Core/Players: Implemented PlayerDataElementAccount, PlayerDataElementCharacter, PlayerDataFlagAccount and PlayerDataFlagCharacter

Port From (https://github.com/TrinityCore/TrinityCore/commit/60400d25f5fff2dabd4aa74bbdbc0d2370360a35)

Source/Game/Achievements/CriteriaHandler.cs

@@ -3713,6 +3713,14 @@ namespace Game.Achievements
                     if (referencePlayer.GetPositionZ() >= reqValue)
                         return false;
                     break;
+                case ModifierTreeType.PlayerDataFlagAccountIsSet: // 378
+                    if (!referencePlayer.HasDataFlagAccount(reqValue))
+                        return false;
+                    break;
+                case ModifierTreeType.PlayerDataFlagCharacterIsSet: // 379
+                    if (!referencePlayer.HasDataFlagCharacter(reqValue))
+                        return false;
+                    break;
                 case ModifierTreeType.PlayerIsOnMapWithExpansion: // 380
                 {
                     var mapEntry = referencePlayer.GetMap().GetEntry();
@@ -3747,6 +3755,16 @@ namespace Game.Achievements
                         return false;
                     break;
                 }
+                case ModifierTreeType.PlayerDataElementCharacterBetween: // 390
+                {
+                    var value = referencePlayer.GetDataElementCharacter(reqValue);
+                    return value >= secondaryAsset && value <= tertiaryAsset;
+                }
+                case ModifierTreeType.PlayerDataElementAccountBetween: // 391
+                {
+                    var value = referencePlayer.GetDataElementAccount(reqValue);
+                    return value >= secondaryAsset && value <= tertiaryAsset;             
+                }
                 case ModifierTreeType.PlayerHasCompletedQuestOrIsReadyToTurnIn: // 392
                 {
                     QuestStatus status = referencePlayer.GetQuestStatus(reqValue);

Source/Game/DataStorage/CliDB.cs

@@ -264,6 +264,10 @@ namespace Game.DataStorage
             PhaseStorage = ReadDB2<PhaseRecord>("Phase.db2", HotfixStatements.SEL_PHASE);
             PhaseXPhaseGroupStorage = ReadDB2<PhaseXPhaseGroupRecord>("PhaseXPhaseGroup.db2", HotfixStatements.SEL_PHASE_X_PHASE_GROUP);
             PlayerConditionStorage = ReadDB2<PlayerConditionRecord>("PlayerCondition.db2", HotfixStatements.SEL_PLAYER_CONDITION, HotfixStatements.SEL_PLAYER_CONDITION_LOCALE);
+            PlayerDataElementAccountStorage = ReadDB2<PlayerDataElementAccountRecord>("PlayerDataElementAccount.db2", HotfixStatements.SEL_PLAYER_DATA_ELEMENT_ACCOUNT);
+            PlayerDataElementCharacterStorage = ReadDB2<PlayerDataElementCharacterRecord>("PlayerDataElementCharacter.db2", HotfixStatements.SEL_PLAYER_DATA_ELEMENT_CHARACTER);
+            PlayerDataFlagAccountStorage = ReadDB2<PlayerDataFlagAccountRecord>("PlayerDataFlagAccount.db2", HotfixStatements.SEL_PLAYER_DATA_FLAG_ACCOUNT);
+            PlayerDataFlagCharacterStorage = ReadDB2<PlayerDataFlagCharacterRecord>("PlayerDataFlagCharacter.db2", HotfixStatements.SEL_PLAYER_DATA_FLAG_CHARACTER);
             PowerDisplayStorage = ReadDB2<PowerDisplayRecord>("PowerDisplay.db2", HotfixStatements.SEL_POWER_DISPLAY);
             PowerTypeStorage = ReadDB2<PowerTypeRecord>("PowerType.db2", HotfixStatements.SEL_POWER_TYPE);
             PrestigeLevelInfoStorage = ReadDB2<PrestigeLevelInfoRecord>("PrestigeLevelInfo.db2", HotfixStatements.SEL_PRESTIGE_LEVEL_INFO, HotfixStatements.SEL_PRESTIGE_LEVEL_INFO_LOCALE);
@@ -396,7 +400,7 @@ namespace Game.DataStorage
             WMOAreaTableStorage = ReadDB2<WMOAreaTableRecord>("WMOAreaTable.db2", HotfixStatements.SEL_WMO_AREA_TABLE, HotfixStatements.SEL_WMO_AREA_TABLE_LOCALE);
             WorldEffectStorage = ReadDB2<WorldEffectRecord>("WorldEffect.db2", HotfixStatements.SEL_WORLD_EFFECT);
             WorldMapOverlayStorage = ReadDB2<WorldMapOverlayRecord>("WorldMapOverlay.db2", HotfixStatements.SEL_WORLD_MAP_OVERLAY);
-            WorldStateExpressionStorage = ReadDB2<WorldStateExpressionRecord>("WorldStateExpression.db2", HotfixStatements.SEL_WORLD_STATE_EXPRESSION);           
+            WorldStateExpressionStorage = ReadDB2<WorldStateExpressionRecord>("WorldStateExpression.db2", HotfixStatements.SEL_WORLD_STATE_EXPRESSION);
 
             // Check loaded DB2 files proper version
             if (!AreaTableStorage.ContainsKey(16108) ||               // last area added in 11.0.7 (58162)
@@ -664,6 +668,10 @@ namespace Game.DataStorage
         public static DB6Storage<PhaseRecord> PhaseStorage;
         public static DB6Storage<PhaseXPhaseGroupRecord> PhaseXPhaseGroupStorage;
         public static DB6Storage<PlayerConditionRecord> PlayerConditionStorage;
+        public static DB6Storage<PlayerDataElementAccountRecord> PlayerDataElementAccountStorage;
+        public static DB6Storage<PlayerDataElementCharacterRecord> PlayerDataElementCharacterStorage;
+        public static DB6Storage<PlayerDataFlagAccountRecord> PlayerDataFlagAccountStorage;
+        public static DB6Storage<PlayerDataFlagCharacterRecord> PlayerDataFlagCharacterStorage;
         public static DB6Storage<PowerDisplayRecord> PowerDisplayStorage;
         public static DB6Storage<PowerTypeRecord> PowerTypeStorage;
         public static DB6Storage<PrestigeLevelInfoRecord> PrestigeLevelInfoStorage;

Source/Game/DataStorage/Structs/P_Records.cs

@@ -149,6 +149,38 @@ namespace Game.DataStorage
         public ushort[] TraitNodeEntryMaxRank = new ushort[4];
     }
 
+    public sealed class PlayerDataElementAccountRecord
+    {
+        public uint Id;
+        public int StorageIndex;
+        public int Type;
+
+        public PlayerDataElementType GetElementType() { return (PlayerDataElementType)Type; }
+    }
+
+    public sealed class PlayerDataElementCharacterRecord
+    {
+        public uint Id;
+        public int StorageIndex;
+        public int Type;
+
+        public PlayerDataElementType GetElementType() { return (PlayerDataElementType)Type; }
+    }
+
+    public sealed class PlayerDataFlagAccountRecord
+    {
+        public uint Id;
+        public int StorageIndex;
+        public int Unknown1107;
+    }
+
+    public sealed class PlayerDataFlagCharacterRecord
+    {
+        public uint Id;
+        public int StorageIndex;
+        public int Unknown1107;
+    }
+
     public sealed class PowerDisplayRecord
     {
         public uint Id;

Source/Game/Entities/Object/Update/UpdateFields.cs

@@ -3804,6 +3804,7 @@ namespace Game.Entities
                 data.WriteInt64(Int64Value);
             }
         }
+
         public void WriteUpdate(WorldPacket data, bool ignoreChangesMask, Player owner, Player receiver)
         {
             data.WriteUInt32(Type);

Source/Game/Entities/Player/Player.DB.cs

@@ -575,6 +575,7 @@ namespace Game.Entities
             // TODO: finish dragonriding - this forces old flight mode
             AddAura(404468, this);
         }
+
         bool _LoadHomeBind(SQLResult result)
         {
             PlayerInfo info = Global.ObjectMgr.GetPlayerInfo(GetRace(), GetClass());
@@ -650,6 +651,80 @@ namespace Game.Entities
 
             return true;
         }
+
+        void _LoadPlayerData(SQLResult elementsResult, SQLResult flagsResult)
+        {
+            if (!elementsResult.IsEmpty())
+            {
+                do
+                {
+                    var entry = CliDB.PlayerDataElementCharacterStorage.LookupByKey(elementsResult.Read<uint>(0));
+                    if (entry == null)
+                        continue;
+
+                    PlayerDataElement dataElement = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.CharacterDataElements, entry.StorageIndex);
+
+                    SetUpdateFieldValue(ref dataElement.Type, (uint)entry.Type);
+
+                    switch (entry.GetElementType())
+                    {
+                        case PlayerDataElementType.Int64:
+                            SetUpdateFieldValue(ref dataElement.Int64Value, elementsResult.Read<long>(1));
+                            break;
+                        case PlayerDataElementType.Float:
+                            SetUpdateFieldValue(ref dataElement.FloatValue, elementsResult.Read<float>(2));
+                            break;
+                        default:
+                            break;
+                    }
+                } while (elementsResult.NextRow());
+            }
+
+            if (!flagsResult.IsEmpty())
+            {
+                BitVectors bitVectors = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.BitVectors);
+                BitVector bitVector = bitVectors.ModifyValue(bitVectors.Values, (int)PlayerDataFlag.CharacterDataIndex);
+
+                do
+                {
+                    SetUpdateFieldValue(bitVector.ModifyValue(bitVector.Values, flagsResult.Read<int>(0)), flagsResult.Read<ulong>(1));
+                } while (flagsResult.NextRow());
+            }
+
+            PlayerDataAccount accountData = GetSession().GetPlayerDataAccount();
+            foreach (var element in accountData.Elements)
+            {
+                var entry = CliDB.PlayerDataElementAccountStorage.LookupByKey(element.Id);
+                if (entry == null)
+                    continue;
+
+                PlayerDataElement dataElement = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.AccountDataElements, entry.StorageIndex);
+
+                SetUpdateFieldValue(ref dataElement.Type, (uint)entry.Type);
+
+                switch (entry.GetElementType())
+                {
+                    case PlayerDataElementType.Int64:
+                        SetUpdateFieldValue(ref dataElement.Int64Value, element.Int64Value);
+                        break;
+                    case PlayerDataElementType.Float:
+                        SetUpdateFieldValue(ref dataElement.FloatValue, element.FloatValue);
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            if (!accountData.Flags.Empty())
+            {
+                BitVectors bitVectors = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.BitVectors);
+                BitVector bitVector = bitVectors.ModifyValue(bitVectors.Values, (int)PlayerDataFlag.AccountDataIndex);
+
+                for (var i = 0; i < accountData.Flags.Count; ++i)
+                    SetUpdateFieldValue(bitVector.ModifyValue(bitVector.Values, i), accountData.Flags[i].Value);
+            }
+        }
+
         void _LoadCurrency(SQLResult result)
         {
             if (result.IsEmpty())
@@ -2194,7 +2269,7 @@ namespace Game.Entities
                         }
 
                         // Save spawn trackings
