*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

1 files changed, 114 insertions, 0 deletions

diff --git a/src/game/AuctionHouseMgr.cpp b/src/game/AuctionHouseMgr.cpp
index 2f7ba808fb3..ffc0c55d9d3 100644
--- a/src/game/AuctionHouseMgr.cpp
+++ b/src/game/AuctionHouseMgr.cpp
@@ -15,6 +15,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+
 #include "Common.h"
 #include "ObjectMgr.h"
 #include "Player.h"
@@ -25,6 +26,7 @@
 #include "Database/SQLStorage.h"
 #include "Policies/SingletonImp.h"
 #include "DBCStores.h"
+
 #include "AccountMgr.h"
 #include "AuctionHouseMgr.h"
 #include "Item.h"
@@ -33,20 +35,26 @@
 #include "ProgressBar.h"
 #include <vector>
 
+
 INSTANTIATE_SINGLETON_1(AuctionHouseMgr);
+
 using namespace std;
+
 AuctionHouseMgr::AuctionHouseMgr()
 {
 }
+
 AuctionHouseMgr::~AuctionHouseMgr()
 {
     for (ItemMap::const_iterator itr = mAitems.begin(); itr != mAitems.end(); ++itr)
         delete itr->second;
 }
+
 AuctionHouseObject * AuctionHouseMgr::GetAuctionsMap(uint32 factionTemplateId)
 {
     if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
         return &mNeutralAuctions;
+
     // team have linked auction houses
     FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId);
     if (!u_entry)
@@ -58,15 +66,18 @@ AuctionHouseObject * AuctionHouseMgr::GetAuctionsMap(uint32 factionTemplateId)
     else
         return &mNeutralAuctions;
 }
+
 uint32 AuctionHouseMgr::GetAuctionDeposit(AuctionHouseEntry const* entry, uint32 time, Item *pItem)
 {
     uint32 MSV = pItem->GetProto()->SellPrice;
     int32 deposit;
     uint32 timeHr = (((time / 60) / 60) / 12);
+
     if (MSV > 0)
         deposit = (int32)floor((double)MSV * (((double)(entry->depositPercent * 3) / 100.0f * (double)sWorld.getRate(RATE_AUCTION_DEPOSIT) * (double)pItem->GetCount()))) * timeHr;
     else
         deposit = 0;
+
     sLog.outDebug("SellPrice:\t\t%u", MSV);
     sLog.outDebug("Deposit Percent:\t%f", ((double)entry->depositPercent / 100.0f));
     sLog.outDebug("Auction Time1:\t\t%u", time);
@@ -84,12 +95,14 @@ uint32 AuctionHouseMgr::GetAuctionDeposit(AuctionHouseEntry const* entry, uint32
         return 0;
     }
 }
