Core/Items: Implement azerite empowered items

Port From (https://github.com/TrinityCore/TrinityCore/commit/d934824421c83598853487c5cc9e4cbb3c5d0006)
2019-12-05 22:55:44 -05:00
parent 86e1065da0
commit 5b9ad41953
47 changed files with 1050 additions and 239 deletions
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2012-2019 CypherCore <http://github.com/CypherCore>
+ * 
+ * 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 3 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/>.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Game.Network;
+using Framework.Constants;
+using Framework.Database;
+using Game.Network.Packets;
+using Game.DataStorage;
+using System.Linq;
+
+namespace Game.Entities
+{
+    public class AzeriteEmpoweredItem : Item
+    {
+        AzeriteEmpoweredItemData m_azeriteEmpoweredItemData;
+        List<AzeritePowerSetMemberRecord> m_azeritePowers;
+        int m_maxTier;
+
+        public AzeriteEmpoweredItem()
+        {
+            ObjectTypeMask |= TypeMask.AzeriteEmpoweredItem;
+            ObjectTypeId = TypeId.AzeriteEmpoweredItem;
+
+            m_azeriteEmpoweredItemData = new AzeriteEmpoweredItemData();
+        }
+
+        public override bool Create(ulong guidlow, uint itemId, ItemContext context, Player owner)
+        {
+            if (!base.Create(guidlow, itemId, context, owner))
+                return false;
+
+            InitAzeritePowerData();
+            return true;
+        }
+
+        public override void SaveToDB(SQLTransaction trans)
+        {
+            base.SaveToDB(trans);
+
+            PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.DEL_ITEM_INSTANCE_AZERITE_EMPOWERED);
+            stmt.AddValue(0, GetGUID().GetCounter());
+            trans.Append(stmt);
+
+            stmt = DB.Characters.GetPreparedStatement(CharStatements.INS_ITEM_INSTANCE_AZERITE_EMPOWERED);
+            stmt.AddValue(0, GetGUID().GetCounter());
+            for (int i = 0; i < SharedConst.MaxAzeriteEmpoweredTier; ++i)
+                stmt.AddValue(1 + i, m_azeriteEmpoweredItemData.Selections[i]);
+
+            trans.Append(stmt);
+        }
+
+        public void LoadAzeriteEmpoweredItemData(Player owner, AzeriteEmpoweredData azeriteEmpoweredItem)
+        {
+            InitAzeritePowerData();
+            bool needSave = false;
+            if (m_azeritePowers != null)
+            {
+                for (int i = SharedConst.MaxAzeriteEmpoweredTier; --i >= 0;)
+                {
+                    int selection = azeriteEmpoweredItem.SelectedAzeritePowers[i];
+                    if (GetTierForAzeritePower(owner.GetClass(), selection) != i)
+                    {
+                        needSave = true;
+                        break;
+                    }
+
+                    SetSelectedAzeritePower(i, selection);
+                }
+            }
+            else
+                needSave = true;
+
+            if (needSave)
+            {
+                PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.UPD_ITEM_INSTANCE_AZERITE_EMPOWERED);
+                for (int i = 0; i < SharedConst.MaxAzeriteEmpoweredTier; ++i)
+                    stmt.AddValue(i, m_azeriteEmpoweredItemData.Selections[i]);
+
+                stmt.AddValue(5, GetGUID().GetCounter());
+                DB.Characters.Execute(stmt);
+            }
+        }
+
+        public static new void DeleteFromDB(SQLTransaction trans, ulong itemGuid)
+        {
+            PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.DEL_ITEM_INSTANCE_AZERITE_EMPOWERED);
+            stmt.AddValue(0, itemGuid);
+            DB.Characters.ExecuteOrAppend(trans, stmt);
+        }
+
+        public override void DeleteFromDB(SQLTransaction trans)
+        {
+            DeleteFromDB(trans, GetGUID().GetCounter());
+            base.DeleteFromDB(trans);
+        }
+
+        public uint GetRequiredAzeriteLevelForTier(uint tier)
+        {
+            return Global.DB2Mgr.GetRequiredAzeriteLevelForAzeritePowerTier(_bonusData.AzeriteTierUnlockSetId, GetContext(), tier);
+        }
+
+        public int GetTierForAzeritePower(Class playerClass, int azeritePowerId)
+        {
+            var azeritePowerItr = m_azeritePowers.Find(power =>
+            {
+                return power.AzeritePowerID == azeritePowerId && power.Class == (int)playerClass;
+            });
+
+            if (azeritePowerItr != null)
+                return azeritePowerItr.Tier;
+
+            return SharedConst.MaxAzeriteEmpoweredTier;
+        }
+
+        public void SetSelectedAzeritePower(int tier, int azeritePowerId)
+        {
+            SetUpdateFieldValue(ref m_values.ModifyValue(m_azeriteEmpoweredItemData).ModifyValue(m_azeriteEmpoweredItemData.Selections, tier), azeritePowerId);
+
+            // Not added to UF::ItemData::BonusListIDs, client fakes it on its own too
+            _bonusData.AddBonusList(CliDB.AzeritePowerStorage.LookupByKey(azeritePowerId).ItemBonusListID);
+        }
+
+        void ClearSelectedAzeritePowers()
+        {
+            for (int i = 0; i < SharedConst.MaxAzeriteEmpoweredTier; ++i)
+                SetUpdateFieldValue(ref m_values.ModifyValue(m_azeriteEmpoweredItemData).ModifyValue(m_azeriteEmpoweredItemData.Selections, i), 0);
+
+            _bonusData = new BonusData(GetTemplate());
+            foreach (uint bonusListID in (List<uint>)m_itemData.BonusListIDs)
+                _bonusData.AddBonusList(bonusListID);
+        }
+
+        public long GetRespecCost()
+        {
+            Player owner = GetOwner();
+            if (owner != null)
+                return (long)(MoneyConstants.Gold * Global.DB2Mgr.GetCurveValueAt((uint)Curves.AzeriteEmpoweredItemRespecCost, (float)owner.GetNumRespecs()));
+
+            return (long)PlayerConst.MaxMoneyAmount + 1;
+        }
+
+        public override void BuildValuesCreate(WorldPacket data, Player target)
+        {
+            UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
+            WorldPacket buffer = new WorldPacket();
+
+            buffer.WriteUInt8((byte)flags);
+            m_objectData.WriteCreate(buffer, flags, this, target);
+            m_itemData.WriteCreate(buffer, flags, this, target);
+            m_azeriteEmpoweredItemData.WriteCreate(buffer, flags, this, target);
+
+            data.WriteUInt32(buffer.GetSize());
+            data.WriteBytes(buffer);
+        }
+
+        public override void BuildValuesUpdate(WorldPacket data, Player target)
+        {
+            UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
+            WorldPacket buffer = new WorldPacket();
+
+            if (m_values.HasChanged(TypeId.Object))
+                m_objectData.WriteUpdate(buffer, flags, this, target);
+
+            if (m_values.HasChanged(TypeId.Item))
+                m_itemData.WriteUpdate(buffer, flags, this, target);
+
+            if (m_values.HasChanged(TypeId.AzeriteEmpoweredItem))
+                m_azeriteEmpoweredItemData.WriteUpdate(buffer, flags, this, target);
+
+            data.WriteUInt32(buffer.GetSize());
+            data.WriteUInt32(m_values.GetChangedObjectTypeMask());
+            data.WriteBytes(buffer);
+        }
+
+        public override void ClearUpdateMask(bool remove)
+        {
+            m_values.ClearChangesMask(m_azeriteEmpoweredItemData);
+            base.ClearUpdateMask(remove);
+        }
+
+        void InitAzeritePowerData()
+        {
+            m_azeritePowers = Global.DB2Mgr.GetAzeritePowers(GetEntry());
+            if (m_azeritePowers != null)
+                m_maxTier = m_azeritePowers.Aggregate((a1, a2) => a1.Tier < a2.Tier ? a2 : a1).Tier;
+        }
+
+        public int GetMaxAzeritePowerTier() { return m_maxTier; }
+        public uint GetSelectedAzeritePower(int tier)
+        {
+            return (uint)m_azeriteEmpoweredItemData.Selections[tier];
+        }
+    }
+}
@@ -314,7 +314,7 @@ namespace Game.Entities
        public bool HasUnlockedEssenceSlot(byte slot)
        {
            AzeriteItemMilestonePowerRecord milestone = Global.DB2Mgr.GetAzeriteItemMilestonePower(slot);
-            return m_azeriteItemData.UnlockedEssenceMilestones.FindIndex(milestone.ID) != -1;
+            return m_azeriteItemData.UnlockedEssenceMilestones.FindIndex(milestone.Id) != -1;
        }

        public bool HasUnlockedEssenceMilestone(uint azeriteItemMilestonePowerId) { return m_azeriteItemData.UnlockedEssenceMilestones.FindIndex(azeriteItemMilestonePowerId) != -1; }