-                        stmt = CharacterDatabase.GetPreparedStatement( CharStatements.DEL_CHAR_QUESTSTATUS_OBJECTIVES_SPAWN_TRACKING_BY_QUEST);
+                        stmt = CharacterDatabase.GetPreparedStatement(CharStatements.DEL_CHAR_QUESTSTATUS_OBJECTIVES_SPAWN_TRACKING_BY_QUEST);
                         stmt.AddValue(0, GetGUID().GetCounter());
                         stmt.AddValue(1, save.Key);
                         trans.Append(stmt);
@@ -2586,6 +2661,7 @@ namespace Game.Entities
                 }
             }
         }
+
         void _SaveStats(SQLTransaction trans)
         {
             // check if stat saving is enabled and if char level is high enough
@@ -2625,6 +2701,71 @@ namespace Game.Entities
 
             trans.Append(stmt);
         }
+
+        void _SavePlayerData(SQLTransaction trans)
+        {
+            ulong guid = GetGUID().GetCounter();
+            PreparedStatement stmt;
+            foreach (uint playerDataElementCharacterId in _playerDataElementsNeedSave)
+            {
+                stmt = CharacterDatabase.GetPreparedStatement(CharStatements.DEL_PLAYER_DATA_ELEMENTS_CHARACTER);
+                stmt.AddValue(0, guid);
+                stmt.AddValue(1, playerDataElementCharacterId);
+                trans.Append(stmt);
+
+                var entry = CliDB.PlayerDataElementCharacterStorage.LookupByKey(playerDataElementCharacterId);
+                if (entry == null)
+                    continue;
+
+                PlayerDataElement element = m_activePlayerData.CharacterDataElements[entry.StorageIndex];
+                switch (entry.GetElementType())
+                {
+                    case PlayerDataElementType.Int64:
+                        if (element.Int64Value == 0)
+                            continue;
+                        stmt = CharacterDatabase.GetPreparedStatement(CharStatements.INS_PLAYER_DATA_ELEMENTS_CHARACTER);
+                        stmt.AddValue(0, guid);
+                        stmt.AddValue(1, playerDataElementCharacterId);
+                        stmt.AddNull(2);
+                        stmt.AddValue(3, element.Int64Value);
+                        trans.Append(stmt);
+                        break;
+                    case PlayerDataElementType.Float:
+                        if (element.FloatValue == 0)
+                            continue;
+                        stmt = CharacterDatabase.GetPreparedStatement(CharStatements.INS_PLAYER_DATA_ELEMENTS_CHARACTER);
+                        stmt.AddValue(0, guid);
+                        stmt.AddValue(1, playerDataElementCharacterId);
+                        stmt.AddValue(2, element.FloatValue);
+                        stmt.AddNull(3);
+                        trans.Append(stmt);
+                        break;
+                }
+
+            }
+
+            foreach (int storageIndex in _playerDataFlagsNeedSave)
+            {
+                stmt = CharacterDatabase.GetPreparedStatement(CharStatements.DEL_PLAYER_DATA_FLAGS_CHARACTER);
+                stmt.AddValue(0, guid);
+                stmt.AddValue(1, storageIndex);
+                trans.Append(stmt);
+
+                ulong value = m_activePlayerData.BitVectors.GetValue().Values[(int)PlayerDataFlag.CharacterDataIndex].Values[storageIndex];
+                if (value == 0)
+                    continue;
+
+                stmt = CharacterDatabase.GetPreparedStatement(CharStatements.INS_PLAYER_DATA_FLAGS_CHARACTER);
+                stmt.AddValue(0, guid);
+                stmt.AddValue(1, storageIndex);
+                stmt.AddValue(2, value);
+                trans.Append(stmt);
+            }
+
+            _playerDataElementsNeedSave.Clear();
+            _playerDataFlagsNeedSave.Clear();
+        }
+
         public void SaveInventoryAndGoldToDB(SQLTransaction trans)
         {
             _SaveInventory(trans);
@@ -2635,6 +2776,7 @@ namespace Game.Entities
             stmt.AddValue(1, GetGUID().GetCounter());
             trans.Append(stmt);
         }
