ItemPacketsCommon.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 "ItemPacketsCommon.h"
#include "Item.h"
#include "Loot.h"
#include "PacketOperators.h"
 
namespace WorldPackets::Item
{
bool ItemBonuses::operator==(ItemBonuses const& r) const
{
    if (Context != r.Context)
        return false;
 
    return std::ranges::is_permutation(BonusListIDs, r.BonusListIDs);
}
 
bool ItemModList::operator==(ItemModList const& r) const
{
    return std::ranges::is_permutation(Values, r.Values);
}
 
void ItemInstance::Initialize(::Item const* item)
{
    ItemID = item->GetEntry();
    std::vector<int32> const& bonusListIds = item->GetBonusListIDs();
    if (!bonusListIds.empty())
    {
        ItemBonus.emplace();
        ItemBonus->BonusListIDs.insert(ItemBonus->BonusListIDs.end(), bonusListIds.begin(), bonusListIds.end());
        ItemBonus->Context = item->GetContext();
    }
 
    for (UF::ItemMod mod : item->m_itemData->Modifiers->Values)
        Modifications.Values.push_back({ .Value = mod.Value, .Type = ItemModifier(mod.Type) });
}
 
void ItemInstance::Initialize(UF::SocketedGem const* gem)
{
    ItemID = gem->ItemID;
 
    ItemBonuses bonus;
    bonus.Context = ItemContext(*gem->Context);
    for (uint16 bonusListId : gem->BonusListIDs)
        if (bonusListId)
            bonus.BonusListIDs.push_back(bonusListId);
 
    if (bonus.Context != ItemContext::NONE || !bonus.BonusListIDs.empty())
        ItemBonus = bonus;
}
 
void ItemInstance::Initialize(::LootItem const& lootItem)
{
    ItemID = lootItem.itemid;
 
    if (!lootItem.BonusListIDs.empty() || lootItem.randomBonusListId)
    {
        ItemBonus.emplace();
        ItemBonus->BonusListIDs = lootItem.BonusListIDs;
        ItemBonus->Context = lootItem.context;
        if (lootItem.randomBonusListId)
            ItemBonus->BonusListIDs.push_back(lootItem.randomBonusListId);
    }
}
 
bool ItemInstance::operator==(ItemInstance const& r) const
{
    if (ItemID != r.ItemID)
        return false;
 
    if (ItemBonus != r.ItemBonus)
        return false;
 
    if (Modifications != r.Modifications)
        return false;
 
    return true;
}
 
bool ItemBonusKey::operator==(ItemBonusKey const& right) const
{
    if (ItemID != right.ItemID)
        return false;
 
    if (BonusListIDs != right.BonusListIDs)
        return false;
 
    if (Modifications != right.Modifications)
        return false;
 
    return true;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemBonuses const& itemBonusInstanceData)
{
    data << uint8(itemBonusInstanceData.Context);
    data << Size<uint32>(itemBonusInstanceData.BonusListIDs);
    for (uint32 bonusID : itemBonusInstanceData.BonusListIDs)
        data << uint32(bonusID);
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, ItemBonuses& itemBonusInstanceData)
{
    data >> As<uint8>(itemBonusInstanceData.Context);
    uint32 bonusListIdSize;
    data >> bonusListIdSize;
    if (bonusListIdSize > 32)
        OnInvalidArraySize(bonusListIdSize, 32);
 
    itemBonusInstanceData.BonusListIDs.resize(bonusListIdSize);
 
    for (int32& bonusListID : itemBonusInstanceData.BonusListIDs)
        data >> bonusListID;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemMod const& itemMod)
{
    data << uint8(itemMod.Type);
    data << int32(itemMod.Value);
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, ItemMod& itemMod)
{
    data >> As<uint8>(itemMod.Type);
    data >> itemMod.Value;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemModList const& itemModList)
{
    data << BitsSize<6>(itemModList.Values);
    data.FlushBits();
 
    for (ItemMod const& itemMod : itemModList.Values)
        data << itemMod;
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, ItemModList& itemModList)
{
    data >> BitsSize<6>(itemModList.Values);
    data.ResetBitPos();
 
    for (ItemMod& itemMod : itemModList.Values)
        data >> itemMod;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemInstance const& itemInstance)
{
    data << int32(itemInstance.ItemID);
 
    data << OptionalInit(itemInstance.ItemBonus);
    data.FlushBits();
 
    data << itemInstance.Modifications;
 
    if (itemInstance.ItemBonus)
        data << *itemInstance.ItemBonus;
 
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, ItemInstance& itemInstance)
{
    data >> itemInstance.ItemID;
    data >> OptionalInit(itemInstance.ItemBonus);
    data.ResetBitPos();
 
    data >> itemInstance.Modifications;
 
    if (itemInstance.ItemBonus)
        data >> *itemInstance.ItemBonus;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemBonusKey const& itemBonusKey)
{
    data << int32(itemBonusKey.ItemID);
    data << Size<uint32>(itemBonusKey.BonusListIDs);
    data << Size<uint32>(itemBonusKey.Modifications);
 
    if (!itemBonusKey.BonusListIDs.empty())
        data.append(itemBonusKey.BonusListIDs.data(), itemBonusKey.BonusListIDs.size());
 
    for (ItemMod const& modification : itemBonusKey.Modifications)
        data << modification;
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemEnchantData const& itemEnchantData)
{
    data << int32(itemEnchantData.ID);
    data << uint32(itemEnchantData.Expiration);
    data << int32(itemEnchantData.Charges);
    data << uint8(itemEnchantData.Slot);
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, ItemGemData const& itemGemData)
{
    data << uint8(itemGemData.Slot);
    data << itemGemData.Item;
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, ItemGemData& itemGemData)
{
    data >> itemGemData.Slot;
    data >> itemGemData.Item;
    return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, InvUpdate& invUpdate)
{
    data >> BitsSize<2>(invUpdate.Items);
    data.ResetBitPos();
    for (InvUpdate::InvItem& item : invUpdate.Items)
    {
        data >> item.ContainerSlot;
        data >> item.Slot;
    }
 
    return data;
}
 
ByteBuffer& operator<<(ByteBuffer& data, UiEventToast const& uiEventToast)
{
    data << int32(uiEventToast.UiEventToastID);
    data << int32(uiEventToast.Asset);
 
    return data;
}
}