AuctionHousePackets.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * 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 "AuctionHousePackets.h"
#include "AuctionHouseMgr.h"
#include "DB2Stores.h"
#include "ObjectGuid.h"
#include "PacketOperators.h"
 
namespace WorldPackets::AuctionHouse
{
AuctionBucketKey& AuctionBucketKey::operator=(AuctionsBucketKey const& key)
{
    ItemID = key.ItemId;
    ItemLevel = key.ItemLevel;
 
    if (key.BattlePetSpeciesId)
        BattlePetSpeciesID = key.BattlePetSpeciesId;
 
    if (key.SuffixItemNameDescriptionId)
        ItemSuffix = key.SuffixItemNameDescriptionId;
 
    return *this;
}
 
ByteBuffer& operator>>(ByteBuffer& data, AuctionBucketKey& itemKey)
{
    data.ResetBitPos();
    data >> Bits<20>(itemKey.ItemID);
    data >> OptionalInit(itemKey.BattlePetSpeciesID);
    data >> Bits<11>(itemKey.ItemLevel);
    data >> OptionalInit(itemKey.ItemSuffix);
 
    if (itemKey.BattlePetSpeciesID)
        data >> *itemKey.BattlePetSpeciesID;
 
    if (itemKey.ItemSuffix)
        data >> *itemKey.ItemSuffix;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, AuctionBucketKey const& itemKey)
{
    data << Bits<20>(itemKey.ItemID);
    data << OptionalInit(itemKey.BattlePetSpeciesID);
    data << Bits<11>(itemKey.ItemLevel);
    data << OptionalInit(itemKey.ItemSuffix);
    data.FlushBits();
 
    if (itemKey.BattlePetSpeciesID)
        data << uint16(*itemKey.BattlePetSpeciesID);
 
    if (itemKey.ItemSuffix)
        data << uint16(*itemKey.ItemSuffix);
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, AuctionListFilterSubClass& filterSubClass)
{
    data >> filterSubClass.InvTypeMask;
    data >> filterSubClass.ItemSubclass;
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, AuctionListFilterClass& filterClass)
{
    data >> filterClass.ItemClass;
    data >> BitsSize<5>(filterClass.SubClassFilters);
    for (AuctionListFilterSubClass& filterSubClass : filterClass.SubClassFilters)
        data >> filterSubClass;
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, AuctionSortDef& sortDef)
{
    data.ResetBitPos();
    data >> As<uint8>(sortDef.SortOrder);
    data >> Bits<1>(sortDef.ReverseSort);
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, AuctionItemForSale& auctionItemForSale)
{
    data >> auctionItemForSale.Guid;
    data >> auctionItemForSale.UseCount;
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, AuctionFavoriteInfo& favoriteInfo)
{
    data >> favoriteInfo.Order;
    data >> favoriteInfo.ItemID;
    data >> favoriteInfo.ItemLevel;
    data >> favoriteInfo.BattlePetSpeciesID;
    data >> favoriteInfo.SuffixItemNameDescriptionID;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, AuctionFavoriteInfo const& favoriteInfo)
{
    data << uint32(favoriteInfo.Order);
    data << uint32(favoriteInfo.ItemID);
    data << uint32(favoriteInfo.ItemLevel);
    data << uint32(favoriteInfo.BattlePetSpeciesID);
    data << uint32(favoriteInfo.SuffixItemNameDescriptionID);
 
    return data;
}
 
void AuctionOwnerNotification::Initialize(::AuctionPosting const* auction)
{
    AuctionID = auction->Id;
    Item.Initialize(auction->Items[0]);
    BidAmount = auction->BidAmount;
}
 
ByteBuffer& operator<<(ByteBuffer& data, AuctionOwnerNotification const& ownerNotification)
{
    data << int32(ownerNotification.AuctionID);
    data << uint64(ownerNotification.BidAmount);
    data << ownerNotification.Item;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, BucketInfo const& bucketInfo)
{
    data << bucketInfo.Key;
    data << int32(bucketInfo.TotalQuantity);
    data << int32(bucketInfo.RequiredLevel);
    data << uint64(bucketInfo.MinPrice);
    data << Size<uint32>(bucketInfo.ItemModifiedAppearanceIDs);
    if (!bucketInfo.ItemModifiedAppearanceIDs.empty())
        data.append(bucketInfo.ItemModifiedAppearanceIDs.data(), bucketInfo.ItemModifiedAppearanceIDs.size());
 
    data << OptionalInit(bucketInfo.MaxBattlePetQuality);
    data << OptionalInit(bucketInfo.MaxBattlePetLevel);
    data << OptionalInit(bucketInfo.BattlePetBreedID);
    data << OptionalInit(bucketInfo.BattlePetLevelMask);
    data << Bits<1>(bucketInfo.ContainsOwnerItem);
    data << Bits<1>(bucketInfo.ContainsOnlyCollectedAppearances);
    data.FlushBits();
 
    if (bucketInfo.MaxBattlePetQuality)
        data << uint8(*bucketInfo.MaxBattlePetQuality);
 
    if (bucketInfo.MaxBattlePetLevel)
        data << uint8(*bucketInfo.MaxBattlePetLevel);
 
    if (bucketInfo.BattlePetBreedID)
        data << uint8(*bucketInfo.BattlePetBreedID);
 
    if (bucketInfo.BattlePetLevelMask)
        data << uint32(*bucketInfo.BattlePetLevelMask);
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, AuctionItem const& auctionItem)
{
    data << OptionalInit(auctionItem.Item);
    data << BitsSize<4>(auctionItem.Enchantments);
    data << BitsSize<2>(auctionItem.Gems);
    data << OptionalInit(auctionItem.MinBid);
    data << OptionalInit(auctionItem.MinIncrement);
    data << OptionalInit(auctionItem.BuyoutPrice);
    data << OptionalInit(auctionItem.UnitPrice);
    data << Bits<1>(auctionItem.CensorServerSideInfo);
    data << Bits<1>(auctionItem.CensorBidInfo);
    data << OptionalInit(auctionItem.AuctionBucketKey);
    data << OptionalInit(auctionItem.Creator);
    if (!auctionItem.CensorBidInfo)
    {
        data << OptionalInit(auctionItem.Bidder);
        data << OptionalInit(auctionItem.BidAmount);
 
        if (auctionItem.Bidder)
            data << *auctionItem.Bidder;
 
        if (auctionItem.BidAmount)
            data << uint64(*auctionItem.BidAmount);
    }
 
    data.FlushBits();
 
    data << int32(auctionItem.Count);
    data << int32(auctionItem.Charges);
    data << int32(auctionItem.Flags);
    data << int32(auctionItem.AuctionID);
    data << auctionItem.Owner;
    data << int32(auctionItem.DurationLeft);
    data << uint8(auctionItem.DeleteReason);
    data << uint32(auctionItem.Unused1110);
 
    if (auctionItem.Item)
        data << *auctionItem.Item;
 
    for (WorldPackets::Item::ItemEnchantData const& enchant : auctionItem.Enchantments)
        data << enchant;
 
    for (WorldPackets::Item::ItemGemData const& gem : auctionItem.Gems)
        data << gem;
 
    if (auctionItem.MinBid)
        data << uint64(*auctionItem.MinBid);
 
    if (auctionItem.MinIncrement)
        data << uint64(*auctionItem.MinIncrement);
 
    if (auctionItem.BuyoutPrice)
        data << uint64(*auctionItem.BuyoutPrice);
 
    if (auctionItem.UnitPrice)
        data << uint64(*auctionItem.UnitPrice);
 
    if (!auctionItem.CensorServerSideInfo)
    {
        data << auctionItem.ItemGuid;
        data << auctionItem.OwnerAccountID;
        data << int32(auctionItem.EndTime);
    }
 
    if (auctionItem.AuctionBucketKey)
        data << *auctionItem.AuctionBucketKey;
 
    if (auctionItem.Creator)
        data << *auctionItem.Creator;
 
    return data;
}
 
void AuctionBidderNotification::Initialize(int32 auctionHouseId, ::AuctionPosting const* auction, ::Item const* item)
{
    AuctionHouseID = auctionHouseId;
    AuctionID = auction->Id;
    Item.Initialize(item);
    Bidder = auction->Bidder;
}
 
ByteBuffer& operator<<(ByteBuffer& data, AuctionBidderNotification const& bidderNotification)
{
    data << int32(bidderNotification.AuctionHouseID);
    data << int32(bidderNotification.AuctionID);
    data << bidderNotification.Bidder;
    data << bidderNotification.Item;
 
    return data;
}
 
void AuctionBrowseQuery::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> Offset;
    _worldPacket >> MinLevel;
    _worldPacket >> MaxLevel;
    _worldPacket >> Unused1007_1;
    _worldPacket >> Unused1007_2;
    _worldPacket >> As<uint32>(Filters);
 