+
         void _SaveEquipmentSets(SQLTransaction trans)
         {
             foreach (var pair in _equipmentSets)
@@ -3628,6 +3770,8 @@ namespace Game.Entities
 
             _LoadCUFProfiles(holder.GetResult(PlayerLoginQueryLoad.CufProfiles));
 
+            _LoadPlayerData(holder.GetResult(PlayerLoginQueryLoad.DataElements), holder.GetResult(PlayerLoginQueryLoad.DataFlags));
+
             var garrison = new Garrison(this);
             if (garrison.LoadFromDB(holder.GetResult(PlayerLoginQueryLoad.Garrison),
                 holder.GetResult(PlayerLoginQueryLoad.GarrisonBlueprints),
@@ -4062,6 +4206,7 @@ namespace Game.Entities
             _SaveInstanceTimeRestrictions(characterTransaction);
             _SaveCurrency(characterTransaction);
             _SaveCUFProfiles(characterTransaction);
+            _SavePlayerData(characterTransaction);
             if (_garrison != null)
                 _garrison.SaveToDB(characterTransaction);
 
@@ -4078,6 +4223,7 @@ namespace Game.Entities
             GetSession().GetCollectionMgr().SaveAccountItemAppearances(loginTransaction);
             GetSession().GetCollectionMgr().SaveAccountTransmogIllusions(loginTransaction);
             GetSession().GetCollectionMgr().SaveAccountWarbandScenes(loginTransaction);
+            GetSession().SavePlayerDataAccount(loginTransaction);
 
             var currentRealmId = Global.RealmMgr.GetCurrentRealmId();
 

Source/Game/Entities/Player/Player.Fields.cs

@@ -253,6 +253,9 @@ namespace Game.Entities
 
         PlayerCommandStates _activeCheats;
 
+        List<uint> _playerDataElementsNeedSave = new();
+        List<uint> _playerDataFlagsNeedSave = new();
+
         class ValuesUpdateForPlayerWithMaskSender : IDoWork<Player>
         {
             Player Owner;

Source/Game/Entities/Player/Player.cs

@@ -5027,7 +5027,7 @@ namespace Game.Entities
                     reward.Money = playerChoiceResponseTemplate.Reward.Money;
                     reward.Xp = playerChoiceResponseTemplate.Reward.Xp;
 
-                    void fillRewardItems<T>(List<T> src, List<Networking.Packets.PlayerChoiceResponseRewardEntry>  dest)
+                    void fillRewardItems<T>(List<T> src, List<Networking.Packets.PlayerChoiceResponseRewardEntry> dest)
                     {
                         for (var j = 0; j < src.Count; ++j)
                         {
@@ -5077,6 +5077,176 @@ namespace Game.Entities
             return ConditionManager.IsPlayerMeetingCondition(this, conditionId);
         }
 
+        public dynamic GetDataElementAccount(uint dataElementId)
+        {
+            var entry = CliDB.PlayerDataElementAccountStorage.LookupByKey(dataElementId);
+            if (entry == null)
+                return 0L;
+
+            switch (entry.GetElementType())
+            {
+                case PlayerDataElementType.Int64:
+                    if (entry.StorageIndex < m_activePlayerData.AccountDataElements.Size())
+                        return m_activePlayerData.AccountDataElements[entry.StorageIndex].Int64Value;
+                    return 0L;
+                case PlayerDataElementType.Float:
+                    if (entry.StorageIndex < m_activePlayerData.AccountDataElements.Size())
+                        return (0, m_activePlayerData.AccountDataElements[entry.StorageIndex].FloatValue);
+                    return 0.0f;
+                default:
+                    break;
+            }
+
+            return 0L;
+        }
+
+        public void SetDataElementAccount(uint dataElementId, dynamic value)
+        {
+            var entry = CliDB.PlayerDataElementAccountStorage.LookupByKey(dataElementId);
+            if (entry == null)
+                return;
+
+            PlayerDataElement elementSetter = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.AccountDataElements, entry.StorageIndex);
+            SetUpdateFieldValue(ref elementSetter.Type, (uint)entry.Type);
+
+            switch (entry.GetElementType())
+            {
+                case PlayerDataElementType.Int64:
+                {
+                    long int64Value = value;
+                    SetUpdateFieldValue(ref elementSetter.Int64Value, int64Value);
+                    GetSession().SetPlayerDataElementAccount(dataElementId, int64Value);
+                    break;
+                }
+                case PlayerDataElementType.Float:
+                {
+                    float floatValue = value;
+                    SetUpdateFieldValue(ref elementSetter.FloatValue, floatValue);
+                    GetSession().SetPlayerDataElementAccount(dataElementId, floatValue);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+
+        public dynamic GetDataElementCharacter(uint dataElementId)
+        {
+            var entry = CliDB.PlayerDataElementCharacterStorage.LookupByKey(dataElementId);
+            if (entry == null)
+                return 0L;
+
+            switch (entry.GetElementType())
+            {
+                case PlayerDataElementType.Int64:
+                    if (entry.StorageIndex < m_activePlayerData.CharacterDataElements.Size())
+                        return m_activePlayerData.CharacterDataElements[entry.StorageIndex].Int64Value;
+                    return 0L;
+                case PlayerDataElementType.Float:
+                    if (entry.StorageIndex < m_activePlayerData.CharacterDataElements.Size())
+                        return m_activePlayerData.CharacterDataElements[entry.StorageIndex].FloatValue;
+                    return 0.0f;
+                default:
+                    break;
+            }
+
+            return 0L;
+        }
+
+        public void SetDataElementCharacter(uint dataElementId, dynamic value)
+        {
+            var entry = CliDB.PlayerDataElementCharacterStorage.LookupByKey(dataElementId);
+            if (entry == null)
+                return;
+
+            PlayerDataElement elementSetter = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.CharacterDataElements, entry.StorageIndex);
+            SetUpdateFieldValue(ref elementSetter.Type, (uint)entry.Type);
+
+            switch (entry.GetElementType())
+            {
+                case PlayerDataElementType.Int64:
+                    SetUpdateFieldValue(ref elementSetter.Int64Value, value);
+                    break;
+                case PlayerDataElementType.Float:
+                    SetUpdateFieldValue(ref elementSetter.FloatValue, value);
+                    break;
+                default:
+                    break;
+            }
+
+            _playerDataElementsNeedSave.Add(dataElementId);
+        }
+
+        public bool HasDataFlagAccount(uint dataFlagId)
+        {
+            var entry = CliDB.PlayerDataFlagAccountStorage.LookupByKey(dataFlagId);
+            if (entry == null)
+                return false;
+
+            int fieldOffset = entry.StorageIndex / PlayerConst.DataFlagValueBits;
+            ulong flag = 1UL << (entry.StorageIndex % PlayerConst.DataFlagValueBits);
+
+            if (fieldOffset >= m_activePlayerData.BitVectors.GetValue().Values[(int)PlayerDataFlag.AccountDataIndex].Values.Size())
+                return false;
+
+            return (m_activePlayerData.BitVectors.GetValue().Values[(int)PlayerDataFlag.AccountDataIndex].Values[fieldOffset] & flag) != 0;
+        }
+
+        public void SetDataFlagAccount(uint dataFlagId, bool on)
+        {
+            var entry = CliDB.PlayerDataFlagAccountStorage.LookupByKey(dataFlagId);
+            if (entry == null)
+                return;
+
+            int fieldOffset = entry.StorageIndex / PlayerConst.DataFlagValueBits;
+            ulong flag = 1UL << (entry.StorageIndex % PlayerConst.DataFlagValueBits);
+
+            BitVectors bitVectors = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.BitVectors);
+            BitVector bitVector = bitVectors.ModifyValue(bitVectors.Values, (int)PlayerDataFlag.AccountDataIndex);
+
+            if (on)
+                SetUpdateFieldFlagValue(bitVector.ModifyValue(bitVector.Values, fieldOffset), flag);
+            else
+                RemoveUpdateFieldFlagValue(bitVector.ModifyValue(bitVector.Values, fieldOffset), flag);
+
+            GetSession().SetPlayerDataFlagAccount(dataFlagId, on);
+        }
+
+        public bool HasDataFlagCharacter(uint dataFlagId)
+        {
+            var entry = CliDB.PlayerDataFlagCharacterStorage.LookupByKey(dataFlagId);
+            if (entry == null)
+                return false;
+
+            int fieldOffset = entry.StorageIndex / PlayerConst.DataFlagValueBits;
+            ulong flag = 1UL << (entry.StorageIndex % PlayerConst.DataFlagValueBits);
+
+            if (fieldOffset >= m_activePlayerData.BitVectors.GetValue().Values[(int)PlayerDataFlag.CharacterDataIndex].Values.Size())
+                return false;
+
+            return (m_activePlayerData.BitVectors.GetValue().Values[(int)PlayerDataFlag.CharacterDataIndex].Values[fieldOffset] & flag) != 0;
+        }
+
+        public void SetDataFlagCharacter(uint dataFlagId, bool on)
+        {
+            var entry = CliDB.PlayerDataFlagCharacterStorage.LookupByKey(dataFlagId);
+            if (entry == null)
+                return;
+
+            int fieldOffset = entry.StorageIndex / PlayerConst.DataFlagValueBits;
+            ulong flag = 1UL << (entry.StorageIndex % PlayerConst.DataFlagValueBits);
+
+            BitVectors bitVectors = m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.BitVectors);
+            BitVector bitVector = bitVectors.ModifyValue(bitVectors.Values, (int)PlayerDataFlag.CharacterDataIndex);
+
+            if (on)
+                SetUpdateFieldFlagValue(bitVector.ModifyValue(bitVector.Values, fieldOffset), flag);
+            else
+                RemoveUpdateFieldFlagValue(bitVector.ModifyValue(bitVector.Values, fieldOffset), flag);
+
+            _playerDataFlagsNeedSave.Add((uint)fieldOffset);
+        }
+
         bool IsInFriendlyArea()
         {
             var areaEntry = CliDB.AreaTableStorage.LookupByKey(GetAreaId());

Source/Game/Handlers/CharacterHandler.cs

@@ -2958,6 +2958,14 @@ namespace Game
             stmt = CharacterDatabase.GetPreparedStatement(CharStatements.SEL_CHAR_TRAIT_CONFIGS);
             stmt.AddValue(0, lowGuid);
             SetQuery(PlayerLoginQueryLoad.TraitConfigs, stmt);
+
+            stmt = CharacterDatabase.GetPreparedStatement(CharStatements.SEL_PLAYER_DATA_ELEMENTS_CHARACTER);
+            stmt.AddValue(0, lowGuid);
+            SetQuery(PlayerLoginQueryLoad.DataElements, stmt);
+
+            stmt = CharacterDatabase.GetPreparedStatement(CharStatements.SEL_PLAYER_DATA_FLAGS_CHARACTER);
+            stmt.AddValue(0, lowGuid);
+            SetQuery(PlayerLoginQueryLoad.DataFlags, stmt);
         }
 
         public ObjectGuid GetGuid() { return m_guid; }
@@ -3064,6 +3072,8 @@ namespace Game
         GarrisonFollowerAbilities,
         TraitEntries,
         TraitConfigs,
+        DataElements,
+        DataFlags,
         Max
     }
 

Source/Game/Server/WorldSession.cs

@@ -9,6 +9,7 @@ using Game.Accounts;
 using Game.BattleGrounds;
 using Game.BattlePets;
 using Game.Chat;
+using Game.DataStorage;
 using Game.Entities;
 using Game.Guilds;
 using Game.Maps;
@@ -18,6 +19,7 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Numerics;
 using System.Text;
 
@@ -26,7 +28,7 @@ namespace Game
     public partial class WorldSession : IDisposable
     {
         public static uint SPECIAL_INIT_ACTIVE_MOVER_TIME_SYNC_COUNTER = 0xFFFFFFFF;
-        public static uint SPECIAL_RESUME_COMMS_TIME_SYNC_COUNTER      = 0xFFFFFFFE;
+        public static uint SPECIAL_RESUME_COMMS_TIME_SYNC_COUNTER = 0xFFFFFFFE;
 
         public WorldSession(uint id, string name, uint battlenetAccountId, WorldSocket sock, AccountTypes sec, Expansion expansion, long mute_time, string os, TimeSpan timezoneOffset, uint build, Framework.ClientBuild.ClientBuildVariantId clientBuildVariant, Locale locale, uint recruiter, bool isARecruiter)
         {
@@ -496,6 +498,163 @@ namespace Game
             tutorialsChanged &= ~TutorialsFlag.Changed;
         }
 
+        void LoadPlayerDataAccount(SQLResult elementsResult, SQLResult flagsResult)
+        {
+            if (!elementsResult.IsEmpty())
+            {
+                do
+                {
+                    var entry = CliDB.PlayerDataElementAccountStorage.LookupByKey(elementsResult.Read<uint>(0));
+                    if (entry == null)
+                        continue;
+
+                    PlayerDataAccount.Element element = new();
+                    element.Id = entry.Id;
+                    element.NeedSave = false;
+
+                    switch (entry.GetElementType())
+                    {
+                        case PlayerDataElementType.Int64:
+                            element.Int64Value = elementsResult.Read<long>(2);
+                            break;
+                        case PlayerDataElementType.Float:
+                            element.FloatValue = elementsResult.Read<float>(1);
+                            break;
+                        default:
+                            break;
+                    }
+
+                    _playerDataAccount.Elements.Add(element);
+                } while (elementsResult.NextRow());
+            }
+
+            if (!flagsResult.IsEmpty())
+            {
+                do
+                {
+                    _playerDataAccount.Flags.EnsureWritableListIndex(flagsResult.Read<uint>(0), new PlayerDataAccount.Flag() { Value = flagsResult.Read<ulong>(1), NeedSave = false });
+                } while (flagsResult.NextRow());
+            }
+        }
+
+        public void SavePlayerDataAccount(SQLTransaction transaction)
+        {
+            PreparedStatement stmt;
+            for (int i = 0; i < _playerDataAccount.Elements.Count; i++)
+            {
+                PlayerDataAccount.Element element = _playerDataAccount.Elements[i];
+                if (!element.NeedSave)
+                    continue;
+
+                stmt = LoginDatabase.GetPreparedStatement(LoginStatements.DEL_BNET_PLAYER_DATA_ELEMENTS_ACCOUNT);
+                stmt.AddValue(0, GetBattlenetAccountId());
+                stmt.AddValue(1, element.Id);
+                transaction.Append(stmt);
+
+                element.NeedSave = false;
+
+                var entry = CliDB.PlayerDataElementAccountStorage.LookupByKey(element.Id);
+                if (entry == null)
+                    continue;
+
+                switch (entry.GetElementType())
+                {
+                    case PlayerDataElementType.Int64:
+                        if (element.Int64Value == 0)
+                            continue;
+                        stmt = LoginDatabase.GetPreparedStatement(LoginStatements.INS_BNET_PLAYER_DATA_ELEMENTS_ACCOUNT);
+                        stmt.AddValue(0, GetBattlenetAccountId());
+                        stmt.AddValue(1, element.Id);
+                        stmt.AddNull(2);
+                        stmt.AddValue(3, element.Int64Value);
+                        transaction.Append(stmt);
+                        break;
+                    case PlayerDataElementType.Float:
+                        if (element.FloatValue == 0)
+                            continue;
+                        stmt = LoginDatabase.GetPreparedStatement(LoginStatements.INS_BNET_PLAYER_DATA_ELEMENTS_ACCOUNT);
+                        stmt.AddValue(0, GetBattlenetAccountId());
+                        stmt.AddValue(1, element.Id);
+                        stmt.AddValue(2, element.FloatValue);
+                        stmt.AddNull(3);
+                        transaction.Append(stmt);
+                        break;
+                }
+            }
+
+            for (var i = 0; i < _playerDataAccount.Flags.Count; ++i)
+            {
+                var flag = _playerDataAccount.Flags[i];
+                if (!flag.NeedSave)
+                    continue;
+
+                stmt = LoginDatabase.GetPreparedStatement(LoginStatements.DEL_BNET_PLAYER_DATA_FLAGS_ACCOUNT);
+                stmt.AddValue(0, GetBattlenetAccountId());
+                stmt.AddValue(1, i);
+                transaction.Append(stmt);
+
+                flag.NeedSave = false;
+
+                if (flag.Value == 0)
+                    continue;
+
+                stmt = LoginDatabase.GetPreparedStatement(LoginStatements.INS_BNET_PLAYER_DATA_FLAGS_ACCOUNT);
+                stmt.AddValue(0, GetBattlenetAccountId());
+                stmt.AddValue(1, i);
+                stmt.AddValue(2, flag.Value);
+                transaction.Append(stmt);
+            }
+        }
+
+        public void SetPlayerDataElementAccount(uint dataElementId, float value)
+        {
+            var element = _playerDataAccount.Elements.Find(p => p.Id == dataElementId);
+            if (element == null)
+            {
+                element = new();
+                element.Id = dataElementId;
+                _playerDataAccount.Elements.Add(element);
+            }
+
+            element.NeedSave = true;
+            element.FloatValue = value;
+        }
+
+        public void SetPlayerDataElementAccount(uint dataElementId, long value)
+        {
+            var element = _playerDataAccount.Elements.Find(p => p.Id == dataElementId);
+            if (element == null)
+            {
+                element = new();
+                element.Id = dataElementId;
+                _playerDataAccount.Elements.Add(element);
+            }
+
+            element.NeedSave = true;
+            element.Int64Value = value;
+        }
+
+        public void SetPlayerDataFlagAccount(uint dataFlagId, bool on)
+        {
+            var entry = CliDB.PlayerDataFlagAccountStorage.LookupByKey(dataFlagId);
+            if (entry == null)
+                return;
+
+            int fieldOffset = entry.StorageIndex / PlayerConst.DataFlagValueBits;
+            ulong flagValue = 1UL << (entry.StorageIndex % PlayerConst.DataFlagValueBits);
+
+            _playerDataAccount.Flags.EnsureWritableListIndex((uint)fieldOffset, new PlayerDataAccount.Flag());
+            var flag = _playerDataAccount.Flags[fieldOffset];
+            if (on)
+                flag.Value |= flagValue;
+            else
+                flag.Value &= ~flagValue;
+
+            flag.NeedSave = true;
+        }
+
+        public PlayerDataAccount GetPlayerDataAccount() { return _playerDataAccount; }
+
         public void SendConnectToInstance(ConnectToSerial serial)
         {
             System.Net.IPAddress instanceAddress = null;
@@ -824,6 +983,7 @@ namespace Game
             _collectionMgr.LoadAccountItemAppearances(holder.GetResult(AccountInfoQueryLoad.ItemAppearances), holder.GetResult(AccountInfoQueryLoad.ItemFavoriteAppearances));
             _collectionMgr.LoadAccountTransmogIllusions(holder.GetResult(AccountInfoQueryLoad.TransmogIllusions));
             _collectionMgr.LoadAccountWarbandScenes(holder.GetResult(AccountInfoQueryLoad.WarbandScenes));
+            LoadPlayerDataAccount(holder.GetResult(AccountInfoQueryLoad.PlayerDataElementsAccount), holder.GetResult(AccountInfoQueryLoad.PlayerDataFlagsAccount));
 
             if (!m_inQueue)
                 SendAuthResponse(BattlenetRpcErrorCode.Ok, false);
@@ -1007,6 +1167,7 @@ namespace Game
         Dictionary<uint, Action<Google.Protobuf.CodedInputStream>> _battlenetResponseCallbacks = new();
         uint _battlenetRequestToken;
 
+        PlayerDataAccount _playerDataAccount = new();
         List<string> _registeredAddonPrefixes = new();
         bool _filterAddonMessages;
         uint recruiterId;
@@ -1217,6 +1378,28 @@ namespace Game
         GlobalAccountDataIndexPerRealm,
         TutorialsIndexPerRealm,
         TransmogIllusions,
-        WarbandScenes
+        WarbandScenes,
+        PlayerDataElementsAccount,
+        PlayerDataFlagsAccount,
+    }
+
+    public class PlayerDataAccount
+    {
+        public List<Element> Elements = new();
+        public List<Flag> Flags = new();
+
+        public class Element
+        {
+            public uint Id;
+            public bool NeedSave;
+            public float FloatValue;
+            public long Int64Value;
+        }
+
+        public class Flag
+        {
+            public ulong Value;
+            public bool NeedSave;
+        }
     }
 }

Source/Game/Spells/SpellEffects.cs

@@ -5899,9 +5899,7 @@ namespace Game.Spells
                 if (bitIndex < 0 || bitIndex >= sizeof(uint) * 8)
                     return false;
 
-                FlagArray128 reqFlag = new();
-                reqFlag[bitIndex / 32] = 1u << (bitIndex % 32);
-                return (spellOnCooldown.SpellFamilyFlags & reqFlag);
+                return (spellOnCooldown.SpellFamilyFlags[bitIndex / 32] & 1u << (bitIndex % 32)) != 0;
             }, TimeSpan.FromMilliseconds(damage));
         }
 