@@ -487,12 +487,12 @@ namespace Game.Entities
                if (milestone.RequiredLevel > GetLevel())
                    break;

-                if (HasUnlockedEssenceMilestone(milestone.ID))
+                if (HasUnlockedEssenceMilestone(milestone.Id))
                    continue;

                if (milestone.AutoUnlock != 0)
                {
-                    AddUnlockedEssenceMilestone(milestone.ID);
+                    AddUnlockedEssenceMilestone(milestone.Id);
                    hasPreviousMilestone = true;
                }
                else
@@ -47,11 +47,11 @@ namespace Game.Entities
            loot = new Loot();
        }

-        public virtual bool Create(ulong guidlow, uint itemid, ItemContext context, Player owner)
+        public virtual bool Create(ulong guidlow, uint itemId, ItemContext context, Player owner)
        {
            _Create(ObjectGuid.Create(HighGuid.Item, guidlow));

-            SetEntry(itemid);
+            SetEntry(itemId);
            SetObjectScale(1.0f);

            if (owner)
@@ -60,7 +60,7 @@ namespace Game.Entities
                SetContainedIn(owner.GetGUID());
            }

-            ItemTemplate itemProto = Global.ObjectMgr.GetItemTemplate(itemid);
+            ItemTemplate itemProto = Global.ObjectMgr.GetItemTemplate(itemId);
            if (itemProto == null)
                return false;

