?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[6982] Implemented gmlevel-based command security
[getmangos.git] / src / game / Unit.h
blob77d9e3b353353b54ca434ff49654f01a579e9b5b
1 /*
2 * Copyright (C) 2005-2008 MaNGOS <http://getmangos.com/>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #ifndef __UNIT_H
20 #define __UNIT_H
21
22 #include "Common.h"
23 #include "Object.h"
24 #include "Opcodes.h"
25 #include "SpellAuraDefines.h"
26 #include "UpdateFields.h"
27 #include "SharedDefines.h"
28 #include "ThreatManager.h"
29 #include "HostilRefManager.h"
30 #include "FollowerReference.h"
31 #include "FollowerRefManager.h"
32 #include "Utilities/EventProcessor.h"
33 #include "MotionMaster.h"
34 #include "Database/DBCStructure.h"
35 #include <list>
36
37 enum SpellInterruptFlags
38 {
39 SPELL_INTERRUPT_FLAG_MOVEMENT = 0x01,
40 SPELL_INTERRUPT_FLAG_DAMAGE = 0x02,
41 SPELL_INTERRUPT_FLAG_INTERRUPT = 0x04,
42 SPELL_INTERRUPT_FLAG_AUTOATTACK = 0x08,
43 //SPELL_INTERRUPT_FLAG_TURNING = 0x10 // not turning - maybe _complete_ interrupt on direct damage?
44 };
45
46 enum SpellChannelInterruptFlags
47 {
48 CHANNEL_FLAG_DAMAGE = 0x0002,
49 CHANNEL_FLAG_MOVEMENT = 0x0008,
50 CHANNEL_FLAG_TURNING = 0x0010,
51 CHANNEL_FLAG_DAMAGE2 = 0x0080,
52 CHANNEL_FLAG_DELAY = 0x4000
53 };
54
55 enum SpellAuraInterruptFlags
56 {
57 AURA_INTERRUPT_FLAG_UNK0 = 0x00000001, // 0 removed when getting hit by a negative spell?
58 AURA_INTERRUPT_FLAG_DAMAGE = 0x00000002, // 1 removed by any damage
59 AURA_INTERRUPT_FLAG_UNK2 = 0x00000004, // 2
60 AURA_INTERRUPT_FLAG_MOVE = 0x00000008, // 3 removed by any movement
61 AURA_INTERRUPT_FLAG_TURNING = 0x00000010, // 4 removed by any turning
62 AURA_INTERRUPT_FLAG_ENTER_COMBAT = 0x00000020, // 5 removed by entering combat
63 AURA_INTERRUPT_FLAG_NOT_MOUNTED = 0x00000040, // 6 removed by unmounting
64 AURA_INTERRUPT_FLAG_NOT_ABOVEWATER = 0x00000080, // 7 removed by entering water
65 AURA_INTERRUPT_FLAG_NOT_UNDERWATER = 0x00000100, // 8 removed by leaving water
66 AURA_INTERRUPT_FLAG_NOT_SHEATHED = 0x00000200, // 9 removed by unsheathing
67 AURA_INTERRUPT_FLAG_UNK10 = 0x00000400, // 10
68 AURA_INTERRUPT_FLAG_UNK11 = 0x00000800, // 11
69 AURA_INTERRUPT_FLAG_UNK12 = 0x00001000, // 12 removed by attack?
70 AURA_INTERRUPT_FLAG_UNK13 = 0x00002000, // 13
71 AURA_INTERRUPT_FLAG_UNK14 = 0x00004000, // 14
72 AURA_INTERRUPT_FLAG_UNK15 = 0x00008000, // 15 removed by casting a spell?
73 AURA_INTERRUPT_FLAG_UNK16 = 0x00010000, // 16
74 AURA_INTERRUPT_FLAG_MOUNTING = 0x00020000, // 17 removed by mounting
75 AURA_INTERRUPT_FLAG_NOT_SEATED = 0x00040000, // 18 removed by standing up
76 AURA_INTERRUPT_FLAG_CHANGE_MAP = 0x00080000, // 19 leaving map/getting teleported
77 AURA_INTERRUPT_FLAG_UNK20 = 0x00100000, // 20
78 AURA_INTERRUPT_FLAG_UNK21 = 0x00200000, // 21
79 AURA_INTERRUPT_FLAG_UNK22 = 0x00400000, // 22
80 AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT = 0x00800000, // 23 removed by entering pvp combat
81 AURA_INTERRUPT_FLAG_DIRECT_DAMAGE = 0x01000000 // 24 removed by any direct damage
82 };
83
84 enum SpellModOp
85 {
86 SPELLMOD_DAMAGE = 0,
87 SPELLMOD_DURATION = 1,
88 SPELLMOD_THREAT = 2,
89 SPELLMOD_EFFECT1 = 3,
90 SPELLMOD_CHARGES = 4,
91 SPELLMOD_RANGE = 5,
92 SPELLMOD_RADIUS = 6,
93 SPELLMOD_CRITICAL_CHANCE = 7,
94 SPELLMOD_ALL_EFFECTS = 8,
95 SPELLMOD_NOT_LOSE_CASTING_TIME = 9,
96 SPELLMOD_CASTING_TIME = 10,
97 SPELLMOD_COOLDOWN = 11,
98 SPELLMOD_EFFECT2 = 12,
99 // spellmod 13 unused
100 SPELLMOD_COST = 14,
101 SPELLMOD_CRIT_DAMAGE_BONUS = 15,
102 SPELLMOD_RESIST_MISS_CHANCE = 16,
103 SPELLMOD_JUMP_TARGETS = 17,
104 SPELLMOD_CHANCE_OF_SUCCESS = 18,
105 SPELLMOD_ACTIVATION_TIME = 19,
106 SPELLMOD_EFFECT_PAST_FIRST = 20,
107 SPELLMOD_CASTING_TIME_OLD = 21,
108 SPELLMOD_DOT = 22,
109 SPELLMOD_EFFECT3 = 23,
110 SPELLMOD_SPELL_BONUS_DAMAGE = 24,
111 // spellmod 25, 26 unused
112 SPELLMOD_MULTIPLE_VALUE = 27,
113 SPELLMOD_RESIST_DISPEL_CHANCE = 28
114 };
115
116 #define MAX_SPELLMOD 32
117
118 enum SpellFacingFlags
119 {
120 SPELL_FACING_FLAG_INFRONT = 0x0001
121 };
122
123 #define BASE_MINDAMAGE 1.0f
124 #define BASE_MAXDAMAGE 2.0f
125 #define BASE_ATTACK_TIME 2000
126
127 // high byte (3 from 0..3) of UNIT_FIELD_BYTES_2
128 enum ShapeshiftForm
129 {
130 FORM_NONE = 0x00,
131 FORM_CAT = 0x01,
132 FORM_TREE = 0x02,
133 FORM_TRAVEL = 0x03,
134 FORM_AQUA = 0x04,
135 FORM_BEAR = 0x05,
136 FORM_AMBIENT = 0x06,
137 FORM_GHOUL = 0x07,
138 FORM_DIREBEAR = 0x08,
139 FORM_CREATUREBEAR = 0x0E,
140 FORM_CREATURECAT = 0x0F,
141 FORM_GHOSTWOLF = 0x10,
142 FORM_BATTLESTANCE = 0x11,
143 FORM_DEFENSIVESTANCE = 0x12,
144 FORM_BERSERKERSTANCE = 0x13,
145 FORM_TEST = 0x14,
146 FORM_ZOMBIE = 0x15,
147 FORM_METAMORPHOSIS = 0x16,
148 FORM_FLIGHT_EPIC = 0x1B,
149 FORM_SHADOW = 0x1C,
150 FORM_FLIGHT = 0x1D,
151 FORM_STEALTH = 0x1E,
152 FORM_MOONKIN = 0x1F,
153 FORM_SPIRITOFREDEMPTION = 0x20
154 };
155
156 // low byte ( 0 from 0..3 ) of UNIT_FIELD_BYTES_2
157 enum SheathState
158 {
159 SHEATH_STATE_UNARMED = 0, // non prepared weapon
160 SHEATH_STATE_MELEE = 1, // prepared melee weapon
161 SHEATH_STATE_RANGED = 2 // prepared ranged weapon
162 };
163
164 // byte (1 from 0..3) of UNIT_FIELD_BYTES_2
165 enum UnitBytes2_Flags
166 {
167 UNIT_BYTE2_FLAG_PVP = 0x01,
168 UNIT_BYTE2_FLAG_UNK1 = 0x02,
169 UNIT_BYTE2_FLAG_FFA_PVP = 0x04,
170 UNIT_BYTE2_FLAG_SANCTUARY = 0x08,
171 UNIT_BYTE2_FLAG_UNK4 = 0x10,
172 UNIT_BYTE2_FLAG_UNK5 = 0x20,
173 UNIT_BYTE2_FLAG_UNK6 = 0x40,
174 UNIT_BYTE2_FLAG_UNK7 = 0x80
175 };
176
177 // byte (2 from 0..3) of UNIT_FIELD_BYTES_2
178 enum UnitRename
179 {
180 UNIT_RENAME_NOT_ALLOWED = 0x02,
181 UNIT_RENAME_ALLOWED = 0x03
182 };
183
184 #define CREATURE_MAX_SPELLS 4
185
186 enum Swing
187 {
188 NOSWING = 0,
189 SINGLEHANDEDSWING = 1,
190 TWOHANDEDSWING = 2
191 };
192
193 enum VictimState
194 {
195 VICTIMSTATE_UNKNOWN1 = 0,
196 VICTIMSTATE_NORMAL = 1,
197 VICTIMSTATE_DODGE = 2,
198 VICTIMSTATE_PARRY = 3,
199 VICTIMSTATE_INTERRUPT = 4,
200 VICTIMSTATE_BLOCKS = 5,
201 VICTIMSTATE_EVADES = 6,
202 VICTIMSTATE_IS_IMMUNE = 7,
203 VICTIMSTATE_DEFLECTS = 8
204 };
205
206 enum HitInfo
207 {
208 HITINFO_NORMALSWING = 0x00000000,
209 HITINFO_UNK1 = 0x00000001, // req correct packet structure
210 HITINFO_NORMALSWING2 = 0x00000002,
211 HITINFO_LEFTSWING = 0x00000004,
212 HITINFO_UNK2 = 0x00000008,
213 HITINFO_MISS = 0x00000010,
214 HITINFO_ABSORB = 0x00000020, // absorbed damage
215 HITINFO_ABSORB2 = 0x00000040, // absorbed damage
216 HITINFO_RESIST = 0x00000080, // resisted atleast some damage
217 HITINFO_RESIST2 = 0x00000100, // resisted atleast some damage
218 HITINFO_CRITICALHIT = 0x00000200, // critical hit
219 // 0x00000400
220 // 0x00000800
221 // 0x00001000
222 HITINFO_BLOCK = 0x00002000, // blocked damage
223 // 0x00004000
224 // 0x00008000
225 HITINFO_GLANCING = 0x00010000,
226 HITINFO_CRUSHING = 0x00020000,
227 HITINFO_NOACTION = 0x00040000, // guessed
228 // 0x00080000
229 // 0x00100000
230 HITINFO_SWINGNOHITSOUND = 0x00200000, // guessed
231 // 0x00400000
232 HITINFO_UNK3 = 0x00800000
233 };
234
235 //i would like to remove this: (it is defined in item.h
236 enum InventorySlot
237 {
238 NULL_BAG = 0,
239 NULL_SLOT = 255
240 };
241
242 struct FactionTemplateEntry;
243 struct Modifier;
244 struct SpellEntry;
245 struct SpellEntryExt;
246
247 class Aura;
248 class Creature;
249 class Spell;
250 class DynamicObject;
251 class GameObject;
252 class Item;
253 class Pet;
254 class Path;
255 class PetAura;
256
257 struct SpellImmune
258 {
259 uint32 type;
260 uint32 spellId;
261 };
262
263 typedef std::list<SpellImmune> SpellImmuneList;
264
265 enum UnitModifierType
266 {
267 BASE_VALUE = 0,
268 BASE_PCT = 1,
269 TOTAL_VALUE = 2,
270 TOTAL_PCT = 3,
271 MODIFIER_TYPE_END = 4
272 };
273
274 enum WeaponDamageRange
275 {
276 MINDAMAGE,
277 MAXDAMAGE
278 };
279
280 enum DamageTypeToSchool
281 {
282 RESISTANCE,
283 DAMAGE_DEALT,
284 DAMAGE_TAKEN
285 };
286
287 enum AuraRemoveMode
288 {
289 AURA_REMOVE_BY_DEFAULT,
290 AURA_REMOVE_BY_STACK, // at replace by semillar aura
291 AURA_REMOVE_BY_CANCEL,
292 AURA_REMOVE_BY_DISPEL,
293 AURA_REMOVE_BY_DEATH
294 };
295
296 enum UnitMods
297 {
298 UNIT_MOD_STAT_STRENGTH, // UNIT_MOD_STAT_STRENGTH..UNIT_MOD_STAT_SPIRIT must be in existed order, it's accessed by index values of Stats enum.
299 UNIT_MOD_STAT_AGILITY,
300 UNIT_MOD_STAT_STAMINA,
301 UNIT_MOD_STAT_INTELLECT,
302 UNIT_MOD_STAT_SPIRIT,
303 UNIT_MOD_HEALTH,
304 UNIT_MOD_MANA, // UNIT_MOD_MANA..UNIT_MOD_RUNIC_POWER must be in existed order, it's accessed by index values of Powers enum.
305 UNIT_MOD_RAGE,
306 UNIT_MOD_FOCUS,
307 UNIT_MOD_ENERGY,
308 UNIT_MOD_HAPPINESS,
309 UNIT_MOD_RUNE,
310 UNIT_MOD_RUNIC_POWER,
311 UNIT_MOD_ARMOR, // UNIT_MOD_ARMOR..UNIT_MOD_RESISTANCE_ARCANE must be in existed order, it's accessed by index values of SpellSchools enum.
312 UNIT_MOD_RESISTANCE_HOLY,
313 UNIT_MOD_RESISTANCE_FIRE,
314 UNIT_MOD_RESISTANCE_NATURE,
315 UNIT_MOD_RESISTANCE_FROST,
316 UNIT_MOD_RESISTANCE_SHADOW,
317 UNIT_MOD_RESISTANCE_ARCANE,
318 UNIT_MOD_ATTACK_POWER,
319 UNIT_MOD_ATTACK_POWER_RANGED,
320 UNIT_MOD_DAMAGE_MAINHAND,
321 UNIT_MOD_DAMAGE_OFFHAND,
322 UNIT_MOD_DAMAGE_RANGED,
323 UNIT_MOD_END,
324 // synonyms
325 UNIT_MOD_STAT_START = UNIT_MOD_STAT_STRENGTH,
326 UNIT_MOD_STAT_END = UNIT_MOD_STAT_SPIRIT + 1,
327 UNIT_MOD_RESISTANCE_START = UNIT_MOD_ARMOR,
328 UNIT_MOD_RESISTANCE_END = UNIT_MOD_RESISTANCE_ARCANE + 1,
329 UNIT_MOD_POWER_START = UNIT_MOD_MANA,
330 UNIT_MOD_POWER_END = UNIT_MOD_RUNIC_POWER + 1
331 };
332
333 enum BaseModGroup
334 {
335 CRIT_PERCENTAGE,
336 RANGED_CRIT_PERCENTAGE,
337 OFFHAND_CRIT_PERCENTAGE,
338 SHIELD_BLOCK_VALUE,
339 BASEMOD_END
340 };
341
342 enum BaseModType
343 {
344 FLAT_MOD,
345 PCT_MOD
346 };
347
348 #define MOD_END (PCT_MOD+1)
349
350 enum DeathState
351 {
352 ALIVE = 0,
353 JUST_DIED = 1,
354 CORPSE = 2,
355 DEAD = 3,
356 JUST_ALIVED = 4,
357 DEAD_FALLING= 5
358 };
359
360 enum UnitState
361 {
362 UNIT_STAT_DIED = 0x0001,
363 UNIT_STAT_MELEE_ATTACKING = 0x0002, // player is melee attacking someone
364 //UNIT_STAT_MELEE_ATTACK_BY = 0x0004, // player is melee attack by someone
365 UNIT_STAT_STUNNED = 0x0008,
366 UNIT_STAT_ROAMING = 0x0010,
367 UNIT_STAT_CHASE = 0x0020,
368 UNIT_STAT_SEARCHING = 0x0040,
369 UNIT_STAT_FLEEING = 0x0080,
370 UNIT_STAT_MOVING = (UNIT_STAT_ROAMING | UNIT_STAT_CHASE | UNIT_STAT_SEARCHING | UNIT_STAT_FLEEING),
371 UNIT_STAT_IN_FLIGHT = 0x0100, // player is in flight mode
372 UNIT_STAT_FOLLOW = 0x0200,
373 UNIT_STAT_ROOT = 0x0400,
374 UNIT_STAT_CONFUSED = 0x0800,
375 UNIT_STAT_DISTRACTED = 0x1000,
376 UNIT_STAT_ISOLATED = 0x2000, // area auras do not affect other players
377 UNIT_STAT_ATTACK_PLAYER = 0x4000,
378 UNIT_STAT_ALL_STATE = 0xffff //(UNIT_STAT_STOPPED | UNIT_STAT_MOVING | UNIT_STAT_IN_COMBAT | UNIT_STAT_IN_FLIGHT)
379 };
380
381 enum UnitMoveType
382 {
383 MOVE_WALK = 0,
384 MOVE_RUN = 1,
385 MOVE_RUN_BACK = 2,
386 MOVE_SWIM = 3,
387 MOVE_SWIM_BACK = 4,
388 MOVE_TURN_RATE = 5,
389 MOVE_FLIGHT = 6,
390 MOVE_FLIGHT_BACK = 7,
391 MOVE_PITCH_RATE = 8
392 };
393
394 #define MAX_MOVE_TYPE 9
395
396 extern float baseMoveSpeed[MAX_MOVE_TYPE];
397
398 enum WeaponAttackType
399 {
400 BASE_ATTACK = 0,
401 OFF_ATTACK = 1,
402 RANGED_ATTACK = 2
403 };
404
405 #define MAX_ATTACK 3
406
407 enum CombatRating
408 {
409 CR_WEAPON_SKILL = 0,
410 CR_DEFENSE_SKILL = 1,
411 CR_DODGE = 2,
412 CR_PARRY = 3,
413 CR_BLOCK = 4,
414 CR_HIT_MELEE = 5,
415 CR_HIT_RANGED = 6,
416 CR_HIT_SPELL = 7,
417 CR_CRIT_MELEE = 8,
418 CR_CRIT_RANGED = 9,
419 CR_CRIT_SPELL = 10,
420 CR_HIT_TAKEN_MELEE = 11,
421 CR_HIT_TAKEN_RANGED = 12,
422 CR_HIT_TAKEN_SPELL = 13,
423 CR_CRIT_TAKEN_MELEE = 14,
424 CR_CRIT_TAKEN_RANGED = 15,
425 CR_CRIT_TAKEN_SPELL = 16,
426 CR_HASTE_MELEE = 17,
427 CR_HASTE_RANGED = 18,
428 CR_HASTE_SPELL = 19,
429 CR_WEAPON_SKILL_MAINHAND = 20,
430 CR_WEAPON_SKILL_OFFHAND = 21,
431 CR_WEAPON_SKILL_RANGED = 22,
432 CR_EXPERTISE = 23,
433 CR_ARMOR_PENETRATION = 24
434 };
435
436 #define MAX_COMBAT_RATING 25
437
438 enum DamageEffectType
439 {
440 DIRECT_DAMAGE = 0, // used for normal weapon damage (not for class abilities or spells)
441 SPELL_DIRECT_DAMAGE = 1, // spell/class abilities damage
442 DOT = 2,
443 HEAL = 3,
444 NODAMAGE = 4, // used also in case when damage applied to health but not applied to spell channelInterruptFlags/etc
445 SELF_DAMAGE = 5
446 };
447
448 enum UnitVisibility
449 {
450 VISIBILITY_OFF = 0, // absolute, not detectable, GM-like, can see all other
451 VISIBILITY_ON = 1,
452 VISIBILITY_GROUP_STEALTH = 2, // detect chance, seen and can see group members
453 VISIBILITY_GROUP_INVISIBILITY = 3, // invisibility, can see and can be seen only another invisible unit or invisible detection unit, set only if not stealthed, and in checks not used (mask used instead)
454 VISIBILITY_GROUP_NO_DETECT = 4, // state just at stealth apply for update Grid state. Don't remove, otherwise stealth spells will break
455 VISIBILITY_RESPAWN = 5 // special totally not detectable visibility for force delete object at respawn command
456 };
457
458 // Value masks for UNIT_FIELD_FLAGS
459 enum UnitFlags
460 {
461 UNIT_FLAG_UNKNOWN7 = 0x00000001,
462 UNIT_FLAG_NON_ATTACKABLE = 0x00000002, // not attackable
463 UNIT_FLAG_DISABLE_MOVE = 0x00000004,
464 UNIT_FLAG_PVP_ATTACKABLE = 0x00000008, // allow apply pvp rules to attackable state in addition to faction dependent state
465 UNIT_FLAG_RENAME = 0x00000010,
466 UNIT_FLAG_PREPARATION = 0x00000020, // don't take reagents for spells with SPELL_ATTR_EX5_NO_REAGENT_WHILE_PREP
467 UNIT_FLAG_UNKNOWN9 = 0x00000040,
468 UNIT_FLAG_NOT_ATTACKABLE_1 = 0x00000080, // ?? (UNIT_FLAG_PVP_ATTACKABLE | UNIT_FLAG_NOT_ATTACKABLE_1) is NON_PVP_ATTACKABLE
469 UNIT_FLAG_UNKNOWN2 = 0x00000100, // 2.0.8
470 UNIT_FLAG_UNKNOWN11 = 0x00000200, // 3.0.3 - makes you unable to attack everything
471 UNIT_FLAG_LOOTING = 0x00000400, // loot animation
472 UNIT_FLAG_PET_IN_COMBAT = 0x00000800, // in combat?, 2.0.8
473 UNIT_FLAG_PVP = 0x00001000, // changed in 3.0.3
474 UNIT_FLAG_SILENCED = 0x00002000, // silenced, 2.1.1
475 UNIT_FLAG_UNKNOWN4 = 0x00004000, // 2.0.8
476 UNIT_FLAG_UNKNOWN13 = 0x00008000,
477 UNIT_FLAG_UNKNOWN14 = 0x00010000,
478 UNIT_FLAG_PACIFIED = 0x00020000, // 3.0.3 ok
479 UNIT_FLAG_STUNNED = 0x00040000, // 3.0.3 ok
480 UNIT_FLAG_IN_COMBAT = 0x00080000,
481 UNIT_FLAG_TAXI_FLIGHT = 0x00100000, // disable casting at client side spell not allowed by taxi flight (mounted?), probably used with 0x4 flag
482 UNIT_FLAG_DISARMED = 0x00200000, // 3.0.3, disable melee spells casting..., "Required melee weapon" added to melee spells tooltip.
483 UNIT_FLAG_CONFUSED = 0x00400000,
484 UNIT_FLAG_FLEEING = 0x00800000,
485 UNIT_FLAG_UNKNOWN5 = 0x01000000, // used in spell Eyes of the Beast for pet...
486 UNIT_FLAG_NOT_SELECTABLE = 0x02000000,
487 UNIT_FLAG_SKINNABLE = 0x04000000,
488 UNIT_FLAG_MOUNT = 0x08000000,
489 UNIT_FLAG_UNKNOWN17 = 0x10000000,
490 UNIT_FLAG_UNKNOWN6 = 0x20000000, // used in Feing Death spell
491 UNIT_FLAG_SHEATHE = 0x40000000
492 };
493
494 // Value masks for UNIT_FIELD_FLAGS_2
495 enum UnitFlags2
496 {
497 UNIT_FLAG2_FEIGN_DEATH = 0x00000001,
498 UNIT_FLAG2_COMPREHEND_LANG = 0x00000008,
499 UNIT_FLAG2_FORCE_MOVE = 0x00000040,
500 UNIT_FLAG2_REGENERATE_POWER = 0x00000800
501 };
502
503 /// Non Player Character flags
504 enum NPCFlags
505 {
506 UNIT_NPC_FLAG_NONE = 0x00000000,
507 UNIT_NPC_FLAG_GOSSIP = 0x00000001, // 100%
508 UNIT_NPC_FLAG_QUESTGIVER = 0x00000002, // guessed, probably ok
509 UNIT_NPC_FLAG_UNK1 = 0x00000004,
510 UNIT_NPC_FLAG_UNK2 = 0x00000008,
511 UNIT_NPC_FLAG_TRAINER = 0x00000010, // 100%
512 UNIT_NPC_FLAG_TRAINER_CLASS = 0x00000020, // 100%
513 UNIT_NPC_FLAG_TRAINER_PROFESSION = 0x00000040, // 100%
514 UNIT_NPC_FLAG_VENDOR = 0x00000080, // 100%
515 UNIT_NPC_FLAG_VENDOR_AMMO = 0x00000100, // 100%, general goods vendor
516 UNIT_NPC_FLAG_VENDOR_FOOD = 0x00000200, // 100%
517 UNIT_NPC_FLAG_VENDOR_POISON = 0x00000400, // guessed
518 UNIT_NPC_FLAG_VENDOR_REAGENT = 0x00000800, // 100%
519 UNIT_NPC_FLAG_REPAIR = 0x00001000, // 100%
520 UNIT_NPC_FLAG_FLIGHTMASTER = 0x00002000, // 100%
521 UNIT_NPC_FLAG_SPIRITHEALER = 0x00004000, // guessed
522 UNIT_NPC_FLAG_SPIRITGUIDE = 0x00008000, // guessed
523 UNIT_NPC_FLAG_INNKEEPER = 0x00010000, // 100%
524 UNIT_NPC_FLAG_BANKER = 0x00020000, // 100%
525 UNIT_NPC_FLAG_PETITIONER = 0x00040000, // 100% 0xC0000 = guild petitions, 0x40000 = arena team petitions
526 UNIT_NPC_FLAG_TABARDDESIGNER = 0x00080000, // 100%
527 UNIT_NPC_FLAG_BATTLEMASTER = 0x00100000, // 100%
528 UNIT_NPC_FLAG_AUCTIONEER = 0x00200000, // 100%
529 UNIT_NPC_FLAG_STABLEMASTER = 0x00400000, // 100%
530 UNIT_NPC_FLAG_GUILD_BANKER = 0x00800000, // cause client to send 997 opcode
531 UNIT_NPC_FLAG_SPELLCLICK = 0x01000000, // cause client to send 1015 opcode (spell click)
532 UNIT_NPC_FLAG_GUARD = 0x10000000, // custom flag for guards
533 };
534
535 enum MovementFlags
536 {
537 MOVEMENTFLAG_NONE = 0x00000000,
538 MOVEMENTFLAG_FORWARD = 0x00000001,
539 MOVEMENTFLAG_BACKWARD = 0x00000002,
540 MOVEMENTFLAG_STRAFE_LEFT = 0x00000004,
541 MOVEMENTFLAG_STRAFE_RIGHT = 0x00000008,
542 MOVEMENTFLAG_LEFT = 0x00000010,
543 MOVEMENTFLAG_RIGHT = 0x00000020,
544 MOVEMENTFLAG_PITCH_UP = 0x00000040,
545 MOVEMENTFLAG_PITCH_DOWN = 0x00000080,
546 MOVEMENTFLAG_WALK_MODE = 0x00000100, // Walking
547 MOVEMENTFLAG_ONTRANSPORT = 0x00000200, // Used for flying on some creatures
548 MOVEMENTFLAG_LEVITATING = 0x00000400,
549 MOVEMENTFLAG_FLY_UNK1 = 0x00000800,
550 MOVEMENTFLAG_JUMPING = 0x00001000,
551 MOVEMENTFLAG_UNK4 = 0x00002000,
552 MOVEMENTFLAG_FALLING = 0x00004000,
553 // 0x8000, 0x10000, 0x20000, 0x40000, 0x80000, 0x100000
554 MOVEMENTFLAG_SWIMMING = 0x00200000, // appears with fly flag also
555 MOVEMENTFLAG_FLY_UP = 0x00400000,
556 MOVEMENTFLAG_CAN_FLY = 0x00800000,
557 MOVEMENTFLAG_FLYING = 0x01000000,
558 MOVEMENTFLAG_FLYING2 = 0x02000000, // Actual flying mode
559 MOVEMENTFLAG_SPLINE = 0x04000000, // used for flight paths
560 MOVEMENTFLAG_SPLINE2 = 0x08000000, // used for flight paths
561 MOVEMENTFLAG_WATERWALKING = 0x10000000, // prevent unit from falling through water
562 MOVEMENTFLAG_SAFE_FALL = 0x20000000, // active rogue safe fall spell (passive)
563 MOVEMENTFLAG_UNK3 = 0x40000000
564 };
565
566 enum DiminishingLevels
567 {
568 DIMINISHING_LEVEL_1 = 0,
569 DIMINISHING_LEVEL_2 = 1,
570 DIMINISHING_LEVEL_3 = 2,
571 DIMINISHING_LEVEL_IMMUNE = 3
572 };
573
574 struct DiminishingReturn
575 {
576 DiminishingReturn(DiminishingGroup group, uint32 t, uint32 count) : DRGroup(group), hitTime(t), hitCount(count), stack(0) {}
577
578 DiminishingGroup DRGroup:16;
579 uint16 stack:16;
580 uint32 hitTime;
581 uint32 hitCount;
582 };
583
584 enum MeleeHitOutcome
585 {
586 MELEE_HIT_EVADE, MELEE_HIT_MISS, MELEE_HIT_DODGE, MELEE_HIT_BLOCK, MELEE_HIT_PARRY,
587 MELEE_HIT_GLANCING, MELEE_HIT_CRIT, MELEE_HIT_CRUSHING, MELEE_HIT_NORMAL, MELEE_HIT_BLOCK_CRIT
588 };
589 struct CleanDamage
590 {
591 CleanDamage(uint32 _damage, WeaponAttackType _attackType, MeleeHitOutcome _hitOutCome) :
592 damage(_damage), attackType(_attackType), hitOutCome(_hitOutCome) {}
593
594 uint32 damage;
595 WeaponAttackType attackType;
596 MeleeHitOutcome hitOutCome;
597 };
598
599 // Struct for use in Unit::CalculateMeleeDamage
600 // Need create structure like in SMSG_ATTACKERSTATEUPDATE opcode
601 struct CalcDamageInfo
602 {
603 Unit *attacker; // Attacker
604 Unit *target; // Target for damage
605 uint32 damageSchoolMask;
606 uint32 damage;
607 uint32 absorb;
608 uint32 resist;
609 uint32 blocked_amount;
610 uint32 HitInfo;
611 uint32 TargetState;
612 // Helper
613 WeaponAttackType attackType; //
614 uint32 procAttacker;
615 uint32 procVictim;
616 uint32 procEx;
617 uint32 cleanDamage; // Used only fo rage calcultion
618 MeleeHitOutcome hitOutCome; // TODO: remove this field (need use TargetState)
619 };
620
621 // Spell damage info structure based on structure sending in SMSG_SPELLNONMELEEDAMAGELOG opcode
622 struct SpellNonMeleeDamage{
623 SpellNonMeleeDamage(Unit *_attacker, Unit *_target, uint32 _SpellID, uint32 _schoolMask) :
624 attacker(_attacker), target(_target), SpellID(_SpellID), damage(0), schoolMask(_schoolMask),
625 absorb(0), resist(0), phusicalLog(false), unused(false), blocked(0), HitInfo(0), cleanDamage(0) {}
626 Unit *target;
627 Unit *attacker;
628 uint32 SpellID;
629 uint32 damage;
630 uint32 schoolMask;
631 uint32 absorb;
632 uint32 resist;
633 bool phusicalLog;
634 bool unused;
635 uint32 blocked;
636 uint32 HitInfo;
637 // Used for help
638 uint32 cleanDamage;
639 };
640
641 uint32 createProcExtendMask(SpellNonMeleeDamage *damageInfo, SpellMissInfo missCondition);
642
643 struct UnitActionBarEntry
644 {
645 union
646 {
647 struct
648 {
649 uint16 SpellOrAction;
650 uint16 Type;
651 };
652 struct
653 {
654 uint32 Raw;
655 };
656 };
657 };
658
659 #define MAX_DECLINED_NAME_CASES 5
660
661 struct DeclinedName
662 {
663 std::string name[MAX_DECLINED_NAME_CASES];
664 };
665
666 enum CurrentSpellTypes
667 {
668 CURRENT_MELEE_SPELL = 0,
669 CURRENT_FIRST_NON_MELEE_SPELL = 1, // just counter
670 CURRENT_GENERIC_SPELL = 1,
671 CURRENT_AUTOREPEAT_SPELL = 2,
672 CURRENT_CHANNELED_SPELL = 3,
673 CURRENT_MAX_SPELL = 4 // just counter
674 };
675
676 enum ActiveStates
677 {
678 ACT_PASSIVE = 0x0100, // 0x0100 - passive
679 ACT_DISABLED = 0x8100, // 0x8000 - castable
680 ACT_ENABLED = 0xC100, // 0x4000 | 0x8000 - auto cast + castable
681 ACT_COMMAND = 0x0700, // 0x0100 | 0x0200 | 0x0400
682 ACT_REACTION = 0x0600, // 0x0200 | 0x0400
683 ACT_DECIDE = 0x0001 // what is it?
684 };
685
686 enum ReactStates
687 {
688 REACT_PASSIVE = 0,
689 REACT_DEFENSIVE = 1,
690 REACT_AGGRESSIVE = 2
691 };
692
693 enum CommandStates
694 {
695 COMMAND_STAY = 0,
696 COMMAND_FOLLOW = 1,
697 COMMAND_ATTACK = 2,
698 COMMAND_ABANDON = 3
699 };
700
701 struct CharmSpellEntry
702 {
703 uint16 spellId;
704 uint16 active;
705 };
706
707 struct CharmInfo
708 {
709 public:
710 explicit CharmInfo(Unit* unit);
711 uint32 GetPetNumber() const { return m_petnumber; }
712 void SetPetNumber(uint32 petnumber, bool statwindow);
713
714 void SetCommandState(CommandStates st) { m_CommandState = st; }
715 CommandStates GetCommandState() { return m_CommandState; }
716 bool HasCommandState(CommandStates state) { return (m_CommandState == state); }
717 void SetReactState(ReactStates st) { m_reactState = st; }
718 ReactStates GetReactState() { return m_reactState; }
719 bool HasReactState(ReactStates state) { return (m_reactState == state); }
720
721 void InitPossessCreateSpells();
722 void InitCharmCreateSpells();
723 void InitPetActionBar();
724 void InitEmptyActionBar();
725 //return true if successful
726 bool AddSpellToAB(uint32 oldid, uint32 newid, ActiveStates newstate = ACT_DECIDE);
727 void ToggleCreatureAutocast(uint32 spellid, bool apply);
728
729 UnitActionBarEntry* GetActionBarEntry(uint8 index) { return &(PetActionBar[index]); }
730 CharmSpellEntry* GetCharmSpell(uint8 index) { return &(m_charmspells[index]); }
731 private:
732 Unit* m_unit;
733 UnitActionBarEntry PetActionBar[10];
734 CharmSpellEntry m_charmspells[4];
735 CommandStates m_CommandState;
736 ReactStates m_reactState;
737 uint32 m_petnumber;
738 };
739
740 // for clearing special attacks
741 #define REACTIVE_TIMER_START 4000
742
743 enum ReactiveType
744 {
745 REACTIVE_DEFENSE = 1,
746 REACTIVE_HUNTER_PARRY = 2,
747 REACTIVE_CRIT = 3,
748 REACTIVE_HUNTER_CRIT = 4,
749 REACTIVE_OVERPOWER = 5
750 };
751
752 #define MAX_REACTIVE 6
753 #define MAX_TOTEM 4
754
755 // delay time next attack to prevent client attack animation problems
756 #define ATTACK_DISPLAY_DELAY 200
757
758 struct SpellProcEventEntry; // used only privately
759
760 class MANGOS_DLL_SPEC Unit : public WorldObject
761 {
762 public:
763 typedef std::set<Unit*> AttackerSet;
764 typedef std::pair<uint32, uint8> spellEffectPair;
765 typedef std::multimap< spellEffectPair, Aura*> AuraMap;
766 typedef std::list<Aura *> AuraList;
767 typedef std::list<DiminishingReturn> Diminishing;
768 typedef std::set<uint32> ComboPointHolderSet;
769 typedef std::map<uint8, uint32> VisibleAuraMap;
770
771 virtual ~Unit ( );
772
773 void AddToWorld();
774 void RemoveFromWorld();
775
776 void CleanupsBeforeDelete(); // used in ~Creature/~Player (or before mass creature delete to remove cross-references to already deleted units)
777
778 DiminishingLevels GetDiminishing(DiminishingGroup group);
779 void IncrDiminishing(DiminishingGroup group);
780 void ApplyDiminishingToDuration(DiminishingGroup group, int32 &duration,Unit* caster, DiminishingLevels Level);
781 void ApplyDiminishingAura(DiminishingGroup group, bool apply);
782 void ClearDiminishings() { m_Diminishing.clear(); }
783
784 virtual void Update( uint32 time );
785
786 void setAttackTimer(WeaponAttackType type, uint32 time) { m_attackTimer[type] = time; }
787 void resetAttackTimer(WeaponAttackType type = BASE_ATTACK);
788 uint32 getAttackTimer(WeaponAttackType type) const { return m_attackTimer[type]; }
789 bool isAttackReady(WeaponAttackType type = BASE_ATTACK) const { return m_attackTimer[type] == 0; }
790 bool haveOffhandWeapon() const;
791 bool canReachWithAttack(Unit *pVictim) const;
792 uint32 m_extraAttacks;
793
794 void _addAttacker(Unit *pAttacker) // must be called only from Unit::Attack(Unit*)
795 {
796 AttackerSet::iterator itr = m_attackers.find(pAttacker);
797 if(itr == m_attackers.end())
798 m_attackers.insert(pAttacker);
799 }
800 void _removeAttacker(Unit *pAttacker) // must be called only from Unit::AttackStop()
801 {
802 AttackerSet::iterator itr = m_attackers.find(pAttacker);
803 if(itr != m_attackers.end())
804 m_attackers.erase(itr);
805 }
806 Unit * getAttackerForHelper() // If someone wants to help, who to give them
807 {
808 if (getVictim() != NULL)
809 return getVictim();
810
811 if (!m_attackers.empty())
812 return *(m_attackers.begin());
813
814 return NULL;
815 }
816 bool Attack(Unit *victim, bool meleeAttack);
817 void CastStop(uint32 except_spellid = 0);
818 bool AttackStop();
819 void RemoveAllAttackers();
820 AttackerSet const& getAttackers() const { return m_attackers; }
821 bool isAttackingPlayer() const;
822 Unit* getVictim() const { return m_attacking; }
823 void CombatStop(bool cast = false);
824 void CombatStopWithPets(bool cast = false);
825 Unit* SelectNearbyTarget() const;
826
827 void addUnitState(uint32 f) { m_state |= f; }
828 bool hasUnitState(const uint32 f) const { return (m_state & f); }
829 void clearUnitState(uint32 f) { m_state &= ~f; }
830 bool CanFreeMove() const
831 {
832 return !hasUnitState(UNIT_STAT_CONFUSED | UNIT_STAT_FLEEING | UNIT_STAT_IN_FLIGHT |
833 UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED ) && GetOwnerGUID()==0;
834 }
835
836 uint32 getLevel() const { return GetUInt32Value(UNIT_FIELD_LEVEL); }
837 virtual uint32 getLevelForTarget(Unit const* /*target*/) const { return getLevel(); }
838 void SetLevel(uint32 lvl);
839 uint8 getRace() const { return GetByteValue(UNIT_FIELD_BYTES_0, 0); }
840 uint32 getRaceMask() const { return 1 << (getRace()-1); }
841 uint8 getClass() const { return GetByteValue(UNIT_FIELD_BYTES_0, 1); }
842 uint32 getClassMask() const { return 1 << (getClass()-1); }
843 uint8 getGender() const { return GetByteValue(UNIT_FIELD_BYTES_0, 2); }
844
845 float GetStat(Stats stat) const { return float(GetUInt32Value(UNIT_FIELD_STAT0+stat)); }
846 void SetStat(Stats stat, int32 val) { SetStatInt32Value(UNIT_FIELD_STAT0+stat, val); }
847 uint32 GetArmor() const { return GetResistance(SPELL_SCHOOL_NORMAL) ; }
848 void SetArmor(int32 val) { SetResistance(SPELL_SCHOOL_NORMAL, val); }
849
850 uint32 GetResistance(SpellSchools school) const { return GetUInt32Value(UNIT_FIELD_RESISTANCES+school); }
851 void SetResistance(SpellSchools school, int32 val) { SetStatInt32Value(UNIT_FIELD_RESISTANCES+school,val); }
852
853 uint32 GetHealth() const { return GetUInt32Value(UNIT_FIELD_HEALTH); }
854 uint32 GetMaxHealth() const { return GetUInt32Value(UNIT_FIELD_MAXHEALTH); }
855 void SetHealth( uint32 val);
856 void SetMaxHealth(uint32 val);
857 int32 ModifyHealth(int32 val);
858
859 Powers getPowerType() const { return Powers(GetByteValue(UNIT_FIELD_BYTES_0, 3)); }
860 void setPowerType(Powers power);
861 uint32 GetPower( Powers power) const { return GetUInt32Value(UNIT_FIELD_POWER1 +power); }
862 uint32 GetMaxPower(Powers power) const { return GetUInt32Value(UNIT_FIELD_MAXPOWER1+power); }
863 void SetPower( Powers power, uint32 val);
864 void SetMaxPower(Powers power, uint32 val);
865 int32 ModifyPower(Powers power, int32 val);
866 void ApplyPowerMod(Powers power, uint32 val, bool apply);
867 void ApplyMaxPowerMod(Powers power, uint32 val, bool apply);
868
869 uint32 GetAttackTime(WeaponAttackType att) const { return (uint32)(GetFloatValue(UNIT_FIELD_BASEATTACKTIME+att)/m_modAttackSpeedPct[att]); }
870 void SetAttackTime(WeaponAttackType att, uint32 val) { SetFloatValue(UNIT_FIELD_BASEATTACKTIME+att,val*m_modAttackSpeedPct[att]); }
871 void ApplyAttackTimePercentMod(WeaponAttackType att,float val, bool apply);
872 void ApplyCastTimePercentMod(float val, bool apply);
873
874 // faction template id
875 uint32 getFaction() const { return GetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE); }
876 void setFaction(uint32 faction) { SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, faction ); }
877 FactionTemplateEntry const* getFactionTemplateEntry() const;
878 bool IsHostileTo(Unit const* unit) const;
879 bool IsHostileToPlayers() const;
880 bool IsFriendlyTo(Unit const* unit) const;
881 bool IsNeutralToAll() const;
882 bool IsContestedGuard() const
883 {
884 if(FactionTemplateEntry const* entry = getFactionTemplateEntry())
885 return entry->IsContestedGuardFaction();
886
887 return false;
888 }
889 bool IsPvP() const { return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP); }
890 void SetPvP(bool state)
891 {
892 if(state)
893 SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
894 else
895 RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
896 }
897 uint32 GetCreatureType() const;
898 uint32 GetCreatureTypeMask() const
899 {
900 uint32 creatureType = GetCreatureType();
901 return (creatureType >= 1) ? (1 << (creatureType - 1)) : 0;
902 }
903
904 uint8 getStandState() const { return GetByteValue(UNIT_FIELD_BYTES_1, 0); }
905 bool IsSitState() const;
906 bool IsStandState() const;
907 void SetStandState(uint8 state);
908
909 bool IsMounted() const { return HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT ); }
910 uint32 GetMountID() const { return GetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID); }
911 void Mount(uint32 mount);
912 void Unmount();
913
914 uint16 GetMaxSkillValueForLevel(Unit const* target = NULL) const { return (target ? getLevelForTarget(target) : getLevel()) * 5; }
915 uint32 DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDamage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask, SpellEntry const *spellProto, bool durabilityLoss);
916
917 void ProcDamageAndSpell(Unit *pVictim, uint32 procAttacker, uint32 procVictim, uint32 procEx, uint32 amount, WeaponAttackType attType = BASE_ATTACK, SpellEntry const *procSpell = NULL);
918 void ProcDamageAndSpellFor( bool isVictim, Unit * pTarget, uint32 procFlag, uint32 procExtra, WeaponAttackType attType, SpellEntry const * procSpell, uint32 damage );
919
920 void HandleEmoteCommand(uint32 anim_id);
921 void AttackerStateUpdate (Unit *pVictim, WeaponAttackType attType = BASE_ATTACK, bool extra = false );
922
923 float MeleeMissChanceCalc(const Unit *pVictim, WeaponAttackType attType) const;
924
925 void CalculateMeleeDamage(Unit *pVictim, uint32 damage, CalcDamageInfo *damageInfo, WeaponAttackType attackType = BASE_ATTACK);
926 void DealMeleeDamage(CalcDamageInfo *damageInfo, bool durabilityLoss);
927
928 void CalculateSpellDamage(SpellNonMeleeDamage *damageInfo, int32 damage, SpellEntry const *spellInfo, WeaponAttackType attackType = BASE_ATTACK);
929 void DealSpellDamage(SpellNonMeleeDamage *damageInfo, bool durabilityLoss);
930
931 float MeleeSpellMissChance(Unit *pVictim, WeaponAttackType attType, int32 skillDiff, SpellEntry const *spell);
932 SpellMissInfo MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell);
933 SpellMissInfo MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell);
934 SpellMissInfo SpellHitResult(Unit *pVictim, SpellEntry const *spell, bool canReflect = false);
935
936 float GetUnitDodgeChance() const;
937 float GetUnitParryChance() const;
938 float GetUnitBlockChance() const;
939 float GetUnitCriticalChance(WeaponAttackType attackType, const Unit *pVictim) const;
940
941 virtual uint32 GetShieldBlockValue() const =0;
942 uint32 GetUnitMeleeSkill(Unit const* target = NULL) const { return (target ? getLevelForTarget(target) : getLevel()) * 5; }
943 uint32 GetDefenseSkillValue(Unit const* target = NULL) const;
944 uint32 GetWeaponSkillValue(WeaponAttackType attType, Unit const* target = NULL) const;
945 float GetWeaponProcChance() const;
946 float GetPPMProcChance(uint32 WeaponSpeed, float PPM) const;
947
948 MeleeHitOutcome RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttackType attType) const;
949 MeleeHitOutcome RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttackType attType, int32 crit_chance, int32 miss_chance, int32 dodge_chance, int32 parry_chance, int32 block_chance, bool SpellCasted ) const;
950
951 bool isVendor() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_VENDOR ); }
952 bool isTrainer() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_TRAINER ); }
953 bool isQuestGiver() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER ); }
954 bool isGossip() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP ); }
955 bool isTaxi() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_FLIGHTMASTER ); }
956 bool isGuildMaster() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_PETITIONER ); }
957 bool isBattleMaster() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_BATTLEMASTER ); }
958 bool isBanker() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_BANKER ); }
959 bool isInnkeeper() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_INNKEEPER ); }
960 bool isSpiritHealer() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPIRITHEALER ); }
961 bool isSpiritGuide() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPIRITGUIDE ); }
962 bool isTabardDesigner()const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_TABARDDESIGNER ); }
963 bool isAuctioner() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_AUCTIONEER ); }
964 bool isArmorer() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_REPAIR ); }
965 bool isServiceProvider() const
966 {
967 return HasFlag( UNIT_NPC_FLAGS,
968 UNIT_NPC_FLAG_VENDOR | UNIT_NPC_FLAG_TRAINER | UNIT_NPC_FLAG_FLIGHTMASTER |
969 UNIT_NPC_FLAG_PETITIONER | UNIT_NPC_FLAG_BATTLEMASTER | UNIT_NPC_FLAG_BANKER |
970 UNIT_NPC_FLAG_INNKEEPER | UNIT_NPC_FLAG_GUARD | UNIT_NPC_FLAG_SPIRITHEALER |
971 UNIT_NPC_FLAG_SPIRITGUIDE | UNIT_NPC_FLAG_TABARDDESIGNER | UNIT_NPC_FLAG_AUCTIONEER );
972 }
973 bool isSpiritService() const { return HasFlag( UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPIRITHEALER | UNIT_NPC_FLAG_SPIRITGUIDE ); }
974
975 //Need fix or use this
976 bool isGuard() const { return HasFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GUARD); }
977
978 bool isInFlight() const { return hasUnitState(UNIT_STAT_IN_FLIGHT); }
979
980 bool isInCombat() const { return HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT); }
981 void SetInCombatState(bool PvP);
982 void SetInCombatWith(Unit* enemy);
983 void ClearInCombat();
984 uint32 GetCombatTimer() const { return m_CombatTimer; }
985
986 bool HasAuraType(AuraType auraType) const;
987 bool HasAura(uint32 spellId, uint32 effIndex) const
988 { return m_Auras.find(spellEffectPair(spellId, effIndex)) != m_Auras.end(); }
989
990 bool virtual HasSpell(uint32 /*spellID*/) const { return false; }
991
992 bool HasStealthAura() const { return HasAuraType(SPELL_AURA_MOD_STEALTH); }
993 bool HasInvisibilityAura() const { return HasAuraType(SPELL_AURA_MOD_INVISIBILITY); }
994 bool isFeared() const { return HasAuraType(SPELL_AURA_MOD_FEAR); }
995 bool isInRoots() const { return HasAuraType(SPELL_AURA_MOD_ROOT); }
996 bool IsPolymorphed() const;
997
998 bool isFrozen() const;
999
1000 void RemoveSpellbyDamageTaken(AuraType auraType, uint32 damage);
1001
1002 bool isTargetableForAttack() const;
1003 virtual bool IsInWater() const;
1004 virtual bool IsUnderWater() const;
1005 bool isInAccessablePlaceFor(Creature const* c) const;
1006
1007 void SendHealSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, bool critical = false);
1008 void SendEnergizeSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage,Powers powertype);
1009 uint32 SpellNonMeleeDamageLog(Unit *pVictim, uint32 spellID, uint32 damage, bool isTriggeredSpell = false, bool useSpellDamage = true);
1010 void CastSpell(Unit* Victim, uint32 spellId, bool triggered, Item *castItem = NULL, Aura* triggeredByAura = NULL, uint64 originalCaster = 0);
1011 void CastSpell(Unit* Victim,SpellEntry const *spellInfo, bool triggered, Item *castItem= NULL, Aura* triggeredByAura = NULL, uint64 originalCaster = 0);
1012 void CastCustomSpell(Unit* Victim, uint32 spellId, int32 const* bp0, int32 const* bp1, int32 const* bp2, bool triggered, Item *castItem= NULL, Aura* triggeredByAura = NULL, uint64 originalCaster = 0);
1013 void CastCustomSpell(Unit* Victim,SpellEntry const *spellInfo, int32 const* bp0, int32 const* bp1, int32 const* bp2, bool triggered, Item *castItem= NULL, Aura* triggeredByAura = NULL, uint64 originalCaster = 0);
1014 void CastSpell(float x, float y, float z, uint32 spellId, bool triggered, Item *castItem = NULL, Aura* triggeredByAura = NULL, uint64 originalCaster = 0);
1015 void CastSpell(float x, float y, float z, SpellEntry const *spellInfo, bool triggered, Item *castItem = NULL, Aura* triggeredByAura = NULL, uint64 originalCaster = 0);
1016
1017 bool IsDamageToThreatSpell(SpellEntry const * spellInfo) const;
1018
1019 void DeMorph();
1020
1021 void SendAttackStateUpdate(CalcDamageInfo *damageInfo);
1022 void SendAttackStateUpdate(uint32 HitInfo, Unit *target, uint8 SwingType, SpellSchoolMask damageSchoolMask, uint32 Damage, uint32 AbsorbDamage, uint32 Resist, VictimState TargetState, uint32 BlockedAmount);
1023 void SendSpellNonMeleeDamageLog(SpellNonMeleeDamage *log);
1024 void SendSpellNonMeleeDamageLog(Unit *target,uint32 SpellID,uint32 Damage, SpellSchoolMask damageSchoolMask,uint32 AbsorbedDamage, uint32 Resist,bool PhysicalDamage, uint32 Blocked, bool CriticalHit = false);
1025 void SendSpellMiss(Unit *target, uint32 spellID, SpellMissInfo missInfo);
1026
1027 void SendMonsterMove(float NewPosX, float NewPosY, float NewPosZ, uint8 type, uint32 MovementFlags, uint32 Time, Player* player = NULL);
1028 void SendMonsterMoveByPath(Path const& path, uint32 start, uint32 end, uint32 MovementFlags);
1029 void SendMonsterMoveWithSpeed(float x, float y, float z, uint32 MovementFlags, uint32 transitTime = 0, Player* player = NULL);
1030 void SendMonsterMoveWithSpeedToCurrentDestination(Player* player = NULL);
1031
1032 virtual void MoveOutOfRange(Player &) { };
1033
1034 bool isAlive() const { return (m_deathState == ALIVE); };
1035 bool isDead() const { return ( m_deathState == DEAD || m_deathState == CORPSE ); };
1036 DeathState getDeathState() { return m_deathState; };
1037 virtual void setDeathState(DeathState s); // overwrited in Creature/Player/Pet
1038
1039 uint64 GetOwnerGUID() const { return GetUInt64Value(UNIT_FIELD_SUMMONEDBY); }
1040 void SetOwnerGUID(uint64 owner) { SetUInt64Value(UNIT_FIELD_SUMMONEDBY, owner); }
1041 uint64 GetCreatorGUID() const { return GetUInt64Value(UNIT_FIELD_CREATEDBY); }
1042 void SetCreatorGUID(uint64 creator) { SetUInt64Value(UNIT_FIELD_CREATEDBY, creator); }
1043 uint64 GetPetGUID() const { return GetUInt64Value(UNIT_FIELD_SUMMON); }
1044 uint64 GetCharmerGUID() const { return GetUInt64Value(UNIT_FIELD_CHARMEDBY); }
1045 void SetCharmerGUID(uint64 owner) { SetUInt64Value(UNIT_FIELD_CHARMEDBY, owner); }
1046 uint64 GetCharmGUID() const { return GetUInt64Value(UNIT_FIELD_CHARM); }
1047
1048 uint64 GetCharmerOrOwnerGUID() const { return GetCharmerGUID() ? GetCharmerGUID() : GetOwnerGUID(); }
1049 uint64 GetCharmerOrOwnerOrOwnGUID() const
1050 {
1051 if(uint64 guid = GetCharmerOrOwnerGUID())
1052 return guid;
1053 return GetGUID();
1054 }
1055 bool isCharmedOwnedByPlayerOrPlayer() const { return IS_PLAYER_GUID(GetCharmerOrOwnerOrOwnGUID()); }
1056
1057 Player* GetSpellModOwner();
1058
1059 Unit* GetOwner() const;
1060 Pet* GetPet() const;
1061 Unit* GetCharmer() const;
1062 Unit* GetCharm() const;
1063 Unit* GetCharmerOrOwner() const { return GetCharmerGUID() ? GetCharmer() : GetOwner(); }
1064 Unit* GetCharmerOrOwnerOrSelf()
1065 {
1066 if(Unit* u = GetCharmerOrOwner())
1067 return u;
1068
1069 return this;
1070 }
1071 Player* GetCharmerOrOwnerPlayerOrPlayerItself();
1072
1073 void SetPet(Pet* pet);
1074 void SetCharm(Unit* pet);
1075
1076 bool isCharmed() const { return GetCharmerGUID() != 0; }
1077
1078 CharmInfo* GetCharmInfo() { return m_charmInfo; }
1079 CharmInfo* InitCharmInfo(Unit* charm);
1080
1081 Pet* CreateTamedPetFrom(Creature* creatureTarget,uint32 spell_id = 0);
1082
1083 bool AddAura(Aura *aur);
1084
1085 void RemoveAura(AuraMap::iterator &i, AuraRemoveMode mode = AURA_REMOVE_BY_DEFAULT);
1086 void RemoveAura(uint32 spellId, uint32 effindex, Aura* except = NULL);
1087 void RemoveSingleAuraFromStack(uint32 spellId, uint32 effindex);
1088 void RemoveAurasDueToSpell(uint32 spellId, Aura* except = NULL);
1089 void RemoveAurasDueToItemSpell(Item* castItem,uint32 spellId);
1090 void RemoveAurasDueToSpellByDispel(uint32 spellId, uint64 casterGUID, Unit *dispeler);
1091 void RemoveAurasDueToSpellBySteal(uint32 spellId, uint64 casterGUID, Unit *stealer);
1092 void RemoveAurasDueToSpellByCancel(uint32 spellId);
1093 void RemoveAurasAtChanneledTarget(SpellEntry const* spellInfo);
1094 void RemoveNotOwnSingleTargetAuras();
1095
1096 void RemoveSpellsCausingAura(AuraType auraType);
1097 void RemoveRankAurasDueToSpell(uint32 spellId);
1098 bool RemoveNoStackAurasDueToAura(Aura *Aur);
1099 void RemoveAurasWithInterruptFlags(uint32 flags);
1100 void RemoveAurasWithDispelType( DispelType type );
1101
1102 void RemoveAllAuras();
1103 void RemoveArenaAuras(bool onleave = false);
1104 void RemoveAllAurasOnDeath();
1105 void DelayAura(uint32 spellId, uint32 effindex, int32 delaytime);
1106
1107 float GetResistanceBuffMods(SpellSchools school, bool positive) const { return GetFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school ); }
1108 void SetResistanceBuffMods(SpellSchools school, bool positive, float val) { SetFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school,val); }
1109 void ApplyResistanceBuffModsMod(SpellSchools school, bool positive, float val, bool apply) { ApplyModSignedFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val, apply); }
1110 void ApplyResistanceBuffModsPercentMod(SpellSchools school, bool positive, float val, bool apply) { ApplyPercentModFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val, apply); }
1111 void InitStatBuffMods()
1112 {
1113 for(int i = STAT_STRENGTH; i < MAX_STATS; ++i) SetFloatValue(UNIT_FIELD_POSSTAT0+i, 0);
1114 for(int i = STAT_STRENGTH; i < MAX_STATS; ++i) SetFloatValue(UNIT_FIELD_NEGSTAT0+i, 0);
1115 }
1116 void ApplyStatBuffMod(Stats stat, float val, bool apply) { ApplyModSignedFloatValue((val > 0 ? UNIT_FIELD_POSSTAT0+stat : UNIT_FIELD_NEGSTAT0+stat), val, apply); }
1117 void ApplyStatPercentBuffMod(Stats stat, float val, bool apply)
1118 {
1119 ApplyPercentModFloatValue(UNIT_FIELD_POSSTAT0+stat, val, apply);
1120 ApplyPercentModFloatValue(UNIT_FIELD_NEGSTAT0+stat, val, apply);
1121 }
1122 void SetCreateStat(Stats stat, float val) { m_createStats[stat] = val; }
1123 void SetCreateHealth(uint32 val) { SetUInt32Value(UNIT_FIELD_BASE_HEALTH, val); }
1124 uint32 GetCreateHealth() const { return GetUInt32Value(UNIT_FIELD_BASE_HEALTH); }
1125 void SetCreateMana(uint32 val) { SetUInt32Value(UNIT_FIELD_BASE_MANA, val); }
1126 uint32 GetCreateMana() const { return GetUInt32Value(UNIT_FIELD_BASE_MANA); }
1127 uint32 GetCreatePowers(Powers power) const;
1128 float GetPosStat(Stats stat) const { return GetFloatValue(UNIT_FIELD_POSSTAT0+stat); }
1129 float GetNegStat(Stats stat) const { return GetFloatValue(UNIT_FIELD_NEGSTAT0+stat); }
1130 float GetCreateStat(Stats stat) const { return m_createStats[stat]; }
1131
1132 void SetCurrentCastedSpell(Spell * pSpell);
1133 virtual void ProhibitSpellScholl(SpellSchoolMask /*idSchoolMask*/, uint32 /*unTimeMs*/ ) { }
1134 void InterruptSpell(uint32 spellType, bool withDelayed = true);
1135
1136 // set withDelayed to true to account delayed spells as casted
1137 // delayed+channeled spells are always accounted as casted
1138 // we can skip channeled or delayed checks using flags
1139 bool IsNonMeleeSpellCasted(bool withDelayed, bool skipChanneled = false, bool skipAutorepeat = false) const;
1140
1141 // set withDelayed to true to interrupt delayed spells too
1142 // delayed+channeled spells are always interrupted
1143 void InterruptNonMeleeSpells(bool withDelayed, uint32 spellid = 0);
1144
1145 Spell* FindCurrentSpellBySpellId(uint32 spell_id) const;
1146
1147 Spell* m_currentSpells[CURRENT_MAX_SPELL];
1148
1149 uint32 m_addDmgOnce;
1150 uint64 m_TotemSlot[MAX_TOTEM];
1151 uint64 m_ObjectSlot[4];
1152 uint32 m_detectInvisibilityMask;
1153 uint32 m_invisibilityMask;
1154 uint32 m_ShapeShiftFormSpellId;
1155 ShapeshiftForm m_form;
1156 float m_modMeleeHitChance;
1157 float m_modRangedHitChance;
1158 float m_modSpellHitChance;
1159 int32 m_baseSpellCritChance;
1160
1161 float m_threatModifier[MAX_SPELL_SCHOOL];
1162 float m_modAttackSpeedPct[3];
1163
1164 // Event handler
1165 EventProcessor m_Events;
1166
1167 // stat system
1168 bool HandleStatModifier(UnitMods unitMod, UnitModifierType modifierType, float amount, bool apply);
1169 void SetModifierValue(UnitMods unitMod, UnitModifierType modifierType, float value) { m_auraModifiersGroup[unitMod][modifierType] = value; }
1170 float GetModifierValue(UnitMods unitMod, UnitModifierType modifierType) const;
1171 float GetTotalStatValue(Stats stat) const;
1172 float GetTotalAuraModValue(UnitMods unitMod) const;
1173 SpellSchools GetSpellSchoolByAuraGroup(UnitMods unitMod) const;
1174 Stats GetStatByAuraGroup(UnitMods unitMod) const;
1175 Powers GetPowerTypeByAuraGroup(UnitMods unitMod) const;
1176 bool CanModifyStats() const { return m_canModifyStats; }
1177 void SetCanModifyStats(bool modifyStats) { m_canModifyStats = modifyStats; }
1178 virtual bool UpdateStats(Stats stat) = 0;
1179 virtual bool UpdateAllStats() = 0;
1180 virtual void UpdateResistances(uint32 school) = 0;
1181 virtual void UpdateArmor() = 0;
1182 virtual void UpdateMaxHealth() = 0;
1183 virtual void UpdateMaxPower(Powers power) = 0;
1184 virtual void UpdateAttackPowerAndDamage(bool ranged = false) = 0;
1185 virtual void UpdateDamagePhysical(WeaponAttackType attType) = 0;
1186 float GetTotalAttackPowerValue(WeaponAttackType attType) const;
1187 float GetWeaponDamageRange(WeaponAttackType attType ,WeaponDamageRange type) const;
1188 void SetBaseWeaponDamage(WeaponAttackType attType ,WeaponDamageRange damageRange, float value) { m_weaponDamage[attType][damageRange] = value; }
1189
1190 bool isInFront(Unit const* target,float distance, float arc = M_PI) const;
1191 void SetInFront(Unit const* target);
1192 bool isInBack(Unit const* target, float distance, float arc = M_PI) const;
1193
1194 // Visibility system
1195 UnitVisibility GetVisibility() const { return m_Visibility; }
1196 void SetVisibility(UnitVisibility x);
1197
1198 // common function for visibility checks for player/creatures with detection code
1199 bool isVisibleForOrDetect(Unit const* u, bool detect, bool inVisibleList = false, bool is3dDistance = true) const;
1200 bool canDetectInvisibilityOf(Unit const* u) const;
1201
1202 // virtual functions for all world objects types
1203 bool isVisibleForInState(Player const* u, bool inVisibleList) const;
1204 // function for low level grid visibility checks in player/creature cases
1205 virtual bool IsVisibleInGridForPlayer(Player* pl) const = 0;
1206
1207 bool waterbreath;
1208 AuraList & GetSingleCastAuras() { return m_scAuras; }
1209 AuraList const& GetSingleCastAuras() const { return m_scAuras; }
1210 SpellImmuneList m_spellImmune[MAX_SPELL_IMMUNITY];
1211
1212 // Threat related methods
1213 bool CanHaveThreatList() const;
1214 void AddThreat(Unit* pVictim, float threat, SpellSchoolMask schoolMask = SPELL_SCHOOL_MASK_NORMAL, SpellEntry const *threatSpell = NULL);
1215 float ApplyTotalThreatModifier(float threat, SpellSchoolMask schoolMask = SPELL_SCHOOL_MASK_NORMAL);
1216 void DeleteThreatList();
1217 bool SelectHostilTarget();
1218 void TauntApply(Unit* pVictim);
1219 void TauntFadeOut(Unit *taunter);
1220 ThreatManager& getThreatManager() { return m_ThreatManager; }
1221 void addHatedBy(HostilReference* pHostilReference) { m_HostilRefManager.insertFirst(pHostilReference); };
1222 void removeHatedBy(HostilReference* /*pHostilReference*/ ) { /* nothing to do yet */ }
1223 HostilRefManager& getHostilRefManager() { return m_HostilRefManager; }
1224
1225 uint32 GetVisibleAura(uint8 slot)
1226 {
1227 VisibleAuraMap::iterator itr = m_visibleAuras.find(slot);
1228 if(itr != m_visibleAuras.end())
1229 return itr->second;
1230 return 0;
1231 }
1232 void SetVisibleAura(uint8 slot, uint32 spellid)
1233 {
1234 if(spellid == 0)
1235 {
1236 VisibleAuraMap::iterator itr = m_visibleAuras.find(slot);
1237 if(itr != m_visibleAuras.end())
1238 {
1239 m_visibleAuras.erase(itr);
1240 return;
1241 }
1242 }
1243 else
1244 m_visibleAuras[slot] = spellid;
1245 }
1246 VisibleAuraMap const *GetVisibleAuras() { return &m_visibleAuras; }
1247 uint8 GetVisibleAurasCount() { return m_visibleAuras.size(); }
1248
1249 Aura* GetAura(uint32 spellId, uint32 effindex);
1250 AuraMap & GetAuras() { return m_Auras; }
1251 AuraMap const& GetAuras() const { return m_Auras; }
1252 AuraList const& GetAurasByType(AuraType type) const { return m_modAuras[type]; }
1253 void ApplyAuraProcTriggerDamage(Aura* aura, bool apply);
1254
1255 int32 GetTotalAuraModifier(AuraType auratype) const;
1256 float GetTotalAuraMultiplier(AuraType auratype) const;
1257 int32 GetMaxPositiveAuraModifier(AuraType auratype) const;
1258 int32 GetMaxNegativeAuraModifier(AuraType auratype) const;
1259
1260 int32 GetTotalAuraModifierByMiscMask(AuraType auratype, uint32 misc_mask) const;
1261 float GetTotalAuraMultiplierByMiscMask(AuraType auratype, uint32 misc_mask) const;
1262 int32 GetMaxPositiveAuraModifierByMiscMask(AuraType auratype, uint32 misc_mask) const;
1263 int32 GetMaxNegativeAuraModifierByMiscMask(AuraType auratype, uint32 misc_mask) const;
1264
1265 int32 GetTotalAuraModifierByMiscValue(AuraType auratype, int32 misc_value) const;
1266 float GetTotalAuraMultiplierByMiscValue(AuraType auratype, int32 misc_value) const;
1267 int32 GetMaxPositiveAuraModifierByMiscValue(AuraType auratype, int32 misc_value) const;
1268 int32 GetMaxNegativeAuraModifierByMiscValue(AuraType auratype, int32 misc_value) const;
1269
1270 Aura* GetDummyAura(uint32 spell_id) const;
1271
1272 uint32 GetDisplayId() { return GetUInt32Value(UNIT_FIELD_DISPLAYID); }
1273 void SetDisplayId(uint32 modelId);
1274 uint32 GetNativeDisplayId() { return GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID); }
1275 void SetNativeDisplayId(uint32 modelId) { SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, modelId); }
1276 void setTransForm(uint32 spellid) { m_transform = spellid;}
1277 uint32 getTransForm() const { return m_transform;}
1278 void AddDynObject(DynamicObject* dynObj);
1279 void RemoveDynObject(uint32 spellid);
1280 void RemoveDynObjectWithGUID(uint64 guid) { m_dynObjGUIDs.remove(guid); }
1281 void RemoveAllDynObjects();
1282 void AddGameObject(GameObject* gameObj);
1283 void RemoveGameObject(GameObject* gameObj, bool del);
1284 void RemoveGameObject(uint32 spellid, bool del);
1285 void RemoveAllGameObjects();
1286 DynamicObject *GetDynObject(uint32 spellId, uint32 effIndex);
1287 DynamicObject *GetDynObject(uint32 spellId);
1288 uint32 CalculateDamage(WeaponAttackType attType, bool normalized);
1289 float GetAPMultiplier(WeaponAttackType attType, bool normalized);
1290 void ModifyAuraState(AuraState flag, bool apply);
1291 bool HasAuraState(AuraState flag) const { return HasFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1)); }
1292 void UnsummonAllTotems();
1293 int32 SpellBaseDamageBonus(SpellSchoolMask schoolMask);
1294 int32 SpellBaseHealingBonus(SpellSchoolMask schoolMask);
1295 int32 SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit *pVictim);
1296 int32 SpellBaseHealingBonusForVictim(SpellSchoolMask schoolMask, Unit *pVictim);
1297 uint32 SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint32 damage, DamageEffectType damagetype);
1298 uint32 SpellHealingBonus(SpellEntry const *spellProto, uint32 healamount, DamageEffectType damagetype, Unit *pVictim);
1299 bool isSpellBlocked(Unit *pVictim, SpellEntry const *spellProto, WeaponAttackType attackType = BASE_ATTACK);
1300 bool isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolMask schoolMask, WeaponAttackType attackType = BASE_ATTACK);
1301 uint32 SpellCriticalBonus(SpellEntry const *spellProto, uint32 damage, Unit *pVictim);
1302
1303 void SetLastManaUse(uint32 spellCastTime) { m_lastManaUse = spellCastTime; }
1304 bool IsUnderLastManaUseEffect() const;
1305
1306 void SetContestedPvP(Player *attackedPlayer = NULL);
1307
1308 void MeleeDamageBonus(Unit *pVictim, uint32 *damage, WeaponAttackType attType, SpellEntry const *spellProto = NULL);
1309 uint32 GetCastingTimeForBonus( SpellEntry const *spellProto, DamageEffectType damagetype, uint32 CastingTime );
1310
1311 void ApplySpellImmune(uint32 spellId, uint32 op, uint32 type, bool apply);
1312 void ApplySpellDispelImmunity(const SpellEntry * spellProto, DispelType type, bool apply);
1313 virtual bool IsImmunedToSpell(SpellEntry const* spellInfo, bool useCharges = false);
1314 // redefined in Creature
1315 bool IsImmunedToDamage(SpellSchoolMask meleeSchoolMask, bool useCharges = false);
1316 virtual bool IsImmunedToSpellEffect(uint32 effect, uint32 mechanic) const;
1317 // redefined in Creature
1318
1319 uint32 CalcArmorReducedDamage(Unit* pVictim, const uint32 damage);
1320 void CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask, DamageEffectType damagetype, const uint32 damage, uint32 *absorb, uint32 *resist);
1321
1322 void UpdateSpeed(UnitMoveType mtype, bool forced);
1323 float GetSpeed( UnitMoveType mtype ) const;
1324 float GetSpeedRate( UnitMoveType mtype ) const { return m_speed_rate[mtype]; }
1325 void SetSpeed(UnitMoveType mtype, float rate, bool forced = false);
1326
1327 void SetHover(bool on);
1328 bool isHover() const { return HasAuraType(SPELL_AURA_HOVER); }
1329
1330 void _RemoveAllAuraMods();
1331 void _ApplyAllAuraMods();
1332
1333 int32 CalculateSpellDamage(SpellEntry const* spellProto, uint8 effect_index, int32 basePoints, Unit const* target);
1334 int32 CalculateSpellDuration(SpellEntry const* spellProto, uint8 effect_index, Unit const* target);
1335 float CalculateLevelPenalty(SpellEntry const* spellProto) const;
1336
1337 void addFollower(FollowerReference* pRef) { m_FollowingRefManager.insertFirst(pRef); }
1338 void removeFollower(FollowerReference* /*pRef*/ ) { /* nothing to do yet */ }
1339 static Unit* GetUnit(WorldObject& object, uint64 guid);
1340
1341 MotionMaster* GetMotionMaster() { return &i_motionMaster; }
1342
1343 bool IsStopped() const { return !(hasUnitState(UNIT_STAT_MOVING)); }
1344 void StopMoving();
1345
1346 void AddUnitMovementFlag(uint32 f) { m_unit_movement_flags |= f; }
1347 void RemoveUnitMovementFlag(uint32 f)
1348 {
1349 uint32 oldval = m_unit_movement_flags;
1350 m_unit_movement_flags = oldval & ~f;
1351 }
1352 uint32 HasUnitMovementFlag(uint32 f) const { return m_unit_movement_flags & f; }
1353 uint32 GetUnitMovementFlags() const { return m_unit_movement_flags; }
1354 void SetUnitMovementFlags(uint32 f) { m_unit_movement_flags = f; }
1355
1356 void SetFeared(bool apply, uint64 casterGUID = 0, uint32 spellID = 0);
1357 void SetConfused(bool apply, uint64 casterGUID = 0, uint32 spellID = 0);
1358
1359 void AddComboPointHolder(uint32 lowguid) { m_ComboPointHolders.insert(lowguid); }
1360 void RemoveComboPointHolder(uint32 lowguid) { m_ComboPointHolders.erase(lowguid); }
1361 void ClearComboPointHolders();
1362
1363 ///----------Pet responses methods-----------------
1364 void SendPetCastFail(uint32 spellid, uint8 msg);
1365 void SendPetActionFeedback (uint8 msg);
1366 void SendPetTalk (uint32 pettalk);
1367 void SendPetSpellCooldown (uint32 spellid, time_t cooltime);
1368 void SendPetClearCooldown (uint32 spellid);
1369 void SendPetAIReaction(uint64 guid);
1370 ///----------End of Pet responses methods----------
1371
1372 void propagateSpeedChange() { GetMotionMaster()->propagateSpeedChange(); }
1373
1374 // reactive attacks
1375 void ClearAllReactives();
1376 void StartReactiveTimer( ReactiveType reactive ) { m_reactiveTimer[reactive] = REACTIVE_TIMER_START;}
1377 void UpdateReactives(uint32 p_time);
1378
1379 // group updates
1380 void UpdateAuraForGroup(uint8 slot);
1381
1382 // pet auras
1383 typedef std::set<PetAura const*> PetAuraSet;
1384 PetAuraSet m_petAuras;
1385 void AddPetAura(PetAura const* petSpell);
1386 void RemovePetAura(PetAura const* petSpell);
1387
1388 protected:
1389 explicit Unit ();
1390
1391 void _UpdateSpells(uint32 time);
1392
1393 void _UpdateAutoRepeatSpell();
1394 bool m_AutoRepeatFirstCast;
1395
1396 uint32 m_attackTimer[MAX_ATTACK];
1397
1398 float m_createStats[MAX_STATS];
1399
1400 AttackerSet m_attackers;
1401 Unit* m_attacking;
1402
1403 DeathState m_deathState;
1404
1405 AuraMap m_Auras;
1406
1407 std::list<Aura *> m_scAuras; // casted singlecast auras
1408
1409 typedef std::list<uint64> DynObjectGUIDs;
1410 DynObjectGUIDs m_dynObjGUIDs;
1411
1412 std::list<GameObject*> m_gameObj;
1413 bool m_isSorted;
1414 uint32 m_transform;
1415 uint32 m_removedAuras;
1416
1417 AuraList m_modAuras[TOTAL_AURAS];
1418 float m_auraModifiersGroup[UNIT_MOD_END][MODIFIER_TYPE_END];
1419 float m_weaponDamage[MAX_ATTACK][2];
1420 bool m_canModifyStats;
1421 //std::list< spellEffectPair > AuraSpells[TOTAL_AURAS]; // TODO: use this if ok for mem
1422 VisibleAuraMap m_visibleAuras;
1423
1424 float m_speed_rate[MAX_MOVE_TYPE];
1425
1426 CharmInfo *m_charmInfo;
1427
1428 virtual SpellSchoolMask GetMeleeDamageSchoolMask() const;
1429
1430 MotionMaster i_motionMaster;
1431 uint32 m_unit_movement_flags;
1432
1433 uint32 m_reactiveTimer[MAX_REACTIVE];
1434 uint32 m_regenTimer;
1435
1436 private:
1437 void SendAttackStop(Unit* victim); // only from AttackStop(Unit*)
1438 void SendAttackStart(Unit* pVictim); // only from Unit::AttackStart(Unit*)
1439
1440 bool IsTriggeredAtSpellProcEvent(Unit *pVictim, Aura* aura, SpellEntry const* procSpell, uint32 procFlag, uint32 procExtra, WeaponAttackType attType, bool isVictim, bool active, SpellProcEventEntry const*& spellProcEvent );
1441 bool HandleDummyAuraProc( Unit *pVictim, uint32 damage, Aura* triggredByAura, SpellEntry const *procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown);
1442 bool HandleHasteAuraProc( Unit *pVictim, uint32 damage, Aura* triggredByAura, SpellEntry const *procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown);
1443 bool HandleProcTriggerSpell(Unit *pVictim, uint32 damage, Aura* triggredByAura, SpellEntry const *procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown);
1444 bool HandleOverrideClassScriptAuraProc(Unit *pVictim, Aura* triggredByAura, SpellEntry const *procSpell, uint32 cooldown);
1445 bool HandleMeandingAuraProc(Aura* triggeredByAura);
1446
1447 uint32 m_state; // Even derived shouldn't modify
1448 uint32 m_CombatTimer;
1449 uint32 m_lastManaUse; // msecs
1450
1451 UnitVisibility m_Visibility;
1452
1453 Diminishing m_Diminishing;
1454 // Manage all Units threatening us
1455 ThreatManager m_ThreatManager;
1456 // Manage all Units that are threatened by us
1457 HostilRefManager m_HostilRefManager;
1458
1459 FollowerRefManager m_FollowingRefManager;
1460
1461 ComboPointHolderSet m_ComboPointHolders;
1462 };
1463 #endif
MaNGOS is a free, Open Source implementation of a game server compatible with the original World of Warcraft client.