AzeriteEmpoweredItem.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 "AzeriteEmpoweredItem.h"
#include "DatabaseEnv.h"
#include "DB2Stores.h"
#include "Player.h"
#include "UpdateData.h"
#include "WorldPacket.h"
 
AzeriteEmpoweredItem::AzeriteEmpoweredItem()
{
    m_objectTypeId = TYPEID_AZERITE_EMPOWERED_ITEM;
 
    m_entityFragments.Add(WowCS::EntityFragment::Tag_AzeriteEmpoweredItem, false);
 
    m_azeritePowers = nullptr;
    m_maxTier = 0;
}
 
bool AzeriteEmpoweredItem::Create(ObjectGuid::LowType guidlow, uint32 itemId, ItemContext context, Player const* owner)
{
    if (!Item::Create(guidlow, itemId, context, owner))
        return false;
 
    InitAzeritePowerData();
    return true;
}
 
void AzeriteEmpoweredItem::SaveToDB(CharacterDatabaseTransaction trans)
{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_AZERITE_EMPOWERED);
    stmt->setUInt64(0, GetGUID().GetCounter());
    trans->Append(stmt);
 
    switch (GetState())
    {
        case ITEM_NEW:
        case ITEM_CHANGED:
        {
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_INSTANCE_AZERITE_EMPOWERED);
            stmt->setUInt64(0, GetGUID().GetCounter());
            for (uint32 i = 0; i < MAX_AZERITE_EMPOWERED_TIER; ++i)
                stmt->setInt32(1 + i, m_azeriteEmpoweredItemData->Selections[i]);
 
            trans->Append(stmt);
            break;
        }
        case ITEM_REMOVED:
        default:
            break;
    }
 
    Item::SaveToDB(trans);
}
 
void AzeriteEmpoweredItem::LoadAzeriteEmpoweredItemData(Player const* owner, AzeriteEmpoweredItemData& azeriteEmpoweredItem)
{
    InitAzeritePowerData();
    bool needSave = false;
    if (m_azeritePowers)
    {
        for (int32 i = MAX_AZERITE_EMPOWERED_TIER; --i >= 0; )
        {
            int32 selection = azeriteEmpoweredItem.SelectedAzeritePowers[i];
            if (GetTierForAzeritePower(Classes(owner->GetClass()), selection) != i)
            {
                needSave = true;
                break;
            }
 
            SetSelectedAzeritePower(i, selection);
        }
    }
    else
        needSave = true;
 
    if (needSave)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_INSTANCE_AZERITE_EMPOWERED);
        for (uint32 i = 0; i < MAX_AZERITE_EMPOWERED_TIER; ++i)
            stmt->setInt32(i, m_azeriteEmpoweredItemData->Selections[i]);
 
        stmt->setUInt64(5, GetGUID().GetCounter());
        CharacterDatabase.Execute(stmt);
    }
}
 
void AzeriteEmpoweredItem::DeleteFromDB(CharacterDatabaseTransaction trans, ObjectGuid::LowType itemGuid)
{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_AZERITE_EMPOWERED);
    stmt->setUInt64(0, itemGuid);
    CharacterDatabase.ExecuteOrAppend(trans, stmt);
}
 
void AzeriteEmpoweredItem::DeleteFromDB(CharacterDatabaseTransaction trans)
{
    AzeriteEmpoweredItem::DeleteFromDB(trans, GetGUID().GetCounter());
    Item::DeleteFromDB(trans);
}
 
uint32 AzeriteEmpoweredItem::GetRequiredAzeriteLevelForTier(uint32 tier) const
{
    return sDB2Manager.GetRequiredAzeriteLevelForAzeritePowerTier(_bonusData.AzeriteTierUnlockSetId, GetContext(), tier);
}
 
int32 AzeriteEmpoweredItem::GetTierForAzeritePower(Classes playerClass, int32 azeritePowerId) const
{
    auto azeritePowerItr = std::find_if(m_azeritePowers->begin(), m_azeritePowers->end(), [&](AzeritePowerSetMemberEntry const* power)
    {
        return power->AzeritePowerID == azeritePowerId && power->Class == playerClass;
    });
    if (azeritePowerItr != m_azeritePowers->end())
        return (*azeritePowerItr)->Tier;
 
    return MAX_AZERITE_EMPOWERED_TIER;
}
 
void AzeriteEmpoweredItem::SetSelectedAzeritePower(int32 tier, int32 azeritePowerId)
{
    SetUpdateFieldValue(m_values.ModifyValue(&AzeriteEmpoweredItem::m_azeriteEmpoweredItemData).ModifyValue(&UF::AzeriteEmpoweredItemData::Selections, uint32(tier)), azeritePowerId);
 
    // Not added to UF::ItemData::BonusListIDs, client fakes it on its own too
    _bonusData.AddBonusList(sAzeritePowerStore.AssertEntry(azeritePowerId)->ItemBonusListID);
}
 