@@ -998,59 +998,50 @@ namespace Game.Entities
                    {
                        BonusData gemBonus = new BonusData(gemTemplate);
                        foreach (var bonusListId in gem.BonusListIDs)
+                            gemBonus.AddBonusList(bonusListId);
+
+                        uint gemBaseItemLevel = gemTemplate.GetBaseItemLevel();
+                        ScalingStatDistributionRecord ssd = CliDB.ScalingStatDistributionStorage.LookupByKey(gemBonus.ScalingStatDistribution);
+                        if (ssd != null)
                        {
+                            uint scaledIlvl = (uint)Global.DB2Mgr.GetCurveValueAt(ssd.PlayerLevelToItemLevelCurveID, gemScalingLevel);
+                            if (scaledIlvl != 0)
+                                gemBaseItemLevel = scaledIlvl;
+                        }

-                            var bonuses = Global.DB2Mgr.GetItemBonusList(bonusListId);
-                            if (bonuses != null)
+                        _bonusData.GemRelicType[slot] = gemBonus.RelicType;
+
+                        for (uint i = 0; i < ItemConst.MaxItemEnchantmentEffects; ++i)
+                        {
+                            switch (gemEnchant.Effect[i])
                            {
-
-                                foreach (ItemBonusRecord itemBonus in bonuses)
-                                    gemBonus.AddBonus(itemBonus.BonusType, itemBonus.Value);
-                            }
-
-                            uint gemBaseItemLevel = gemTemplate.GetBaseItemLevel();
-                            ScalingStatDistributionRecord ssd = CliDB.ScalingStatDistributionStorage.LookupByKey(gemBonus.ScalingStatDistribution);
-                            if (ssd != null)
-                            {
-                                uint scaledIlvl = (uint)Global.DB2Mgr.GetCurveValueAt(ssd.PlayerLevelToItemLevelCurveID, gemScalingLevel);
-                                if (scaledIlvl != 0)
-                                    gemBaseItemLevel = scaledIlvl;
-                            }
-
-                            _bonusData.GemRelicType[slot] = gemBonus.RelicType;
-
-                            for (uint i = 0; i < ItemConst.MaxItemEnchantmentEffects; ++i)
-                            {
-                                switch (gemEnchant.Effect[i])
-                                {
-                                    case ItemEnchantmentType.BonusListID:
+                                case ItemEnchantmentType.BonusListID:
+                                    {
+                                        var bonusesEffect = Global.DB2Mgr.GetItemBonusList(gemEnchant.EffectArg[i]);
+                                        if (bonusesEffect != null)
                                        {
-                                            var bonusesEffect = Global.DB2Mgr.GetItemBonusList(gemEnchant.EffectArg[i]);
+                                            foreach (ItemBonusRecord itemBonus in bonusesEffect)
+                                                if (itemBonus.BonusType == ItemBonusType.ItemLevel)
+
+                                                    _bonusData.GemItemLevelBonus[slot] += (uint)itemBonus.Value[0];
+                                        }
+                                        break;
+                                    }
+                                case ItemEnchantmentType.BonusListCurve:
+                                    {
+                                        uint artifactrBonusListId = Global.DB2Mgr.GetItemBonusListForItemLevelDelta((short)Global.DB2Mgr.GetCurveValueAt((uint)Curves.ArtifactRelicItemLevelBonus, gemBaseItemLevel + gemBonus.ItemLevelBonus));
+                                        if (artifactrBonusListId != 0)
+                                        {
+                                            var bonusesEffect = Global.DB2Mgr.GetItemBonusList(artifactrBonusListId);
                                            if (bonusesEffect != null)
-                                            {
                                                foreach (ItemBonusRecord itemBonus in bonusesEffect)
                                                    if (itemBonus.BonusType == ItemBonusType.ItemLevel)
-
                                                        _bonusData.GemItemLevelBonus[slot] += (uint)itemBonus.Value[0];
-                                            }
-                                            break;
                                        }
-                                    case ItemEnchantmentType.BonusListCurve:
-                                        {
-                                            uint artifactrBonusListId = Global.DB2Mgr.GetItemBonusListForItemLevelDelta((short)Global.DB2Mgr.GetCurveValueAt((uint)Curves.ArtifactRelicItemLevelBonus, gemBaseItemLevel + gemBonus.ItemLevelBonus));
-                                            if (artifactrBonusListId != 0)
-                                            {
-                                                var bonusesEffect = Global.DB2Mgr.GetItemBonusList(artifactrBonusListId);
-                                                if (bonusesEffect != null)
-                                                    foreach (ItemBonusRecord itemBonus in bonusesEffect)
-                                                        if (itemBonus.BonusType == ItemBonusType.ItemLevel)
-                                                            _bonusData.GemItemLevelBonus[slot] += (uint)itemBonus.Value[0];
-                                            }
-                                            break;
-                                        }
-                                    default:
                                        break;
-                                }
+                                    }
+                                default:
+                                    break;
                            }
                        }
                    }
