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