    uint32 knownPetsSize = _worldPacket.read<uint32>();
    uint32 const sizeLimit = sBattlePetSpeciesStore.GetNumRows() / (sizeof(decltype(KnownPets)::value_type) * 8) + 1;
    if (knownPetsSize >= sizeLimit)
        OnInvalidArraySize(knownPetsSize, sizeLimit);
 
    KnownPets.resize(knownPetsSize);
    _worldPacket >> MaxPetLevel;
    _worldPacket >> Unused1026;
    for (uint8& knownPetMask : KnownPets)
        _worldPacket >> knownPetMask;
 
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> SizedString::BitsSize<8>(Name);
    _worldPacket >> BitsSize<3>(ItemClassFilters);
    _worldPacket >> BitsSize<2>(Sorts);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    _worldPacket >> SizedString::Data(Name);
    for (AuctionListFilterClass& filterClass : ItemClassFilters)
        _worldPacket >> filterClass;
 
    for (AuctionSortDef& sortDef : Sorts)
        _worldPacket >> sortDef;
}
 
void AuctionCancelCommoditiesPurchase::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> OptionalInit(TaintedBy);
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
}
 
void AuctionConfirmCommoditiesPurchase::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> ItemID;
    _worldPacket >> Quantity;
    _worldPacket >> OptionalInit(TaintedBy);
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
}
 