@@ -2160,14 +2151,7 @@ namespace Game.Entities
            SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.BonusListIDs), bonusListIDs);

            foreach (uint bonusListID in (List<uint>)m_itemData.BonusListIDs)
-            {
-                var bonuses = Global.DB2Mgr.GetItemBonusList(bonusListID);
-                if (bonuses != null)
-                {
-                    foreach (ItemBonusRecord bonus in bonuses)
-                        _bonusData.AddBonus(bonus.BonusType, bonus.Value);
-                }
-            }
+                _bonusData.AddBonusList(bonusListID);

            SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.ItemAppearanceModID), (byte)_bonusData.AppearanceModID);
        }
@@ -2444,6 +2428,9 @@ namespace Game.Entities
            if (Global.DB2Mgr.IsAzeriteItem(proto.GetId()))
                return new AzeriteItem();

+            if (Global.DB2Mgr.GetAzeriteEmpoweredItem(proto.GetId()) != null)
+                return new AzeriteEmpoweredItem();
+
            return new Item();
        }

@@ -2596,17 +2583,19 @@ namespace Game.Entities
        public void AddItemFlag(ItemFieldFlags flags) { SetUpdateFieldFlagValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags), (uint)flags); }
        public void RemoveItemFlag(ItemFieldFlags flags) { RemoveUpdateFieldFlagValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags), (uint)flags); }
        public void SetItemFlags(ItemFieldFlags flags) { SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags), (uint)flags); }