+
 //does not clear ram
 void AuctionHouseMgr::SendAuctionWonMail(AuctionEntry *auction)
 {
     Item *pItem = GetAItem(auction->item_guidlow);
     if (!pItem)
         return;
+
     uint32 bidder_accId = 0;
     uint32 bidder_security = 0;
     uint64 bidder_guid = MAKE_NEW_GUID(auction->bidder, 0, HIGHGUID_PLAYER);
@@ -108,6 +121,7 @@ void AuctionHouseMgr::SendAuctionWonMail(AuctionEntry *auction)
         {
             bidder_accId = objmgr.GetPlayerAccountIdByGUID(bidder_guid);
             bidder_security = accmgr.GetSecurity(bidder_accId);
+
             if (bidder_security > SEC_PLAYER) // not do redundant DB requests
             {
                 if (!objmgr.GetPlayerNameByGUID(bidder_guid,bidder_name))
@@ -119,34 +133,44 @@ void AuctionHouseMgr::SendAuctionWonMail(AuctionEntry *auction)
             std::string owner_name;
             if (!objmgr.GetPlayerNameByGUID(auction->owner,owner_name))
                 owner_name = objmgr.GetTrinityStringForDBCLocale(LANG_UNKNOWN);
+
             uint32 owner_accid = objmgr.GetPlayerAccountIdByGUID(auction->owner);
+
             sLog.outCommand(bidder_accId,"GM %s (Account: %u) won item in auction: %s (Entry: %u Count: %u) and pay money: %u. Original owner %s (Account: %u)",
                 bidder_name.c_str(),bidder_accId,pItem->GetProto()->Name1,pItem->GetEntry(),pItem->GetCount(),auction->bid,owner_name.c_str(),owner_accid);
         }
     }
+
     // receiver exist
     if (bidder || bidder_accId)
     {
         std::ostringstream msgAuctionWonSubject;
         msgAuctionWonSubject << auction->item_template << ":0:" << AUCTION_WON;
+
         std::ostringstream msgAuctionWonBody;
         msgAuctionWonBody.width(16);
         msgAuctionWonBody << std::right << std::hex << auction->owner;
         msgAuctionWonBody << std::dec << ":" << auction->bid << ":" << auction->buyout;
         sLog.outDebug("AuctionWon body string : %s", msgAuctionWonBody.str().c_str());
+
         //prepare mail data... :
         uint32 itemTextId = objmgr.CreateItemText(msgAuctionWonBody.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,pItem->GetGUIDLow());
         CharacterDatabase.CommitTransaction();
+
         MailItemsInfo mi;
         mi.AddItem(auction->item_guidlow, auction->item_template, pItem);
+
         if (bidder)
             bidder->GetSession()->SendAuctionBidderNotification(auction->GetHouseId(), auction->Id, bidder_guid, 0, 0, auction->item_template);
+
         WorldSession::SendMailTo(bidder, MAIL_AUCTION, MAIL_STATIONERY_AUCTION, auction->GetHouseId(), auction->bidder, msgAuctionWonSubject.str(), itemTextId, &mi, 0, 0, MAIL_CHECK_MASK_AUCTION);
     }
 }
+
 void AuctionHouseMgr::SendAuctionSalePendingMail(AuctionEntry * auction)
 {
     uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
@@ -157,19 +181,26 @@ void AuctionHouseMgr::SendAuctionSalePendingMail(AuctionEntry * auction)
     {
         std::ostringstream msgAuctionSalePendingSubject;
         msgAuctionSalePendingSubject << auction->item_template << ":0:" << AUCTION_SALE_PENDING;
+
         std::ostringstream msgAuctionSalePendingBody;
         uint32 auctionCut = auction->GetAuctionCut();
+
         time_t distrTime = time(NULL) + sWorld.getConfig(CONFIG_MAIL_DELIVERY_DELAY);
+
         msgAuctionSalePendingBody.width(16);
         msgAuctionSalePendingBody << std::right << std::hex << auction->bidder;
         msgAuctionSalePendingBody << std::dec << ":" << auction->bid << ":" << auction->buyout;
         msgAuctionSalePendingBody << ":" << auction->deposit << ":" << auctionCut << ":0:";
         msgAuctionSalePendingBody << secsToTimeBitFields(distrTime);
+
         sLog.outDebug("AuctionSalePending body string : %s", msgAuctionSalePendingBody.str().c_str());
+
         uint32 itemTextId = objmgr.CreateItemText(msgAuctionSalePendingBody.str());
+
         WorldSession::SendMailTo(owner, MAIL_AUCTION, MAIL_STATIONERY_AUCTION, auction->GetHouseId(), auction->owner, msgAuctionSalePendingSubject.str(), itemTextId, NULL, 0, 0, MAIL_CHECK_MASK_AUCTION);
     }
 }