void AuctionHelloRequest::Read()
{
    _worldPacket >> Guid;
}
 
void AuctionListBiddedItems::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> Offset;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<7>(AuctionIDs);
    _worldPacket >> BitsSize<2>(Sorts);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (uint32& auctionID : AuctionIDs)
        _worldPacket >> auctionID;
 
    for (AuctionSortDef& sortDef : Sorts)
        _worldPacket >> sortDef;
}
 
void AuctionListBucketsByBucketKeys::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<7>(BucketKeys);
    _worldPacket >> BitsSize<2>(Sorts);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (AuctionBucketKey& bucketKey : BucketKeys)
        _worldPacket >> bucketKey;
 
    for (AuctionSortDef& sortDef : Sorts)
        _worldPacket >> sortDef;
}
 
void AuctionListItemsByBucketKey::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> BucketKey;
    _worldPacket >> Offset;
    _worldPacket >> Unknown830;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<2>(Sorts);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (AuctionSortDef& sortDef : Sorts)
        _worldPacket >> sortDef;
}
 
void AuctionListItemsByItemID::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> ItemID;
    _worldPacket >> SuffixItemNameDescriptionID;
    _worldPacket >> Offset;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<2>(Sorts);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (AuctionSortDef& sortDef : Sorts)
        _worldPacket >> sortDef;
}
 
void AuctionListOwnedItems::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> Offset;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<2>(Sorts);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (AuctionSortDef& sortDef : Sorts)
        _worldPacket >> sortDef;
}
 
void AuctionPlaceBid::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> AuctionID;
    _worldPacket >> BidAmount;
    _worldPacket >> OptionalInit(TaintedBy);
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
}
 
void AuctionRemoveItem::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> AuctionID;
    _worldPacket >> ItemID;
    _worldPacket >> OptionalInit(TaintedBy);
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
}
 
void AuctionReplicateItems::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> ChangeNumberGlobal;
    _worldPacket >> ChangeNumberCursor;
    _worldPacket >> ChangeNumberTombstone;
    _worldPacket >> Count;
    _worldPacket >> OptionalInit(TaintedBy);
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
}
 
void AuctionSellCommodity::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> UnitPrice;
    _worldPacket >> RunTime;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<6>(Items);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (AuctionItemForSale& item : Items)
        _worldPacket >> item;
}
 
void AuctionSellItem::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> MinBid;
    _worldPacket >> BuyoutPrice;
    _worldPacket >> RunTime;
    _worldPacket >> OptionalInit(TaintedBy);
    _worldPacket >> BitsSize<6>(Items);
 
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
 
    for (AuctionItemForSale& item : Items)
        _worldPacket >> item;
}
 
void AuctionSetFavoriteItem::Read()
{
    _worldPacket >> Bits<1>(IsNotFavorite);
    _worldPacket >> Item;
}
 
void AuctionGetCommodityQuote::Read()
{
    _worldPacket >> Auctioneer;
    _worldPacket >> ItemID;
    _worldPacket >> Quantity;
    _worldPacket >> OptionalInit(TaintedBy);
    if (TaintedBy)
        _worldPacket >> *TaintedBy;
}
 
