Core/Items: Item bonus generation improvements

* Pass ItemContext to item creation wherever possible * Support scaling item levels with m+ keystone levels (not used currently) * Fixed item link validation when client sends it as default uninitialized bonus list with context only * Support scaling items depending on current active season (seasons not implemented) * Implemented content tuning redirection Port From (https://github.com/TrinityCore/TrinityCore/commit/0fb8765a6638fd947b59fce44d5c31251d0cdadd)
2023-06-21 09:19:40 -04:00
parent 378b0ffccd
commit 49a07ebcce
30 changed files with 796 additions and 336 deletions
@@ -1086,26 +1086,19 @@ namespace Game.Entities
                            {
                                case ItemEnchantmentType.BonusListID:
                                {
-                                    var bonusesEffect = Global.DB2Mgr.GetItemBonusList(gemEnchant.EffectArg[i]);
-                                    if (bonusesEffect != null)
-                                    {
-                                        foreach (ItemBonusRecord itemBonus in bonusesEffect)
-                                            if (itemBonus.BonusType == ItemBonusType.ItemLevel)
-
-                                                _bonusData.GemItemLevelBonus[slot] += (uint)itemBonus.Value[0];
-                                    }
+                                    foreach (var itemBonus in ItemBonusMgr.GetItemBonuses(gemEnchant.EffectArg[i]))
+                                        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)
+                                    uint bonusListId = ItemBonusMgr.GetItemBonusListForItemLevelDelta((short)Global.DB2Mgr.GetCurveValueAt((uint)Curves.ArtifactRelicItemLevelBonus, gemBaseItemLevel + gemBonus.ItemLevelBonus));
+                                    if (bonusListId != 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];
+                                        foreach (var itemBonus in ItemBonusMgr.GetItemBonuses(bonusListId))
+                                            if (itemBonus.BonusType == ItemBonusType.ItemLevel)
+                                                _bonusData.GemItemLevelBonus[slot] += (uint)itemBonus.Value[0];
                                    }
                                    break;
                                }
@@ -1195,22 +1188,25 @@ namespace Game.Entities
            owner.SendPacket(itemTimeUpdate);
        }