@@ -6003,6 +6001,58 @@ namespace Game.Spells
 
             target.GetSession().GetCollectionMgr().AddWarbandScene((uint)effectInfo.MiscValue);
         }
+
+        [SpellEffectHandler(SpellEffectName.SetPlayerDataElementAccount)]
+        void EffectSetPlayerDataElementAccount()
+        {
+            if (effectHandleMode != SpellEffectHandleMode.HitTarget)
+                return;
+
+            Player target = unitTarget?.ToPlayer();
+            if (target == null)
+                return;
+
+            target.SetDataElementAccount((uint)effectInfo.MiscValue, (long)damage);
+        }
+
+        [SpellEffectHandler(SpellEffectName.SetPlayerDataElementCharacter)]
+        void EffectSetPlayerDataElementCharacter()
+        {
+            if (effectHandleMode != SpellEffectHandleMode.HitTarget)
+                return;
+
+            Player target = unitTarget?.ToPlayer();
+            if (target == null)
+                return;
+
+            target.SetDataElementCharacter((uint)effectInfo.MiscValue, (long)damage);
+        }
+
+        [SpellEffectHandler(SpellEffectName.SetPlayerDataFlagAccount)]
+        void EffectSetPlayerDataFlagAccount()
+        {
+            if (effectHandleMode != SpellEffectHandleMode.HitTarget)
+                return;
+
+            Player target = unitTarget?.ToPlayer();
+            if (target == null)
+                return;
+
+            target.SetDataFlagAccount((uint)effectInfo.MiscValue, damage != 0);
+        }
+
+        [SpellEffectHandler(SpellEffectName.SetPlayerDataFlagCharacter)]
+        void EffectSetPlayerDataFlagCharacter()
+        {
+            if (effectHandleMode != SpellEffectHandleMode.HitTarget)
+                return;
+
+            Player target = unitTarget?.ToPlayer();
+            if (target == null)
+                return;
+
+            target.SetDataFlagCharacter((uint)effectInfo.MiscValue, damage != 0);
+        }
     }
 
     public class DispelableAura

