Core: Updated to 11.2.5.63704

Port From (https://github.com/TrinityCore/TrinityCore/commit/53068a94e88991ae7196fb247df4b7ca2e47e554)
2025-12-16 13:57:09 -05:00
parent ed33a88776
commit 3a890782b5
57 changed files with 3079 additions and 2630 deletions
@@ -358,19 +358,19 @@ namespace Game.Entities

            SetActiveTalentGroup(spec.OrderIndex);
            SetPrimarySpecialization(spec.Id);
-            int specTraitConfigIndex = m_activePlayerData.TraitConfigs.FindIndexIf(traitConfig =>
+            var specTraitConfig = m_activePlayerData.TraitConfigs.FindIf(traitConfig =>
            {
                return (TraitConfigType)(int)traitConfig.Type == TraitConfigType.Combat
                    && traitConfig.ChrSpecializationID == spec.Id
                    && ((TraitCombatConfigFlags)(int)traitConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) != TraitCombatConfigFlags.None;
-            });
-            if (specTraitConfigIndex >= 0)
+            }).Item2;
+
+            if (specTraitConfig != null)
            {
-                TraitConfig activeTraitConfig = m_activePlayerData.TraitConfigs[specTraitConfigIndex];
-                SetActiveCombatTraitConfigID(activeTraitConfig.ID);
-                int activeSubTree = activeTraitConfig.SubTrees.FindIndexIf(subTree => subTree.Active != 0);
+                SetActiveCombatTraitConfigID(specTraitConfig.ID);
+                int activeSubTree = specTraitConfig.SubTrees.FindIndexIf(subTree => subTree.Active != 0);
                if (activeSubTree >= 0)
-                    SetCurrentCombatTraitConfigSubTreeID(activeTraitConfig.SubTrees[activeSubTree].TraitSubTreeID);
+                    SetCurrentCombatTraitConfigSubTreeID(specTraitConfig.SubTrees[activeSubTree].TraitSubTreeID);
                else
                    SetCurrentCombatTraitConfigSubTreeID(0);
            }
@@ -497,16 +497,16 @@ namespace Game.Entities
            TraitConfig traitConfig = GetTraitConfig((int)(uint)m_activePlayerData.ActiveCombatTraitConfigID);
            if (traitConfig != null)
            {
-                int usedSavedTraitConfigIndex = m_activePlayerData.TraitConfigs.FindIndexIf(savedConfig =>
+                var usedSavedTraitConfigId = m_activePlayerData.TraitConfigs.FindIf(savedConfig =>
                {
                    return (TraitConfigType)(int)savedConfig.Type == TraitConfigType.Combat
                    && ((TraitCombatConfigFlags)(int)savedConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) == TraitCombatConfigFlags.None
                    && ((TraitCombatConfigFlags)(int)savedConfig.CombatConfigFlags & TraitCombatConfigFlags.SharedActionBars) == TraitCombatConfigFlags.None
                    && savedConfig.LocalIdentifier == traitConfig.LocalIdentifier;
-                });
+                }).Item1;

-                if (usedSavedTraitConfigIndex >= 0)
-                    traitConfigId = (uint)(int)m_activePlayerData.TraitConfigs[usedSavedTraitConfigIndex].ID;
+                if (usedSavedTraitConfigId != 0)
+                    traitConfigId = (uint)usedSavedTraitConfigId;
            }

            // load them asynchronously