WorldPacket const* AuctionClosedNotification::Write()
{
    _worldPacket << Info;
    _worldPacket << float(ProceedsMailDelay);
    _worldPacket << Bits<1>(Sold);
    _worldPacket.FlushBits();
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionCommandResult::Write()
{
    _worldPacket << int32(AuctionID);
    _worldPacket << int32(Command);
    _worldPacket << int32(ErrorCode);
    _worldPacket << int32(BagResult);
    _worldPacket << Guid;
    _worldPacket << uint64(MinIncrement);
    _worldPacket << uint64(Money);
    _worldPacket << uint32(DesiredDelay);
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionGetCommodityQuoteResult::Write()
{
    _worldPacket << OptionalInit(TotalPrice);
    _worldPacket << OptionalInit(Quantity);
    _worldPacket << OptionalInit(QuoteDuration);
    _worldPacket << int32(ItemID);
    _worldPacket << uint32(DesiredDelay);
 
    if (TotalPrice)
        _worldPacket << uint64(*TotalPrice);
 
    if (Quantity)
        _worldPacket << uint32(*Quantity);
 
    if (QuoteDuration)
        _worldPacket << *QuoteDuration;
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionFavoriteList::Write()
{
    _worldPacket << uint32(DesiredDelay);
    _worldPacket << BitsSize<7>(Items);
    _worldPacket.FlushBits();
 
    for (AuctionFavoriteInfo const& favoriteInfo : Items)
        _worldPacket << favoriteInfo;
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionHelloResponse::Write()
{
    _worldPacket << Auctioneer;
    _worldPacket << uint32(PurchaseDeliveryDelay);
    _worldPacket << uint32(CancelDeliveryDelay);
    _worldPacket << int32(AuctionHouseID);
    _worldPacket << Bits<1>(OpenForBusiness);
    _worldPacket.FlushBits();
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionListBiddedItemsResult::Write()
{
    _worldPacket << Size<uint32>(Items);
    _worldPacket << uint32(DesiredDelay);
 
    for (AuctionItem const& item : Items)
        _worldPacket << item;
 
    _worldPacket << Bits<1>(HasMoreResults);
    _worldPacket.FlushBits();
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionListBucketsResult::Write()
{
    _worldPacket << Size<uint32>(Buckets);
    _worldPacket << uint32(DesiredDelay);
    _worldPacket << int32(Filters);
    _worldPacket << int32(TotalCount);
 
    for (BucketInfo const& bucketInfo : Buckets)
        _worldPacket << bucketInfo;
 
    _worldPacket << Bits<1>(BrowseMode);
    _worldPacket << Bits<1>(HasMoreResults);
    _worldPacket.FlushBits();
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionListItemsResult::Write()
{
    {
        _worldPacket << Size<uint32>(Items);
        _worldPacket << uint32(TotalCount);
        _worldPacket << uint32(DesiredDelay);
        for (AuctionItem const& item : Items)
            _worldPacket << item;
    }
 
    {
        _worldPacket << Bits<2>(ListType);
        _worldPacket << Bits<1>(HasMoreResults);
        _worldPacket.FlushBits();
 
        _worldPacket << BucketKey;
        _worldPacket << uint32(TotalQuantity);
    }
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionListOwnedItemsResult::Write()
{
    _worldPacket << Size<int32>(Items);
    _worldPacket << Size<int32>(SoldItems);
    _worldPacket << uint32(DesiredDelay);
 
    for (AuctionItem const& item : Items)
        _worldPacket << item;
 
    for (AuctionItem const& item : SoldItems)
        _worldPacket << item;
 
    _worldPacket << Bits<1>(HasMoreResults);
    _worldPacket.FlushBits();
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionOutbidNotification::Write()
{
    _worldPacket << Info;
    _worldPacket << uint64(BidAmount);
    _worldPacket << uint64(MinIncrement);
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionOwnerBidNotification::Write()
{
    _worldPacket << Info;
    _worldPacket << uint64(MinIncrement);
    _worldPacket << Bidder;
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionReplicateResponse::Write()
{
    _worldPacket << uint32(Result);
    _worldPacket << uint32(DesiredDelay);
    _worldPacket << uint32(ChangeNumberGlobal);
    _worldPacket << uint32(ChangeNumberCursor);
    _worldPacket << uint32(ChangeNumberTombstone);
    _worldPacket << Size<uint32>(Items);
 
    for (AuctionItem const& item : Items)
        _worldPacket << item;
 
    return &_worldPacket;
}
 
WorldPacket const* AuctionWonNotification::Write()
{
    _worldPacket << Info;
 
    return &_worldPacket;
}
}