src/game/Unit.h

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