@@ -873,45 +873,38 @@ namespace Game.Entities
        public void CreateTraitConfig(TraitConfigPacket traitConfig)
        {
            int configId = TraitMgr.GenerateNewTraitConfigId();
-            bool hasConfigId(int id)
-            {
-                return m_activePlayerData.TraitConfigs.FindIndexIf(config => config.ID == id) >= 0;
-            }
+            bool hasConfigId(int id) => m_activePlayerData.TraitConfigs.Get(id).Item1 != null;

            while (hasConfigId(configId))
                configId = TraitMgr.GenerateNewTraitConfigId();

            traitConfig.ID = configId;

-            int traitConfigIndex = m_activePlayerData.TraitConfigs.Size();
            AddTraitConfig(traitConfig);

+            TraitConfig entrySetter = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, configId);
            foreach (TraitEntry grantedEntry in TraitMgr.GetGrantedTraitEntriesForConfig(traitConfig, this))
            {
                var entryIndex = traitConfig.Entries.Find(entry => entry.TraitNodeID == grantedEntry.TraitNodeID && entry.TraitNodeEntryID == grantedEntry.TraitNodeEntryID);
                if (entryIndex == null)
-                {
-                    TraitConfig value = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, traitConfigIndex);
-                    AddDynamicUpdateFieldValue(value.ModifyValue(value.Entries), grantedEntry);
-                }
+                    AddDynamicUpdateFieldValue(entrySetter.ModifyValue(entrySetter.Entries), grantedEntry);
            }

-            m_traitConfigStates[(int)configId] = PlayerSpellState.Changed;
+            m_traitConfigStates[configId] = PlayerSpellState.Changed;
        }

        void AddTraitConfig(TraitConfigPacket traitConfig)
        {
-            var setter = new TraitConfig();
-            setter.ModifyValue(setter.ID).SetValue(traitConfig.ID);
-            setter.ModifyValue(setter.Name).SetValue(traitConfig.Name);
-            setter.ModifyValue(setter.Type).SetValue((int)traitConfig.Type);
-            setter.ModifyValue(setter.SkillLineID).SetValue((int)traitConfig.SkillLineID);
-            setter.ModifyValue(setter.ChrSpecializationID).SetValue(traitConfig.ChrSpecializationID);
-            setter.ModifyValue(setter.CombatConfigFlags).SetValue((int)traitConfig.CombatConfigFlags);
-            setter.ModifyValue(setter.LocalIdentifier).SetValue(traitConfig.LocalIdentifier);
-            setter.ModifyValue(setter.TraitSystemID).SetValue(traitConfig.TraitSystemID);

-            AddDynamicUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs), setter);
+            var setter = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, traitConfig.ID);
+            SetUpdateFieldValue(setter.ModifyValue(setter.ID), traitConfig.ID);
+            SetUpdateFieldValue(setter.ModifyValue(setter.Name), traitConfig.Name);
+            SetUpdateFieldValue(setter.ModifyValue(setter.Type), (int)traitConfig.Type);
+            SetUpdateFieldValue(setter.ModifyValue(setter.SkillLineID), (int)traitConfig.SkillLineID);
+            SetUpdateFieldValue(setter.ModifyValue(setter.ChrSpecializationID), traitConfig.ChrSpecializationID);
+            SetUpdateFieldValue(setter.ModifyValue(setter.CombatConfigFlags), (int)traitConfig.CombatConfigFlags);
+            SetUpdateFieldValue(setter.ModifyValue(setter.LocalIdentifier), traitConfig.LocalIdentifier);
+            SetUpdateFieldValue(setter.ModifyValue(setter.TraitSystemID), traitConfig.TraitSystemID);

            foreach (TraitEntryPacket traitEntry in traitConfig.Entries)
            {
@@ -945,17 +938,13 @@ namespace Game.Entities

        public TraitConfig GetTraitConfig(int configId)
        {
-            int index = m_activePlayerData.TraitConfigs.FindIndexIf(config => config.ID == configId);
-            if (index < 0)
-                return null;
-
-            return m_activePlayerData.TraitConfigs[index];
+            return m_activePlayerData.TraitConfigs.Get(configId).Item1;
        }

        public void UpdateTraitConfig(TraitConfigPacket newConfig, int savedConfigId, bool withCastTime)
        {
-            int index = m_activePlayerData.TraitConfigs.FindIndexIf(config => config.ID == newConfig.ID);
-            if (index < 0)
+            var oldConfig = m_activePlayerData.TraitConfigs.Get(newConfig.ID).Item1;
+            if (oldConfig == null)
                return;

            if (withCastTime)
@@ -966,14 +955,14 @@ namespace Game.Entities

            bool isActiveConfig = true;
            bool loadActionButtons = false;
-            switch ((TraitConfigType)(int)m_activePlayerData.TraitConfigs[index].Type)
+            switch ((TraitConfigType)(int)oldConfig.Type)
            {
                case TraitConfigType.Combat:
                    isActiveConfig = newConfig.ID == m_activePlayerData.ActiveCombatTraitConfigID;
-                    loadActionButtons = m_activePlayerData.TraitConfigs[index].LocalIdentifier != newConfig.LocalIdentifier;
+                    loadActionButtons = oldConfig.LocalIdentifier != newConfig.LocalIdentifier;
                    break;
                case TraitConfigType.Profession:
-                    isActiveConfig = HasSkill((uint)(int)m_activePlayerData.TraitConfigs[index].SkillLineID);
+                    isActiveConfig = HasSkill((uint)(int)oldConfig.SkillLineID);
                    break;
                default:
                    break;
@@ -981,7 +970,7 @@ namespace Game.Entities

            Action finalizeTraitConfigUpdate = () =>
            {
-                TraitConfig newTraitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, index);
+                TraitConfig newTraitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, newConfig.ID);
                SetUpdateFieldValue(newTraitConfig.ModifyValue(newTraitConfig.LocalIdentifier), newConfig.LocalIdentifier);

                ApplyTraitEntryChanges(newConfig.ID, newConfig, isActiveConfig, true);
@@ -1007,11 +996,11 @@ namespace Game.Entities

        void ApplyTraitEntryChanges(int editedConfigId, TraitConfigPacket newConfig, bool applyTraits, bool consumeCurrencies)
        {
-            int editedIndex = m_activePlayerData.TraitConfigs.FindIndexIf(config => config.ID == editedConfigId);
-            if (editedIndex < 0)
+            var editedConfig = m_activePlayerData.TraitConfigs.Get(editedConfigId).Item1;
+            if (editedConfig == null)
                return;

-            TraitConfig editedConfig = m_activePlayerData.TraitConfigs[editedIndex];
+            var configSetter = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedConfigId);

            // remove traits not found in new config
            SortedSet<int> entryIndicesToRemove = new(Comparer<int>.Create((a, b) => -a.CompareTo(b)));
@@ -1029,10 +1018,7 @@ namespace Game.Entities
            }

            foreach (int indexToRemove in entryIndicesToRemove)
-            {
-                TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedIndex);
-                RemoveDynamicUpdateFieldValue(traitConfig.ModifyValue(traitConfig.Entries), indexToRemove);
-            }
+                RemoveDynamicUpdateFieldValue(configSetter.ModifyValue(configSetter.Entries), indexToRemove);

            List<TraitEntryPacket> costEntries = new();