+
 //call this method to send mail to auction owner, when auction is successful, it does not clear ram
 void AuctionHouseMgr::SendAuctionSuccessfulMail(AuctionEntry * auction)
 {
@@ -181,15 +212,21 @@ void AuctionHouseMgr::SendAuctionSuccessfulMail(AuctionEntry * auction)
     {
         std::ostringstream msgAuctionSuccessfulSubject;
         msgAuctionSuccessfulSubject << auction->item_template << ":0:" << 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;
+
         sLog.outDebug("AuctionSuccessful body string : %s", auctionSuccessfulBody.str().c_str());
+
         uint32 itemTextId = objmgr.CreateItemText(auctionSuccessfulBody.str());
+
         uint32 profit = auction->bid + auction->deposit - auctionCut;
+
         //FIXME: what do if owner offline
         if (owner && owner->GetGUIDLow() != auctionbot.GetAHBplayerGUID())
         {
@@ -200,12 +237,14 @@ void AuctionHouseMgr::SendAuctionSuccessfulMail(AuctionEntry * auction)
         WorldSession::SendMailTo(owner, MAIL_AUCTION, MAIL_STATIONERY_AUCTION, auction->GetHouseId(), auction->owner, msgAuctionSuccessfulSubject.str(), itemTextId, NULL, profit, 0, MAIL_CHECK_MASK_AUCTION, sWorld.getConfig(CONFIG_MAIL_DELIVERY_DELAY));
     }
 }
+
 //does not clear ram
 void AuctionHouseMgr::SendAuctionExpiredMail(AuctionEntry * auction)
 { //return an item in auction to its owner by mail
     Item *pItem = GetAItem(auction->item_guidlow);
     if (!pItem)
         return;
+
     uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
     Player *owner = objmgr.GetPlayer(owner_guid);
     uint32 owner_accId = objmgr.GetPlayerAccountIdByGUID(owner_guid);
@@ -214,17 +253,22 @@ void AuctionHouseMgr::SendAuctionExpiredMail(AuctionEntry * auction)
     {
         std::ostringstream subject;
         subject << auction->item_template << ":0:" << AUCTION_EXPIRED;
+
         if (owner && owner->GetGUIDLow() != auctionbot.GetAHBplayerGUID())
             owner->GetSession()->SendAuctionOwnerNotification(auction);
+
         MailItemsInfo mi;
         mi.AddItem(auction->item_guidlow, auction->item_template, pItem);
+
         WorldSession::SendMailTo(owner, MAIL_AUCTION, MAIL_STATIONERY_AUCTION, auction->GetHouseId(), GUID_LOPART(owner_guid), subject.str(), 0, &mi, 0, 0, MAIL_CHECK_MASK_NONE);
     }
 }
+
 void AuctionHouseMgr::LoadAuctionItems()
 {
     // data needs to be at first place for Item::LoadFromDB
     QueryResult *result = CharacterDatabase.Query("SELECT data,itemguid,item_template FROM auctionhouse JOIN item_instance ON itemguid = guid");
+
     if (!result)
     {
         barGoLink bar(1);
@@ -233,34 +277,45 @@ void AuctionHouseMgr::LoadAuctionItems()
         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 = objmgr.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,0, result))
         {
             delete item;
             continue;
         }
         AddAItem(item);
+
         ++count;
     } while (result->NextRow());
     delete result;
+
     sLog.outString();
     sLog.outString(">> Loaded %u auction items", count);
 }
+
 void AuctionHouseMgr::LoadAuctions()
 {
     QueryResult *result = CharacterDatabase.Query("SELECT COUNT(*) FROM auctionhouse");
@@ -272,9 +327,11 @@ void AuctionHouseMgr::LoadAuctions()
         sLog.outString(">> Loaded 0 auctions. DB table `auctionhouse` is empty.");
         return;
     }
+
     Field *fields = result->Fetch();
     uint32 AuctionCount=fields[0].GetUInt32();
     delete result;
+
     if (!AuctionCount)
     {
         barGoLink bar(1);
@@ -283,6 +340,7 @@ void AuctionHouseMgr::LoadAuctions()
         sLog.outString(">> Loaded 0 auctions. DB table `auctionhouse` is empty.");
         return;
     }
+
     result = CharacterDatabase.Query("SELECT id,auctioneerguid,itemguid,item_template,itemowner,buyoutprice,time,buyguid,lastbid,startbid,deposit FROM auctionhouse");
     if (!result)
     {
@@ -292,12 +350,17 @@ void AuctionHouseMgr::LoadAuctions()
         sLog.outString(">> Loaded 0 auctions. DB table `auctionhouse` is empty.");
         return;
     }
+
     barGoLink bar(AuctionCount);
