TrinityCore
UpdateFields.cpp
Go to the documentation of this file.
1/*
2 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#include "UpdateFields.h"
19#include "AreaTrigger.h"
20#include "ByteBuffer.h"
21#include "Corpse.h"
22#include "DynamicObject.h"
23#include "Player.h"
25
26// This file is automatically generated, DO NOT EDIT
27
28#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
29#pragma GCC diagnostic push
30#pragma GCC diagnostic ignored "-Wunused-parameter"
31#else
32#pragma warning(push)
33#pragma warning(disable: 4100)
34#endif
35
36namespace UF
37{
38void ObjectData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Object const* owner, Player const* receiver) const
39{
40 data << int32(ViewerDependentValue<EntryIDTag>::GetValue(this, owner, receiver));
41 data << uint32(ViewerDependentValue<DynamicFlagsTag>::GetValue(this, owner, receiver));
42 data << float(Scale);
43}
44
45void ObjectData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Object const* owner, Player const* receiver) const
46{
47 WriteUpdate(data, _changesMask, false, owner, receiver);
48}
49
50void ObjectData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Object const* owner, Player const* receiver) const
51{
52 data.WriteBits(changesMask.GetBlock(0), 4);
53
54 data.FlushBits();
55 if (changesMask[0])
56 {
57 if (changesMask[1])
58 {
59 data << int32(ViewerDependentValue<EntryIDTag>::GetValue(this, owner, receiver));
60 }
61 if (changesMask[2])
62 {
63 data << uint32(ViewerDependentValue<DynamicFlagsTag>::GetValue(this, owner, receiver));
64 }
65 if (changesMask[3])
66 {
67 data << float(Scale);
68 }
69 }
70}
71
73{
78}
79
80void ItemEnchantment::WriteCreate(ByteBuffer& data, Item const* owner, Player const* receiver) const
81{
82 data << int32(ID);
83 data << uint32(Duration);
84 data << int16(Charges);
85 data << uint16(Inactive);
86}
87
88void ItemEnchantment::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Item const* owner, Player const* receiver) const
89{
90 Mask changesMask = _changesMask;
91 if (ignoreChangesMask)
92 changesMask.SetAll();
93
94 data.WriteBits(changesMask.GetBlock(0), 5);
95
96 data.FlushBits();
97 if (changesMask[0])
98 {
99 if (changesMask[1])
100 {
101 data << int32(ID);
102 }
103 if (changesMask[2])
104 {
105 data << uint32(Duration);
106 }
107 if (changesMask[3])
108 {
109 data << int16(Charges);
110 }
111 if (changesMask[4])
112 {
113 data << uint16(Inactive);
114 }
115 }
116}
117
119{
125}
126
127void ItemMod::WriteCreate(ByteBuffer& data, Item const* owner, Player const* receiver) const
128{
129 data << uint8(Type);
130 data << int32(Value);
131}
132
133void ItemMod::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Item const* owner, Player const* receiver) const
134{
135 data << uint8(Type);
136 data << int32(Value);
137}
138
139bool ItemMod::operator==(ItemMod const& right) const
140{
141 return Type == right.Type
142 && Value == right.Value;
143}
144
145void ItemModList::WriteCreate(ByteBuffer& data, Item const* owner, Player const* receiver) const
146{
147 data.WriteBits(Values.size(), 6);
148 for (uint32 i = 0; i < Values.size(); ++i)
149 {
150 Values[i].WriteCreate(data, owner, receiver);
151 }
152 data.FlushBits();
153}
154
155void ItemModList::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Item const* owner, Player const* receiver) const
156{
157 Mask changesMask = _changesMask;
158 if (ignoreChangesMask)
159 changesMask.SetAll();
160
161 data.WriteBits(changesMask.GetBlock(0), 1);
162
163 if (changesMask[0])
164 {
165 if (!ignoreChangesMask)
166 Values.WriteUpdateMask(data, 6);
167 else
169 }
170 data.FlushBits();
171 if (changesMask[0])
172 {
173 for (uint32 i = 0; i < Values.size(); ++i)
174 {
175 if (Values.HasChanged(i) || ignoreChangesMask)
176 {
177 Values[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
178 }
179 }
180 }
181 data.FlushBits();
182}
183
185{
188}
189
190void ArtifactPower::WriteCreate(ByteBuffer& data, Item const* owner, Player const* receiver) const
191{
192 data << int16(ArtifactPowerID);
193 data << uint8(PurchasedRank);
195}
196
197void ArtifactPower::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Item const* owner, Player const* receiver) const
198{
199 data << int16(ArtifactPowerID);
200 data << uint8(PurchasedRank);
202}
203
205{
206 return ArtifactPowerID == right.ArtifactPowerID
207 && PurchasedRank == right.PurchasedRank
209}
210
211void SocketedGem::WriteCreate(ByteBuffer& data, Item const* owner, Player const* receiver) const
212{
213 data << int32(ItemID);
214 for (uint32 i = 0; i < 16; ++i)
215 {
216 data << uint16(BonusListIDs[i]);
217 }
218 data << uint8(Context);
219}
220
221void SocketedGem::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Item const* owner, Player const* receiver) const
222{
223 Mask changesMask = _changesMask;
224 if (ignoreChangesMask)
225 changesMask.SetAll();
226
227 data.WriteBits(changesMask.GetBlocksMask(0), 1);
228 if (changesMask.GetBlock(0))
229 data.WriteBits(changesMask.GetBlock(0), 32);
230
231 data.FlushBits();
232 if (changesMask[0])
233 {
234 if (changesMask[1])
235 {
236 data << int32(ItemID);
237 }
238 if (changesMask[2])
239 {
240 data << uint8(Context);
241 }
242 }
243 if (changesMask[3])
244 {
245 for (uint32 i = 0; i < 16; ++i)
246 {
247 if (changesMask[4 + i])
248 {
249 data << uint16(BonusListIDs[i]);
250 }
251 }
252 }
253}
254
256{
261}
262
263void ItemData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Item const* owner, Player const* receiver) const
264{
265 data << Owner;
266 data << ContainedIn;
267 data << Creator;
268 data << GiftCreator;
269 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
270 {
271 data << uint32(StackCount);
272 data << uint32(Expiration);
273 for (uint32 i = 0; i < 5; ++i)
274 {
275 data << int32(SpellCharges[i]);
276 }
277 }
278 data << uint32(DynamicFlags);
279 for (uint32 i = 0; i < 13; ++i)
280 {
281 Enchantment[i].WriteCreate(data, owner, receiver);
282 }
283 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
284 {
285 data << uint32(Durability);
286 data << uint32(MaxDurability);
287 }
288 data << uint32(CreatePlayedTime);
289 data << uint8(Context);
290 data << int64(CreateTime);
291 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
292 {
293 data << uint64(ArtifactXP);
294 data << uint8(ItemAppearanceModID);
295 }
296 data << uint32(ArtifactPowers.size());
297 data << uint32(Gems.size());
298 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
299 {
300 data << uint32(ZoneFlags);
301 }
302 data << ItemBonusKey;
303 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
304 {
305 data << uint16(DEBUGItemLevel);
306 }
307 for (uint32 i = 0; i < ArtifactPowers.size(); ++i)
308 {
309 ArtifactPowers[i].WriteCreate(data, owner, receiver);
310 }
311 for (uint32 i = 0; i < Gems.size(); ++i)
312 {
313 Gems[i].WriteCreate(data, owner, receiver);
314 }
315 Modifiers->WriteCreate(data, owner, receiver);
316}
317
318void ItemData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Item const* owner, Player const* receiver) const
319{
320 Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu });
321 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
322 WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
323}
324
325void ItemData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
326{
327 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
328 allowedMaskForTarget |= std::array<uint32, 2>{ 0x07F58D80u, 0x00000000u };
329}
330
332{
333 Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu });
334 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
335 changesMask &= allowedMaskForTarget;
336}
337
338void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Item const* owner, Player const* receiver) const
339{
340 data.WriteBits(changesMask.GetBlocksMask(0), 2);
341 for (uint32 i = 0; i < 2; ++i)
342 if (changesMask.GetBlock(i))
343 data.WriteBits(changesMask.GetBlock(i), 32);
344
345 if (changesMask[0])
346 {
347 if (changesMask[1])
348 {
349 if (!ignoreNestedChangesMask)
351 else
353 }
354 if (changesMask[2])
355 {
356 if (!ignoreNestedChangesMask)
357 Gems.WriteUpdateMask(data);
358 else
360 }
361 }
362 data.FlushBits();
363 if (changesMask[0])
364 {
365 if (changesMask[1])
366 {
367 for (uint32 i = 0; i < ArtifactPowers.size(); ++i)
368 {
369 if (ArtifactPowers.HasChanged(i) || ignoreNestedChangesMask)
370 {
371 ArtifactPowers[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
372 }
373 }
374 }
375 if (changesMask[2])
376 {
377 for (uint32 i = 0; i < Gems.size(); ++i)
378 {
379 if (Gems.HasChanged(i) || ignoreNestedChangesMask)
380 {
381 Gems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
382 }
383 }
384 }
385 if (changesMask[3])
386 {
387 data << Owner;
388 }
389 if (changesMask[4])
390 {
391 data << ContainedIn;
392 }
393 if (changesMask[5])
394 {
395 data << Creator;
396 }
397 if (changesMask[6])
398 {
399 data << GiftCreator;
400 }
401 if (changesMask[7])
402 {
403 data << uint32(StackCount);
404 }
405 if (changesMask[8])
406 {
407 data << uint32(Expiration);
408 }
409 if (changesMask[9])
410 {
411 data << uint32(DynamicFlags);
412 }
413 if (changesMask[10])
414 {
415 data << uint32(Durability);
416 }
417 if (changesMask[11])
418 {
419 data << uint32(MaxDurability);
420 }
421 if (changesMask[12])
422 {
423 data << uint32(CreatePlayedTime);
424 }
425 if (changesMask[13])
426 {
427 data << uint8(Context);
428 }
429 if (changesMask[14])
430 {
431 data << int64(CreateTime);
432 }
433 if (changesMask[15])
434 {
435 data << uint64(ArtifactXP);
436 }
437 if (changesMask[16])
438 {
439 data << uint8(ItemAppearanceModID);
440 }
441 if (changesMask[18])
442 {
443 data << uint32(ZoneFlags);
444 }
445 if (changesMask[19])
446 {
447 data << ItemBonusKey;
448 }
449 if (changesMask[20])
450 {
451 data << uint16(DEBUGItemLevel);
452 }
453 if (changesMask[17])
454 {
455 Modifiers->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
456 }
457 }
458 if (changesMask[21])
459 {
460 for (uint32 i = 0; i < 5; ++i)
461 {
462 if (changesMask[22 + i])
463 {
464 data << int32(SpellCharges[i]);
465 }
466 }
467 }
468 if (changesMask[27])
469 {
470 for (uint32 i = 0; i < 13; ++i)
471 {
472 if (changesMask[28 + i])
473 {
474 Enchantment[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
475 }
476 }
477 }
478}
479
481{
505}
506
507void ContainerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Bag const* owner, Player const* receiver) const
508{
509 for (uint32 i = 0; i < 98; ++i)
510 {
511 data << Slots[i];
512 }
513 data << uint32(NumSlots);
514}
515
516void ContainerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Bag const* owner, Player const* receiver) const
517{
518 WriteUpdate(data, _changesMask, false, owner, receiver);
519}
520
521void ContainerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Bag const* owner, Player const* receiver) const
522{
523 data.WriteBits(changesMask.GetBlocksMask(0), 4);
524 for (uint32 i = 0; i < 4; ++i)
525 if (changesMask.GetBlock(i))
526 data.WriteBits(changesMask.GetBlock(i), 32);
527
528 data.FlushBits();
529 if (changesMask[0])
530 {
531 if (changesMask[1])
532 {
533 data << uint32(NumSlots);
534 }
535 }
536 if (changesMask[2])
537 {
538 for (uint32 i = 0; i < 98; ++i)
539 {
540 if (changesMask[3 + i])
541 {
542 data << Slots[i];
543 }
544 }
545 }
546}
547
549{
553}
554
555void AzeriteEmpoweredItemData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AzeriteEmpoweredItem const* owner, Player const* receiver) const
556{
557 for (uint32 i = 0; i < 5; ++i)
558 {
559 data << int32(Selections[i]);
560 }
561}
562
563void AzeriteEmpoweredItemData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AzeriteEmpoweredItem const* owner, Player const* receiver) const
564{
565 WriteUpdate(data, _changesMask, false, owner, receiver);
566}
567
568void AzeriteEmpoweredItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, AzeriteEmpoweredItem const* owner, Player const* receiver) const
569{
570 data.WriteBits(changesMask.GetBlocksMask(0), 1);
571 if (changesMask.GetBlock(0))
572 data.WriteBits(changesMask.GetBlock(0), 32);
573
574 data.FlushBits();
575 if (changesMask[0])
576 {
577 for (uint32 i = 0; i < 5; ++i)
578 {
579 if (changesMask[1 + i])
580 {
581 data << int32(Selections[i]);
582 }
583 }
584 }
585}
586
588{
591}
592
593void UnlockedAzeriteEssence::WriteCreate(ByteBuffer& data, AzeriteItem const* owner, Player const* receiver) const
594{
595 data << uint32(AzeriteEssenceID);
596 data << uint32(Rank);
597}
598
599void UnlockedAzeriteEssence::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, AzeriteItem const* owner, Player const* receiver) const
600{
601 data << uint32(AzeriteEssenceID);
602 data << uint32(Rank);
603}
604
606{
607 return AzeriteEssenceID == right.AzeriteEssenceID
608 && Rank == right.Rank;
609}
610
611void SelectedAzeriteEssences::WriteCreate(ByteBuffer& data, AzeriteItem const* owner, Player const* receiver) const
612{
613 for (uint32 i = 0; i < 4; ++i)
614 {
615 data << uint32(AzeriteEssenceID[i]);
616 }
617 data << uint32(SpecializationID);
618 data.WriteBit(Enabled);
619 data.FlushBits();
620}
621
622void SelectedAzeriteEssences::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, AzeriteItem const* owner, Player const* receiver) const
623{
624 Mask changesMask = _changesMask;
625 if (ignoreChangesMask)
626 changesMask.SetAll();
627
628 data.WriteBits(changesMask.GetBlocksMask(0), 1);
629 if (changesMask.GetBlock(0))
630 data.WriteBits(changesMask.GetBlock(0), 32);
631
632 if (changesMask[0])
633 {
634 if (changesMask[1])
635 {
636 data.WriteBit(Enabled);
637 }
638 }
639 data.FlushBits();
640 if (changesMask[0])
641 {
642 if (changesMask[2])
643 {
644 data << uint32(SpecializationID);
645 }
646 }
647 if (changesMask[3])
648 {
649 for (uint32 i = 0; i < 4; ++i)
650 {
651 if (changesMask[4 + i])
652 {
653 data << uint32(AzeriteEssenceID[i]);
654 }
655 }
656 }
657 data.FlushBits();
658}
659
661{
666}
667
668void AzeriteItemData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AzeriteItem const* owner, Player const* receiver) const
669{
670 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
671 {
672 data << uint64(Xp);
673 data << uint32(Level);
674 data << uint32(AuraLevel);
675 data << uint32(KnowledgeLevel);
676 data << int32(DEBUGknowledgeWeek);
677 }
678 data << uint32(UnlockedEssences.size());
679 data << uint32(SelectedEssences.size());
681 for (uint32 i = 0; i < UnlockedEssences.size(); ++i)
682 {
683 UnlockedEssences[i].WriteCreate(data, owner, receiver);
684 }
685 for (uint32 i = 0; i < UnlockedEssenceMilestones.size(); ++i)
686 {
688 }
689 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
690 {
691 data.WriteBit(Enabled);
692 }
693 for (uint32 i = 0; i < SelectedEssences.size(); ++i)
694 {
695 SelectedEssences[i].WriteCreate(data, owner, receiver);
696 }
697 data.FlushBits();
698}
699
700void AzeriteItemData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AzeriteItem const* owner, Player const* receiver) const
701{
702 Mask allowedMaskForTarget({ 0x0000001Du });
703 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
704 WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
705}
706
707void AzeriteItemData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
708{
709 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
710 allowedMaskForTarget |= std::array<uint32, 1>{ 0x000003E2u };
711}
712
714{
715 Mask allowedMaskForTarget({ 0x0000001Du });
716 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
717 changesMask &= allowedMaskForTarget;
718}
719
720void AzeriteItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, AzeriteItem const* owner, Player const* receiver) const
721{
722 data.WriteBits(changesMask.GetBlock(0), 10);
723
724 if (changesMask[0])
725 {
726 if (changesMask[1])
727 {
728 data.WriteBit(Enabled);
729 }
730 if (changesMask[2])
731 {
732 if (!ignoreNestedChangesMask)
734 else
736 }
737 if (changesMask[3])
738 {
739 if (!ignoreNestedChangesMask)
741 else
743 }
744 if (changesMask[4])
745 {
746 if (!ignoreNestedChangesMask)
748 else
750 }
751 }
752 data.FlushBits();
753 if (changesMask[0])
754 {
755 if (changesMask[2])
756 {
757 for (uint32 i = 0; i < UnlockedEssences.size(); ++i)
758 {
759 if (UnlockedEssences.HasChanged(i) || ignoreNestedChangesMask)
760 {
761 UnlockedEssences[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
762 }
763 }
764 }
765 if (changesMask[4])
766 {
767 for (uint32 i = 0; i < UnlockedEssenceMilestones.size(); ++i)
768 {
769 if (UnlockedEssenceMilestones.HasChanged(i) || ignoreNestedChangesMask)
770 {
772 }
773 }
774 }
775 if (changesMask[3])
776 {
777 for (uint32 i = 0; i < SelectedEssences.size(); ++i)
778 {
779 if (SelectedEssences.HasChanged(i) || ignoreNestedChangesMask)
780 {
781 SelectedEssences[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
782 }
783 }
784 }
785 if (changesMask[5])
786 {
787 data << uint64(Xp);
788 }
789 if (changesMask[6])
790 {
791 data << uint32(Level);
792 }
793 if (changesMask[7])
794 {
795 data << uint32(AuraLevel);
796 }
797 if (changesMask[8])
798 {
799 data << uint32(KnowledgeLevel);
800 }
801 if (changesMask[9])
802 {
803 data << int32(DEBUGknowledgeWeek);
804 }
805 }
806 data.FlushBits();
807}
808
810{
821}
822
823void SpellCastVisual::WriteCreate(ByteBuffer& data, Object const* owner, Player const* receiver) const
824{
825 data << int32(SpellXSpellVisualID);
826 data << int32(ScriptVisualID);
827}
828
829void SpellCastVisual::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Object const* owner, Player const* receiver) const
830{
831 data << int32(SpellXSpellVisualID);
832 data << int32(ScriptVisualID);
833}
834
836{
838 && ScriptVisualID == right.ScriptVisualID;
839}
840
841void UnitChannel::WriteCreate(ByteBuffer& data, Unit const* owner, Player const* receiver) const
842{
843 data << int32(SpellID);
844 SpellVisual.WriteCreate(data, owner, receiver);
845}
846
847void UnitChannel::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Unit const* owner, Player const* receiver) const
848{
849 data << int32(SpellID);
850 SpellVisual.WriteUpdate(data, ignoreChangesMask, owner, receiver);
851}
852
853bool UnitChannel::operator==(UnitChannel const& right) const
854{
855 return SpellID == right.SpellID
856 && SpellVisual == right.SpellVisual;
857}
858
859void VisibleItem::WriteCreate(ByteBuffer& data, Unit const* owner, Player const* receiver) const
860{
861 data << int32(ItemID);
865 data << uint16(ItemVisual);
866}
867
868void VisibleItem::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Unit const* owner, Player const* receiver) const
869{
870 Mask changesMask = _changesMask;
871 if (ignoreChangesMask)
872 changesMask.SetAll();
873
874 data.WriteBits(changesMask.GetBlock(0), 6);
875
876 data.FlushBits();
877 if (changesMask[0])
878 {
879 if (changesMask[1])
880 {
881 data << int32(ItemID);
882 }
883 if (changesMask[2])
884 {
886 }
887 if (changesMask[3])
888 {
890 }
891 if (changesMask[4])
892 {
894 }
895 if (changesMask[5])
896 {
897 data << uint16(ItemVisual);
898 }
899 }
900}
901
903{
910}
911
912void PassiveSpellHistory::WriteCreate(ByteBuffer& data, Unit const* owner, Player const* receiver) const
913{
914 data << int32(SpellID);
915 data << int32(AuraSpellID);
916}
917
918void PassiveSpellHistory::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Unit const* owner, Player const* receiver) const
919{
920 data << int32(SpellID);
921 data << int32(AuraSpellID);
922}
923
925{
926 return SpellID == right.SpellID
927 && AuraSpellID == right.AuraSpellID;
928}
929
930void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Unit const* owner, Player const* receiver) const
931{
932 data << int32(ViewerDependentValue<DisplayIDTag>::GetValue(this, owner, receiver));
933 data << uint32(ViewerDependentValue<NpcFlagsTag>::GetValue(this, owner, receiver));
934 data << uint32(ViewerDependentValue<NpcFlags2Tag>::GetValue(this, owner, receiver));
936 data << uint32(ViewerDependentValue<StateAnimIDTag>::GetValue(this, owner, receiver));
937 data << uint32(ViewerDependentValue<StateAnimKitIDTag>::GetValue(this, owner, receiver));
938 std::vector stateWorldEffects = ViewerDependentValue<StateWorldEffectIDsTag>::GetValue(this, owner, receiver);
939 data << uint32(stateWorldEffects.size());
941 data << int32(SpellOverrideNameID);
942 for (uint32 i = 0; i < stateWorldEffects.size(); ++i)
943 {
944 data << uint32((stateWorldEffects)[i]);
945 }
946 data << Charm;
947 data << Summon;
948 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
949 {
950 data << Critter;
951 }
952 data << CharmedBy;
953 data << SummonedBy;
954 data << CreatedBy;
955 data << DemonCreator;
957 data << Target;
959 data << uint64(BattlePetDBID);
960 ChannelData->WriteCreate(data, owner, receiver);
961 data << int8(SpellEmpowerStage);
963 data << uint8(Race);
964 data << uint8(ClassId);
965 data << uint8(PlayerClassId);
966 data << uint8(Sex);
967 data << uint8(DisplayPower);
969 data << int64(Health);
970 for (uint32 i = 0; i < 10; ++i)
971 {
972 data << int32(Power[i]);
973 data << int32(MaxPower[i]);
974 }
975 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner | UpdateFieldFlag::UnitAll))
976 {
977 for (uint32 i = 0; i < 10; ++i)
978 {
979 data << float(PowerRegenFlatModifier[i]);
980 data << float(PowerRegenInterruptedFlatModifier[i]);
981 }
982 }
983 data << int64(MaxHealth);
984 data << int32(Level);
985 data << int32(EffectiveLevel);
986 data << int32(ContentTuningID);
987 data << int32(ScalingLevelMin);
988 data << int32(ScalingLevelMax);
989 data << int32(ScalingLevelDelta);
990 data << int32(ScalingFactionGroup);
991 data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
992 for (uint32 i = 0; i < 3; ++i)
993 {
994 VirtualItems[i].WriteCreate(data, owner, receiver);
995 }
996 data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
997 data << uint32(ViewerDependentValue<Flags2Tag>::GetValue(this, owner, receiver));
998 data << uint32(ViewerDependentValue<Flags3Tag>::GetValue(this, owner, receiver));
999 data << uint32(ViewerDependentValue<AuraStateTag>::GetValue(this, owner, receiver));
1000 for (uint32 i = 0; i < 2; ++i)
1001 {
1002 data << uint32(AttackRoundBaseTime[i]);
1003 }
1004 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
1005 {
1007 }
1008 data << float(BoundingRadius);
1009 data << float(CombatReach);
1010 data << float(DisplayScale);
1011 data << int32(CreatureFamily);
1012 data << int32(CreatureType);
1013 data << int32(NativeDisplayID);
1014 data << float(NativeXDisplayScale);
1015 data << int32(MountDisplayID);
1017 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner | UpdateFieldFlag::Empath))
1018 {
1019 data << float(MinDamage);
1020 data << float(MaxDamage);
1021 data << float(MinOffHandDamage);
1022 data << float(MaxOffHandDamage);
1023 }
1024 data << uint8(StandState);
1025 data << uint8(PetTalentPoints);
1026 data << uint8(VisFlags);
1027 data << uint8(AnimTier);
1028 data << uint32(PetNumber);
1029 data << uint32(PetNameTimestamp);
1030 data << uint32(PetExperience);
1032 data << float(ModCastingSpeed);
1033 data << float(ModCastingSpeedNeg);
1034 data << float(ModSpellHaste);
1035 data << float(ModHaste);
1036 data << float(ModRangedHaste);
1037 data << float(ModHasteRegen);
1038 data << float(ModTimeRate);
1039 data << int32(CreatedBySpell);
1040 data << int32(EmoteState);
1041 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
1042 {
1043 for (uint32 i = 0; i < 4; ++i)
1044 {
1045 data << int32(Stats[i]);
1046 data << int32(StatPosBuff[i]);
1047 data << int32(StatNegBuff[i]);
1048 data << int32(StatSupportBuff[i]);
1049 }
1050 }
1051 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner | UpdateFieldFlag::Empath))
1052 {
1053 for (uint32 i = 0; i < 7; ++i)
1054 {
1055 data << int32(Resistances[i]);
1056 }
1057 }
1058 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
1059 {
1060 for (uint32 i = 0; i < 7; ++i)
1061 {
1062 data << int32(BonusResistanceMods[i]);
1063 data << int32(ManaCostModifier[i]);
1064 }
1065 }
1066 data << int32(BaseMana);
1067 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
1068 {
1069 data << int32(BaseHealth);
1070 }
1071 data << uint8(SheatheState);
1072 data << uint8(ViewerDependentValue<PvpFlagsTag>::GetValue(this, owner, receiver));
1073 data << uint8(PetFlags);
1074 data << uint8(ShapeshiftForm);
1075 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
1076 {
1077 data << int32(AttackPower);
1078 data << int32(AttackPowerModPos);
1079 data << int32(AttackPowerModNeg);
1080 data << float(AttackPowerMultiplier);
1082 data << int32(RangedAttackPower);
1085 data << float(RangedAttackPowerMultiplier);
1090 data << int32(SetAttackSpeedAura);
1091 data << float(Lifesteal);
1092 data << float(MinRangedDamage);
1093 data << float(MaxRangedDamage);
1094 data << float(ManaCostMultiplier);
1095 }
1096 data << float(MaxHealthModifier);
1097 data << float(HoverHeight);
1098 data << int32(MinItemLevelCutoff);
1099 data << int32(MinItemLevel);
1100 data << int32(MaxItemLevel);
1101 data << int32(AzeriteItemLevel);
1102 data << int32(WildBattlePetLevel);
1105 data << int32(ViewerDependentValue<InteractSpellIDTag>::GetValue(this, owner, receiver));
1106 data << int32(ScaleDuration);
1107 data << int32(LooksLikeMountID);
1108 data << int32(LooksLikeCreatureID);
1109 data << int32(LookAtControllerID);
1110 data << int32(PerksVendorItemID);
1111 data << int32(TaxiNodesID);
1112 data << GuildGUID;
1113 data << uint32(PassiveSpells.size());
1114 data << uint32(WorldEffects.size());
1115 data << uint32(ChannelObjects.size());
1116 data << int32(FlightCapabilityID);
1117 data << float(GlideEventSpeedDivisor);
1120 data << uint32(SilencedSchoolMask);
1121 data << uint32(CurrentAreaID);
1122 data << float(Field_31C);
1123 data << float(Field_320);
1124 data << NameplateAttachToGUID;
1125 for (uint32 i = 0; i < PassiveSpells.size(); ++i)
1126 {
1127 PassiveSpells[i].WriteCreate(data, owner, receiver);
1128 }
1129 for (uint32 i = 0; i < WorldEffects.size(); ++i)
1130 {
1131 data << int32(WorldEffects[i]);
1132 }
1133 for (uint32 i = 0; i < ChannelObjects.size(); ++i)
1134 {
1135 data << ChannelObjects[i];
1136 }
1137 data.WriteBit(Field_314);
1138 data.FlushBits();
1139}
1140
1141void UnitData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Unit const* owner, Player const* receiver) const
1142{
1143 Mask allowedMaskForTarget({ 0xFFFEFFFFu, 0x87FDFFFFu, 0x007BFFFFu, 0xFFFFFC01u, 0x03FFFFFFu, 0x001FC000u, 0x00000000u });
1144 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
1145 WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
1146}
1147
1148void UnitData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
1149{
1150 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
1151 allowedMaskForTarget |= std::array<uint32, 7>{ 0x00010000u, 0x78020000u, 0xFF840000u, 0x000003FEu, 0xFC000020u, 0xFFE03FFFu, 0x0FFFFFFFu };
1152 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::UnitAll))
1153 allowedMaskForTarget |= std::array<uint32, 7>{ 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFC000020u, 0x00003FFFu, 0x00000000u };
1154 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Empath))
1155 allowedMaskForTarget |= std::array<uint32, 7>{ 0x00000000u, 0x78000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00003FC0u };
1156}
1157
1159{
1160 Mask allowedMaskForTarget({ 0xFFFEFFFFu, 0x87FDFFFFu, 0x007BFFFFu, 0xFFFFFC01u, 0x03FFFFFFu, 0x001FC000u, 0x00000000u });
1161 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
1162 changesMask &= allowedMaskForTarget;
1163}
1164
1165void UnitData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Unit const* owner, Player const* receiver) const
1166{
1167 data.WriteBits(changesMask.GetBlocksMask(0), 7);
1168 for (uint32 i = 0; i < 7; ++i)
1169 if (changesMask.GetBlock(i))
1170 data.WriteBits(changesMask.GetBlock(i), 32);
1171
1172 if (changesMask[0])
1173 {
1174 if (changesMask[1])
1175 {
1176 data.WriteBit(Field_314);
1177 }
1178 if (changesMask[2])
1179 {
1180 std::vector stateWorldEffects = ViewerDependentValue<StateWorldEffectIDsTag>::GetValue(this, owner, receiver);
1181 data.WriteBits(stateWorldEffects.size(), 32);
1182 for (uint32 i = 0; i < stateWorldEffects.size(); ++i)
1183 {
1184 data << uint32((stateWorldEffects)[i]);
1185 }
1186 }
1187 }
1188 data.FlushBits();
1189 if (changesMask[0])
1190 {
1191 if (changesMask[3])
1192 {
1193 if (!ignoreNestedChangesMask)
1195 else
1197 }
1198 if (changesMask[4])
1199 {
1200 if (!ignoreNestedChangesMask)
1202 else
1204 }
1205 if (changesMask[5])
1206 {
1207 if (!ignoreNestedChangesMask)
1209 else
1211 }
1212 }
1213 data.FlushBits();
1214 if (changesMask[0])
1215 {
1216 if (changesMask[3])
1217 {
1218 for (uint32 i = 0; i < PassiveSpells.size(); ++i)
1219 {
1220 if (PassiveSpells.HasChanged(i) || ignoreNestedChangesMask)
1221 {
1222 PassiveSpells[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
1223 }
1224 }
1225 }
1226 if (changesMask[4])
1227 {
1228 for (uint32 i = 0; i < WorldEffects.size(); ++i)
1229 {
1230 if (WorldEffects.HasChanged(i) || ignoreNestedChangesMask)
1231 {
1232 data << int32(WorldEffects[i]);
1233 }
1234 }
1235 }
1236 if (changesMask[5])
1237 {
1238 for (uint32 i = 0; i < ChannelObjects.size(); ++i)
1239 {
1240 if (ChannelObjects.HasChanged(i) || ignoreNestedChangesMask)
1241 {
1242 data << ChannelObjects[i];
1243 }
1244 }
1245 }
1246 if (changesMask[6])
1247 {
1248 data << int32(ViewerDependentValue<DisplayIDTag>::GetValue(this, owner, receiver));
1249 }
1250 if (changesMask[7])
1251 {
1252 data << uint32(ViewerDependentValue<NpcFlagsTag>::GetValue(this, owner, receiver));
1253 }
1254 if (changesMask[8])
1255 {
1256 data << uint32(ViewerDependentValue<NpcFlags2Tag>::GetValue(this, owner, receiver));
1257 }
1258 if (changesMask[9])
1259 {
1260 data << uint32(ViewerDependentValue<StateSpellVisualIDTag>::GetValue(this, owner, receiver));
1261 }
1262 if (changesMask[10])
1263 {
1264 data << uint32(ViewerDependentValue<StateAnimIDTag>::GetValue(this, owner, receiver));
1265 }
1266 if (changesMask[11])
1267 {
1268 data << uint32(ViewerDependentValue<StateAnimKitIDTag>::GetValue(this, owner, receiver));
1269 }
1270 if (changesMask[12])
1271 {
1273 }
1274 if (changesMask[13])
1275 {
1276 data << int32(SpellOverrideNameID);
1277 }
1278 if (changesMask[14])
1279 {
1280 data << Charm;
1281 }
1282 if (changesMask[15])
1283 {
1284 data << Summon;
1285 }
1286 if (changesMask[16])
1287 {
1288 data << Critter;
1289 }
1290 if (changesMask[17])
1291 {
1292 data << CharmedBy;
1293 }
1294 if (changesMask[18])
1295 {
1296 data << SummonedBy;
1297 }
1298 if (changesMask[19])
1299 {
1300 data << CreatedBy;
1301 }
1302 if (changesMask[20])
1303 {
1304 data << DemonCreator;
1305 }
1306 if (changesMask[21])
1307 {
1308 data << LookAtControllerTarget;
1309 }
1310 if (changesMask[22])
1311 {
1312 data << Target;
1313 }
1314 if (changesMask[23])
1315 {
1316 data << BattlePetCompanionGUID;
1317 }
1318 if (changesMask[24])
1319 {
1320 data << uint64(BattlePetDBID);
1321 }
1322 if (changesMask[25])
1323 {
1324 ChannelData->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
1325 }
1326 if (changesMask[26])
1327 {
1328 data << int8(SpellEmpowerStage);
1329 }
1330 if (changesMask[27])
1331 {
1332 data << uint32(SummonedByHomeRealm);
1333 }
1334 if (changesMask[28])
1335 {
1336 data << uint8(Race);
1337 }
1338 if (changesMask[29])
1339 {
1340 data << uint8(ClassId);
1341 }
1342 if (changesMask[30])
1343 {
1344 data << uint8(PlayerClassId);
1345 }
1346 if (changesMask[31])
1347 {
1348 data << uint8(Sex);
1349 }
1350 }
1351 if (changesMask[32])
1352 {
1353 if (changesMask[33])
1354 {
1355 data << uint8(DisplayPower);
1356 }
1357 if (changesMask[34])
1358 {
1360 }
1361 if (changesMask[35])
1362 {
1363 data << int64(Health);
1364 }
1365 if (changesMask[36])
1366 {
1367 data << int64(MaxHealth);
1368 }
1369 if (changesMask[37])
1370 {
1371 data << int32(Level);
1372 }
1373 if (changesMask[38])
1374 {
1375 data << int32(EffectiveLevel);
1376 }
1377 if (changesMask[39])
1378 {
1379 data << int32(ContentTuningID);
1380 }
1381 if (changesMask[40])
1382 {
1383 data << int32(ScalingLevelMin);
1384 }
1385 if (changesMask[41])
1386 {
1387 data << int32(ScalingLevelMax);
1388 }
1389 if (changesMask[42])
1390 {
1391 data << int32(ScalingLevelDelta);
1392 }
1393 if (changesMask[43])
1394 {
1395 data << int32(ScalingFactionGroup);
1396 }
1397 if (changesMask[44])
1398 {
1399 data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
1400 }
1401 if (changesMask[45])
1402 {
1403 data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
1404 }
1405 if (changesMask[46])
1406 {
1407 data << uint32(ViewerDependentValue<Flags2Tag>::GetValue(this, owner, receiver));
1408 }
1409 if (changesMask[47])
1410 {
1411 data << uint32(ViewerDependentValue<Flags3Tag>::GetValue(this, owner, receiver));
1412 }
1413 if (changesMask[48])
1414 {
1415 data << uint32(ViewerDependentValue<AuraStateTag>::GetValue(this, owner, receiver));
1416 }
1417 if (changesMask[49])
1418 {
1420 }
1421 if (changesMask[50])
1422 {
1423 data << float(BoundingRadius);
1424 }
1425 if (changesMask[51])
1426 {
1427 data << float(CombatReach);
1428 }
1429 if (changesMask[52])
1430 {
1431 data << float(DisplayScale);
1432 }
1433 if (changesMask[53])
1434 {
1435 data << int32(CreatureFamily);
1436 }
1437 if (changesMask[54])
1438 {
1439 data << int32(CreatureType);
1440 }
1441 if (changesMask[55])
1442 {
1443 data << int32(NativeDisplayID);
1444 }
1445 if (changesMask[56])
1446 {
1447 data << float(NativeXDisplayScale);
1448 }
1449 if (changesMask[57])
1450 {
1451 data << int32(MountDisplayID);
1452 }
1453 if (changesMask[58])
1454 {
1456 }
1457 if (changesMask[59])
1458 {
1459 data << float(MinDamage);
1460 }
1461 if (changesMask[60])
1462 {
1463 data << float(MaxDamage);
1464 }
1465 if (changesMask[61])
1466 {
1467 data << float(MinOffHandDamage);
1468 }
1469 if (changesMask[62])
1470 {
1471 data << float(MaxOffHandDamage);
1472 }
1473 if (changesMask[63])
1474 {
1475 data << uint8(StandState);
1476 }
1477 }
1478 if (changesMask[64])
1479 {
1480 if (changesMask[65])
1481 {
1482 data << uint8(PetTalentPoints);
1483 }
1484 if (changesMask[66])
1485 {
1486 data << uint8(VisFlags);
1487 }
1488 if (changesMask[67])
1489 {
1490 data << uint8(AnimTier);
1491 }
1492 if (changesMask[68])
1493 {
1494 data << uint32(PetNumber);
1495 }
1496 if (changesMask[69])
1497 {
1498 data << uint32(PetNameTimestamp);
1499 }
1500 if (changesMask[70])
1501 {
1502 data << uint32(PetExperience);
1503 }
1504 if (changesMask[71])
1505 {
1507 }
1508 if (changesMask[72])
1509 {
1510 data << float(ModCastingSpeed);
1511 }
1512 if (changesMask[73])
1513 {
1514 data << float(ModCastingSpeedNeg);
1515 }
1516 if (changesMask[74])
1517 {
1518 data << float(ModSpellHaste);
1519 }
1520 if (changesMask[75])
1521 {
1522 data << float(ModHaste);
1523 }
1524 if (changesMask[76])
1525 {
1526 data << float(ModRangedHaste);
1527 }
1528 if (changesMask[77])
1529 {
1530 data << float(ModHasteRegen);
1531 }
1532 if (changesMask[78])
1533 {
1534 data << float(ModTimeRate);
1535 }
1536 if (changesMask[79])
1537 {
1538 data << int32(CreatedBySpell);
1539 }
1540 if (changesMask[80])
1541 {
1542 data << int32(EmoteState);
1543 }
1544 if (changesMask[81])
1545 {
1546 data << int32(BaseMana);
1547 }
1548 if (changesMask[82])
1549 {
1550 data << int32(BaseHealth);
1551 }
1552 if (changesMask[83])
1553 {
1554 data << uint8(SheatheState);
1555 }
1556 if (changesMask[84])
1557 {
1558 data << uint8(ViewerDependentValue<PvpFlagsTag>::GetValue(this, owner, receiver));
1559 }
1560 if (changesMask[85])
1561 {
1562 data << uint8(PetFlags);
1563 }
1564 if (changesMask[86])
1565 {
1566 data << uint8(ShapeshiftForm);
1567 }
1568 if (changesMask[87])
1569 {
1570 data << int32(AttackPower);
1571 }
1572 if (changesMask[88])
1573 {
1574 data << int32(AttackPowerModPos);
1575 }
1576 if (changesMask[89])
1577 {
1578 data << int32(AttackPowerModNeg);
1579 }
1580 if (changesMask[90])
1581 {
1582 data << float(AttackPowerMultiplier);
1583 }
1584 if (changesMask[91])
1585 {
1587 }
1588 if (changesMask[92])
1589 {
1590 data << int32(RangedAttackPower);
1591 }
1592 if (changesMask[93])
1593 {
1595 }
1596 if (changesMask[94])
1597 {
1599 }
1600 if (changesMask[95])
1601 {
1602 data << float(RangedAttackPowerMultiplier);
1603 }
1604 }
1605 if (changesMask[96])
1606 {
1607 if (changesMask[97])
1608 {
1610 }
1611 if (changesMask[98])
1612 {
1614 }
1615 if (changesMask[99])
1616 {
1618 }
1619 if (changesMask[100])
1620 {
1622 }
1623 if (changesMask[101])
1624 {
1625 data << int32(SetAttackSpeedAura);
1626 }
1627 if (changesMask[102])
1628 {
1629 data << float(Lifesteal);
1630 }
1631 if (changesMask[103])
1632 {
1633 data << float(MinRangedDamage);
1634 }
1635 if (changesMask[104])
1636 {
1637 data << float(MaxRangedDamage);
1638 }
1639 if (changesMask[105])
1640 {
1641 data << float(ManaCostMultiplier);
1642 }
1643 if (changesMask[106])
1644 {
1645 data << float(MaxHealthModifier);
1646 }
1647 if (changesMask[107])
1648 {
1649 data << float(HoverHeight);
1650 }
1651 if (changesMask[108])
1652 {
1653 data << int32(MinItemLevelCutoff);
1654 }
1655 if (changesMask[109])
1656 {
1657 data << int32(MinItemLevel);
1658 }
1659 if (changesMask[110])
1660 {
1661 data << int32(MaxItemLevel);
1662 }
1663 if (changesMask[111])
1664 {
1665 data << int32(AzeriteItemLevel);
1666 }
1667 if (changesMask[112])
1668 {
1669 data << int32(WildBattlePetLevel);
1670 }
1671 if (changesMask[113])
1672 {
1674 }
1675 if (changesMask[114])
1676 {
1678 }
1679 if (changesMask[115])
1680 {
1681 data << int32(ViewerDependentValue<InteractSpellIDTag>::GetValue(this, owner, receiver));
1682 }
1683 if (changesMask[116])
1684 {
1685 data << int32(ScaleDuration);
1686 }
1687 if (changesMask[117])
1688 {
1689 data << int32(LooksLikeMountID);
1690 }
1691 if (changesMask[118])
1692 {
1693 data << int32(LooksLikeCreatureID);
1694 }
1695 if (changesMask[119])
1696 {
1697 data << int32(LookAtControllerID);
1698 }
1699 if (changesMask[120])
1700 {
1701 data << int32(PerksVendorItemID);
1702 }
1703 if (changesMask[121])
1704 {
1705 data << int32(TaxiNodesID);
1706 }
1707 if (changesMask[122])
1708 {
1709 data << GuildGUID;
1710 }
1711 if (changesMask[123])
1712 {
1713 data << int32(FlightCapabilityID);
1714 }
1715 if (changesMask[124])
1716 {
1717 data << float(GlideEventSpeedDivisor);
1718 }
1719 if (changesMask[125])
1720 {
1722 }
1723 if (changesMask[126])
1724 {
1726 }
1727 if (changesMask[127])
1728 {
1729 data << uint32(SilencedSchoolMask);
1730 }
1731 }
1732 if (changesMask[128])
1733 {
1734 if (changesMask[129])
1735 {
1736 data << uint32(CurrentAreaID);
1737 }
1738 if (changesMask[130])
1739 {
1740 data << float(Field_31C);
1741 }
1742 if (changesMask[131])
1743 {
1744 data << float(Field_320);
1745 }
1746 if (changesMask[132])
1747 {
1748 data << NameplateAttachToGUID;
1749 }
1750 }
1751 if (changesMask[133])
1752 {
1753 for (uint32 i = 0; i < 10; ++i)
1754 {
1755 if (changesMask[134 + i])
1756 {
1757 data << int32(Power[i]);
1758 }
1759 if (changesMask[144 + i])
1760 {
1761 data << int32(MaxPower[i]);
1762 }
1763 if (changesMask[154 + i])
1764 {
1765 data << float(PowerRegenFlatModifier[i]);
1766 }
1767 if (changesMask[164 + i])
1768 {
1769 data << float(PowerRegenInterruptedFlatModifier[i]);
1770 }
1771 }
1772 }
1773 if (changesMask[174])
1774 {
1775 for (uint32 i = 0; i < 3; ++i)
1776 {
1777 if (changesMask[175 + i])
1778 {
1779 VirtualItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
1780 }
1781 }
1782 }
1783 if (changesMask[178])
1784 {
1785 for (uint32 i = 0; i < 2; ++i)
1786 {
1787 if (changesMask[179 + i])
1788 {
1789 data << uint32(AttackRoundBaseTime[i]);
1790 }
1791 }
1792 }
1793 if (changesMask[181])
1794 {
1795 for (uint32 i = 0; i < 4; ++i)
1796 {
1797 if (changesMask[182 + i])
1798 {
1799 data << int32(Stats[i]);
1800 }
1801 if (changesMask[186 + i])
1802 {
1803 data << int32(StatPosBuff[i]);
1804 }
1805 if (changesMask[190 + i])
1806 {
1807 data << int32(StatNegBuff[i]);
1808 }
1809 if (changesMask[194 + i])
1810 {
1811 data << int32(StatSupportBuff[i]);
1812 }
1813 }
1814 }
1815 if (changesMask[198])
1816 {
1817 for (uint32 i = 0; i < 7; ++i)
1818 {
1819 if (changesMask[199 + i])
1820 {
1821 data << int32(Resistances[i]);
1822 }
1823 if (changesMask[206 + i])
1824 {
1825 data << int32(BonusResistanceMods[i]);
1826 }
1827 if (changesMask[213 + i])
1828 {
1829 data << int32(ManaCostModifier[i]);
1830 }
1831 }
1832 }
1833 data.FlushBits();
1834}
1835
1837{
1980}
1981
1982void ChrCustomizationChoice::WriteCreate(ByteBuffer& data, Object const* owner, Player const* receiver) const
1983{
1986}
1987
1988void ChrCustomizationChoice::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Object const* owner, Player const* receiver) const
1989{
1992}
1993
1995{
1998}
1999
2000void QuestLog::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2001{
2002 data << int64(EndTime);
2003 data << int32(QuestID);
2004 data << uint32(StateFlags);
2005 data << uint32(ObjectiveFlags);
2006 for (uint32 i = 0; i < 24; ++i)
2007 {
2008 data << int16(ObjectiveProgress[i]);
2009 }
2010}
2011
2012void QuestLog::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2013{
2014 Mask changesMask = _changesMask;
2015 if (ignoreChangesMask)
2016 changesMask.SetAll();
2017
2018 data.WriteBits(changesMask.GetBlocksMask(0), 1);
2019 if (changesMask.GetBlock(0))
2020 data.WriteBits(changesMask.GetBlock(0), 32);
2021
2022 data.FlushBits();
2023 if (changesMask[0])
2024 {
2025 if (changesMask[1])
2026 {
2027 data << int64(EndTime);
2028 }
2029 if (changesMask[2])
2030 {
2031 data << int32(QuestID);
2032 }
2033 if (changesMask[3])
2034 {
2035 data << uint32(StateFlags);
2036 }
2037 if (changesMask[4])
2038 {
2039 data << uint32(ObjectiveFlags);
2040 }
2041 }
2042 if (changesMask[5])
2043 {
2044 for (uint32 i = 0; i < 24; ++i)
2045 {
2046 if (changesMask[6 + i])
2047 {
2048 data << int16(ObjectiveProgress[i]);
2049 }
2050 }
2051 }
2052}
2053
2055{
2062}
2063
2064void ArenaCooldown::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2065{
2066 data << int32(SpellID);
2067 data << int32(Charges);
2068 data << uint32(Flags);
2069 data << uint32(StartTime);
2070 data << uint32(EndTime);
2071 data << uint32(NextChargeTime);
2072 data << uint8(MaxCharges);
2073}
2074
2075void ArenaCooldown::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2076{
2077 Mask changesMask = _changesMask;
2078 if (ignoreChangesMask)
2079 changesMask.SetAll();
2080
2081 data.WriteBits(changesMask.GetBlock(0), 8);
2082
2083 data.FlushBits();
2084 if (changesMask[0])
2085 {
2086 if (changesMask[1])
2087 {
2088 data << int32(SpellID);
2089 }
2090 if (changesMask[2])
2091 {
2092 data << int32(Charges);
2093 }
2094 if (changesMask[3])
2095 {
2096 data << uint32(Flags);
2097 }
2098 if (changesMask[4])
2099 {
2100 data << uint32(StartTime);
2101 }
2102 if (changesMask[5])
2103 {
2104 data << uint32(EndTime);
2105 }
2106 if (changesMask[6])
2107 {
2108 data << uint32(NextChargeTime);
2109 }
2110 if (changesMask[7])
2111 {
2112 data << uint8(MaxCharges);
2113 }
2114 }
2115}
2116
2118{
2127}
2128
2129void ZonePlayerForcedReaction::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2130{
2131 data << int32(FactionID);
2132 data << int32(Reaction);
2133}
2134
2135void ZonePlayerForcedReaction::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2136{
2137 Mask changesMask = _changesMask;
2138 if (ignoreChangesMask)
2139 changesMask.SetAll();
2140
2141 data.WriteBits(changesMask.GetBlock(0), 3);
2142
2143 data.FlushBits();
2144 if (changesMask[0])
2145 {
2146 if (changesMask[1])
2147 {
2148 data << int32(FactionID);
2149 }
2150 if (changesMask[2])
2151 {
2152 data << int32(Reaction);
2153 }
2154 }
2155}
2156
2158{
2162}
2163
2164void PetCreatureName::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2165{
2166 data << uint32(CreatureID);
2167 data.WriteBits(Name->size(), 8);
2168 data.WriteString(Name);
2169 data.FlushBits();
2170}
2171
2172void PetCreatureName::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2173{
2174 Mask changesMask = _changesMask;
2175 if (ignoreChangesMask)
2176 changesMask.SetAll();
2177
2178 data.WriteBits(changesMask.GetBlock(0), 3);
2179
2180 data.FlushBits();
2181 if (changesMask[0])
2182 {
2183 if (changesMask[1])
2184 {
2185 data << uint32(CreatureID);
2186 }
2187 if (changesMask[2])
2188 {
2189 data.WriteBits(Name->size(), 8);
2190 data.WriteString(Name);
2191 }
2192 }
2193 data.FlushBits();
2194}
2195
2197{
2201}
2202
2203void CTROptions::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2204{
2205 data << int32(ConditionalFlags);
2206 data << uint32(FactionGroup);
2208}
2209
2210void CTROptions::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2211{
2212 data << int32(ConditionalFlags);
2213 data << uint32(FactionGroup);
2215}
2216
2217bool CTROptions::operator==(CTROptions const& right) const
2218{
2219 return ConditionalFlags == right.ConditionalFlags
2220 && FactionGroup == right.FactionGroup
2222}
2223
2224void DeclinedNames::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2225{
2226 for (uint32 i = 0; i < 5; ++i)
2227 {
2228 data.WriteBits(Name[i].size(), 10);
2229 }
2230 data.FlushBits();
2231 for (uint32 i = 0; i < 5; ++i)
2232 {
2233 data.WriteString(Name[i]);
2234 }
2235 data.FlushBits();
2236}
2237
2238void DeclinedNames::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2239{
2240 Mask changesMask = _changesMask;
2241 if (ignoreChangesMask)
2242 changesMask.SetAll();
2243
2244 data.WriteBits(changesMask.GetBlocksMask(0), 1);
2245 if (changesMask.GetBlock(0))
2246 data.WriteBits(changesMask.GetBlock(0), 32);
2247
2248 data.FlushBits();
2249 if (changesMask[0])
2250 {
2251 for (uint32 i = 0; i < 5; ++i)
2252 {
2253 if (changesMask[1 + i])
2254 {
2255 data.WriteBits(Name[i].size(), 10);
2256 }
2257 }
2258 }
2259 data.FlushBits();
2260 if (changesMask[0])
2261 {
2262 for (uint32 i = 0; i < 5; ++i)
2263 {
2264 if (changesMask[1 + i])
2265 {
2266 data.WriteString(Name[i]);
2267 }
2268 }
2269 }
2270 data.FlushBits();
2271}
2272
2274{
2277}
2278
2279void CustomTabardInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2280{
2281 data << int32(EmblemStyle);
2282 data << int32(EmblemColor);
2283 data << int32(BorderStyle);
2284 data << int32(BorderColor);
2285 data << int32(BackgroundColor);
2286}
2287
2288void CustomTabardInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2289{
2290 Mask changesMask = _changesMask;
2291 if (ignoreChangesMask)
2292 changesMask.SetAll();
2293
2294 data.WriteBits(changesMask.GetBlock(0), 6);
2295
2296 data.FlushBits();
2297 if (changesMask[0])
2298 {
2299 if (changesMask[1])
2300 {
2301 data << int32(EmblemStyle);
2302 }
2303 if (changesMask[2])
2304 {
2305 data << int32(EmblemColor);
2306 }
2307 if (changesMask[3])
2308 {
2309 data << int32(BorderStyle);
2310 }
2311 if (changesMask[4])
2312 {
2313 data << int32(BorderColor);
2314 }
2315 if (changesMask[5])
2316 {
2317 data << int32(BackgroundColor);
2318 }
2319 }
2320}
2321
2323{
2330}
2331
2332void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const
2333{
2334 data << DuelArbiter;
2335 data << WowAccount;
2336 data << BnetAccount;
2337 data << uint64(GuildClubMemberID);
2338 data << LootTargetGUID;
2339 data << uint32(PlayerFlags);
2340 data << uint32(PlayerFlagsEx);
2341 data << uint32(GuildRankID);
2342 data << uint32(GuildDeleteDate);
2343 data << int32(GuildLevel);
2344 data << uint32(Customizations.size());
2345 data << uint32(QaCustomizations.size());
2346 for (uint32 i = 0; i < 2; ++i)
2347 {
2348 data << uint8(PartyType[i]);
2349 }
2350 data << uint8(NativeSex);
2351 data << uint8(Inebriation);
2352 data << uint8(PvpTitle);
2353 data << uint8(ArenaFaction);
2354 data << uint32(DuelTeam);
2355 data << int32(GuildTimeStamp);
2356 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
2357 {
2358 for (uint32 i = 0; i < 175; ++i)
2359 {
2360 QuestLog[i].WriteCreate(data, owner, receiver);
2361 }
2362 data << uint32(QuestSessionQuestLog.size());
2363 }
2364 for (uint32 i = 0; i < 19; ++i)
2365 {
2366 VisibleItems[i].WriteCreate(data, owner, receiver);
2367 }
2368 data << int32(PlayerTitle);
2369 data << int32(FakeInebriation);
2370 data << uint32(VirtualPlayerRealm);
2371 data << uint32(CurrentSpecID);
2372 data << int32(TaxiMountAnimKitID);
2373 for (uint32 i = 0; i < 6; ++i)
2374 {
2375 data << float(AvgItemLevel[i]);
2376 }
2378 data << int32(HonorLevel);
2379 data << int64(LogoutTime);
2380 data << uint32(ArenaCooldowns.size());
2381 for (uint32 i = 0; i < 32; ++i)
2382 {
2383 ForcedReactions[i].WriteCreate(data, owner, receiver);
2384 }
2385 data << int32(Field_1AC);
2386 data << int32(Field_1B0);
2388 data << uint32(PetNames.size());
2389 CtrOptions->WriteCreate(data, owner, receiver);
2390 data << int32(CovenantID);
2391 data << int32(SoulbindID);
2392 data << SpectateTarget;
2393 data << int32(Field_200);
2395 for (uint32 i = 0; i < 19; ++i)
2396 {
2397 data << uint32(Field_3120[i]);
2398 }
2399 PersonalTabard->WriteCreate(data, owner, receiver);
2400 for (uint32 i = 0; i < Customizations.size(); ++i)
2401 {
2402 Customizations[i].WriteCreate(data, owner, receiver);
2403 }
2404 for (uint32 i = 0; i < QaCustomizations.size(); ++i)
2405 {
2406 QaCustomizations[i].WriteCreate(data, owner, receiver);
2407 }
2408 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
2409 {
2410 for (uint32 i = 0; i < QuestSessionQuestLog.size(); ++i)
2411 {
2412 QuestSessionQuestLog[i].WriteCreate(data, owner, receiver);
2413 }
2414 }
2415 for (uint32 i = 0; i < ArenaCooldowns.size(); ++i)
2416 {
2417 ArenaCooldowns[i].WriteCreate(data, owner, receiver);
2418 }
2419 for (uint32 i = 0; i < VisualItemReplacements.size(); ++i)
2420 {
2421 data << int32(VisualItemReplacements[i]);
2422 }
2423 data.FlushBits();
2424 data.WriteBits(Name->size(), 6);
2425 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
2426 {
2428 }
2429 data.WriteBit(HasLevelLink);
2430 data.WriteBits(DeclinedNames.has_value(), 1);
2431 data << DungeonScore;
2432 data.WriteString(Name);
2433 for (uint32 i = 0; i < 16; ++i)
2434 {
2435 data << VisibleEquipableSpells[i];
2436 }
2437 for (uint32 i = 0; i < PetNames.size(); ++i)
2438 {
2439 PetNames[i].WriteCreate(data, owner, receiver);
2440 }
2441 if (DeclinedNames.has_value())
2442 {
2443 DeclinedNames->WriteCreate(data, owner, receiver);
2444 }
2445 data.FlushBits();
2446}
2447
2448void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const
2449{
2450 Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000003u });
2451 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
2452 WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
2453}
2454
2455void PlayerData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
2456{
2457 if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
2458 allowedMaskForTarget |= std::array<uint32, 11>{ 0x00000022u, 0xFFFE0000u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000001u, 0x00000000u, 0x00000000u, 0x00000000u };
2459}
2460
2462{
2463 Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000003u });
2464 AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
2465 changesMask &= allowedMaskForTarget;
2466}
2467
2468void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Player const* owner, Player const* receiver) const
2469{
2470 data.WriteBits(changesMask.GetBlocksMask(0), 11);
2471 for (uint32 i = 0; i < 11; ++i)
2472 if (changesMask.GetBlock(i))
2473 data.WriteBits(changesMask.GetBlock(i), 32);
2474
2475 bool noQuestLogChangesMask = data.WriteBit(IsQuestLogChangesMaskSkipped());
2476 if (changesMask[0])
2477 {
2478 if (changesMask[1])
2479 {
2481 }
2482 if (changesMask[2])
2483 {
2484 data.WriteBit(HasLevelLink);
2485 }
2486 if (changesMask[3])
2487 {
2488 if (!ignoreNestedChangesMask)
2490 else
2492 }
2493 if (changesMask[4])
2494 {
2495 if (!ignoreNestedChangesMask)
2497 else
2499 }
2500 if (changesMask[5])
2501 {
2502 if (!ignoreNestedChangesMask)
2504 else
2506 }
2507 if (changesMask[6])
2508 {
2509 if (!ignoreNestedChangesMask)
2511 else
2513 }
2514 if (changesMask[7])
2515 {
2516 if (!ignoreNestedChangesMask)
2518 else
2520 }
2521 if (changesMask[8])
2522 {
2523 if (!ignoreNestedChangesMask)
2525 else
2527 }
2528 }
2529 data.FlushBits();
2530 if (changesMask[0])
2531 {
2532 if (changesMask[3])
2533 {
2534 for (uint32 i = 0; i < Customizations.size(); ++i)
2535 {
2536 if (Customizations.HasChanged(i) || ignoreNestedChangesMask)
2537 {
2538 Customizations[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2539 }
2540 }
2541 }
2542 if (changesMask[4])
2543 {
2544 for (uint32 i = 0; i < QaCustomizations.size(); ++i)
2545 {
2546 if (QaCustomizations.HasChanged(i) || ignoreNestedChangesMask)
2547 {
2548 QaCustomizations[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2549 }
2550 }
2551 }
2552 if (changesMask[5])
2553 {
2554 for (uint32 i = 0; i < QuestSessionQuestLog.size(); ++i)
2555 {
2556 if (QuestSessionQuestLog.HasChanged(i) || ignoreNestedChangesMask)
2557 {
2558 if (noQuestLogChangesMask)
2559 QuestSessionQuestLog[i].WriteCreate(data, owner, receiver);
2560 else
2561 QuestSessionQuestLog[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2562 }
2563 }
2564 }
2565 if (changesMask[6])
2566 {
2567 for (uint32 i = 0; i < ArenaCooldowns.size(); ++i)
2568 {
2569 if (ArenaCooldowns.HasChanged(i) || ignoreNestedChangesMask)
2570 {
2571 ArenaCooldowns[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2572 }
2573 }
2574 }
2575 if (changesMask[8])
2576 {
2577 for (uint32 i = 0; i < VisualItemReplacements.size(); ++i)
2578 {
2579 if (VisualItemReplacements.HasChanged(i) || ignoreNestedChangesMask)
2580 {
2581 data << int32(VisualItemReplacements[i]);
2582 }
2583 }
2584 }
2585 if (changesMask[7])
2586 {
2587 for (uint32 i = 0; i < PetNames.size(); ++i)
2588 {
2589 if (PetNames.HasChanged(i) || ignoreNestedChangesMask)
2590 {
2591 PetNames[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2592 }
2593 }
2594 }
2595 if (changesMask[9])
2596 {
2597 data << DuelArbiter;
2598 }
2599 if (changesMask[10])
2600 {
2601 data << WowAccount;
2602 }
2603 if (changesMask[11])
2604 {
2605 data << BnetAccount;
2606 }
2607 if (changesMask[12])
2608 {
2609 data << uint64(GuildClubMemberID);
2610 }
2611 if (changesMask[13])
2612 {
2613 data << LootTargetGUID;
2614 }
2615 if (changesMask[14])
2616 {
2617 data << uint32(PlayerFlags);
2618 }
2619 if (changesMask[15])
2620 {
2621 data << uint32(PlayerFlagsEx);
2622 }
2623 if (changesMask[16])
2624 {
2625 data << uint32(GuildRankID);
2626 }
2627 if (changesMask[17])
2628 {
2629 data << uint32(GuildDeleteDate);
2630 }
2631 if (changesMask[18])
2632 {
2633 data << int32(GuildLevel);
2634 }
2635 if (changesMask[19])
2636 {
2637 data << uint8(NativeSex);
2638 }
2639 if (changesMask[20])
2640 {
2641 data << uint8(Inebriation);
2642 }
2643 if (changesMask[21])
2644 {
2645 data << uint8(PvpTitle);
2646 }
2647 if (changesMask[22])
2648 {
2649 data << uint8(ArenaFaction);
2650 }
2651 if (changesMask[23])
2652 {
2653 data << uint32(DuelTeam);
2654 }
2655 if (changesMask[24])
2656 {
2657 data << int32(GuildTimeStamp);
2658 }
2659 if (changesMask[25])
2660 {
2661 data << int32(PlayerTitle);
2662 }
2663 if (changesMask[26])
2664 {
2665 data << int32(FakeInebriation);
2666 }
2667 if (changesMask[27])
2668 {
2669 data << uint32(VirtualPlayerRealm);
2670 }
2671 if (changesMask[28])
2672 {
2673 data << uint32(CurrentSpecID);
2674 }
2675 if (changesMask[29])
2676 {
2677 data << int32(TaxiMountAnimKitID);
2678 }
2679 if (changesMask[30])
2680 {
2682 }
2683 if (changesMask[31])
2684 {
2685 data << int32(HonorLevel);
2686 }
2687 }
2688 if (changesMask[32])
2689 {
2690 if (changesMask[33])
2691 {
2692 data << int64(LogoutTime);
2693 }
2694 if (changesMask[35])
2695 {
2696 data << int32(Field_1AC);
2697 }
2698 if (changesMask[36])
2699 {
2700 data << int32(Field_1B0);
2701 }
2702 if (changesMask[37])
2703 {
2705 }
2706 if (changesMask[38])
2707 {
2708 CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2709 }
2710 if (changesMask[39])
2711 {
2712 data << int32(CovenantID);
2713 }
2714 if (changesMask[40])
2715 {
2716 data << int32(SoulbindID);
2717 }
2718 if (changesMask[42])
2719 {
2720 data << SpectateTarget;
2721 }
2722 if (changesMask[43])
2723 {
2724 data << int32(Field_200);
2725 }
2726 if (changesMask[45])
2727 {
2728 PersonalTabard->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2729 }
2730 if (changesMask[34])
2731 {
2732 data.WriteBits(Name->size(), 6);
2733 }
2734 data.WriteBits(DeclinedNames.has_value(), 1);
2735 data.FlushBits();
2736 if (changesMask[41])
2737 {
2738 data << DungeonScore;
2739 }
2740 if (changesMask[34])
2741 {
2742 data.WriteString(Name);
2743 }
2744 if (changesMask[44])
2745 {
2746 if (DeclinedNames.has_value())
2747 {
2748 DeclinedNames->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2749 }
2750 }
2751 }
2752 if (changesMask[46])
2753 {
2754 for (uint32 i = 0; i < 2; ++i)
2755 {
2756 if (changesMask[47 + i])
2757 {
2758 data << uint8(PartyType[i]);
2759 }
2760 }
2761 }
2762 if (changesMask[49])
2763 {
2764 for (uint32 i = 0; i < 175; ++i)
2765 {
2766 if (changesMask[50 + i])
2767 {
2768 if (noQuestLogChangesMask)
2769 QuestLog[i].WriteCreate(data, owner, receiver);
2770 else
2771 QuestLog[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2772 }
2773 }
2774 }
2775 if (changesMask[225])
2776 {
2777 for (uint32 i = 0; i < 19; ++i)
2778 {
2779 if (changesMask[226 + i])
2780 {
2781 VisibleItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2782 }
2783 }
2784 }
2785 if (changesMask[245])
2786 {
2787 for (uint32 i = 0; i < 6; ++i)
2788 {
2789 if (changesMask[246 + i])
2790 {
2791 data << float(AvgItemLevel[i]);
2792 }
2793 }
2794 }
2795 if (changesMask[252])
2796 {
2797 for (uint32 i = 0; i < 32; ++i)
2798 {
2799 if (changesMask[253 + i])
2800 {
2801 ForcedReactions[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
2802 }
2803 }
2804 }
2805 if (changesMask[302])
2806 {
2807 for (uint32 i = 0; i < 19; ++i)
2808 {
2809 if (changesMask[303 + i])
2810 {
2811 data << uint32(Field_3120[i]);
2812 }
2813 }
2814 }
2815 if (changesMask[285])
2816 {
2817 for (uint32 i = 0; i < 16; ++i)
2818 {
2819 if (changesMask[286 + i])
2820 {
2821 data << VisibleEquipableSpells[i];
2822 }
2823 }
2824 }
2825 data.FlushBits();
2826}
2827
2829{
2882}
2883
2884void SkillInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2885{
2886 for (uint32 i = 0; i < 256; ++i)
2887 {
2888 data << uint16(SkillLineID[i]);
2889 data << uint16(SkillStep[i]);
2890 data << uint16(SkillRank[i]);
2891 data << uint16(SkillStartingRank[i]);
2892 data << uint16(SkillMaxRank[i]);
2893 data << int16(SkillTempBonus[i]);
2894 data << uint16(SkillPermBonus[i]);
2895 }
2896}
2897
2898void SkillInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2899{
2900 Mask changesMask = _changesMask;
2901 if (ignoreChangesMask)
2902 changesMask.SetAll();
2903
2904 for (uint32 i = 0; i < 1; ++i)
2905 data << uint32(changesMask.GetBlocksMask(i));
2906 data.WriteBits(changesMask.GetBlocksMask(1), 25);
2907 for (uint32 i = 0; i < 57; ++i)
2908 if (changesMask.GetBlock(i))
2909 data.WriteBits(changesMask.GetBlock(i), 32);
2910
2911 data.FlushBits();
2912 if (changesMask[0])
2913 {
2914 for (uint32 i = 0; i < 256; ++i)
2915 {
2916 if (changesMask[1 + i])
2917 {
2918 data << uint16(SkillLineID[i]);
2919 }
2920 if (changesMask[257 + i])
2921 {
2922 data << uint16(SkillStep[i]);
2923 }
2924 if (changesMask[513 + i])
2925 {
2926 data << uint16(SkillRank[i]);
2927 }
2928 if (changesMask[769 + i])
2929 {
2930 data << uint16(SkillStartingRank[i]);
2931 }
2932 if (changesMask[1025 + i])
2933 {
2934 data << uint16(SkillMaxRank[i]);
2935 }
2936 if (changesMask[1281 + i])
2937 {
2938 data << int16(SkillTempBonus[i]);
2939 }
2940 if (changesMask[1537 + i])
2941 {
2942 data << uint16(SkillPermBonus[i]);
2943 }
2944 }
2945 }
2946}
2947
2949{
2958}
2959
2960void BitVector::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
2961{
2962 data << uint32(Values.size());
2963 for (uint32 i = 0; i < Values.size(); ++i)
2964 {
2965 data << uint64(Values[i]);
2966 }
2967}
2968
2969void BitVector::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
2970{
2971 Mask changesMask = _changesMask;
2972 if (ignoreChangesMask)
2973 changesMask.SetAll();
2974
2975 data.WriteBits(changesMask.GetBlock(0), 2);
2976
2977 if (changesMask[0])
2978 {
2979 if (changesMask[1])
2980 {
2981 if (!ignoreChangesMask)
2982 Values.WriteUpdateMask(data);
2983 else
2985 }
2986 }
2987 data.FlushBits();
2988 if (changesMask[0])
2989 {
2990 if (changesMask[1])
2991 {
2992 for (uint32 i = 0; i < Values.size(); ++i)
2993 {
2994 if (Values.HasChanged(i) || ignoreChangesMask)
2995 {
2996 data << uint64(Values[i]);
2997 }
2998 }
2999 }
3000 }
3001}
3002
3004{
3007}
3008
3009void BitVectors::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3010{
3011 for (uint32 i = 0; i < 13; ++i)
3012 {
3013 Values[i].WriteCreate(data, owner, receiver);
3014 }
3015}
3016
3017void BitVectors::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3018{
3019 Mask changesMask = _changesMask;
3020 if (ignoreChangesMask)
3021 changesMask.SetAll();
3022
3023 data.WriteBits(changesMask.GetBlocksMask(0), 1);
3024 if (changesMask.GetBlock(0))
3025 data.WriteBits(changesMask.GetBlock(0), 32);
3026
3027 data.FlushBits();
3028 if (changesMask[0])
3029 {
3030 for (uint32 i = 0; i < 13; ++i)
3031 {
3032 if (changesMask[1 + i])
3033 {
3034 Values[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
3035 }
3036 }
3037 }
3038}
3039
3041{
3044}
3045
3046void PlayerDataElement::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3047{
3048 data.WriteBits(Type, 1);
3049 if (Type == 1)
3050 {
3051 data << float(FloatValue);
3052 }
3053 if (Type == 0)
3054 {
3055 data << int64(Int64Value);
3056 }
3057 data.FlushBits();
3058}
3059
3060void PlayerDataElement::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3061{
3062 data.WriteBits(Type, 1);
3063 if (Type == 1)
3064 {
3065 data << float(FloatValue);
3066 }
3067 if (Type == 0)
3068 {
3069 data << int64(Int64Value);
3070 }
3071 data.FlushBits();
3072}
3073
3075{
3076 return Type == right.Type
3077 && FloatValue == right.FloatValue
3078 && Int64Value == right.Int64Value;
3079}
3080
3081void RestInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3082{
3083 data << uint32(Threshold);
3084 data << uint8(StateID);
3085}
3086
3087void RestInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3088{
3089 Mask changesMask = _changesMask;
3090 if (ignoreChangesMask)
3091 changesMask.SetAll();
3092
3093 data.WriteBits(changesMask.GetBlock(0), 3);
3094
3095 data.FlushBits();
3096 if (changesMask[0])
3097 {
3098 if (changesMask[1])
3099 {
3100 data << uint32(Threshold);
3101 }
3102 if (changesMask[2])
3103 {
3104 data << uint8(StateID);
3105 }
3106 }
3107}
3108
3110{
3114}
3115
3116void PVPInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3117{
3118 data << int8(Bracket);
3119 data << int32(PvpRatingID);
3120 data << uint32(WeeklyPlayed);
3121 data << uint32(WeeklyWon);
3122 data << uint32(SeasonPlayed);
3123 data << uint32(SeasonWon);
3124 data << uint32(Rating);
3125 data << uint32(WeeklyBestRating);
3126 data << uint32(SeasonBestRating);
3127 data << uint32(PvpTierID);
3129 data << uint32(Field_28);
3130 data << uint32(Field_2C);
3131 data << uint32(WeeklyRoundsPlayed);
3132 data << uint32(WeeklyRoundsWon);
3133 data << uint32(SeasonRoundsPlayed);
3134 data << uint32(SeasonRoundsWon);
3135 data.WriteBit(Disqualified);
3136 data.FlushBits();
3137}
3138
3139void PVPInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3140{
3141 Mask changesMask = _changesMask;
3142 if (ignoreChangesMask)
3143 changesMask.SetAll();
3144
3145 data.WriteBits(changesMask.GetBlock(0), 19);
3146
3147 if (changesMask[0])
3148 {
3149 if (changesMask[1])
3150 {
3151 data.WriteBit(Disqualified);
3152 }
3153 }
3154 data.FlushBits();
3155 if (changesMask[0])
3156 {
3157 if (changesMask[2])
3158 {
3159 data << int8(Bracket);
3160 }
3161 if (changesMask[3])
3162 {
3163 data << int32(PvpRatingID);
3164 }
3165 if (changesMask[4])
3166 {
3167 data << uint32(WeeklyPlayed);
3168 }
3169 if (changesMask[5])
3170 {
3171 data << uint32(WeeklyWon);
3172 }
3173 if (changesMask[6])
3174 {
3175 data << uint32(SeasonPlayed);
3176 }
3177 if (changesMask[7])
3178 {
3179 data << uint32(SeasonWon);
3180 }
3181 if (changesMask[8])
3182 {
3183 data << uint32(Rating);
3184 }
3185 if (changesMask[9])
3186 {
3187 data << uint32(WeeklyBestRating);
3188 }
3189 if (changesMask[10])
3190 {
3191 data << uint32(SeasonBestRating);
3192 }
3193 if (changesMask[11])
3194 {
3195 data << uint32(PvpTierID);
3196 }
3197 if (changesMask[12])
3198 {
3200 }
3201 if (changesMask[13])
3202 {
3203 data << uint32(Field_28);
3204 }
3205 if (changesMask[14])
3206 {
3207 data << uint32(Field_2C);
3208 }
3209 if (changesMask[15])
3210 {
3211 data << uint32(WeeklyRoundsPlayed);
3212 }
3213 if (changesMask[16])
3214 {
3215 data << uint32(WeeklyRoundsWon);
3216 }
3217 if (changesMask[17])
3218 {
3219 data << uint32(SeasonRoundsPlayed);
3220 }
3221 if (changesMask[18])
3222 {
3223 data << uint32(SeasonRoundsWon);
3224 }
3225 }
3226 data.FlushBits();
3227}
3228
3230{
3250}
3251
3252void CharacterRestriction::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3253{
3254 data << int32(Field_0);
3255 data << int32(Field_4);
3256 data << int32(Field_8);
3257 data.WriteBits(Type, 5);
3258 data.FlushBits();
3259}
3260
3261void CharacterRestriction::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3262{
3263 data << int32(Field_0);
3264 data << int32(Field_4);
3265 data << int32(Field_8);
3266 data.WriteBits(Type, 5);
3267 data.FlushBits();
3268}
3269
3271{
3272 return Field_0 == right.Field_0
3273 && Field_4 == right.Field_4
3274 && Field_8 == right.Field_8
3275 && Type == right.Type;
3276}
3277
3278void SpellPctModByLabel::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3279{
3280 data << int32(ModIndex);
3281 data << float(ModifierValue);
3282 data << int32(LabelID);
3283}
3284
3285void SpellPctModByLabel::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3286{
3287 data << int32(ModIndex);
3288 data << float(ModifierValue);
3289 data << int32(LabelID);
3290}
3291
3293{
3294 return ModIndex == right.ModIndex
3295 && ModifierValue == right.ModifierValue
3296 && LabelID == right.LabelID;
3297}
3298
3299void SpellFlatModByLabel::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3300{
3301 data << int32(ModIndex);
3302 data << int32(ModifierValue);
3303 data << int32(LabelID);
3304}
3305
3306void SpellFlatModByLabel::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3307{
3308 data << int32(ModIndex);
3309 data << int32(ModifierValue);
3310 data << int32(LabelID);
3311}
3312
3314{
3315 return ModIndex == right.ModIndex
3316 && ModifierValue == right.ModifierValue
3317 && LabelID == right.LabelID;
3318}
3319
3320void CompletedProject::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3321{
3322 data << uint32(ProjectID);
3323 data << int64(FirstCompleted);
3324 data << uint32(CompletionCount);
3325}
3326
3327void CompletedProject::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3328{
3329 Mask changesMask = _changesMask;
3330 if (ignoreChangesMask)
3331 changesMask.SetAll();
3332
3333 data.WriteBits(changesMask.GetBlock(0), 4);
3334
3335 data.FlushBits();
3336 if (changesMask[0])
3337 {
3338 if (changesMask[1])
3339 {
3340 data << uint32(ProjectID);
3341 }
3342 if (changesMask[2])
3343 {
3344 data << int64(FirstCompleted);
3345 }
3346 if (changesMask[3])
3347 {
3348 data << uint32(CompletionCount);
3349 }
3350 }
3351}
3352
3354{
3359}
3360
3361void ResearchHistory::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3362{
3363 data << uint32(CompletedProjects.size());
3364 for (uint32 i = 0; i < CompletedProjects.size(); ++i)
3365 {
3366 CompletedProjects[i].WriteCreate(data, owner, receiver);
3367 }
3368}
3369
3370void ResearchHistory::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3371{
3372 Mask changesMask = _changesMask;
3373 if (ignoreChangesMask)
3374 changesMask.SetAll();
3375
3376 data.WriteBits(changesMask.GetBlock(0), 2);
3377
3378 if (changesMask[0])
3379 {
3380 if (changesMask[1])
3381 {
3382 if (!ignoreChangesMask)
3384 else
3386 }
3387 }
3388 data.FlushBits();
3389 if (changesMask[0])
3390 {
3391 if (changesMask[1])
3392 {
3393 for (uint32 i = 0; i < CompletedProjects.size(); ++i)
3394 {
3395 if (CompletedProjects.HasChanged(i) || ignoreChangesMask)
3396 {
3397 CompletedProjects[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
3398 }
3399 }
3400 }
3401 }
3402}
3403
3405{
3408}
3409
3410void MawPower::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3411{
3412 data << int32(SpellID);
3413 data << int32(MawPowerID);
3414 data << int32(Stacks);
3415}
3416
3417void MawPower::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3418{
3419 data << int32(SpellID);
3420 data << int32(MawPowerID);
3421 data << int32(Stacks);
3422}
3423
3424bool MawPower::operator==(MawPower const& right) const
3425{
3426 return SpellID == right.SpellID
3427 && MawPowerID == right.MawPowerID
3428 && Stacks == right.Stacks;
3429}
3430
3431void MultiFloorExplore::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3432{
3433 data << uint32(WorldMapOverlayIDs.size());
3434 for (uint32 i = 0; i < WorldMapOverlayIDs.size(); ++i)
3435 {
3436 data << int32(WorldMapOverlayIDs[i]);
3437 }
3438}
3439
3440void MultiFloorExplore::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3441{
3442 data << uint32(WorldMapOverlayIDs.size());
3443 for (uint32 i = 0; i < WorldMapOverlayIDs.size(); ++i)
3444 {
3445 data << int32(WorldMapOverlayIDs[i]);
3446 }
3447 data.FlushBits();
3448}
3449
3451{
3452 return WorldMapOverlayIDs == right.WorldMapOverlayIDs;
3453}
3454
3455void RecipeProgressionInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3456{
3458 data << uint16(Experience);
3459}
3460
3461void RecipeProgressionInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3462{
3464 data << uint16(Experience);
3465}
3466
3468{
3470 && Experience == right.Experience;
3471}
3472
3473void ActivePlayerUnk901::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3474{
3475 data << Field_0;
3476 data << int32(Field_10);
3477}
3478
3479void ActivePlayerUnk901::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3480{
3481 Mask changesMask = _changesMask;
3482 if (ignoreChangesMask)
3483 changesMask.SetAll();
3484
3485 data.WriteBits(changesMask.GetBlock(0), 3);
3486
3487 data.FlushBits();
3488 if (changesMask[0])
3489 {
3490 if (changesMask[1])
3491 {
3492 data << Field_0;
3493 }
3494 if (changesMask[2])
3495 {
3496 data << int32(Field_10);
3497 }
3498 }
3499}
3500
3502{
3506}
3507
3508void QuestSession::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3509{
3510 data << Owner;
3511 QuestCompleted->WriteCreate(data, owner, receiver);
3512}
3513
3514void QuestSession::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3515{
3516 Mask changesMask = _changesMask;
3517 if (ignoreChangesMask)
3518 changesMask.SetAll();
3519
3520 data.WriteBits(changesMask.GetBlock(0), 3);
3521
3522 data.FlushBits();
3523 if (changesMask[0])
3524 {
3525 if (changesMask[1])
3526 {
3527 data << Owner;
3528 }
3529 if (changesMask[2])
3530 {
3531 QuestCompleted->WriteUpdate(data, ignoreChangesMask, owner, receiver);
3532 }
3533 }
3534}
3535
3537{
3541}
3542
3543void ReplayedQuest::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3544{
3545 data << int32(QuestID);
3546 data << uint32(ReplayTime);
3547}
3548
3549void ReplayedQuest::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3550{
3551 Mask changesMask = _changesMask;
3552 if (ignoreChangesMask)
3553 changesMask.SetAll();
3554
3555 data.WriteBits(changesMask.GetBlock(0), 3);
3556
3557 data.FlushBits();
3558 if (changesMask[0])
3559 {
3560 if (changesMask[1])
3561 {
3562 data << int32(QuestID);
3563 }
3564 if (changesMask[2])
3565 {
3566 data << uint32(ReplayTime);
3567 }
3568 }
3569}
3570
3572{
3576}
3577
3578void TraitEntry::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3579{
3580 data << int32(TraitNodeID);
3581 data << int32(TraitNodeEntryID);
3582 data << int32(Rank);
3583 data << int32(GrantedRanks);
3584}
3585
3586void TraitEntry::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3587{
3588 data << int32(TraitNodeID);
3589 data << int32(TraitNodeEntryID);
3590 data << int32(Rank);
3591 data << int32(GrantedRanks);
3592}
3593
3594bool TraitEntry::operator==(TraitEntry const& right) const
3595{
3596 return TraitNodeID == right.TraitNodeID
3598 && Rank == right.Rank
3599 && GrantedRanks == right.GrantedRanks;
3600}
3601
3602void TraitSubTreeCache::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3603{
3604 data << int32(TraitSubTreeID);
3605 data << uint32(Entries.size());
3606 for (uint32 i = 0; i < Entries.size(); ++i)
3607 {
3608 Entries[i].WriteCreate(data, owner, receiver);
3609 }
3610 data.WriteBits(Active, 1);
3611 data.FlushBits();
3612}
3613
3614void TraitSubTreeCache::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3615{
3616 data << int32(TraitSubTreeID);
3617 data << uint32(Entries.size());
3618 for (uint32 i = 0; i < Entries.size(); ++i)
3619 {
3620 Entries[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
3621 }
3622 data.FlushBits();
3623 data.WriteBits(Active, 1);
3624 data.FlushBits();
3625}
3626
3628{
3629 return Entries == right.Entries
3630 && TraitSubTreeID == right.TraitSubTreeID
3631 && Active == right.Active;
3632}
3633
3634void TraitConfig::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3635{
3636 data << int32(ID);
3637 data << int32(Type);
3638 data << uint32(Entries.size());
3639 data << uint32(SubTrees.size());
3640 if (Type == 2)
3641 {
3642 data << int32(SkillLineID);
3643 }
3644 if (Type == 1)
3645 {
3646 data << int32(ChrSpecializationID);
3647 data << int32(CombatConfigFlags);
3648 data << int32(LocalIdentifier);
3649 }
3650 if (Type == 3)
3651 {
3652 data << int32(TraitSystemID);
3653 }
3654 for (uint32 i = 0; i < Entries.size(); ++i)
3655 {
3656 Entries[i].WriteCreate(data, owner, receiver);
3657 }
3658 data.WriteBits(Name->size(), 9);
3659 for (uint32 i = 0; i < SubTrees.size(); ++i)
3660 {
3661 SubTrees[i].WriteCreate(data, owner, receiver);
3662 }
3663 data.WriteString(Name);
3664 data.FlushBits();
3665}
3666
3667void TraitConfig::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3668{
3669 Mask changesMask = _changesMask;
3670 if (ignoreChangesMask)
3671 changesMask.SetAll();
3672
3673 data.WriteBits(changesMask.GetBlock(0), 14);
3674
3675 if (changesMask[0])
3676 {
3677 if (changesMask[1])
3678 {
3679 if (!ignoreChangesMask)
3680 Entries.WriteUpdateMask(data);
3681 else
3683 }
3684 if (changesMask[2])
3685 {
3686 if (!ignoreChangesMask)
3688 else
3690 }
3691 }
3692 data.FlushBits();
3693 if (changesMask[0])
3694 {
3695 if (changesMask[1])
3696 {
3697 for (uint32 i = 0; i < Entries.size(); ++i)
3698 {
3699 if (Entries.HasChanged(i) || ignoreChangesMask)
3700 {
3701 Entries[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
3702 }
3703 }
3704 }
3705 if (changesMask[2])
3706 {
3707 for (uint32 i = 0; i < SubTrees.size(); ++i)
3708 {
3709 if (SubTrees.HasChanged(i) || ignoreChangesMask)
3710 {
3711 SubTrees[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
3712 }
3713 }
3714 }
3715 if (changesMask[3])
3716 {
3717 data << int32(ID);
3718 }
3719 }
3720 if (changesMask[4])
3721 {
3722 if (changesMask[6])
3723 {
3724 data << int32(Type);
3725 }
3726 if (changesMask[7])
3727 {
3728 if (Type == 2)
3729 {
3730 data << int32(SkillLineID);
3731 }
3732 }
3733 }
3734 if (changesMask[8])
3735 {
3736 if (changesMask[9])
3737 {
3738 if (Type == 1)
3739 {
3740 data << int32(ChrSpecializationID);
3741 }
3742 }
3743 if (changesMask[10])
3744 {
3745 if (Type == 1)
3746 {
3747 data << int32(CombatConfigFlags);
3748 }
3749 }
3750 if (changesMask[11])
3751 {
3752 if (Type == 1)
3753 {
3754 data << int32(LocalIdentifier);
3755 }
3756 }
3757 }
3758 if (changesMask[12])
3759 {
3760 if (changesMask[13])
3761 {
3762 if (Type == 3)
3763 {
3764 data << int32(TraitSystemID);
3765 }
3766 }
3767 }
3768 if (changesMask[4])
3769 {
3770 if (changesMask[5])
3771 {
3772 data.WriteBits(Name->size(), 9);
3773 data.WriteString(Name);
3774 }
3775 }
3776 data.FlushBits();
3777}
3778
3780{
3792}
3793
3794void CraftingOrderItem::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3795{
3796 data << uint64(Field_0);
3797 data << ItemGUID;
3798 data << OwnerGUID;
3799 data << int32(ItemID);
3800 data << uint32(Quantity);
3801 data << int32(ReagentQuality);
3803 data.FlushBits();
3805 {
3806 data << uint8(DataSlotIndex);
3807 }
3808}
3809
3810void CraftingOrderItem::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3811{
3812 Mask changesMask = _changesMask;
3813 if (ignoreChangesMask)
3814 changesMask.SetAll();
3815
3816 data.WriteBits(changesMask.GetBlock(0), 7);
3817
3818 data.FlushBits();
3819 if (changesMask[0])
3820 {
3821 data << uint64(Field_0);
3822 }
3823 if (changesMask[1])
3824 {
3825 data << ItemGUID;
3826 }
3827 if (changesMask[2])
3828 {
3829 data << OwnerGUID;
3830 }
3831 if (changesMask[3])
3832 {
3833 data << int32(ItemID);
3834 }
3835 if (changesMask[4])
3836 {
3837 data << uint32(Quantity);
3838 }
3839 if (changesMask[5])
3840 {
3841 data << int32(ReagentQuality);
3842 }
3844 data.FlushBits();
3845 if (changesMask[6])
3846 {
3848 {
3849 data << uint8(DataSlotIndex);
3850 }
3851 }
3852}
3853
3855{
3864}
3865
3866void CraftingOrderCustomer::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3867{
3868 data << CustomerGUID;
3869 data << CustomerAccountGUID;
3870}
3871
3872void CraftingOrderCustomer::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3873{
3874 Mask changesMask = _changesMask;
3875 if (ignoreChangesMask)
3876 changesMask.SetAll();
3877
3878 data.WriteBits(changesMask.GetBlock(0), 2);
3879
3880 data.FlushBits();
3881 if (changesMask[0])
3882 {
3883 data << CustomerGUID;
3884 }
3885 if (changesMask[1])
3886 {
3887 data << CustomerAccountGUID;
3888 }
3889}
3890
3892{
3896}
3897
3898void CraftingOrderNpcCustomer::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3899{
3901 data << int32(Field_8);
3902}
3903
3904void CraftingOrderNpcCustomer::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3905{
3906 Mask changesMask = _changesMask;
3907 if (ignoreChangesMask)
3908 changesMask.SetAll();
3909
3910 data.WriteBits(changesMask.GetBlock(0), 2);
3911
3912 data.FlushBits();
3913 if (changesMask[0])
3914 {
3916 }
3917 if (changesMask[1])
3918 {
3919 data << int32(Field_8);
3920 }
3921}
3922
3924{
3928}
3929
3930void CraftingOrderData::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
3931{
3932 data << int32(Field_0);
3933 data << uint64(OrderID);
3934 data << int32(SkillLineAbilityID);
3935 data << uint8(OrderState);
3936 data << uint8(OrderType);
3937 data << uint8(MinQuality);
3938 data << int64(ExpirationTime);
3939 data << int64(ClaimEndTime);
3940 data << int64(TipAmount);
3941 data << int64(ConsortiumCut);
3942 data << uint32(Flags);
3943 data << CrafterGUID;
3944 data << PersonalCrafterGUID;
3946 data << int32(NpcTreasureID);
3947 data << uint32(Reagents.size());
3948 data.WriteBits(CustomerNotes->size(), 10);
3949 data.WriteBits(Customer.has_value(), 1);
3950 data.WriteBits(NpcCustomer.has_value(), 1);
3951 data.WriteBits(OutputItem.has_value(), 1);
3953 data.FlushBits();
3954 for (uint32 i = 0; i < Reagents.size(); ++i)
3955 {
3956 Reagents[i].WriteCreate(data, owner, receiver);
3957 }
3959 if (Customer.has_value())
3960 {
3961 Customer->WriteCreate(data, owner, receiver);
3962 }
3963 if (NpcCustomer.has_value())
3964 {
3965 NpcCustomer->WriteCreate(data, owner, receiver);
3966 }
3967 if (OutputItem.has_value())
3968 {
3969 OutputItem->WriteCreate(data, owner, receiver);
3970 }
3972 {
3973 data << OutputItemData;
3974 }
3975 data.FlushBits();
3976}
3977
3978void CraftingOrderData::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
3979{
3980 Mask changesMask = _changesMask;
3981 if (ignoreChangesMask)
3982 changesMask.SetAll();
3983
3984 data.WriteBits(changesMask.GetBlock(0), 26);
3985
3986 if (changesMask[0])
3987 {
3988 if (changesMask[1])
3989 {
3990 if (!ignoreChangesMask)
3992 else
3994 }
3995 }
3996 data.FlushBits();
3997 if (changesMask[0])
3998 {
3999 if (changesMask[1])
4000 {
4001 for (uint32 i = 0; i < Reagents.size(); ++i)
4002 {
4003 if (Reagents.HasChanged(i) || ignoreChangesMask)
4004 {
4005 Reagents[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
4006 }
4007 }
4008 }
4009 if (changesMask[2])
4010 {
4011 data << int32(Field_0);
4012 }
4013 if (changesMask[3])
4014 {
4015 data << uint64(OrderID);
4016 }
4017 if (changesMask[4])
4018 {
4019 data << int32(SkillLineAbilityID);
4020 }
4021 if (changesMask[5])
4022 {
4023 data << uint8(OrderState);
4024 }
4025 }
4026 if (changesMask[6])
4027 {
4028 if (changesMask[7])
4029 {
4030 data << uint8(OrderType);
4031 }
4032 if (changesMask[8])
4033 {
4034 data << uint8(MinQuality);
4035 }
4036 if (changesMask[9])
4037 {
4038 data << int64(ExpirationTime);
4039 }
4040 if (changesMask[10])
4041 {
4042 data << int64(ClaimEndTime);
4043 }
4044 if (changesMask[11])
4045 {
4046 data << int64(TipAmount);
4047 }
4048 }
4049 if (changesMask[12])
4050 {
4051 if (changesMask[13])
4052 {
4053 data << int64(ConsortiumCut);
4054 }
4055 if (changesMask[14])
4056 {
4057 data << uint32(Flags);
4058 }
4059 if (changesMask[15])
4060 {
4061 data << CrafterGUID;
4062 }
4063 if (changesMask[16])
4064 {
4065 data << PersonalCrafterGUID;
4066 }
4067 if (changesMask[17])
4068 {
4070 }
4071 }
4072 if (changesMask[18])
4073 {
4074 if (changesMask[19])
4075 {
4076 data << int32(NpcTreasureID);
4077 }
4078 if (changesMask[20])
4079 {
4080 data.WriteBits(CustomerNotes->size(), 10);
4081 }
4082 data.WriteBits(Customer.has_value(), 1);
4083 data.WriteBits(NpcCustomer.has_value(), 1);
4084 data.WriteBits(OutputItem.has_value(), 1);
4085 }
4086 if (changesMask[24])
4087 {
4089 }
4090 if (changesMask[18])
4091 {
4092 if (changesMask[20])
4093 {
4095 }
4096 if (changesMask[21])
4097 {
4098 if (Customer.has_value())
4099 {
4100 Customer->WriteUpdate(data, ignoreChangesMask, owner, receiver);
4101 }
4102 }
4103 if (changesMask[22])
4104 {
4105 if (NpcCustomer.has_value())
4106 {
4107 NpcCustomer->WriteUpdate(data, ignoreChangesMask, owner, receiver);
4108 }
4109 }
4110 if (changesMask[23])
4111 {
4112 if (OutputItem.has_value())
4113 {
4114 OutputItem->WriteUpdate(data, ignoreChangesMask, owner, receiver);
4115 }
4116 }
4117 }
4118 if (changesMask[24])
4119 {
4120 if (changesMask[25])
4121 {
4123 {
4124 data << OutputItemData;
4125 }
4126 }
4127 }
4128 data.FlushBits();
4129}
4130
4132{
4155}
4156
4157void CraftingOrder::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4158{
4159 Data->WriteCreate(data, owner, receiver);
4161 data.WriteBits(Enchantments.size(), 4);
4162 data.WriteBits(Gems.size(), 2);
4163 data.FlushBits();
4165 {
4166 data << RecraftItemInfo;
4167 }
4168 for (uint32 i = 0; i < Enchantments.size(); ++i)
4169 {
4170 data << Enchantments[i];
4171 }
4172 for (uint32 i = 0; i < Gems.size(); ++i)
4173 {
4174 data << Gems[i];
4175 }
4176 data.FlushBits();
4177}
4178
4179void CraftingOrder::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4180{
4181 Mask changesMask = _changesMask;
4182 if (ignoreChangesMask)
4183 changesMask.SetAll();
4184
4185 data.WriteBits(changesMask.GetBlock(0), 4);
4186
4187 if (changesMask[0])
4188 {
4189 if (!ignoreChangesMask)
4191 else
4193 }
4194 if (changesMask[1])
4195 {
4196 if (!ignoreChangesMask)
4197 Gems.WriteUpdateMask(data, 2);
4198 else
4200 }
4201 data.FlushBits();
4202 if (changesMask[0])
4203 {
4204 for (uint32 i = 0; i < Enchantments.size(); ++i)
4205 {
4206 if (Enchantments.HasChanged(i) || ignoreChangesMask)
4207 {
4208 data << Enchantments[i];
4209 }
4210 }
4211 }
4212 if (changesMask[1])
4213 {
4214 for (uint32 i = 0; i < Gems.size(); ++i)
4215 {
4216 if (Gems.HasChanged(i) || ignoreChangesMask)
4217 {
4218 data << Gems[i];
4219 }
4220 }
4221 }
4222 if (changesMask[2])
4223 {
4224 Data->WriteUpdate(data, ignoreChangesMask, owner, receiver);
4225 }
4227 data.FlushBits();
4228 if (changesMask[3])
4229 {
4231 {
4232 data << RecraftItemInfo;
4233 }
4234 }
4235 data.FlushBits();
4236}
4237
4239{
4245}
4246
4247void PersonalCraftingOrderCount::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4248{
4249 data << int32(ProfessionID);
4250 data << uint32(Count);
4251}
4252
4253void PersonalCraftingOrderCount::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4254{
4255 Mask changesMask = _changesMask;
4256 if (ignoreChangesMask)
4257 changesMask.SetAll();
4258
4259 data.WriteBits(changesMask.GetBlock(0), 2);
4260
4261 data.FlushBits();
4262 if (changesMask[0])
4263 {
4264 data << int32(ProfessionID);
4265 }
4266 if (changesMask[1])
4267 {
4268 data << uint32(Count);
4269 }
4270}
4271
4273{
4277}
4278
4279void NPCCraftingOrderInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4280{
4281 data << uint64(OrderID);
4283 data << int32(NpcTreasureID);
4285}
4286
4287void NPCCraftingOrderInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4288{
4289 Mask changesMask = _changesMask;
4290 if (ignoreChangesMask)
4291 changesMask.SetAll();
4292
4293 data.WriteBits(changesMask.GetBlock(0), 4);
4294
4295 data.FlushBits();
4296 if (changesMask[0])
4297 {
4298 data << uint64(OrderID);
4299 }
4300 if (changesMask[1])
4301 {
4303 }
4304 if (changesMask[2])
4305 {
4306 data << int32(NpcTreasureID);
4307 }
4308 if (changesMask[3])
4309 {
4311 }
4312}
4313
4315{
4321}
4322
4323void CategoryCooldownMod::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4324{
4325 data << int32(SpellCategoryID);
4326 data << int32(ModCooldown);
4327}
4328
4329void CategoryCooldownMod::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4330{
4331 data << int32(SpellCategoryID);
4332 data << int32(ModCooldown);
4333}
4334
4336{
4337 return SpellCategoryID == right.SpellCategoryID
4338 && ModCooldown == right.ModCooldown;
4339}
4340
4341void WeeklySpellUse::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4342{
4343 data << int32(SpellCategoryID);
4344 data << uint8(Uses);
4345}
4346
4347void WeeklySpellUse::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4348{
4349 data << int32(SpellCategoryID);
4350 data << uint8(Uses);
4351}
4352
4354{
4355 return SpellCategoryID == right.SpellCategoryID
4356 && Uses == right.Uses;
4357}
4358
4359void StablePetInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4360{
4361 data << uint32(PetSlot);
4362 data << uint32(PetNumber);
4363 data << uint32(CreatureID);
4364 data << uint32(DisplayID);
4365 data << uint32(ExperienceLevel);
4366 data << uint8(PetFlags);
4367 data.WriteBits(Name->size(), 8);
4368 data.WriteString(Name);
4369 data.FlushBits();
4370}
4371
4372void StablePetInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4373{
4374 Mask changesMask = _changesMask;
4375 if (ignoreChangesMask)
4376 changesMask.SetAll();
4377
4378 data.WriteBits(changesMask.GetBlock(0), 8);
4379
4380 data.FlushBits();
4381 if (changesMask[0])
4382 {
4383 if (changesMask[1])
4384 {
4385 data << uint32(PetSlot);
4386 }
4387 if (changesMask[2])
4388 {
4389 data << uint32(PetNumber);
4390 }
4391 if (changesMask[3])
4392 {
4393 data << uint32(CreatureID);
4394 }
4395 if (changesMask[4])
4396 {
4397 data << uint32(DisplayID);
4398 }
4399 if (changesMask[5])
4400 {
4401 data << uint32(ExperienceLevel);
4402 }
4403 if (changesMask[7])
4404 {
4405 data << uint8(PetFlags);
4406 }
4407 if (changesMask[6])
4408 {
4409 data.WriteBits(Name->size(), 8);
4410 data.WriteString(Name);
4411 }
4412 }
4413 data.FlushBits();
4414}
4415
4417{
4426}
4427
4428void StableInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4429{
4430 data << uint32(Pets.size());
4431 data << StableMaster;
4432 for (uint32 i = 0; i < Pets.size(); ++i)
4433 {
4434 Pets[i].WriteCreate(data, owner, receiver);
4435 }
4436}
4437
4438void StableInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4439{
4440 Mask changesMask = _changesMask;
4441 if (ignoreChangesMask)
4442 changesMask.SetAll();
4443
4444 data.WriteBits(changesMask.GetBlock(0), 3);
4445
4446 if (changesMask[0])
4447 {
4448 if (changesMask[1])
4449 {
4450 if (!ignoreChangesMask)
4451 Pets.WriteUpdateMask(data);
4452 else
4454 }
4455 }
4456 data.FlushBits();
4457 if (changesMask[0])
4458 {
4459 if (changesMask[1])
4460 {
4461 for (uint32 i = 0; i < Pets.size(); ++i)
4462 {
4463 if (Pets.HasChanged(i) || ignoreChangesMask)
4464 {
4465 Pets[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
4466 }
4467 }
4468 }
4469 if (changesMask[2])
4470 {
4471 data << StableMaster;
4472 }
4473 }
4474}
4475
4477{
4481}
4482
4483void CollectableSourceTrackedData::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4484{
4485 data << int32(TargetType);
4486 data << int32(TargetID);
4488}
4489
4490void CollectableSourceTrackedData::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4491{
4492 Mask changesMask = _changesMask;
4493 if (ignoreChangesMask)
4494 changesMask.SetAll();
4495
4496 data.WriteBits(changesMask.GetBlock(0), 4);
4497
4498 data.FlushBits();
4499 if (changesMask[0])
4500 {
4501 if (changesMask[1])
4502 {
4503 data << int32(TargetType);
4504 }
4505 if (changesMask[2])
4506 {
4507 data << int32(TargetID);
4508 }
4509 if (changesMask[3])
4510 {
4512 }
4513 }
4514}
4515
4517{
4522}
4523
4524void BankTabSettings::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4525{
4526 data.WriteBits(Name->size(), 7);
4527 data.WriteBits(Icon->size(), 9);
4528 data.WriteBits(Description->size(), 14);
4529 data << int32(DepositFlags);
4530 data.WriteString(Name);
4531 data.WriteString(Icon);
4533 data.FlushBits();
4534}
4535
4536void BankTabSettings::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4537{
4538 Mask changesMask = _changesMask;
4539 if (ignoreChangesMask)
4540 changesMask.SetAll();
4541
4542 data.WriteBits(changesMask.GetBlock(0), 4);
4543
4544 data.FlushBits();
4545 if (changesMask[0])
4546 {
4547 data.WriteBits(Name->size(), 7);
4548 }
4549 if (changesMask[1])
4550 {
4551 data.WriteBits(Icon->size(), 9);
4552 }
4553 if (changesMask[2])
4554 {
4555 data.WriteBits(Description->size(), 14);
4556 }
4557 if (changesMask[3])
4558 {
4559 data << int32(DepositFlags);
4560 }
4561 if (changesMask[0])
4562 {
4563 data.WriteString(Name);
4564 }
4565 if (changesMask[1])
4566 {
4567 data.WriteString(Icon);
4568 }
4569 if (changesMask[2])
4570 {
4572 }
4573 data.FlushBits();
4574}
4575
4577{
4583}
4584
4585void WalkInData::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4586{
4587 data << int32(MapID);
4588 data << int64(Field_8);
4589 data << Field_18;
4590 data.WriteBits(Type, 1);
4591 data.FlushBits();
4592}
4593
4594void WalkInData::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4595{
4596 data << int32(MapID);
4597 data << int64(Field_8);
4598 data << Field_18;
4599 data.WriteBits(Type, 1);
4600 data.FlushBits();
4601}
4602
4603bool WalkInData::operator==(WalkInData const& right) const
4604{
4605 return MapID == right.MapID
4606 && Field_8 == right.Field_8
4607 && Type == right.Type
4608 && Field_18 == right.Field_18;
4609}
4610
4611void DelveData::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4612{
4613 data << int32(Field_0);
4614 data << uint64(Field_8);
4615 data << int32(Field_10);
4616 data << int32(SpellID);
4617 data << uint32(Owners.size());
4618 for (uint32 i = 0; i < Owners.size(); ++i)
4619 {
4620 data << Owners[i];
4621 }
4622 data.WriteBits(Started, 1);
4623 data.FlushBits();
4624}
4625
4626void DelveData::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4627{
4628 data.FlushBits();
4629 data << int32(Field_0);
4630 data << uint64(Field_8);
4631 data << int32(Field_10);
4632 data << int32(SpellID);
4633 data << uint32(Owners.size());
4634 for (uint32 i = 0; i < Owners.size(); ++i)
4635 {
4636 data << Owners[i];
4637 }
4638 data.WriteBits(Started, 1);
4639 data.FlushBits();
4640}
4641
4642bool DelveData::operator==(DelveData const& right) const
4643{
4644 return Owners == right.Owners
4645 && Field_0 == right.Field_0
4646 && Field_8 == right.Field_8
4647 && Field_10 == right.Field_10
4648 && SpellID == right.SpellID
4649 && Started == right.Started;
4650}
4651
4652void Research::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
4653{
4654 data << int16(ResearchProjectID);
4655}
4656
4657void Research::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
4658{
4659 data << int16(ResearchProjectID);
4660}
4661
4662bool Research::operator==(Research const& right) const
4663{
4664 return ResearchProjectID == right.ResearchProjectID;
4665}
4666
4667void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const
4668{
4669 for (uint32 i = 0; i < 232; ++i)
4670 {
4671 data << InvSlots[i];
4672 }
4673 data << FarsightObject;
4674 data << SummonedBattlePetGUID;
4675 data << uint32(KnownTitles.size());
4676 data << uint64(Coinage);
4677 data << uint64(AccountBankCoinage);
4678 data << int32(XP);
4679 data << int32(NextLevelXP);
4680 data << int32(TrialXP);
4681 Skill->WriteCreate(data, owner, receiver);
4682 data << int32(CharacterPoints);
4683 data << int32(MaxTalentTiers);
4684 data << uint32(TrackCreatureMask);
4685 data << float(MainhandExpertise);
4686 data << float(OffhandExpertise);
4687 data << float(RangedExpertise);
4688 data << float(CombatRatingExpertise);
4689 data << float(BlockPercentage);
4690 data << float(DodgePercentage);
4691 data << float(DodgePercentageFromAttribute);
4692 data << float(ParryPercentage);
4693 data << float(ParryPercentageFromAttribute);
4694 data << float(CritPercentage);
4695 data << float(RangedCritPercentage);
4696 data << float(OffhandCritPercentage);
4697 data << float(SpellCritPercentage);
4698 data << int32(ShieldBlock);
4699 data << float(ShieldBlockCritPercentage);
4700 data << float(Mastery);
4701 data << float(Speed);
4702 data << float(Avoidance);
4703 data << float(Sturdiness);
4704 data << int32(Versatility);
4705 data << float(VersatilityBonus);
4706 data << float(PvpPowerDamage);
4707 data << float(PvpPowerHealing);
4708 BitVectors->WriteCreate(data, owner, receiver);
4710 data << uint32(AccountDataElements.size());
4711 for (uint32 i = 0; i < 2; ++i)
4712 {
4713 RestInfo[i].WriteCreate(data, owner, receiver);
4714 }
4715 for (uint32 i = 0; i < 7; ++i)
4716 {
4717 data << int32(ModDamageDonePos[i]);
4718 data << int32(ModDamageDoneNeg[i]);
4719 data << float(ModDamageDonePercent[i]);
4720 data << float(ModHealingDonePercent[i]);
4721 }
4722 data << int32(ModHealingDonePos);
4723 data << float(ModHealingPercent);
4724 data << float(ModPeriodicHealingDonePercent);
4725 for (uint32 i = 0; i < 3; ++i)
4726 {
4727 data << float(WeaponDmgMultipliers[i]);
4728 data << float(WeaponAtkSpeedMultipliers[i]);
4729 }
4730 data << float(ModSpellPowerPercent);
4731 data << float(ModResiliencePercent);
4732 data << float(OverrideSpellPowerByAPPercent);
4733 data << float(OverrideAPBySpellPowerPercent);
4734 data << int32(ModTargetResistance);
4736 data << uint32(LocalFlags);
4737 data << uint8(GrantableLevels);
4738 data << uint8(MultiActionBars);
4739 data << uint8(LifetimeMaxRank);
4740 data << uint8(NumRespecs);
4741 data << uint32(PvpMedals);
4742 for (uint32 i = 0; i < 12; ++i)