@@ -1045,14 +1031,13 @@ namespace Game.Entities
                    if (consumeCurrencies)
                        costEntries.Add(newEntry);

-                    TraitConfig newTraitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedIndex);
                    TraitEntry newUfEntry = new();
                    newUfEntry.TraitNodeID = newEntry.TraitNodeID;
                    newUfEntry.TraitNodeEntryID = newEntry.TraitNodeEntryID;
                    newUfEntry.Rank = newEntry.Rank;
                    newUfEntry.GrantedRanks = newEntry.GrantedRanks;

-                    AddDynamicUpdateFieldValue(newTraitConfig.ModifyValue(newTraitConfig.Entries), newUfEntry);
+                    AddDynamicUpdateFieldValue(configSetter.ModifyValue(configSetter.Entries), newUfEntry);

                    if (applyTraits)
                    {
@@ -1069,11 +1054,10 @@ namespace Game.Entities
                        costEntries.Add(newEntry);
                    }

-                    TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedIndex);
-                    TraitEntry traitEntry = traitConfig.ModifyValue(traitConfig.Entries, oldEntryIndex);
+                    TraitEntry traitEntry = configSetter.ModifyValue(configSetter.Entries, oldEntryIndex);
                    traitEntry.Rank = newEntry.Rank;
                    traitEntry.GrantedRanks = newEntry.GrantedRanks;