+
     AuctionEntry *aItem;
+
     do
     {
         fields = result->Fetch();
+
         bar.step();
+
         aItem = new AuctionEntry;
         aItem->Id = fields[0].GetUInt32();
         aItem->auctioneer = fields[1].GetUInt32();
@@ -310,6 +373,7 @@ void AuctionHouseMgr::LoadAuctions()
         aItem->bid = fields[8].GetUInt32();
         aItem->startbid = fields[9].GetUInt32();
         aItem->deposit = fields[10].GetUInt32();
+
         CreatureData const* auctioneerData = objmgr.GetCreatureData(aItem->auctioneer);
         if (!auctioneerData)
         {
@@ -318,6 +382,7 @@ void AuctionHouseMgr::LoadAuctions()
             delete aItem;
             continue;
         }
+
         CreatureInfo const* auctioneerInfo = objmgr.GetCreatureTemplate(auctioneerData->id);
         if (!auctioneerInfo)
         {
@@ -326,6 +391,7 @@ void AuctionHouseMgr::LoadAuctions()
             delete aItem;
             continue;
         }
+
         aItem->auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(auctioneerInfo->faction_A);
         if (!aItem->auctionHouseEntry)
         {
@@ -335,6 +401,7 @@ void AuctionHouseMgr::LoadAuctions()
             delete aItem;
             continue;
         }
+
         // check if sold item exists for guid
         // and item_template in fact (GetAItem will fail if problematic in result check in AuctionHouseMgr::LoadAuctionItems)
         if (!GetAItem(aItem->item_guidlow))
@@ -344,35 +411,44 @@ void AuctionHouseMgr::LoadAuctions()
             delete aItem;
             continue;
         }
+
         GetAuctionsMap(auctioneerInfo->faction_A)->AddAuction(aItem);
+
     } while (result->NextRow());
     delete result;
+
     sLog.outString();
     sLog.outString(">> Loaded %u auctions", AuctionCount);
 }
+
 void AuctionHouseMgr::AddAItem(Item* it)
 {
     ASSERT(it);
     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()
 {
     mHordeAuctions.Update();
     mAllianceAuctions.Update();
     mNeutralAuctions.Update();
 }
+
 AuctionHouseEntry const* AuctionHouseMgr::GetAuctionHouseEntry(uint32 factionTemplateId)
 {
     uint32 houseid = 7; // goblin auction house
+
     if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
     {
         //FIXME: found way for proper auctionhouse selection by another way
@@ -405,6 +481,7 @@ AuctionHouseEntry const* AuctionHouseMgr::GetAuctionHouseEntry(uint32 factionTem
             }
         }
     }
+
     return sAuctionHouseStore.LookupEntry(houseid);
 }
     void AuctionHouseObject::AddAuction(AuctionEntry *ah)
@@ -413,45 +490,57 @@ AuctionHouseEntry const* AuctionHouseMgr::GetAuctionHouseEntry(uint32 factionTem
         AuctionsMap[ah->Id] = ah;
         auctionbot.IncrementItemCounts(ah);
     }
+
     bool AuctionHouseObject::RemoveAuction(AuctionEntry *auction, uint32 item_template)
     {
         auctionbot.DecrementItemCounts(auction, item_template);
         return AuctionsMap.erase(auction->Id) ? true : false;
     }