-        public static Item CreateItem(uint item, uint count, ItemContext context, Player player = null)
+        public static Item CreateItem(uint itemEntry, uint count, ItemContext context, Player player = null, bool addDefaultBonuses = true)
        {
            if (count < 1)
                return null;                                        //don't create item at zero count

-            var pProto = Global.ObjectMgr.GetItemTemplate(item);
+            var pProto = Global.ObjectMgr.GetItemTemplate(itemEntry);
            if (pProto != null)
            {
                if (count > pProto.GetMaxStackSize())
                    count = pProto.GetMaxStackSize();

-                Item pItem = Bag.NewItemOrBag(pProto);
-                if (pItem.Create(Global.ObjectMgr.GetGenerator(HighGuid.Item).Generate(), item, context, player))
+                Item item = Bag.NewItemOrBag(pProto);
+                if (item.Create(Global.ObjectMgr.GetGenerator(HighGuid.Item).Generate(), itemEntry, context, player))
                {
-                    pItem.SetCount(count);
-                    return pItem;
+                    item.SetCount(count);
+                    if (addDefaultBonuses)
+                        item.SetBonuses(ItemBonusMgr.GetBonusListsForItem(itemEntry, new(context)));
+
+                    return item;
                }
            }

@@ -1219,7 +1215,7 @@ namespace Game.Entities

        public Item CloneItem(uint count, Player player = null)
        {
-            Item newItem = CreateItem(GetEntry(), count, GetContext(), player);
+            Item newItem = CreateItem(GetEntry(), count, GetContext(), player, false);
            if (newItem == null)
                return null;

@@ -1227,6 +1223,7 @@ namespace Game.Entities
            newItem.SetGiftCreator(GetGiftCreator());
            newItem.ReplaceAllItemFlags((ItemFieldFlags)(m_itemData.DynamicFlags & ~(uint)(ItemFieldFlags.Refundable | ItemFieldFlags.BopTradeable)));
            newItem.SetExpiration(m_itemData.Expiration);
+            newItem.SetBonuses(m_itemData.ItemBonusKey.GetValue().BonusListIDs);
            // player CAN be NULL in which case we must not update random properties because that accesses player's item update queue
            if (player != null)
                newItem.SetItemRandomBonusList(m_randomBonusListId);
@@ -2072,26 +2069,21 @@ namespace Game.Entities
        }

        public List<uint> GetBonusListIDs() { return m_itemData.ItemBonusKey.GetValue().BonusListIDs; }
-        
+
        public void AddBonuses(uint bonusListID)
        {
            var bonusListIDs = GetBonusListIDs();
            if (bonusListIDs.Contains(bonusListID))
                return;

-            var bonuses = Global.DB2Mgr.GetItemBonusList(bonusListID);
-            if (bonuses != null)
-            {
-                ItemBonusKey itemBonusKey = new();
-                itemBonusKey.ItemID = GetEntry();
-                itemBonusKey.BonusListIDs = GetBonusListIDs();
-                itemBonusKey.BonusListIDs.Add(bonusListID);
-                SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.ItemBonusKey), itemBonusKey);
-                foreach (ItemBonusRecord bonus in bonuses)
-                    _bonusData.AddBonus(bonus.BonusType, bonus.Value);
-
-                SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.ItemAppearanceModID), (byte)_bonusData.AppearanceModID);
-            }
+            ItemBonusKey itemBonusKey = new();
+            itemBonusKey.ItemID = GetEntry();
+            itemBonusKey.BonusListIDs = GetBonusListIDs();
+            itemBonusKey.BonusListIDs.Add(bonusListID);
+            SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.ItemBonusKey), itemBonusKey);
+            foreach (var bonus in ItemBonusMgr.GetItemBonuses(bonusListID))
+                _bonusData.AddBonus(bonus.BonusType, bonus.Value);
+            SetUpdateFieldValue(m_values.ModifyValue(m_itemData).ModifyValue(m_itemData.ItemAppearanceModID), (byte)_bonusData.AppearanceModID);
        }

        public void SetBonuses(List<uint> bonusListIDs)
@@ -2906,10 +2898,8 @@ namespace Game.Entities

        public void AddBonusList(uint bonusListId)
        {
-            var bonuses = Global.DB2Mgr.GetItemBonusList(bonusListId);
-            if (bonuses != null)
-                foreach (ItemBonusRecord bonus in bonuses)
-                    AddBonus(bonus.BonusType, bonus.Value);
+            foreach (var bonus in ItemBonusMgr.GetItemBonuses(bonusListId))
+                AddBonus(bonus.BonusType, bonus.Value);
        }

        public void AddBonus(ItemBonusType type, int[] values)
