1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PhaseShift_h__
#define PhaseShift_h__
#include "Define.h"
#include "EnumFlag.h"
#include "FlatSet.h"
#include "ObjectGuid.h"
#include <map>
class PhasingHandler;
struct Condition;
struct TerrainSwapInfo;
#define DEFAULT_PHASE 169
enum class PhaseShiftFlags : uint32
{
None = 0x00,
AlwaysVisible = 0x01, // Ignores all phasing, can see everything and be seen by everything
Inverse = 0x02, // By default having at least one shared phase for two objects means they can see each other
// this flag makes objects see each other if they have at least one non-shared phase
InverseUnphased = 0x04,
Unphased = 0x08,
NoCosmetic = 0x10 // This flag ignores shared cosmetic phases (two players that both have shared cosmetic phase but no other phase cannot see each other)
};
enum class PhaseFlags : uint16
{
None = 0x0,
Cosmetic = 0x1,
Personal = 0x2
};
DEFINE_ENUM_FLAG(PhaseShiftFlags);
DEFINE_ENUM_FLAG(PhaseFlags);
class TC_GAME_API PhaseShift
{
public:
struct PhaseRef
{
PhaseRef(uint32 id, PhaseFlags flags, std::vector<Condition> const* conditions)
: Id(id), Flags(flags), References(0), AreaConditions(conditions) { }
uint16 Id;
EnumFlag<PhaseFlags> Flags;
int32 References;
std::vector<Condition> const* AreaConditions;
std::strong_ordering operator<=>(PhaseRef const& right) const { return Id <=> right.Id; }
bool operator==(PhaseRef const& right) const { return Id == right.Id; }
bool IsPersonal() const { return Flags.HasFlag(PhaseFlags::Personal); }
};
struct VisibleMapIdRef
{
int32 References = 0;
TerrainSwapInfo const* VisibleMapInfo = nullptr;
};
struct UiMapPhaseIdRef
{
int32 References = 0;
};
template<typename Container>
struct EraseResult
{
typename Container::iterator Iterator;
bool Erased;
};
using PhaseContainer = Trinity::Containers::FlatSet<PhaseRef>;
using VisibleMapIdContainer = std::map<uint32, VisibleMapIdRef>;
using UiMapPhaseIdContainer = std::map<uint32, UiMapPhaseIdRef>;
PhaseShift();
PhaseShift(PhaseShift const& right);
PhaseShift(PhaseShift&& right) noexcept;
PhaseShift& operator=(PhaseShift const& right);
PhaseShift& operator=(PhaseShift&& right) noexcept;
~PhaseShift();
ObjectGuid GetPersonalGuid() const { return PersonalGuid; }
bool AddPhase(uint32 phaseId, PhaseFlags flags, std::vector<Condition> const* areaConditions, int32 references = 1);
EraseResult<PhaseContainer> RemovePhase(uint32 phaseId);
bool HasPhase(uint32 phaseId) const { return Phases.find(PhaseRef(phaseId, PhaseFlags::None, nullptr)) != Phases.end(); }
PhaseContainer const& GetPhases() const { return Phases; }
bool AddVisibleMapId(uint32 visibleMapId, TerrainSwapInfo const* visibleMapInfo, int32 references = 1);
EraseResult<VisibleMapIdContainer> RemoveVisibleMapId(uint32 visibleMapId);
bool HasVisibleMapId(uint32 visibleMapId) const { return VisibleMapIds.find(visibleMapId) != VisibleMapIds.end(); }
VisibleMapIdContainer const& GetVisibleMapIds() const { return VisibleMapIds; }
bool AddUiMapPhaseId(uint32 uiMapPhaseId, int32 references = 1);
EraseResult<UiMapPhaseIdContainer> RemoveUiMapPhaseId(uint32 uiMapPhaseId);
bool HasUiMapPhaseId(uint32 uiMapPhaseId) const { return UiMapPhaseIds.find(uiMapPhaseId) != UiMapPhaseIds.end(); }
UiMapPhaseIdContainer const& GetUiMapPhaseIds() const { return UiMapPhaseIds; }
void Clear();
void ClearPhases();
bool CanSee(PhaseShift const& other) const;
bool HasPersonalPhase() const;
protected:
friend class PhasingHandler;
EnumFlag<PhaseShiftFlags> Flags = PhaseShiftFlags::Unphased;
ObjectGuid PersonalGuid;
PhaseContainer Phases;
VisibleMapIdContainer VisibleMapIds;
UiMapPhaseIdContainer UiMapPhaseIds;
void ModifyPhasesReferences(PhaseContainer::iterator itr, int32 references);
void UpdateUnphasedFlag();
void UpdatePersonalGuid();
int32 NonCosmeticReferences = 0;
int32 CosmeticReferences = 0;
int32 PersonalReferences = 0;
int32 DefaultReferences = 0;
bool IsDbPhaseShift = false;
};
#endif // PhaseShift_h__
|