-        bool HasItemFlag2(ItemFieldFlags2 flag) { return (m_itemData.DynamicFlags2 & (uint)flag) != 0; }
-        void AddItemFlag2(ItemFieldFlags2 flags) { SetUpdateFieldFlagValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags2), (uint)flags); }
-        void RemoveItemFlag2(ItemFieldFlags2 flags) { RemoveUpdateFieldFlagValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags2), (uint)flags); }
-        void SetItemFlags2(ItemFieldFlags2 flags) { SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags2), (uint)flags); }
+        public bool HasItemFlag2(ItemFieldFlags2 flag) { return (m_itemData.DynamicFlags2 & (uint)flag) != 0; }
+        public void AddItemFlag2(ItemFieldFlags2 flags) { SetUpdateFieldFlagValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags2), (uint)flags); }
+        public void RemoveItemFlag2(ItemFieldFlags2 flags) { RemoveUpdateFieldFlagValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags2), (uint)flags); }
+        public void SetItemFlags2(ItemFieldFlags2 flags) { SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.DynamicFlags2), (uint)flags); }

        public Bag ToBag() { return IsBag() ? this as Bag : null; }
        public AzeriteItem ToAzeriteItem() { return IsAzeriteItem() ? this as AzeriteItem : null; }
+        public AzeriteEmpoweredItem ToAzeriteEmpoweredItem() { return IsAzeriteEmpoweredItem() ? this as AzeriteEmpoweredItem : null; }

        public bool IsLocked() { return !HasItemFlag(ItemFieldFlags.Unlocked); }
        public bool IsBag() { return GetTemplate().GetInventoryType() == InventoryType.Bag; }
        public bool IsAzeriteItem() { return GetTypeId() == TypeId.AzeriteItem; }
+        public bool IsAzeriteEmpoweredItem() { return GetTypeId() == TypeId.AzeriteEmpoweredItem; }
        public bool IsCurrencyToken() { return GetTemplate().IsCurrencyToken(); }
        public bool IsBroken() { return m_itemData.MaxDurability > 0 && m_itemData.Durability == 0; }
        public void SetDurability(uint durability) { SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.Durability), durability); }
@@ -2863,11 +2852,18 @@ namespace Game.Entities
            RelicType = -1;
            HasFixedLevel = false;
            RequiredLevelOverride = 0;
+            AzeriteTierUnlockSetId = 0;
+
+            AzeriteEmpoweredItemRecord azeriteEmpoweredItem = Global.DB2Mgr.GetAzeriteEmpoweredItem(proto.GetId());
+            if (azeriteEmpoweredItem != null)
+                AzeriteTierUnlockSetId = azeriteEmpoweredItem.AzeriteTierUnlockSetID;
+
            CanDisenchant = !proto.GetFlags().HasAnyFlag(ItemFlags.NoDisenchant);
            CanScrap = proto.GetFlags4().HasAnyFlag(ItemFlags4.Scrapable);

            _state.AppearanceModPriority = int.MaxValue;
            _state.ScalingStatDistributionPriority = int.MaxValue;
+            _state.AzeriteTierUnlockSetPriority = int.MaxValue;
            _state.HasQualityBonus = false;
        }

@@ -2876,17 +2872,18 @@ namespace Game.Entities
            if (itemInstance.ItemBonus.HasValue)
            {
                foreach (uint bonusListID in itemInstance.ItemBonus.Value.BonusListIDs)
-                {
-                    var bonuses = Global.DB2Mgr.GetItemBonusList(bonusListID);
-                    if (bonuses != null)
-                    {
-                        foreach (ItemBonusRecord bonus in bonuses)
-                            AddBonus(bonus.BonusType, bonus.Value);
-                    }
-                }
+                    AddBonusList(bonusListID);
            }
        }