void AzeriteEmpoweredItem::ClearSelectedAzeritePowers()
{
    for (uint32 i = 0; i < MAX_AZERITE_EMPOWERED_TIER; ++i)
        SetUpdateFieldValue(m_values.ModifyValue(&AzeriteEmpoweredItem::m_azeriteEmpoweredItemData).ModifyValue(&UF::AzeriteEmpoweredItemData::Selections, i), 0);
 
    _bonusData.Initialize(GetTemplate());
    for (int32 bonusListID : GetBonusListIDs())
        _bonusData.AddBonusList(bonusListID);
}
 
int64 AzeriteEmpoweredItem::GetRespecCost() const
{
    if (Player const* owner = GetOwner())
        return int64(float(GOLD) * sDB2Manager.GetCurveValueAt(CURVE_ID_AZERITE_EMPOWERED_ITEM_RESPEC_COST, float(owner->GetNumRespecs())));
 
    return MAX_MONEY_AMOUNT + 1;
}
 
void AzeriteEmpoweredItem::BuildValuesCreate(UF::UpdateFieldFlag flags, ByteBuffer& data, Player const* target) const
{
    m_objectData->WriteCreate(flags, data, target, this);
    m_itemData->WriteCreate(flags, data, target, this);
    m_azeriteEmpoweredItemData->WriteCreate(flags, data, target, this);
}
 
void AzeriteEmpoweredItem::BuildValuesUpdate(UF::UpdateFieldFlag flags, ByteBuffer& data, Player const* target) const
{
    data << uint32(m_values.GetChangedObjectTypeMask());
 
    if (m_values.HasChanged(TYPEID_OBJECT))
        m_objectData->WriteUpdate(flags, data, target, this);
 
    if (m_values.HasChanged(TYPEID_ITEM))
        m_itemData->WriteUpdate(flags, data, target, this);
 
    if (m_values.HasChanged(TYPEID_AZERITE_EMPOWERED_ITEM))
        m_azeriteEmpoweredItemData->WriteUpdate(flags, data, target, this);
}
 
void AzeriteEmpoweredItem::BuildValuesUpdateForPlayerWithMask(UpdateData* data, UF::ObjectData::Mask const& requestedObjectMask,
    UF::ItemData::Mask const& requestedItemMask, UF::AzeriteEmpoweredItemData::Mask const& requestedAzeriteEmpoweredItemMask,
    Player const* target, bool ignoreNestedChangesMask) const
{
    UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
    UpdateMask<NUM_CLIENT_OBJECT_TYPES> valuesMask;
    if (requestedObjectMask.IsAnySet())
        valuesMask.Set(TYPEID_OBJECT);
 
    UF::ItemData::Mask itemMask = requestedItemMask;
    UF::ItemData::FilterDisallowedFieldsMaskForFlag(itemMask, flags);
    if (itemMask.IsAnySet())
        valuesMask.Set(TYPEID_ITEM);
 
    if (requestedAzeriteEmpoweredItemMask.IsAnySet())
        valuesMask.Set(TYPEID_AZERITE_EMPOWERED_ITEM);
 
    ByteBuffer& buffer = PrepareValuesUpdateBuffer(data);
    std::size_t sizePos = buffer.wpos();
    buffer << uint32(0);
    BuildEntityFragmentsForValuesUpdateForPlayerWithMask(buffer, flags);
    buffer << uint32(valuesMask.GetBlock(0));
 
    if (valuesMask[TYPEID_OBJECT])
        m_objectData->WriteUpdate(requestedObjectMask, buffer, target, this, ignoreNestedChangesMask);
 
    if (valuesMask[TYPEID_ITEM])
        m_itemData->WriteUpdate(itemMask, buffer, target, this, ignoreNestedChangesMask);
 
    if (valuesMask[TYPEID_AZERITE_EMPOWERED_ITEM])
        m_azeriteEmpoweredItemData->WriteUpdate(requestedAzeriteEmpoweredItemMask, buffer, target, this, ignoreNestedChangesMask);
 
    buffer.put<uint32>(sizePos, buffer.wpos() - sizePos - 4);
 
    data->AddUpdateBlock();
}
 
void AzeriteEmpoweredItem::ValuesUpdateForPlayerWithMaskSender::operator()(Player const* player) const
{
    UpdateData udata(player->GetMapId());
    WorldPacket packet;
 
    Owner->BuildValuesUpdateForPlayerWithMask(&udata, ObjectMask.GetChangesMask(), ItemMask.GetChangesMask(), AzeriteEmpoweredItemMask.GetChangesMask(),
        player, IgnoreNestedChangesMask);
 
    udata.BuildPacket(&packet);
    player->SendDirectMessage(&packet);
}
 
void AzeriteEmpoweredItem::ClearValuesChangesMask()
{
    m_values.ClearChangesMask(&AzeriteEmpoweredItem::m_azeriteEmpoweredItemData);
    Item::ClearValuesChangesMask();
}
 
void AzeriteEmpoweredItem::InitAzeritePowerData()
{
    m_azeritePowers = sDB2Manager.GetAzeritePowers(GetEntry());
    if (m_azeritePowers)
        m_maxTier = (*std::ranges::max_element(*m_azeritePowers, {}, &AzeritePowerSetMemberEntry::Tier))->Tier;
}