-
Notifications
You must be signed in to change notification settings - Fork 89
/
SpellAuras.h
534 lines (466 loc) · 25.3 KB
/
SpellAuras.h
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
/*
* Copyright (C) 2005-2012 MaNGOS <http://getmangos.com/>
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef MANGOS_SPELLAURAS_H
#define MANGOS_SPELLAURAS_H
#include "SpellAuraDefines.h"
#include "DBCEnums.h"
#include "ObjectGuid.h"
struct Modifier
{
AuraType m_auraname;
int32 m_amount;
int32 m_miscvalue;
uint32 periodictime;
};
class Unit;
struct SpellEntry;
struct ProcTriggerSpell;
// forward decl
class Aura;
// internal helper
struct ReapplyAffectedPassiveAurasHelper;
class MANGOS_DLL_SPEC SpellAuraHolder
{
public:
SpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem);
Aura* m_auras[MAX_EFFECT_INDEX];
void AddAura(Aura* aura, SpellEffectIndex index);
void RemoveAura(SpellEffectIndex index);
void ApplyAuraModifiers(bool apply, bool real = false);
void _AddSpellAuraHolder();
void _RemoveSpellAuraHolder();
void BuildUpdatePacket(WorldPacket& data) const;
void SendAuraUpdate(bool remove) const;
void HandleSpellSpecificBoosts(bool apply);
void CleanupTriggeredSpells();
void setDiminishGroup(DiminishingGroup group) { m_AuraDRGroup = group; }
DiminishingGroup getDiminishGroup() const { return m_AuraDRGroup; }
uint32 GetStackAmount() const { return m_stackAmount; }
void SetStackAmount(uint32 stackAmount);
bool ModStackAmount(int32 num); // return true if last charge dropped
Aura* GetAuraByEffectIndex(SpellEffectIndex index) const { return m_auras[index]; }
uint32 GetId() const { return m_spellProto->Id; }
SpellEntry const* GetSpellProto() const { return m_spellProto; }
ObjectGuid const& GetCasterGuid() const { return m_casterGuid; }
void SetCasterGuid(ObjectGuid guid) { m_casterGuid = guid; }
ObjectGuid const& GetCastItemGuid() const { return m_castItemGuid; }
Unit* GetCaster() const;
Unit* GetTarget() const { return m_target; }
void SetTarget(Unit* target) { m_target = target; }
bool IsPermanent() const { return m_permanent; }
void SetPermanent(bool permanent) { m_permanent = permanent; }
bool IsPassive() const { return m_isPassive; }
bool IsDeathPersistent() const { return m_isDeathPersist; }
bool IsPersistent() const;
bool IsPositive() const;
bool IsAreaAura() const; // if one from auras of holder applied as area aura
bool IsWeaponBuffCoexistableWith(SpellAuraHolder const* ref) const;
bool IsNeedVisibleSlot(Unit const* caster) const;
bool IsRemovedOnShapeLost() const { return m_isRemovedOnShapeLost; }
bool IsInUse() const { return m_in_use;}
bool IsDeleted() const { return m_deleted;}
bool IsEmptyHolder() const;
void SetDeleted() { m_deleted = true; }
void SetInUse(bool state)
{
if (state)
++m_in_use;
else
{
if (m_in_use)
--m_in_use;
}
}
void UpdateHolder(uint32 diff) { SetInUse(true); Update(diff); SetInUse(false); }
void Update(uint32 diff);
void RefreshHolder();
TrackedAuraType GetTrackedAuraType() const { return m_trackedAuraType; }
void SetTrackedAuraType(TrackedAuraType val) { m_trackedAuraType = val; }
void UnregisterAndCleanupTrackedAuras();
int32 GetAuraMaxDuration() const { return m_maxDuration; }
void SetAuraMaxDuration(int32 duration);
int32 GetAuraDuration() const { return m_duration; }
void SetAuraDuration(int32 duration) { m_duration = duration; }
uint8 GetAuraSlot() const { return m_auraSlot; }
void SetAuraSlot(uint8 slot) { m_auraSlot = slot; }
uint8 GetAuraFlags() const { return m_auraFlags; }
void SetAuraFlags(uint8 flags) { m_auraFlags = flags; }
uint8 GetAuraLevel() const { return m_auraLevel; }
void SetAuraLevel(uint8 level) { m_auraLevel = level; }
uint32 GetAuraCharges() const { return m_procCharges; }
void SetAuraCharges(uint32 charges, bool update = true)
{
if (m_procCharges == charges)
return;
m_procCharges = charges;
if (update)
SendAuraUpdate(false);
}
bool DropAuraCharge() // return true if last charge dropped
{
if (m_procCharges == 0)
return false;
--m_procCharges;
SendAuraUpdate(false);
return m_procCharges == 0;
}
time_t GetAuraApplyTime() const { return m_applyTime; }
void SetVisibleAura(bool remove) { m_target->SetVisibleAura(m_auraSlot, remove ? NULL : this); }
void SetRemoveMode(AuraRemoveMode mode) { m_removeMode = mode; }
void SetLoadedState(ObjectGuid const& casterGUID, ObjectGuid const& itemGUID, uint32 stackAmount, uint32 charges, int32 maxduration, int32 duration)
{
m_casterGuid = casterGUID;
m_castItemGuid = itemGUID;
m_procCharges = charges;
m_stackAmount = stackAmount;
SetAuraMaxDuration(maxduration);
SetAuraDuration(duration);
}
bool HasMechanic(uint32 mechanic) const;
bool HasMechanicMask(uint32 mechanicMask) const;
~SpellAuraHolder();
private:
SpellEntry const* m_spellProto;
Unit* m_target;
ObjectGuid m_casterGuid;
ObjectGuid m_castItemGuid; // it is NOT safe to keep a pointer to the item because it may get deleted
time_t m_applyTime;
uint8 m_auraSlot; // Aura slot on unit (for show in client)
uint8 m_auraFlags; // Aura info flag (for send data to client)
uint8 m_auraLevel; // Aura level (store caster level for correct show level dep amount)
uint32 m_procCharges; // Aura charges (0 for infinite)
uint32 m_stackAmount; // Aura stack amount
int32 m_maxDuration; // Max aura duration
int32 m_duration; // Current time
int32 m_timeCla; // Timer for power per sec calculation
AuraRemoveMode m_removeMode: 8; // Store info for know remove aura reason
DiminishingGroup m_AuraDRGroup: 8; // Diminishing
TrackedAuraType m_trackedAuraType: 8; // store if the caster tracks the aura - can change at spell steal for example
bool m_permanent: 1;
bool m_isPassive: 1;
bool m_isDeathPersist: 1;
bool m_isRemovedOnShapeLost: 1;
bool m_deleted: 1;
uint32 m_in_use; // > 0 while in SpellAuraHolder::ApplyModifiers call/SpellAuraHolder::Update/etc
};
typedef void(Aura::*pAuraHandler)(bool Apply, bool Real);
// Real == true at aura add/remove
// Real == false at aura mod unapply/reapply; when adding/removing dependent aura/item/stat mods
//
// Code in aura handler can be guarded by if(Real) check if it should execution only at real add/remove of aura
//
// MAIN RULE: Code MUST NOT be guarded by if(Real) check if it modifies any stats
// (percent auras, stats mods, etc)
// Second rule: Code must be guarded by if(Real) check if it modifies object state (start/stop attack, send packets to client, etc)
//
// Other case choice: each code line moved under if(Real) check is mangos speedup,
// each setting object update field code line moved under if(Real) check is significant mangos speedup, and less server->client data sends
// each packet sending code moved under if(Real) check is _large_ mangos speedup, and lot less server->client data sends
class MANGOS_DLL_SPEC Aura
{
friend struct ReapplyAffectedPassiveAurasHelper;
friend Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem);
public:
// aura handlers
void HandleNULL(bool, bool)
{
// NOT IMPLEMENTED
}
void HandleUnused(bool, bool)
{
// NOT USED BY ANY SPELL OR USELESS
}
void HandleNoImmediateEffect(bool, bool)
{
// aura not have immediate effect at add/remove and handled by ID in other code place
}
void HandleBindSight(bool Apply, bool Real);
void HandleModPossess(bool Apply, bool Real);
void HandlePeriodicDamage(bool Apply, bool Real);
void HandleAuraDummy(bool Apply, bool Real);
void HandleAuraPeriodicDummy(bool apply, bool Real);
void HandleModConfuse(bool Apply, bool Real);
void HandleModCharm(bool Apply, bool Real);
void HandleModFear(bool Apply, bool Real);
void HandlePeriodicHeal(bool Apply, bool Real);
void HandleModAttackSpeed(bool Apply, bool Real);
void HandleModMeleeRangedSpeedPct(bool apply, bool Real);
void HandleModCombatSpeedPct(bool apply, bool Real);
void HandleModThreat(bool Apply, bool Real);
void HandleModTaunt(bool Apply, bool Real);
void HandleFeignDeath(bool Apply, bool Real);
void HandleAuraModDisarm(bool Apply, bool Real);
void HandleAuraModStalked(bool Apply, bool Real);
void HandleAuraWaterWalk(bool Apply, bool Real);
void HandleAuraFeatherFall(bool Apply, bool Real);
void HandleAuraHover(bool Apply, bool Real);
void HandleAddModifier(bool Apply, bool Real);
void HandleAuraModStun(bool Apply, bool Real);
void HandleModDamageDone(bool Apply, bool Real);
void HandleAuraUntrackable(bool Apply, bool Real);
void HandleAuraEmpathy(bool Apply, bool Real);
void HandleModOffhandDamagePercent(bool apply, bool Real);
void HandleAuraModRangedAttackPower(bool Apply, bool Real);
void HandleAuraModIncreaseEnergyPercent(bool Apply, bool Real);
void HandleAuraModIncreaseHealthPercent(bool Apply, bool Real);
void HandleAuraModRegenInterrupt(bool Apply, bool Real);
void HandleModMeleeSpeedPct(bool Apply, bool Real);
void HandlePeriodicTriggerSpell(bool Apply, bool Real);
void HandlePeriodicTriggerSpellWithValue(bool apply, bool Real);
void HandlePeriodicEnergize(bool Apply, bool Real);
void HandleAuraModResistanceExclusive(bool Apply, bool Real);
void HandleAuraSafeFall(bool Apply, bool Real);
void HandleAuraModPetTalentsPoints(bool Apply, bool Real);
void HandleModStealth(bool Apply, bool Real);
void HandleInvisibility(bool Apply, bool Real);
void HandleInvisibilityDetect(bool Apply, bool Real);
void HandleAuraModTotalHealthPercentRegen(bool Apply, bool Real);
void HandleAuraModTotalManaPercentRegen(bool Apply, bool Real);
void HandleAuraModResistance(bool Apply, bool Real);
void HandleAuraModRoot(bool Apply, bool Real);
void HandleAuraModSilence(bool Apply, bool Real);
void HandleAuraModStat(bool Apply, bool Real);
void HandleDetectAmore(bool Apply, bool Real);
void HandleAuraFakeInebriation(bool Apply, bool Real);
void HandleAuraModIncreaseSpeed(bool Apply, bool Real);
void HandleAuraModIncreaseMountedSpeed(bool Apply, bool Real);
void HandleAuraModIncreaseFlightSpeed(bool Apply, bool Real);
void HandleAuraModDecreaseSpeed(bool Apply, bool Real);
void HandleAuraModUseNormalSpeed(bool Apply, bool Real);
void HandleAuraModIncreaseHealth(bool Apply, bool Real);
void HandleAuraModIncreaseEnergy(bool Apply, bool Real);
void HandleAuraModShapeshift(bool Apply, bool Real);
void HandleAuraModEffectImmunity(bool Apply, bool Real);
void HandleAuraModStateImmunity(bool Apply, bool Real);
void HandleAuraModSchoolImmunity(bool Apply, bool Real);
void HandleAuraModDmgImmunity(bool Apply, bool Real);
void HandleAuraModDispelImmunity(bool Apply, bool Real);
void HandleAuraProcTriggerSpell(bool Apply, bool Real);
void HandleAuraTrackCreatures(bool Apply, bool Real);
void HandleAuraTrackResources(bool Apply, bool Real);
void HandleAuraModParryPercent(bool Apply, bool Real);
void HandleAuraModDodgePercent(bool Apply, bool Real);
void HandleAuraModBlockChancePercent(bool Apply, bool Real);
void HandleAuraModCritPercent(bool Apply, bool Real);
void HandlePeriodicLeech(bool Apply, bool Real);
void HandleModHitChance(bool Apply, bool Real);
void HandleModSpellHitChance(bool Apply, bool Real);
void HandleAuraModScale(bool Apply, bool Real);
void HandlePeriodicManaLeech(bool Apply, bool Real);
void HandlePeriodicHealthFunnel(bool apply, bool Real);
void HandleModCastingSpeed(bool Apply, bool Real);
void HandleAuraMounted(bool Apply, bool Real);
void HandleWaterBreathing(bool Apply, bool Real);
void HandleModBaseResistance(bool Apply, bool Real);
void HandleModRegen(bool Apply, bool Real);
void HandleModPowerRegen(bool Apply, bool Real);
void HandleModPowerRegenPCT(bool Apply, bool Real);
void HandleChannelDeathItem(bool Apply, bool Real);
void HandleDamagePercentTaken(bool Apply, bool Real);
void HandlePeriodicDamagePCT(bool Apply, bool Real);
void HandleAuraModAttackPower(bool Apply, bool Real);
void HandleAuraTransform(bool Apply, bool Real);
void HandleModSpellCritChance(bool Apply, bool Real);
void HandleAuraModIncreaseSwimSpeed(bool Apply, bool Real);
void HandleModPowerCostPCT(bool Apply, bool Real);
void HandleModPowerCost(bool Apply, bool Real);
void HandleFarSight(bool Apply, bool Real);
void HandleModPossessPet(bool Apply, bool Real);
void HandleModMechanicImmunity(bool Apply, bool Real);
void HandleModMechanicImmunityMask(bool Apply, bool Real);
void HandleAuraModSkill(bool Apply, bool Real);
void HandleModDamagePercentDone(bool Apply, bool Real);
void HandleModPercentStat(bool Apply, bool Real);
void HandleModResistancePercent(bool Apply, bool Real);
void HandleAuraModBaseResistancePCT(bool Apply, bool Real);
void HandleAuraTrackStealthed(bool Apply, bool Real);
void HandleForceReaction(bool Apply, bool Real);
void HandleAuraModRangedHaste(bool Apply, bool Real);
void HandleRangedAmmoHaste(bool Apply, bool Real);
void HandleModHealingDone(bool Apply, bool Real);
void HandleModTotalPercentStat(bool Apply, bool Real);
void HandleAuraModTotalThreat(bool Apply, bool Real);
void HandleModUnattackable(bool Apply, bool Real);
void HandleAuraModPacify(bool Apply, bool Real);
void HandleAuraGhost(bool Apply, bool Real);
void HandleAuraAllowFlight(bool Apply, bool Real);
void HandleModRating(bool apply, bool Real);
void HandleModRatingFromStat(bool apply, bool Real);
void HandleModTargetResistance(bool apply, bool Real);
void HandleAuraModAttackPowerPercent(bool apply, bool Real);
void HandleAuraModRangedAttackPowerPercent(bool apply, bool Real);
void HandleAuraModRangedAttackPowerOfStatPercent(bool apply, bool Real);
void HandleAuraModAttackPowerOfStatPercent(bool apply, bool Real);
void HandleAuraModAttackPowerOfArmor(bool apply, bool Real);
void HandleSpiritOfRedemption(bool apply, bool Real);
void HandleModManaRegen(bool apply, bool Real);
void HandleComprehendLanguage(bool apply, bool Real);
void HandleModShieldBlockDamage(bool apply, bool Real);
void HandleModSpellCritChanceShool(bool apply, bool Real);
void HandleAuraRetainComboPoints(bool apply, bool Real);
void HandleModSpellDamagePercentFromStat(bool apply, bool Real);
void HandleModSpellHealingPercentFromStat(bool apply, bool Real);
void HandleAuraModDispelResist(bool apply, bool Real);
void HandleAuraControlVehicle(bool apply, bool Real);
void HandleModSpellDamagePercentFromAttackPower(bool apply, bool Real);
void HandleModSpellHealingPercentFromAttackPower(bool apply, bool Real);
void HandleAuraModPacifyAndSilence(bool Apply, bool Real);
void HandleAuraModIncreaseMaxHealth(bool apply, bool Real);
void HandleAuraModExpertise(bool apply, bool Real);
void HandleForceMoveForward(bool apply, bool Real);
void HandleAuraModResistenceOfStatPercent(bool apply, bool Real);
void HandleAuraPowerBurn(bool apply, bool Real);
void HandleSchoolAbsorb(bool apply, bool Real);
void HandlePreventFleeing(bool apply, bool Real);
void HandleManaShield(bool apply, bool Real);
void HandleArenaPreparation(bool apply, bool Real);
void HandleAuraMirrorImage(bool apply, bool Real);
void HandleAuraConvertRune(bool apply, bool Real);
void HandleAuraIncreaseBaseHealthPercent(bool Apply, bool Real);
void HandleNoReagentUseAura(bool Apply, bool Real);
void HandlePhase(bool Apply, bool Real);
void HandleModTargetArmorPct(bool Apply, bool Real);
void HandleAuraModAllCritChance(bool Apply, bool Real);
void HandleAuraOpenStable(bool apply, bool Real);
void HandleAuraAddMechanicAbilities(bool apply, bool Real);
void HandleAuraStopNaturalManaRegen(bool apply, bool Real);
void HandleAuraSetVehicleId(bool apply, bool Real);
void HandleAuraMastery(bool apply, bool Real);
void HandleAuraModBlockCritChance(bool apply, bool Real);
void HandleModIncreaseSpellPowerPct(bool apply, bool Real);
void HandleOverrideSpellPowerByAp(bool apply, bool Real);
virtual ~Aura();
void SetModifier(AuraType t, int32 a, uint32 pt, int32 miscValue);
Modifier* GetModifier() { return &m_modifier; }
Modifier const* GetModifier() const { return &m_modifier; }
int32 GetMiscValue() const { return m_spellEffect ? m_spellEffect->EffectMiscValue : 0; }
int32 GetMiscBValue() const { return m_spellEffect ? m_spellEffect->EffectMiscValueB : 0; }
SpellEntry const* GetSpellProto() const { return GetHolder()->GetSpellProto(); }
SpellEffectEntry const* GetSpellEffect() const { return m_spellEffect; }
uint32 GetId() const{ return GetHolder()->GetSpellProto()->Id; }
ObjectGuid const& GetCastItemGuid() const { return GetHolder()->GetCastItemGuid(); }
ObjectGuid const& GetCasterGuid() const { return GetHolder()->GetCasterGuid(); }
Unit* GetCaster() const { return GetHolder()->GetCaster(); }
Unit* GetTarget() const { return GetHolder()->GetTarget(); }
SpellEffectIndex GetEffIndex() const { return m_effIndex; }
int32 GetBasePoints() const { return m_currentBasePoints; }
int32 GetAuraMaxDuration() const { return GetHolder()->GetAuraMaxDuration(); }
int32 GetAuraDuration() const { return GetHolder()->GetAuraDuration(); }
time_t GetAuraApplyTime() const { return m_applyTime; }
uint32 GetAuraTicks() const { return m_periodicTick; }
uint32 GetAuraMaxTicks() const
{
int32 maxDuration = GetAuraMaxDuration();
return maxDuration > 0 && m_modifier.periodictime > 0 ? maxDuration / m_modifier.periodictime : 0;
}
uint32 GetStackAmount() const { return GetHolder()->GetStackAmount(); }
void SetLoadedState(int32 damage, uint32 periodicTime)
{
m_modifier.m_amount = damage;
m_modifier.periodictime = periodicTime;
if (uint32 maxticks = GetAuraMaxTicks())
m_periodicTick = maxticks - GetAuraDuration() / m_modifier.periodictime;
}
bool IsPositive() { return m_positive; }
bool IsPersistent() const { return m_isPersistent; }
bool IsAreaAura() const { return m_isAreaAura; }
bool IsPeriodic() const { return m_isPeriodic; }
bool IsInUse() const { return m_in_use; }
void SetInUse(bool state)
{
if (state)
++m_in_use;
else
{
if (m_in_use)
--m_in_use;
}
}
void ApplyModifier(bool apply, bool Real = false);
void UpdateAura(uint32 diff) { SetInUse(true); Update(diff); SetInUse(false); }
void SetRemoveMode(AuraRemoveMode mode) { m_removeMode = mode; }
virtual Unit* GetTriggerTarget() const { return m_spellAuraHolder->GetTarget(); }
// add/remove SPELL_AURA_MOD_SHAPESHIFT (36) linked auras
void HandleShapeshiftBoosts(bool apply);
void TriggerSpell();
void TriggerSpellWithValue();
ClassFamilyMask const& GetAuraSpellClassMask() const { return m_spellAuraHolder->GetSpellProto()->GetEffectSpellClassMask(m_effIndex); }
bool isAffectedOnSpell(SpellEntry const* spell) const;
bool CanProcFrom(SpellEntry const* spell, uint32 procFlag, uint32 EventProcEx, uint32 procEx, bool active, bool useClassMask) const;
SpellAuraHolder* GetHolder() { return m_spellAuraHolder; }
SpellAuraHolder const* GetHolder() const { return m_spellAuraHolder; }
bool IsLastAuraOnHolder();
bool HasMechanic(uint32 mechanic) const;
protected:
Aura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
// must be called only from Aura::UpdateAura
virtual void Update(uint32 diff);
// must be called only from Aura*::Update
void PeriodicTick();
void PeriodicDummyTick();
bool IsCritFromAbilityAura(Unit* caster, uint32& damage);
void ReapplyAffectedPassiveAuras();
Modifier m_modifier;
SpellEffectEntry const* m_spellEffect;
time_t m_applyTime;
int32 m_currentBasePoints; // cache SpellEntry::CalculateSimpleValue and use for set custom base points
int32 m_periodicTimer; // Timer for periodic auras
uint32 m_periodicTick; // Tick count pass (including current if use in tick code) from aura apply, used for some tick count dependent aura effects
AuraRemoveMode m_removeMode: 8; // Store info for know remove aura reason
SpellEffectIndex m_effIndex : 8; // Aura effect index in spell
bool m_positive: 1;
bool m_isPeriodic: 1;
bool m_isAreaAura: 1;
bool m_isPersistent: 1;
uint32 m_in_use; // > 0 while in Aura::ApplyModifier call/Aura::Update/etc
SpellAuraHolder* const m_spellAuraHolder;
private:
void ReapplyAffectedPassiveAuras(Unit* target, bool owner_mode);
};
class MANGOS_DLL_SPEC AreaAura : public Aura
{
public:
AreaAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
~AreaAura();
protected:
void Update(uint32 diff) override;
private:
float m_radius;
AreaAuraType m_areaAuraType;
};
class MANGOS_DLL_SPEC PersistentAreaAura : public Aura
{
public:
PersistentAreaAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
~PersistentAreaAura();
protected:
void Update(uint32 diff) override;
};
class MANGOS_DLL_SPEC SingleEnemyTargetAura : public Aura
{
friend Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem);
public:
~SingleEnemyTargetAura();
Unit* GetTriggerTarget() const override;
protected:
SingleEnemyTargetAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
ObjectGuid m_castersTargetGuid;
};
Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
SpellAuraHolder* CreateSpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem = NULL);
#endif