From 68588dbb25d2cb45757764db187d5e66b7726305 Mon Sep 17 00:00:00 2001 From: Shauren Date: Sat, 28 Jun 2025 19:43:01 +0200 Subject: Core/Objects: Modernize updatefield internals - replace tag dispatch and std::enable if --- src/server/game/Entities/Object/Object.h | 16 +- .../game/Entities/Object/Updates/UpdateField.h | 233 ++++++++++----------- .../game/Entities/Object/Updates/UpdateFields.cpp | 80 ++++--- .../game/Entities/Object/Updates/UpdateMask.h | 4 +- 4 files changed, 165 insertions(+), 168 deletions(-) (limited to 'src') diff --git a/src/server/game/Entities/Object/Object.h b/src/server/game/Entities/Object/Object.h index fcbcedf77a5..b5940dc0b73 100644 --- a/src/server/game/Entities/Object/Object.h +++ b/src/server/game/Entities/Object/Object.h @@ -143,7 +143,7 @@ namespace UF }; template - inline bool SetUpdateFieldValue(UpdateFieldSetter& setter, typename UpdateFieldSetter::value_type&& value) + inline bool SetUpdateFieldValue(UpdateFieldPrivateSetter& setter, typename UpdateFieldPrivateSetter::value_type&& value) { return setter.SetValue(std::move(value)); } @@ -304,7 +304,7 @@ class TC_GAME_API Object UF::UpdateField m_objectData; template - void ForceUpdateFieldChange(UF::UpdateFieldSetter const& /*setter*/) + void ForceUpdateFieldChange(UF::UpdateFieldPrivateSetter const& /*setter*/) { AddToObjectUpdateIfNeeded(); } @@ -323,21 +323,21 @@ class TC_GAME_API Object void _Create(ObjectGuid const& guid); template - void SetUpdateFieldValue(UF::UpdateFieldSetter setter, typename UF::UpdateFieldSetter::value_type value) + void SetUpdateFieldValue(UF::UpdateFieldPrivateSetter setter, typename UF::UpdateFieldPrivateSetter::value_type value) { if (UF::SetUpdateFieldValue(setter, std::move(value))) AddToObjectUpdateIfNeeded(); } template - void SetUpdateFieldFlagValue(UF::UpdateFieldSetter setter, typename UF::UpdateFieldSetter::value_type flag) + void SetUpdateFieldFlagValue(UF::UpdateFieldPrivateSetter setter, typename UF::UpdateFieldPrivateSetter::value_type flag) { static_assert(std::is_integral::value, "SetUpdateFieldFlagValue must be used with integral types"); SetUpdateFieldValue(setter, setter.GetValue() | flag); } template - void RemoveUpdateFieldFlagValue(UF::UpdateFieldSetter setter, typename UF::UpdateFieldSetter::value_type flag) + void RemoveUpdateFieldFlagValue(UF::UpdateFieldPrivateSetter setter, typename UF::UpdateFieldPrivateSetter::value_type flag) { static_assert(std::is_integral::value, "RemoveUpdateFieldFlagValue must be used with integral types"); SetUpdateFieldValue(setter, setter.GetValue() & ~flag); @@ -380,14 +380,14 @@ class TC_GAME_API Object // stat system helpers template - void SetUpdateFieldStatValue(UF::UpdateFieldSetter setter, typename UF::UpdateFieldSetter::value_type value) + void SetUpdateFieldStatValue(UF::UpdateFieldPrivateSetter setter, typename UF::UpdateFieldPrivateSetter::value_type value) { static_assert(std::is_arithmetic::value, "SetUpdateFieldStatValue must be used with arithmetic types"); SetUpdateFieldValue(setter, std::max(value, T(0))); } template - void ApplyModUpdateFieldValue(UF::UpdateFieldSetter setter, typename UF::UpdateFieldSetter::value_type mod, bool apply) + void ApplyModUpdateFieldValue(UF::UpdateFieldPrivateSetter setter, typename UF::UpdateFieldPrivateSetter::value_type mod, bool apply) { static_assert(std::is_arithmetic::value, "SetUpdateFieldStatValue must be used with arithmetic types"); @@ -401,7 +401,7 @@ class TC_GAME_API Object } template - void ApplyPercentModUpdateFieldValue(UF::UpdateFieldSetter setter, float percent, bool apply) + void ApplyPercentModUpdateFieldValue(UF::UpdateFieldPrivateSetter setter, float percent, bool apply) { static_assert(std::is_arithmetic::value, "SetUpdateFieldStatValue must be used with arithmetic types"); diff --git a/src/server/game/Entities/Object/Updates/UpdateField.h b/src/server/game/Entities/Object/Updates/UpdateField.h index 930f055c655..2e2b40ac8b1 100644 --- a/src/server/game/Entities/Object/Updates/UpdateField.h +++ b/src/server/game/Entities/Object/Updates/UpdateField.h @@ -69,7 +69,10 @@ namespace UF class OptionalUpdateField; template - struct MutableFieldReference; + struct MutableFieldReferenceWithChangesMask; + + template + struct MutableFieldReferenceNoChangesMask; template struct MutableNestedFieldReference; @@ -85,14 +88,14 @@ namespace UF }; template - struct UpdateFieldSetter + struct UpdateFieldPrivateSetter { using value_type = T; template - friend bool SetUpdateFieldValue(UpdateFieldSetter& setter, typename UpdateFieldSetter::value_type&& value); + friend bool SetUpdateFieldValue(UpdateFieldPrivateSetter& setter, typename UpdateFieldPrivateSetter::value_type&& value); - UpdateFieldSetter(T& value) : _value(value) + UpdateFieldPrivateSetter(T& value) : _value(value) { } @@ -139,6 +142,14 @@ namespace UF T& _value; }; + template + using UpdateFieldSetter = std::conditional_t, UpdateFieldPrivateSetter>; + + template + using MutableFieldReference = std::conditional_t, + MutableFieldReferenceWithChangesMask, + MutableFieldReferenceNoChangesMask>; + template struct DynamicUpdateFieldSetter { @@ -165,9 +176,9 @@ namespace UF insert_result AddValue() { MarkChanged(_values.size()); - _values.emplace_back(); - T& value = _values.back(); - MarkNewValue(value, std::is_base_of{}); + T& value = _values.emplace_back(); + if constexpr (std::is_base_of_v) + value._changesMask.SetAll(); return { value }; } @@ -178,7 +189,8 @@ namespace UF { MarkChanged(i); // also mark all fields of value as changed - MarkNewValue(_values[i], std::is_base_of{}); + if constexpr (std::is_base_of_v) + _values[i]._changesMask.SetAll(); } return { _values[index] }; } @@ -191,7 +203,8 @@ namespace UF { MarkChanged(i); // also mark all fields of value as changed - MarkNewValue(_values[i], std::is_base_of{}); + if constexpr (std::is_base_of_v) + _values[i]._changesMask.SetAll(); } if (_values.size() % 32) _updateMask[UpdateMaskHelpers::GetBlockIndex(_values.size())] &= ~UpdateMaskHelpers::GetBlockFlag(_values.size()); @@ -214,15 +227,6 @@ namespace UF _updateMask[block] |= UpdateMaskHelpers::GetBlockFlag(index); } - static void MarkNewValue(T&, std::false_type) - { - } - - static void MarkNewValue(T& value, std::true_type) - { - value._changesMask.SetAll(); - } - std::vector& _values; std::vector& _updateMask; }; @@ -246,19 +250,18 @@ namespace UF }; template - struct MutableFieldReference + struct MutableFieldReferenceWithChangesMask { - MutableFieldReference(T& value) : _value(value) + MutableFieldReferenceWithChangesMask(T& value) : _value(value) { } - template - std::enable_if_t, - std::conditional_t, + template + std::conditional_t, MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>> ModifyValue(UpdateField(T::* field)) { if constexpr (BlockBit >= 0) @@ -268,13 +271,12 @@ namespace UF return { (_value.*field)._value }; } - template - std::enable_if_t, - std::conditional_t, + template + std::conditional_t, MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>> ModifyValue(UpdateFieldArray(T::* field), uint32 index) { _value._changesMask.Set(Bit); @@ -289,9 +291,8 @@ namespace UF return { (_value.*field)._values[index] }; } - template - std::enable_if_t, DynamicUpdateFieldSetter> - ModifyValue(DynamicUpdateField(T::* field)) + template + DynamicUpdateFieldSetter ModifyValue(DynamicUpdateField(T::* field)) { if constexpr (BlockBit >= 0) _value._changesMask.Set(BlockBit); @@ -300,20 +301,19 @@ namespace UF return { (_value.*field)._values, (_value.*field)._updateMask }; } - template - std::enable_if_t, - std::conditional_t, + template + std::conditional_t, MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>> ModifyValue(DynamicUpdateField(T::* field), uint32 index) { if (index >= (_value.*field).size()) { // fill with zeros until reaching desired slot (_value.*field)._values.resize(index + 1); - (_value.*field)._updateMask.resize(((_value.*field)._values.size() + 31) / 32); + (_value.*field)._updateMask.resize((index + 1 + 31) / 32); } if constexpr (BlockBit >= 0) @@ -324,9 +324,8 @@ namespace UF return { (_value.*field)._values[index] }; } - template - std::enable_if_t, OptionalUpdateFieldSetter> - ModifyValue(OptionalUpdateField(T::* field)) + template + OptionalUpdateFieldSetter ModifyValue(OptionalUpdateField(T::* field)) { if constexpr (BlockBit >= 0) _value._changesMask.Set(BlockBit); @@ -335,13 +334,12 @@ namespace UF return { _value.*field }; } - template - std::enable_if_t, - std::conditional_t, + template + std::conditional_t, MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>> ModifyValue(OptionalUpdateField(T::* field), uint32 /*dummy*/) { if (!(_value.*field).has_value()) @@ -354,18 +352,25 @@ namespace UF return { *((_value.*field)._value) }; } - template - std::enable_if_t && !std::is_array_v, - std::conditional_t, UpdateFieldSetter>> - ModifyValue(V(T::* field)) + private: + T& _value; + }; + + template + struct MutableFieldReferenceNoChangesMask + { + MutableFieldReferenceNoChangesMask(T& value) : _value(value) + { + } + + template + UpdateFieldSetter ModifyValue(V(T::* field)) { return { _value.*field }; } - template - std::enable_if_t, - std::conditional_t, UpdateFieldSetter>> - ModifyValue(V(T::* field)[Size], uint32 index) + template + UpdateFieldSetter ModifyValue(V(T::* field)[Size], uint32 index) { return { (_value.*field)[index] }; } @@ -389,7 +394,7 @@ namespace UF MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>>> ModifyValue() { return { _value._value }; @@ -401,7 +406,7 @@ namespace UF MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>>> ModifyValue(uint32 index) { return { _value._values[index] }; @@ -420,14 +425,14 @@ namespace UF MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>>> ModifyValue(uint32 index) { if (index >= _value.size()) { // fill with zeros until reaching desired slot _value._values.resize(index + 1); - _value._updateMask.resize((_value._values.size() + 31) / 32); + _value._updateMask.resize((index + 1 + 31) / 32); } _value.MarkChanged(index); @@ -447,7 +452,7 @@ namespace UF MutableFieldReference, std::conditional_t, MutableNestedFieldReference, - std::conditional_t, UpdateFieldSetter>>>> + UpdateFieldSetter>>> ModifyValue(uint32 /*dummy*/) { if (!_value.has_value()) @@ -467,7 +472,10 @@ namespace UF friend struct DynamicUpdateFieldSetter; template - friend struct MutableFieldReference; + friend struct MutableFieldReferenceWithChangesMask; + + template + friend struct MutableFieldReferenceNoChangesMask; template friend class UpdateField; @@ -511,7 +519,7 @@ namespace UF { // fill with zeros until reaching desired slot uf._values.resize(index + 1); - uf._updateMask.resize((uf._values.size() + 31) / 32); + uf._updateMask.resize((index + 1 + 31) / 32); } MarkChanged(field); @@ -600,7 +608,10 @@ namespace UF void ClearChanged(DynamicUpdateField(Derived::* field), uint32 index) { _changesMask.Reset(Bit); - (static_cast(this)->*field).ClearChanged(index); + + DynamicUpdateField& uf = (static_cast(this)->*field); + if (index < uf.size()) + uf.ClearChanged(index); } template @@ -617,65 +628,34 @@ namespace UF template static void ClearChangesMask(UpdateField& field) { - ClearChangesMask(field, std::is_base_of{}); - } - - template - static void ClearChangesMask(UpdateField&, std::false_type) { } - - template - static void ClearChangesMask(UpdateField& field, std::true_type) - { - field._value.ClearChangesMask(); + if constexpr (std::is_base_of_v) + field._value.ClearChangesMask(); } template static void ClearChangesMask(UpdateFieldArray& field) { - ClearChangesMask(field, std::disjunction, std::is_base_of>{}); - } - - template - static void ClearChangesMask(UpdateFieldArray&, std::false_type) { } - - template - static void ClearChangesMask(UpdateFieldArray& field, std::true_type) - { - for (uint32 i = 0; i < Size; ++i) - field._values[i].ClearChangesMask(); + if constexpr (std::disjunction_v, std::is_base_of>) + for (T& value : field._values) + value.ClearChangesMask(); } template static void ClearChangesMask(DynamicUpdateField& field) { - ClearChangesMask(field, std::is_base_of{}); - field.ClearChangesMask(); - } - - template - static void ClearChangesMask(DynamicUpdateField&, std::false_type) { } + if constexpr (std::is_base_of_v) + for (T& value : field._values) + value.ClearChangesMask(); - template - static void ClearChangesMask(DynamicUpdateField& field, std::true_type) - { - for (uint32 i = 0; i < field._values.size(); ++i) - field._values[i].ClearChangesMask(); + field.ClearChangesMask(); } template static void ClearChangesMask(OptionalUpdateField& field) { - ClearChangesMask(field, std::is_base_of{}); - } - - template - static void ClearChangesMask(OptionalUpdateField&, std::false_type) { } - - template - static void ClearChangesMask(OptionalUpdateField& field, std::true_type) - { - if (field.has_value()) - field._value->ClearChangesMask(); + if constexpr (std::is_base_of_v) + if (field.has_value()) + field._value->ClearChangesMask(); } Mask _changesMask; @@ -685,7 +665,10 @@ namespace UF class UpdateFieldBase : public IsUpdateFieldHolderTag { template - friend struct MutableFieldReference; + friend struct MutableFieldReferenceWithChangesMask; + + template + friend struct MutableFieldReferenceNoChangesMask; template friend struct MutableNestedFieldReference; @@ -729,7 +712,10 @@ namespace UF class UpdateFieldArrayBase : public UpdateFieldArrayBaseWithoutSize { template - friend struct MutableFieldReference; + friend struct MutableFieldReferenceWithChangesMask; + + template + friend struct MutableFieldReferenceNoChangesMask; template friend struct MutableNestedFieldReference; @@ -789,7 +775,10 @@ namespace UF class DynamicUpdateFieldBase : public IsUpdateFieldHolderTag { template - friend struct MutableFieldReference; + friend struct MutableFieldReferenceWithChangesMask; + + template + friend struct MutableFieldReferenceNoChangesMask; template friend struct MutableNestedFieldReference; @@ -862,25 +851,17 @@ namespace UF private: void MarkChanged(std::size_t index) { - std::size_t block = UpdateMaskHelpers::GetBlockIndex(index); - if (block >= _updateMask.size()) - _updateMask.emplace_back(0); - - _updateMask[block] |= UpdateMaskHelpers::GetBlockFlag(index); + _updateMask[UpdateMaskHelpers::GetBlockIndex(index)] |= UpdateMaskHelpers::GetBlockFlag(index); } void ClearChanged(std::size_t index) { - std::size_t block = UpdateMaskHelpers::GetBlockIndex(index); - if (block >= _updateMask.size()) - _updateMask.emplace_back(0); - - _updateMask[block] &= ~UpdateMaskHelpers::GetBlockFlag(index); + _updateMask[UpdateMaskHelpers::GetBlockIndex(index)] &= ~UpdateMaskHelpers::GetBlockFlag(index); } void ClearChangesMask() { - std::fill(_updateMask.begin(), _updateMask.end(), 0); + std::memset(_updateMask.data(), 0, _updateMask.size() * sizeof(uint32)); } std::vector _values; @@ -896,7 +877,10 @@ namespace UF class OptionalUpdateFieldBase : public IsUpdateFieldHolderTag { template - friend struct MutableFieldReference; + friend struct MutableFieldReferenceWithChangesMask; + + template + friend struct MutableFieldReferenceNoChangesMask; template friend struct MutableNestedFieldReference; @@ -940,17 +924,10 @@ namespace UF private: void ConstructValue() { - ConstructValue(IsLarge{}); - } - - void ConstructValue(std::false_type) - { - _value.emplace(); - } - - void ConstructValue(std::true_type) - { - _value = std::make_unique(); + if constexpr (IsLarge::value) + _value = std::make_unique(); + else + _value.emplace(); } void DestroyValue() diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.cpp b/src/server/game/Entities/Object/Updates/UpdateFields.cpp index 419e2eca445..23079db0c41 100644 --- a/src/server/game/Entities/Object/Updates/UpdateFields.cpp +++ b/src/server/game/Entities/Object/Updates/UpdateFields.cpp @@ -315,26 +315,31 @@ void ItemData::WriteCreate(ByteBuffer& data, EnumFlag fieldVisi Modifiers->WriteCreate(data, owner, receiver); } -void ItemData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, Item const* owner, Player const* receiver) const +static constexpr void ItemDataAppendAllowedFieldsMaskForFlag(ItemData::Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { - Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); - WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); + if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner)) + allowedMaskForTarget |= std::array{ 0x07F58D80u, 0x00000000u }; } void ItemData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { - if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner)) - allowedMaskForTarget |= std::array{ 0x07F58D80u, 0x00000000u }; + ItemDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); } void ItemData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag fieldVisibilityFlags) { Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + ItemDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); changesMask &= allowedMaskForTarget; } +void ItemData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, Item const* owner, Player const* receiver) const +{ + Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu }); + ItemDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); +} + void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Item const* owner, Player const* receiver) const { data.WriteBits(changesMask.GetBlocksMask(0), 2); @@ -697,26 +702,31 @@ void AzeriteItemData::WriteCreate(ByteBuffer& data, EnumFlag fi data.FlushBits(); } -void AzeriteItemData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, AzeriteItem const* owner, Player const* receiver) const +static constexpr void AzeriteItemDataAppendAllowedFieldsMaskForFlag(AzeriteItemData::Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { - Mask allowedMaskForTarget({ 0x0000001Du }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); - WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); + if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner)) + allowedMaskForTarget |= std::array{ 0x000003E2u }; } void AzeriteItemData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { - if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner)) - allowedMaskForTarget |= std::array{ 0x000003E2u }; + AzeriteItemDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); } void AzeriteItemData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag fieldVisibilityFlags) { Mask allowedMaskForTarget({ 0x0000001Du }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + AzeriteItemDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); changesMask &= allowedMaskForTarget; } +void AzeriteItemData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, AzeriteItem const* owner, Player const* receiver) const +{ + Mask allowedMaskForTarget({ 0x0000001Du }); + AzeriteItemDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); +} + void AzeriteItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, AzeriteItem const* owner, Player const* receiver) const { data.WriteBits(changesMask.GetBlock(0), 10); @@ -1142,14 +1152,7 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag fieldVisi data.FlushBits(); } -void UnitData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, Unit const* owner, Player const* receiver) const -{ - Mask allowedMaskForTarget({ 0xFFFEFFFFu, 0x0FFBFFFFu, 0x00F7FFFFu, 0xFFFFF801u, 0x0FFFFFFFu, 0x007F0000u, 0x00000000u }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); - WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); -} - -void UnitData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) +static constexpr void UnitDataAppendAllowedFieldsMaskForFlag(UnitData::Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner)) allowedMaskForTarget |= std::array{ 0x00010000u, 0xF0040000u, 0xFF080000u, 0x000007FEu, 0xF0000080u, 0xFF80FFFFu, 0x3FFFFFFFu }; @@ -1159,13 +1162,25 @@ void UnitData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFl allowedMaskForTarget |= std::array{ 0x00000000u, 0xF0000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x0000FF00u }; } +void UnitData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) +{ + UnitDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); +} + void UnitData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag fieldVisibilityFlags) { Mask allowedMaskForTarget({ 0xFFFEFFFFu, 0x0FFBFFFFu, 0x00F7FFFFu, 0xFFFFF801u, 0x0FFFFFFFu, 0x007F0000u, 0x00000000u }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + UnitDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); changesMask &= allowedMaskForTarget; } +void UnitData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, Unit const* owner, Player const* receiver) const +{ + Mask allowedMaskForTarget({ 0xFFFEFFFFu, 0x0FFBFFFFu, 0x00F7FFFFu, 0xFFFFF801u, 0x0FFFFFFFu, 0x007F0000u, 0x00000000u }); + UnitDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); +} + void UnitData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Unit const* owner, Player const* receiver) const { data.WriteBits(changesMask.GetBlocksMask(0), 7); @@ -2461,26 +2476,31 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag fieldVi data.FlushBits(); } -void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, Player const* owner, Player const* receiver) const +static constexpr void PlayerDataAppendAllowedFieldsMaskForFlag(PlayerData::Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { - Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000003u }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); - WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); + if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember)) + allowedMaskForTarget |= std::array{ 0x00000022u, 0xFFFE0000u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000001u, 0x00000000u, 0x00000000u, 0x00000000u }; } void PlayerData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag fieldVisibilityFlags) { - if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember)) - allowedMaskForTarget |= std::array{ 0x00000022u, 0xFFFE0000u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000001u, 0x00000000u, 0x00000000u, 0x00000000u }; + PlayerDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); } void PlayerData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag fieldVisibilityFlags) { Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000003u }); - AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + PlayerDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); changesMask &= allowedMaskForTarget; } +void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag fieldVisibilityFlags, Player const* owner, Player const* receiver) const +{ + Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000003u }); + PlayerDataAppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags); + WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver); +} + void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Player const* owner, Player const* receiver) const { data.WriteBits(changesMask.GetBlocksMask(0), 11); diff --git a/src/server/game/Entities/Object/Updates/UpdateMask.h b/src/server/game/Entities/Object/Updates/UpdateMask.h index a79b5c038ab..4ccb7af8fbb 100644 --- a/src/server/game/Entities/Object/Updates/UpdateMask.h +++ b/src/server/game/Entities/Object/Updates/UpdateMask.h @@ -139,7 +139,7 @@ private: }; template -UpdateMask operator&(UpdateMask const& left, UpdateMask const& right) +constexpr UpdateMask operator&(UpdateMask const& left, UpdateMask const& right) { UpdateMask result = left; result &= right; @@ -147,7 +147,7 @@ UpdateMask operator&(UpdateMask const& left, UpdateMask const& } template -UpdateMask operator|(UpdateMask const& left, UpdateMask const& right) +constexpr UpdateMask operator|(UpdateMask const& left, UpdateMask const& right) { UpdateMask result = left; result |= right; -- cgit v1.2.3