+        public void AddBonusList(uint bonusListId)
+        {
+            var bonuses = Global.DB2Mgr.GetItemBonusList(bonusListId);
+            if (bonuses != null)
+                foreach (ItemBonusRecord bonus in bonuses)
+                    AddBonus(bonus.BonusType, bonus.Value);
+        }
+
        public void AddBonus(ItemBonusType type, int[] values)
        {
            switch (type)
@@ -2962,6 +2959,13 @@ namespace Game.Entities
                case ItemBonusType.OverrideRequiredLevel:
                    RequiredLevelOverride = values[0];
                    break;
+                case ItemBonusType.AzeriteTierUnlockSet:
+                    if (values[1] < _state.AzeriteTierUnlockSetPriority)
+                    {
+                        AzeriteTierUnlockSetId = (uint)values[0];
+                        _state.AzeriteTierUnlockSetPriority = values[1];
+                    }
+                    break;
                case ItemBonusType.OverrideCanDisenchant:
                    CanDisenchant = values[0] != 0;
                    break;
@@ -2989,6 +2993,7 @@ namespace Game.Entities
        public ushort[] GemRelicRankBonus = new ushort[ItemConst.MaxGemSockets];
        public int RelicType;
        public int RequiredLevelOverride;
+        public uint AzeriteTierUnlockSetId;
        public bool CanDisenchant;
        public bool CanScrap;
        public bool HasFixedLevel;
@@ -2998,6 +3003,7 @@ namespace Game.Entities
        {
            public int AppearanceModPriority;
            public int ScalingStatDistributionPriority;
+            public int AzeriteTierUnlockSetPriority;
            public bool HasQualityBonus;
        }
    }
@@ -3017,12 +3023,19 @@ namespace Game.Entities
        public List<ArtifactPowerData> ArtifactPowers = new List<ArtifactPowerData>();
    }

+    public class AzeriteEmpoweredData
+    {
+        public Array<int> SelectedAzeritePowers = new Array<int>(SharedConst.MaxAzeriteEmpoweredTier);
+    }
+
    class ItemAdditionalLoadInfo
    {
        public ArtifactData Artifact;
        public AzeriteData AzeriteItem;
+        public AzeriteEmpoweredData AzeriteEmpoweredItem;

-        public static void Init(Dictionary<ulong, ItemAdditionalLoadInfo> loadInfo, SQLResult artifactResult, SQLResult azeriteItemResult, SQLResult azeriteItemMilestonePowersResult, SQLResult azeriteItemUnlockedEssencesResult)
+        public static void Init(Dictionary<ulong, ItemAdditionalLoadInfo> loadInfo, SQLResult artifactResult, SQLResult azeriteItemResult, SQLResult azeriteItemMilestonePowersResult, 
+            SQLResult azeriteItemUnlockedEssencesResult, SQLResult azeriteEmpoweredItemResult)
        {
            ItemAdditionalLoadInfo GetOrCreateLoadInfo(ulong guid)
            {
@@ -3091,7 +3104,7 @@ namespace Game.Entities
                            if (azeriteEssence == null || !Global.DB2Mgr.IsSpecSetMember(azeriteEssence.SpecSetID, specializationId))
                                continue;

-                            info.AzeriteItem.SelectedAzeriteEssences[i].AzeriteEssenceId[j] = azeriteEssence.ID;
+                            info.AzeriteItem.SelectedAzeriteEssences[i].AzeriteEssenceId[j] = azeriteEssence.Id;
                        }
                    }

@@ -3127,6 +3140,21 @@ namespace Game.Entities
                }
                while (azeriteItemUnlockedEssencesResult.NextRow());
            }
+
+            if (!azeriteEmpoweredItemResult.IsEmpty())
+            {
+                do
+                {
+                    ItemAdditionalLoadInfo info = GetOrCreateLoadInfo(azeriteEmpoweredItemResult.Read<ulong>(0));
+                    if (info.AzeriteEmpoweredItem == null)
+                        info.AzeriteEmpoweredItem = new AzeriteEmpoweredData();
+
+                    for (int i = 0; i < SharedConst.MaxAzeriteEmpoweredTier; ++i)
+                        if (CliDB.AzeritePowerStorage.ContainsKey(azeriteEmpoweredItemResult.Read<int>(1 + i)))
+                            info.AzeriteEmpoweredItem.SelectedAzeritePowers[i] = azeriteEmpoweredItemResult.Read<int>(1 + i);
+
+                } while (azeriteEmpoweredItemResult.NextRow());
+            }
        }
    }