@@ -0,0 +1,506 @@
+// Copyright (c) CypherCore <http://github.com/CypherCore> All rights reserved.
+// Licensed under the GNU GENERAL PUBLIC LICENSE. See LICENSE file in the project root for full license information.
+
+using Framework.Constants;
+using Game.DataStorage;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace Game.Entities
+{
+    class ItemBonusMgr
+    {
+        static MultiMap<uint /*azeriteUnlockMappingSetId*/, AzeriteUnlockMappingRecord> _azeriteUnlockMappings = new();
+        static MultiMap<uint /*itemBonusTreeId*/, ChallengeModeItemBonusOverrideRecord> _challengeModeItemBonusOverrides = new();
+        static MultiMap<uint /*itemBonusListId*/, ItemBonusRecord> _itemBonusLists = new();
+        static MultiMap<int, ItemBonusListGroupEntryRecord> _itemBonusListGroupEntries = new();
+        static Dictionary<short /*itemLevelDelta*/, uint /*itemBonusListId*/> _itemLevelDeltaToBonusListContainer = new();
+        static SortedMultiMap<uint /*itemLevelSelectorQualitySetId*/, ItemLevelSelectorQualityRecord> _itemLevelQualitySelectorQualities = new();
+        static MultiMap<uint /*itemBonusTreeId*/, ItemBonusTreeNodeRecord> _itemBonusTrees = new();
+        static MultiMap<uint /*itemId*/, uint /*itemBonusTreeId*/> _itemToBonusTree = new();
+
+        public static void Load()
+        {
+            foreach (var azeriteUnlockMapping in CliDB.AzeriteUnlockMappingStorage.Values)
+                _azeriteUnlockMappings.Add(azeriteUnlockMapping.AzeriteUnlockMappingSetID, azeriteUnlockMapping);
+
+            foreach (var challengeModeItemBonusOverride in CliDB.ChallengeModeItemBonusOverrideStorage.Values)
+                _challengeModeItemBonusOverrides.Add(challengeModeItemBonusOverride.SrcItemBonusTreeID, challengeModeItemBonusOverride);
+
+            foreach (var bonus in CliDB.ItemBonusStorage.Values)
+                _itemBonusLists.Add(bonus.ParentItemBonusListID, bonus);
+
+            foreach (var bonusListGroupEntry in CliDB.ItemBonusListGroupEntryStorage.Values)
+                _itemBonusListGroupEntries.Add(bonusListGroupEntry.ItemBonusListGroupID, bonusListGroupEntry);
+
+            foreach (var itemBonusListLevelDelta in CliDB.ItemBonusListLevelDeltaStorage.Values)
+                _itemLevelDeltaToBonusListContainer[itemBonusListLevelDelta.ItemLevelDelta] = itemBonusListLevelDelta.Id;
+
+            foreach (var itemLevelSelectorQuality in CliDB.ItemLevelSelectorQualityStorage.Values)
+                _itemLevelQualitySelectorQualities.Add(itemLevelSelectorQuality.ParentILSQualitySetID, itemLevelSelectorQuality);
+
+            foreach (var bonusTreeNode in CliDB.ItemBonusTreeNodeStorage.Values)
+                _itemBonusTrees.Add(bonusTreeNode.ParentItemBonusTreeID, bonusTreeNode);
+
+            foreach (var itemBonusTreeAssignment in CliDB.ItemXBonusTreeStorage.Values)
+                _itemToBonusTree.Add(itemBonusTreeAssignment.ItemID, itemBonusTreeAssignment.ItemBonusTreeID);
+        }
+
+        public static ItemContext GetContextForPlayer(MapDifficultyRecord mapDifficulty, Player player)
+        {
+            ItemContext evalContext(ItemContext currentContext, ItemContext newContext)
+            {
+                if (newContext == ItemContext.None)
+                    newContext = currentContext;
+                else if (newContext == ItemContext.ForceToNone)
+                    newContext = ItemContext.None;
+                return newContext;
+            }
+
+            ItemContext context = ItemContext.None;
+            var difficulty = CliDB.DifficultyStorage.LookupByKey(mapDifficulty.DifficultyID);
+            if (difficulty != null)
+                context = evalContext(context, (ItemContext)difficulty.ItemContext);
+
+            context = evalContext(context, (ItemContext)mapDifficulty.ItemContext);
+
+            if (mapDifficulty.ItemContextPickerID != 0)
+            {
+                uint contentTuningId = Global.DB2Mgr.GetRedirectedContentTuningId((uint)mapDifficulty.ContentTuningID, player.m_playerData.CtrOptions.GetValue().ContentTuningConditionMask);
+
+                ItemContextPickerEntryRecord selectedPickerEntry = null;
+                foreach (var itemContextPickerEntry in CliDB.ItemContextPickerEntryStorage.Values)
+                {
+                    if (itemContextPickerEntry.ItemContextPickerID != mapDifficulty.ItemContextPickerID)
+                        continue;
+
+                    if (itemContextPickerEntry.PVal <= 0)
+                        continue;
+
+                    bool meetsPlayerCondition = false;
+                    if (player)
+                    {
+                        var playerCondition = CliDB.PlayerConditionStorage.LookupByKey(itemContextPickerEntry.PlayerConditionID);
+                        if (playerCondition != null)
+                            meetsPlayerCondition = ConditionManager.IsPlayerMeetingCondition(player, playerCondition);
+                    }
+
+                    if ((itemContextPickerEntry.Flags & 0x1) != 0)
+                        meetsPlayerCondition = !meetsPlayerCondition;
+
+                    if (!meetsPlayerCondition)
+                        continue;
+
+                    if (itemContextPickerEntry.LabelID != 0 && !Global.DB2Mgr.HasContentTuningLabel(contentTuningId, itemContextPickerEntry.LabelID))
+                        continue;
+
+                    if (selectedPickerEntry == null || selectedPickerEntry.OrderIndex < itemContextPickerEntry.OrderIndex)
+                        selectedPickerEntry = itemContextPickerEntry;
+                }
+
+                if (selectedPickerEntry != null)
+                    context = evalContext(context, (ItemContext)selectedPickerEntry.ItemCreationContext);
+            }
+
+            return context;
+        }
+
+        public static List<ItemBonusRecord> GetItemBonuses(uint bonusListId)
+        {
+            return _itemBonusLists.LookupByKey(bonusListId);
+        }
+
+        public static uint GetItemBonusListForItemLevelDelta(short delta)
+        {
+            return _itemLevelDeltaToBonusListContainer.LookupByKey(delta);
+        }
+
+        public static bool CanApplyBonusTreeToItem(ItemTemplate itemTemplate, uint itemBonusTreeId, ItemBonusGenerationParams generationParams)
+        {
+            var bonusTree = CliDB.ItemBonusTreeStorage.LookupByKey(itemBonusTreeId);
+            if (bonusTree != null)
+            {
+                if (bonusTree.InventoryTypeSlotMask != 0)
+                    if ((1 << (int)itemTemplate.GetInventoryType() & bonusTree.InventoryTypeSlotMask) == 0)
+                        return false;
+
+                if ((bonusTree.Flags & 0x8) != 0 && !itemTemplate.HasFlag(ItemFlags2.CasterWeapon))
+                    return false;
+                if ((bonusTree.Flags & 0x10) != 0 && itemTemplate.HasFlag(ItemFlags2.CasterWeapon))
+                    return false;
+                if ((bonusTree.Flags & 0x20) != 0 && !itemTemplate.HasFlag(ItemFlags4.CcTrinket))
+                    return false;
+                if ((bonusTree.Flags & 0x40) != 0 && itemTemplate.HasFlag(ItemFlags4.CcTrinket))
+                    return false;
+
+                if ((bonusTree.Flags & 0x4) != 0)
+                    return true;
+            }
+
+            var bonusTreeNodes = _itemBonusTrees.LookupByKey(itemBonusTreeId);
+            if (!bonusTreeNodes.Empty())
+            {
+                bool anyNodeMatched = false;
+                foreach (var bonusTreeNode in bonusTreeNodes)
+                {
+                    if (bonusTreeNode.MinMythicPlusLevel > 0)
+                        continue;
+
+                    ItemContext nodeContext = (ItemContext)bonusTreeNode.ItemContext;
+                    if (nodeContext == ItemContext.None || nodeContext == generationParams.Context)
+                    {
+                        if (anyNodeMatched)
+                            return false;
+
+                        anyNodeMatched = true;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public static uint GetBonusTreeIdOverride(uint itemBonusTreeId, ItemBonusGenerationParams generationParams)
+        {
+            // TODO: configure seasons globally
+            var mythicPlusSeason = CliDB.MythicPlusSeasonStorage.LookupByKey(0);
+            if (mythicPlusSeason != null)
+            {
+                int selectedLevel = -1;
+                int selectedMilestoneSeason = -1;
+                ChallengeModeItemBonusOverrideRecord selectedItemBonusOverride = null;
+                foreach (var itemBonusOverride in _challengeModeItemBonusOverrides.LookupByKey(itemBonusTreeId))
+                {
+                    if (itemBonusOverride.Type != 0)
+                        continue;
+
+                    if (itemBonusOverride.Value > generationParams.MythicPlusKeystoneLevel.GetValueOrDefault(-1))
+                        continue;
+
+                    if (itemBonusOverride.MythicPlusSeasonID != 0)
+                    {
+                        var overrideSeason = CliDB.MythicPlusSeasonStorage.LookupByKey(itemBonusOverride.MythicPlusSeasonID);
+                        if (overrideSeason == null)
+                            continue;
+
+                        if (mythicPlusSeason.MilestoneSeason < overrideSeason.MilestoneSeason)
+                            continue;
+
+                        if (selectedMilestoneSeason > overrideSeason.MilestoneSeason)
+                            continue;
+
+                        if (selectedMilestoneSeason == overrideSeason.MilestoneSeason)
+                            if (selectedLevel > itemBonusOverride.Value)
+                                continue;
+
+                        selectedMilestoneSeason = overrideSeason.MilestoneSeason;
+                    }
+                    else if (selectedLevel > itemBonusOverride.Value)
+                        continue;
+
+                    selectedLevel = itemBonusOverride.Value;
+                    selectedItemBonusOverride = itemBonusOverride;
+                }
+
+                if (selectedItemBonusOverride != null && selectedItemBonusOverride.DstItemBonusTreeID != 0)
+                    itemBonusTreeId = (uint)selectedItemBonusOverride.DstItemBonusTreeID;
+            }
+
+            // TODO: configure seasons globally
+            var pvpSeason = CliDB.PvpSeasonStorage.LookupByKey(0);
+            if (pvpSeason != null)
+            {
+                int selectedLevel = -1;
+                int selectedMilestoneSeason = -1;
+                ChallengeModeItemBonusOverrideRecord selectedItemBonusOverride = null;
+                foreach (var itemBonusOverride in _challengeModeItemBonusOverrides.LookupByKey(itemBonusTreeId))
+                {
+                    if (itemBonusOverride.Type != 1)
+                        continue;
+
+                    if (itemBonusOverride.Value > generationParams.PvpTier.GetValueOrDefault(-1))
+                        continue;
+
+                    if (itemBonusOverride.PvPSeasonID != 0)
+                    {
+                        var overrideSeason = CliDB.PvpSeasonStorage.LookupByKey(itemBonusOverride.PvPSeasonID);
+                        if (overrideSeason == null)
+                            continue;
+
+                        if (pvpSeason.MilestoneSeason < overrideSeason.MilestoneSeason)
+                            continue;
+
+                        if (selectedMilestoneSeason > overrideSeason.MilestoneSeason)
+                            continue;
+
+                        if (selectedMilestoneSeason == overrideSeason.MilestoneSeason)
+                            if (selectedLevel > itemBonusOverride.Value)
+                                continue;
+
+                        selectedMilestoneSeason = overrideSeason.MilestoneSeason;
+                    }
+                    else if (selectedLevel > itemBonusOverride.Value)
+                        continue;
+
+                    selectedLevel = itemBonusOverride.Value;
+                    selectedItemBonusOverride = itemBonusOverride;
+                }
+
+                if (selectedItemBonusOverride != null && selectedItemBonusOverride.DstItemBonusTreeID != 0)
+                    itemBonusTreeId = (uint)selectedItemBonusOverride.DstItemBonusTreeID;
+            }
+
+            return itemBonusTreeId;
+        }
+
+        public static void ApplyBonusTreeHelper(ItemTemplate itemTemplate, uint itemBonusTreeId, ItemBonusGenerationParams generationParams, int sequenceLevel, ref uint itemLevelSelectorId, List<uint> bonusListIDs)
+        {
+            uint originalItemBonusTreeId = itemBonusTreeId;
+
+            // override bonus tree with season specific values
+            itemBonusTreeId = GetBonusTreeIdOverride(itemBonusTreeId, generationParams);
+
+            if (!CanApplyBonusTreeToItem(itemTemplate, itemBonusTreeId, generationParams))
+                return;
+
+            var treeList = _itemBonusTrees.LookupByKey(itemBonusTreeId);
+            if (treeList.Empty())
+                return;
+
+            foreach (var bonusTreeNode in treeList)
+            {
+                ItemContext nodeContext = (ItemContext)bonusTreeNode.ItemContext;
+                ItemContext requiredContext = nodeContext != ItemContext.ForceToNone ? nodeContext : ItemContext.None;
+                if (nodeContext != ItemContext.None && generationParams.Context != requiredContext)
+                    continue;
+
+                if (generationParams.MythicPlusKeystoneLevel != 0)
+                {
+                    if (bonusTreeNode.MinMythicPlusLevel != 0 && generationParams.MythicPlusKeystoneLevel < bonusTreeNode.MinMythicPlusLevel)
+                        continue;
+
+                    if (bonusTreeNode.MaxMythicPlusLevel != 0 && generationParams.MythicPlusKeystoneLevel > bonusTreeNode.MaxMythicPlusLevel)
+                        continue;
+                }
+
+                if (bonusTreeNode.ChildItemBonusTreeID != 0)
+                    ApplyBonusTreeHelper(itemTemplate, bonusTreeNode.ChildItemBonusTreeID, generationParams, sequenceLevel, ref itemLevelSelectorId, bonusListIDs);
+                else if (bonusTreeNode.ChildItemBonusListID != 0)
+                    bonusListIDs.Add(bonusTreeNode.ChildItemBonusListID);
+                else if (bonusTreeNode.ChildItemLevelSelectorID != 0)
+                    itemLevelSelectorId = bonusTreeNode.ChildItemLevelSelectorID;
+                else if (bonusTreeNode.ChildItemBonusListGroupID != 0)
+                {
+                    int resolvedSequenceLevel = sequenceLevel;
+                    switch (originalItemBonusTreeId)
+                    {
+                        case 4001:
+                            resolvedSequenceLevel = 1;
+                            break;
+                        case 4079:
+                            if (generationParams.MythicPlusKeystoneLevel != 0)
+                            {
+                                switch (bonusTreeNode.IblGroupPointsModSetID)
+                                {
+                                    case 2909: // MythicPlus_End_of_Run levels 2-8
+                                        resolvedSequenceLevel = (int)Global.DB2Mgr.GetCurveValueAt(62951, generationParams.MythicPlusKeystoneLevel.Value);
+                                        break;
+                                    case 2910: // MythicPlus_End_of_Run levels 9-16
+                                        resolvedSequenceLevel = (int)Global.DB2Mgr.GetCurveValueAt(62952, generationParams.MythicPlusKeystoneLevel.Value);
+                                        break;
+                                    case 2911: // MythicPlus_End_of_Run levels 17-20
+                                        resolvedSequenceLevel = (int)Global.DB2Mgr.GetCurveValueAt(62954, generationParams.MythicPlusKeystoneLevel.Value);
+                                        break;
+                                    case 3007: // MythicPlus_Jackpot (weekly reward) levels 2-7
+                                        resolvedSequenceLevel = (int)Global.DB2Mgr.GetCurveValueAt(64388, generationParams.MythicPlusKeystoneLevel.Value);
+                                        break;
+                                    case 3008: // MythicPlus_Jackpot (weekly reward) levels 8-15
+                                        resolvedSequenceLevel = (int)Global.DB2Mgr.GetCurveValueAt(64389, generationParams.MythicPlusKeystoneLevel.Value);
+                                        break;
+                                    case 3009: // MythicPlus_Jackpot (weekly reward) levels 16-20
+                                        resolvedSequenceLevel = (int)Global.DB2Mgr.GetCurveValueAt(64395, generationParams.MythicPlusKeystoneLevel.Value);
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            }
+                            break;
+                        case 4125:
+                            resolvedSequenceLevel = 2;
+                            break;
+                        case 4126:
+                            resolvedSequenceLevel = 3;
+                            break;
+                        case 4127:
+                            resolvedSequenceLevel = 4;
+                            break;
+                        case 4128:
+                            switch (generationParams.Context)
+                            {
+                                case ItemContext.RaidNormal:
+                                case ItemContext.RaidRaidFinder:
+                                case ItemContext.RaidHeroic:
+                                    resolvedSequenceLevel = 2;
+                                    break;
+                                case ItemContext.RaidMythic:
+                                    resolvedSequenceLevel = 6;
+                                    break;
+                                default:
+                                    break;
+                            }
+                            break;
+                        case 4140:
+                            switch (generationParams.Context)
+                            {
+                                case ItemContext.DungeonNormal:
+                                    resolvedSequenceLevel = 2;
+                                    break;
+                                case ItemContext.DungeonHeroic:
+                                    resolvedSequenceLevel = 4;
+                                    break;
+                                default:
+                                    break;
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+
+                    foreach (var bonusListGroupEntry in _itemBonusListGroupEntries.LookupByKey(bonusTreeNode.ChildItemBonusListGroupID))
+                    {
+                        if ((resolvedSequenceLevel > 0 || bonusListGroupEntry.SequenceValue <= 0) && resolvedSequenceLevel != bonusListGroupEntry.SequenceValue)
+                            continue;
+
+                        itemLevelSelectorId = (uint)bonusListGroupEntry.ItemLevelSelectorID;
+                        bonusListIDs.Add((uint)bonusListGroupEntry.ItemBonusListID);
+                        break;
+                    }
+                }
+            }
+        }
+
+        public static uint GetAzeriteUnlockBonusList(ushort azeriteUnlockMappingSetId, ushort minItemLevel, InventoryType inventoryType)
+        {
+            AzeriteUnlockMappingRecord selectedAzeriteUnlockMapping = null;
+            foreach (var azeriteUnlockMapping in _azeriteUnlockMappings.LookupByKey(azeriteUnlockMappingSetId))
+            {
+                if (minItemLevel < azeriteUnlockMapping.ItemLevel)
+                    continue;
+
+                if (selectedAzeriteUnlockMapping != null && selectedAzeriteUnlockMapping.ItemLevel > azeriteUnlockMapping.ItemLevel)
+                    continue;
+
+                selectedAzeriteUnlockMapping = azeriteUnlockMapping;
+            }
+
+            if (selectedAzeriteUnlockMapping != null)
+            {
+                switch (inventoryType)
+                {
+                    case InventoryType.Head:
+                        return selectedAzeriteUnlockMapping.ItemBonusListHead;
+                    case InventoryType.Shoulders:
+                        return selectedAzeriteUnlockMapping.ItemBonusListShoulders;
+                    case InventoryType.Chest:
+                    case InventoryType.Robe:
+                        return selectedAzeriteUnlockMapping.ItemBonusListChest;
+                    default:
+                        break;
+                }
+            }
+
+            return 0;
+        }
+
+        public static List<uint> GetBonusListsForItem(uint itemId, ItemBonusGenerationParams generationParams)
+        {
+            List<uint> bonusListIDs = new();
+
+            ItemTemplate itemTemplate = Global.ObjectMgr.GetItemTemplate(itemId);
+            if (itemTemplate == null)
+                return bonusListIDs;
+
+            uint itemLevelSelectorId = 0;
+
+            foreach (var itemBonusTreeId in _itemToBonusTree.LookupByKey(itemId))
+                ApplyBonusTreeHelper(itemTemplate, itemBonusTreeId, generationParams, 0, ref itemLevelSelectorId, bonusListIDs);
+
+            var selector = CliDB.ItemLevelSelectorStorage.LookupByKey(itemLevelSelectorId);
+            if (selector != null)
+            {
+                short delta = (short)(selector.MinItemLevel - itemTemplate.GetBaseItemLevel());
+
+                uint bonus = GetItemBonusListForItemLevelDelta(delta);
+                if (bonus != 0)
+                    bonusListIDs.Add(bonus);
+
+                var selectorQualitySet = CliDB.ItemLevelSelectorQualitySetStorage.LookupByKey(selector.ItemLevelSelectorQualitySetID);
+                if (selectorQualitySet != null)
+                {
+                    var itemSelectorQualities = _itemLevelQualitySelectorQualities.LookupByKey(selector.ItemLevelSelectorQualitySetID);
+                    if (!itemSelectorQualities.Empty())
+                    {
+                        ItemQuality quality = ItemQuality.Uncommon;
+                        if (selector.MinItemLevel >= selectorQualitySet.IlvlEpic)
+                            quality = ItemQuality.Epic;
+                        else if (selector.MinItemLevel >= selectorQualitySet.IlvlRare)
+                            quality = ItemQuality.Rare;
+
+                        var itemSelectorQuality = itemSelectorQualities.First(record => record.Quality < (sbyte)quality);
+
+                        if (itemSelectorQuality != null)
+                            bonusListIDs.Add(itemSelectorQuality.QualityItemBonusListID);
+                    }
+                }
+
+                uint azeriteUnlockBonusListId = GetAzeriteUnlockBonusList(selector.AzeriteUnlockMappingSet, selector.MinItemLevel, itemTemplate.GetInventoryType());
+                if (azeriteUnlockBonusListId != 0)
+                    bonusListIDs.Add(azeriteUnlockBonusListId);
+            }
+
+            return bonusListIDs;
+        }
+
+        public static void VisitItemBonusTree(uint itemBonusTreeId, Action<ItemBonusTreeNodeRecord> visitor)
+        {
+            var treeItr = _itemBonusTrees.LookupByKey(itemBonusTreeId);
+            if (treeItr.Empty())
+                return;
+
+            foreach (var bonusTreeNode in treeItr)
+            {
+                visitor(bonusTreeNode);
+                if (bonusTreeNode.ChildItemBonusTreeID != 0)
+                    VisitItemBonusTree(bonusTreeNode.ChildItemBonusTreeID, visitor);
+            }
+        }
+
+        public static List<uint> GetAllBonusListsForTree(uint itemBonusTreeId)
+        {
+            List<uint> bonusListIDs = new();
+            VisitItemBonusTree(itemBonusTreeId, bonusTreeNode =>
+            {
+                if (bonusTreeNode.ChildItemBonusListID != 0)
+                    bonusListIDs.Add(bonusTreeNode.ChildItemBonusListID);
+            });
+
+            return bonusListIDs;
+        }
+
+        public struct ItemBonusGenerationParams
+        {
+            public ItemBonusGenerationParams(ItemContext context, int? mythicPlusKeystoneLevel = null, int? pvpTier = null)
+            {
+                Context = context;
+                MythicPlusKeystoneLevel = mythicPlusKeystoneLevel;
+                PvpTier = pvpTier;
+            }
+
+            public ItemContext Context;
+            public int? MythicPlusKeystoneLevel;
+            public int? PvpTier;
+        }
+    }
+}
@@ -32,7 +32,7 @@ namespace Game.Entities
                uint bonusListId = result.Read<uint>(1);
                float chance = result.Read<float>(2);

-                if (Global.DB2Mgr.GetItemBonusList(bonusListId) == null)
+                if (ItemBonusMgr.GetItemBonuses(bonusListId).Empty())
                {
                    Log.outError(LogFilter.Sql, $"Bonus list {bonusListId} used in `item_random_bonus_list_template` by id {id} doesn't have exist in ItemBonus.db2");
                    continue;