+
 void AuctionHouseObject::Update()
 {
     time_t curTime = sWorld.GetGameTime();
     ///- Handle expired auctions
+
     // If storage is empty, no need to update. next == NULL in this case.
     if (AuctionsMap.empty())
         return;
+
     QueryResult* result = CharacterDatabase.PQuery("SELECT id FROM auctionhouse WHERE time <= %u ORDER BY TIME ASC", (uint32)curTime+60);
+
     if (!result)
     {
         delete result;
         return;
     }
+
     if (result->GetRowCount() == 0)
     {
         delete result;
         return;
     }
+
     vector<uint32> expiredAuctions;
+
     do
     {
         uint32 tmpdata = result->Fetch()->GetUInt32();
         expiredAuctions.push_back(tmpdata);
     } while (result->NextRow());
     delete result;
+
     vector<uint32>::iterator iter = expiredAuctions.begin();
     while (!expiredAuctions.empty())
     {
         // from auctionhousehandler.cpp, creates auction pointer & player pointer
         AuctionEntry* auction = GetAuction(*iter);
+
         // Erase the auction from the vector.
         expiredAuctions.erase(iter);
+
         if (!auction)
             continue;
+
         ///- Either cancel the auction if there was no bidder
         if (auction->bidder == 0)
             auctionmgr.SendAuctionExpiredMail(auction);
@@ -464,6 +553,7 @@ void AuctionHouseObject::Update()
             auctionmgr.SendAuctionSuccessfulMail(auction);
             auctionmgr.SendAuctionWonMail(auction);
         }
+
         ///- In any case clear the auction
         auction->DeleteFromDB();
         uint32 item_template = auction->item_template;
@@ -471,6 +561,7 @@ void AuctionHouseObject::Update()
         RemoveAuction(auction, item_template);
     }
 }
+
 void AuctionHouseObject::BuildListBidderItems(WorldPacket& data, Player* player, uint32& count, uint32& totalcount)
 {
     for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin();itr != AuctionsMap.end();++itr)
@@ -480,10 +571,12 @@ void AuctionHouseObject::BuildListBidderItems(WorldPacket& data, Player* player,
         {
             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)
@@ -493,38 +586,50 @@ void AuctionHouseObject::BuildListOwnerItems(WorldPacket& data, Player* player,
         {
             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 = auctionmgr.GetAItem(Aentry->item_guidlow);
         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 && player->CanUseItem(item) != EQUIP_ERR_OK)
             continue;
+
         std::string name = proto->Name1;
         if (name.empty())
             continue;
+
         // local name
         if (loc_idx >= 0)
         {
@@ -535,8 +640,10 @@ void AuctionHouseObject::BuildListAuctionItems(WorldPacket& data, Player* player
                     name = il->Name[loc_idx];
             }
         }
+
         if (!wsearchedname.empty() && !Utf8FitTo(name, wsearchedname))
             continue;
+
         if (count < 50 && totalcount >= listfrom)
         {
             ++count;
@@ -545,6 +652,7 @@ void AuctionHouseObject::BuildListAuctionItems(WorldPacket& data, Player* player
         ++totalcount;
     }
 }
+
 //this function inserts to WorldPacket auction's data
 bool AuctionEntry::BuildAuctionInfo(WorldPacket & data) const
 {
@@ -556,12 +664,14 @@ bool AuctionEntry::BuildAuctionInfo(WorldPacket & data) const
     }
     data << uint32(Id);
     data << uint32(pItem->GetEntry());
+
     for (uint8 i = 0; i < MAX_INSPECTED_ENCHANTMENT_SLOT; ++i)
     {
         data << uint32(pItem->GetEnchantmentId(EnchantmentSlot(i)));
         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
@@ -577,6 +687,7 @@ bool AuctionEntry::BuildAuctionInfo(WorldPacket & data) const
     data << uint32(bid);                                    //current bid
     return true;
 }
+
 uint32 AuctionEntry::GetAuctionCut() const
 {
     int32 cut = int32(((double)auctionHouseEntry->cutPercent / 100.0f) * (double)sWorld.getRate(RATE_AUCTION_CUT)) * bid;
@@ -585,6 +696,7 @@ uint32 AuctionEntry::GetAuctionCut() const
     else
         return 0;
 }
+
 /// the sum of outbid is (1% from current bid)*5, if bid is very small, it is 1c
 uint32 AuctionEntry::GetAuctionOutBid() const
 {
@@ -593,11 +705,13 @@ uint32 AuctionEntry::GetAuctionOutBid() const
         outbid = 1;
     return outbid;
 }
+
 void AuctionEntry::DeleteFromDB() const
 {
     //No SQL injection (Id is integer)
     CharacterDatabase.PExecute("DELETE FROM auctionhouse WHERE id = '%u'",Id);
 }
+
 void AuctionEntry::SaveToDB() const
 {
     //No SQL injection (no strings)