Core: Change Handlers location

2012-01-26 10:54:53 +01:00
parent f4b7414dc0
commit c9762b0e38
37 changed files with 5 additions and 3 deletions
@@ -0,0 +1,639 @@
+/*
+ * Copyright (C) 2008-2012 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "World.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+
+#include "AuctionHouseMgr.h"
+#include "Log.h"
+#include "Opcodes.h"
+#include "UpdateMask.h"
+#include "Util.h"
+#include "AccountMgr.h"
+
+//please DO NOT use iterator++, because it is slower than ++iterator!!!
+//post-incrementation is always slower than pre-incrementation !
+
+//void called when player click on auctioneer npc
+void WorldSession::HandleAuctionHelloOpcode(WorldPacket & recv_data)
+{
+    uint64 guid;                                            //NPC guid
+    recv_data >> guid;
+
+    Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!unit)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionHelloOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)));
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    SendAuctionHello(guid, unit);
+}
+
+//this void causes that auction window is opened
+void WorldSession::SendAuctionHello(uint64 guid, Creature* unit)
+{
+    if (GetPlayer()->getLevel() < sWorld->getIntConfig(CONFIG_AUCTION_LEVEL_REQ))
+    {
+        SendNotification(GetTrinityString(LANG_AUCTION_REQ), sWorld->getIntConfig(CONFIG_AUCTION_LEVEL_REQ));
+        return;
+    }
+
+    AuctionHouseEntry const* ahEntry = AuctionHouseMgr::GetAuctionHouseEntry(unit->getFaction());
+    if (!ahEntry)
+        return;
+
+    WorldPacket data(MSG_AUCTION_HELLO, 12);
+    data << uint64(guid);
+    data << uint32(ahEntry->houseId);
+    data << uint8(1);                                       // 3.3.3: 1 - AH enabled, 0 - AH disabled
+    SendPacket(&data);
+}
+
+//call this method when player bids, creates, or deletes auction
+void WorldSession::SendAuctionCommandResult(uint32 auctionId, uint32 Action, uint32 ErrorCode, uint32 bidError)
+{
+    WorldPacket data(SMSG_AUCTION_COMMAND_RESULT, 16);
+    data << auctionId;
+    data << Action;
+    data << ErrorCode;
+    if (!ErrorCode && Action)
+        data << bidError;                                   //when bid, then send 0, once...
+    SendPacket(&data);
+}
+
+//this function sends notification, if bidder is online
+void WorldSession::SendAuctionBidderNotification(uint32 location, uint32 auctionId, uint64 bidder, uint32 bidSum, uint32 diff, uint32 item_template)
+{
+    WorldPacket data(SMSG_AUCTION_BIDDER_NOTIFICATION, (8*4));
+    data << uint32(location);
+    data << uint32(auctionId);
+    data << uint64(bidder);
+    data << uint32(bidSum);
+    data << uint32(diff);
+    data << uint32(item_template);
+    data << uint32(0);
+    SendPacket(&data);
+}
+
+//this void causes on client to display: "Your auction sold"
+void WorldSession::SendAuctionOwnerNotification(AuctionEntry* auction)
+{
+    WorldPacket data(SMSG_AUCTION_OWNER_NOTIFICATION, (8*4));
+    data << uint32(auction->Id);
+    data << uint32(auction->bid);
+    data << uint32(0);                                      //unk
+    data << uint64(0);                                      //unk (bidder guid?)
+    data << uint32(auction->item_template);
+    data << uint32(0);                                      //unk
+    data << float(0);                                       //unk (time?)
+    SendPacket(&data);
+}
+
+//this void creates new auction and adds auction to some auctionhouse
+void WorldSession::HandleAuctionSellItem(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_SELL_ITEM");
+
+    uint64 auctioneer, item;
+    uint32 etime, bid, buyout, count;
+    recv_data >> auctioneer;
+    recv_data.read_skip<uint32>();                          // const 1?
+    recv_data >> item;
+    recv_data >> count;                                     // 3.2.2, number of items being auctioned
+    recv_data >> bid;
+    recv_data >> buyout;
+    recv_data >> etime;
+
+    Player* player = GetPlayer();
+
+    if (!item || !bid || !etime)
+        return;                                             //check for cheaters
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!creature)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionSellItem - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(auctioneer)));
+        return;
+    }
+
+    AuctionHouseEntry const* auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(creature->getFaction());
+    if (!auctionHouseEntry)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionSellItem - Unit (GUID: %u) has wrong faction.", uint32(GUID_LOPART(auctioneer)));
+        return;
+    }
+
+    // client send time in minutes, convert to common used sec time
+    etime *= MINUTE;
+
+    // client understand only 3 auction time
+    switch (etime)
+    {
+        case 1*MIN_AUCTION_TIME:
+        case 2*MIN_AUCTION_TIME:
+        case 4*MIN_AUCTION_TIME:
+            break;
+        default:
+            return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    Item* it = player->GetItemByGuid(item);
+    //do not allow to sell already auctioned items
+    if (sAuctionMgr->GetAItem(GUID_LOPART(item)))
+    {
+        sLog->outError("AuctionError, player %s is sending item id: %u, but item is already in another auction", player->GetName(), GUID_LOPART(item));
+        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_INTERNAL_ERROR);
+        return;
+    }
+    // prevent sending bag with items (cheat: can be placed in bag after adding equiped empty bag to auction)
+    if (!it)
+    {
+        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_ITEM_NOT_FOUND);
+        return;
+    }
+
+    if (!it->CanBeTraded())
+    {
+        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_INTERNAL_ERROR);
+        return;
+    }
+
+    if (it->GetTemplate()->Flags & ITEM_PROTO_FLAG_CONJURED || it->GetUInt32Value(ITEM_FIELD_DURATION))
+    {
+        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_INTERNAL_ERROR);
+        return;
+    }
+
+    if (it->IsNotEmptyBag())
+    {
+        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_INTERNAL_ERROR);
+        return;
+    }
+
+    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
+
+    //we have to take deposit :
+    uint32 deposit = sAuctionMgr->GetAuctionDeposit(auctionHouseEntry, etime, it, count);
+    if (!player->HasEnoughMoney(deposit))
+    {
+        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_NOT_ENOUGHT_MONEY);
+        return;
+    }
+
+    if (AccountMgr::IsGMAccount(GetSecurity()) && sWorld->getBoolConfig(CONFIG_GM_LOG_TRADE))
+    {
+        sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
+            GetPlayerName(), GetAccountId(), it->GetTemplate()->Name1.c_str(), it->GetEntry(), count);
+    }
+
+    player->ModifyMoney(-int32(deposit));
+
+    uint32 auction_time = uint32(etime * sWorld->getRate(RATE_AUCTION_TIME));
+
+    AuctionEntry* AH = new AuctionEntry;
+    AH->Id = sObjectMgr->GenerateAuctionID();
+    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
+        AH->auctioneer = 23442;
+    else
+        AH->auctioneer = GUID_LOPART(auctioneer);
+    AH->item_guidlow = GUID_LOPART(item);
+    AH->item_template = it->GetEntry();
+    AH->owner = player->GetGUIDLow();
+    AH->startbid = bid;
+    AH->bidder = 0;
+    AH->bid = 0;
+    AH->buyout = buyout;
+    AH->expire_time = time(NULL) + auction_time;
+    AH->deposit = deposit;
+    AH->auctionHouseEntry = auctionHouseEntry;
+
+    sLog->outDetail("selling item %u to auctioneer %u with initial bid %u with buyout %u and with time %u (in sec) in auctionhouse %u", GUID_LOPART(item), AH->auctioneer, bid, buyout, auction_time, AH->GetHouseId());
+    sAuctionMgr->AddAItem(it);
+    auctionHouse->AddAuction(AH);
+
+    player->MoveItemFromInventory(it->GetBagSlot(), it->GetSlot(), true);
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+    it->DeleteFromInventoryDB(trans);
+    it->SaveToDB(trans);                                         // recursive and not have transaction guard into self, not in inventiory and can be save standalone
+    AH->SaveToDB(trans);
+    player->SaveInventoryAndGoldToDB(trans);
+    CharacterDatabase.CommitTransaction(trans);
+
+    SendAuctionCommandResult(AH->Id, AUCTION_SELL_ITEM, AUCTION_OK);
+
+    GetPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
+}
+
+//this function is called when client bids or buys out auction
+void WorldSession::HandleAuctionPlaceBid(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_PLACE_BID");
+
+    uint64 auctioneer;
+    uint32 auctionId;
+    uint32 price;
+    recv_data >> auctioneer;
+    recv_data >> auctionId >> price;
+
+    if (!auctionId || !price)
+        return;                                             //check for cheaters
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!creature)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionPlaceBid - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(auctioneer)));
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
+
+    AuctionEntry* auction = auctionHouse->GetAuction(auctionId);
+    Player* player = GetPlayer();
+
+    if (!auction || auction->owner == player->GetGUIDLow())
+    {
+        //you cannot bid your own auction:
+        SendAuctionCommandResult(0, AUCTION_PLACE_BID, CANNOT_BID_YOUR_AUCTION_ERROR);
+        return;
+    }
+
+    // impossible have online own another character (use this for speedup check in case online owner)
+    Player* auction_owner = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER));
+    if (!auction_owner && sObjectMgr->GetPlayerAccountIdByGUID(MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER)) == player->GetSession()->GetAccountId())
+    {
+        //you cannot bid your another character auction:
+        SendAuctionCommandResult(0, AUCTION_PLACE_BID, CANNOT_BID_YOUR_AUCTION_ERROR);
+        return;
+    }
+
+    // cheating
+    if (price <= auction->bid || price < auction->startbid)
+        return;
+
+    // price too low for next bid if not buyout
+    if ((price < auction->buyout || auction->buyout == 0) &&
+        price < auction->bid + auction->GetAuctionOutBid())
+    {
+        //auction has already higher bid, client tests it!
+        return;
+    }
+
+    if (!player->HasEnoughMoney(price))
+    {
+        //you don't have enought money!, client tests!
+        //SendAuctionCommandResult(auction->auctionId, AUCTION_PLACE_BID, ???);
+        return;
+    }
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+
+    if (price < auction->buyout || auction->buyout == 0)
+    {
+        if (auction->bidder > 0)
+        {
+            if (auction->bidder == player->GetGUIDLow())
+                player->ModifyMoney(-int32(price - auction->bid));
+            else
+            {
+                // mail to last bidder and return money
+                sAuctionMgr->SendAuctionOutbiddedMail(auction, price, GetPlayer(), trans);
+                player->ModifyMoney(-int32(price));
+            }
+        }
+        else
+            player->ModifyMoney(-int32(price));
+
+        auction->bidder = player->GetGUIDLow();
+        auction->bid = price;
+        GetPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, price);
+
+        trans->PAppend("UPDATE auctionhouse SET buyguid = '%u', lastbid = '%u' WHERE id = '%u'", auction->bidder, auction->bid, auction->Id);
+
+        SendAuctionCommandResult(auction->Id, AUCTION_PLACE_BID, AUCTION_OK, 0);
+    }
+    else
+    {
+        //buyout:
+        if (player->GetGUIDLow() == auction->bidder)
+            player->ModifyMoney(-int32(auction->buyout - auction->bid));
+        else
+        {
+            player->ModifyMoney(-int32(auction->buyout));
+            if (auction->bidder)                          //buyout for bidded auction ..
+                sAuctionMgr->SendAuctionOutbiddedMail(auction, auction->buyout, GetPlayer(), trans);
+        }
+        auction->bidder = player->GetGUIDLow();
+        auction->bid = auction->buyout;
+        GetPlayer()->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, auction->buyout);
+
+        //- Mails must be under transaction control too to prevent data loss
+        sAuctionMgr->SendAuctionSalePendingMail(auction, trans);
+        sAuctionMgr->SendAuctionSuccessfulMail(auction, trans);
+        sAuctionMgr->SendAuctionWonMail(auction, trans);
+
+        SendAuctionCommandResult(auction->Id, AUCTION_PLACE_BID, AUCTION_OK);
+
+        auction->DeleteFromDB(trans);
+
+        uint32 item_template = auction->item_template;
+        sAuctionMgr->RemoveAItem(auction->item_guidlow);
+        auctionHouse->RemoveAuction(auction, item_template);
+    }
+    player->SaveInventoryAndGoldToDB(trans);
+    CharacterDatabase.CommitTransaction(trans);
+}
+
+//this void is called when auction_owner cancels his auction
+void WorldSession::HandleAuctionRemoveItem(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_REMOVE_ITEM");
+
+    uint64 auctioneer;
+    uint32 auctionId;
+    recv_data >> auctioneer;
+    recv_data >> auctionId;
+    //sLog->outDebug("Cancel AUCTION AuctionID: %u", auctionId);
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!creature)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionRemoveItem - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(auctioneer)));
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
+
+    AuctionEntry* auction = auctionHouse->GetAuction(auctionId);
+    Player* player = GetPlayer();
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+    if (auction && auction->owner == player->GetGUIDLow())
+    {
+        Item* pItem = sAuctionMgr->GetAItem(auction->item_guidlow);
+        if (pItem)
+        {
+            if (auction->bidder > 0)                        // If we have a bidder, we have to send him the money he paid
+            {
+                uint32 auctionCut = auction->GetAuctionCut();
+                if (!player->HasEnoughMoney(auctionCut))          //player doesn't have enough money, maybe message needed
+                    return;
+                //some auctionBidderNotification would be needed, but don't know that parts..
+                sAuctionMgr->SendAuctionCancelledToBidderMail(auction, trans);
+                player->ModifyMoney(-int32(auctionCut));
+            }
+            // Return the item by mail
+            std::ostringstream msgAuctionCanceledOwner;
+            msgAuctionCanceledOwner << auction->item_template << ":0:" << AUCTION_CANCELED << ":0:0";
+
+            // item will deleted or added to received mail list
+            MailDraft(msgAuctionCanceledOwner.str(), "")    // TODO: fix body
+                .AddItem(pItem)
+                .SendMailTo(trans, player, auction, MAIL_CHECK_MASK_COPIED);
+        }
+        else
+        {
+            sLog->outError("Auction id: %u has non-existed item (item guid : %u)!!!", auction->Id, auction->item_guidlow);
+            SendAuctionCommandResult(0, AUCTION_CANCEL, AUCTION_INTERNAL_ERROR);
+            return;
+        }
+    }
+    else
+    {
+        SendAuctionCommandResult(0, AUCTION_CANCEL, AUCTION_INTERNAL_ERROR);
+        //this code isn't possible ... maybe there should be assert
+        sLog->outError("CHEATER : %u, he tried to cancel auction (id: %u) of another player, or auction is NULL", player->GetGUIDLow(), auctionId);
+        return;
+    }
+
+    //inform player, that auction is removed
+    SendAuctionCommandResult(auction->Id, AUCTION_CANCEL, AUCTION_OK);
+
+    // Now remove the auction
+
+    player->SaveInventoryAndGoldToDB(trans);
+    auction->DeleteFromDB(trans);
+    CharacterDatabase.CommitTransaction(trans);
+
+    uint32 item_template = auction->item_template;
+    sAuctionMgr->RemoveAItem(auction->item_guidlow);
+    auctionHouse->RemoveAuction(auction, item_template);
+}
+
+//called when player lists his bids
+void WorldSession::HandleAuctionListBidderItems(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_LIST_BIDDER_ITEMS");
+
+    uint64 guid;                                            //NPC guid
+    uint32 listfrom;                                        //page of auctions
+    uint32 outbiddedCount;                                  //count of outbidded auctions
+
+    recv_data >> guid;
+    recv_data >> listfrom;                                  // not used in fact (this list not have page control in client)
+    recv_data >> outbiddedCount;
+    if (recv_data.size() != (16 + outbiddedCount * 4))
+    {
+        sLog->outError("Client sent bad opcode!!! with count: %u and size : %lu (must be: %u)", outbiddedCount, (unsigned long)recv_data.size(), (16 + outbiddedCount * 4));
+        outbiddedCount = 0;
+    }
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!creature)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionListBidderItems - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)));
+        recv_data.rfinish();
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
+
+    WorldPacket data(SMSG_AUCTION_BIDDER_LIST_RESULT, (4+4+4));
+    Player* player = GetPlayer();
+    data << (uint32) 0;                                     //add 0 as count
+    uint32 count = 0;
+    uint32 totalcount = 0;
+    while (outbiddedCount > 0)                             //add all data, which client requires
+    {
+        --outbiddedCount;
+        uint32 outbiddedAuctionId;
+        recv_data >> outbiddedAuctionId;
+        AuctionEntry* auction = auctionHouse->GetAuction(outbiddedAuctionId);
+        if (auction && auction->BuildAuctionInfo(data))
+        {
+            ++totalcount;
+            ++count;
+        }
+    }
+
+    auctionHouse->BuildListBidderItems(data, player, count, totalcount);
+    data.put<uint32>(0, count);                           // add count to placeholder
+    data << totalcount;
+    data << (uint32)300;                                    //unk 2.3.0
+    SendPacket(&data);
+}
+
+//this void sends player info about his auctions
+void WorldSession::HandleAuctionListOwnerItems(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_LIST_OWNER_ITEMS");
+
+    uint32 listfrom;
+    uint64 guid;
+
+    recv_data >> guid;
+    recv_data >> listfrom;                                  // not used in fact (this list not have page control in client)
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!creature)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionListOwnerItems - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)));
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
+
+    WorldPacket data(SMSG_AUCTION_OWNER_LIST_RESULT, (4+4+4));
+    data << (uint32) 0;                                     // amount place holder
+
+    uint32 count = 0;
+    uint32 totalcount = 0;
+
+    auctionHouse->BuildListOwnerItems(data, _player, count, totalcount);
+    data.put<uint32>(0, count);
+    data << (uint32) totalcount;
+    data << (uint32) 0;
+    SendPacket(&data);
+}
+
+//this void is called when player clicks on search button
+void WorldSession::HandleAuctionListItems(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_LIST_ITEMS");
+
+    std::string searchedname;
+    uint8 levelmin, levelmax, usable;
+    uint32 listfrom, auctionSlotID, auctionMainCategory, auctionSubCategory, quality;
+    uint64 guid;
+
+    recv_data >> guid;
+    recv_data >> listfrom;                                  // start, used for page control listing by 50 elements
+    recv_data >> searchedname;
+
+    recv_data >> levelmin >> levelmax;
+    recv_data >> auctionSlotID >> auctionMainCategory >> auctionSubCategory;
+    recv_data >> quality >> usable;
+
+    recv_data.read_skip<uint8>();                           // unk
+
+    // this block looks like it uses some lame byte packing or similar...
+    uint8 unkCnt;
+    recv_data >> unkCnt;
+    for (uint8 i = 0; i < unkCnt; i++)
+    {
+        recv_data.read_skip<uint8>();
+        recv_data.read_skip<uint8>();
+    }
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_AUCTIONEER);
+    if (!creature)
+    {
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleAuctionListItems - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)));
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
+
+    //sLog->outDebug("Auctionhouse search (GUID: %u TypeId: %u)",, list from: %u, searchedname: %s, levelmin: %u, levelmax: %u, auctionSlotID: %u, auctionMainCategory: %u, auctionSubCategory: %u, quality: %u, usable: %u",
+    //  GUID_LOPART(guid), GuidHigh2TypeId(GUID_HIPART(guid)), listfrom, searchedname.c_str(), levelmin, levelmax, auctionSlotID, auctionMainCategory, auctionSubCategory, quality, usable);
+
+    WorldPacket data(SMSG_AUCTION_LIST_RESULT, (4+4+4));
+    uint32 count = 0;
+    uint32 totalcount = 0;
+    data << (uint32) 0;
+
+    // converting string that we try to find to lower case
+    std::wstring wsearchedname;
+    if (!Utf8toWStr(searchedname, wsearchedname))
+        return;
+
+    wstrToLower(wsearchedname);
+
+    auctionHouse->BuildListAuctionItems(data, _player,
+        wsearchedname, listfrom, levelmin, levelmax, usable,
+        auctionSlotID, auctionMainCategory, auctionSubCategory, quality,
+        count, totalcount);
+
+    data.put<uint32>(0, count);
+    data << (uint32) totalcount;
+    data << (uint32) 300;                                   // unk 2.3.0 const?
+    SendPacket(&data);
+}
+
+void WorldSession::HandleAuctionListPendingSales(WorldPacket & recv_data)
+{
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_AUCTION_LIST_PENDING_SALES");
+
+    recv_data.read_skip<uint64>();
+
+    uint32 count = 0;
+
+    WorldPacket data(SMSG_AUCTION_LIST_PENDING_SALES, 4);
+    data << uint32(count);                                  // count
+    /*for (uint32 i = 0; i < count; ++i)
+    {
+        data << "";                                         // string
+        data << "";                                         // string
+        data << uint32(0);
+        data << uint32(0);
+        data << float(0);
+    }*/
+    SendPacket(&data);
+}