-                    SetUpdateFieldValue(traitConfig.Entries, oldEntryIndex, traitEntry);
+                    SetUpdateFieldValue(configSetter.Entries, oldEntryIndex, traitEntry);

                    if (applyTraits)
                        ApplyTraitEntry(newEntry.TraitNodeEntryID, newEntry.Rank, newEntry.GrantedRanks, true);
@@ -1126,19 +1110,17 @@ namespace Game.Entities
                    newUfSubTree.Active = newSubTree.Active ? 1 : 0u;
                    newUfSubTree.Entries = subTreeEntries;

-                    TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedIndex);
-                    AddDynamicUpdateFieldValue(traitConfig.ModifyValue(traitConfig.SubTrees), newUfSubTree);
+                    AddDynamicUpdateFieldValue(configSetter.ModifyValue(configSetter.SubTrees), newUfSubTree);
                }
                else
                {
-                    bool wasActive = m_activePlayerData.TraitConfigs[editedIndex].SubTrees[oldSubTreeIndex].Active != 0;
+                    bool wasActive = configSetter.SubTrees[oldSubTreeIndex].Active != 0;

-                    TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedIndex);
-                    TraitSubTreeCache traitSubTreeCache = traitConfig.ModifyValue(traitConfig.SubTrees, oldSubTreeIndex);
+                    TraitSubTreeCache traitSubTreeCache = configSetter.ModifyValue(configSetter.SubTrees, oldSubTreeIndex);

                    traitSubTreeCache.Active = newSubTree.Active ? 1 : 0u;
                    traitSubTreeCache.Entries = subTreeEntries;
-                    SetUpdateFieldValue(traitConfig.ModifyValue(traitConfig.SubTrees, oldSubTreeIndex), traitSubTreeCache);
+                    SetUpdateFieldValue(configSetter.ModifyValue(configSetter.SubTrees, oldSubTreeIndex), traitSubTreeCache);


                    if (applyTraits && wasActive != newSubTree.Active)
@@ -1163,16 +1145,13 @@ namespace Game.Entities

        public void RenameTraitConfig(int editedConfigId, string newName)
        {
-            int editedIndex = m_activePlayerData.TraitConfigs.FindIndexIf(traitConfig =>
-            {
-                return traitConfig.ID == editedConfigId
-                    && (TraitConfigType)(int)traitConfig.Type == TraitConfigType.Combat
-                    && ((TraitCombatConfigFlags)(int)traitConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) == TraitCombatConfigFlags.None;
-            });
-            if (editedIndex < 0)
+            TraitConfig editedConfig = m_activePlayerData.TraitConfigs.Get(editedConfigId).Item1;
+            if (editedConfig == null
+                || (TraitConfigType)(int)editedConfig.Type != TraitConfigType.Combat
+                || ((TraitCombatConfigFlags)(int)editedConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) != TraitCombatConfigFlags.None)
                return;

-            TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedIndex);
+            TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, editedConfigId);
            SetUpdateFieldValue(traitConfig.ModifyValue(traitConfig.Name), newName);

            m_traitConfigStates[editedConfigId] = PlayerSpellState.Changed;
@@ -1180,17 +1159,14 @@ namespace Game.Entities

        public void DeleteTraitConfig(int deletedConfigId)
        {
-            int deletedIndex = m_activePlayerData.TraitConfigs.FindIndexIf(traitConfig =>
-            {
-                return traitConfig.ID == deletedConfigId
-                    && (TraitConfigType)(int)traitConfig.Type == TraitConfigType.Combat
-                    && ((TraitCombatConfigFlags)(int)traitConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) == TraitCombatConfigFlags.None;
-            });
-            if (deletedIndex < 0)
+            TraitConfig deletedConfig = m_activePlayerData.TraitConfigs.Get(deletedConfigId).Item1;
+            if (deletedConfig == null
+                || (TraitConfigType)(int)deletedConfig.Type != TraitConfigType.Combat
+                || ((TraitCombatConfigFlags)(int)deletedConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) != TraitCombatConfigFlags.None)
                return;

-            RemoveDynamicUpdateFieldValue(m_values.ModifyValue(m_activePlayerData)
-                .ModifyValue(m_activePlayerData.TraitConfigs), deletedIndex);
+            RemoveMapUpdateFieldValue(m_values.ModifyValue(m_activePlayerData)
+                .ModifyValue(m_activePlayerData.TraitConfigs), deletedConfigId);

            m_traitConfigStates[deletedConfigId] = PlayerSpellState.Removed;
        }