Source/Game/Spells/SpellInfo.cs

@@ -4891,10 +4891,10 @@ namespace Game.Spells
             new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 332 SPELL_EFFECT_332
             new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 333 SPELL_EFFECT_333
             new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 334 SPELL_EFFECT_334
-            new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 335 SPELL_EFFECT_335
-            new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 336 SPELL_EFFECT_336
-            new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 337 SPELL_EFFECT_337
-            new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 338 SPELL_EFFECT_338
+            new StaticData(SpellEffectImplicitTargetTypes.Explicit, SpellTargetObjectTypes.Unit), // 335 SPELL_EFFECT_SET_PLAYER_DATA_ELEMENT_ACCOUNT
+            new StaticData(SpellEffectImplicitTargetTypes.Explicit, SpellTargetObjectTypes.Unit), // 336 SPELL_EFFECT_SET_PLAYER_DATA_ELEMENT_CHARACTER
+            new StaticData(SpellEffectImplicitTargetTypes.Explicit, SpellTargetObjectTypes.Unit), // 337 SPELL_EFFECT_SET_PLAYER_DATA_FLAG_ACCOUNT
+            new StaticData(SpellEffectImplicitTargetTypes.Explicit, SpellTargetObjectTypes.Unit), // 338 SPELL_EFFECT_SET_PLAYER_DATA_FLAG_CHARACTER
             new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 339 SPELL_EFFECT_UI_ACTION
             new StaticData(SpellEffectImplicitTargetTypes.None,     SpellTargetObjectTypes.None), // 340 SPELL_EFFECT_340
             new StaticData(SpellEffectImplicitTargetTypes.Explicit, SpellTargetObjectTypes.Unit), // 341 SPELL_EFFECT_LEARN_WARBAND_SCENE