@@ -1238,27 +1214,24 @@ namespace Game.Entities

        public void SetTraitConfigUseStarterBuild(int traitConfigId, bool useStarterBuild)
        {
-            int configIndex = m_activePlayerData.TraitConfigs.FindIndexIf(traitConfig =>
-            {
-                return traitConfig.ID == traitConfigId
-                    && (TraitConfigType)(int)traitConfig.Type == TraitConfigType.Combat
-                    && ((TraitCombatConfigFlags)(int)traitConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) != TraitCombatConfigFlags.None;
-            });
-            if (configIndex < 0)
+            TraitConfig config = m_activePlayerData.TraitConfigs.Get(traitConfigId).Item1;
+            if (config == null
+                || (TraitConfigType)(int)config.Type != TraitConfigType.Combat
+                || ((TraitCombatConfigFlags)(int)config.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) == TraitCombatConfigFlags.None)
                return;

-            bool currentlyUsesStarterBuild = ((TraitCombatConfigFlags)(int)m_activePlayerData.TraitConfigs[configIndex].CombatConfigFlags).HasFlag(TraitCombatConfigFlags.StarterBuild);
+            bool currentlyUsesStarterBuild = ((TraitCombatConfigFlags)(int)config.CombatConfigFlags).HasFlag(TraitCombatConfigFlags.StarterBuild);
            if (currentlyUsesStarterBuild == useStarterBuild)
                return;

            if (useStarterBuild)
            {
-                TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, configIndex);
+                TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, traitConfigId);
                SetUpdateFieldFlagValue(traitConfig.ModifyValue(traitConfig.CombatConfigFlags), (int)TraitCombatConfigFlags.StarterBuild);
            }
            else
            {
-                TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, configIndex);
+                TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, traitConfigId);
                RemoveUpdateFieldFlagValue(traitConfig.ModifyValue(traitConfig.CombatConfigFlags), (int)TraitCombatConfigFlags.StarterBuild);
            }

@@ -1267,20 +1240,17 @@ namespace Game.Entities

        public void SetTraitConfigUseSharedActionBars(int traitConfigId, bool usesSharedActionBars, bool isLastSelectedSavedConfig)
        {
-            int configIndex = m_activePlayerData.TraitConfigs.FindIndexIf(traitConfig =>
-            {
-                return traitConfig.ID == traitConfigId
-                    && (TraitConfigType)(int)traitConfig.Type == TraitConfigType.Combat
-                    && ((TraitCombatConfigFlags)(int)traitConfig.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) == TraitCombatConfigFlags.None;
-            });
-            if (configIndex < 0)
+            TraitConfig config = m_activePlayerData.TraitConfigs.Get(traitConfigId).Item1;
+            if (config == null
+                || (TraitConfigType)(int)config.Type != TraitConfigType.Combat
+                || ((TraitCombatConfigFlags)(int)config.CombatConfigFlags & TraitCombatConfigFlags.ActiveForSpec) != TraitCombatConfigFlags.None)
                return;

-            bool currentlyUsesSharedActionBars = ((TraitCombatConfigFlags)(int)m_activePlayerData.TraitConfigs[configIndex].CombatConfigFlags).HasFlag(TraitCombatConfigFlags.SharedActionBars);
+            bool currentlyUsesSharedActionBars = ((TraitCombatConfigFlags)(int)config.CombatConfigFlags).HasFlag(TraitCombatConfigFlags.SharedActionBars);
            if (currentlyUsesSharedActionBars == usesSharedActionBars)
                return;

-            TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, configIndex);
+            TraitConfig traitConfig = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TraitConfigs, traitConfigId);
            if (usesSharedActionBars)
            {
                SetUpdateFieldFlagValue(traitConfig.ModifyValue(traitConfig.CombatConfigFlags), (int)TraitCombatConfigFlags.SharedActionBars);