src/game/Unit.cpp

   1 /*
   2  * Copyright (C) 2005-2008 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Log.h"
  21 #include "Opcodes.h"
  22 #include "WorldPacket.h"
  23 #include "WorldSession.h"
  24 #include "World.h"
  25 #include "ObjectMgr.h"
  26 #include "SpellMgr.h"
  27 #include "Unit.h"
  28 #include "QuestDef.h"
  29 #include "Player.h"
  30 #include "Creature.h"
  31 #include "Spell.h"
  32 #include "Group.h"
  33 #include "SpellAuras.h"
  34 #include "MapManager.h"
  35 #include "ObjectAccessor.h"
  36 #include "CreatureAI.h"
  37 #include "Formulas.h"
  38 #include "Pet.h"
  39 #include "Util.h"
  40 #include "Totem.h"
  41 #include "BattleGround.h"
  42 #include "InstanceSaveMgr.h"
  43 #include "GridNotifiersImpl.h"
  44 #include "CellImpl.h"
  45 #include "Path.h"
  46
  47 #include <math.h>
  48
  49 float baseMoveSpeed[MAX_MOVE_TYPE] =
  50 {
  51     2.5f,                                                   // MOVE_WALK
  52     7.0f,                                                   // MOVE_RUN
  53     1.25f,                                                  // MOVE_WALKBACK
  54     4.722222f,                                              // MOVE_SWIM
  55     4.5f,                                                   // MOVE_SWIMBACK
  56     3.141594f,                                              // MOVE_TURN
  57     7.0f,                                                   // MOVE_FLY
  58     4.5f,                                                   // MOVE_FLYBACK
  59     3.14f                                                   // MOVE_PITCH
  60 };
  61
  62 // auraTypes contains attacker auras capable of proc'ing cast auras
  63 static Unit::AuraTypeSet GenerateAttakerProcCastAuraTypes()
  64 {
  65     static Unit::AuraTypeSet auraTypes;
  66     auraTypes.insert(SPELL_AURA_DUMMY);
  67     auraTypes.insert(SPELL_AURA_PROC_TRIGGER_SPELL);
  68     auraTypes.insert(SPELL_AURA_MOD_HASTE);
  69     auraTypes.insert(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
  70     return auraTypes;
  71 }
  72
  73 // auraTypes contains victim auras capable of proc'ing cast auras
  74 static Unit::AuraTypeSet GenerateVictimProcCastAuraTypes()
  75 {
  76     static Unit::AuraTypeSet auraTypes;
  77     auraTypes.insert(SPELL_AURA_DUMMY);
  78     auraTypes.insert(SPELL_AURA_PRAYER_OF_MENDING);
  79     auraTypes.insert(SPELL_AURA_PROC_TRIGGER_SPELL);
  80     return auraTypes;
  81 }
  82
  83 // auraTypes contains auras capable of proc effect/damage (but not cast) for attacker
  84 static Unit::AuraTypeSet GenerateAttakerProcEffectAuraTypes()
  85 {
  86     static Unit::AuraTypeSet auraTypes;
  87     auraTypes.insert(SPELL_AURA_MOD_DAMAGE_DONE);
  88     auraTypes.insert(SPELL_AURA_PROC_TRIGGER_DAMAGE);
  89     auraTypes.insert(SPELL_AURA_MOD_CASTING_SPEED);
  90     auraTypes.insert(SPELL_AURA_MOD_RATING);
  91     return auraTypes;
  92 }
  93
  94 // auraTypes contains auras capable of proc effect/damage (but not cast) for victim
  95 static Unit::AuraTypeSet GenerateVictimProcEffectAuraTypes()
  96 {
  97     static Unit::AuraTypeSet auraTypes;
  98     auraTypes.insert(SPELL_AURA_MOD_RESISTANCE);
  99     auraTypes.insert(SPELL_AURA_PROC_TRIGGER_DAMAGE);
 100     auraTypes.insert(SPELL_AURA_MOD_PARRY_PERCENT);
 101     auraTypes.insert(SPELL_AURA_MOD_BLOCK_PERCENT);
 102     auraTypes.insert(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
 103     return auraTypes;
 104 }
 105
 106 static Unit::AuraTypeSet attackerProcCastAuraTypes = GenerateAttakerProcCastAuraTypes();
 107 static Unit::AuraTypeSet attackerProcEffectAuraTypes = GenerateAttakerProcEffectAuraTypes();
 108
 109 static Unit::AuraTypeSet victimProcCastAuraTypes = GenerateVictimProcCastAuraTypes();
 110 static Unit::AuraTypeSet victimProcEffectAuraTypes   = GenerateVictimProcEffectAuraTypes();
 111
 112 // auraTypes contains auras capable of proc'ing for attacker and victim
 113 static Unit::AuraTypeSet GenerateProcAuraTypes()
 114 {
 115     Unit::AuraTypeSet auraTypes;
 116     auraTypes.insert(attackerProcCastAuraTypes.begin(),attackerProcCastAuraTypes.end());
 117     auraTypes.insert(attackerProcEffectAuraTypes.begin(),attackerProcEffectAuraTypes.end());
 118     auraTypes.insert(victimProcCastAuraTypes.begin(),victimProcCastAuraTypes.end());
 119     auraTypes.insert(victimProcEffectAuraTypes.begin(),victimProcEffectAuraTypes.end());
 120     return auraTypes;
 121 }
 122
 123 static Unit::AuraTypeSet procAuraTypes = GenerateProcAuraTypes();
 124
 125 bool IsPassiveStackableSpell( uint32 spellId )
 126 {
 127     if(!IsPassiveSpell(spellId))
 128         return false;
 129
 130     SpellEntry const* spellProto = sSpellStore.LookupEntry(spellId);
 131     if(!spellProto)
 132         return false;
 133
 134     for(int j = 0; j < 3; ++j)
 135     {
 136         if(std::find(procAuraTypes.begin(),procAuraTypes.end(),spellProto->EffectApplyAuraName[j])!=procAuraTypes.end())
 137             return false;
 138     }
 139
 140     return true;
 141 }
 142
 143 Unit::Unit()
 144 : WorldObject(), i_motionMaster(this), m_ThreatManager(this), m_HostilRefManager(this)
 145 {
 146     m_objectType |= TYPEMASK_UNIT;
 147     m_objectTypeId = TYPEID_UNIT;
 148                                                             // 2.3.2 - 0x70
 149     m_updateFlag = (UPDATEFLAG_LOWGUID | UPDATEFLAG_HIGHGUID | UPDATEFLAG_LIVING | UPDATEFLAG_HAS_POSITION);
 150
 151     m_attackTimer[BASE_ATTACK]   = 0;
 152     m_attackTimer[OFF_ATTACK]    = 0;
 153     m_attackTimer[RANGED_ATTACK] = 0;
 154     m_modAttackSpeedPct[BASE_ATTACK] = 1.0f;
 155     m_modAttackSpeedPct[OFF_ATTACK] = 1.0f;
 156     m_modAttackSpeedPct[RANGED_ATTACK] = 1.0f;
 157
 158     m_extraAttacks = 0;
 159
 160     m_state = 0;
 161     m_form = FORM_NONE;
 162     m_deathState = ALIVE;
 163
 164     for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
 165         m_currentSpells[i] = NULL;
 166
 167     m_addDmgOnce = 0;
 168
 169     for(int i = 0; i < MAX_TOTEM; ++i)
 170         m_TotemSlot[i]  = 0;
 171
 172     m_ObjectSlot[0] = m_ObjectSlot[1] = m_ObjectSlot[2] = m_ObjectSlot[3] = 0;
 173     //m_Aura = NULL;
 174     //m_AurasCheck = 2000;
 175     //m_removeAuraTimer = 4;
 176     //tmpAura = NULL;
 177     waterbreath = false;
 178
 179     m_Visibility = VISIBILITY_ON;
 180
 181     m_detectInvisibilityMask = 0;
 182     m_invisibilityMask = 0;
 183     m_transform = 0;
 184     m_ShapeShiftFormSpellId = 0;
 185     m_canModifyStats = false;
 186
 187     for (int i = 0; i < MAX_SPELL_IMMUNITY; i++)
 188         m_spellImmune[i].clear();
 189     for (int i = 0; i < UNIT_MOD_END; i++)
 190     {
 191         m_auraModifiersGroup[i][BASE_VALUE] = 0.0f;
 192         m_auraModifiersGroup[i][BASE_PCT] = 1.0f;
 193         m_auraModifiersGroup[i][TOTAL_VALUE] = 0.0f;
 194         m_auraModifiersGroup[i][TOTAL_PCT] = 1.0f;
 195     }
 196                                                             // implement 50% base damage from offhand
 197     m_auraModifiersGroup[UNIT_MOD_DAMAGE_OFFHAND][TOTAL_PCT] = 0.5f;
 198
 199     for (int i = 0; i < 3; i++)
 200     {
 201         m_weaponDamage[i][MINDAMAGE] = BASE_MINDAMAGE;
 202         m_weaponDamage[i][MAXDAMAGE] = BASE_MAXDAMAGE;
 203     }
 204     for (int i = 0; i < MAX_STATS; i++)
 205         m_createStats[i] = 0.0f;
 206
 207     m_attacking = NULL;
 208     m_modMeleeHitChance = 0.0f;
 209     m_modRangedHitChance = 0.0f;
 210     m_modSpellHitChance = 0.0f;
 211     m_baseSpellCritChance = 5;
 212
 213     m_CombatTimer = 0;
 214     m_lastManaUse = 0;
 215
 216     //m_victimThreat = 0.0f;
 217     for (int i = 0; i < MAX_SPELL_SCHOOL; ++i)
 218         m_threatModifier[i] = 1.0f;
 219     m_isSorted = true;
 220     for (int i = 0; i < MAX_MOVE_TYPE; ++i)
 221         m_speed_rate[i] = 1.0f;
 222
 223     m_removedAuras = 0;
 224     m_charmInfo = NULL;
 225     m_unit_movement_flags = 0;
 226
 227     // remove aurastates allowing special moves
 228     for(int i=0; i < MAX_REACTIVE; ++i)
 229         m_reactiveTimer[i] = 0;
 230 }
 231
 232 Unit::~Unit()
 233 {
 234     // set current spells as deletable
 235     for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
 236     {
 237         if (m_currentSpells[i])
 238         {
 239             m_currentSpells[i]->SetReferencedFromCurrent(false);
 240             m_currentSpells[i] = NULL;
 241         }
 242     }
 243
 244     RemoveAllGameObjects();
 245     RemoveAllDynObjects();
 246
 247     if(m_charmInfo) delete m_charmInfo;
 248 }
 249
 250 void Unit::Update( uint32 p_time )
 251 {
 252     /*if(p_time > m_AurasCheck)
 253     {
 254     m_AurasCheck = 2000;
 255     _UpdateAura();
 256     }else
 257     m_AurasCheck -= p_time;*/
 258
 259     // WARNING! Order of execution here is important, do not change.
 260     // Spells must be processed with event system BEFORE they go to _UpdateSpells.
 261     // Or else we may have some SPELL_STATE_FINISHED spells stalled in pointers, that is bad.
 262     m_Events.Update( p_time );
 263     _UpdateSpells( p_time );
 264
 265     // update combat timer only for players and pets
 266     if (isInCombat() && (GetTypeId() == TYPEID_PLAYER || ((Creature*)this)->isPet() || ((Creature*)this)->isCharmed()))
 267     {
 268         // Check UNIT_STAT_MELEE_ATTACKING or UNIT_STAT_CHASE (without UNIT_STAT_FOLLOW in this case) so pets can reach far away
 269         // targets without stopping half way there and running off.
 270         // These flags are reset after target dies or another command is given.
 271         if( m_HostilRefManager.isEmpty() )
 272         {
 273             // m_CombatTimer set at aura start and it will be freeze until aura removing
 274             if ( m_CombatTimer <= p_time )
 275                 ClearInCombat();
 276             else
 277                 m_CombatTimer -= p_time;
 278         }
 279     }
 280
 281     if(uint32 base_att = getAttackTimer(BASE_ATTACK))
 282     {
 283         setAttackTimer(BASE_ATTACK, (p_time >= base_att ? 0 : base_att - p_time) );
 284     }
 285
 286     // update abilities available only for fraction of time
 287     UpdateReactives( p_time );
 288
 289     ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, GetHealth() < GetMaxHealth()*0.20f);
 290     ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, GetHealth() < GetMaxHealth()*0.35f);
 291
 292     i_motionMaster.UpdateMotion(p_time);
 293 }
 294
 295 bool Unit::haveOffhandWeapon() const
 296 {
 297     if(GetTypeId() == TYPEID_PLAYER)
 298         return ((Player*)this)->GetWeaponForAttack(OFF_ATTACK,true);
 299     else
 300         return false;
 301 }
 302
 303 void Unit::SendMonsterMoveWithSpeedToCurrentDestination(Player* player)
 304 {
 305     float x, y, z;
 306     if(GetMotionMaster()->GetDestination(x, y, z))
 307         SendMonsterMoveWithSpeed(x, y, z, GetUnitMovementFlags(), 0, player);
 308 }
 309
 310 void Unit::SendMonsterMoveWithSpeed(float x, float y, float z, uint32 MovementFlags, uint32 transitTime, Player* player)
 311 {
 312     if (!transitTime)
 313     {
 314         float dx = x - GetPositionX();
 315         float dy = y - GetPositionY();
 316         float dz = z - GetPositionZ();
 317
 318         float dist = ((dx*dx) + (dy*dy) + (dz*dz));
 319         if(dist<0)
 320             dist = 0;
 321         else
 322             dist = sqrt(dist);
 323
 324         double speed = GetSpeed((MovementFlags & MOVEMENTFLAG_WALK_MODE) ? MOVE_WALK : MOVE_RUN);
 325         if(speed<=0)
 326             speed = 2.5f;
 327         speed *= 0.001f;
 328         transitTime = static_cast<uint32>(dist / speed + 0.5);
 329     }
 330     //float orientation = (float)atan2((double)dy, (double)dx);
 331     SendMonsterMove(x, y, z, 0, MovementFlags, transitTime, player);
 332 }
 333
 334 void Unit::SendMonsterMove(float NewPosX, float NewPosY, float NewPosZ, uint8 type, uint32 MovementFlags, uint32 Time, Player* player)
 335 {
 336     WorldPacket data( SMSG_MONSTER_MOVE, (41 + GetPackGUID().size()) );
 337     data.append(GetPackGUID());
 338
 339     // Point A, starting location
 340     data << GetPositionX() << GetPositionY() << GetPositionZ();
 341     // unknown field - unrelated to orientation
 342     // seems to increment about 1000 for every 1.7 seconds
 343     // for now, we'll just use mstime
 344     data << getMSTime();
 345
 346     data << uint8(type);                                    // unknown
 347     switch(type)
 348     {
 349         case 0:                                             // normal packet
 350             break;
 351         case 1:                                             // stop packet
 352             SendMessageToSet( &data, true );
 353             return;
 354         case 2:                                             // not used currently
 355             data << float(0);
 356             data << float(0);
 357             data << float(0);
 358             break;
 359         case 3:                                             // not used currently
 360             data << uint64(0);                              // probably target guid
 361             break;
 362         case 4:                                             // not used currently
 363             data << float(0);                               // probably orientation
 364             break;
 365     }
 366
 367     //Movement Flags (0x0 = walk, 0x100 = run, 0x200 = fly/swim)
 368     data << uint32(MovementFlags);
 369
 370     data << Time;                                           // Time in between points
 371     data << uint32(1);                                      // 1 single waypoint
 372     data << NewPosX << NewPosY << NewPosZ;                  // the single waypoint Point B
 373
 374     if(player)
 375         player->GetSession()->SendPacket(&data);
 376     else
 377         SendMessageToSet( &data, true );
 378 }
 379
 380 void Unit::SendMonsterMoveByPath(Path const& path, uint32 start, uint32 end, uint32 MovementFlags)
 381 {
 382     uint32 traveltime = uint32(path.GetTotalLength(start, end) * 32);
 383
 384     uint32 pathSize = end-start;
 385
 386     WorldPacket data( SMSG_MONSTER_MOVE, (GetPackGUID().size()+4+4+4+4+1+4+4+4+pathSize*4*3) );
 387     data.append(GetPackGUID());
 388     data << GetPositionX();
 389     data << GetPositionY();
 390     data << GetPositionZ();
 391
 392     // unknown field - unrelated to orientation
 393     // seems to increment about 1000 for every 1.7 seconds
 394     // for now, we'll just use mstime
 395     data << getMSTime();
 396
 397     data << uint8( 0 );
 398     data << uint32( MovementFlags );
 399     data << uint32( traveltime );
 400     data << uint32( pathSize );
 401     data.append( (char*)path.GetNodes(start), pathSize * 4 * 3 );
 402
 403     //WPAssert( data.size() == 37 + pathnodes.Size( ) * 4 * 3 );
 404     SendMessageToSet(&data, true);
 405 }
 406
 407 void Unit::resetAttackTimer(WeaponAttackType type)
 408 {
 409     m_attackTimer[type] = uint32(GetAttackTime(type) * m_modAttackSpeedPct[type]);
 410 }
 411
 412 bool Unit::canReachWithAttack(Unit *pVictim) const
 413 {
 414     assert(pVictim);
 415     float reach = GetFloatValue(UNIT_FIELD_COMBATREACH);
 416     if( reach <= 0.0f )
 417         reach = 1.0f;
 418     return IsWithinDistInMap(pVictim, reach);
 419 }
 420
 421 void Unit::RemoveSpellsCausingAura(AuraType auraType)
 422 {
 423     if (auraType >= TOTAL_AURAS) return;
 424     AuraList::iterator iter, next;
 425     for (iter = m_modAuras[auraType].begin(); iter != m_modAuras[auraType].end(); iter = next)
 426     {
 427         next = iter;
 428         ++next;
 429
 430         if (*iter)
 431         {
 432             RemoveAurasDueToSpell((*iter)->GetId());
 433             if (!m_modAuras[auraType].empty())
 434                 next = m_modAuras[auraType].begin();
 435             else
 436                 return;
 437         }
 438     }
 439 }
 440
 441 bool Unit::HasAuraType(AuraType auraType) const
 442 {
 443     return (!m_modAuras[auraType].empty());
 444 }
 445
 446 /* Called by DealDamage for auras that have a chance to be dispelled on damage taken. */
 447 void Unit::RemoveSpellbyDamageTaken(AuraType auraType, uint32 damage)
 448 {
 449     if(!HasAuraType(auraType))
 450         return;
 451
 452     // The chance to dispel an aura depends on the damage taken with respect to the casters level.
 453     uint32 max_dmg = getLevel() > 8 ? 25 * getLevel() - 150 : 50;
 454     float chance = float(damage) / max_dmg * 100.0f;
 455     if (roll_chance_f(chance))
 456         RemoveSpellsCausingAura(auraType);
 457 }
 458
 459 uint32 Unit::DealDamage(Unit *pVictim, uint32 damage, CleanDamage const* cleanDamage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask, SpellEntry const *spellProto, bool durabilityLoss)
 460 {
 461     if (!pVictim->isAlive() || pVictim->isInFlight() || pVictim->GetTypeId() == TYPEID_UNIT && ((Creature*)pVictim)->IsInEvadeMode())
 462         return 0;
 463
 464     //You don't lose health from damage taken from another player while in a sanctuary
 465     //You still see it in the combat log though
 466     if(pVictim != this && GetTypeId() == TYPEID_PLAYER && pVictim->GetTypeId() == TYPEID_PLAYER)
 467     {
 468         const AreaTableEntry *area = GetAreaEntryByAreaID(pVictim->GetAreaId());
 469         if(area && area->flags & AREA_FLAG_SANCTUARY)       //sanctuary
 470             return 0;
 471     }
 472
 473     // remove affects from victim (including from 0 damage and DoTs)
 474     if(pVictim != this)
 475         pVictim->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
 476
 477     // remove affects from attacker at any non-DoT damage (including 0 damage)
 478     if( damagetype != DOT)
 479     {
 480         RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
 481         RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
 482
 483         if(pVictim != this)
 484             RemoveSpellsCausingAura(SPELL_AURA_MOD_INVISIBILITY);
 485
 486         if(pVictim->GetTypeId() == TYPEID_PLAYER && !pVictim->IsStandState() && !pVictim->hasUnitState(UNIT_STAT_STUNNED))
 487             pVictim->SetStandState(PLAYER_STATE_NONE);
 488     }
 489
 490     //Script Event damage Deal
 491     if( GetTypeId()== TYPEID_UNIT && ((Creature *)this)->AI())
 492         ((Creature *)this)->AI()->DamageDeal(pVictim, damage);
 493     //Script Event damage taken
 494     if( pVictim->GetTypeId()== TYPEID_UNIT && ((Creature *)pVictim)->AI() )
 495         ((Creature *)pVictim)->AI()->DamageTaken(this, damage);
 496
 497     if(!damage)
 498     {
 499         // Rage from physical damage received .
 500         if(cleanDamage && cleanDamage->damage && (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL) && pVictim->GetTypeId() == TYPEID_PLAYER && (pVictim->getPowerType() == POWER_RAGE))
 501             ((Player*)pVictim)->RewardRage(cleanDamage->damage, 0, false);
 502
 503         return 0;
 504     }
 505
 506     pVictim->RemoveSpellbyDamageTaken(SPELL_AURA_MOD_FEAR, damage);
 507     // root type spells do not dispel the root effect
 508     if(!spellProto || spellProto->Mechanic != MECHANIC_ROOT)
 509         pVictim->RemoveSpellbyDamageTaken(SPELL_AURA_MOD_ROOT, damage);
 510
 511     if(pVictim->GetTypeId() != TYPEID_PLAYER)
 512     {
 513         // no xp,health if type 8 /critters/
 514         if ( pVictim->GetCreatureType() == CREATURE_TYPE_CRITTER)
 515         {
 516             pVictim->setDeathState(JUST_DIED);
 517             pVictim->SetHealth(0);
 518
 519             // allow loot only if has loot_id in creature_template
 520             CreatureInfo const* cInfo = ((Creature*)pVictim)->GetCreatureInfo();
 521             if(cInfo && cInfo->lootid)
 522                 pVictim->SetUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
 523
 524             // some critters required for quests
 525             if(GetTypeId() == TYPEID_PLAYER)
 526                 ((Player*)this)->KilledMonster(pVictim->GetEntry(),pVictim->GetGUID());
 527
 528             return damage;
 529         }
 530
 531         if(!pVictim->isInCombat() && ((Creature*)pVictim)->AI())
 532             ((Creature*)pVictim)->AI()->AttackStart(this);
 533     }
 534
 535     DEBUG_LOG("DealDamageStart");
 536
 537     uint32 health = pVictim->GetHealth();
 538     sLog.outDetail("deal dmg:%d to health:%d ",damage,health);
 539
 540     // duel ends when player has 1 or less hp
 541     bool duel_hasEnded = false;
 542     if(pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->duel && damage >= (health-1))
 543     {
 544         // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
 545         if(((Player*)pVictim)->duel->opponent==this || ((Player*)pVictim)->duel->opponent->GetGUID() == GetOwnerGUID())
 546             damage = health-1;
 547
 548         duel_hasEnded = true;
 549     }
 550     //Get in CombatState
 551     if(pVictim != this && damagetype != DOT)
 552     {
 553         SetInCombatWith(pVictim);
 554         pVictim->SetInCombatWith(this);
 555
 556         if(Player* attackedPlayer = pVictim->GetCharmerOrOwnerPlayerOrPlayerItself())
 557             SetContestedPvP(attackedPlayer);
 558     }
 559
 560     // Rage from Damage made (only from direct weapon damage)
 561     if( cleanDamage && damagetype==DIRECT_DAMAGE && this != pVictim && GetTypeId() == TYPEID_PLAYER && (getPowerType() == POWER_RAGE))
 562     {
 563         uint32 weaponSpeedHitFactor;
 564
 565         switch(cleanDamage->attackType)
 566         {
 567             case BASE_ATTACK:
 568             {
 569                 if(cleanDamage->hitOutCome == MELEE_HIT_CRIT)
 570                     weaponSpeedHitFactor = uint32(GetAttackTime(cleanDamage->attackType)/1000.0f * 7);
 571                 else
 572                     weaponSpeedHitFactor = uint32(GetAttackTime(cleanDamage->attackType)/1000.0f * 3.5f);
 573
 574                 ((Player*)this)->RewardRage(damage, weaponSpeedHitFactor, true);
 575
 576                 break;
 577             }
 578             case OFF_ATTACK:
 579             {
 580                 if(cleanDamage->hitOutCome == MELEE_HIT_CRIT)
 581                     weaponSpeedHitFactor = uint32(GetAttackTime(cleanDamage->attackType)/1000.0f * 3.5f);
 582                 else
 583                     weaponSpeedHitFactor = uint32(GetAttackTime(cleanDamage->attackType)/1000.0f * 1.75f);
 584
 585                 ((Player*)this)->RewardRage(damage, weaponSpeedHitFactor, true);
 586
 587                 break;
 588             }
 589             case RANGED_ATTACK:
 590                 break;
 591         }
 592     }
 593
 594     if(pVictim->GetTypeId() == TYPEID_PLAYER && GetTypeId() == TYPEID_PLAYER)
 595     {
 596         if(((Player*)pVictim)->InBattleGround())
 597         {
 598             Player *killer = ((Player*)this);
 599             if(killer != ((Player*)pVictim))
 600                 if(BattleGround *bg = killer->GetBattleGround())
 601                     bg->UpdatePlayerScore(killer, SCORE_DAMAGE_DONE, damage);
 602         }
 603     }
 604
 605     if (pVictim->GetTypeId() == TYPEID_UNIT && !((Creature*)pVictim)->isPet() && !((Creature*)pVictim)->hasLootRecipient())
 606         ((Creature*)pVictim)->SetLootRecipient(this);
 607     if (health <= damage)
 608     {
 609         // battleground things
 610         if(pVictim->GetTypeId() == TYPEID_PLAYER && (((Player*)pVictim)->InBattleGround()))
 611         {
 612             Player *killed = ((Player*)pVictim);
 613             Player *killer = NULL;
 614             if(GetTypeId() == TYPEID_PLAYER)
 615                 killer = ((Player*)this);
 616             else if(GetTypeId() == TYPEID_UNIT && ((Creature*)this)->isPet())
 617             {
 618                 Unit *owner = GetOwner();
 619                 if(owner && owner->GetTypeId() == TYPEID_PLAYER)
 620                     killer = ((Player*)owner);
 621             }
 622
 623             if(killer)
 624                 if(BattleGround *bg = killed->GetBattleGround())
 625                     bg->HandleKillPlayer(killed, killer);   // drop flags and etc
 626         }
 627
 628         DEBUG_LOG("DealDamage: victim just died");
 629
 630         // find player: owner of controlled `this` or `this` itself maybe
 631         Player *player = GetCharmerOrOwnerPlayerOrPlayerItself();
 632
 633         if(pVictim->GetTypeId() == TYPEID_UNIT && ((Creature*)pVictim)->GetLootRecipient())
 634             player = ((Creature*)pVictim)->GetLootRecipient();
 635         // Reward player, his pets, and group/raid members
 636         // call kill spell proc event (before real die and combat stop to triggering auras removed at death/combat stop)
 637         if(player && player!=pVictim)
 638             if(player->RewardPlayerAndGroupAtKill(pVictim))
 639                 player->ProcDamageAndSpell(pVictim,PROC_FLAG_KILL_XP_GIVER,PROC_FLAG_NONE);
 640
 641         DEBUG_LOG("DealDamageAttackStop");
 642
 643         // stop combat
 644         pVictim->CombatStop();
 645         pVictim->getHostilRefManager().deleteReferences();
 646
 647         bool damageFromSpiritOfRedemtionTalent = spellProto && spellProto->Id == 27795;
 648
 649         // if talent known but not triggered (check priest class for speedup check)
 650         Aura* spiritOfRedemtionTalentReady = NULL;
 651         if( !damageFromSpiritOfRedemtionTalent &&           // not called from SPELL_AURA_SPIRIT_OF_REDEMPTION
 652             pVictim->GetTypeId()==TYPEID_PLAYER && pVictim->getClass()==CLASS_PRIEST )
 653         {
 654             AuraList const& vDummyAuras = pVictim->GetAurasByType(SPELL_AURA_DUMMY);
 655             for(AuraList::const_iterator itr = vDummyAuras.begin(); itr != vDummyAuras.end(); ++itr)
 656             {
 657                 if((*itr)->GetSpellProto()->SpellIconID==1654)
 658                 {
 659                     spiritOfRedemtionTalentReady = *itr;
 660                     break;
 661                 }
 662             }
 663         }
 664
 665         DEBUG_LOG("SET JUST_DIED");
 666         if(!spiritOfRedemtionTalentReady)
 667             pVictim->setDeathState(JUST_DIED);
 668
 669         DEBUG_LOG("DealDamageHealth1");
 670
 671         if(spiritOfRedemtionTalentReady)
 672         {
 673             // save value before aura remove
 674             uint32 ressSpellId = pVictim->GetUInt32Value(PLAYER_SELF_RES_SPELL);
 675             if(!ressSpellId)
 676                 ressSpellId = ((Player*)pVictim)->GetResurrectionSpellId();
 677
 678             //Remove all expected to remove at death auras (most important negative case like DoT or periodic triggers)
 679             pVictim->RemoveAllAurasOnDeath();
 680
 681             // restore for use at real death
 682             pVictim->SetUInt32Value(PLAYER_SELF_RES_SPELL,ressSpellId);
 683
 684             // FORM_SPIRITOFREDEMPTION and related auras
 685             pVictim->CastSpell(pVictim,27827,true,NULL,spiritOfRedemtionTalentReady);
 686         }
 687         else
 688             pVictim->SetHealth(0);
 689
 690         // remember victim PvP death for corpse type and corpse reclaim delay
 691         // at original death (not at SpiritOfRedemtionTalent timeout)
 692         if( pVictim->GetTypeId()==TYPEID_PLAYER && !damageFromSpiritOfRedemtionTalent )
 693             ((Player*)pVictim)->SetPvPDeath(player!=NULL);
 694
 695         // Call KilledUnit for creatures
 696         if (GetTypeId() == TYPEID_UNIT && ((Creature*)this)->AI())
 697             ((Creature*)this)->AI()->KilledUnit(pVictim);
 698
 699         // achievement stuff
 700         if ( pVictim->GetTypeId() == TYPEID_PLAYER)
 701         {
 702             if(GetTypeId() == TYPEID_UNIT)
 703                 ((Player*)pVictim)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE, GetEntry());
 704             else if(GetTypeId() == TYPEID_PLAYER)
 705                 ((Player*)pVictim)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER, 1);
 706         }
 707
 708         // 10% durability loss on death
 709         // clean InHateListOf
 710         if (pVictim->GetTypeId() == TYPEID_PLAYER)
 711         {
 712             // only if not player and not controlled by player pet. And not at BG
 713             if (durabilityLoss && !player && !((Player*)pVictim)->InBattleGround())
 714             {
 715                 DEBUG_LOG("We are dead, loosing 10 percents durability");
 716                 ((Player*)pVictim)->DurabilityLossAll(0.10f,false);
 717                 // durability lost message
 718                 WorldPacket data(SMSG_DURABILITY_DAMAGE_DEATH, 0);
 719                 ((Player*)pVictim)->GetSession()->SendPacket(&data);
 720             }
 721         }
 722         else                                                // creature died
 723         {
 724             DEBUG_LOG("DealDamageNotPlayer");
 725             Creature *cVictim = (Creature*)pVictim;
 726
 727             if(!cVictim->isPet())
 728             {
 729                 cVictim->DeleteThreatList();
 730                 cVictim->SetUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
 731             }
 732             // Call creature just died function
 733             if (cVictim->AI())
 734                 cVictim->AI()->JustDied(this);
 735
 736             // Dungeon specific stuff, only applies to players killing creatures
 737             if(cVictim->GetInstanceId())
 738             {
 739                 Map *m = cVictim->GetMap();
 740                 Player *creditedPlayer = GetCharmerOrOwnerPlayerOrPlayerItself();
 741                 // TODO: do instance binding anyway if the charmer/owner is offline
 742
 743                 if(m->IsDungeon() && creditedPlayer)
 744                 {
 745                     if(m->IsRaid() || m->IsHeroic())
 746                     {
 747                         if(cVictim->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_INSTANCE_BIND)
 748                             ((InstanceMap *)m)->PermBindAllPlayers(creditedPlayer);
 749                     }
 750                     else
 751                     {
 752                         // the reset time is set but not added to the scheduler
 753                         // until the players leave the instance
 754                         time_t resettime = cVictim->GetRespawnTimeEx() + 2 * HOUR;
 755                         if(InstanceSave *save = sInstanceSaveManager.GetInstanceSave(cVictim->GetInstanceId()))
 756                             if(save->GetResetTime() < resettime) save->SetResetTime(resettime);
 757                     }
 758                 }
 759             }
 760         }
 761
 762         // last damage from non duel opponent or opponent controlled creature
 763         if(duel_hasEnded)
 764         {
 765             assert(pVictim->GetTypeId()==TYPEID_PLAYER);
 766             Player *he = (Player*)pVictim;
 767
 768             assert(he->duel);
 769
 770             he->duel->opponent->CombatStopWithPets(true);
 771             he->CombatStopWithPets(true);
 772
 773             he->DuelComplete(DUEL_INTERUPTED);
 774         }
 775     }
 776     else                                                    // if (health <= damage)
 777     {
 778         DEBUG_LOG("DealDamageAlive");
 779
 780         pVictim->ModifyHealth(- (int32)damage);
 781
 782         // Check if health is below 20% (apply damage before to prevent case when after ProcDamageAndSpell health < damage
 783         if(pVictim->GetHealth()*5 < pVictim->GetMaxHealth())
 784         {
 785             uint32 procVictim = PROC_FLAG_NONE;
 786
 787             // if just dropped below 20% (for CheatDeath)
 788             if((pVictim->GetHealth()+damage)*5 > pVictim->GetMaxHealth())
 789                 procVictim = PROC_FLAG_LOW_HEALTH;
 790
 791             ProcDamageAndSpell(pVictim,PROC_FLAG_TARGET_LOW_HEALTH,procVictim);
 792         }
 793
 794         if(damagetype != DOT)
 795         {
 796             if(getVictim())
 797             {
 798                 // if have target and damage pVictim just call AI reaction
 799                 if(pVictim != getVictim() && pVictim->GetTypeId()==TYPEID_UNIT && ((Creature*)pVictim)->AI())
 800                     ((Creature*)pVictim)->AI()->AttackedBy(this);
 801             }
 802             else
 803             {
 804                 // if not have main target then attack state with target (including AI call)
 805                 //start melee attacks only after melee hit
 806                 Attack(pVictim,(damagetype == DIRECT_DAMAGE));
 807             }
 808         }
 809
 810         // polymorphed and other negative transformed cases
 811         if(pVictim->getTransForm() && pVictim->hasUnitState(UNIT_STAT_CONFUSED))
 812             pVictim->RemoveAurasDueToSpell(pVictim->getTransForm());
 813
 814         if(damagetype == DIRECT_DAMAGE|| damagetype == SPELL_DIRECT_DAMAGE)
 815             pVictim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_DIRECT_DAMAGE);
 816
 817         if (pVictim->GetTypeId() != TYPEID_PLAYER)
 818         {
 819             if(spellProto && IsDamageToThreatSpell(spellProto))
 820                 pVictim->AddThreat(this, damage*2, damageSchoolMask, spellProto);
 821             else
 822                 pVictim->AddThreat(this, damage, damageSchoolMask, spellProto);
 823         }
 824         else                                                // victim is a player
 825         {
 826             // Rage from damage received
 827             if(this != pVictim && pVictim->getPowerType() == POWER_RAGE)
 828             {
 829                 uint32 rage_damage = damage + (cleanDamage ? cleanDamage->damage : 0);
 830                 ((Player*)pVictim)->RewardRage(rage_damage, 0, false);
 831             }
 832
 833             // random durability for items (HIT TAKEN)
 834             if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_DAMAGE)))
 835             {
 836                 EquipmentSlots slot = EquipmentSlots(urand(0,EQUIPMENT_SLOT_END-1));
 837                 ((Player*)pVictim)->DurabilityPointLossForEquipSlot(slot);
 838             }
 839         }
 840
 841         if(GetTypeId()==TYPEID_PLAYER)
 842         {
 843             // random durability for items (HIT DONE)
 844             if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_DAMAGE)))
 845             {
 846                 EquipmentSlots slot = EquipmentSlots(urand(0,EQUIPMENT_SLOT_END-1));
 847                 ((Player*)this)->DurabilityPointLossForEquipSlot(slot);
 848             }
 849         }
 850
 851         // TODO: Store auras by interrupt flag to speed this up.
 852         AuraMap& vAuras = pVictim->GetAuras();
 853         for (AuraMap::iterator i = vAuras.begin(), next; i != vAuras.end(); i = next)
 854         {
 855             const SpellEntry *se = i->second->GetSpellProto();
 856             next = i; ++next;
 857             if( se->AuraInterruptFlags & AURA_INTERRUPT_FLAG_DAMAGE )
 858             {
 859                 bool remove = true;
 860                 if (se->procFlags & (1<<3))
 861                 {
 862                     if (!roll_chance_i(se->procChance))
 863                         remove = false;
 864                 }
 865                 if (remove)
 866                 {
 867                     pVictim->RemoveAurasDueToSpell(i->second->GetId());
 868                     // FIXME: this may cause the auras with proc chance to be rerolled several times
 869                     next = vAuras.begin();
 870                 }
 871             }
 872         }
 873
 874         if (damagetype != NODAMAGE && damage && pVictim->GetTypeId() == TYPEID_PLAYER)
 875         {
 876             if( damagetype != DOT )
 877             {
 878                 for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
 879                 {
 880                     // skip channeled spell (processed differently below)
 881                     if (i == CURRENT_CHANNELED_SPELL)
 882                         continue;
 883
 884                     if(Spell* spell = pVictim->m_currentSpells[i])
 885                         if(spell->getState() == SPELL_STATE_PREPARING)
 886                             spell->Delayed();
 887                 }
 888             }
 889
 890             if(Spell* spell = pVictim->m_currentSpells[CURRENT_CHANNELED_SPELL])
 891             {
 892                 if (spell->getState() == SPELL_STATE_CASTING)
 893                 {
 894                     uint32 channelInterruptFlags = spell->m_spellInfo->ChannelInterruptFlags;
 895                     if( channelInterruptFlags & CHANNEL_FLAG_DELAY )
 896                     {
 897                         if(pVictim!=this)                   //don't shorten the duration of channeling if you damage yourself
 898                             spell->DelayedChannel();
 899                     }
 900                     else if( (channelInterruptFlags & (CHANNEL_FLAG_DAMAGE | CHANNEL_FLAG_DAMAGE2)) )
 901                     {
 902                         sLog.outDetail("Spell %u canceled at damage!",spell->m_spellInfo->Id);
 903                         pVictim->InterruptSpell(CURRENT_CHANNELED_SPELL);
 904                     }
 905                 }
 906                 else if (spell->getState() == SPELL_STATE_DELAYED)
 907                     // break channeled spell in delayed state on damage
 908                 {
 909                     sLog.outDetail("Spell %u canceled at damage!",spell->m_spellInfo->Id);
 910                     pVictim->InterruptSpell(CURRENT_CHANNELED_SPELL);
 911                 }
 912             }
 913         }
 914
 915         // last damage from duel opponent
 916         if(duel_hasEnded)
 917         {
 918             assert(pVictim->GetTypeId()==TYPEID_PLAYER);
 919             Player *he = (Player*)pVictim;
 920
 921             assert(he->duel);
 922
 923             he->SetHealth(1);
 924
 925             he->duel->opponent->CombatStopWithPets(true);
 926             he->CombatStopWithPets(true);
 927
 928             he->CastSpell(he, 7267, true);                  // beg
 929             he->DuelComplete(DUEL_WON);
 930         }
 931     }
 932
 933     DEBUG_LOG("DealDamageEnd returned %d damage", damage);
 934
 935     return damage;
 936 }
 937
 938 void Unit::CastStop(uint32 except_spellid)
 939 {
 940     for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
 941         if (m_currentSpells[i] && m_currentSpells[i]->m_spellInfo->Id!=except_spellid)
 942             InterruptSpell(i,false);
 943 }
 944
 945 void Unit::CastSpell(Unit* Victim, uint32 spellId, bool triggered, Item *castItem, Aura* triggeredByAura, uint64 originalCaster)
 946 {
 947     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId );
 948
 949     if(!spellInfo)
 950     {
 951         sLog.outError("CastSpell: unknown spell id %i by caster: %s %u)", spellId,(GetTypeId()==TYPEID_PLAYER ? "player (GUID:" : "creature (Entry:"),(GetTypeId()==TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
 952         return;
 953     }
 954
 955     CastSpell(Victim,spellInfo,triggered,castItem,triggeredByAura, originalCaster);
 956 }
 957
 958 void Unit::CastSpell(Unit* Victim,SpellEntry const *spellInfo, bool triggered, Item *castItem, Aura* triggeredByAura, uint64 originalCaster)
 959 {
 960     if(!spellInfo)
 961     {
 962         sLog.outError("CastSpell: unknown spell by caster: %s %u)", (GetTypeId()==TYPEID_PLAYER ? "player (GUID:" : "creature (Entry:"),(GetTypeId()==TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
 963         return;
 964     }
 965
 966     if (castItem)
 967         DEBUG_LOG("WORLD: cast Item spellId - %i", spellInfo->Id);
 968
 969     if(!originalCaster && triggeredByAura)
 970         originalCaster = triggeredByAura->GetCasterGUID();
 971
 972     Spell *spell = new Spell(this, spellInfo, triggered, originalCaster );
 973
 974     SpellCastTargets targets;
 975     targets.setUnitTarget( Victim );
 976     spell->m_CastItem = castItem;
 977     spell->prepare(&targets, triggeredByAura);
 978 }
 979
 980 void Unit::CastCustomSpell(Unit* Victim,uint32 spellId, int32 const* bp0, int32 const* bp1, int32 const* bp2, bool triggered, Item *castItem, Aura* triggeredByAura, uint64 originalCaster)
 981 {
 982     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId );
 983
 984     if(!spellInfo)
 985     {
 986         sLog.outError("CastCustomSpell: unknown spell id %i\n", spellId);
 987         return;
 988     }
 989
 990     CastCustomSpell(Victim,spellInfo,bp0,bp1,bp2,triggered,castItem,triggeredByAura, originalCaster);
 991 }
 992
 993 void Unit::CastCustomSpell(Unit* Victim,SpellEntry const *spellInfo, int32 const* bp0, int32 const* bp1, int32 const* bp2, bool triggered, Item *castItem, Aura* triggeredByAura, uint64 originalCaster)
 994 {
 995     if(!spellInfo)
 996     {
 997         sLog.outError("CastCustomSpell: unknown spell");
 998         return;
 999     }
1000
1001     if (castItem)
1002         DEBUG_LOG("WORLD: cast Item spellId - %i", spellInfo->Id);
1003
1004     if(!originalCaster && triggeredByAura)
1005         originalCaster = triggeredByAura->GetCasterGUID();
1006
1007     Spell *spell = new Spell(this, spellInfo, triggered, originalCaster);
1008
1009     if(bp0)
1010         spell->m_currentBasePoints[0] = *bp0-int32(spellInfo->EffectBaseDice[0]);
1011
1012     if(bp1)
1013         spell->m_currentBasePoints[1] = *bp1-int32(spellInfo->EffectBaseDice[1]);
1014
1015     if(bp2)
1016         spell->m_currentBasePoints[2] = *bp2-int32(spellInfo->EffectBaseDice[2]);
1017
1018     SpellCastTargets targets;
1019     targets.setUnitTarget( Victim );
1020     spell->m_CastItem = castItem;
1021     spell->prepare(&targets, triggeredByAura);
1022 }
1023
1024 // used for scripting
1025 void Unit::CastSpell(float x, float y, float z, uint32 spellId, bool triggered, Item *castItem, Aura* triggeredByAura, uint64 originalCaster)
1026 {
1027     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId );
1028
1029     if(!spellInfo)
1030     {
1031         sLog.outError("CastSpell(x,y,z): unknown spell id %i by caster: %s %u)", spellId,(GetTypeId()==TYPEID_PLAYER ? "player (GUID:" : "creature (Entry:"),(GetTypeId()==TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
1032         return;
1033     }
1034
1035     CastSpell(x, y, z,spellInfo,triggered,castItem,triggeredByAura, originalCaster);
1036 }
1037
1038 // used for scripting
1039 void Unit::CastSpell(float x, float y, float z, SpellEntry const *spellInfo, bool triggered, Item *castItem, Aura* triggeredByAura, uint64 originalCaster)
1040 {
1041     if(!spellInfo)
1042     {
1043         sLog.outError("CastSpell(x,y,z): unknown spell by caster: %s %u)", (GetTypeId()==TYPEID_PLAYER ? "player (GUID:" : "creature (Entry:"),(GetTypeId()==TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
1044         return;
1045     }
1046
1047     if (castItem)
1048         DEBUG_LOG("WORLD: cast Item spellId - %i", spellInfo->Id);
1049
1050     if(!originalCaster && triggeredByAura)
1051         originalCaster = triggeredByAura->GetCasterGUID();
1052
1053     Spell *spell = new Spell(this, spellInfo, triggered, originalCaster );
1054
1055     SpellCastTargets targets;
1056     targets.setDestination(x, y, z);
1057     spell->m_CastItem = castItem;
1058     spell->prepare(&targets, triggeredByAura);
1059 }
1060
1061 void Unit::DealFlatDamage(Unit *pVictim, SpellEntry const *spellInfo, uint32 *damage, CleanDamage *cleanDamage, bool *crit, bool isTriggeredSpell)
1062 {
1063     // TODO this in only generic way, check for exceptions
1064     DEBUG_LOG("DealFlatDamage (BEFORE) >> DMG:%u", *damage);
1065
1066     // Per-damage class calculation
1067     switch (spellInfo->DmgClass)
1068     {
1069         // Melee and Ranged Spells
1070         case SPELL_DAMAGE_CLASS_RANGED:
1071         case SPELL_DAMAGE_CLASS_MELEE:
1072         {
1073             // Calculate physical outcome
1074             MeleeHitOutcome outcome = RollPhysicalOutcomeAgainst(pVictim, BASE_ATTACK, spellInfo);
1075
1076             //Used to store the Hit Outcome
1077             cleanDamage->hitOutCome = outcome;
1078
1079             // Return miss/evade first (sends miss message)
1080             switch(outcome)
1081             {
1082                 case MELEE_HIT_EVADE:
1083                 {
1084                     SendAttackStateUpdate(HITINFO_MISS, pVictim, 1, GetSpellSchoolMask(spellInfo), 0, 0,0,VICTIMSTATE_EVADES,0);
1085                     *damage = 0;
1086                     return;
1087                 }
1088                 case MELEE_HIT_MISS:
1089                 {
1090                     SendAttackStateUpdate(HITINFO_MISS, pVictim, 1, GetSpellSchoolMask(spellInfo), 0, 0,0,VICTIMSTATE_NORMAL,0);
1091                     *damage = 0;
1092
1093                     if(GetTypeId()== TYPEID_PLAYER)
1094                         ((Player*)this)->UpdateWeaponSkill(BASE_ATTACK);
1095
1096                     CastMeleeProcDamageAndSpell(pVictim,0,GetSpellSchoolMask(spellInfo),BASE_ATTACK,MELEE_HIT_MISS,spellInfo,isTriggeredSpell);
1097                     return;
1098                 }
1099             }
1100
1101             //  Hitinfo, Victimstate
1102             uint32 hitInfo = HITINFO_NORMALSWING;
1103             VictimState victimState = VICTIMSTATE_NORMAL;
1104
1105             // Physical Damage
1106             if ( GetSpellSchoolMask(spellInfo) & SPELL_SCHOOL_MASK_NORMAL )
1107             {
1108                 // apply spellmod to Done damage
1109                 if(Player* modOwner = GetSpellModOwner())
1110                     modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_DAMAGE, *damage);
1111
1112                 //Calculate armor mitigation
1113                 uint32 damageAfterArmor = CalcArmorReducedDamage(pVictim, *damage);
1114
1115                 // random durability for main hand weapon (ABSORB)
1116                 if(damageAfterArmor < *damage)
1117                     if(pVictim->GetTypeId() == TYPEID_PLAYER)
1118                         if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_ABSORB)))
1119                             ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EquipmentSlots(urand(EQUIPMENT_SLOT_START,EQUIPMENT_SLOT_BACK)));
1120
1121                 cleanDamage->damage += *damage - damageAfterArmor;
1122                 *damage = damageAfterArmor;
1123             }
1124             // Magical Damage
1125             else
1126             {
1127                 // Calculate damage bonus
1128                 *damage = SpellDamageBonus(pVictim, spellInfo, *damage, SPELL_DIRECT_DAMAGE);
1129             }
1130
1131             // Classify outcome
1132             switch (outcome)
1133             {
1134                 case MELEE_HIT_BLOCK_CRIT:
1135                 case MELEE_HIT_CRIT:
1136                 {
1137                     uint32 bonusDmg = *damage;
1138
1139                     // Apply crit_damage bonus
1140                     if(Player* modOwner = GetSpellModOwner())
1141                         modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CRIT_DAMAGE_BONUS, bonusDmg);
1142
1143                     uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
1144                     AuraList const& mDamageDoneVersus = GetAurasByType(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS);
1145                     for(AuraList::const_iterator i = mDamageDoneVersus.begin();i != mDamageDoneVersus.end(); ++i)
1146                         if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
1147                             bonusDmg = uint32(bonusDmg * ((*i)->GetModifier()->m_amount+100.0f)/100.0f);
1148
1149                     *damage += bonusDmg;
1150
1151                     // Resilience - reduce crit damage
1152                     if (pVictim->GetTypeId()==TYPEID_PLAYER)
1153                     {
1154                         uint32 resilienceReduction = ((Player*)pVictim)->GetMeleeCritDamageReduction(*damage);
1155                         cleanDamage->damage += resilienceReduction;
1156                         *damage -=  resilienceReduction;
1157                     }
1158
1159                     *crit = true;
1160                     hitInfo |= HITINFO_CRITICALHIT;
1161
1162                     ModifyAuraState(AURA_STATE_CRIT, true);
1163                     StartReactiveTimer( REACTIVE_CRIT );
1164
1165                     if(getClass()==CLASS_HUNTER)
1166                     {
1167                         ModifyAuraState(AURA_STATE_HUNTER_CRIT_STRIKE, true);
1168                         StartReactiveTimer( REACTIVE_HUNTER_CRIT );
1169                     }
1170
1171                     if ( outcome == MELEE_HIT_BLOCK_CRIT )
1172                     {
1173                         uint32 blocked_amount = uint32(pVictim->GetShieldBlockValue());
1174                         if (blocked_amount >= *damage)
1175                         {
1176                             hitInfo |= HITINFO_SWINGNOHITSOUND;
1177                             victimState = VICTIMSTATE_BLOCKS;
1178                             cleanDamage->damage += *damage; // To Help Calculate Rage
1179                             *damage = 0;
1180                         }
1181                         else
1182                         {
1183                             // To Help Calculate Rage
1184                             cleanDamage->damage += blocked_amount;
1185                             *damage = *damage - blocked_amount;
1186                         }
1187
1188                         pVictim->ModifyAuraState(AURA_STATE_DEFENSE, true);
1189                         pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
1190
1191                         if(pVictim->GetTypeId() == TYPEID_PLAYER)
1192                         {
1193                             // Update defense
1194                             ((Player*)pVictim)->UpdateDefense();
1195
1196                             // random durability for main hand weapon (BLOCK)
1197                             if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_BLOCK)))
1198                                 ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_OFFHAND);
1199                         }
1200                     }
1201                     break;
1202                 }
1203                 case MELEE_HIT_PARRY:
1204                 {
1205                     cleanDamage->damage += *damage;         // To Help Calculate Rage
1206                     *damage = 0;
1207                     victimState = VICTIMSTATE_PARRY;
1208
1209                     // Counter-attack ( explained in Unit::DoAttackDamage() )
1210                     if(pVictim->GetTypeId()==TYPEID_PLAYER || !(((Creature*)pVictim)->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_PARRY_HASTEN) )
1211                     {
1212                         // Get attack timers
1213                         float offtime  = float(pVictim->getAttackTimer(OFF_ATTACK));
1214                         float basetime = float(pVictim->getAttackTimer(BASE_ATTACK));
1215
1216                         // Reduce attack time
1217                         if (pVictim->haveOffhandWeapon() && offtime < basetime)
1218                         {
1219                             float percent20 = pVictim->GetAttackTime(OFF_ATTACK) * 0.20;
1220                             float percent60 = 3 * percent20;
1221                             if(offtime > percent20 && offtime <= percent60)
1222                             {
1223                                 pVictim->setAttackTimer(OFF_ATTACK, uint32(percent20));
1224                             }
1225                             else if(offtime > percent60)
1226                             {
1227                                 offtime -= 2 * percent20;
1228                                 pVictim->setAttackTimer(OFF_ATTACK, uint32(offtime));
1229                             }
1230                         }
1231                         else
1232                         {
1233                             float percent20 = pVictim->GetAttackTime(BASE_ATTACK) * 0.20;
1234                             float percent60 = 3 * percent20;
1235                             if(basetime > percent20 && basetime <= percent60)
1236                             {
1237                                 pVictim->setAttackTimer(BASE_ATTACK, uint32(percent20));
1238                             }
1239                             else if(basetime > percent60)
1240                             {
1241                                 basetime -= 2 * percent20;
1242                                 pVictim->setAttackTimer(BASE_ATTACK, uint32(basetime));
1243                             }
1244                         }
1245                     }
1246
1247                     if(pVictim->GetTypeId() == TYPEID_PLAYER)
1248                     {
1249                         // Update victim defense ?
1250                         ((Player*)pVictim)->UpdateDefense();
1251
1252                         // random durability for main hand weapon (PARRY)
1253                         if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_PARRY)))
1254                             ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_MAINHAND);
1255                     }
1256
1257                     // Set parry flags
1258                     pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
1259
1260                     // Mongoose bite - set only Counterattack here
1261                     if (pVictim->getClass() == CLASS_HUNTER)
1262                     {
1263                         pVictim->ModifyAuraState(AURA_STATE_HUNTER_PARRY,true);
1264                         pVictim->StartReactiveTimer( REACTIVE_HUNTER_PARRY );
1265                     }
1266                     else
1267                     {
1268                         pVictim->ModifyAuraState(AURA_STATE_DEFENSE, true);
1269                         pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
1270                     }
1271                     break;
1272                 }
1273                 case MELEE_HIT_DODGE:
1274                 {
1275                     if(pVictim->GetTypeId() == TYPEID_PLAYER)
1276                         ((Player*)pVictim)->UpdateDefense();
1277
1278                     cleanDamage->damage += *damage;         // To Help Calculate Rage
1279                     *damage = 0;
1280                     hitInfo |= HITINFO_SWINGNOHITSOUND;
1281                     victimState = VICTIMSTATE_DODGE;
1282
1283                     // Set dodge flags
1284                     pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
1285
1286                     // Overpower
1287                     if (GetTypeId() == TYPEID_PLAYER && getClass() == CLASS_WARRIOR)
1288                     {
1289                         ((Player*)this)->AddComboPoints(pVictim, 1);
1290                         StartReactiveTimer( REACTIVE_OVERPOWER );
1291                     }
1292
1293                     // Riposte
1294                     if (pVictim->getClass() != CLASS_ROGUE)
1295                     {
1296                         pVictim->ModifyAuraState(AURA_STATE_DEFENSE, true);
1297                         pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
1298                     }
1299                     break;
1300                 }
1301                 case MELEE_HIT_BLOCK:
1302                 {
1303                     uint32 blocked_amount = uint32(pVictim->GetShieldBlockValue());
1304                     if (blocked_amount >= *damage)
1305                     {
1306                         hitInfo |= HITINFO_SWINGNOHITSOUND;
1307                         victimState = VICTIMSTATE_BLOCKS;
1308                         cleanDamage->damage += *damage;     // To Help Calculate Rage
1309                         *damage = 0;
1310                     }
1311                     else
1312                     {
1313                         // To Help Calculate Rage
1314                         cleanDamage->damage += blocked_amount;
1315                         *damage = *damage - blocked_amount;
1316                     }
1317
1318                     pVictim->ModifyAuraState(AURA_STATE_DEFENSE, true);
1319                     pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
1320
1321                     if(pVictim->GetTypeId() == TYPEID_PLAYER)
1322                     {
1323                         // Update defense
1324                         ((Player*)pVictim)->UpdateDefense();
1325
1326                         // random durability for main hand weapon (BLOCK)
1327                         if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_BLOCK)))
1328                             ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_OFFHAND);
1329                     }
1330                     break;
1331                 }
1332                 case MELEE_HIT_EVADE:                       // already processed early
1333                 case MELEE_HIT_MISS:                        // already processed early
1334                 case MELEE_HIT_GLANCING:
1335                 case MELEE_HIT_CRUSHING:
1336                 case MELEE_HIT_NORMAL:
1337                     break;
1338             }
1339
1340             // do all damage=0 cases here
1341             if(*damage == 0)
1342                 CastMeleeProcDamageAndSpell(pVictim,0,GetSpellSchoolMask(spellInfo),BASE_ATTACK,outcome,spellInfo,isTriggeredSpell);
1343
1344             break;
1345         }
1346         // Magical Attacks
1347         case SPELL_DAMAGE_CLASS_NONE:
1348         case SPELL_DAMAGE_CLASS_MAGIC:
1349         {
1350             // Calculate damage bonus
1351             *damage = SpellDamageBonus(pVictim, spellInfo, *damage, SPELL_DIRECT_DAMAGE);
1352
1353             *crit = isSpellCrit(pVictim, spellInfo, GetSpellSchoolMask(spellInfo), BASE_ATTACK);
1354             if (*crit)
1355             {
1356                 *damage = SpellCriticalBonus(spellInfo, *damage, pVictim);
1357
1358                 // Resilience - reduce crit damage
1359                 if (pVictim && pVictim->GetTypeId()==TYPEID_PLAYER)
1360                 {
1361                     uint32 damage_reduction = ((Player *)pVictim)->GetSpellCritDamageReduction(*damage);
1362                     if(*damage > damage_reduction)
1363                         *damage -= damage_reduction;
1364                     else
1365                         *damage = 0;
1366                 }
1367
1368                 cleanDamage->hitOutCome = MELEE_HIT_CRIT;
1369             }
1370             // spell proc all magic damage==0 case in this function
1371             if(*damage == 0)
1372             {
1373                 // Procflags
1374                 uint32 procAttacker = PROC_FLAG_HIT_SPELL;
1375                 uint32 procVictim   = (PROC_FLAG_STRUCK_SPELL|PROC_FLAG_TAKE_DAMAGE);
1376
1377                 ProcDamageAndSpell(pVictim, procAttacker, procVictim, 0, GetSpellSchoolMask(spellInfo), spellInfo, isTriggeredSpell);
1378             }
1379
1380             break;
1381         }
1382     }
1383
1384     // TODO this in only generic way, check for exceptions
1385     DEBUG_LOG("DealFlatDamage (AFTER) >> DMG:%u", *damage);
1386 }
1387
1388 uint32 Unit::SpellNonMeleeDamageLog(Unit *pVictim, uint32 spellID, uint32 damage, bool isTriggeredSpell, bool useSpellDamage)
1389 {
1390     if(!this || !pVictim)
1391         return 0;
1392     if(!isAlive() || !pVictim->isAlive())
1393         return 0;
1394
1395     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellID);
1396     if(!spellInfo)
1397         return 0;
1398
1399     CleanDamage cleanDamage = CleanDamage(0, BASE_ATTACK, MELEE_HIT_NORMAL);
1400     bool crit = false;
1401
1402     if (useSpellDamage)
1403         DealFlatDamage(pVictim, spellInfo, &damage, &cleanDamage, &crit, isTriggeredSpell);
1404
1405     // If we actually dealt some damage (spell proc's for 0 damage (normal and magic) called in DealFlatDamage)
1406     if(damage > 0)
1407     {
1408         // Calculate absorb & resists
1409         uint32 absorb = 0;
1410         uint32 resist = 0;
1411
1412         CalcAbsorbResist(pVictim,GetSpellSchoolMask(spellInfo), SPELL_DIRECT_DAMAGE, damage, &absorb, &resist);
1413
1414         //No more damage left, target absorbed and/or resisted all damage
1415         if (damage > absorb + resist)
1416             damage -= absorb + resist;      //Remove Absorbed and Resisted from damage actually dealt
1417         else
1418         {
1419             uint32 HitInfo = HITINFO_SWINGNOHITSOUND;
1420
1421             if (absorb)
1422                 HitInfo |= HITINFO_ABSORB;
1423             if (resist)
1424             {
1425                 HitInfo |= HITINFO_RESIST;
1426                 ProcDamageAndSpell(pVictim, PROC_FLAG_TARGET_RESISTS, PROC_FLAG_RESIST_SPELL, 0, GetSpellSchoolMask(spellInfo), spellInfo,isTriggeredSpell);
1427             }
1428
1429             //Send resist
1430             SendAttackStateUpdate(HitInfo, pVictim, 1, GetSpellSchoolMask(spellInfo), damage, absorb,resist,VICTIMSTATE_NORMAL,0);
1431             return 0;
1432         }
1433
1434         // Deal damage done
1435         damage = DealDamage(pVictim, damage, &cleanDamage, SPELL_DIRECT_DAMAGE, GetSpellSchoolMask(spellInfo), spellInfo, true);
1436
1437         // Send damage log
1438         sLog.outDetail("SpellNonMeleeDamageLog: %u (TypeId: %u) attacked %u (TypeId: %u) for %u dmg inflicted by %u,absorb is %u,resist is %u",
1439             GetGUIDLow(), GetTypeId(), pVictim->GetGUIDLow(), pVictim->GetTypeId(), damage, spellID, absorb,resist);
1440
1441         // Actual log sent to client
1442         SendSpellNonMeleeDamageLog(pVictim, spellID, damage, GetSpellSchoolMask(spellInfo), absorb, resist, false, 0, crit);
1443
1444         // Procflags
1445         uint32 procAttacker = PROC_FLAG_HIT_SPELL;
1446         uint32 procVictim   = (PROC_FLAG_STRUCK_SPELL|PROC_FLAG_TAKE_DAMAGE);
1447
1448         if (crit)
1449         {
1450             procAttacker |= PROC_FLAG_CRIT_SPELL;
1451             procVictim   |= PROC_FLAG_STRUCK_CRIT_SPELL;
1452         }
1453
1454         ProcDamageAndSpell(pVictim, procAttacker, procVictim, damage, GetSpellSchoolMask(spellInfo), spellInfo, isTriggeredSpell);
1455
1456         return damage;
1457     }
1458     else
1459     {
1460         // all spell proc for 0 normal and magic damage called in DealFlatDamage
1461
1462         //Check for rage
1463         if(cleanDamage.damage)
1464             // Rage from damage received.
1465             if(pVictim->GetTypeId() == TYPEID_PLAYER && (pVictim->getPowerType() == POWER_RAGE))
1466                 ((Player*)pVictim)->RewardRage(cleanDamage.damage, 0, false);
1467
1468         return 0;
1469     }
1470 }
1471
1472 void Unit::HandleEmoteCommand(uint32 anim_id)
1473 {
1474     WorldPacket data( SMSG_EMOTE, 12 );
1475     data << uint32(anim_id);
1476     data << uint64(GetGUID());
1477     SendMessageToSet(&data, true);
1478 }
1479
1480 uint32 Unit::CalcArmorReducedDamage(Unit* pVictim, const uint32 damage)
1481 {
1482     uint32 newdamage = 0;
1483     float armor = pVictim->GetArmor();
1484     // Ignore enemy armor by SPELL_AURA_MOD_TARGET_RESISTANCE aura
1485     armor += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, SPELL_SCHOOL_MASK_NORMAL);
1486
1487     if (armor<0.0f) armor=0.0f;
1488
1489     float tmpvalue = 0.0f;
1490     if(getLevel() <= 59)                                    //Level 1-59
1491         tmpvalue = armor / (armor + 400.0f + 85.0f * getLevel());
1492     else if(getLevel() < 70)                                //Level 60-69
1493         tmpvalue = armor / (armor - 22167.5f + 467.5f * getLevel());
1494     else                                                    //Level 70+
1495         tmpvalue = armor / (armor + 10557.5f);
1496
1497     if(tmpvalue < 0.0f)
1498         tmpvalue = 0.0f;
1499     if(tmpvalue > 0.75f)
1500         tmpvalue = 0.75f;
1501     newdamage = uint32(damage - (damage * tmpvalue));
1502
1503     return (newdamage > 1) ? newdamage : 1;
1504 }
1505
1506 void Unit::CalcAbsorbResist(Unit *pVictim,SpellSchoolMask schoolMask, DamageEffectType damagetype, const uint32 damage, uint32 *absorb, uint32 *resist)
1507 {
1508     if(!pVictim || !pVictim->isAlive() || !damage)
1509         return;
1510
1511     // Magic damage, check for resists
1512     if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL)==0)
1513     {
1514         // Get base victim resistance for school
1515         float tmpvalue2 = (float)pVictim->GetResistance(GetFirstSchoolInMask(schoolMask));
1516         // Ignore resistance by self SPELL_AURA_MOD_TARGET_RESISTANCE aura
1517         tmpvalue2 += (float)GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask);
1518
1519         tmpvalue2 *= (float)(0.15f / getLevel());
1520         if (tmpvalue2 < 0.0f)
1521             tmpvalue2 = 0.0f;
1522         if (tmpvalue2 > 0.75f)
1523             tmpvalue2 = 0.75f;
1524         uint32 ran = urand(0, 100);
1525         uint32 faq[4] = {24,6,4,6};
1526         uint8 m = 0;
1527         float Binom = 0.0f;
1528         for (uint8 i = 0; i < 4; i++)
1529         {
1530             Binom += 2400 *( powf(tmpvalue2, i) * powf( (1-tmpvalue2), (4-i)))/faq[i];
1531             if (ran > Binom )
1532                 ++m;
1533             else
1534                 break;
1535         }
1536         if (damagetype == DOT && m == 4)
1537             *resist += uint32(damage - 1);
1538         else
1539             *resist += uint32(damage * m / 4);
1540         if(*resist > damage)
1541             *resist = damage;
1542     }
1543     else
1544         *resist = 0;
1545
1546     int32 RemainingDamage = damage - *resist;
1547
1548     // absorb without mana cost
1549     int32 reflectDamage = 0;
1550     Aura* reflectAura = NULL;
1551     AuraList const& vSchoolAbsorb = pVictim->GetAurasByType(SPELL_AURA_SCHOOL_ABSORB);
1552     for(AuraList::const_iterator i = vSchoolAbsorb.begin(), next; i != vSchoolAbsorb.end() && RemainingDamage > 0; i = next)
1553     {
1554         next = i; ++next;
1555
1556         if (((*i)->GetModifier()->m_miscvalue & schoolMask)==0)
1557             continue;
1558
1559         // Cheat Death
1560         if((*i)->GetSpellProto()->SpellFamilyName==SPELLFAMILY_ROGUE && (*i)->GetSpellProto()->SpellIconID == 2109)
1561         {
1562             if (((Player*)pVictim)->HasSpellCooldown(31231))
1563                 continue;
1564             if (pVictim->GetHealth() <= RemainingDamage)
1565             {
1566                 int32 chance = (*i)->GetModifier()->m_amount;
1567                 if (roll_chance_i(chance))
1568                 {
1569                     pVictim->CastSpell(pVictim,31231,true);
1570                     ((Player*)pVictim)->AddSpellCooldown(31231,0,time(NULL)+60);
1571
1572                     // with health > 10% lost health until health==10%, in other case no losses
1573                     uint32 health10 = pVictim->GetMaxHealth()/10;
1574                     RemainingDamage = pVictim->GetHealth() > health10 ? pVictim->GetHealth() - health10 : 0;
1575                 }
1576             }
1577             continue;
1578         }
1579
1580         int32 currentAbsorb;
1581
1582         //Reflective Shield
1583         if ((pVictim != this) && (*i)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_PRIEST && (*i)->GetSpellProto()->SpellFamilyFlags == 0x1)
1584         {
1585             if(Unit* caster = (*i)->GetCaster())
1586             {
1587                 AuraList const& vOverRideCS = caster->GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
1588                 for(AuraList::const_iterator k = vOverRideCS.begin(); k != vOverRideCS.end(); ++k)
1589                 {
1590                     switch((*k)->GetModifier()->m_miscvalue)
1591                     {
1592                         case 5065:                          // Rank 1
1593                         case 5064:                          // Rank 2
1594                         case 5063:                          // Rank 3
1595                         case 5062:                          // Rank 4
1596                         case 5061:                          // Rank 5
1597                         {
1598                             if(RemainingDamage >= (*i)->GetModifier()->m_amount)
1599                                 reflectDamage = (*i)->GetModifier()->m_amount * (*k)->GetModifier()->m_amount/100;
1600                             else
1601                                 reflectDamage = (*k)->GetModifier()->m_amount * RemainingDamage/100;
1602                             reflectAura = *i;
1603
1604                         } break;
1605                         default: break;
1606                     }
1607
1608                     if(reflectDamage)
1609                         break;
1610                 }
1611             }
1612         }
1613
1614         if (RemainingDamage >= (*i)->GetModifier()->m_amount)
1615         {
1616             currentAbsorb = (*i)->GetModifier()->m_amount;
1617             pVictim->RemoveAurasDueToSpell((*i)->GetId());
1618             next = vSchoolAbsorb.begin();
1619         }
1620         else
1621         {
1622             currentAbsorb = RemainingDamage;
1623             (*i)->GetModifier()->m_amount -= RemainingDamage;
1624         }
1625
1626         RemainingDamage -= currentAbsorb;
1627     }
1628     // do not cast spells while looping auras; auras can get invalid otherwise
1629     if (reflectDamage)
1630         pVictim->CastCustomSpell(this, 33619, &reflectDamage, NULL, NULL, true, NULL, reflectAura);
1631
1632     // absorb by mana cost
1633     AuraList const& vManaShield = pVictim->GetAurasByType(SPELL_AURA_MANA_SHIELD);
1634     for(AuraList::const_iterator i = vManaShield.begin(), next; i != vManaShield.end() && RemainingDamage > 0; i = next)
1635     {
1636         next = i; ++next;
1637
1638         // check damage school mask
1639         if(((*i)->GetModifier()->m_miscvalue & schoolMask)==0)
1640             continue;
1641
1642         int32 currentAbsorb;
1643         if (RemainingDamage >= (*i)->GetModifier()->m_amount)
1644             currentAbsorb = (*i)->GetModifier()->m_amount;
1645         else
1646             currentAbsorb = RemainingDamage;
1647
1648         float manaMultiplier = (*i)->GetSpellProto()->EffectMultipleValue[(*i)->GetEffIndex()];
1649         if(Player *modOwner = GetSpellModOwner())
1650             modOwner->ApplySpellMod((*i)->GetId(), SPELLMOD_MULTIPLE_VALUE, manaMultiplier);
1651
1652         int32 maxAbsorb = int32(pVictim->GetPower(POWER_MANA) / manaMultiplier);
1653         if (currentAbsorb > maxAbsorb)
1654             currentAbsorb = maxAbsorb;
1655
1656         (*i)->GetModifier()->m_amount -= currentAbsorb;
1657         if((*i)->GetModifier()->m_amount <= 0)
1658         {
1659             pVictim->RemoveAurasDueToSpell((*i)->GetId());
1660             next = vManaShield.begin();
1661         }
1662
1663         int32 manaReduction = int32(currentAbsorb * manaMultiplier);
1664         pVictim->ApplyPowerMod(POWER_MANA, manaReduction, false);
1665
1666         RemainingDamage -= currentAbsorb;
1667     }
1668
1669     // only split damage if not damaging yourself
1670     if(pVictim != this)
1671     {
1672         AuraList const& vSplitDamageFlat = pVictim->GetAurasByType(SPELL_AURA_SPLIT_DAMAGE_FLAT);
1673         for(AuraList::const_iterator i = vSplitDamageFlat.begin(), next; i != vSplitDamageFlat.end() && RemainingDamage >= 0; i = next)
1674         {
1675             next = i; ++next;
1676
1677             // check damage school mask
1678             if(((*i)->GetModifier()->m_miscvalue & schoolMask)==0)
1679                 continue;
1680
1681             // Damage can be splitted only if aura has an alive caster
1682             Unit *caster = (*i)->GetCaster();
1683             if(!caster || caster == pVictim || !caster->IsInWorld() || !caster->isAlive())
1684                 continue;
1685
1686             int32 currentAbsorb;
1687             if (RemainingDamage >= (*i)->GetModifier()->m_amount)
1688                 currentAbsorb = (*i)->GetModifier()->m_amount;
1689             else
1690                 currentAbsorb = RemainingDamage;
1691
1692             RemainingDamage -= currentAbsorb;
1693
1694             SendSpellNonMeleeDamageLog(caster, (*i)->GetSpellProto()->Id, currentAbsorb, schoolMask, 0, 0, false, 0, false);
1695
1696             CleanDamage cleanDamage = CleanDamage(currentAbsorb, BASE_ATTACK, MELEE_HIT_NORMAL);
1697             DealDamage(caster, currentAbsorb, &cleanDamage, DIRECT_DAMAGE, schoolMask, (*i)->GetSpellProto(), false);
1698         }
1699
1700         AuraList const& vSplitDamagePct = pVictim->GetAurasByType(SPELL_AURA_SPLIT_DAMAGE_PCT);
1701         for(AuraList::const_iterator i = vSplitDamagePct.begin(), next; i != vSplitDamagePct.end() && RemainingDamage >= 0; i = next)
1702         {
1703             next = i; ++next;
1704
1705             // check damage school mask
1706             if(((*i)->GetModifier()->m_miscvalue & schoolMask)==0)
1707                 continue;
1708
1709             // Damage can be splitted only if aura has an alive caster
1710             Unit *caster = (*i)->GetCaster();
1711             if(!caster || caster == pVictim || !caster->IsInWorld() || !caster->isAlive())
1712                 continue;
1713
1714             int32 splitted = int32(RemainingDamage * (*i)->GetModifier()->m_amount / 100.0f);
1715
1716             RemainingDamage -= splitted;
1717
1718             SendSpellNonMeleeDamageLog(caster, (*i)->GetSpellProto()->Id, splitted, schoolMask, 0, 0, false, 0, false);
1719
1720             CleanDamage cleanDamage = CleanDamage(splitted, BASE_ATTACK, MELEE_HIT_NORMAL);
1721             DealDamage(caster, splitted, &cleanDamage, DIRECT_DAMAGE, schoolMask, (*i)->GetSpellProto(), false);
1722         }
1723     }
1724
1725     *absorb = damage - RemainingDamage - *resist;
1726 }
1727
1728 void Unit::DoAttackDamage (Unit *pVictim, uint32 *damage, CleanDamage *cleanDamage, uint32 *blocked_amount, SpellSchoolMask damageSchoolMask, uint32 *hitInfo, VictimState *victimState, uint32 *absorbDamage, uint32 *resistDamage, WeaponAttackType attType, SpellEntry const *spellCasted, bool isTriggeredSpell)
1729 {
1730     MeleeHitOutcome outcome;
1731
1732     // If is casted Melee spell, calculate like physical
1733     if(!spellCasted)
1734         outcome = RollMeleeOutcomeAgainst (pVictim, attType);
1735     else
1736         outcome = RollPhysicalOutcomeAgainst (pVictim, attType, spellCasted);
1737
1738     if(outcome == MELEE_HIT_MISS ||outcome == MELEE_HIT_DODGE ||outcome == MELEE_HIT_BLOCK ||outcome == MELEE_HIT_PARRY)
1739         pVictim->AddThreat(this, 0.0f);
1740     switch(outcome)
1741     {
1742         case MELEE_HIT_EVADE:
1743         {
1744             *hitInfo |= HITINFO_MISS;
1745             *damage = 0;
1746             cleanDamage->damage = 0;
1747             return;
1748         }
1749         case MELEE_HIT_MISS:
1750         {
1751             *hitInfo |= HITINFO_MISS;
1752             *damage = 0;
1753             cleanDamage->damage = 0;
1754             if(GetTypeId()== TYPEID_PLAYER)
1755                 ((Player*)this)->UpdateWeaponSkill(attType);
1756             return;
1757         }
1758     }
1759
1760     /// If this is a creature and it attacks from behind it has a probability to daze it's victim
1761     if( (outcome==MELEE_HIT_CRIT || outcome==MELEE_HIT_CRUSHING || outcome==MELEE_HIT_NORMAL || outcome==MELEE_HIT_GLANCING) &&
1762         GetTypeId() != TYPEID_PLAYER && !((Creature*)this)->GetCharmerOrOwnerGUID() && !pVictim->HasInArc(M_PI, this) )
1763     {
1764         // -probability is between 0% and 40%
1765         // 20% base chance
1766         float Probability = 20;
1767
1768         //there is a newbie protection, at level 10 just 7% base chance; assuming linear function
1769         if( pVictim->getLevel() < 30 )
1770             Probability = 0.65f*pVictim->getLevel()+0.5;
1771
1772         uint32 VictimDefense=pVictim->GetDefenseSkillValue(this);
1773         uint32 AttackerMeleeSkill=GetUnitMeleeSkill(pVictim);
1774
1775         Probability *= AttackerMeleeSkill/(float)VictimDefense;
1776
1777         if(Probability > 40.0f)
1778             Probability = 40.0f;
1779
1780         if(roll_chance_f(Probability))
1781             CastSpell(pVictim, 1604, true);
1782     }
1783
1784     //Calculate the damage after armor mitigation if SPELL_SCHOOL_NORMAL
1785     if (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL)
1786     {
1787         uint32 damageAfterArmor = CalcArmorReducedDamage(pVictim, *damage);
1788
1789         // random durability for main hand weapon (ABSORB)
1790         if(damageAfterArmor < *damage)
1791             if(pVictim->GetTypeId() == TYPEID_PLAYER)
1792                 if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_ABSORB)))
1793                     ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EquipmentSlots(urand(EQUIPMENT_SLOT_START,EQUIPMENT_SLOT_BACK)));
1794
1795         cleanDamage->damage += *damage - damageAfterArmor;
1796         *damage = damageAfterArmor;
1797     }
1798
1799     if(GetTypeId() == TYPEID_PLAYER && pVictim->GetTypeId() != TYPEID_PLAYER && pVictim->GetCreatureType() != CREATURE_TYPE_CRITTER )
1800         ((Player*)this)->UpdateCombatSkills(pVictim, attType, outcome, false);
1801
1802     if(GetTypeId() != TYPEID_PLAYER && pVictim->GetTypeId() == TYPEID_PLAYER)
1803         ((Player*)pVictim)->UpdateCombatSkills(this, attType, outcome, true);
1804
1805     switch (outcome)
1806     {
1807         case MELEE_HIT_BLOCK_CRIT:
1808         case MELEE_HIT_CRIT:
1809         {
1810             *hitInfo  = HITINFO_CRITICALHIT | HITINFO_NORMALSWING2 | HITINFO_UNK2;
1811
1812             // Crit bonus calc
1813             uint32 crit_bonus;
1814             crit_bonus = *damage;
1815
1816             // Apply crit_damage bonus for melee spells
1817             if (spellCasted)
1818             {
1819                 if(Player* modOwner = GetSpellModOwner())
1820                     modOwner->ApplySpellMod(spellCasted->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
1821
1822                 uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
1823                 AuraList const& mDamageDoneVersus = GetAurasByType(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS);
1824                 for(AuraList::const_iterator i = mDamageDoneVersus.begin();i != mDamageDoneVersus.end(); ++i)
1825                     if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
1826                         crit_bonus = uint32(crit_bonus * ((*i)->GetModifier()->m_amount+100.0f)/100.0f);
1827             }
1828
1829             *damage += crit_bonus;
1830
1831             uint32 resilienceReduction = 0;
1832
1833             if(attType == RANGED_ATTACK)
1834             {
1835                 int32 mod = pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
1836                 *damage = int32((*damage) * float((100.0f + mod)/100.0f));
1837                 // Resilience - reduce crit damage
1838                 if (pVictim->GetTypeId()==TYPEID_PLAYER)
1839                     resilienceReduction = ((Player*)pVictim)->GetRangedCritDamageReduction(*damage);
1840             }
1841             else
1842             {
1843                 int32 mod = pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
1844                 mod += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS_MELEE);
1845                 *damage = int32((*damage) * float((100.0f + mod)/100.0f));
1846                 // Resilience - reduce crit damage
1847                 if (pVictim->GetTypeId()==TYPEID_PLAYER)
1848                     resilienceReduction = ((Player*)pVictim)->GetMeleeCritDamageReduction(*damage);
1849             }
1850
1851             *damage -= resilienceReduction;
1852             cleanDamage->damage += resilienceReduction;
1853
1854             if(GetTypeId() == TYPEID_PLAYER && pVictim->GetTypeId() != TYPEID_PLAYER && pVictim->GetCreatureType() != CREATURE_TYPE_CRITTER )
1855                 ((Player*)this)->UpdateWeaponSkill(attType);
1856
1857             ModifyAuraState(AURA_STATE_CRIT, true);
1858             StartReactiveTimer( REACTIVE_CRIT );
1859
1860             if(getClass()==CLASS_HUNTER)
1861             {
1862                 ModifyAuraState(AURA_STATE_HUNTER_CRIT_STRIKE, true);
1863                 StartReactiveTimer( REACTIVE_HUNTER_CRIT );
1864             }
1865
1866             if ( outcome == MELEE_HIT_BLOCK_CRIT )
1867             {
1868                 *blocked_amount = pVictim->GetShieldBlockValue();
1869
1870                 if (pVictim->GetUnitBlockChance())
1871                     pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYSHIELD);
1872                 else
1873                     pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
1874
1875                 //Only set VICTIMSTATE_BLOCK on a full block
1876                 if (*blocked_amount >= uint32(*damage))
1877                 {
1878                     *victimState = VICTIMSTATE_BLOCKS;
1879                     *blocked_amount = uint32(*damage);
1880                 }
1881
1882                 if(pVictim->GetTypeId() == TYPEID_PLAYER)
1883                 {
1884                     // Update defense
1885                     ((Player*)pVictim)->UpdateDefense();
1886
1887                     // random durability for main hand weapon (BLOCK)
1888                     if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_BLOCK)))
1889                         ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_OFFHAND);
1890                 }
1891
1892                 pVictim->ModifyAuraState(AURA_STATE_DEFENSE,true);
1893                 pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
1894                 break;
1895             }
1896
1897             pVictim->HandleEmoteCommand(EMOTE_ONESHOT_WOUNDCRITICAL);
1898             break;
1899         }
1900         case MELEE_HIT_PARRY:
1901         {
1902             if(attType == RANGED_ATTACK)                    //range attack - no parry
1903             {
1904                 outcome = MELEE_HIT_NORMAL;
1905                 break;
1906             }
1907
1908             cleanDamage->damage += *damage;
1909             *damage = 0;
1910             *victimState = VICTIMSTATE_PARRY;
1911
1912             // instant (maybe with small delay) counter attack
1913             {
1914                 float offtime  = float(pVictim->getAttackTimer(OFF_ATTACK));
1915                 float basetime = float(pVictim->getAttackTimer(BASE_ATTACK));
1916
1917                 // after parry nearest next attack time will reduced at %40 from full attack time.
1918                 // The delay cannot be reduced to less than 20% of your weapon base swing delay.
1919                 if (pVictim->haveOffhandWeapon() && offtime < basetime)
1920                 {
1921                     float percent20 = pVictim->GetAttackTime(OFF_ATTACK)*0.20;
1922                     float percent60 = 3*percent20;
1923                     // set to 20% if in range 20%...20+40% of full time
1924                     if(offtime > percent20 && offtime <= percent60)
1925                     {
1926                         pVictim->setAttackTimer(OFF_ATTACK,uint32(percent20));
1927                     }
1928                     // decrease at %40 from full time
1929                     else if(offtime > percent60)
1930                     {
1931                         offtime -= 2*percent20;
1932                         pVictim->setAttackTimer(OFF_ATTACK,uint32(offtime));
1933                     }
1934                     // ELSE not changed
1935                 }
1936                 else
1937                 {
1938                     float percent20 = pVictim->GetAttackTime(BASE_ATTACK)*0.20;
1939                     float percent60 = 3*percent20;
1940                     // set to 20% if in range 20%...20+40% of full time
1941                     if(basetime > percent20 && basetime <= percent60)
1942                     {
1943                         pVictim->setAttackTimer(BASE_ATTACK,uint32(percent20));
1944                     }
1945                     // decrease at %40 from full time
1946                     else if(basetime > percent60)
1947                     {
1948                         basetime -= 2*percent20;
1949                         pVictim->setAttackTimer(BASE_ATTACK,uint32(basetime));
1950                     }
1951                     // ELSE not changed
1952                 }
1953             }
1954
1955             if(pVictim->GetTypeId() == TYPEID_PLAYER)
1956             {
1957                 // Update victim defense ?
1958                 ((Player*)pVictim)->UpdateDefense();
1959
1960                 // random durability for main hand weapon (PARRY)
1961                 if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_PARRY)))
1962                     ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_MAINHAND);
1963             }
1964
1965             pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
1966
1967             if (pVictim->getClass() == CLASS_HUNTER)
1968             {
1969                 pVictim->ModifyAuraState(AURA_STATE_HUNTER_PARRY,true);
1970                 pVictim->StartReactiveTimer( REACTIVE_HUNTER_PARRY );
1971             }
1972             else
1973             {
1974                 pVictim->ModifyAuraState(AURA_STATE_DEFENSE, true);
1975                 pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
1976             }
1977
1978             CastMeleeProcDamageAndSpell(pVictim, 0, damageSchoolMask, attType, outcome, spellCasted, isTriggeredSpell);
1979             return;
1980         }
1981         case MELEE_HIT_DODGE:
1982         {
1983             if(attType == RANGED_ATTACK)                    //range attack - no dodge
1984             {
1985                 outcome = MELEE_HIT_NORMAL;
1986                 break;
1987             }
1988
1989             cleanDamage->damage += *damage;
1990             *damage = 0;
1991             *victimState = VICTIMSTATE_DODGE;
1992
1993             if(pVictim->GetTypeId() == TYPEID_PLAYER)
1994                 ((Player*)pVictim)->UpdateDefense();
1995
1996             pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
1997
1998             if (pVictim->getClass() != CLASS_ROGUE)         // Riposte
1999             {
2000                 pVictim->ModifyAuraState(AURA_STATE_DEFENSE, true);
2001                 pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
2002             }
2003
2004             // Overpower
2005             if (GetTypeId() == TYPEID_PLAYER && getClass() == CLASS_WARRIOR)
2006             {
2007                 ((Player*)this)->AddComboPoints(pVictim, 1);
2008                 StartReactiveTimer( REACTIVE_OVERPOWER );
2009             }
2010
2011             CastMeleeProcDamageAndSpell(pVictim, 0, damageSchoolMask, attType, outcome, spellCasted, isTriggeredSpell);
2012             return;
2013         }
2014         case MELEE_HIT_BLOCK:
2015         {
2016             *blocked_amount = pVictim->GetShieldBlockValue();
2017
2018             if (pVictim->GetUnitBlockChance())
2019                 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYSHIELD);
2020             else
2021                 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
2022
2023             //Only set VICTIMSTATE_BLOCK on a full block
2024             if (*blocked_amount >= uint32(*damage))
2025             {
2026                 *victimState = VICTIMSTATE_BLOCKS;
2027                 *blocked_amount = uint32(*damage);
2028             }
2029
2030             if(pVictim->GetTypeId() == TYPEID_PLAYER)
2031             {
2032                 // Update defense
2033                 ((Player*)pVictim)->UpdateDefense();
2034
2035                 // random durability for main hand weapon (BLOCK)
2036                 if (roll_chance_f(sWorld.getRate(RATE_DURABILITY_LOSS_BLOCK)))
2037                     ((Player*)pVictim)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_OFFHAND);
2038             }
2039
2040             pVictim->ModifyAuraState(AURA_STATE_DEFENSE,true);
2041             pVictim->StartReactiveTimer( REACTIVE_DEFENSE );
2042
2043             break;
2044         }
2045         case MELEE_HIT_GLANCING:
2046         {
2047             float reducePercent = 1.0f;                     //damage factor
2048
2049             // calculate base values and mods
2050             float baseLowEnd = 1.3;
2051             float baseHighEnd = 1.2;
2052             switch(getClass())                              // lowering base values for casters
2053             {
2054                 case CLASS_SHAMAN:
2055                 case CLASS_PRIEST:
2056                 case CLASS_MAGE:
2057                 case CLASS_WARLOCK:
2058                 case CLASS_DRUID:
2059                     baseLowEnd  -= 0.7;
2060                     baseHighEnd -= 0.3;
2061                     break;
2062             }
2063
2064             float maxLowEnd = 0.6;
2065             switch(getClass())                              // upper for melee classes
2066             {
2067                 case CLASS_WARRIOR:
2068                 case CLASS_ROGUE:
2069                     maxLowEnd = 0.91;                       //If the attacker is a melee class then instead the lower value of 0.91
2070             }
2071
2072             // calculate values
2073             int32 diff = int32(pVictim->GetDefenseSkillValue(this)) - int32(GetWeaponSkillValue(attType,pVictim));
2074             float lowEnd  = baseLowEnd - ( 0.05f * diff );
2075             float highEnd = baseHighEnd - ( 0.03f * diff );
2076
2077             // apply max/min bounds
2078             if ( lowEnd < 0.01f )                           //the low end must not go bellow 0.01f
2079                 lowEnd = 0.01f;
2080             else if ( lowEnd > maxLowEnd )                  //the smaller value of this and 0.6 is kept as the low end
2081                 lowEnd = maxLowEnd;
2082
2083             if ( highEnd < 0.2f )                           //high end limits
2084                 highEnd = 0.2f;
2085             if ( highEnd > 0.99f )
2086                 highEnd = 0.99f;
2087
2088             if(lowEnd > highEnd)                            // prevent negative range size
2089                 lowEnd = highEnd;
2090
2091             reducePercent = lowEnd + rand_norm() * ( highEnd - lowEnd );
2092
2093             *damage = uint32(reducePercent * *damage);
2094             cleanDamage->damage += *damage;
2095             *hitInfo |= HITINFO_GLANCING;
2096             break;
2097         }
2098         case MELEE_HIT_CRUSHING:
2099         {
2100             // 150% normal damage
2101             *damage += (*damage / 2);
2102             cleanDamage->damage = *damage;
2103             *hitInfo |= HITINFO_CRUSHING;
2104             // TODO: victimState, victim animation?
2105             break;
2106         }
2107         default:
2108             break;
2109     }
2110
2111     // apply melee damage bonus and absorb only if base damage not fully blocked to prevent negative damage or damage with full block
2112     if(*victimState != VICTIMSTATE_BLOCKS)
2113     {
2114         MeleeDamageBonus(pVictim, damage,attType,spellCasted);
2115         CalcAbsorbResist(pVictim, damageSchoolMask, DIRECT_DAMAGE, *damage-*blocked_amount, absorbDamage, resistDamage);
2116     }
2117
2118     if (*absorbDamage) *hitInfo |= HITINFO_ABSORB;
2119     if (*resistDamage) *hitInfo |= HITINFO_RESIST;
2120
2121     cleanDamage->damage += *blocked_amount;
2122
2123     if (*damage <= *absorbDamage + *resistDamage + *blocked_amount)
2124     {
2125         //*hitInfo = 0x00010020;
2126         //*hitInfo |= HITINFO_SWINGNOHITSOUND;
2127         //*damageType = 0;
2128         CastMeleeProcDamageAndSpell(pVictim, 0, damageSchoolMask, attType, outcome, spellCasted, isTriggeredSpell);
2129         return;
2130     }
2131
2132     // update at damage Judgement aura duration that applied by attacker at victim
2133     if(*damage)
2134     {
2135         AuraMap const& vAuras = pVictim->GetAuras();
2136         for(AuraMap::const_iterator itr = vAuras.begin(); itr != vAuras.end(); ++itr)
2137         {
2138             SpellEntry const *spellInfo = (*itr).second->GetSpellProto();
2139             if( (spellInfo->AttributesEx3 & 0x40000) && spellInfo->SpellFamilyName == SPELLFAMILY_PALADIN &&
2140                 ((*itr).second->GetCasterGUID() == GetGUID() && (!spellCasted || spellCasted->Id == 35395)) )
2141             {
2142                 (*itr).second->SetAuraDuration((*itr).second->GetAuraMaxDuration());
2143                 (*itr).second->SendAuraUpdate(false);
2144             }
2145         }
2146     }
2147
2148     CastMeleeProcDamageAndSpell(pVictim, (*damage - *absorbDamage - *resistDamage - *blocked_amount), damageSchoolMask, attType, outcome, spellCasted, isTriggeredSpell);
2149
2150     // victim's damage shield
2151     // yet another hack to fix crashes related to the aura getting removed during iteration
2152     std::set<Aura*> alreadyDone;
2153     uint32 removedAuras = pVictim->m_removedAuras;
2154     AuraList const& vDamageShields = pVictim->GetAurasByType(SPELL_AURA_DAMAGE_SHIELD);
2155     for(AuraList::const_iterator i = vDamageShields.begin(), next = vDamageShields.begin(); i != vDamageShields.end(); i = next)
2156     {
2157         ++next;
2158         if (alreadyDone.find(*i) == alreadyDone.end())
2159         {
2160             alreadyDone.insert(*i);
2161             pVictim->SpellNonMeleeDamageLog(this, (*i)->GetId(), (*i)->GetModifier()->m_amount, false, false);
2162             if (pVictim->m_removedAuras > removedAuras)
2163             {
2164                 removedAuras = pVictim->m_removedAuras;
2165                 next = vDamageShields.begin();
2166             }
2167         }
2168     }
2169 }
2170
2171 void Unit::AttackerStateUpdate (Unit *pVictim, WeaponAttackType attType, bool extra )
2172 {
2173     if(hasUnitState(UNIT_STAT_CONFUSED | UNIT_STAT_STUNNED | UNIT_STAT_FLEEING) || HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED) )
2174         return;
2175
2176     if (!pVictim->isAlive())
2177         return;
2178
2179     if(IsNonMeleeSpellCasted(false))
2180         return;
2181
2182     uint32 hitInfo;
2183     if (attType == BASE_ATTACK)
2184         hitInfo = HITINFO_NORMALSWING2;
2185     else if (attType == OFF_ATTACK)
2186         hitInfo = HITINFO_LEFTSWING;
2187     else
2188         return;                                             // ignore ranged case
2189
2190     uint32 extraAttacks = m_extraAttacks;
2191
2192     // melee attack spell casted at main hand attack only
2193     if (attType == BASE_ATTACK && m_currentSpells[CURRENT_MELEE_SPELL])
2194     {
2195         m_currentSpells[CURRENT_MELEE_SPELL]->cast();
2196
2197         // not recent extra attack only at any non extra attack (melee spell case)
2198         if(!extra && extraAttacks)
2199         {
2200             while(m_extraAttacks)
2201             {
2202                 AttackerStateUpdate(pVictim, BASE_ATTACK, true);
2203                 if(m_extraAttacks > 0)
2204                     --m_extraAttacks;
2205             }
2206         }
2207
2208         return;
2209     }
2210
2211     VictimState victimState = VICTIMSTATE_NORMAL;
2212
2213     CleanDamage cleanDamage = CleanDamage(0, BASE_ATTACK, MELEE_HIT_NORMAL );
2214     uint32   blocked_dmg = 0;
2215     uint32   absorbed_dmg = 0;
2216     uint32   resisted_dmg = 0;
2217
2218     SpellSchoolMask meleeSchoolMask = GetMeleeDamageSchoolMask();
2219
2220     if(pVictim->IsImmunedToDamage(meleeSchoolMask,true))    // use charges
2221     {
2222         SendAttackStateUpdate (HITINFO_NORMALSWING, pVictim, 1, meleeSchoolMask, 0, 0, 0, VICTIMSTATE_IS_IMMUNE, 0);
2223
2224         // not recent extra attack only at any non extra attack (miss case)
2225         if(!extra && extraAttacks)
2226         {
2227             while(m_extraAttacks)
2228             {
2229                 AttackerStateUpdate(pVictim, BASE_ATTACK, true);
2230                 if(m_extraAttacks > 0)
2231                     --m_extraAttacks;
2232             }
2233         }
2234
2235         return;
2236     }
2237
2238     uint32 damage = CalculateDamage (attType, false);
2239
2240     DoAttackDamage (pVictim, &damage, &cleanDamage, &blocked_dmg, meleeSchoolMask, &hitInfo, &victimState, &absorbed_dmg, &resisted_dmg, attType);
2241
2242     if (hitInfo & HITINFO_MISS)
2243         //send miss
2244         SendAttackStateUpdate (hitInfo, pVictim, 1, meleeSchoolMask, damage, absorbed_dmg, resisted_dmg, victimState, blocked_dmg);
2245     else
2246     {
2247         //do animation
2248         SendAttackStateUpdate (hitInfo, pVictim, 1, meleeSchoolMask, damage, absorbed_dmg, resisted_dmg, victimState, blocked_dmg);
2249
2250         if (damage > (absorbed_dmg + resisted_dmg + blocked_dmg))
2251             damage -= (absorbed_dmg + resisted_dmg + blocked_dmg);
2252         else
2253             damage = 0;
2254
2255         DealDamage (pVictim, damage, &cleanDamage, DIRECT_DAMAGE, meleeSchoolMask, NULL, true);
2256
2257         if(GetTypeId() == TYPEID_PLAYER && pVictim->isAlive())
2258         {
2259             for(int i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; i++)
2260                 ((Player*)this)->CastItemCombatSpell(((Player*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0,i),pVictim,attType);
2261         }
2262     }
2263
2264     if (GetTypeId() == TYPEID_PLAYER)
2265         DEBUG_LOG("AttackerStateUpdate: (Player) %u attacked %u (TypeId: %u) for %u dmg, absorbed %u, blocked %u, resisted %u.",
2266             GetGUIDLow(), pVictim->GetGUIDLow(), pVictim->GetTypeId(), damage, absorbed_dmg, blocked_dmg, resisted_dmg);
2267     else
2268         DEBUG_LOG("AttackerStateUpdate: (NPC)    %u attacked %u (TypeId: %u) for %u dmg, absorbed %u, blocked %u, resisted %u.",
2269             GetGUIDLow(), pVictim->GetGUIDLow(), pVictim->GetTypeId(), damage, absorbed_dmg, blocked_dmg, resisted_dmg);
2270
2271     // extra attack only at any non extra attack (normal case)
2272     if(!extra && extraAttacks)
2273     {
2274         while(m_extraAttacks)
2275         {
2276             AttackerStateUpdate(pVictim, BASE_ATTACK, true);
2277             if(m_extraAttacks > 0)
2278                 --m_extraAttacks;
2279         }
2280     }
2281 }
2282
2283 MeleeHitOutcome Unit::RollPhysicalOutcomeAgainst (Unit const *pVictim, WeaponAttackType attType, SpellEntry const *spellInfo)
2284 {
2285     // Miss chance based on melee
2286     float miss_chance = MeleeMissChanceCalc(pVictim, attType);
2287
2288     // Critical hit chance
2289     float crit_chance = GetUnitCriticalChance(attType, pVictim);
2290     // this is to avoid compiler issue when declaring variables inside if
2291     float block_chance, parry_chance, dodge_chance;
2292
2293     // cannot be dodged/parried/blocked
2294     if(spellInfo->Attributes & SPELL_ATTR_IMPOSSIBLE_DODGE_PARRY_BLOCK)
2295     {
2296         block_chance = 0.0f;
2297         parry_chance = 0.0f;
2298         dodge_chance = 0.0f;
2299     }
2300     else
2301     {
2302         // parry can be avoided only by some abilities
2303         parry_chance = pVictim->GetUnitParryChance();
2304         // block might be bypassed by it as well
2305         block_chance = pVictim->GetUnitBlockChance();
2306         // stunned target cannot dodge and this is check in GetUnitDodgeChance()
2307         dodge_chance = pVictim->GetUnitDodgeChance();
2308     }
2309
2310     // Only players can have Talent&Spell bonuses
2311     if (GetTypeId() == TYPEID_PLAYER)
2312     {
2313         // Increase from SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL aura
2314         crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, spellInfo->SchoolMask);
2315
2316         if( dodge_chance != 0.0f )                          // if dodge chance is already 0, ignore talents for speed
2317         {
2318             AuraList const& mCanNotBeDodge = GetAurasByType(SPELL_AURA_IGNORE_COMBAT_RESULT);
2319             for(AuraList::const_iterator i = mCanNotBeDodge.begin(); i != mCanNotBeDodge.end(); ++i)
2320             {
2321                 // can't be dodged rogue finishing move
2322                 if((*i)->GetModifier()->m_miscvalue == VICTIMSTATE_DODGE)
2323                 {
2324                     if(spellInfo->SpellFamilyName==SPELLFAMILY_ROGUE && (spellInfo->SpellFamilyFlags & SPELLFAMILYFLAG_ROGUE__FINISHING_MOVE))
2325                     {
2326                         dodge_chance = 0.0f;
2327                         break;
2328                     }
2329                 }
2330             }
2331         }
2332     }
2333
2334     // Spellmods
2335     if(Player* modOwner = GetSpellModOwner())
2336         modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CRITICAL_CHANCE, crit_chance);
2337
2338     DEBUG_LOG("PHYSICAL OUTCOME: miss %f crit %f dodge %f parry %f block %f",miss_chance,crit_chance,dodge_chance,parry_chance, block_chance);
2339
2340     return RollMeleeOutcomeAgainst(pVictim, attType, int32(crit_chance*100), int32(miss_chance*100),int32(dodge_chance*100),int32(parry_chance*100),int32(block_chance*100), true);
2341 }
2342
2343 MeleeHitOutcome Unit::RollMeleeOutcomeAgainst(const Unit *pVictim, WeaponAttackType attType) const
2344 {
2345     // This is only wrapper
2346
2347     // Miss chance based on melee
2348     float miss_chance = MeleeMissChanceCalc(pVictim, attType);
2349
2350     // Critical hit chance
2351     float crit_chance = GetUnitCriticalChance(attType, pVictim);
2352
2353     // stunned target cannot dodge and this is check in GetUnitDodgeChance() (returned 0 in this case)
2354     float dodge_chance = pVictim->GetUnitDodgeChance();
2355     float block_chance = pVictim->GetUnitBlockChance();
2356     float parry_chance = pVictim->GetUnitParryChance();
2357
2358     // Useful if want to specify crit & miss chances for melee, else it could be removed
2359     DEBUG_LOG("MELEE OUTCOME: miss %f crit %f dodge %f parry %f block %f", miss_chance,crit_chance,dodge_chance,parry_chance,block_chance);
2360
2361     return RollMeleeOutcomeAgainst(pVictim, attType, int32(crit_chance*100), int32(miss_chance*100), int32(dodge_chance*100),int32(parry_chance*100),int32(block_chance*100), false);
2362 }
2363
2364 MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim, WeaponAttackType attType, int32 crit_chance, int32 miss_chance, int32 dodge_chance, int32 parry_chance, int32 block_chance, bool SpellCasted ) const
2365 {
2366     if(pVictim->GetTypeId()==TYPEID_UNIT && ((Creature*)pVictim)->IsInEvadeMode())
2367         return MELEE_HIT_EVADE;
2368
2369     int32 attackerMaxSkillValueForLevel = GetMaxSkillValueForLevel(pVictim);
2370     int32 victimMaxSkillValueForLevel = pVictim->GetMaxSkillValueForLevel(this);
2371
2372     int32 attackerWeaponSkill = GetWeaponSkillValue(attType,pVictim);
2373     int32 victimDefenseSkill = pVictim->GetDefenseSkillValue(this);
2374
2375     // bonus from skills is 0.04%
2376     int32    skillBonus  = 4 * ( attackerWeaponSkill - victimMaxSkillValueForLevel );
2377     int32    skillBonus2 = 4 * ( attackerMaxSkillValueForLevel - victimDefenseSkill );
2378     int32    sum = 0, tmp = 0;
2379     int32    roll = urand (0, 10000);
2380
2381     DEBUG_LOG ("RollMeleeOutcomeAgainst: skill bonus of %d for attacker", skillBonus);
2382     DEBUG_LOG ("RollMeleeOutcomeAgainst: rolled %d, miss %d, dodge %d, parry %d, block %d, crit %d",
2383         roll, miss_chance, dodge_chance, parry_chance, block_chance, crit_chance);
2384
2385     tmp = miss_chance;
2386
2387     if (tmp > 0 && roll < (sum += tmp ))
2388     {
2389         DEBUG_LOG ("RollMeleeOutcomeAgainst: MISS");
2390         return MELEE_HIT_MISS;
2391     }
2392
2393     // always crit against a sitting target (except 0 crit chance)
2394     if( pVictim->GetTypeId() == TYPEID_PLAYER && crit_chance > 0 && !pVictim->IsStandState() )
2395     {
2396         DEBUG_LOG ("RollMeleeOutcomeAgainst: CRIT (sitting victim)");
2397         return MELEE_HIT_CRIT;
2398     }
2399
2400     // Dodge chance
2401
2402     // only players can't dodge if attacker is behind
2403     if (pVictim->GetTypeId() == TYPEID_PLAYER && !pVictim->HasInArc(M_PI,this))
2404     {
2405         DEBUG_LOG ("RollMeleeOutcomeAgainst: attack came from behind and victim was a player.");
2406     }
2407     else
2408     {
2409         // Reduce dodge chance by attacker expertise rating
2410         if (GetTypeId() == TYPEID_PLAYER)
2411             dodge_chance -= int32(((Player*)this)->GetExpertiseDodgeOrParryReduction(attType)*100);
2412
2413         // Modify dodge chance by attacker SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
2414         dodge_chance+= GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE);
2415
2416         tmp = dodge_chance;
2417         if (   (tmp > 0)                                        // check if unit _can_ dodge
2418             && ((tmp -= skillBonus) > 0)
2419             && roll < (sum += tmp))
2420         {
2421             DEBUG_LOG ("RollMeleeOutcomeAgainst: DODGE <%d, %d)", sum-tmp, sum);
2422             return MELEE_HIT_DODGE;
2423         }
2424     }
2425
2426     // parry & block chances
2427
2428     // check if attack comes from behind, nobody can parry or block if attacker is behind
2429     if (!pVictim->HasInArc(M_PI,this))
2430     {
2431         DEBUG_LOG ("RollMeleeOutcomeAgainst: attack came from behind.");
2432     }
2433     else
2434     {
2435         // Reduce parry chance by attacker expertise rating
2436         if (GetTypeId() == TYPEID_PLAYER)
2437             parry_chance-= int32(((Player*)this)->GetExpertiseDodgeOrParryReduction(attType)*100);
2438
2439         if(pVictim->GetTypeId()==TYPEID_PLAYER || !(((Creature*)pVictim)->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_PARRY) )
2440         {
2441             int32 tmp = int32(parry_chance);
2442             if (   (tmp > 0)                                    // check if unit _can_ parry
2443                 && ((tmp -= skillBonus) > 0)
2444                 && (roll < (sum += tmp)))
2445             {
2446                 DEBUG_LOG ("RollMeleeOutcomeAgainst: PARRY <%d, %d)", sum-tmp, sum);
2447                 return MELEE_HIT_PARRY;
2448             }
2449         }
2450
2451         if(pVictim->GetTypeId()==TYPEID_PLAYER || !(((Creature*)pVictim)->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK) )
2452         {
2453             tmp = block_chance;
2454             if (   (tmp > 0)                                    // check if unit _can_ block
2455                 && ((tmp -= skillBonus) > 0)
2456                 && (roll < (sum += tmp)))
2457             {
2458                 // Critical chance
2459                 tmp = crit_chance + skillBonus2;
2460                 if ( GetTypeId() == TYPEID_PLAYER && SpellCasted && tmp > 0 )
2461                 {
2462                     if ( roll_chance_i(tmp/100))
2463                     {
2464                         DEBUG_LOG ("RollMeleeOutcomeAgainst: BLOCKED CRIT");
2465                         return MELEE_HIT_BLOCK_CRIT;
2466                     }
2467                 }
2468                 DEBUG_LOG ("RollMeleeOutcomeAgainst: BLOCK <%d, %d)", sum-tmp, sum);
2469                 return MELEE_HIT_BLOCK;
2470             }
2471         }
2472     }
2473
2474     // Critical chance
2475     tmp = crit_chance + skillBonus2;
2476
2477     if (tmp > 0 && roll < (sum += tmp))
2478     {
2479         DEBUG_LOG ("RollMeleeOutcomeAgainst: CRIT <%d, %d)", sum-tmp, sum);
2480         return MELEE_HIT_CRIT;
2481     }
2482
2483     // Max 40% chance to score a glancing blow against mobs that are higher level (can do only players and pets and not with ranged weapon)
2484     if( attType != RANGED_ATTACK && !SpellCasted &&
2485         (GetTypeId() == TYPEID_PLAYER || ((Creature*)this)->isPet()) &&
2486         pVictim->GetTypeId() != TYPEID_PLAYER && !((Creature*)pVictim)->isPet() &&
2487         getLevel() < pVictim->getLevelForTarget(this) )
2488     {
2489         // cap possible value (with bonuses > max skill)
2490         int32 skill = attackerWeaponSkill;
2491         int32 maxskill = attackerMaxSkillValueForLevel;
2492         skill = (skill > maxskill) ? maxskill : skill;
2493
2494         tmp = (10 + (victimDefenseSkill - skill)) * 100;
2495         tmp = tmp > 4000 ? 4000 : tmp;
2496         if (roll < (sum += tmp))
2497         {
2498             DEBUG_LOG ("RollMeleeOutcomeAgainst: GLANCING <%d, %d)", sum-4000, sum);
2499             return MELEE_HIT_GLANCING;
2500         }
2501     }
2502
2503     if(GetTypeId()!=TYPEID_PLAYER && !(((Creature*)this)->GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NO_CRUSH) && !((Creature*)this)->isPet() )
2504     {
2505         // mobs can score crushing blows if they're 3 or more levels above victim
2506         // or when their weapon skill is 15 or more above victim's defense skill
2507         tmp = victimDefenseSkill;
2508         int32 tmpmax = victimMaxSkillValueForLevel;
2509         // having defense above your maximum (from items, talents etc.) has no effect
2510         tmp = tmp > tmpmax ? tmpmax : tmp;
2511         // tmp = mob's level * 5 - player's current defense skill
2512         tmp = attackerMaxSkillValueForLevel - tmp;
2513         if(tmp >= 15)
2514         {
2515             // add 2% chance per lacking skill point, min. is 15%
2516             tmp = tmp * 200 - 1500;
2517             if (roll < (sum += tmp))
2518             {
2519                 DEBUG_LOG ("RollMeleeOutcomeAgainst: CRUSHING <%d, %d)", sum-tmp, sum);
2520                 return MELEE_HIT_CRUSHING;
2521             }
2522         }
2523     }
2524
2525     DEBUG_LOG ("RollMeleeOutcomeAgainst: NORMAL");
2526     return MELEE_HIT_NORMAL;
2527 }
2528
2529 uint32 Unit::CalculateDamage (WeaponAttackType attType, bool normalized)
2530 {
2531     float min_damage, max_damage;
2532
2533     if (normalized && GetTypeId()==TYPEID_PLAYER)
2534         ((Player*)this)->CalculateMinMaxDamage(attType,normalized,min_damage, max_damage);
2535     else
2536     {
2537         switch (attType)
2538         {
2539             case RANGED_ATTACK:
2540                 min_damage = GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE);
2541                 max_damage = GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE);
2542                 break;
2543             case BASE_ATTACK:
2544                 min_damage = GetFloatValue(UNIT_FIELD_MINDAMAGE);
2545                 max_damage = GetFloatValue(UNIT_FIELD_MAXDAMAGE);
2546                 break;
2547             case OFF_ATTACK:
2548                 min_damage = GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE);
2549                 max_damage = GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE);
2550                 break;
2551                 // Just for good manner
2552             default:
2553                 min_damage = 0.0f;
2554                 max_damage = 0.0f;
2555                 break;
2556         }
2557     }
2558
2559     if (min_damage > max_damage)
2560     {
2561         std::swap(min_damage,max_damage);
2562     }
2563
2564     if(max_damage == 0.0f)
2565         max_damage = 5.0f;
2566
2567     return urand((uint32)min_damage, (uint32)max_damage);
2568 }
2569
2570 float Unit::CalculateLevelPenalty(SpellEntry const* spellProto) const
2571 {
2572     if(spellProto->spellLevel <= 0)
2573         return 1.0f;
2574
2575     float LvlPenalty = 0.0f;
2576
2577     if(spellProto->spellLevel < 20)
2578         LvlPenalty = 20.0f - spellProto->spellLevel * 3.75f;
2579     float LvlFactor = (float(spellProto->spellLevel) + 6.0f) / float(getLevel());
2580     if(LvlFactor > 1.0f)
2581         LvlFactor = 1.0f;
2582
2583     return (100.0f - LvlPenalty) * LvlFactor / 100.0f;
2584 }
2585
2586 void Unit::SendAttackStart(Unit* pVictim)
2587 {
2588     WorldPacket data( SMSG_ATTACKSTART, 16 );
2589     data << uint64(GetGUID());
2590     data << uint64(pVictim->GetGUID());
2591
2592     SendMessageToSet(&data, true);
2593     DEBUG_LOG( "WORLD: Sent SMSG_ATTACKSTART" );
2594 }
2595
2596 void Unit::SendAttackStop(Unit* victim)
2597 {
2598     if(!victim)
2599         return;
2600
2601     WorldPacket data( SMSG_ATTACKSTOP, (4+16) );            // we guess size
2602     data.append(GetPackGUID());
2603     data.append(victim->GetPackGUID());                     // can be 0x00...
2604     data << uint32(0);                                      // can be 0x1
2605     SendMessageToSet(&data, true);
2606     sLog.outDetail("%s %u stopped attacking %s %u", (GetTypeId()==TYPEID_PLAYER ? "player" : "creature"), GetGUIDLow(), (victim->GetTypeId()==TYPEID_PLAYER ? "player" : "creature"),victim->GetGUIDLow());
2607
2608     /*if(victim->GetTypeId() == TYPEID_UNIT)
2609     ((Creature*)victim)->AI().EnterEvadeMode(this);*/
2610 }
2611
2612 /*
2613 // Melee based spells can be miss, parry or dodge on this step
2614 // Crit or block - determined on damage calculation phase! (and can be both in some time)
2615 float Unit::MeleeSpellMissChance(Unit *pVictim, WeaponAttackType attType, int32 skillDiff, SpellEntry const *spell)
2616 {
2617     // Calculate hit chance (more correct for chance mod)
2618     int32 HitChance;
2619
2620     // PvP - PvE melee chances
2621     int32 lchance = pVictim->GetTypeId() == TYPEID_PLAYER ? 5 : 7;
2622     int32 leveldif = pVictim->getLevelForTarget(this) - getLevelForTarget(pVictim);
2623     if(leveldif < 3)
2624         HitChance = 95 - leveldif;
2625     else
2626         HitChance = 93 - (leveldif - 2) * lchance;
2627
2628     // Hit chance depends from victim auras
2629     if(attType == RANGED_ATTACK)
2630         HitChance += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
2631     else
2632         HitChance += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
2633
2634     // Spellmod from SPELLMOD_RESIST_MISS_CHANCE
2635     if(Player *modOwner = GetSpellModOwner())
2636         modOwner->ApplySpellMod(spell->Id, SPELLMOD_RESIST_MISS_CHANCE, HitChance);
2637
2638     // Miss = 100 - hit
2639     float miss_chance= 100.0f - HitChance;
2640
2641     // Bonuses from attacker aura and ratings
2642     if (attType == RANGED_ATTACK)
2643         miss_chance -= m_modRangedHitChance;
2644     else
2645         miss_chance -= m_modMeleeHitChance;
2646
2647     // bonus from skills is 0.04%
2648     miss_chance -= skillDiff * 0.04f;
2649
2650     // Limit miss chance from 0 to 60%
2651     if (miss_chance < 0.0f)
2652         return 0.0f;
2653     if (miss_chance > 60.0f)
2654         return 60.0f;
2655     return miss_chance;
2656 }
2657
2658 // Melee based spells hit result calculations
2659 SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
2660 {
2661     WeaponAttackType attType = BASE_ATTACK;
2662
2663     if (spell->DmgClass == SPELL_DAMAGE_CLASS_RANGED)
2664         attType = RANGED_ATTACK;
2665
2666     // bonus from skills is 0.04% per skill Diff
2667     int32 attackerWeaponSkill = int32(GetWeaponSkillValue(attType,pVictim));
2668     int32 skillDiff = attackerWeaponSkill - int32(pVictim->GetMaxSkillValueForLevel(this));
2669     int32 fullSkillDiff = attackerWeaponSkill - int32(pVictim->GetDefenseSkillValue(this));
2670
2671     uint32 roll = urand (0, 10000);
2672     uint32 missChance = uint32(MeleeSpellMissChance(pVictim, attType, fullSkillDiff, spell)*100.0f);
2673
2674     // Roll miss
2675     uint32 tmp = missChance;
2676     if (roll < tmp)
2677         return SPELL_MISS_MISS;
2678
2679     // Same spells cannot be parry/dodge
2680     if (spell->Attributes & SPELL_ATTR_IMPOSSIBLE_DODGE_PARRY_BLOCK)
2681         return SPELL_MISS_NONE;
2682
2683     // Ranged attack can`t miss too
2684     if (attType == RANGED_ATTACK)
2685         return SPELL_MISS_NONE;
2686
2687     bool attackFromBehind = !pVictim->HasInArc(M_PI,this);
2688
2689     // Roll dodge
2690     int32 dodgeChance = int32(pVictim->GetUnitDodgeChance()*100.0f) - skillDiff * 4;
2691     // Reduce enemy dodge chance by SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
2692     dodgeChance+= GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE);
2693
2694     // Reduce dodge chance by attacker expertise rating
2695     if (GetTypeId() == TYPEID_PLAYER)
2696         dodgeChance-=int32(((Player*)this)->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
2697     if (dodgeChance < 0)
2698         dodgeChance = 0;
2699
2700     // Can`t dodge from behind in PvP (but its possible in PvE)
2701     if (GetTypeId() == TYPEID_PLAYER && pVictim->GetTypeId() == TYPEID_PLAYER && attackFromBehind)
2702         dodgeChance = 0;
2703
2704     // Rogue talent`s cant be dodged
2705     AuraList const& mCanNotBeDodge = GetAurasByType(SPELL_AURA_IGNORE_COMBAT_RESULT);
2706     for(AuraList::const_iterator i = mCanNotBeDodge.begin(); i != mCanNotBeDodge.end(); ++i)
2707     {
2708         if((*i)->GetModifier()->m_miscvalue == VICTIMSTATE_DODGE)       // can't be dodged rogue finishing move
2709         {
2710             if(spell->SpellFamilyName==SPELLFAMILY_ROGUE && (spell->SpellFamilyFlags & SPELLFAMILYFLAG_ROGUE__FINISHING_MOVE))
2711             {
2712                 dodgeChance = 0;
2713                 break;
2714             }
2715         }
2716     }
2717
2718     tmp += dodgeChance;
2719     if (roll < tmp)
2720         return SPELL_MISS_DODGE;
2721
2722     // Roll parry
2723     int32 parryChance = int32(pVictim->GetUnitParryChance()*100.0f)  - skillDiff * 4;
2724     // Reduce parry chance by attacker expertise rating
2725     if (GetTypeId() == TYPEID_PLAYER)
2726         parryChance-=int32(((Player*)this)->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
2727     // Can`t parry from behind
2728     if (parryChance < 0 || attackFromBehind)
2729         parryChance = 0;
2730
2731     tmp += parryChance;
2732     if (roll < tmp)
2733         return SPELL_MISS_PARRY;
2734
2735     return SPELL_MISS_NONE;
2736 }*/
2737
2738 // TODO need use unit spell resistances in calculations
2739 SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
2740 {
2741     // Can`t miss on dead target (on skinning for example)
2742     if (!pVictim->isAlive())
2743         return SPELL_MISS_NONE;
2744
2745     SpellSchoolMask schoolMask = GetSpellSchoolMask(spell);
2746     // PvP - PvE spell misschances per leveldif > 2
2747     int32 lchance = pVictim->GetTypeId() == TYPEID_PLAYER ? 7 : 11;
2748     int32 leveldif = int32(pVictim->getLevelForTarget(this)) - int32(getLevelForTarget(pVictim));
2749
2750     // Base hit chance from attacker and victim levels
2751     int32 modHitChance;
2752     if(leveldif < 3)
2753         modHitChance = 96 - leveldif;
2754     else
2755         modHitChance = 94 - (leveldif - 2) * lchance;
2756
2757     // Spellmod from SPELLMOD_RESIST_MISS_CHANCE
2758     if(Player *modOwner = GetSpellModOwner())
2759         modOwner->ApplySpellMod(spell->Id, SPELLMOD_RESIST_MISS_CHANCE, modHitChance);
2760     // Increase from attacker SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT auras
2761     modHitChance+=GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT, schoolMask);
2762     // Chance hit from victim SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE auras
2763     modHitChance+= pVictim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE, schoolMask);
2764     // Reduce spell hit chance for Area of effect spells from victim SPELL_AURA_MOD_AOE_AVOIDANCE aura
2765     if (IsAreaOfEffectSpell(spell))
2766         modHitChance-=pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_AOE_AVOIDANCE);
2767     // Reduce spell hit chance for dispel mechanic spells from victim SPELL_AURA_MOD_DISPEL_RESIST
2768     if (IsDispelSpell(spell))
2769         modHitChance-=pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_DISPEL_RESIST);
2770     // Chance resist mechanic (select max value from every mechanic spell effect)
2771     int32 resist_mech = 0;
2772     // Get effects mechanic and chance
2773     for(int eff = 0; eff < 3; ++eff)
2774     {
2775         int32 effect_mech = GetEffectMechanic(spell, eff);
2776         if (effect_mech)
2777         {
2778             int32 temp = pVictim->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
2779             if (resist_mech < temp)
2780                 resist_mech = temp;
2781         }
2782     }
2783     // Apply mod
2784     modHitChance-=resist_mech;
2785
2786     // Chance resist debuff
2787     modHitChance-=pVictim->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel));
2788
2789     int32 HitChance = modHitChance * 100;
2790     // Increase hit chance from attacker SPELL_AURA_MOD_SPELL_HIT_CHANCE and attacker ratings
2791     HitChance += int32(m_modSpellHitChance*100.0f);
2792
2793     // Decrease hit chance from victim rating bonus
2794     if (pVictim->GetTypeId()==TYPEID_PLAYER)
2795         HitChance -= int32(((Player*)pVictim)->GetRatingBonusValue(CR_HIT_TAKEN_SPELL)*100.0f);
2796
2797     if (HitChance <  100) HitChance =  100;
2798     if (HitChance > 9900) HitChance = 9900;
2799
2800     uint32 rand = urand(0,10000);
2801     if (rand > HitChance)
2802         return SPELL_MISS_RESIST;
2803     return SPELL_MISS_NONE;
2804 }
2805
2806 SpellMissInfo Unit::SpellHitResult(Unit *pVictim, SpellEntry const *spell, bool CanReflect)
2807 {
2808     // Return evade for units in evade mode
2809     if (pVictim->GetTypeId()==TYPEID_UNIT && ((Creature*)pVictim)->IsInEvadeMode())
2810         return SPELL_MISS_EVADE;
2811
2812     // Check for immune (use charges)
2813     if (pVictim->IsImmunedToSpell(spell,true))
2814         return SPELL_MISS_IMMUNE;
2815
2816     // All positive spells can`t miss
2817     // TODO: client not show miss log for this spells - so need find info for this in dbc and use it!
2818     if (IsPositiveSpell(spell->Id))
2819         return SPELL_MISS_NONE;
2820
2821     // Check for immune (use charges)
2822     if (pVictim->IsImmunedToDamage(GetSpellSchoolMask(spell),true))
2823         return SPELL_MISS_IMMUNE;
2824
2825     // Try victim reflect spell
2826     if (CanReflect)
2827     {
2828         // specialized first
2829         Unit::AuraList const& mReflectSpellsSchool = pVictim->GetAurasByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
2830         for(Unit::AuraList::const_iterator i = mReflectSpellsSchool.begin(); i != mReflectSpellsSchool.end(); ++i)
2831         {
2832             if((*i)->GetModifier()->m_miscvalue & GetSpellSchoolMask(spell))
2833             {
2834                 int32 reflectchance = (*i)->GetModifier()->m_amount;
2835                 if (reflectchance > 0 && roll_chance_i(reflectchance))
2836                 {
2837                     if((*i)->m_procCharges > 0)
2838                     {
2839                         --(*i)->m_procCharges;
2840                         if((*i)->m_procCharges==0)
2841                             pVictim->RemoveAurasDueToSpell((*i)->GetId());
2842                     }
2843                     return SPELL_MISS_REFLECT;
2844                 }
2845             }
2846         }
2847
2848         // generic reflection
2849         Unit::AuraList const& mReflectSpells = pVictim->GetAurasByType(SPELL_AURA_REFLECT_SPELLS);
2850         for(Unit::AuraList::const_iterator i = mReflectSpells.begin(); i != mReflectSpells.end(); ++i)
2851         {
2852             int32 reflectchance = (*i)->GetModifier()->m_amount;
2853             if (reflectchance > 0 && roll_chance_i(reflectchance))
2854             {
2855                 if((*i)->m_procCharges > 0)
2856                 {
2857                     --(*i)->m_procCharges;
2858                     if((*i)->m_procCharges==0)
2859                         pVictim->RemoveAurasDueToSpell((*i)->GetId());
2860                 }
2861                 return SPELL_MISS_REFLECT;
2862             }
2863         }
2864     }
2865
2866     // Temporary solution for melee based spells and spells vs SPELL_SCHOOL_NORMAL (hit result calculated after)
2867     for (int i=0;i<3;i++)
2868     {
2869         if (spell->Effect[i] == SPELL_EFFECT_WEAPON_DAMAGE ||
2870             spell->Effect[i] == SPELL_EFFECT_WEAPON_PERCENT_DAMAGE ||
2871             spell->Effect[i] == SPELL_EFFECT_NORMALIZED_WEAPON_DMG ||
2872             spell->Effect[i] == SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL)
2873             return SPELL_MISS_NONE;
2874     }
2875
2876     // TODO need use this code for spell hit result calculation
2877     // now code commented for computability
2878     switch (spell->DmgClass)
2879     {
2880         case SPELL_DAMAGE_CLASS_RANGED:
2881         case SPELL_DAMAGE_CLASS_MELEE:
2882 //             return MeleeSpellHitResult(pVictim, spell);
2883             return SPELL_MISS_NONE;
2884         case SPELL_DAMAGE_CLASS_NONE:
2885         case SPELL_DAMAGE_CLASS_MAGIC:
2886             return MagicSpellHitResult(pVictim, spell);
2887     }
2888     return SPELL_MISS_NONE;
2889 }
2890
2891 float Unit::MeleeMissChanceCalc(const Unit *pVictim, WeaponAttackType attType) const
2892 {
2893     if(!pVictim)
2894         return 0.0f;
2895
2896     // Base misschance 5%
2897     float misschance = 5.0f;
2898
2899     // DualWield - Melee spells and physical dmg spells - 5% , white damage 24%
2900     if (haveOffhandWeapon() && attType != RANGED_ATTACK)
2901     {
2902         bool isNormal = false;
2903         for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
2904         {
2905             if( m_currentSpells[i] && (GetSpellSchoolMask(m_currentSpells[i]->m_spellInfo) & SPELL_SCHOOL_MASK_NORMAL) )
2906             {
2907                 isNormal = true;
2908                 break;
2909             }
2910         }
2911         if (isNormal || m_currentSpells[CURRENT_MELEE_SPELL])
2912         {
2913             misschance = 5.0f;
2914         }
2915         else
2916         {
2917             misschance = 24.0f;
2918         }
2919     }
2920
2921     // PvP : PvE melee misschances per leveldif > 2
2922     int32 chance = pVictim->GetTypeId() == TYPEID_PLAYER ? 5 : 7;
2923
2924     int32 leveldif = int32(pVictim->getLevelForTarget(this)) - int32(getLevelForTarget(pVictim));
2925     if(leveldif < 0)
2926         leveldif = 0;
2927
2928     // Hit chance from attacker based on ratings and auras
2929     float m_modHitChance;
2930     if (attType == RANGED_ATTACK)
2931         m_modHitChance = m_modRangedHitChance;
2932     else
2933         m_modHitChance = m_modMeleeHitChance;
2934
2935     if(leveldif < 3)
2936         misschance += (leveldif - m_modHitChance);
2937     else
2938         misschance += ((leveldif - 2) * chance - m_modHitChance);
2939
2940     // Hit chance for victim based on ratings
2941     if (pVictim->GetTypeId()==TYPEID_PLAYER)
2942     {
2943         if (attType == RANGED_ATTACK)
2944             misschance += ((Player*)pVictim)->GetRatingBonusValue(CR_HIT_TAKEN_RANGED);
2945         else
2946             misschance += ((Player*)pVictim)->GetRatingBonusValue(CR_HIT_TAKEN_MELEE);
2947     }
2948
2949     // Modify miss chance by victim auras
2950     if(attType == RANGED_ATTACK)
2951         misschance -= pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
2952     else
2953         misschance -= pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
2954
2955     // Modify miss chance from skill difference ( bonus from skills is 0.04% )
2956     int32 skillBonus = int32(GetWeaponSkillValue(attType,pVictim)) - int32(pVictim->GetDefenseSkillValue(this));
2957     misschance -= skillBonus * 0.04f;
2958
2959     // Limit miss chance from 0 to 60%
2960     if ( misschance < 0.0f)
2961         return 0.0f;
2962     if ( misschance > 60.0f)
2963         return 60.0f;
2964
2965     return misschance;
2966 }
2967
2968 uint32 Unit::GetDefenseSkillValue(Unit const* target) const
2969 {
2970     if(GetTypeId() == TYPEID_PLAYER)
2971     {
2972         // in PvP use full skill instead current skill value
2973         uint32 value = (target && target->GetTypeId() == TYPEID_PLAYER)
2974             ? ((Player*)this)->GetMaxSkillValue(SKILL_DEFENSE)
2975             : ((Player*)this)->GetSkillValue(SKILL_DEFENSE);
2976         value += uint32(((Player*)this)->GetRatingBonusValue(CR_DEFENSE_SKILL));
2977         return value;
2978     }
2979     else
2980         return GetUnitMeleeSkill(target);
2981 }
2982
2983 float Unit::GetUnitDodgeChance() const
2984 {
2985     if(hasUnitState(UNIT_STAT_STUNNED))
2986         return 0.0f;
2987     if( GetTypeId() == TYPEID_PLAYER )
2988         return GetFloatValue(PLAYER_DODGE_PERCENTAGE);
2989     else
2990     {
2991         if(((Creature const*)this)->isTotem())
2992             return 0.0f;
2993         else
2994         {
2995             float dodge = 5.0f;
2996             dodge += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT);
2997             return dodge > 0.0f ? dodge : 0.0f;
2998         }
2999     }
3000 }
3001
3002 float Unit::GetUnitParryChance() const
3003 {
3004     if ( IsNonMeleeSpellCasted(false) || hasUnitState(UNIT_STAT_STUNNED))
3005         return 0.0f;
3006
3007     float chance = 0.0f;
3008
3009     if(GetTypeId() == TYPEID_PLAYER)
3010     {
3011         Player const* player = (Player const*)this;
3012         if(player->CanParry() )
3013         {
3014             Item *tmpitem = player->GetWeaponForAttack(BASE_ATTACK,true);
3015             if(!tmpitem)
3016                 tmpitem = player->GetWeaponForAttack(OFF_ATTACK,true);
3017
3018             if(tmpitem)
3019                 chance = GetFloatValue(PLAYER_PARRY_PERCENTAGE);
3020         }
3021     }
3022     else if(GetTypeId() == TYPEID_UNIT)
3023     {
3024         if(GetCreatureType() == CREATURE_TYPE_HUMANOID)
3025         {
3026             chance = 5.0f;
3027             chance += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT);
3028         }
3029     }
3030
3031     return chance > 0.0f ? chance : 0.0f;
3032 }
3033
3034 float Unit::GetUnitBlockChance() const
3035 {
3036     if ( IsNonMeleeSpellCasted(false) || hasUnitState(UNIT_STAT_STUNNED))
3037         return 0.0f;
3038
3039     if(GetTypeId() == TYPEID_PLAYER)
3040     {
3041         Player const* player = (Player const*)this;
3042         if(player->CanBlock() )
3043         {
3044             Item *tmpitem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
3045             if(tmpitem && !tmpitem->IsBroken() && tmpitem->GetProto()->Block)
3046                 return GetFloatValue(PLAYER_BLOCK_PERCENTAGE);
3047         }
3048         // is player but has no block ability or no not broken shield equipped
3049         return 0.0f;
3050     }
3051     else
3052     {
3053         if(((Creature const*)this)->isTotem())
3054             return 0.0f;
3055         else
3056         {
3057             float block = 5.0f;
3058             block += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT);
3059             return block > 0.0f ? block : 0.0f;
3060         }
3061     }
3062 }
3063
3064 float Unit::GetUnitCriticalChance(WeaponAttackType attackType, const Unit *pVictim) const
3065 {
3066     float crit;
3067
3068     if(GetTypeId() == TYPEID_PLAYER)
3069     {
3070         switch(attackType)
3071         {
3072             case BASE_ATTACK:
3073                 crit = GetFloatValue( PLAYER_CRIT_PERCENTAGE );
3074                 break;
3075             case OFF_ATTACK:
3076                 crit = GetFloatValue( PLAYER_OFFHAND_CRIT_PERCENTAGE );
3077                 break;
3078             case RANGED_ATTACK:
3079                 crit = GetFloatValue( PLAYER_RANGED_CRIT_PERCENTAGE );
3080                 break;
3081                 // Just for good manner
3082             default:
3083                 crit = 0.0f;
3084                 break;
3085         }
3086     }
3087     else
3088     {
3089         crit = 5.0f;
3090         crit += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_PERCENT);
3091     }
3092
3093     // flat aura mods
3094     if(attackType == RANGED_ATTACK)
3095         crit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
3096     else
3097         crit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
3098
3099     crit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
3100
3101     // reduce crit chance from Rating for players
3102     if (pVictim->GetTypeId()==TYPEID_PLAYER)
3103     {
3104         if (attackType==RANGED_ATTACK)
3105             crit -= ((Player*)pVictim)->GetRatingBonusValue(CR_CRIT_TAKEN_RANGED);
3106         else
3107             crit -= ((Player*)pVictim)->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE);
3108     }
3109
3110     if (crit < 0.0f)
3111         crit = 0.0f;
3112     return crit;
3113 }
3114
3115 uint32 Unit::GetWeaponSkillValue (WeaponAttackType attType, Unit const* target) const
3116 {
3117     uint32 value = 0;
3118     if(GetTypeId() == TYPEID_PLAYER)
3119     {
3120         Item* item = ((Player*)this)->GetWeaponForAttack(attType,true);
3121
3122         // feral or unarmed skill only for base attack
3123         if(attType != BASE_ATTACK && !item )
3124             return 0;
3125
3126         if(((Player*)this)->IsInFeralForm())
3127             return GetMaxSkillValueForLevel();              // always maximized SKILL_FERAL_COMBAT in fact
3128
3129         // weapon skill or (unarmed for base attack)
3130         uint32  skill = item ? item->GetSkill() : SKILL_UNARMED;
3131
3132         // in PvP use full skill instead current skill value
3133         value = (target && target->GetTypeId() == TYPEID_PLAYER)
3134             ? ((Player*)this)->GetMaxSkillValue(skill)
3135             : ((Player*)this)->GetSkillValue(skill);
3136         // Modify value from ratings
3137         value += uint32(((Player*)this)->GetRatingBonusValue(CR_WEAPON_SKILL));
3138         switch (attType)
3139         {
3140             case BASE_ATTACK:   value+=uint32(((Player*)this)->GetRatingBonusValue(CR_WEAPON_SKILL_MAINHAND));break;
3141             case OFF_ATTACK:    value+=uint32(((Player*)this)->GetRatingBonusValue(CR_WEAPON_SKILL_OFFHAND));break;
3142             case RANGED_ATTACK: value+=uint32(((Player*)this)->GetRatingBonusValue(CR_WEAPON_SKILL_RANGED));break;
3143         }
3144     }
3145     else
3146         value = GetUnitMeleeSkill(target);
3147    return value;
3148 }
3149
3150 void Unit::_UpdateSpells( uint32 time )
3151 {
3152     if(m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
3153         _UpdateAutoRepeatSpell();
3154
3155     // remove finished spells from current pointers
3156     for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
3157     {
3158         if (m_currentSpells[i] && m_currentSpells[i]->getState() == SPELL_STATE_FINISHED)
3159         {
3160             m_currentSpells[i]->SetReferencedFromCurrent(false);
3161             m_currentSpells[i] = NULL;                      // remove pointer
3162         }
3163     }
3164
3165     // TODO: Find a better way to prevent crash when multiple auras are removed.
3166     m_removedAuras = 0;
3167     for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
3168         if ((*i).second)
3169             (*i).second->SetUpdated(false);
3170
3171     for (AuraMap::iterator i = m_Auras.begin(), next; i != m_Auras.end(); i = next)
3172     {
3173         next = i;
3174         ++next;
3175         if ((*i).second)
3176         {
3177             // prevent double update
3178             if ((*i).second->IsUpdated())
3179                 continue;
3180             (*i).second->SetUpdated(true);
3181             (*i).second->Update( time );
3182             // several auras can be deleted due to update
3183             if (m_removedAuras)
3184             {
3185                 if (m_Auras.empty()) break;
3186                 next = m_Auras.begin();
3187                 m_removedAuras = 0;
3188             }
3189         }
3190     }
3191
3192     for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end();)
3193     {
3194         if ((*i).second)
3195         {
3196             if ( !(*i).second->GetAuraDuration() && !((*i).second->IsPermanent() || ((*i).second->IsPassive())) )
3197             {
3198                 RemoveAura(i);
3199             }
3200             else
3201             {
3202                 ++i;
3203             }
3204         }
3205         else
3206         {
3207             ++i;
3208         }
3209     }
3210
3211     if(!m_gameObj.empty())
3212     {
3213         std::list<GameObject*>::iterator ite1, dnext1;
3214         for (ite1 = m_gameObj.begin(); ite1 != m_gameObj.end(); ite1 = dnext1)
3215         {
3216             dnext1 = ite1;
3217             //(*i)->Update( difftime );
3218             if( !(*ite1)->isSpawned() )
3219             {
3220                 (*ite1)->SetOwnerGUID(0);
3221                 (*ite1)->SetRespawnTime(0);
3222                 (*ite1)->Delete();
3223                 dnext1 = m_gameObj.erase(ite1);
3224             }
3225             else
3226                 ++dnext1;
3227         }
3228     }
3229 }
3230
3231 void Unit::_UpdateAutoRepeatSpell()
3232 {
3233     //check "realtime" interrupts
3234     if ( (GetTypeId() == TYPEID_PLAYER && ((Player*)this)->isMoving()) || IsNonMeleeSpellCasted(false,false,true) )
3235     {
3236         // cancel wand shoot
3237         if(m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Category == 351)
3238             InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
3239         m_AutoRepeatFirstCast = true;
3240         return;
3241     }
3242
3243     //apply delay
3244     if ( m_AutoRepeatFirstCast && getAttackTimer(RANGED_ATTACK) < 500 )
3245         setAttackTimer(RANGED_ATTACK,500);
3246     m_AutoRepeatFirstCast = false;
3247
3248     //castroutine
3249     if (isAttackReady(RANGED_ATTACK))
3250     {
3251         // Check if able to cast
3252         if(m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->CanCast(true))
3253         {
3254             InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
3255             return;
3256         }
3257
3258         // we want to shoot
3259         Spell* spell = new Spell(this, m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo, true, 0);
3260         spell->prepare(&(m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_targets));
3261
3262         // all went good, reset attack
3263         resetAttackTimer(RANGED_ATTACK);
3264     }
3265 }
3266
3267 void Unit::SetCurrentCastedSpell( Spell * pSpell )
3268 {
3269     assert(pSpell);                                         // NULL may be never passed here, use InterruptSpell or InterruptNonMeleeSpells
3270
3271     uint32 CSpellType = pSpell->GetCurrentContainer();
3272
3273     if (pSpell == m_currentSpells[CSpellType]) return;      // avoid breaking self
3274
3275     // break same type spell if it is not delayed
3276     InterruptSpell(CSpellType,false);
3277
3278     // special breakage effects:
3279     switch (CSpellType)
3280     {
3281         case CURRENT_GENERIC_SPELL:
3282         {
3283             // generic spells always break channeled not delayed spells
3284             InterruptSpell(CURRENT_CHANNELED_SPELL,false);
3285
3286             // autorepeat breaking
3287             if ( m_currentSpells[CURRENT_AUTOREPEAT_SPELL] )
3288             {
3289                 // break autorepeat if not Auto Shot
3290                 if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Category == 351)
3291                     InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
3292                 m_AutoRepeatFirstCast = true;
3293             }
3294         } break;
3295
3296         case CURRENT_CHANNELED_SPELL:
3297         {
3298             // channel spells always break generic non-delayed and any channeled spells
3299             InterruptSpell(CURRENT_GENERIC_SPELL,false);
3300             InterruptSpell(CURRENT_CHANNELED_SPELL);
3301
3302             // it also does break autorepeat if not Auto Shot
3303             if ( m_currentSpells[CURRENT_AUTOREPEAT_SPELL] &&
3304                 m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Category == 351 )
3305                 InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
3306         } break;
3307
3308         case CURRENT_AUTOREPEAT_SPELL:
3309         {
3310             // only Auto Shoot does not break anything
3311             if (pSpell->m_spellInfo->Category == 351)
3312             {
3313                 // generic autorepeats break generic non-delayed and channeled non-delayed spells
3314                 InterruptSpell(CURRENT_GENERIC_SPELL,false);
3315                 InterruptSpell(CURRENT_CHANNELED_SPELL,false);
3316             }
3317             // special action: set first cast flag
3318             m_AutoRepeatFirstCast = true;
3319         } break;
3320
3321         default:
3322         {
3323             // other spell types don't break anything now
3324         } break;
3325     }
3326
3327     // current spell (if it is still here) may be safely deleted now
3328     if (m_currentSpells[CSpellType])
3329         m_currentSpells[CSpellType]->SetReferencedFromCurrent(false);
3330
3331     // set new current spell
3332     m_currentSpells[CSpellType] = pSpell;
3333     pSpell->SetReferencedFromCurrent(true);
3334 }
3335
3336 void Unit::InterruptSpell(uint32 spellType, bool withDelayed)
3337 {
3338     assert(spellType < CURRENT_MAX_SPELL);
3339
3340     if(m_currentSpells[spellType] && (withDelayed || m_currentSpells[spellType]->getState() != SPELL_STATE_DELAYED) )
3341     {
3342         // send autorepeat cancel message for autorepeat spells
3343         if (spellType == CURRENT_AUTOREPEAT_SPELL)
3344         {
3345             if(GetTypeId()==TYPEID_PLAYER)
3346                 ((Player*)this)->SendAutoRepeatCancel();
3347         }
3348
3349         if (m_currentSpells[spellType]->getState() != SPELL_STATE_FINISHED)
3350             m_currentSpells[spellType]->cancel();
3351         m_currentSpells[spellType]->SetReferencedFromCurrent(false);
3352         m_currentSpells[spellType] = NULL;
3353     }
3354 }
3355
3356 bool Unit::IsNonMeleeSpellCasted(bool withDelayed, bool skipChanneled, bool skipAutorepeat) const
3357 {
3358     // We don't do loop here to explicitly show that melee spell is excluded.
3359     // Maybe later some special spells will be excluded too.
3360
3361     // generic spells are casted when they are not finished and not delayed
3362     if ( m_currentSpells[CURRENT_GENERIC_SPELL] &&
3363         (m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_FINISHED) &&
3364         (withDelayed || m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_DELAYED) )
3365         return(true);
3366
3367     // channeled spells may be delayed, but they are still considered casted
3368     else if ( !skipChanneled && m_currentSpells[CURRENT_CHANNELED_SPELL] &&
3369         (m_currentSpells[CURRENT_CHANNELED_SPELL]->getState() != SPELL_STATE_FINISHED) )
3370         return(true);
3371
3372     // autorepeat spells may be finished or delayed, but they are still considered casted
3373     else if ( !skipAutorepeat && m_currentSpells[CURRENT_AUTOREPEAT_SPELL] )
3374         return(true);
3375
3376     return(false);
3377 }
3378
3379 void Unit::InterruptNonMeleeSpells(bool withDelayed, uint32 spell_id)
3380 {
3381     // generic spells are interrupted if they are not finished or delayed
3382     if (m_currentSpells[CURRENT_GENERIC_SPELL] && (!spell_id || m_currentSpells[CURRENT_GENERIC_SPELL]->m_spellInfo->Id==spell_id))
3383     {
3384         if  ( (m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_FINISHED) &&
3385             (withDelayed || m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_DELAYED) )
3386             m_currentSpells[CURRENT_GENERIC_SPELL]->cancel();
3387         m_currentSpells[CURRENT_GENERIC_SPELL]->SetReferencedFromCurrent(false);
3388         m_currentSpells[CURRENT_GENERIC_SPELL] = NULL;
3389     }
3390
3391     // autorepeat spells are interrupted if they are not finished or delayed
3392     if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL] && (!spell_id || m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id==spell_id))
3393     {
3394         // send disable autorepeat packet in any case
3395         if(GetTypeId()==TYPEID_PLAYER)
3396             ((Player*)this)->SendAutoRepeatCancel();
3397
3398         if ( (m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->getState() != SPELL_STATE_FINISHED) &&
3399             (withDelayed || m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->getState() != SPELL_STATE_DELAYED) )
3400             m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->cancel();
3401         m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->SetReferencedFromCurrent(false);
3402         m_currentSpells[CURRENT_AUTOREPEAT_SPELL] = NULL;
3403     }
3404
3405     // channeled spells are interrupted if they are not finished, even if they are delayed
3406     if (m_currentSpells[CURRENT_CHANNELED_SPELL] && (!spell_id || m_currentSpells[CURRENT_CHANNELED_SPELL]->m_spellInfo->Id==spell_id))
3407     {
3408         if (m_currentSpells[CURRENT_CHANNELED_SPELL]->getState() != SPELL_STATE_FINISHED)
3409             m_currentSpells[CURRENT_CHANNELED_SPELL]->cancel();
3410         m_currentSpells[CURRENT_CHANNELED_SPELL]->SetReferencedFromCurrent(false);
3411         m_currentSpells[CURRENT_CHANNELED_SPELL] = NULL;
3412     }
3413 }
3414
3415 Spell* Unit::FindCurrentSpellBySpellId(uint32 spell_id) const
3416 {
3417     for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
3418         if(m_currentSpells[i] && m_currentSpells[i]->m_spellInfo->Id==spell_id)
3419             return m_currentSpells[i];
3420     return NULL;
3421 }
3422
3423 bool Unit::isInFront(Unit const* target, float distance,  float arc) const
3424 {
3425     return IsWithinDistInMap(target, distance) && HasInArc( arc, target );
3426 }
3427
3428 void Unit::SetInFront(Unit const* target)
3429 {
3430     SetOrientation(GetAngle(target));
3431 }
3432
3433 bool Unit::isInBack(Unit const* target, float distance, float arc) const
3434 {
3435     return IsWithinDistInMap(target, distance) && !HasInArc( 2 * M_PI - arc, target );
3436 }
3437
3438 bool Unit::isInAccessablePlaceFor(Creature const* c) const
3439 {
3440     if(IsInWater())
3441         return c->canSwim();
3442     else
3443         return c->canWalk() || c->canFly();
3444 }
3445
3446 bool Unit::IsInWater() const
3447 {
3448     return MapManager::Instance().GetBaseMap(GetMapId())->IsInWater(GetPositionX(),GetPositionY(), GetPositionZ());
3449 }
3450
3451 bool Unit::IsUnderWater() const
3452 {
3453     return MapManager::Instance().GetBaseMap(GetMapId())->IsUnderWater(GetPositionX(),GetPositionY(),GetPositionZ());
3454 }
3455
3456 void Unit::DeMorph()
3457 {
3458     SetDisplayId(GetNativeDisplayId());
3459 }
3460
3461 int32 Unit::GetTotalAuraModifier(AuraType auratype) const
3462 {
3463     int32 modifier = 0;
3464
3465     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3466     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3467         modifier += (*i)->GetModifier()->m_amount;
3468
3469     return modifier;
3470 }
3471
3472 float Unit::GetTotalAuraMultiplier(AuraType auratype) const
3473 {
3474     float multiplier = 1.0f;
3475
3476     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3477     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3478         multiplier *= (100.0f + (*i)->GetModifier()->m_amount)/100.0f;
3479
3480     return multiplier;
3481 }
3482
3483 int32 Unit::GetMaxPositiveAuraModifier(AuraType auratype) const
3484 {
3485     int32 modifier = 0;
3486
3487     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3488     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3489         if ((*i)->GetModifier()->m_amount > modifier)
3490             modifier = (*i)->GetModifier()->m_amount;
3491
3492     return modifier;
3493 }
3494
3495 int32 Unit::GetMaxNegativeAuraModifier(AuraType auratype) const
3496 {
3497     int32 modifier = 0;
3498
3499     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3500     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3501         if ((*i)->GetModifier()->m_amount < modifier)
3502             modifier = (*i)->GetModifier()->m_amount;
3503
3504     return modifier;
3505 }
3506
3507 int32 Unit::GetTotalAuraModifierByMiscMask(AuraType auratype, uint32 misc_mask) const
3508 {
3509     int32 modifier = 0;
3510
3511     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3512     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3513     {
3514         Modifier* mod = (*i)->GetModifier();
3515         if (mod->m_miscvalue & misc_mask)
3516             modifier += mod->m_amount;
3517     }
3518     return modifier;
3519 }
3520
3521 float Unit::GetTotalAuraMultiplierByMiscMask(AuraType auratype, uint32 misc_mask) const
3522 {
3523     float multiplier = 1.0f;
3524
3525     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3526     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3527     {
3528         Modifier* mod = (*i)->GetModifier();
3529         if (mod->m_miscvalue & misc_mask)
3530             multiplier *= (100.0f + mod->m_amount)/100.0f;
3531     }
3532     return multiplier;
3533 }
3534
3535 int32 Unit::GetMaxPositiveAuraModifierByMiscMask(AuraType auratype, uint32 misc_mask) const
3536 {
3537     int32 modifier = 0;
3538
3539     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3540     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3541     {
3542         Modifier* mod = (*i)->GetModifier();
3543         if (mod->m_miscvalue & misc_mask && mod->m_amount > modifier)
3544             modifier = mod->m_amount;
3545     }
3546
3547     return modifier;
3548 }
3549
3550 int32 Unit::GetMaxNegativeAuraModifierByMiscMask(AuraType auratype, uint32 misc_mask) const
3551 {
3552     int32 modifier = 0;
3553
3554     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3555     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3556     {
3557         Modifier* mod = (*i)->GetModifier();
3558         if (mod->m_miscvalue & misc_mask && mod->m_amount < modifier)
3559             modifier = mod->m_amount;
3560     }
3561
3562     return modifier;
3563 }
3564
3565 int32 Unit::GetTotalAuraModifierByMiscValue(AuraType auratype, int32 misc_value) const
3566 {
3567     int32 modifier = 0;
3568
3569     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3570     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3571     {
3572         Modifier* mod = (*i)->GetModifier();
3573         if (mod->m_miscvalue == misc_value)
3574             modifier += mod->m_amount;
3575     }
3576     return modifier;
3577 }
3578
3579 float Unit::GetTotalAuraMultiplierByMiscValue(AuraType auratype, int32 misc_value) const
3580 {
3581     float multiplier = 1.0f;
3582
3583     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3584     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3585     {
3586         Modifier* mod = (*i)->GetModifier();
3587         if (mod->m_miscvalue == misc_value)
3588             multiplier *= (100.0f + mod->m_amount)/100.0f;
3589     }
3590     return multiplier;
3591 }
3592
3593 int32 Unit::GetMaxPositiveAuraModifierByMiscValue(AuraType auratype, int32 misc_value) const
3594 {
3595     int32 modifier = 0;
3596
3597     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3598     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3599     {
3600         Modifier* mod = (*i)->GetModifier();
3601         if (mod->m_miscvalue == misc_value && mod->m_amount > modifier)
3602             modifier = mod->m_amount;
3603     }
3604
3605     return modifier;
3606 }
3607
3608 int32 Unit::GetMaxNegativeAuraModifierByMiscValue(AuraType auratype, int32 misc_value) const
3609 {
3610     int32 modifier = 0;
3611
3612     AuraList const& mTotalAuraList = GetAurasByType(auratype);
3613     for(AuraList::const_iterator i = mTotalAuraList.begin();i != mTotalAuraList.end(); ++i)
3614     {
3615         Modifier* mod = (*i)->GetModifier();
3616         if (mod->m_miscvalue == misc_value && mod->m_amount < modifier)
3617             modifier = mod->m_amount;
3618     }
3619
3620     return modifier;
3621 }
3622
3623 bool Unit::AddAura(Aura *Aur)
3624 {
3625     // ghost spell check, allow apply any auras at player loading in ghost mode (will be cleanup after load)
3626     if( !isAlive() && Aur->GetId() != 20584 && Aur->GetId() != 8326 && Aur->GetId() != 2584 &&
3627         (GetTypeId()!=TYPEID_PLAYER || !((Player*)this)->GetSession()->PlayerLoading()) )
3628     {
3629         delete Aur;
3630         return false;
3631     }
3632
3633     if(Aur->GetTarget() != this)
3634     {
3635         sLog.outError("Aura (spell %u eff %u) add to aura list of %s (lowguid: %u) but Aura target is %s (lowguid: %u)",
3636             Aur->GetId(),Aur->GetEffIndex(),(GetTypeId()==TYPEID_PLAYER?"player":"creature"),GetGUIDLow(),
3637             (Aur->GetTarget()->GetTypeId()==TYPEID_PLAYER?"player":"creature"),Aur->GetTarget()->GetGUIDLow());
3638         delete Aur;
3639         return false;
3640     }
3641
3642     SpellEntry const* aurSpellInfo = Aur->GetSpellProto();
3643
3644     spellEffectPair spair = spellEffectPair(Aur->GetId(), Aur->GetEffIndex());
3645     AuraMap::iterator i = m_Auras.find( spair );
3646
3647     // take out same spell
3648     if (i != m_Auras.end())
3649     {
3650         // passive and persistent auras can stack with themselves any number of times
3651         if (!Aur->IsPassive() && !Aur->IsPersistent())
3652         {
3653             // replace aura if next will > spell StackAmount
3654             if(aurSpellInfo->StackAmount)
3655             {
3656                 if(m_Auras.count(spair) >= aurSpellInfo->StackAmount)
3657                     RemoveAura(i,AURA_REMOVE_BY_STACK);
3658             }
3659             // if StackAmount==0 not allow auras from same caster
3660             else
3661             {
3662                 for(AuraMap::iterator i2 = m_Auras.lower_bound(spair); i2 != m_Auras.upper_bound(spair); ++i2)
3663                 {
3664                     if(i2->second->GetCasterGUID()==Aur->GetCasterGUID())
3665                     {
3666                         // can be only single (this check done at _each_ aura add
3667                         RemoveAura(i2,AURA_REMOVE_BY_STACK);
3668                         break;
3669                     }
3670
3671                     bool stop = false;
3672                     switch(aurSpellInfo->EffectApplyAuraName[Aur->GetEffIndex()])
3673                     {
3674                         // DoT/HoT/etc
3675                         case SPELL_AURA_PERIODIC_DAMAGE:    // allow stack
3676                         case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
3677                         case SPELL_AURA_PERIODIC_LEECH:
3678                         case SPELL_AURA_PERIODIC_HEAL:
3679                         case SPELL_AURA_OBS_MOD_HEALTH:
3680                         case SPELL_AURA_PERIODIC_MANA_LEECH:
3681                         case SPELL_AURA_PERIODIC_ENERGIZE:
3682                         case SPELL_AURA_OBS_MOD_MANA:
3683                         case SPELL_AURA_POWER_BURN_MANA:
3684                             break;
3685                         default:                            // not allow
3686                             // can be only single (this check done at _each_ aura add
3687                             RemoveAura(i2,AURA_REMOVE_BY_STACK);
3688                             stop = true;
3689                             break;
3690                     }
3691
3692                     if(stop)
3693                         break;
3694                 }
3695             }
3696         }
3697     }
3698
3699     // passive auras stack with all (except passive spell proc auras)
3700     if ((!Aur->IsPassive() || !IsPassiveStackableSpell(Aur->GetId())) &&
3701         !(Aur->GetId() == 20584 || Aur->GetId() == 8326))
3702     {
3703         if (!RemoveNoStackAurasDueToAura(Aur))
3704         {
3705             delete Aur;
3706             return false;                                   // couldn't remove conflicting aura with higher rank
3707         }
3708     }
3709
3710     // update single target auras list (before aura add to aura list, to prevent unexpected remove recently added aura)
3711     if (IsSingleTargetSpell(aurSpellInfo) && Aur->GetTarget())
3712     {
3713         // caster pointer can be deleted in time aura remove, find it by guid at each iteration
3714         for(;;)
3715         {
3716             Unit* caster = Aur->GetCaster();
3717             if(!caster)                                     // caster deleted and not required adding scAura
3718                 break;
3719
3720             bool restart = false;
3721             AuraList& scAuras = caster->GetSingleCastAuras();
3722             for(AuraList::iterator itr = scAuras.begin(); itr != scAuras.end(); ++itr)
3723             {
3724                 if( (*itr)->GetTarget() != Aur->GetTarget() &&
3725                     IsSingleTargetSpells((*itr)->GetSpellProto(),aurSpellInfo) )
3726                 {
3727                     if ((*itr)->IsInUse())
3728                     {
3729                         sLog.outError("Aura (Spell %u Effect %u) is in process but attempt removed at aura (Spell %u Effect %u) adding, need add stack rule for IsSingleTargetSpell", (*itr)->GetId(), (*itr)->GetEffIndex(),Aur->GetId(), Aur->GetEffIndex());
3730                         continue;
3731                     }
3732                     (*itr)->GetTarget()->RemoveAura((*itr)->GetId(), (*itr)->GetEffIndex());
3733                     restart = true;
3734                     break;
3735                 }
3736             }
3737
3738             if(!restart)
3739             {
3740                 // done
3741                 scAuras.push_back(Aur);
3742                 break;
3743             }
3744         }
3745     }
3746
3747     // add aura, register in lists and arrays
3748     Aur->_AddAura();
3749     m_Auras.insert(AuraMap::value_type(spellEffectPair(Aur->GetId(), Aur->GetEffIndex()), Aur));
3750     if (Aur->GetModifier()->m_auraname < TOTAL_AURAS)
3751     {
3752         m_modAuras[Aur->GetModifier()->m_auraname].push_back(Aur);
3753     }
3754
3755     Aur->ApplyModifier(true,true);
3756     sLog.outDebug("Aura %u now is in use", Aur->GetModifier()->m_auraname);
3757     return true;
3758 }
3759
3760 void Unit::RemoveRankAurasDueToSpell(uint32 spellId)
3761 {
3762     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
3763     if(!spellInfo)
3764         return;
3765     AuraMap::iterator i,next;
3766     for (i = m_Auras.begin(); i != m_Auras.end(); i = next)
3767     {
3768         next = i;
3769         ++next;
3770         uint32 i_spellId = (*i).second->GetId();
3771         if((*i).second && i_spellId && i_spellId != spellId)
3772         {
3773             if(spellmgr.IsRankSpellDueToSpell(spellInfo,i_spellId))
3774             {
3775                 RemoveAurasDueToSpell(i_spellId);
3776
3777                 if( m_Auras.empty() )
3778                     break;
3779                 else
3780                     next =  m_Auras.begin();
3781             }
3782         }
3783     }
3784 }
3785
3786 bool Unit::RemoveNoStackAurasDueToAura(Aura *Aur)
3787 {
3788     if (!Aur)
3789         return false;
3790
3791     SpellEntry const* spellProto = Aur->GetSpellProto();
3792     if (!spellProto)
3793         return false;
3794
3795     uint32 spellId = Aur->GetId();
3796     uint32 effIndex = Aur->GetEffIndex();
3797
3798     SpellSpecific spellId_spec = GetSpellSpecific(spellId);
3799
3800     AuraMap::iterator i,next;
3801     for (i = m_Auras.begin(); i != m_Auras.end(); i = next)
3802     {
3803         next = i;
3804         ++next;
3805         if (!(*i).second) continue;
3806
3807         SpellEntry const* i_spellProto = (*i).second->GetSpellProto();
3808
3809         if (!i_spellProto)
3810             continue;
3811
3812         uint32 i_spellId = i_spellProto->Id;
3813
3814         if(IsPassiveSpell(i_spellId))
3815         {
3816             if(IsPassiveStackableSpell(i_spellId))
3817                 continue;
3818
3819             // passive non-stackable spells not stackable only with another rank of same spell
3820             if (!spellmgr.IsRankSpellDueToSpell(spellProto, i_spellId))
3821                 continue;
3822         }
3823
3824         uint32 i_effIndex = (*i).second->GetEffIndex();
3825
3826         if(i_spellId == spellId) continue;
3827
3828         bool is_triggered_by_spell = false;
3829         // prevent triggered aura of removing aura that triggered it
3830         for(int j = 0; j < 3; ++j)
3831             if (i_spellProto->EffectTriggerSpell[j] == spellProto->Id)
3832                 is_triggered_by_spell = true;
3833         if (is_triggered_by_spell) continue;
3834
3835         for(int j = 0; j < 3; ++j)
3836         {
3837             // prevent remove dummy triggered spells at next effect aura add
3838             switch(spellProto->Effect[j])                   // main spell auras added added after triggered spell
3839             {
3840                 case SPELL_EFFECT_DUMMY:
3841                     switch(spellId)
3842                     {
3843                         case 5420: if(i_spellId==34123) is_triggered_by_spell = true; break;
3844                     }
3845                     break;
3846             }
3847
3848             if(is_triggered_by_spell)
3849                 break;
3850
3851             // prevent remove form main spell by triggered passive spells
3852             switch(i_spellProto->EffectApplyAuraName[j])    // main aura added before triggered spell
3853             {
3854                 case SPELL_AURA_MOD_SHAPESHIFT:
3855                     switch(i_spellId)
3856                     {
3857                         case 24858: if(spellId==24905)                  is_triggered_by_spell = true; break;
3858                         case 33891: if(spellId==5420 || spellId==34123) is_triggered_by_spell = true; break;
3859                         case 34551: if(spellId==22688)                  is_triggered_by_spell = true; break;
3860                     }
3861                     break;
3862             }
3863         }
3864
3865         if(!is_triggered_by_spell)
3866         {
3867             SpellSpecific i_spellId_spec = GetSpellSpecific(i_spellId);
3868
3869             bool is_sspc = IsSingleFromSpellSpecificPerCaster(spellId_spec,i_spellId_spec);
3870
3871             if( is_sspc && Aur->GetCasterGUID() == (*i).second->GetCasterGUID() )
3872             {
3873                 // cannot remove higher rank
3874                 if (spellmgr.IsRankSpellDueToSpell(spellProto, i_spellId))
3875                     if(CompareAuraRanks(spellId, effIndex, i_spellId, i_effIndex) < 0)
3876                         return false;
3877
3878                 // Its a parent aura (create this aura in ApplyModifier)
3879                 if ((*i).second->IsInUse())
3880                 {
3881                     sLog.outError("Aura (Spell %u Effect %u) is in process but attempt removed at aura (Spell %u Effect %u) adding, need add stack rule for Unit::RemoveNoStackAurasDueToAura", i->second->GetId(), i->second->GetEffIndex(),Aur->GetId(), Aur->GetEffIndex());
3882                     continue;
3883                 }
3884                 RemoveAurasDueToSpell(i_spellId);
3885
3886                 if( m_Auras.empty() )
3887                     break;
3888                 else
3889                     next =  m_Auras.begin();
3890             }
3891             else if( !is_sspc && spellmgr.IsNoStackSpellDueToSpell(spellId, i_spellId) )
3892             {
3893                 // Its a parent aura (create this aura in ApplyModifier)
3894                 if ((*i).second->IsInUse())
3895                 {
3896                     sLog.outError("Aura (Spell %u Effect %u) is in process but attempt removed at aura (Spell %u Effect %u) adding, need add stack rule for Unit::RemoveNoStackAurasDueToAura", i->second->GetId(), i->second->GetEffIndex(),Aur->GetId(), Aur->GetEffIndex());
3897                     continue;
3898                 }
3899                 RemoveAurasDueToSpell(i_spellId);
3900
3901                 if( m_Auras.empty() )
3902                     break;
3903                 else
3904                     next =  m_Auras.begin();
3905             }
3906             // Potions stack aura by aura (elixirs/flask already checked)
3907             else if( spellProto->SpellFamilyName == SPELLFAMILY_POTION && i_spellProto->SpellFamilyName == SPELLFAMILY_POTION )
3908             {
3909                 if (IsNoStackAuraDueToAura(spellId, effIndex, i_spellId, i_effIndex))
3910                 {
3911                     if(CompareAuraRanks(spellId, effIndex, i_spellId, i_effIndex) < 0)
3912                         return false;                       // cannot remove higher rank
3913
3914                     // Its a parent aura (create this aura in ApplyModifier)
3915                     if ((*i).second->IsInUse())
3916                     {
3917                         sLog.outError("Aura (Spell %u Effect %u) is in process but attempt removed at aura (Spell %u Effect %u) adding, need add stack rule for Unit::RemoveNoStackAurasDueToAura", i->second->GetId(), i->second->GetEffIndex(),Aur->GetId(), Aur->GetEffIndex());
3918                         continue;
3919                     }
3920                     RemoveAura(i);
3921                     next = i;
3922                 }
3923             }
3924         }
3925     }
3926     return true;
3927 }
3928
3929 void Unit::RemoveAura(uint32 spellId, uint32 effindex, Aura* except)
3930 {
3931     spellEffectPair spair = spellEffectPair(spellId, effindex);
3932     for(AuraMap::iterator iter = m_Auras.lower_bound(spair); iter != m_Auras.upper_bound(spair);)
3933     {
3934         if(iter->second!=except)
3935         {
3936             RemoveAura(iter);
3937             iter = m_Auras.lower_bound(spair);
3938         }
3939         else
3940             ++iter;
3941     }
3942 }
3943
3944 void Unit::RemoveAurasDueToSpellByDispel(uint32 spellId, uint64 casterGUID, Unit *dispeler)
3945 {
3946     for (AuraMap::iterator iter = m_Auras.begin(); iter != m_Auras.end(); )
3947     {
3948         Aura *aur = iter->second;
3949         if (aur->GetId() == spellId && aur->GetCasterGUID() == casterGUID)
3950         {
3951             // Custom dispel case
3952             // Unstable Affliction
3953             if (aur->GetSpellProto()->SpellFamilyName == SPELLFAMILY_WARLOCK && (aur->GetSpellProto()->SpellFamilyFlags & 0x010000000000LL))
3954             {
3955                 int32 damage = aur->GetModifier()->m_amount*9;
3956                 uint64 caster_guid = aur->GetCasterGUID();
3957
3958                 // Remove aura
3959                 RemoveAura(iter, AURA_REMOVE_BY_DISPEL);
3960
3961                 // backfire damage and silence
3962                 dispeler->CastCustomSpell(dispeler, 31117, &damage, NULL, NULL, true, NULL, NULL,caster_guid);
3963
3964                 iter = m_Auras.begin();                     // iterator can be invalidate at cast if self-dispel
3965             }
3966             else
3967                 RemoveAura(iter, AURA_REMOVE_BY_DISPEL);
3968         }
3969         else
3970             ++iter;
3971     }
3972 }
3973
3974 void Unit::RemoveAurasDueToSpellBySteal(uint32 spellId, uint64 casterGUID, Unit *stealer)
3975 {
3976     for (AuraMap::iterator iter = m_Auras.begin(); iter != m_Auras.end(); )
3977     {
3978         Aura *aur = iter->second;
3979         if (aur->GetId() == spellId && aur->GetCasterGUID() == casterGUID)
3980         {
3981             int32 basePoints = aur->GetBasePoints();
3982             // construct the new aura for the attacker
3983             Aura * new_aur = CreateAura(aur->GetSpellProto(), aur->GetEffIndex(), &basePoints, stealer);
3984             if(!new_aur)
3985                 continue;
3986
3987             // set its duration and maximum duration
3988             // max duration 2 minutes (in msecs)
3989             int32 dur = aur->GetAuraDuration();
3990             const int32 max_dur = 2*MINUTE*1000;
3991             new_aur->SetAuraMaxDuration( max_dur > dur ? dur : max_dur );
3992             new_aur->SetAuraDuration( max_dur > dur ? dur : max_dur );
3993
3994             // add the new aura to stealer
3995             stealer->AddAura(new_aur);
3996
3997             // Remove aura as dispel
3998             RemoveAura(iter, AURA_REMOVE_BY_DISPEL);
3999         }
4000         else
4001             ++iter;
4002     }
4003 }
4004
4005 void Unit::RemoveAurasDueToSpellByCancel(uint32 spellId)
4006 {
4007     for (AuraMap::iterator iter = m_Auras.begin(); iter != m_Auras.end(); )
4008     {
4009         if (iter->second->GetId() == spellId)
4010             RemoveAura(iter, AURA_REMOVE_BY_CANCEL);
4011         else
4012             ++iter;
4013     }
4014 }
4015
4016 void Unit::RemoveAurasWithDispelType( DispelType type )
4017 {
4018     // Create dispel mask by dispel type
4019     uint32 dispelMask = GetDispellMask(type);
4020     // Dispel all existing auras vs current dispel type
4021     AuraMap& auras = GetAuras();
4022     for(AuraMap::iterator itr = auras.begin(); itr != auras.end(); )
4023     {
4024         SpellEntry const* spell = itr->second->GetSpellProto();
4025         if( (1<<spell->Dispel) & dispelMask )
4026         {
4027             // Dispel aura
4028             RemoveAurasDueToSpell(spell->Id);
4029             itr = auras.begin();
4030         }
4031         else
4032             ++itr;
4033     }
4034 }
4035
4036 void Unit::RemoveSingleAuraFromStack(uint32 spellId, uint32 effindex)
4037 {
4038     AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, effindex));
4039     if(iter != m_Auras.end())
4040         RemoveAura(iter);
4041 }
4042
4043 void Unit::RemoveAurasDueToSpell(uint32 spellId, Aura* except)
4044 {
4045     for (int i = 0; i < 3; ++i)
4046         RemoveAura(spellId,i,except);
4047 }
4048
4049 void Unit::RemoveAurasDueToItemSpell(Item* castItem,uint32 spellId)
4050 {
4051     for (int k=0; k < 3; ++k)
4052     {
4053         spellEffectPair spair = spellEffectPair(spellId, k);
4054         for (AuraMap::iterator iter = m_Auras.lower_bound(spair); iter != m_Auras.upper_bound(spair);)
4055         {
4056             if (iter->second->GetCastItemGUID() == castItem->GetGUID())
4057             {
4058                 RemoveAura(iter);
4059                 iter = m_Auras.upper_bound(spair);          // overwrite by more appropriate
4060             }
4061             else
4062                 ++iter;
4063         }
4064     }
4065 }
4066
4067 void Unit::RemoveAurasWithInterruptFlags(uint32 flags)
4068 {
4069     for (AuraMap::iterator iter = m_Auras.begin(); iter != m_Auras.end(); )
4070     {
4071         if (iter->second->GetSpellProto()->AuraInterruptFlags & flags)
4072             RemoveAura(iter);
4073         else
4074             ++iter;
4075     }
4076 }
4077
4078 void Unit::RemoveNotOwnSingleTargetAuras()
4079 {
4080     // single target auras from other casters
4081     for (AuraMap::iterator iter = m_Auras.begin(); iter != m_Auras.end(); )
4082     {
4083         if (iter->second->GetCasterGUID()!=GetGUID() && IsSingleTargetSpell(iter->second->GetSpellProto()))
4084             RemoveAura(iter);
4085         else
4086             ++iter;
4087     }
4088
4089     // single target auras at other targets
4090     AuraList& scAuras = GetSingleCastAuras();
4091     for (AuraList::iterator iter = scAuras.begin(); iter != scAuras.end(); )
4092     {
4093         Aura* aura = *iter;
4094         if (aura->GetTarget()!=this)
4095         {
4096             scAuras.erase(iter);                            // explicitly remove, instead waiting remove in RemoveAura
4097             aura->GetTarget()->RemoveAura(aura->GetId(),aura->GetEffIndex());
4098             iter = scAuras.begin();
4099         }
4100         else
4101             ++iter;
4102     }
4103
4104 }
4105
4106 void Unit::RemoveAura(AuraMap::iterator &i, AuraRemoveMode mode)
4107 {
4108     if (IsSingleTargetSpell((*i).second->GetSpellProto()))
4109     {
4110         if(Unit* caster = (*i).second->GetCaster())
4111         {
4112             AuraList& scAuras = caster->GetSingleCastAuras();
4113             scAuras.remove((*i).second);
4114         }
4115         else
4116         {
4117             sLog.outError("Couldn't find the caster of the single target aura, may crash later!");
4118             assert(false);
4119         }
4120     }
4121
4122     if ((*i).second->GetModifier()->m_auraname < TOTAL_AURAS)
4123     {
4124         m_modAuras[(*i).second->GetModifier()->m_auraname].remove((*i).second);
4125     }
4126
4127     // remove from list before mods removing (prevent cyclic calls, mods added before including to aura list - use reverse order)
4128     Aura* Aur = i->second;
4129     // Set remove mode
4130     Aur->SetRemoveMode(mode);
4131     // some ShapeshiftBoosts at remove trigger removing other auras including parent Shapeshift aura
4132     // remove aura from list before to prevent deleting it before
4133     m_Auras.erase(i);
4134     ++m_removedAuras;                                       // internal count used by unit update
4135
4136     // Status unsummoned at aura remove
4137     Totem* statue = NULL;
4138     if(IsChanneledSpell(Aur->GetSpellProto()))
4139         if(Unit* caster = Aur->GetCaster())
4140             if(caster->GetTypeId()==TYPEID_UNIT && ((Creature*)caster)->isTotem() && ((Totem*)caster)->GetTotemType()==TOTEM_STATUE)
4141                 statue = ((Totem*)caster);
4142
4143     sLog.outDebug("Aura %u now is remove mode %d",Aur->GetModifier()->m_auraname, mode);
4144     Aur->ApplyModifier(false,true);
4145     Aur->_RemoveAura();
4146     delete Aur;
4147
4148     if(statue)
4149         statue->UnSummon();
4150
4151     // only way correctly remove all auras from list
4152     if( m_Auras.empty() )
4153         i = m_Auras.end();
4154     else
4155         i = m_Auras.begin();
4156 }
4157
4158 void Unit::RemoveAllAuras()
4159 {
4160     while (!m_Auras.empty())
4161     {
4162         AuraMap::iterator iter = m_Auras.begin();
4163         RemoveAura(iter);
4164     }
4165 }
4166
4167 void Unit::RemoveAllAurasOnDeath()
4168 {
4169     // used just after dieing to remove all visible auras
4170     // and disable the mods for the passive ones
4171     for(AuraMap::iterator iter = m_Auras.begin(); iter != m_Auras.end();)
4172     {
4173         if (!iter->second->IsPassive() && !iter->second->IsDeathPersistent())
4174             RemoveAura(iter, AURA_REMOVE_BY_DEATH);
4175         else
4176             ++iter;
4177     }
4178 }
4179
4180 void Unit::DelayAura(uint32 spellId, uint32 effindex, int32 delaytime)
4181 {
4182     AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, effindex));
4183     if (iter != m_Auras.end())
4184     {
4185         if (iter->second->GetAuraDuration() < delaytime)
4186             iter->second->SetAuraDuration(0);
4187         else
4188             iter->second->SetAuraDuration(iter->second->GetAuraDuration() - delaytime);
4189         iter->second->SendAuraUpdate(false);
4190         sLog.outDebug("Aura %u partially interrupted on unit %u, new duration: %u ms",iter->second->GetModifier()->m_auraname, GetGUIDLow(), iter->second->GetAuraDuration());
4191     }
4192 }
4193
4194 void Unit::_RemoveAllAuraMods()
4195 {
4196     for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
4197     {
4198         (*i).second->ApplyModifier(false);
4199     }
4200 }
4201
4202 void Unit::_ApplyAllAuraMods()
4203 {
4204     for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
4205     {
4206         (*i).second->ApplyModifier(true);
4207     }
4208 }
4209
4210 Aura* Unit::GetAura(uint32 spellId, uint32 effindex)
4211 {
4212     AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, effindex));
4213     if (iter != m_Auras.end())
4214         return iter->second;
4215     return NULL;
4216 }
4217
4218 void Unit::AddDynObject(DynamicObject* dynObj)
4219 {
4220     m_dynObjGUIDs.push_back(dynObj->GetGUID());
4221 }
4222
4223 void Unit::RemoveDynObject(uint32 spellid)
4224 {
4225     if(m_dynObjGUIDs.empty())
4226         return;
4227     for (DynObjectGUIDs::iterator i = m_dynObjGUIDs.begin(); i != m_dynObjGUIDs.end();)
4228     {
4229         DynamicObject* dynObj = ObjectAccessor::GetDynamicObject(*this,*m_dynObjGUIDs.begin());
4230         if(!dynObj)
4231         {
4232             i = m_dynObjGUIDs.erase(i);
4233         }
4234         else if(spellid == 0 || dynObj->GetSpellId() == spellid)
4235         {
4236             dynObj->Delete();
4237             i = m_dynObjGUIDs.erase(i);
4238         }
4239         else
4240             ++i;
4241     }
4242 }
4243
4244 void Unit::RemoveAllDynObjects()
4245 {
4246     while(!m_dynObjGUIDs.empty())
4247     {
4248         DynamicObject* dynObj = ObjectAccessor::GetDynamicObject(*this,*m_dynObjGUIDs.begin());
4249         if(dynObj)
4250             dynObj->Delete();
4251         m_dynObjGUIDs.erase(m_dynObjGUIDs.begin());
4252     }
4253 }
4254
4255 DynamicObject * Unit::GetDynObject(uint32 spellId, uint32 effIndex)
4256 {
4257     for (DynObjectGUIDs::iterator i = m_dynObjGUIDs.begin(); i != m_dynObjGUIDs.end();)
4258     {
4259         DynamicObject* dynObj = ObjectAccessor::GetDynamicObject(*this,*m_dynObjGUIDs.begin());
4260         if(!dynObj)
4261         {
4262             i = m_dynObjGUIDs.erase(i);
4263             continue;
4264         }
4265
4266         if (dynObj->GetSpellId() == spellId && dynObj->GetEffIndex() == effIndex)
4267             return dynObj;
4268         ++i;
4269     }
4270     return NULL;
4271 }
4272
4273 DynamicObject * Unit::GetDynObject(uint32 spellId)
4274 {
4275     for (DynObjectGUIDs::iterator i = m_dynObjGUIDs.begin(); i != m_dynObjGUIDs.end();)
4276     {
4277         DynamicObject* dynObj = ObjectAccessor::GetDynamicObject(*this,*m_dynObjGUIDs.begin());
4278         if(!dynObj)
4279         {
4280             i = m_dynObjGUIDs.erase(i);
4281             continue;
4282         }
4283
4284         if (dynObj->GetSpellId() == spellId)
4285             return dynObj;
4286         ++i;
4287     }
4288     return NULL;
4289 }
4290
4291 void Unit::AddGameObject(GameObject* gameObj)
4292 {
4293     assert(gameObj && gameObj->GetOwnerGUID()==0);
4294     m_gameObj.push_back(gameObj);
4295     gameObj->SetOwnerGUID(GetGUID());
4296 }
4297
4298 void Unit::RemoveGameObject(GameObject* gameObj, bool del)
4299 {
4300     assert(gameObj && gameObj->GetOwnerGUID()==GetGUID());
4301
4302     // GO created by some spell
4303     if ( GetTypeId()==TYPEID_PLAYER && gameObj->GetSpellId() )
4304     {
4305         SpellEntry const* createBySpell = sSpellStore.LookupEntry(gameObj->GetSpellId());
4306         // Need activate spell use for owner
4307         if (createBySpell && createBySpell->Attributes & SPELL_ATTR_DISABLED_WHILE_ACTIVE)
4308             ((Player*)this)->SendCooldownEvent(createBySpell);
4309     }
4310     gameObj->SetOwnerGUID(0);
4311     m_gameObj.remove(gameObj);
4312     if(del)
4313     {
4314         gameObj->SetRespawnTime(0);
4315         gameObj->Delete();
4316     }
4317 }
4318
4319 void Unit::RemoveGameObject(uint32 spellid, bool del)
4320 {
4321     if(m_gameObj.empty())
4322         return;
4323     std::list<GameObject*>::iterator i, next;
4324     for (i = m_gameObj.begin(); i != m_gameObj.end(); i = next)
4325     {
4326         next = i;
4327         if(spellid == 0 || (*i)->GetSpellId() == spellid)
4328         {
4329             (*i)->SetOwnerGUID(0);
4330             if(del)
4331             {
4332                 (*i)->SetRespawnTime(0);
4333                 (*i)->Delete();
4334             }
4335
4336             next = m_gameObj.erase(i);
4337         }
4338         else
4339             ++next;
4340     }
4341 }
4342
4343 void Unit::RemoveAllGameObjects()
4344 {
4345     // remove references to unit
4346     for(std::list<GameObject*>::iterator i = m_gameObj.begin(); i != m_gameObj.end();)
4347     {
4348         (*i)->SetOwnerGUID(0);
4349         (*i)->SetRespawnTime(0);
4350         (*i)->Delete();
4351         i = m_gameObj.erase(i);
4352     }
4353 }
4354
4355 void Unit::SendSpellNonMeleeDamageLog(Unit *target,uint32 SpellID,uint32 Damage, SpellSchoolMask damageSchoolMask,uint32 AbsorbedDamage, uint32 Resist,bool PhysicalDamage, uint32 Blocked, bool CriticalHit)
4356 {
4357     sLog.outDebug("Sending: SMSG_SPELLNONMELEEDAMAGELOG");
4358     WorldPacket data(SMSG_SPELLNONMELEEDAMAGELOG, (16+4+4+1+4+4+1+1+4+4+1)); // we guess size
4359     data.append(target->GetPackGUID());
4360     data.append(GetPackGUID());
4361     data << uint32(SpellID);
4362     data << uint32(Damage-AbsorbedDamage-Resist-Blocked);
4363     data << uint32(0);                                      // wotlk
4364     data << uint8(damageSchoolMask);                        // spell school
4365     data << uint32(AbsorbedDamage);                         // AbsorbedDamage
4366     data << uint32(Resist);                                 // resist
4367     data << uint8(PhysicalDamage);                          // if 1, then client show spell name (example: %s's ranged shot hit %s for %u school or %s suffers %u school damage from %s's spell_name
4368     data << uint8(0);                                       // unk isFromAura
4369     data << uint32(Blocked);                                // blocked
4370     data << uint32(CriticalHit ? 0x27 : 0x25);              // hitType, flags: 0x2 - SPELL_HIT_TYPE_CRIT, 0x10 - replace caster?
4371     data << uint8(0);                                       // isDebug?
4372     SendMessageToSet( &data, true );
4373 }
4374
4375 void Unit::SendSpellMiss(Unit *target, uint32 spellID, SpellMissInfo missInfo)
4376 {
4377     WorldPacket data(SMSG_SPELLLOGMISS, (4+8+1+4+8+1));
4378     data << uint32(spellID);
4379     data << uint64(GetGUID());
4380     data << uint8(0);                                       // can be 0 or 1
4381     data << uint32(1);                                      // target count
4382     // for(i = 0; i < target count; ++i)
4383     data << uint64(target->GetGUID());                      // target GUID
4384     data << uint8(missInfo);
4385     // end loop
4386     SendMessageToSet(&data, true);
4387 }
4388
4389 void Unit::SendAttackStateUpdate(uint32 HitInfo, Unit *target, uint8 SwingType, SpellSchoolMask damageSchoolMask, uint32 Damage, uint32 AbsorbDamage, uint32 Resist, VictimState TargetState, uint32 BlockedAmount)
4390 {
4391     sLog.outDebug("WORLD: Sending SMSG_ATTACKERSTATEUPDATE");
4392
4393     WorldPacket data(SMSG_ATTACKERSTATEUPDATE, (16+45));    // we guess size
4394     data << uint32(HitInfo);                                // flags
4395     data.append(GetPackGUID());
4396     data.append(target->GetPackGUID());
4397     data << uint32(Damage-AbsorbDamage-Resist-BlockedAmount);// damage
4398     data << uint32(0);                                      // overkill value
4399
4400     data << (uint8)SwingType;                               // count?
4401
4402     // for(i = 0; i < SwingType; ++i)
4403     data << (uint32)damageSchoolMask;
4404     data << (float)(Damage-AbsorbDamage-Resist-BlockedAmount);
4405     data << (uint32)(Damage-AbsorbDamage-Resist-BlockedAmount);
4406     // end loop
4407
4408     if(HitInfo & (HITINFO_ABSORB | HITINFO_ABSORB2))
4409     {
4410         // for(i = 0; i < SwingType; ++i)
4411         data << uint32(AbsorbDamage);
4412         // end loop
4413     }
4414
4415     if(HitInfo & (HITINFO_RESIST | HITINFO_RESIST2))
4416     {
4417         // for(i = 0; i < SwingType; ++i)
4418         data << uint32(Resist);
4419         // end loop
4420     }
4421
4422     data << (uint8)TargetState;
4423     data << (uint32)0;
4424     data << (uint32)0;
4425
4426     if(HitInfo & HITINFO_BLOCK)
4427     {
4428         data << uint32(BlockedAmount);
4429     }
4430
4431     if(HitInfo & HITINFO_UNK3)
4432     {
4433         data << uint32(0);
4434     }
4435
4436     if(HitInfo & HITINFO_UNK1)
4437     {
4438         data << uint32(0);
4439         data << float(0);
4440         data << float(0);
4441         data << float(0);
4442         data << float(0);
4443         data << float(0);
4444         data << float(0);
4445         data << float(0);
4446         data << float(0);
4447         for(uint8 i = 0; i < 5; ++i)
4448         {
4449             data << float(0);
4450             data << float(0);
4451         }
4452         data << uint32(0);
4453     }
4454
4455     SendMessageToSet( &data, true );
4456 }
4457
4458 void Unit::ProcDamageAndSpell(Unit *pVictim, uint32 procAttacker, uint32 procVictim, uint32 damage, SpellSchoolMask damageSchoolMask, SpellEntry const *procSpell, bool isTriggeredSpell, WeaponAttackType attType)
4459 {
4460     sLog.outDebug("ProcDamageAndSpell: attacker flags are 0x%x, victim flags 0x%x", procAttacker, procVictim);
4461     if(procSpell)
4462         sLog.outDebug("ProcDamageAndSpell: invoked due to spell id %u %s", procSpell->Id, (isTriggeredSpell?"(triggered)":""));
4463
4464     // Assign melee/ranged proc flags for magic attacks, that are actually melee/ranged abilities
4465     // not assign for spell proc triggered spell to prevent infinity (or unexpected 2-3 times) melee damage spell proc call with melee damage effect
4466     // That is the question though if it's fully correct
4467     if(procSpell && !isTriggeredSpell)
4468     {
4469         if(procSpell->DmgClass == SPELL_DAMAGE_CLASS_MELEE)
4470         {
4471             if(procAttacker &  PROC_FLAG_HIT_SPELL) procAttacker |= PROC_FLAG_HIT_MELEE;
4472             if(procAttacker & PROC_FLAG_CRIT_SPELL) procAttacker |= PROC_FLAG_CRIT_MELEE;
4473             if(procVictim & PROC_FLAG_STRUCK_SPELL) procVictim |= PROC_FLAG_STRUCK_MELEE;
4474             if(procVictim & PROC_FLAG_STRUCK_CRIT_SPELL) procVictim |= PROC_FLAG_STRUCK_CRIT_MELEE;
4475             attType = BASE_ATTACK;                          // Melee abilities are assumed to be dealt with mainhand weapon
4476         }
4477         else if (procSpell->DmgClass == SPELL_DAMAGE_CLASS_RANGED)
4478         {
4479             if(procAttacker &  PROC_FLAG_HIT_SPELL) procAttacker |= PROC_FLAG_HIT_RANGED;
4480             if(procAttacker & PROC_FLAG_CRIT_SPELL) procAttacker |= PROC_FLAG_CRIT_RANGED;
4481             if(procVictim & PROC_FLAG_STRUCK_SPELL) procVictim |= PROC_FLAG_STRUCK_RANGED;
4482             if(procVictim & PROC_FLAG_STRUCK_CRIT_SPELL) procVictim |= PROC_FLAG_STRUCK_CRIT_RANGED;
4483             attType = RANGED_ATTACK;
4484         }
4485     }
4486     if(damage && (procVictim & (PROC_FLAG_STRUCK_MELEE|PROC_FLAG_STRUCK_RANGED|PROC_FLAG_STRUCK_SPELL)))
4487         procVictim |= (PROC_FLAG_TAKE_DAMAGE|PROC_FLAG_TOUCH);
4488
4489     // Not much to do if no flags are set.
4490     if (procAttacker)
4491     {
4492         // processing auras that not generate casts at proc event before auras that generate casts to prevent proc aura added at prev. proc aura execute in set
4493         ProcDamageAndSpellFor(false,pVictim,procAttacker,attackerProcEffectAuraTypes,attType, procSpell, damage, damageSchoolMask);
4494         ProcDamageAndSpellFor(false,pVictim,procAttacker,attackerProcCastAuraTypes,attType, procSpell, damage, damageSchoolMask);
4495     }
4496
4497     // Now go on with a victim's events'n'auras
4498     // Not much to do if no flags are set or there is no victim
4499     if(pVictim && pVictim->isAlive() && procVictim)
4500     {
4501         // processing auras that not generate casts at proc event before auras that generate casts to prevent proc aura added at prev. proc aura execute in set
4502         pVictim->ProcDamageAndSpellFor(true,this,procVictim,victimProcEffectAuraTypes,attType,procSpell, damage, damageSchoolMask);
4503         pVictim->ProcDamageAndSpellFor(true,this,procVictim,victimProcCastAuraTypes,attType,procSpell, damage, damageSchoolMask);
4504     }
4505 }
4506
4507 void Unit::CastMeleeProcDamageAndSpell(Unit* pVictim, uint32 damage, SpellSchoolMask damageSchoolMask, WeaponAttackType attType, MeleeHitOutcome outcome, SpellEntry const *spellCasted, bool isTriggeredSpell)
4508 {
4509     if(!pVictim)
4510         return;
4511
4512     uint32 procAttacker = PROC_FLAG_NONE;
4513     uint32 procVictim   = PROC_FLAG_NONE;
4514
4515     switch(outcome)
4516     {
4517         case MELEE_HIT_EVADE:
4518             return;
4519         case MELEE_HIT_MISS:
4520             if(attType == BASE_ATTACK || attType == OFF_ATTACK)
4521             {
4522                 procAttacker = PROC_FLAG_MISS;
4523             }
4524             break;
4525         case MELEE_HIT_BLOCK_CRIT:
4526         case MELEE_HIT_CRIT:
4527             if(spellCasted && attType == BASE_ATTACK)
4528             {
4529                 procAttacker |= PROC_FLAG_CRIT_SPELL;
4530                 procVictim   |= PROC_FLAG_STRUCK_CRIT_SPELL;
4531                 if ( outcome == MELEE_HIT_BLOCK_CRIT )
4532                 {
4533                     procVictim |= PROC_FLAG_BLOCK;
4534                     procAttacker |= PROC_FLAG_TARGET_BLOCK;
4535                 }
4536             }
4537             else if(attType == BASE_ATTACK || attType == OFF_ATTACK)
4538             {
4539                 procAttacker = PROC_FLAG_HIT_MELEE | PROC_FLAG_CRIT_MELEE;
4540                 procVictim = PROC_FLAG_STRUCK_MELEE | PROC_FLAG_STRUCK_CRIT_MELEE;
4541             }
4542             else
4543             {
4544                 procAttacker = PROC_FLAG_HIT_RANGED | PROC_FLAG_CRIT_RANGED;
4545                 procVictim = PROC_FLAG_STRUCK_RANGED | PROC_FLAG_STRUCK_CRIT_RANGED;
4546             }
4547             break;
4548         case MELEE_HIT_PARRY:
4549             procAttacker = PROC_FLAG_TARGET_DODGE_OR_PARRY;
4550             procVictim = PROC_FLAG_PARRY;
4551             break;
4552         case MELEE_HIT_BLOCK:
4553             procAttacker = PROC_FLAG_TARGET_BLOCK;
4554             procVictim = PROC_FLAG_BLOCK;
4555             break;
4556         case MELEE_HIT_DODGE:
4557             procAttacker = PROC_FLAG_TARGET_DODGE_OR_PARRY;
4558             procVictim = PROC_FLAG_DODGE;
4559             break;
4560         case MELEE_HIT_CRUSHING:
4561             if(attType == BASE_ATTACK || attType == OFF_ATTACK)
4562             {
4563                 procAttacker = PROC_FLAG_HIT_MELEE | PROC_FLAG_CRIT_MELEE;
4564                 procVictim = PROC_FLAG_STRUCK_MELEE | PROC_FLAG_STRUCK_CRIT_MELEE;
4565             }
4566             else
4567             {
4568                 procAttacker = PROC_FLAG_HIT_RANGED | PROC_FLAG_CRIT_RANGED;
4569                 procVictim = PROC_FLAG_STRUCK_RANGED | PROC_FLAG_STRUCK_CRIT_RANGED;
4570             }
4571             break;
4572         default:
4573             if(attType == BASE_ATTACK || attType == OFF_ATTACK)
4574             {
4575                 procAttacker = PROC_FLAG_HIT_MELEE;
4576                 procVictim = PROC_FLAG_STRUCK_MELEE;
4577             }
4578             else
4579             {
4580                 procAttacker = PROC_FLAG_HIT_RANGED;
4581                 procVictim = PROC_FLAG_STRUCK_RANGED;
4582             }
4583             break;
4584     }
4585
4586     if(damage > 0)
4587         procVictim |= PROC_FLAG_TAKE_DAMAGE;
4588
4589     if(procAttacker != PROC_FLAG_NONE || procVictim != PROC_FLAG_NONE)
4590         ProcDamageAndSpell(pVictim, procAttacker, procVictim, damage, damageSchoolMask, spellCasted, isTriggeredSpell, attType);
4591 }
4592
4593 bool Unit::HandleHasteAuraProc(Unit *pVictim, uint32 damage, Aura* triggeredByAura, SpellEntry const * /*procSpell*/, uint32 /*procFlag*/, uint32 cooldown)
4594 {
4595     SpellEntry const *hasteSpell = triggeredByAura->GetSpellProto();
4596
4597     Item* castItem = triggeredByAura->GetCastItemGUID() && GetTypeId()==TYPEID_PLAYER
4598         ? ((Player*)this)->GetItemByGuid(triggeredByAura->GetCastItemGUID()) : NULL;
4599
4600     uint32 triggered_spell_id = 0;
4601     Unit* target = pVictim;
4602     int32 basepoints0 = 0;
4603
4604     switch(hasteSpell->SpellFamilyName)
4605     {
4606         case SPELLFAMILY_ROGUE:
4607         {
4608             switch(hasteSpell->Id)
4609             {
4610                 // Blade Flurry
4611                 case 13877:
4612                 case 33735:
4613                 {
4614                     target = SelectNearbyTarget();
4615                     if(!target)
4616                         return false;
4617                     basepoints0 = damage;
4618                     triggered_spell_id = 22482;
4619                     break;
4620                 }
4621             }
4622             break;
4623         }
4624     }
4625
4626     // processed charge only counting case
4627     if(!triggered_spell_id)
4628         return true;
4629
4630     SpellEntry const* triggerEntry = sSpellStore.LookupEntry(triggered_spell_id);
4631
4632     if(!triggerEntry)
4633     {
4634         sLog.outError("Unit::HandleHasteAuraProc: Spell %u have not existed triggered spell %u",hasteSpell->Id,triggered_spell_id);
4635         return false;
4636     }
4637
4638     // default case
4639     if(!target || target!=this && !target->isAlive())
4640         return false;
4641
4642     if( cooldown && GetTypeId()==TYPEID_PLAYER && ((Player*)this)->HasSpellCooldown(triggered_spell_id))
4643         return false;
4644
4645     if(basepoints0)
4646         CastCustomSpell(target,triggered_spell_id,&basepoints0,NULL,NULL,true,castItem,triggeredByAura);
4647     else
4648         CastSpell(target,triggered_spell_id,true,castItem,triggeredByAura);
4649
4650     if( cooldown && GetTypeId()==TYPEID_PLAYER )
4651         ((Player*)this)->AddSpellCooldown(triggered_spell_id,0,time(NULL) + cooldown);
4652
4653     return true;
4654 }
4655
4656 bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage, Aura* triggeredByAura, SpellEntry const * procSpell, uint32 procFlag, uint32 cooldown)
4657 {
4658     SpellEntry const *dummySpell = triggeredByAura->GetSpellProto ();
4659     uint32 effIndex = triggeredByAura->GetEffIndex ();
4660
4661     Item* castItem = triggeredByAura->GetCastItemGUID() && GetTypeId()==TYPEID_PLAYER
4662         ? ((Player*)this)->GetItemByGuid(triggeredByAura->GetCastItemGUID()) : NULL;
4663
4664     uint32 triggered_spell_id = 0;
4665     Unit* target = pVictim;
4666     int32 basepoints0 = 0;
4667
4668     switch(dummySpell->SpellFamilyName)
4669     {
4670         case SPELLFAMILY_GENERIC:
4671         {
4672             switch (dummySpell->Id)
4673             {
4674                 // Eye of Eye
4675                 case 9799:
4676                 case 25988:
4677                 {
4678                     // prevent damage back from weapon special attacks
4679                     if (!procSpell || procSpell->DmgClass != SPELL_DAMAGE_CLASS_MAGIC )
4680                         return false;
4681
4682                     // return damage % to attacker but < 50% own total health
4683                     basepoints0 = triggeredByAura->GetModifier()->m_amount*int32(damage)/100;
4684                     if(basepoints0 > GetMaxHealth()/2)
4685                         basepoints0 = GetMaxHealth()/2;
4686
4687                     triggered_spell_id = 25997;
4688                     break;
4689                 }
4690                 // Sweeping Strikes
4691                 case 12328:
4692                 case 18765:
4693                 case 35429:
4694                 {
4695                     // prevent chain of triggered spell from same triggered spell
4696                     if(procSpell && procSpell->Id==26654)
4697                         return false;
4698
4699                     target = SelectNearbyTarget();
4700                     if(!target)
4701                         return false;
4702
4703                     triggered_spell_id = 26654;
4704                     break;
4705                 }
4706                 // Unstable Power
4707                 case 24658:
4708                 {
4709                     if (!procSpell || procSpell->Id == 24659)
4710                         return false;
4711                     // Need remove one 24659 aura
4712                     RemoveSingleAuraFromStack(24659, 0);
4713                     RemoveSingleAuraFromStack(24659, 1);
4714                     return true;
4715                 }
4716                 // Restless Strength
4717                 case 24661:
4718                 {
4719                     // Need remove one 24662 aura
4720                     RemoveSingleAuraFromStack(24662, 0);
4721                     return true;
4722                 }
4723                 // Adaptive Warding (Frostfire Regalia set)
4724                 case 28764:
4725                 {
4726                     if(!procSpell)
4727                         return false;
4728
4729                     // find Mage Armor
4730                     bool found = false;
4731                     AuraList const& mRegenInterupt = GetAurasByType(SPELL_AURA_MOD_MANA_REGEN_INTERRUPT);
4732                     for(AuraList::const_iterator iter = mRegenInterupt.begin(); iter != mRegenInterupt.end(); ++iter)
4733                     {
4734                         if(SpellEntry const* iterSpellProto = (*iter)->GetSpellProto())
4735                         {
4736                             if(iterSpellProto->SpellFamilyName==SPELLFAMILY_MAGE && (iterSpellProto->SpellFamilyFlags & 0x10000000))
4737                             {
4738                                 found=true;
4739                                 break;
4740                             }
4741                         }
4742                     }
4743                     if(!found)
4744                         return false;
4745
4746                     switch(GetFirstSchoolInMask(GetSpellSchoolMask(procSpell)))
4747                     {
4748                         case SPELL_SCHOOL_NORMAL:
4749                         case SPELL_SCHOOL_HOLY:
4750                             return false;                   // ignored
4751                         case SPELL_SCHOOL_FIRE:   triggered_spell_id = 28765; break;
4752                         case SPELL_SCHOOL_NATURE: triggered_spell_id = 28768; break;
4753                         case SPELL_SCHOOL_FROST:  triggered_spell_id = 28766; break;
4754                         case SPELL_SCHOOL_SHADOW: triggered_spell_id = 28769; break;
4755                         case SPELL_SCHOOL_ARCANE: triggered_spell_id = 28770; break;
4756                         default:
4757                             return false;
4758                     }
4759
4760                     target = this;
4761                     break;
4762                 }
4763                 // Obsidian Armor (Justice Bearer`s Pauldrons shoulder)
4764                 case 27539:
4765                 {
4766                     if(!procSpell)
4767                         return false;
4768
4769                     // not from DoT
4770                     bool found = false;
4771                     for(int j = 0; j < 3; ++j)
4772                     {
4773                         if(procSpell->EffectApplyAuraName[j]==SPELL_AURA_PERIODIC_DAMAGE||procSpell->EffectApplyAuraName[j]==SPELL_AURA_PERIODIC_DAMAGE_PERCENT)
4774                         {
4775                             found = true;
4776                             break;
4777                         }
4778                     }
4779                     if(found)
4780                         return false;
4781
4782                     switch(GetFirstSchoolInMask(GetSpellSchoolMask(procSpell)))
4783                     {
4784                         case SPELL_SCHOOL_NORMAL:
4785                             return false;                   // ignore
4786                         case SPELL_SCHOOL_HOLY:   triggered_spell_id = 27536; break;
4787                         case SPELL_SCHOOL_FIRE:   triggered_spell_id = 27533; break;
4788                         case SPELL_SCHOOL_NATURE: triggered_spell_id = 27538; break;
4789                         case SPELL_SCHOOL_FROST:  triggered_spell_id = 27534; break;
4790                         case SPELL_SCHOOL_SHADOW: triggered_spell_id = 27535; break;
4791                         case SPELL_SCHOOL_ARCANE: triggered_spell_id = 27540; break;
4792                         default:
4793                             return false;
4794                     }
4795
4796                     target = this;
4797                     break;
4798                 }
4799                 // Mana Leech (Passive) (Priest Pet Aura)
4800                 case 28305:
4801                 {
4802                     // Cast on owner
4803                     target = GetOwner();
4804                     if(!target)
4805                         return false;
4806
4807                     basepoints0 = int32(damage * 2.5f);     // manaregen
4808                     triggered_spell_id = 34650;
4809                     break;
4810                 }
4811                 // Mark of Malice
4812                 case 33493:
4813                 {
4814                     // Cast finish spell at last charge
4815                     if (triggeredByAura->m_procCharges > 1)
4816                         return false;
4817
4818                     target = this;
4819                     triggered_spell_id = 33494;
4820                     break;
4821                 }
4822                 // Twisted Reflection (boss spell)
4823                 case 21063:
4824                     triggered_spell_id = 21064;
4825                     break;
4826                 // Vampiric Aura (boss spell)
4827                 case 38196:
4828                 {
4829                     basepoints0 = 3 * damage;               // 300%
4830                     if (basepoints0 < 0)
4831                         return false;
4832
4833                     triggered_spell_id = 31285;
4834                     target = this;
4835                     break;
4836                 }
4837                 // Aura of Madness (Darkmoon Card: Madness trinket)
4838                 //=====================================================
4839                 // 39511 Sociopath: +35 strength (Paladin, Rogue, Druid, Warrior)
4840                 // 40997 Delusional: +70 attack power (Rogue, Hunter, Paladin, Warrior, Druid)
4841                 // 40998 Kleptomania: +35 agility (Warrior, Rogue, Paladin, Hunter, Druid)
4842                 // 40999 Megalomania: +41 damage/healing (Druid, Shaman, Priest, Warlock, Mage, Paladin)
4843                 // 41002 Paranoia: +35 spell/melee/ranged crit strike rating (All classes)
4844                 // 41005 Manic: +35 haste (spell, melee and ranged) (All classes)
4845                 // 41009 Narcissism: +35 intellect (Druid, Shaman, Priest, Warlock, Mage, Paladin, Hunter)
4846                 // 41011 Martyr Complex: +35 stamina (All classes)
4847                 // 41406 Dementia: Every 5 seconds either gives you +5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
4848                 // 41409 Dementia: Every 5 seconds either gives you -5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
4849                 case 39446:
4850                 {
4851                     if(GetTypeId() != TYPEID_PLAYER)
4852                         return false;
4853
4854                     // Select class defined buff
4855                     switch (getClass())
4856                     {
4857                         case CLASS_PALADIN:                 // 39511,40997,40998,40999,41002,41005,41009,41011,41409
4858                         case CLASS_DRUID:                   // 39511,40997,40998,40999,41002,41005,41009,41011,41409
4859                         {
4860                             uint32 RandomSpell[]={39511,40997,40998,40999,41002,41005,41009,41011,41409};
4861                             triggered_spell_id = RandomSpell[ irand(0, sizeof(RandomSpell)/sizeof(uint32) - 1) ];
4862                             break;
4863                         }
4864                         case CLASS_ROGUE:                   // 39511,40997,40998,41002,41005,41011
4865                         case CLASS_WARRIOR:                 // 39511,40997,40998,41002,41005,41011
4866                         {
4867                             uint32 RandomSpell[]={39511,40997,40998,41002,41005,41011};
4868                             triggered_spell_id = RandomSpell[ irand(0, sizeof(RandomSpell)/sizeof(uint32) - 1) ];
4869                             break;
4870                         }
4871                         case CLASS_PRIEST:                  // 40999,41002,41005,41009,41011,41406,41409
4872                         case CLASS_SHAMAN:                  // 40999,41002,41005,41009,41011,41406,41409
4873                         case CLASS_MAGE:                    // 40999,41002,41005,41009,41011,41406,41409
4874                         case CLASS_WARLOCK:                 // 40999,41002,41005,41009,41011,41406,41409
4875                         {
4876                             uint32 RandomSpell[]={40999,41002,41005,41009,41011,41406,41409};
4877                             triggered_spell_id = RandomSpell[ irand(0, sizeof(RandomSpell)/sizeof(uint32) - 1) ];
4878                             break;
4879                         }
4880                         case CLASS_HUNTER:                  // 40997,40999,41002,41005,41009,41011,41406,41409
4881                         {
4882                             uint32 RandomSpell[]={40997,40999,41002,41005,41009,41011,41406,41409};
4883                             triggered_spell_id = RandomSpell[ irand(0, sizeof(RandomSpell)/sizeof(uint32) - 1) ];
4884                             break;
4885                         }
4886                         default:
4887                             return false;
4888                     }
4889
4890                     target = this;
4891                     if (roll_chance_i(10))
4892                         ((Player*)this)->Say("This is Madness!", LANG_UNIVERSAL);
4893                     break;
4894                 }
4895                 /*
4896                 // TODO: need find item for aura and triggered spells
4897                 // Sunwell Exalted Caster Neck (??? neck)
4898                 // cast ??? Light's Wrath if Exalted by Aldor
4899                 // cast ??? Arcane Bolt if Exalted by Scryers*/
4900                 case 46569:
4901                     return false;                           // disable for while
4902                 /*
4903                 {
4904                     if(GetTypeId() != TYPEID_PLAYER)
4905                         return false;
4906
4907                     // Get Aldor reputation rank
4908                     if (((Player *)this)->GetReputationRank(932) == REP_EXALTED)
4909                     {
4910                         target = this;
4911                         triggered_spell_id = ???
4912                         break;
4913                     }
4914                     // Get Scryers reputation rank
4915                     if (((Player *)this)->GetReputationRank(934) == REP_EXALTED)
4916                     {
4917                         triggered_spell_id = ???
4918                         break;
4919                     }
4920                     return false;
4921                 }/**/
4922                 // Sunwell Exalted Caster Neck (Shattered Sun Pendant of Acumen neck)
4923                 // cast 45479 Light's Wrath if Exalted by Aldor
4924                 // cast 45429 Arcane Bolt if Exalted by Scryers
4925                 case 45481:
4926                 {
4927                     if(GetTypeId() != TYPEID_PLAYER)
4928                         return false;
4929
4930                     // Get Aldor reputation rank
4931                     if (((Player *)this)->GetReputationRank(932) == REP_EXALTED)
4932                     {
4933                         target = this;
4934                         triggered_spell_id = 45479;
4935                         break;
4936                     }
4937                     // Get Scryers reputation rank
4938                     if (((Player *)this)->GetReputationRank(934) == REP_EXALTED)
4939                     {
4940                         triggered_spell_id = 45429;
4941                         break;
4942                     }
4943                     return false;
4944                 }
4945                 // Sunwell Exalted Melee Neck (Shattered Sun Pendant of Might neck)
4946                 // cast 45480 Light's Strength if Exalted by Aldor
4947                 // cast 45428 Arcane Strike if Exalted by Scryers
4948                 case 45482:
4949                 {
4950                     if(GetTypeId() != TYPEID_PLAYER)
4951                         return false;
4952
4953                     // Get Aldor reputation rank
4954                     if (((Player *)this)->GetReputationRank(932) == REP_EXALTED)
4955                     {
4956                         target = this;
4957                         triggered_spell_id = 45480;
4958                         break;
4959                     }
4960                     // Get Scryers reputation rank
4961                     if (((Player *)this)->GetReputationRank(934) == REP_EXALTED)
4962                     {
4963                         triggered_spell_id = 45428;
4964                         break;
4965                     }
4966                     return false;
4967                 }
4968                 // Sunwell Exalted Tank Neck (Shattered Sun Pendant of Resolve neck)
4969                 // cast 45431 Arcane Insight if Exalted by Aldor
4970                 // cast 45432 Light's Ward if Exalted by Scryers
4971                 case 45483:
4972                 {
4973                     if(GetTypeId() != TYPEID_PLAYER)
4974                         return false;
4975
4976                     // Get Aldor reputation rank
4977                     if (((Player *)this)->GetReputationRank(932) == REP_EXALTED)
4978                     {
4979                         target = this;
4980                         triggered_spell_id = 45432;
4981                         break;
4982                     }
4983                     // Get Scryers reputation rank
4984                     if (((Player *)this)->GetReputationRank(934) == REP_EXALTED)
4985                     {
4986                         target = this;
4987                         triggered_spell_id = 45431;
4988                         break;
4989                     }
4990                     return false;
4991                 }
4992                 // Sunwell Exalted Healer Neck (Shattered Sun Pendant of Restoration neck)
4993                 // cast 45478 Light's Salvation if Exalted by Aldor
4994                 // cast 45430 Arcane Surge if Exalted by Scryers
4995                 case 45484:
4996                 {
4997                     if(GetTypeId() != TYPEID_PLAYER)
4998                         return false;
4999
5000                     // Get Aldor reputation rank
5001                     if (((Player *)this)->GetReputationRank(932) == REP_EXALTED)
5002                     {
5003                         target = this;
5004                         triggered_spell_id = 45478;
5005                         break;
5006                     }
5007                     // Get Scryers reputation rank
5008                     if (((Player *)this)->GetReputationRank(934) == REP_EXALTED)
5009                     {
5010                         triggered_spell_id = 45430;
5011                         break;
5012                     }
5013                     return false;
5014                 }
5015             }
5016             break;
5017         }
5018         case SPELLFAMILY_MAGE:
5019         {
5020             // Magic Absorption
5021             if (dummySpell->SpellIconID == 459)             // only this spell have SpellIconID == 459 and dummy aura
5022             {
5023                 if (getPowerType() != POWER_MANA)
5024                     return false;
5025
5026                 // mana reward
5027                 basepoints0 = (triggeredByAura->GetModifier()->m_amount * GetMaxPower(POWER_MANA) / 100);
5028                 target = this;
5029                 triggered_spell_id = 29442;
5030                 break;
5031             }
5032             // Master of Elements
5033             if (dummySpell->SpellIconID == 1920)
5034             {
5035                 if(!procSpell)
5036                     return false;
5037
5038                 // mana cost save
5039                 basepoints0 = procSpell->manaCost * triggeredByAura->GetModifier()->m_amount/100;
5040                 if( basepoints0 <=0 )
5041                     return false;
5042
5043                 target = this;
5044                 triggered_spell_id = 29077;
5045                 break;
5046             }
5047             switch(dummySpell->Id)
5048             {
5049                 // Ignite
5050                 case 11119:
5051                 case 11120:
5052                 case 12846:
5053                 case 12847:
5054                 case 12848:
5055                 {
5056                     switch (dummySpell->Id)
5057                     {
5058                         case 11119: basepoints0 = int32(0.04f*damage); break;
5059                         case 11120: basepoints0 = int32(0.08f*damage); break;
5060                         case 12846: basepoints0 = int32(0.12f*damage); break;
5061                         case 12847: basepoints0 = int32(0.16f*damage); break;
5062                         case 12848: basepoints0 = int32(0.20f*damage); break;
5063                         default:
5064                             sLog.outError("Unit::HandleDummyAuraProc: non handled spell id: %u (IG)",dummySpell->Id);
5065                             return false;
5066                     }
5067
5068                     triggered_spell_id = 12654;
5069                     break;
5070                 }
5071                 // Combustion
5072                 case 11129:
5073                 {
5074                     //last charge and crit
5075                     if( triggeredByAura->m_procCharges <= 1 && (procFlag & PROC_FLAG_CRIT_SPELL) )
5076                     {
5077                         RemoveAurasDueToSpell(28682);       //-> remove Combustion auras
5078                         return true;                        // charge counting (will removed)
5079                     }
5080
5081                     CastSpell(this, 28682, true, castItem, triggeredByAura);
5082                     return(procFlag & PROC_FLAG_CRIT_SPELL);// charge update only at crit hits, no hidden cooldowns
5083                 }
5084             }
5085             break;
5086         }
5087         case SPELLFAMILY_WARRIOR:
5088         {
5089             // Retaliation
5090             if(dummySpell->SpellFamilyFlags==0x0000000800000000LL)
5091             {
5092                 // check attack comes not from behind
5093                 if (!HasInArc(M_PI, pVictim))
5094                     return false;
5095
5096                 triggered_spell_id = 22858;
5097                 break;
5098             }
5099             break;
5100         }
5101         case SPELLFAMILY_WARLOCK:
5102         {
5103             // Seed of Corruption
5104             if (dummySpell->SpellFamilyFlags & 0x0000001000000000LL)
5105             {
5106                 Modifier* mod = triggeredByAura->GetModifier();
5107                 // if damage is more than need or target die from damage deal finish spell
5108                 // FIX ME: not triggered currently at death
5109                 if( mod->m_amount <= damage || GetHealth() <= damage )
5110                 {
5111                     // remember guid before aura delete
5112                     uint64 casterGuid = triggeredByAura->GetCasterGUID();
5113
5114                     // Remove aura (before cast for prevent infinite loop handlers)
5115                     RemoveAurasDueToSpell(triggeredByAura->GetId());
5116
5117                     // Cast finish spell (triggeredByAura already not exist!)
5118                     CastSpell(this, 27285, true, castItem, NULL, casterGuid);
5119                     return true;                            // no hidden cooldown
5120                 }
5121
5122                 // Damage counting
5123                 mod->m_amount-=damage;
5124                 return true;
5125             }
5126             // Seed of Corruption (Mobs cast) - no die req
5127             if (dummySpell->SpellFamilyFlags == 0x00LL && dummySpell->SpellIconID == 1932)
5128             {
5129                 Modifier* mod = triggeredByAura->GetModifier();
5130                 // if damage is more than need deal finish spell
5131                 if( mod->m_amount <= damage )
5132                 {
5133                     // remember guid before aura delete
5134                     uint64 casterGuid = triggeredByAura->GetCasterGUID();
5135
5136                     // Remove aura (before cast for prevent infinite loop handlers)
5137                     RemoveAurasDueToSpell(triggeredByAura->GetId());
5138
5139                     // Cast finish spell (triggeredByAura already not exist!)
5140                     CastSpell(this, 32865, true, castItem, NULL, casterGuid);
5141                     return true;                            // no hidden cooldown
5142                 }
5143                 // Damage counting
5144                 mod->m_amount-=damage;
5145                 return true;
5146             }
5147             switch(dummySpell->Id)
5148             {
5149                 // Nightfall
5150                 case 18094:
5151                 case 18095:
5152                 {
5153                     target = this;
5154                     triggered_spell_id = 17941;
5155                     break;
5156                 }
5157                 //Soul Leech
5158                 case 30293:
5159                 case 30295:
5160                 case 30296:
5161                 {
5162                     // health
5163                     basepoints0 = int32(damage*triggeredByAura->GetModifier()->m_amount/100);
5164                     target = this;
5165                     triggered_spell_id = 30294;
5166                     break;
5167                 }
5168                 // Shadowflame (Voidheart Raiment set bonus)
5169                 case 37377:
5170                 {
5171                     triggered_spell_id = 37379;
5172                     break;
5173                 }
5174                 // Pet Healing (Corruptor Raiment or Rift Stalker Armor)
5175                 case 37381:
5176                 {
5177                     target = GetPet();
5178                     if(!target)
5179                         return false;
5180
5181                     // heal amount
5182                     basepoints0 = damage * triggeredByAura->GetModifier()->m_amount/100;
5183                     triggered_spell_id = 37382;
5184                     break;
5185                 }
5186                 // Shadowflame Hellfire (Voidheart Raiment set bonus)
5187                 case 39437:
5188                 {
5189                     triggered_spell_id = 37378;
5190                     break;
5191                 }
5192             }
5193             break;
5194         }
5195         case SPELLFAMILY_PRIEST:
5196         {
5197             // Vampiric Touch
5198             if( dummySpell->SpellFamilyFlags & 0x0000040000000000LL )
5199             {
5200                 if(!pVictim || !pVictim->isAlive())
5201                     return false;
5202
5203                 // pVictim is caster of aura
5204                 if(triggeredByAura->GetCasterGUID() != pVictim->GetGUID())
5205                     return false;
5206
5207                 // energize amount
5208                 basepoints0 = triggeredByAura->GetModifier()->m_amount*damage/100;
5209                 pVictim->CastCustomSpell(pVictim,34919,&basepoints0,NULL,NULL,true,castItem,triggeredByAura);
5210                 return true;                                // no hidden cooldown
5211             }
5212             switch(dummySpell->Id)
5213             {
5214                 // Vampiric Embrace
5215                 case 15286:
5216                 {
5217                     if(!pVictim || !pVictim->isAlive())
5218                         return false;
5219
5220                     // pVictim is caster of aura
5221                     if(triggeredByAura->GetCasterGUID() != pVictim->GetGUID())
5222                         return false;
5223
5224                     // heal amount
5225                     basepoints0 = triggeredByAura->GetModifier()->m_amount*damage/100;
5226                     pVictim->CastCustomSpell(pVictim,15290,&basepoints0,NULL,NULL,true,castItem,triggeredByAura);
5227                     return true;                                // no hidden cooldown
5228                 }
5229                 // Priest Tier 6 Trinket (Ashtongue Talisman of Acumen)
5230                 case 40438:
5231                 {
5232                     // Shadow Word: Pain
5233                     if( procSpell->SpellFamilyFlags & 0x0000000000008000LL )
5234                         triggered_spell_id = 40441;
5235                     // Renew
5236                     else if( procSpell->SpellFamilyFlags & 0x0000000000000010LL )
5237                         triggered_spell_id = 40440;
5238                     else
5239                         return false;
5240
5241                     target = this;
5242                     break;
5243                 }
5244                 // Oracle Healing Bonus ("Garments of the Oracle" set)
5245                 case 26169:
5246                 {
5247                     // heal amount
5248                     basepoints0 = int32(damage * 10/100);
5249                     target = this;
5250                     triggered_spell_id = 26170;
5251                     break;
5252                 }
5253                 // Frozen Shadoweave (Shadow's Embrace set) warning! its not only priest set
5254                 case 39372:
5255                 {
5256                     if(!procSpell || (GetSpellSchoolMask(procSpell) & (SPELL_SCHOOL_MASK_FROST | SPELL_SCHOOL_MASK_SHADOW))==0 )
5257                         return false;
5258
5259                     // heal amount
5260                     basepoints0 = int32(damage * 2 / 100);
5261                     target = this;
5262                     triggered_spell_id = 39373;
5263                     break;
5264                 }
5265                 // Vestments of Faith (Priest Tier 3) - 4 pieces bonus
5266                 case 28809:
5267                 {
5268                     triggered_spell_id = 28810;
5269                     break;
5270                 }
5271             }
5272             break;
5273         }
5274         case SPELLFAMILY_DRUID:
5275         {
5276             switch(dummySpell->Id)
5277             {
5278                 // Healing Touch (Dreamwalker Raiment set)
5279                 case 28719:
5280                 {
5281                     // mana back
5282                     basepoints0 = int32(procSpell->manaCost * 30 / 100);
5283                     target = this;
5284                     triggered_spell_id = 28742;
5285                     break;
5286                 }
5287                 // Healing Touch Refund (Idol of Longevity trinket)
5288                 case 28847:
5289                 {
5290                     target = this;
5291                     triggered_spell_id = 28848;
5292                     break;
5293                 }
5294                 // Mana Restore (Malorne Raiment set / Malorne Regalia set)
5295                 case 37288:
5296                 case 37295:
5297                 {
5298                     target = this;
5299                     triggered_spell_id = 37238;
5300                     break;
5301                 }
5302                 // Druid Tier 6 Trinket
5303                 case 40442:
5304                 {
5305                     float  chance;
5306
5307                     // Starfire
5308                     if( procSpell->SpellFamilyFlags & 0x0000000000000004LL )
5309                     {
5310                         triggered_spell_id = 40445;
5311                         chance = 25.f;
5312                     }
5313                     // Rejuvenation
5314                     else if( procSpell->SpellFamilyFlags & 0x0000000000000010LL )
5315                     {
5316                         triggered_spell_id = 40446;
5317                         chance = 25.f;
5318                     }
5319                     // Mangle (cat/bear)
5320                     else if( procSpell->SpellFamilyFlags & 0x0000044000000000LL )
5321                     {
5322                         triggered_spell_id = 40452;
5323                         chance = 40.f;
5324                     }
5325                     else
5326                         return false;
5327
5328                     if (!roll_chance_f(chance))
5329                         return false;
5330
5331                     target = this;
5332                     break;
5333                 }
5334                 // Maim Interrupt
5335                 case 44835:
5336                 {
5337                     // Deadly Interrupt Effect
5338                     triggered_spell_id = 32747;
5339                     break;
5340                 }
5341             }
5342             break;
5343         }
5344         case SPELLFAMILY_ROGUE:
5345         {
5346             switch(dummySpell->Id)
5347             {
5348                 // Deadly Throw Interrupt
5349                 case 32748:
5350                 {
5351                     // Prevent cast Deadly Throw Interrupt on self from last effect (apply dummy) of Deadly Throw
5352                     if(this == pVictim)
5353                         return false;
5354
5355                     triggered_spell_id = 32747;
5356                     break;
5357                 }
5358             }
5359             // Quick Recovery
5360             if( dummySpell->SpellIconID == 2116 )
5361             {
5362                 if(!procSpell)
5363                     return false;
5364
5365                 // only rogue's finishing moves (maybe need additional checks)
5366                 if( procSpell->SpellFamilyName!=SPELLFAMILY_ROGUE ||
5367                     (procSpell->SpellFamilyFlags & SPELLFAMILYFLAG_ROGUE__FINISHING_MOVE) == 0)
5368                     return false;
5369
5370                 // energy cost save
5371                 basepoints0 = procSpell->manaCost * triggeredByAura->GetModifier()->m_amount/100;
5372                 if(basepoints0 <= 0)
5373                     return false;
5374
5375                 target = this;
5376                 triggered_spell_id = 31663;
5377                 break;
5378             }
5379             break;
5380         }
5381         case SPELLFAMILY_HUNTER:
5382         {
5383             // Thrill of the Hunt
5384             if ( dummySpell->SpellIconID == 2236 )
5385             {
5386                 if(!procSpell)
5387                     return false;
5388
5389                 // mana cost save
5390                 basepoints0 = procSpell->manaCost * 40/100;
5391                 if(basepoints0 <= 0)
5392                     return false;
5393
5394                 target = this;
5395                 triggered_spell_id = 34720;
5396                 break;
5397             }
5398             break;
5399         }
5400         case SPELLFAMILY_PALADIN:
5401         {
5402             // Seal of Righteousness - melee proc dummy
5403             if (dummySpell->SpellFamilyFlags&0x000000008000000LL && triggeredByAura->GetEffIndex()==0)
5404             {
5405                 if(GetTypeId() != TYPEID_PLAYER)
5406                     return false;
5407
5408                 uint32 spellId;
5409                 switch (triggeredByAura->GetId())
5410                 {
5411                     case 21084: spellId = 25742; break;     // Rank 1
5412                     case 20287: spellId = 25740; break;     // Rank 2
5413                     case 20288: spellId = 25739; break;     // Rank 3
5414                     case 20289: spellId = 25738; break;     // Rank 4
5415                     case 20290: spellId = 25737; break;     // Rank 5
5416                     case 20291: spellId = 25736; break;     // Rank 6
5417                     case 20292: spellId = 25735; break;     // Rank 7
5418                     case 20293: spellId = 25713; break;     // Rank 8
5419                     case 27155: spellId = 27156; break;     // Rank 9
5420                     default:
5421                         sLog.outError("Unit::HandleDummyAuraProc: non handled possibly SoR (Id = %u)", triggeredByAura->GetId());
5422                         return false;
5423                 }
5424                 Item *item = ((Player*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
5425                 float speed = (item ? item->GetProto()->Delay : BASE_ATTACK_TIME)/1000.0f;
5426
5427                 float damageBasePoints;
5428                 if(item && item->GetProto()->InventoryType == INVTYPE_2HWEAPON)
5429                     // two hand weapon
5430                     damageBasePoints=1.20f*triggeredByAura->GetModifier()->m_amount * 1.2f * 1.03f * speed/100.0f + 1;
5431                 else
5432                     // one hand weapon/no weapon
5433                     damageBasePoints=0.85f*ceil(triggeredByAura->GetModifier()->m_amount * 1.2f * 1.03f * speed/100.0f) - 1;
5434
5435                 int32 damagePoint = int32(damageBasePoints + 0.03f * (GetWeaponDamageRange(BASE_ATTACK,MINDAMAGE)+GetWeaponDamageRange(BASE_ATTACK,MAXDAMAGE))/2.0f) + 1;
5436
5437                 // apply damage bonuses manually
5438                 if(damagePoint >= 0)
5439                     damagePoint = SpellDamageBonus(pVictim, dummySpell, damagePoint, SPELL_DIRECT_DAMAGE);
5440
5441                 CastCustomSpell(pVictim,spellId,&damagePoint,NULL,NULL,true,NULL, triggeredByAura);
5442                 return true;                                // no hidden cooldown
5443             }
5444             // Seal of Blood do damage trigger
5445             if(dummySpell->SpellFamilyFlags & 0x0000040000000000LL)
5446             {
5447                 switch(triggeredByAura->GetEffIndex())
5448                 {
5449                     case 0:
5450                         // prevent chain triggering
5451                         if(procSpell && procSpell->Id==31893 )
5452                             return false;
5453
5454                         triggered_spell_id = 31893;
5455                         break;
5456                     case 1:
5457                     {
5458                         // damage
5459                         basepoints0 = triggeredByAura->GetModifier()->m_amount * damage / 100;
5460                         target = this;
5461                         triggered_spell_id = 32221;
5462                         break;
5463                     }
5464                 }
5465             }
5466
5467             switch(dummySpell->Id)
5468             {
5469                 // Holy Power (Redemption Armor set)
5470                 case 28789:
5471                 {
5472                     if(!pVictim)
5473                         return false;
5474
5475                     // Set class defined buff
5476                     switch (pVictim->getClass())
5477                     {
5478                         case CLASS_PALADIN:
5479                         case CLASS_PRIEST:
5480                         case CLASS_SHAMAN:
5481                         case CLASS_DRUID:
5482                             triggered_spell_id = 28795;     // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
5483                             break;
5484                         case CLASS_MAGE:
5485                         case CLASS_WARLOCK:
5486                             triggered_spell_id = 28793;     // Increases the friendly target's spell damage and healing by up to $s1 for $d.
5487                             break;
5488                         case CLASS_HUNTER:
5489                         case CLASS_ROGUE:
5490                             triggered_spell_id = 28791;     // Increases the friendly target's attack power by $s1 for $d.
5491                             break;
5492                         case CLASS_WARRIOR:
5493                             triggered_spell_id = 28790;     // Increases the friendly target's armor
5494                             break;
5495                         default:
5496                             return false;
5497                     }
5498                     break;
5499                 }
5500                 //Seal of Vengeance
5501                 case 31801:
5502                 {
5503                     if(effIndex != 0)                       // effect 1,2 used by seal unleashing code
5504                         return false;
5505
5506                     triggered_spell_id = 31803;
5507                     break;
5508                 }
5509                 // Spiritual Att.
5510                 case 31785:
5511                 case 33776:
5512                 {
5513                     // if healed by another unit (pVictim)
5514                     if(this == pVictim)
5515                         return false;
5516
5517                     // heal amount
5518                     basepoints0 = triggeredByAura->GetModifier()->m_amount*damage/100;
5519                     target = this;
5520                     triggered_spell_id = 31786;
5521                     break;
5522                 }
5523                 // Paladin Tier 6 Trinket (Ashtongue Talisman of Zeal)
5524                 case 40470:
5525                 {
5526                     if( !procSpell )
5527                         return false;
5528
5529                     float  chance;
5530
5531                     // Flash of light/Holy light
5532                     if( procSpell->SpellFamilyFlags & 0x00000000C0000000LL)
5533                     {
5534                         triggered_spell_id = 40471;
5535                         chance = 15.f;
5536                     }
5537                     // Judgement
5538                     else if( procSpell->SpellFamilyFlags & 0x0000000000800000LL )
5539                     {
5540                         triggered_spell_id = 40472;
5541                         chance = 50.f;
5542                     }
5543                     else
5544                         return false;
5545
5546                     if (!roll_chance_f(chance))
5547                         return false;
5548
5549                     break;
5550                 }
5551             }
5552             break;
5553         }
5554         case SPELLFAMILY_SHAMAN:
5555         {
5556             switch(dummySpell->Id)
5557             {
5558                 // Totemic Power (The Earthshatterer set)
5559                 case 28823:
5560                 {
5561                     if( !pVictim )
5562                         return false;
5563
5564                     // Set class defined buff
5565                     switch (pVictim->getClass())
5566                     {
5567                         case CLASS_PALADIN:
5568                         case CLASS_PRIEST:
5569                         case CLASS_SHAMAN:
5570                         case CLASS_DRUID:
5571                             triggered_spell_id = 28824;     // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
5572                             break;
5573                         case CLASS_MAGE:
5574                         case CLASS_WARLOCK:
5575                             triggered_spell_id = 28825;     // Increases the friendly target's spell damage and healing by up to $s1 for $d.
5576                             break;
5577                         case CLASS_HUNTER:
5578                         case CLASS_ROGUE:
5579                             triggered_spell_id = 28826;     // Increases the friendly target's attack power by $s1 for $d.
5580                             break;
5581                         case CLASS_WARRIOR:
5582                             triggered_spell_id = 28827;     // Increases the friendly target's armor
5583                             break;
5584                         default:
5585                             return false;
5586                     }
5587                     break;
5588                 }
5589                 // Lesser Healing Wave (Totem of Flowing Water Relic)
5590                 case 28849:
5591                 {
5592                     target = this;
5593                     triggered_spell_id = 28850;
5594                     break;
5595                 }
5596                 // Windfury Weapon (Passive) 1-5 Ranks
5597                 case 33757:
5598                 {
5599                     if(GetTypeId()!=TYPEID_PLAYER)
5600                         return false;
5601
5602                     if(!castItem || !castItem->IsEquipped())
5603                         return false;
5604
5605                     // custom cooldown processing case
5606                     if( cooldown && ((Player*)this)->HasSpellCooldown(dummySpell->Id))
5607                         return false;
5608
5609                     uint32 spellId;
5610                     switch (castItem->GetEnchantmentId(EnchantmentSlot(TEMP_ENCHANTMENT_SLOT)))
5611                     {
5612                         case 283: spellId = 33757; break;   //1 Rank
5613                         case 284: spellId = 33756; break;   //2 Rank
5614                         case 525: spellId = 33755; break;   //3 Rank
5615                         case 1669:spellId = 33754; break;   //4 Rank
5616                         case 2636:spellId = 33727; break;   //5 Rank
5617                         default:
5618                         {
5619                             sLog.outError("Unit::HandleDummyAuraProc: non handled item enchantment (rank?) %u for spell id: %u (Windfury)",
5620                                 castItem->GetEnchantmentId(EnchantmentSlot(TEMP_ENCHANTMENT_SLOT)),dummySpell->Id);
5621                             return false;
5622                         }
5623                     }
5624
5625                     SpellEntry const* windfurySpellEntry = sSpellStore.LookupEntry(spellId);
5626                     if(!windfurySpellEntry)
5627                     {
5628                         sLog.outError("Unit::HandleDummyAuraProc: non existed spell id: %u (Windfury)",spellId);
5629                         return false;
5630                     }
5631
5632                     int32 extra_attack_power = CalculateSpellDamage(windfurySpellEntry,0,windfurySpellEntry->EffectBasePoints[0],pVictim);
5633
5634                     // Off-Hand case
5635                     if ( castItem->GetSlot() == EQUIPMENT_SLOT_OFFHAND )
5636                     {
5637                         // Value gained from additional AP
5638                         basepoints0 = int32(extra_attack_power/14.0f * GetAttackTime(OFF_ATTACK)/1000/2);
5639                         triggered_spell_id = 33750;
5640                     }
5641                     // Main-Hand case
5642                     else
5643                     {
5644                         // Value gained from additional AP
5645                         basepoints0 = int32(extra_attack_power/14.0f * GetAttackTime(BASE_ATTACK)/1000);
5646                         triggered_spell_id = 25504;
5647                     }
5648
5649                     // apply cooldown before cast to prevent processing itself
5650                     if( cooldown )
5651                         ((Player*)this)->AddSpellCooldown(dummySpell->Id,0,time(NULL) + cooldown);
5652
5653                     // Attack Twice
5654                     for ( uint32 i = 0; i<2; ++i )
5655                         CastCustomSpell(pVictim,triggered_spell_id,&basepoints0,NULL,NULL,true,castItem,triggeredByAura);
5656
5657                     return true;
5658                 }
5659                 // Shaman Tier 6 Trinket
5660                 case 40463:
5661                 {
5662                     if( !procSpell )
5663                         return false;
5664
5665                     float  chance;
5666                     if (procSpell->SpellFamilyFlags & 0x0000000000000001LL)
5667                     {
5668                         triggered_spell_id = 40465;         // Lightning Bolt
5669                         chance = 15.f;
5670                     }
5671                     else if (procSpell->SpellFamilyFlags & 0x0000000000000080LL)
5672                     {
5673                         triggered_spell_id = 40465;         // Lesser Healing Wave
5674                         chance = 10.f;
5675                     }
5676                     else if (procSpell->SpellFamilyFlags & 0x0000001000000000LL)
5677                     {
5678                         triggered_spell_id = 40466;         // Stormstrike
5679                         chance = 50.f;
5680                     }
5681                     else
5682                         return false;
5683
5684                     if (!roll_chance_f(chance))
5685                         return false;
5686
5687                     target = this;
5688                     break;
5689                 }
5690             }
5691
5692             // Earth Shield
5693             if(dummySpell->SpellFamilyFlags==0x40000000000LL)
5694             {
5695                 if(GetTypeId() != TYPEID_PLAYER)
5696                     return false;
5697
5698                 // heal
5699                 basepoints0 = triggeredByAura->GetModifier()->m_amount;
5700                 target = this;
5701                 triggered_spell_id = 379;
5702                 break;
5703             }
5704             // Lightning Overload
5705             if (dummySpell->SpellIconID == 2018)            // only this spell have SpellFamily Shaman SpellIconID == 2018 and dummy aura
5706             {
5707                 if(!procSpell || GetTypeId() != TYPEID_PLAYER || !pVictim )
5708                     return false;
5709
5710                 // custom cooldown processing case
5711                 if( cooldown && GetTypeId()==TYPEID_PLAYER && ((Player*)this)->HasSpellCooldown(dummySpell->Id))
5712                     return false;
5713
5714                 uint32 spellId = 0;
5715                 // Every Lightning Bolt and Chain Lightning spell have duplicate vs half damage and zero cost
5716                 switch (procSpell->Id)
5717                 {
5718                     // Lightning Bolt
5719                     case   403: spellId = 45284; break;     // Rank  1
5720                     case   529: spellId = 45286; break;     // Rank  2
5721                     case   548: spellId = 45287; break;     // Rank  3
5722                     case   915: spellId = 45288; break;     // Rank  4
5723                     case   943: spellId = 45289; break;     // Rank  5
5724                     case  6041: spellId = 45290; break;     // Rank  6
5725                     case 10391: spellId = 45291; break;     // Rank  7
5726                     case 10392: spellId = 45292; break;     // Rank  8
5727                     case 15207: spellId = 45293; break;     // Rank  9
5728                     case 15208: spellId = 45294; break;     // Rank 10
5729                     case 25448: spellId = 45295; break;     // Rank 11
5730                     case 25449: spellId = 45296; break;     // Rank 12
5731                     // Chain Lightning
5732                     case   421: spellId = 45297; break;     // Rank  1
5733                     case   930: spellId = 45298; break;     // Rank  2
5734                     case  2860: spellId = 45299; break;     // Rank  3
5735                     case 10605: spellId = 45300; break;     // Rank  4
5736                     case 25439: spellId = 45301; break;     // Rank  5
5737                     case 25442: spellId = 45302; break;     // Rank  6
5738                     default:
5739                         sLog.outError("Unit::HandleDummyAuraProc: non handled spell id: %u (LO)", procSpell->Id);
5740                         return false;
5741                 }
5742                 // No thread generated mod
5743                 SpellModifier *mod = new SpellModifier;
5744                 mod->op = SPELLMOD_THREAT;
5745                 mod->value = -100;
5746                 mod->type = SPELLMOD_PCT;
5747                 mod->spellId = dummySpell->Id;
5748                 mod->effectId = 0;
5749                 mod->lastAffected = NULL;
5750                 mod->mask = 0x0000000000000003LL;
5751                 mod->charges = 0;
5752                 ((Player*)this)->AddSpellMod(mod, true);
5753
5754                 // Remove cooldown (Chain Lightning - have Category Recovery time)
5755                 if (procSpell->SpellFamilyFlags & 0x0000000000000002LL)
5756                     ((Player*)this)->RemoveSpellCooldown(spellId);
5757
5758                 // Hmmm.. in most case spells already set half basepoints but...
5759                 // Lightning Bolt (2-10 rank) have full basepoint and half bonus from level
5760                 // As on wiki:
5761                 // BUG: Rank 2 to 10 (and maybe 11) of Lightning Bolt will proc another Bolt with FULL damage (not halved). This bug is known and will probably be fixed soon.
5762                 // So - no add changes :)
5763                 CastSpell(pVictim, spellId, true, castItem, triggeredByAura);
5764
5765                 ((Player*)this)->AddSpellMod(mod, false);
5766
5767                 if( cooldown && GetTypeId()==TYPEID_PLAYER )
5768                     ((Player*)this)->AddSpellCooldown(dummySpell->Id,0,time(NULL) + cooldown);
5769
5770                 return true;
5771             }
5772             break;
5773         }
5774         default:
5775             break;
5776     }
5777
5778     // processed charge only counting case
5779     if(!triggered_spell_id)
5780         return true;
5781
5782     SpellEntry const* triggerEntry = sSpellStore.LookupEntry(triggered_spell_id);
5783
5784     if(!triggerEntry)
5785     {
5786         sLog.outError("Unit::HandleDummyAuraProc: Spell %u have not existed triggered spell %u",dummySpell->Id,triggered_spell_id);
5787         return false;
5788     }
5789
5790     // default case
5791     if(!target || target!=this && !target->isAlive())
5792         return false;
5793
5794     if( cooldown && GetTypeId()==TYPEID_PLAYER && ((Player*)this)->HasSpellCooldown(triggered_spell_id))
5795         return false;
5796
5797     if(basepoints0)
5798         CastCustomSpell(target,triggered_spell_id,&basepoints0,NULL,NULL,true,castItem,triggeredByAura);
5799     else
5800         CastSpell(target,triggered_spell_id,true,castItem,triggeredByAura);
5801
5802     if( cooldown && GetTypeId()==TYPEID_PLAYER )
5803         ((Player*)this)->AddSpellCooldown(triggered_spell_id,0,time(NULL) + cooldown);
5804
5805     return true;
5806 }
5807
5808 bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage, Aura* triggeredByAura, SpellEntry const *procSpell, uint32 procFlags,WeaponAttackType attackType, uint32 cooldown)
5809 {
5810     SpellEntry const* auraSpellInfo = triggeredByAura->GetSpellProto();
5811
5812     Item* castItem = triggeredByAura->GetCastItemGUID() && GetTypeId()==TYPEID_PLAYER
5813         ? ((Player*)this)->GetItemByGuid(triggeredByAura->GetCastItemGUID()) : NULL;
5814
5815     uint32 triggered_spell_id = auraSpellInfo->EffectTriggerSpell[triggeredByAura->GetEffIndex()];
5816     Unit* target = !(procFlags & PROC_FLAG_HEAL) && IsPositiveSpell(triggered_spell_id) ? this : pVictim;
5817     int32 basepoints0 = 0;
5818
5819     switch(auraSpellInfo->SpellFamilyName)
5820     {
5821         case SPELLFAMILY_GENERIC:
5822         {
5823             switch(auraSpellInfo->Id)
5824             {
5825                 // Aegis of Preservation
5826                 case 23780:
5827                     //Aegis Heal (instead non-existed triggered spell)
5828                     triggered_spell_id = 23781;
5829                     target = this;
5830                     break;
5831                 // Elune's Touch (moonkin mana restore)
5832                 case 24905:
5833                 {
5834                     // Elune's Touch (instead non-existed triggered spell)
5835                     triggered_spell_id = 33926;
5836                     basepoints0 = int32(0.3f * GetTotalAttackPowerValue(BASE_ATTACK));
5837                     target = this;
5838                     break;
5839                 }
5840                 // Enlightenment
5841                 case 29601:
5842                 {
5843                     // only for cast with mana price
5844                     if(!procSpell || procSpell->powerType!=POWER_MANA || procSpell->manaCost==0 && procSpell->ManaCostPercentage==0 && procSpell->manaCostPerlevel==0)
5845                         return false;
5846                     break;                                  // fall through to normal cast
5847                 }
5848                 // Health Restore
5849                 case 33510:
5850                 {
5851                     // at melee hit call std triggered spell
5852                     if(procFlags & PROC_FLAG_HIT_MELEE)
5853                         break;                              // fall through to normal cast
5854
5855                     // Mark of Conquest - else (at range hit) called custom case
5856                     triggered_spell_id = 39557;
5857                     target = this;
5858                     break;
5859                 }
5860                 // Shaleskin
5861                 case 36576:
5862                     return true;                            // nothing to do
5863                 // Forgotten Knowledge (Blade of Wizardry)
5864                 case 38319:
5865                     // only for harmful enemy targeted spell
5866                     if(!pVictim || pVictim==this || !procSpell || IsPositiveSpell(procSpell->Id))
5867                         return false;
5868                     break;                              // fall through to normal cast
5869                 // Aura of Wrath (Darkmoon Card: Wrath trinket bonus)
5870                 case 39442:
5871                 {
5872                     // proc only at non-crit hits
5873                     if(procFlags & (PROC_FLAG_CRIT_MELEE|PROC_FLAG_CRIT_RANGED|PROC_FLAG_CRIT_SPELL))
5874                         return false;
5875                     break;                                  // fall through to normal cast
5876                 }
5877                 // Augment Pain (Timbal's Focusing Crystal trinket bonus)
5878                 case 45054:
5879                 {
5880                     if(!procSpell)
5881                         return false;
5882
5883                     //only periodic damage can trigger spell
5884                     bool found = false;
5885                     for(int j = 0; j < 3; ++j)
5886                     {
5887                         if( procSpell->EffectApplyAuraName[j]==SPELL_AURA_PERIODIC_DAMAGE         ||
5888                             procSpell->EffectApplyAuraName[j]==SPELL_AURA_PERIODIC_DAMAGE_PERCENT ||
5889                             procSpell->EffectApplyAuraName[j]==SPELL_AURA_PERIODIC_LEECH          )
5890                         {
5891                             found = true;
5892                             break;
5893                         }
5894                     }
5895                     if(!found)
5896                         return false;
5897
5898                     break;                                  // fall through to normal cast
5899                 }
5900                 // Evasive Maneuvers (Commendation of Kael'thas)
5901                 case 45057:
5902                 {
5903                     // damage taken that reduces below 35% health
5904                     // does NOT mean you must have been >= 35% before
5905                     if (int32(GetHealth())-int32(damage) >= int32(GetMaxHealth()*0.35f))
5906                         return false;
5907                     break;                                  // fall through to normal cast
5908                 }
5909             }
5910
5911             switch(triggered_spell_id)
5912             {
5913                 // Setup
5914                 case 15250:
5915                 {
5916                     // applied only for main target
5917                     if(!pVictim || pVictim != getVictim())
5918                         return false;
5919
5920                     // continue normal case
5921                     break;
5922                 }
5923                 // Shamanistic Rage triggered spell
5924                 case 30824:
5925                     basepoints0 = int32(GetTotalAttackPowerValue(BASE_ATTACK)*triggeredByAura->GetModifier()->m_amount/100);
5926                     break;
5927             }
5928             break;
5929         }
5930         case SPELLFAMILY_MAGE:
5931         {
5932             switch(auraSpellInfo->SpellIconID)
5933             {
5934                 // Blazing Speed
5935                 case 2127:
5936                     //Blazing Speed (instead non-existed triggered spell)
5937                     triggered_spell_id = 31643;
5938                     target = this;
5939                     break;
5940             }
5941             switch(auraSpellInfo->Id)
5942             {
5943                 // Persistent Shield (Scarab Brooch)
5944                 case 26467:
5945                     basepoints0 = int32(damage * 0.15f);
5946                     break;
5947             }
5948             break;
5949         }
5950         case SPELLFAMILY_WARRIOR:
5951         {
5952             //Rampage
5953             if((auraSpellInfo->SpellFamilyFlags & 0x100000) && auraSpellInfo->SpellIconID==2006)
5954             {
5955                 //all ranks have effect[0]==AURA (Proc Trigger Spell, non-existed)
5956                 //and effect[1]==TriggerSpell
5957                 if(auraSpellInfo->Effect[1]!=SPELL_EFFECT_TRIGGER_SPELL)
5958                 {
5959                     sLog.outError("Unit::HandleProcTriggerSpell: Spell %u have wrong effect in RM",triggeredByAura->GetSpellProto()->Id);
5960                     return false;
5961                 }
5962                 triggered_spell_id = auraSpellInfo->EffectTriggerSpell[1];
5963                 break;                                      // fall through to normal cast
5964             }
5965             break;
5966         }
5967         case SPELLFAMILY_WARLOCK:
5968         {
5969             // Pyroclasm
5970             if(auraSpellInfo->SpellFamilyFlags == 0x0000000000000000 && auraSpellInfo->SpellIconID==1137)
5971             {
5972                 // last case for Hellfire that damage caster also but don't must stun caster
5973                 if( pVictim == this )
5974                     return false;
5975
5976                 // custom chance
5977                 float chance = 0;
5978                 switch (triggeredByAura->GetId())
5979                 {
5980                     case 18096: chance = 13.0f; break;
5981                     case 18073: chance = 26.0f; break;
5982                 }
5983                 if (!roll_chance_f(chance))
5984                     return false;
5985
5986                 // Pyroclasm (instead non-existed triggered spell)
5987                 triggered_spell_id = 18093;
5988                 target = pVictim;
5989                 break;
5990             }
5991             // Drain Soul
5992             if(auraSpellInfo->SpellFamilyFlags & 0x0000000000004000)
5993             {
5994                 bool found = false;
5995                 Unit::AuraList const& mAddFlatModifier = GetAurasByType(SPELL_AURA_ADD_FLAT_MODIFIER);
5996                 for(Unit::AuraList::const_iterator i = mAddFlatModifier.begin(); i != mAddFlatModifier.end(); ++i)
5997                 {
5998                     //Improved Drain Soul
5999                     if ((*i)->GetModifier()->m_miscvalue == SPELLMOD_CHANCE_OF_SUCCESS && (*i)->GetSpellProto()->SpellIconID == 113)
6000                     {
6001                         int32 value2 = CalculateSpellDamage((*i)->GetSpellProto(),2,(*i)->GetSpellProto()->EffectBasePoints[2],this);
6002                         basepoints0 = value2 * GetMaxPower(POWER_MANA) / 100;
6003
6004                         // Drain Soul
6005                         triggered_spell_id = 18371;
6006                         target = this;
6007                         found = true;
6008                         break;
6009                     }
6010                 }
6011                 if(!found)
6012                     return false;
6013                 break;                                      // fall through to normal cast
6014             }
6015             break;
6016         }
6017         case SPELLFAMILY_PRIEST:
6018         {
6019             //Blessed Recovery
6020             if(auraSpellInfo->SpellFamilyFlags == 0x00000000LL && auraSpellInfo->SpellIconID==1875)
6021             {
6022                 switch (triggeredByAura->GetSpellProto()->Id)
6023                 {
6024                     case 27811: triggered_spell_id = 27813; break;
6025                     case 27815: triggered_spell_id = 27817; break;
6026                     case 27816: triggered_spell_id = 27818; break;
6027                     default:
6028                         sLog.outError("Unit::HandleProcTriggerSpell: Spell %u not handled in BR",triggeredByAura->GetSpellProto()->Id);
6029                         return false;
6030                 }
6031
6032                 int32 heal_amount = damage * triggeredByAura->GetModifier()->m_amount / 100;
6033                 basepoints0 = heal_amount/3;
6034                 target = this;
6035                 break;
6036             }
6037             // Shadowguard
6038             if((auraSpellInfo->SpellFamilyFlags & 0x80000000LL) && auraSpellInfo->SpellVisual[0]==7958)
6039             {
6040                 switch(triggeredByAura->GetSpellProto()->Id)
6041                 {
6042                     case 18137:
6043                         triggered_spell_id = 28377; break;  // Rank 1
6044                     case 19308:
6045                         triggered_spell_id = 28378; break;  // Rank 2
6046                     case 19309:
6047                         triggered_spell_id = 28379; break;  // Rank 3
6048                     case 19310:
6049                         triggered_spell_id = 28380; break;  // Rank 4
6050                     case 19311:
6051                         triggered_spell_id = 28381; break;  // Rank 5
6052                     case 19312:
6053                         triggered_spell_id = 28382; break;  // Rank 6
6054                     case 25477:
6055                         triggered_spell_id = 28385; break;  // Rank 7
6056                     default:
6057                         sLog.outError("Unit::HandleProcTriggerSpell: Spell %u not handled in SG",triggeredByAura->GetSpellProto()->Id);
6058                         return false;
6059                 }
6060                 target = pVictim;
6061                 break;
6062             }
6063             break;
6064         }
6065         case SPELLFAMILY_DRUID:
6066         {
6067             switch(auraSpellInfo->Id)
6068             {
6069                 // Leader of the Pack (triggering Improved Leader of the Pack heal)
6070                 case 24932:
6071                 {
6072                     if (triggeredByAura->GetModifier()->m_amount == 0)
6073                         return false;
6074                     basepoints0 = triggeredByAura->GetModifier()->m_amount * GetMaxHealth() / 100;
6075                     triggered_spell_id = 34299;
6076                     break;
6077                 };
6078                 // Druid Forms Trinket (Druid Tier5 Trinket, triggers different spells per Form)
6079                 case 37336:
6080                 {
6081                     switch(m_form)
6082                     {
6083                         case FORM_BEAR:
6084                         case FORM_DIREBEAR:
6085                             triggered_spell_id=37340; break;// Ursine Blessing
6086                         case FORM_CAT:
6087                             triggered_spell_id=37341; break;// Feline Blessing
6088                         case FORM_TREE:
6089                             triggered_spell_id=37342; break;// Slyvan Blessing
6090                         case FORM_MOONKIN:
6091                             triggered_spell_id=37343; break;// Lunar Blessing
6092                         case FORM_NONE:
6093                             triggered_spell_id=37344; break;// Cenarion Blessing (for caster form, except FORM_MOONKIN)
6094                         default:
6095                             return false;
6096                     }
6097
6098                     target = this;
6099                     break;
6100                 }
6101             }
6102             break;
6103         }
6104         case SPELLFAMILY_ROGUE:
6105         {
6106             if(auraSpellInfo->SpellFamilyFlags == 0x0000000000000000LL)
6107             {
6108                 switch(auraSpellInfo->SpellIconID)
6109                 {
6110                     // Combat Potency
6111                     case 2260:
6112                     {
6113                         // skip non offhand attacks
6114                         if(attackType!=OFF_ATTACK)
6115                             return false;
6116                         break;                                  // fall through to normal cast
6117                     }
6118                 }
6119             }
6120             break;
6121         }
6122         case SPELLFAMILY_PALADIN:
6123         {
6124             if(auraSpellInfo->SpellFamilyFlags == 0x00000000LL)
6125             {
6126                 switch(auraSpellInfo->Id)
6127                 {
6128                     // Lightning Capacitor
6129                     case 37657:
6130                     {
6131                         // trinket ProcTriggerSpell but for safe checks for player
6132                         if(!castItem || !pVictim || !pVictim->isAlive() || GetTypeId()!=TYPEID_PLAYER)
6133                             return false;
6134
6135                         if(((Player*)this)->HasSpellCooldown(37657))
6136                             return false;
6137
6138                         // stacking
6139                         CastSpell(this, 37658, true, castItem, triggeredByAura);
6140                         // 2.5s cooldown before it can stack again, current system allow 1 sec step in cooldown
6141                         ((Player*)this)->AddSpellCooldown(37657,0,time(NULL)+(roll_chance_i(50) ? 2 : 3));
6142
6143                         // counting
6144                         uint32 count = 0;
6145                         AuraList const& dummyAura = GetAurasByType(SPELL_AURA_DUMMY);
6146                         for(AuraList::const_iterator itr = dummyAura.begin(); itr != dummyAura.end(); ++itr)
6147                             if((*itr)->GetId()==37658)
6148                                 ++count;
6149
6150                         // release at 3 aura in stack
6151                         if(count <= 2)
6152                             return true;                    // main triggered spell casted anyway
6153
6154                         RemoveAurasDueToSpell(37658);
6155                         CastSpell(pVictim, 37661, true, castItem, triggeredByAura);
6156                         return true;
6157                     }
6158                     // Healing Discount
6159                     case 37705:
6160                         // Healing Trance (instead non-existed triggered spell)
6161                         triggered_spell_id = 37706;
6162                         target = this;
6163                         break;
6164                     // HoTs on Heals (Fel Reaver's Piston trinket)
6165                     case 38299:
6166                     {
6167                         // at direct heal effect
6168                         if(!procSpell || !IsSpellHaveEffect(procSpell,SPELL_EFFECT_HEAL))
6169                             return false;
6170
6171                         // single proc at time
6172                         AuraList const& scAuras = GetSingleCastAuras();
6173                         for(AuraList::const_iterator itr = scAuras.begin(); itr != scAuras.end(); ++itr)
6174                             if((*itr)->GetId()==triggered_spell_id)
6175                                 return false;
6176
6177                         // positive cast at victim instead self
6178                         target = pVictim;
6179                         break;
6180                     }
6181                 }
6182                 switch(auraSpellInfo->SpellIconID)
6183                 {
6184                     case 241:
6185                     {
6186                         switch(auraSpellInfo->EffectTriggerSpell[0])
6187                         {
6188                             //Illumination
6189                             case 18350:
6190                             {
6191                                 if(!procSpell)
6192                                     return false;
6193
6194                                 // procspell is triggered spell but we need mana cost of original casted spell
6195                                 uint32 originalSpellId = procSpell->Id;
6196
6197                                 // Holy Shock
6198                                 if(procSpell->SpellFamilyName == SPELLFAMILY_PALADIN)
6199                                 {
6200                                     if(procSpell->SpellFamilyFlags & 0x0001000000000000LL)
6201                                     {
6202                                         switch(procSpell->Id)
6203                                         {
6204                                             case 25914: originalSpellId = 20473; break;
6205                                             case 25913: originalSpellId = 20929; break;
6206                                             case 25903: originalSpellId = 20930; break;
6207                                             case 27175: originalSpellId = 27174; break;
6208                                             case 33074: originalSpellId = 33072; break;
6209                                             default:
6210                                                 sLog.outError("Unit::HandleProcTriggerSpell: Spell %u not handled in HShock",procSpell->Id);
6211                                                 return false;
6212                                         }
6213                                     }
6214                                 }
6215
6216                                 SpellEntry const *originalSpell = sSpellStore.LookupEntry(originalSpellId);
6217                                 if(!originalSpell)
6218                                 {
6219                                     sLog.outError("Unit::HandleProcTriggerSpell: Spell %u unknown but selected as original in Illu",originalSpellId);
6220                                     return false;
6221                                 }
6222
6223                                 // percent stored in effect 1 (class scripts) base points
6224                                 int32 percent = auraSpellInfo->EffectBasePoints[1]+1;
6225
6226                                 basepoints0 = originalSpell->manaCost*percent/100;
6227                                 triggered_spell_id = 20272;
6228                                 target = this;
6229                                 break;
6230                             }
6231                         }
6232                         break;
6233                     }
6234                 }
6235             }
6236             if(auraSpellInfo->SpellFamilyFlags & 0x00080000)
6237             {
6238                 switch(auraSpellInfo->SpellIconID)
6239                 {
6240                     //Judgement of Wisdom (overwrite non existing triggered spell call in spell.dbc
6241                     case 206:
6242                     {
6243                         if(!pVictim || !pVictim->isAlive())
6244                             return false;
6245
6246                         switch(triggeredByAura->GetSpellProto()->Id)
6247                         {
6248                             case 20186:
6249                                 triggered_spell_id = 20268; // Rank 1
6250                                 break;
6251                             case 20354:
6252                                 triggered_spell_id = 20352; // Rank 2
6253                                 break;
6254                             case 20355:
6255                                 triggered_spell_id = 20353; // Rank 3
6256                                 break;
6257                             case 27164:
6258                                 triggered_spell_id = 27165; // Rank 4
6259                                 break;
6260                             default:
6261                                 sLog.outError("Unit::HandleProcTriggerSpell: Spell %u not handled in JoW",triggeredByAura->GetSpellProto()->Id);
6262                                 return false;
6263                         }
6264
6265                         pVictim->CastSpell(pVictim,triggered_spell_id,true,castItem,triggeredByAura,GetGUID());
6266                         return true;                        // no hidden cooldown
6267                     }
6268                     //Judgement of Light
6269                     case 299:
6270                     {
6271                         if(!pVictim || !pVictim->isAlive())
6272                             return false;
6273
6274                         // overwrite non existing triggered spell call in spell.dbc
6275                         switch(triggeredByAura->GetSpellProto()->Id)
6276                         {
6277                             case 20185:
6278                                 triggered_spell_id = 20267; // Rank 1
6279                                 break;
6280                             case 20344:
6281                                 triggered_spell_id = 20341; // Rank 2
6282                                 break;
6283                             case 20345:
6284                                 triggered_spell_id = 20342; // Rank 3
6285                                 break;
6286                             case 20346:
6287                                 triggered_spell_id = 20343; // Rank 4
6288                                 break;
6289                             case 27162:
6290                                 triggered_spell_id = 27163; // Rank 5
6291                                 break;
6292                             default:
6293                                 sLog.outError("Unit::HandleProcTriggerSpell: Spell %u not handled in JoL",triggeredByAura->GetSpellProto()->Id);
6294                                 return false;
6295                         }
6296                         pVictim->CastSpell(pVictim,triggered_spell_id,true,castItem,triggeredByAura,GetGUID());
6297                         return true;                        // no hidden cooldown
6298                     }
6299                 }
6300             }
6301             // custom check for proc spell
6302             switch(auraSpellInfo->Id)
6303             {
6304                 // Bonus Healing (item spell)
6305                 case 40971:
6306                 {
6307                     if(!pVictim || !pVictim->isAlive())
6308                         return false;
6309
6310                     // bonus if health < 50%
6311                     if(pVictim->GetHealth() >= pVictim->GetMaxHealth()*triggeredByAura->GetModifier()->m_amount/100)
6312                         return false;
6313
6314                     // cast at target positive spell
6315                     target = pVictim;
6316                     break;
6317                 }
6318             }
6319             switch(triggered_spell_id)
6320             {
6321                 // Seal of Command
6322                 case 20424:
6323                     // prevent chain of triggered spell from same triggered spell
6324                     if(procSpell && procSpell->Id==20424)
6325                         return false;
6326                     break;
6327             }
6328             break;
6329         }
6330         case SPELLFAMILY_SHAMAN:
6331         {
6332             if(auraSpellInfo->SpellFamilyFlags == 0x0000000000000000)
6333             {
6334                 switch(auraSpellInfo->SpellIconID)
6335                 {
6336                     case 19:
6337                     {
6338                         switch(auraSpellInfo->Id)
6339                         {
6340                             case 23551:                     // Lightning Shield - Tier2: 8 pieces proc shield
6341                             {
6342                                 // Lightning Shield (overwrite non existing triggered spell call in spell.dbc)
6343                                 triggered_spell_id = 23552;
6344                                 target = pVictim;
6345                                 break;
6346                             }
6347                             case 23552:                     // Lightning Shield - trigger shield damage
6348                             {
6349                                 // Lightning Shield (overwrite non existing triggered spell call in spell.dbc)
6350                                 triggered_spell_id = 27635;
6351                                 target = pVictim;
6352                                 break;
6353                             }
6354                         }
6355                         break;
6356                     }
6357                     // Mana Surge (Shaman T1 bonus)
6358                     case 87:
6359                     {
6360                         if(!procSpell)
6361                             return false;
6362
6363                         basepoints0 = procSpell->manaCost * 35/100;
6364                         triggered_spell_id = 23571;
6365                         target = this;
6366                         break;
6367                     }
6368                     //Nature's Guardian
6369                     case 2013:
6370                     {
6371                         if(GetTypeId()!=TYPEID_PLAYER)
6372                             return false;
6373
6374                         // damage taken that reduces below 30% health
6375                         // does NOT mean you must have been >= 30% before
6376                         if (10*(int32(GetHealth())-int32(damage)) >= 3*GetMaxHealth())
6377                             return false;
6378
6379                         triggered_spell_id = 31616;
6380
6381                         // need check cooldown now
6382                         if( cooldown && ((Player*)this)->HasSpellCooldown(triggered_spell_id))
6383                             return false;
6384
6385                         basepoints0 = triggeredByAura->GetModifier()->m_amount * GetMaxHealth() / 100;
6386                         target = this;
6387                         if(pVictim && pVictim->isAlive())
6388                             pVictim->getThreatManager().modifyThreatPercent(this,-10);
6389                         break;
6390                     }
6391                 }
6392             }
6393
6394             // Water Shield (we can't set cooldown for main spell - it's player casted spell
6395             if((auraSpellInfo->SpellFamilyFlags & 0x0000002000000000LL) && auraSpellInfo->SpellVisual[0]==7358)
6396             {
6397                 target = this;
6398                 break;
6399             }
6400
6401             // Lightning Shield
6402             if((auraSpellInfo->SpellFamilyFlags & 0x00000400) && auraSpellInfo->SpellVisual[0]==37)
6403             {
6404                 // overwrite non existing triggered spell call in spell.dbc
6405                 switch(triggeredByAura->GetSpellProto()->Id)
6406                 {
6407                     case   324:
6408                         triggered_spell_id = 26364; break;  // Rank 1
6409                     case   325:
6410                         triggered_spell_id = 26365; break;  // Rank 2
6411                     case   905:
6412                         triggered_spell_id = 26366; break;  // Rank 3
6413                     case   945:
6414                         triggered_spell_id = 26367; break;  // Rank 4
6415                     case  8134:
6416                         triggered_spell_id = 26369; break;  // Rank 5
6417                     case 10431:
6418                         triggered_spell_id = 26370; break;  // Rank 6
6419                     case 10432:
6420                         triggered_spell_id = 26363; break;  // Rank 7
6421                     case 25469:
6422                         triggered_spell_id = 26371; break;  // Rank 8
6423                     case 25472:
6424                         triggered_spell_id = 26372; break;  // Rank 9
6425                     default:
6426                         sLog.outError("Unit::HandleProcTriggerSpell: Spell %u not handled in LShield",triggeredByAura->GetSpellProto()->Id);
6427                         return false;
6428                 }
6429
6430                 target = pVictim;
6431                 break;
6432             }
6433             break;
6434         }
6435     }
6436
6437     // standard non-dummy case
6438     if(!triggered_spell_id)
6439     {
6440         sLog.outError("Unit::HandleProcTriggerSpell: Spell %u have 0 in EffectTriggered[%d], not handled custom case?",auraSpellInfo->Id,triggeredByAura->GetEffIndex());
6441         return false;
6442     }
6443
6444     SpellEntry const* triggerEntry = sSpellStore.LookupEntry(triggered_spell_id);
6445
6446     if(!triggerEntry)
6447     {
6448         sLog.outError("Unit::HandleProcTriggerSpell: Spell %u have not existed EffectTriggered[%d]=%u, not handled custom case?",auraSpellInfo->Id,triggeredByAura->GetEffIndex(),triggered_spell_id);
6449         return false;
6450     }
6451
6452     // not allow proc extra attack spell at extra attack
6453     if( m_extraAttacks && IsSpellHaveEffect(triggerEntry,SPELL_EFFECT_ADD_EXTRA_ATTACKS) )
6454         return false;
6455
6456     if( cooldown && GetTypeId()==TYPEID_PLAYER && ((Player*)this)->HasSpellCooldown(triggered_spell_id))
6457         return false;
6458
6459     // default case
6460     if(!target || target!=this && !target->isAlive())
6461         return false;
6462
6463     if(basepoints0)
6464         CastCustomSpell(target,triggered_spell_id,&basepoints0,NULL,NULL,true,castItem,triggeredByAura);
6465     else
6466         CastSpell(target,triggered_spell_id,true,castItem,triggeredByAura);
6467
6468     if( cooldown && GetTypeId()==TYPEID_PLAYER )
6469         ((Player*)this)->AddSpellCooldown(triggered_spell_id,0,time(NULL) + cooldown);
6470
6471     return true;
6472 }
6473
6474 bool Unit::HandleOverrideClassScriptAuraProc(Unit *pVictim, Aura *triggeredByAura, SpellEntry const *procSpell, uint32 cooldown)
6475 {
6476     int32 scriptId = triggeredByAura->GetModifier()->m_miscvalue;
6477
6478     if(!pVictim || !pVictim->isAlive())
6479         return false;
6480
6481     Item* castItem = triggeredByAura->GetCastItemGUID() && GetTypeId()==TYPEID_PLAYER
6482         ? ((Player*)this)->GetItemByGuid(triggeredByAura->GetCastItemGUID()) : NULL;
6483
6484     uint32 triggered_spell_id = 0;
6485
6486     switch(scriptId)
6487     {
6488         case 836:                                           // Improved Blizzard (Rank 1)
6489         {
6490             if (!procSpell || procSpell->SpellVisual[0]!=9487)
6491                 return false;
6492             triggered_spell_id = 12484;
6493             break;
6494         }
6495         case 988:                                           // Improved Blizzard (Rank 2)
6496         {
6497             if (!procSpell || procSpell->SpellVisual[0]!=9487)
6498                 return false;
6499             triggered_spell_id = 12485;
6500             break;
6501         }
6502         case 989:                                           // Improved Blizzard (Rank 3)
6503         {
6504             if (!procSpell || procSpell->SpellVisual[0]!=9487)
6505                 return false;
6506             triggered_spell_id = 12486;
6507             break;
6508         }
6509         case 4086:                                          // Improved Mend Pet (Rank 1)
6510         case 4087:                                          // Improved Mend Pet (Rank 2)
6511         {
6512             int32 chance = triggeredByAura->GetSpellProto()->EffectBasePoints[triggeredByAura->GetEffIndex()];
6513             if(!roll_chance_i(chance))
6514                 return false;
6515
6516             triggered_spell_id = 24406;
6517             break;
6518         }
6519         case 4533:                                          // Dreamwalker Raiment 2 pieces bonus
6520         {
6521             // Chance 50%
6522             if (!roll_chance_i(50))
6523                 return false;
6524
6525             switch (pVictim->getPowerType())
6526             {
6527                 case POWER_MANA:   triggered_spell_id = 28722; break;
6528                 case POWER_RAGE:   triggered_spell_id = 28723; break;
6529                 case POWER_ENERGY: triggered_spell_id = 28724; break;
6530                 default:
6531                     return false;
6532             }
6533             break;
6534         }
6535         case 4537:                                          // Dreamwalker Raiment 6 pieces bonus
6536             triggered_spell_id = 28750;                     // Blessing of the Claw
6537             break;
6538         case 5497:                                          // Improved Mana Gems (Serpent-Coil Braid)
6539             triggered_spell_id = 37445;                     // Mana Surge
6540             break;
6541     }
6542
6543     // not processed
6544     if(!triggered_spell_id)
6545         return false;
6546
6547     // standard non-dummy case
6548     SpellEntry const* triggerEntry = sSpellStore.LookupEntry(triggered_spell_id);
6549
6550     if(!triggerEntry)
6551     {
6552         sLog.outError("Unit::HandleOverrideClassScriptAuraProc: Spell %u triggering for class script id %u",triggered_spell_id,scriptId);
6553         return false;
6554     }
6555
6556     if( cooldown && GetTypeId()==TYPEID_PLAYER && ((Player*)this)->HasSpellCooldown(triggered_spell_id))
6557         return false;
6558
6559     CastSpell(pVictim, triggered_spell_id, true, castItem, triggeredByAura);
6560
6561     if( cooldown && GetTypeId()==TYPEID_PLAYER )
6562         ((Player*)this)->AddSpellCooldown(triggered_spell_id,0,time(NULL) + cooldown);
6563
6564     return true;
6565 }
6566
6567 void Unit::setPowerType(Powers new_powertype)
6568 {
6569     SetByteValue(UNIT_FIELD_BYTES_0, 3, new_powertype);
6570
6571     if(GetTypeId() == TYPEID_PLAYER)
6572     {
6573         if(((Player*)this)->GetGroup())
6574             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_POWER_TYPE);
6575     }
6576     else if(((Creature*)this)->isPet())
6577     {
6578         Pet *pet = ((Pet*)this);
6579         if(pet->isControlled())
6580         {
6581             Unit *owner = GetOwner();
6582             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
6583                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_POWER_TYPE);
6584         }
6585     }
6586
6587     switch(new_powertype)
6588     {
6589         default:
6590         case POWER_MANA:
6591             break;
6592         case POWER_RAGE:
6593             SetMaxPower(POWER_RAGE,GetCreatePowers(POWER_RAGE));
6594             SetPower(   POWER_RAGE,0);
6595             break;
6596         case POWER_FOCUS:
6597             SetMaxPower(POWER_FOCUS,GetCreatePowers(POWER_FOCUS));
6598             SetPower(   POWER_FOCUS,GetCreatePowers(POWER_FOCUS));
6599             break;
6600         case POWER_ENERGY:
6601             SetMaxPower(POWER_ENERGY,GetCreatePowers(POWER_ENERGY));
6602             SetPower(   POWER_ENERGY,0);
6603             break;
6604         case POWER_HAPPINESS:
6605             SetMaxPower(POWER_HAPPINESS,GetCreatePowers(POWER_HAPPINESS));
6606             SetPower(POWER_HAPPINESS,GetCreatePowers(POWER_HAPPINESS));
6607             break;
6608     }
6609 }
6610
6611 FactionTemplateEntry const* Unit::getFactionTemplateEntry() const
6612 {
6613     FactionTemplateEntry const* entry = sFactionTemplateStore.LookupEntry(getFaction());
6614     if(!entry)
6615     {
6616         static uint64 guid = 0;                             // prevent repeating spam same faction problem
6617
6618         if(GetGUID() != guid)
6619         {
6620             if(GetTypeId() == TYPEID_PLAYER)
6621                 sLog.outError("Player %s have invalid faction (faction template id) #%u", ((Player*)this)->GetName(), getFaction());
6622             else
6623                 sLog.outError("Creature (template id: %u) have invalid faction (faction template id) #%u", ((Creature*)this)->GetCreatureInfo()->Entry, getFaction());
6624             guid = GetGUID();
6625         }
6626     }
6627     return entry;
6628 }
6629
6630 bool Unit::IsHostileTo(Unit const* unit) const
6631 {
6632     // always non-hostile to self
6633     if(unit==this)
6634         return false;
6635
6636     // always non-hostile to GM in GM mode
6637     if(unit->GetTypeId()==TYPEID_PLAYER && ((Player const*)unit)->isGameMaster())
6638         return false;
6639
6640     // always hostile to enemy
6641     if(getVictim()==unit || unit->getVictim()==this)
6642         return true;
6643
6644     // test pet/charm masters instead pers/charmeds
6645     Unit const* testerOwner = GetCharmerOrOwner();
6646     Unit const* targetOwner = unit->GetCharmerOrOwner();
6647
6648     // always hostile to owner's enemy
6649     if(testerOwner && (testerOwner->getVictim()==unit || unit->getVictim()==testerOwner))
6650         return true;
6651
6652     // always hostile to enemy owner
6653     if(targetOwner && (getVictim()==targetOwner || targetOwner->getVictim()==this))
6654         return true;
6655
6656     // always hostile to owner of owner's enemy
6657     if(testerOwner && targetOwner && (testerOwner->getVictim()==targetOwner || targetOwner->getVictim()==testerOwner))
6658         return true;
6659
6660     Unit const* tester = testerOwner ? testerOwner : this;
6661     Unit const* target = targetOwner ? targetOwner : unit;
6662
6663     // always non-hostile to target with common owner, or to owner/pet
6664     if(tester==target)
6665         return false;
6666
6667     // special cases (Duel, etc)
6668     if(tester->GetTypeId()==TYPEID_PLAYER && target->GetTypeId()==TYPEID_PLAYER)
6669     {
6670         Player const* pTester = (Player const*)tester;
6671         Player const* pTarget = (Player const*)target;
6672
6673         // Duel
6674         if(pTester->duel && pTester->duel->opponent == pTarget && pTester->duel->startTime != 0)
6675             return true;
6676
6677         // Group
6678         if(pTester->GetGroup() && pTester->GetGroup()==pTarget->GetGroup())
6679             return false;
6680
6681         // Sanctuary
6682         if(pTarget->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_SANCTUARY) && pTester->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_SANCTUARY))
6683             return false;
6684
6685         // PvP FFA state
6686         if(pTester->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_FFA_PVP) && pTarget->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_FFA_PVP))
6687             return true;
6688
6689         //= PvP states
6690         // Green/Blue (can't attack)
6691         if(pTester->GetTeam()==pTarget->GetTeam())
6692             return false;
6693
6694         // Red (can attack) if true, Blue/Yellow (can't attack) in another case
6695         return pTester->IsPvP() && pTarget->IsPvP();
6696     }
6697
6698     // faction base cases
6699     FactionTemplateEntry const*tester_faction = tester->getFactionTemplateEntry();
6700     FactionTemplateEntry const*target_faction = target->getFactionTemplateEntry();
6701     if(!tester_faction || !target_faction)
6702         return false;
6703
6704     if(target->isAttackingPlayer() && tester->IsContestedGuard())
6705         return true;
6706
6707     // PvC forced reaction and reputation case
6708     if(tester->GetTypeId()==TYPEID_PLAYER)
6709     {
6710         // forced reaction
6711         ForcedReactions::const_iterator forceItr = ((Player*)tester)->m_forcedReactions.find(target_faction->faction);
6712         if(forceItr!=((Player*)tester)->m_forcedReactions.end())
6713             return forceItr->second <= REP_HOSTILE;
6714
6715         // if faction have reputation then hostile state for tester at 100% dependent from at_war state
6716         if(FactionEntry const* raw_target_faction = sFactionStore.LookupEntry(target_faction->faction))
6717             if(raw_target_faction->reputationListID >=0)
6718                 if(FactionState const* factionState = ((Player*)tester)->GetFactionState(raw_target_faction))
6719                     return (factionState->Flags & FACTION_FLAG_AT_WAR);
6720     }
6721     // CvP forced reaction and reputation case
6722     else if(target->GetTypeId()==TYPEID_PLAYER)
6723     {
6724         // forced reaction
6725         ForcedReactions::const_iterator forceItr = ((Player const*)target)->m_forcedReactions.find(tester_faction->faction);
6726         if(forceItr!=((Player const*)target)->m_forcedReactions.end())
6727             return forceItr->second <= REP_HOSTILE;
6728
6729         // apply reputation state
6730         FactionEntry const* raw_tester_faction = sFactionStore.LookupEntry(tester_faction->faction);
6731         if(raw_tester_faction && raw_tester_faction->reputationListID >=0 )
6732             return ((Player const*)target)->GetReputationRank(raw_tester_faction) <= REP_HOSTILE;
6733     }
6734
6735     // common faction based case (CvC,PvC,CvP)
6736     return tester_faction->IsHostileTo(*target_faction);
6737 }
6738
6739 bool Unit::IsFriendlyTo(Unit const* unit) const
6740 {
6741     // always friendly to self
6742     if(unit==this)
6743         return true;
6744
6745     // always friendly to GM in GM mode
6746     if(unit->GetTypeId()==TYPEID_PLAYER && ((Player const*)unit)->isGameMaster())
6747         return true;
6748
6749     // always non-friendly to enemy
6750     if(getVictim()==unit || unit->getVictim()==this)
6751         return false;
6752
6753     // test pet/charm masters instead pers/charmeds
6754     Unit const* testerOwner = GetCharmerOrOwner();
6755     Unit const* targetOwner = unit->GetCharmerOrOwner();
6756
6757     // always non-friendly to owner's enemy
6758     if(testerOwner && (testerOwner->getVictim()==unit || unit->getVictim()==testerOwner))
6759         return false;
6760
6761     // always non-friendly to enemy owner
6762     if(targetOwner && (getVictim()==targetOwner || targetOwner->getVictim()==this))
6763         return false;
6764
6765     // always non-friendly to owner of owner's enemy
6766     if(testerOwner && targetOwner && (testerOwner->getVictim()==targetOwner || targetOwner->getVictim()==testerOwner))
6767         return false;
6768
6769     Unit const* tester = testerOwner ? testerOwner : this;
6770     Unit const* target = targetOwner ? targetOwner : unit;
6771
6772     // always friendly to target with common owner, or to owner/pet
6773     if(tester==target)
6774         return true;
6775
6776     // special cases (Duel)
6777     if(tester->GetTypeId()==TYPEID_PLAYER && target->GetTypeId()==TYPEID_PLAYER)
6778     {
6779         Player const* pTester = (Player const*)tester;
6780         Player const* pTarget = (Player const*)target;
6781
6782         // Duel
6783         if(pTester->duel && pTester->duel->opponent == target && pTester->duel->startTime != 0)
6784             return false;
6785
6786         // Group
6787         if(pTester->GetGroup() && pTester->GetGroup()==pTarget->GetGroup())
6788             return true;
6789
6790         // Sanctuary
6791         if(pTarget->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_SANCTUARY) && pTester->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_SANCTUARY))
6792             return true;
6793
6794         // PvP FFA state
6795         if(pTester->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_FFA_PVP) && pTarget->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_FFA_PVP))
6796             return false;
6797
6798         //= PvP states
6799         // Green/Blue (non-attackable)
6800         if(pTester->GetTeam()==pTarget->GetTeam())
6801             return true;
6802
6803         // Blue (friendly/non-attackable) if not PVP, or Yellow/Red in another case (attackable)
6804         return !pTarget->IsPvP();
6805     }
6806
6807     // faction base cases
6808     FactionTemplateEntry const*tester_faction = tester->getFactionTemplateEntry();
6809     FactionTemplateEntry const*target_faction = target->getFactionTemplateEntry();
6810     if(!tester_faction || !target_faction)
6811         return false;
6812
6813     if(target->isAttackingPlayer() && tester->IsContestedGuard())
6814         return false;
6815
6816     // PvC forced reaction and reputation case
6817     if(tester->GetTypeId()==TYPEID_PLAYER)
6818     {
6819         // forced reaction
6820         ForcedReactions::const_iterator forceItr = ((Player const*)tester)->m_forcedReactions.find(target_faction->faction);
6821         if(forceItr!=((Player const*)tester)->m_forcedReactions.end())
6822             return forceItr->second >= REP_FRIENDLY;
6823
6824         // if faction have reputation then friendly state for tester at 100% dependent from at_war state
6825         if(FactionEntry const* raw_target_faction = sFactionStore.LookupEntry(target_faction->faction))
6826             if(raw_target_faction->reputationListID >=0)
6827                 if(FactionState const* FactionState = ((Player*)tester)->GetFactionState(raw_target_faction))
6828                     return !(FactionState->Flags & FACTION_FLAG_AT_WAR);
6829     }
6830     // CvP forced reaction and reputation case
6831     else if(target->GetTypeId()==TYPEID_PLAYER)
6832     {
6833         // forced reaction
6834         ForcedReactions::const_iterator forceItr = ((Player const*)target)->m_forcedReactions.find(tester_faction->faction);
6835         if(forceItr!=((Player const*)target)->m_forcedReactions.end())
6836             return forceItr->second >= REP_FRIENDLY;
6837
6838         // apply reputation state
6839         if(FactionEntry const* raw_tester_faction = sFactionStore.LookupEntry(tester_faction->faction))
6840             if(raw_tester_faction->reputationListID >=0 )
6841                 return ((Player const*)target)->GetReputationRank(raw_tester_faction) >= REP_FRIENDLY;
6842     }
6843
6844     // common faction based case (CvC,PvC,CvP)
6845     return tester_faction->IsFriendlyTo(*target_faction);
6846 }
6847
6848 bool Unit::IsHostileToPlayers() const
6849 {
6850     FactionTemplateEntry const* my_faction = getFactionTemplateEntry();
6851     if(!my_faction)
6852         return false;
6853
6854     FactionEntry const* raw_faction = sFactionStore.LookupEntry(my_faction->faction);
6855     if(raw_faction && raw_faction->reputationListID >=0 )
6856         return false;
6857
6858     return my_faction->IsHostileToPlayers();
6859 }
6860
6861 bool Unit::IsNeutralToAll() const
6862 {
6863     FactionTemplateEntry const* my_faction = getFactionTemplateEntry();
6864     if(!my_faction)
6865         return true;
6866
6867     FactionEntry const* raw_faction = sFactionStore.LookupEntry(my_faction->faction);
6868     if(raw_faction && raw_faction->reputationListID >=0 )
6869         return false;
6870
6871     return my_faction->IsNeutralToAll();
6872 }
6873
6874 bool Unit::Attack(Unit *victim, bool meleeAttack)
6875 {
6876     if(!victim || victim == this)
6877         return false;
6878
6879     // dead units can neither attack nor be attacked
6880     if(!isAlive() || !victim->isAlive())
6881         return false;
6882
6883     // player cannot attack in mount state
6884     if(GetTypeId()==TYPEID_PLAYER && IsMounted())
6885         return false;
6886
6887     // nobody can attack GM in GM-mode
6888     if(victim->GetTypeId()==TYPEID_PLAYER)
6889     {
6890         if(((Player*)victim)->isGameMaster())
6891             return false;
6892     }
6893     else
6894     {
6895         if(((Creature*)victim)->IsInEvadeMode())
6896             return false;
6897     }
6898
6899     // remove SPELL_AURA_MOD_UNATTACKABLE at attack (in case non-interruptible spells stun aura applied also that not let attack)
6900     if(HasAuraType(SPELL_AURA_MOD_UNATTACKABLE))
6901         RemoveSpellsCausingAura(SPELL_AURA_MOD_UNATTACKABLE);
6902
6903     if (m_attacking)
6904     {
6905         if (m_attacking == victim)
6906         {
6907             // switch to melee attack from ranged/magic
6908             if( meleeAttack && !hasUnitState(UNIT_STAT_MELEE_ATTACKING) )
6909             {
6910                 addUnitState(UNIT_STAT_MELEE_ATTACKING);
6911                 SendAttackStart(victim);
6912                 return true;
6913             }
6914             return false;
6915         }
6916         AttackStop();
6917     }
6918
6919     //Set our target
6920     SetUInt64Value(UNIT_FIELD_TARGET, victim->GetGUID());
6921
6922     if(meleeAttack)
6923         addUnitState(UNIT_STAT_MELEE_ATTACKING);
6924     m_attacking = victim;
6925     m_attacking->_addAttacker(this);
6926
6927     if(m_attacking->GetTypeId()==TYPEID_UNIT && ((Creature*)m_attacking)->AI())
6928         ((Creature*)m_attacking)->AI()->AttackedBy(this);
6929
6930     if(GetTypeId()==TYPEID_UNIT)
6931     {
6932         WorldPacket data(SMSG_AI_REACTION, 12);
6933         data << uint64(GetGUID());
6934         data << uint32(AI_REACTION_AGGRO);                  // Aggro sound
6935         ((WorldObject*)this)->SendMessageToSet(&data, true);
6936
6937         ((Creature*)this)->CallAssistence();
6938         ((Creature*)this)->SetCombatStartPosition(GetPositionX(), GetPositionY(), GetPositionZ());
6939     }
6940
6941     // delay offhand weapon attack to next attack time
6942     if(haveOffhandWeapon())
6943         resetAttackTimer(OFF_ATTACK);
6944
6945     if(meleeAttack)
6946         SendAttackStart(victim);
6947
6948     return true;
6949 }
6950
6951 bool Unit::AttackStop()
6952 {
6953     if (!m_attacking)
6954         return false;
6955
6956     Unit* victim = m_attacking;
6957
6958     m_attacking->_removeAttacker(this);
6959     m_attacking = NULL;
6960
6961     //Clear our target
6962     SetUInt64Value(UNIT_FIELD_TARGET, 0);
6963
6964     clearUnitState(UNIT_STAT_MELEE_ATTACKING);
6965
6966     InterruptSpell(CURRENT_MELEE_SPELL);
6967
6968     if( GetTypeId()==TYPEID_UNIT )
6969     {
6970         // reset call assistance
6971         ((Creature*)this)->SetNoCallAssistence(false);
6972     }
6973
6974     SendAttackStop(victim);
6975
6976     return true;
6977 }
6978
6979 void Unit::CombatStop(bool cast)
6980 {
6981     if(cast& IsNonMeleeSpellCasted(false))
6982         InterruptNonMeleeSpells(false);
6983
6984     AttackStop();
6985     RemoveAllAttackers();
6986     if( GetTypeId()==TYPEID_PLAYER )
6987         ((Player*)this)->SendAttackSwingCancelAttack();     // melee and ranged forced attack cancel
6988     ClearInCombat();
6989 }
6990
6991 void Unit::CombatStopWithPets(bool cast)
6992 {
6993     CombatStop(cast);
6994     if(Pet* pet = GetPet())
6995         pet->CombatStop(cast);
6996     if(Unit* charm = GetCharm())
6997         charm->CombatStop(cast);
6998     if(GetTypeId()==TYPEID_PLAYER)
6999     {
7000         GuardianPetList const& guardians = ((Player*)this)->GetGuardians();
7001         for(GuardianPetList::const_iterator itr = guardians.begin(); itr != guardians.end(); ++itr)
7002             if(Unit* guardian = Unit::GetUnit(*this,*itr))
7003                 guardian->CombatStop(cast);
7004     }
7005 }
7006
7007 bool Unit::isAttackingPlayer() const
7008 {
7009     if(hasUnitState(UNIT_STAT_ATTACK_PLAYER))
7010         return true;
7011
7012     Pet* pet = GetPet();
7013     if(pet && pet->isAttackingPlayer())
7014         return true;
7015
7016     Unit* charmed = GetCharm();
7017     if(charmed && charmed->isAttackingPlayer())
7018         return true;
7019
7020     for (int8 i = 0; i < MAX_TOTEM; i++)
7021     {
7022         if(m_TotemSlot[i])
7023         {
7024             Creature *totem = ObjectAccessor::GetCreature(*this, m_TotemSlot[i]);
7025             if(totem && totem->isAttackingPlayer())
7026                 return true;
7027         }
7028     }
7029
7030     return false;
7031 }
7032
7033 void Unit::RemoveAllAttackers()
7034 {
7035     while (!m_attackers.empty())
7036     {
7037         AttackerSet::iterator iter = m_attackers.begin();
7038         if(!(*iter)->AttackStop())
7039         {
7040             sLog.outError("WORLD: Unit has an attacker that isn't attacking it!");
7041             m_attackers.erase(iter);
7042         }
7043     }
7044 }
7045
7046 void Unit::ModifyAuraState(AuraState flag, bool apply)
7047 {
7048     if (apply)
7049     {
7050         if (!HasFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1)))
7051         {
7052             SetFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1));
7053             if(GetTypeId() == TYPEID_PLAYER)
7054             {
7055                 const PlayerSpellMap& sp_list = ((Player*)this)->GetSpellMap();
7056                 for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
7057                 {
7058                     if(itr->second->state == PLAYERSPELL_REMOVED) continue;
7059                     SpellEntry const *spellInfo = sSpellStore.LookupEntry(itr->first);
7060                     if (!spellInfo || !IsPassiveSpell(itr->first)) continue;
7061                     if (spellInfo->CasterAuraState == flag)
7062                         CastSpell(this, itr->first, true, NULL);
7063                 }
7064             }
7065         }
7066     }
7067     else
7068     {
7069         if (HasFlag(UNIT_FIELD_AURASTATE,1<<(flag-1)))
7070         {
7071             RemoveFlag(UNIT_FIELD_AURASTATE, 1<<(flag-1));
7072             Unit::AuraMap& tAuras = GetAuras();
7073             for (Unit::AuraMap::iterator itr = tAuras.begin(); itr != tAuras.end();)
7074             {
7075                 SpellEntry const* spellProto = (*itr).second->GetSpellProto();
7076                 if (spellProto->CasterAuraState == flag)
7077                 {
7078                     // exceptions (applied at state but not removed at state change)
7079                     // Rampage
7080                     if(spellProto->SpellIconID==2006 && spellProto->SpellFamilyName==SPELLFAMILY_WARRIOR && spellProto->SpellFamilyFlags==0x100000)
7081                     {
7082                         ++itr;
7083                         continue;
7084                     }
7085
7086                     RemoveAura(itr);
7087                 }
7088                 else
7089                     ++itr;
7090             }
7091         }
7092     }
7093 }
7094
7095 Unit *Unit::GetOwner() const
7096 {
7097     uint64 ownerid = GetOwnerGUID();
7098     if(!ownerid)
7099         return NULL;
7100     return ObjectAccessor::GetUnit(*this, ownerid);
7101 }
7102
7103 Unit *Unit::GetCharmer() const
7104 {
7105     if(uint64 charmerid = GetCharmerGUID())
7106         return ObjectAccessor::GetUnit(*this, charmerid);
7107     return NULL;
7108 }
7109
7110 Player* Unit::GetCharmerOrOwnerPlayerOrPlayerItself()
7111 {
7112     uint64 guid = GetCharmerOrOwnerGUID();
7113     if(IS_PLAYER_GUID(guid))
7114         return ObjectAccessor::GetPlayer(*this, guid);
7115
7116     return GetTypeId()==TYPEID_PLAYER ? (Player*)this : NULL;
7117 }
7118
7119 Pet* Unit::GetPet() const
7120 {
7121     if(uint64 pet_guid = GetPetGUID())
7122     {
7123         if(Pet* pet = ObjectAccessor::GetPet(pet_guid))
7124             return pet;
7125
7126         sLog.outError("Unit::GetPet: Pet %u not exist.",GUID_LOPART(pet_guid));
7127         const_cast<Unit*>(this)->SetPet(0);
7128     }
7129
7130     return NULL;
7131 }
7132
7133 Unit* Unit::GetCharm() const
7134 {
7135     if(uint64 charm_guid = GetCharmGUID())
7136     {
7137         if(Unit* pet = ObjectAccessor::GetUnit(*this, charm_guid))
7138             return pet;
7139
7140         sLog.outError("Unit::GetCharm: Charmed creature %u not exist.",GUID_LOPART(charm_guid));
7141         const_cast<Unit*>(this)->SetCharm(0);
7142     }
7143
7144     return NULL;
7145 }
7146
7147 void Unit::SetPet(Pet* pet)
7148 {
7149     SetUInt64Value(UNIT_FIELD_SUMMON, pet ? pet->GetGUID() : 0);
7150
7151     // FIXME: hack, speed must be set only at follow
7152     if(pet)
7153         for(int i = 0; i < MAX_MOVE_TYPE; ++i)
7154             pet->SetSpeed(UnitMoveType(i), m_speed_rate[i], true);
7155 }
7156
7157 void Unit::SetCharm(Unit* pet)
7158 {
7159     SetUInt64Value(UNIT_FIELD_CHARM, pet ? pet->GetGUID() : 0);
7160
7161     if(GetTypeId() == TYPEID_PLAYER)
7162         ((Player*)this)->m_mover = pet ? pet : this;
7163 }
7164
7165 void Unit::UnsummonAllTotems()
7166 {
7167     for (int8 i = 0; i < MAX_TOTEM; ++i)
7168     {
7169         if(!m_TotemSlot[i])
7170             continue;
7171
7172         Creature *OldTotem = ObjectAccessor::GetCreature(*this, m_TotemSlot[i]);
7173         if (OldTotem && OldTotem->isTotem())
7174             ((Totem*)OldTotem)->UnSummon();
7175     }
7176 }
7177
7178 void Unit::SendHealSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, bool critical)
7179 {
7180     // we guess size
7181     WorldPacket data(SMSG_SPELLHEALLOG, (8+8+4+4+1));
7182     data.append(pVictim->GetPackGUID());
7183     data.append(GetPackGUID());
7184     data << uint32(SpellID);
7185     data << uint32(Damage);
7186     data << uint32(0);                                      // over healing?
7187     data << uint8(critical ? 1 : 0);
7188     data << uint8(0);                                       // unused in client?
7189     SendMessageToSet(&data, true);
7190 }
7191
7192 void Unit::SendEnergizeSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage, Powers powertype)
7193 {
7194     WorldPacket data(SMSG_SPELLENERGIZELOG, (8+8+4+4+4+1));
7195     data.append(pVictim->GetPackGUID());
7196     data.append(GetPackGUID());
7197     data << uint32(SpellID);
7198     data << uint32(powertype);
7199     data << uint32(Damage);
7200     SendMessageToSet(&data, true);
7201 }
7202
7203 uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto, uint32 pdamage, DamageEffectType damagetype)
7204 {
7205     if(!spellProto || !pVictim || damagetype==DIRECT_DAMAGE )
7206         return pdamage;
7207
7208     int32 BonusDamage = 0;
7209     if( GetTypeId()==TYPEID_UNIT )
7210     {
7211         // Pets just add their bonus damage to their spell damage
7212         // note that their spell damage is just gain of their own auras
7213         if (((Creature*)this)->isPet())
7214         {
7215             BonusDamage = ((Pet*)this)->GetBonusDamage();
7216         }
7217         // For totems get damage bonus from owner (statue isn't totem in fact)
7218         else if (((Creature*)this)->isTotem() && ((Totem*)this)->GetTotemType()!=TOTEM_STATUE)
7219         {
7220             if(Unit* owner = GetOwner())
7221                 return owner->SpellDamageBonus(pVictim, spellProto, pdamage, damagetype);
7222         }
7223     }
7224
7225     // Damage Done
7226     uint32 CastingTime = !IsChanneledSpell(spellProto) ? GetSpellCastTime(spellProto) : GetSpellDuration(spellProto);
7227
7228     // Taken/Done fixed damage bonus auras
7229     int32 DoneAdvertisedBenefit  = SpellBaseDamageBonus(GetSpellSchoolMask(spellProto))+BonusDamage;
7230     int32 TakenAdvertisedBenefit = SpellBaseDamageBonusForVictim(GetSpellSchoolMask(spellProto), pVictim);
7231
7232     // Damage over Time spells bonus calculation
7233     float DotFactor = 1.0f;
7234     if(damagetype == DOT)
7235     {
7236         int32 DotDuration = GetSpellDuration(spellProto);
7237         // 200% limit
7238         if(DotDuration > 0)
7239         {
7240             if(DotDuration > 30000) DotDuration = 30000;
7241             if(!IsChanneledSpell(spellProto)) DotFactor = DotDuration / 15000.0f;
7242             int x = 0;
7243             for(int j = 0; j < 3; j++)
7244             {
7245                 if( spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && (
7246                     spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_DAMAGE ||
7247                     spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH) )
7248                 {
7249                     x = j;
7250                     break;
7251                 }
7252             }
7253             int DotTicks = 6;
7254             if(spellProto->EffectAmplitude[x] != 0)
7255                 DotTicks = DotDuration / spellProto->EffectAmplitude[x];
7256             if(DotTicks)
7257             {
7258                 DoneAdvertisedBenefit /= DotTicks;
7259                 TakenAdvertisedBenefit /= DotTicks;
7260             }
7261         }
7262     }
7263
7264     // Taken/Done total percent damage auras
7265     float DoneTotalMod = 1.0f;
7266     float TakenTotalMod = 1.0f;
7267
7268     // ..done
7269     AuraList const& mModDamagePercentDone = GetAurasByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
7270     for(AuraList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
7271     {
7272         if( ((*i)->GetModifier()->m_miscvalue & GetSpellSchoolMask(spellProto)) &&
7273             (*i)->GetSpellProto()->EquippedItemClass == -1 &&
7274                                                             // -1 == any item class (not wand then)
7275             (*i)->GetSpellProto()->EquippedItemInventoryTypeMask == 0 )
7276                                                             // 0 == any inventory type (not wand then)
7277         {
7278             DoneTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
7279         }
7280     }
7281
7282     uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
7283     AuraList const& mDamageDoneVersus = GetAurasByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
7284     for(AuraList::const_iterator i = mDamageDoneVersus.begin();i != mDamageDoneVersus.end(); ++i)
7285         if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
7286             DoneTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
7287
7288     // ..taken
7289     AuraList const& mModDamagePercentTaken = pVictim->GetAurasByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
7290     for(AuraList::const_iterator i = mModDamagePercentTaken.begin(); i != mModDamagePercentTaken.end(); ++i)
7291         if( (*i)->GetModifier()->m_miscvalue & GetSpellSchoolMask(spellProto) )
7292             TakenTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
7293
7294     // .. taken pct: scripted (increases damage of * against targets *)
7295     AuraList const& mOverrideClassScript = GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
7296     for(AuraList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
7297     {
7298         switch((*i)->GetModifier()->m_miscvalue)
7299         {
7300             //Molten Fury
7301             case 4920: case 4919:
7302                 if(pVictim->HasAuraState(AURA_STATE_HEALTHLESS_20_PERCENT))
7303                     TakenTotalMod *= (100.0f+(*i)->GetModifier()->m_amount)/100.0f; break;
7304         }
7305     }
7306
7307     // .. taken pct: dummy auras
7308     AuraList const& mDummyAuras = pVictim->GetAurasByType(SPELL_AURA_DUMMY);
7309     for(AuraList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
7310     {
7311         switch((*i)->GetSpellProto()->SpellIconID)
7312         {
7313             //Cheat Death
7314             case 2109:
7315                 if( ((*i)->GetModifier()->m_miscvalue & GetSpellSchoolMask(spellProto)) )
7316                 {
7317                     if(pVictim->GetTypeId() != TYPEID_PLAYER)
7318                         continue;
7319                     float mod = -((Player*)pVictim)->GetRatingBonusValue(CR_CRIT_TAKEN_SPELL)*2*4;
7320                     if (mod < (*i)->GetModifier()->m_amount)
7321                         mod = (*i)->GetModifier()->m_amount;
7322                     TakenTotalMod *= (mod+100.0f)/100.0f;
7323                 }
7324                 break;
7325             //Mangle
7326             case 2312:
7327                 for(int j=0;j<3;j++)
7328                 {
7329                     if(GetEffectMechanic(spellProto, j)==MECHANIC_BLEED)
7330                     {
7331                         TakenTotalMod *= (100.0f+(*i)->GetModifier()->m_amount)/100.0f;
7332                         break;
7333                     }
7334                 }
7335                 break;
7336         }
7337     }
7338
7339     // Distribute Damage over multiple effects, reduce by AoE
7340     CastingTime = GetCastingTimeForBonus( spellProto, damagetype, CastingTime );
7341
7342     // 50% for damage and healing spells for leech spells from damage bonus and 0% from healing
7343     for(int j = 0; j < 3; ++j)
7344     {
7345         if( spellProto->Effect[j] == SPELL_EFFECT_HEALTH_LEECH ||
7346             spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH )
7347         {
7348             CastingTime /= 2;
7349             break;
7350         }
7351     }
7352
7353     switch(spellProto->SpellFamilyName)
7354     {
7355         case SPELLFAMILY_MAGE:
7356             // Ignite - do not modify, it is (8*Rank)% damage of procing Spell
7357             if(spellProto->Id==12654)
7358             {
7359                 return pdamage;
7360             }
7361             // Ice Lance
7362             else if((spellProto->SpellFamilyFlags & 0x20000LL) && spellProto->SpellIconID == 186)
7363             {
7364                 CastingTime /= 3;                           // applied 1/3 bonuses in case generic target
7365                 if(pVictim->isFrozen())                     // and compensate this for frozen target.
7366                     TakenTotalMod *= 3.0f;
7367             }
7368             // Pyroblast - 115% of Fire Damage, DoT - 20% of Fire Damage
7369             else if((spellProto->SpellFamilyFlags & 0x400000LL) && spellProto->SpellIconID == 184 )
7370             {
7371                 DotFactor = damagetype == DOT ? 0.2f : 1.0f;
7372                 CastingTime = damagetype == DOT ? 3500 : 4025;
7373             }
7374             // Fireball - 100% of Fire Damage, DoT - 0% of Fire Damage
7375             else if((spellProto->SpellFamilyFlags & 0x1LL) && spellProto->SpellIconID == 185)
7376             {
7377                 CastingTime = 3500;
7378                 DotFactor = damagetype == DOT ? 0.0f : 1.0f;
7379             }
7380             // Molten armor
7381             else if (spellProto->SpellFamilyFlags & 0x0000000800000000LL)
7382             {
7383                 CastingTime = 0;
7384             }
7385             // Arcane Missiles triggered spell
7386             else if ((spellProto->SpellFamilyFlags & 0x200000LL) && spellProto->SpellIconID == 225)
7387             {
7388                 CastingTime = 1000;
7389             }
7390             // Blizzard triggered spell
7391             else if ((spellProto->SpellFamilyFlags & 0x80080LL) && spellProto->SpellIconID == 285)
7392             {
7393                 CastingTime = 500;
7394             }
7395             break;
7396         case SPELLFAMILY_WARLOCK:
7397             // Life Tap
7398             if((spellProto->SpellFamilyFlags & 0x40000LL) && spellProto->SpellIconID == 208)
7399             {
7400                 CastingTime = 2800;                         // 80% from +shadow damage
7401                 DoneTotalMod = 1.0f;
7402                 TakenTotalMod = 1.0f;
7403             }
7404             // Dark Pact
7405             else if((spellProto->SpellFamilyFlags & 0x80000000LL) && spellProto->SpellIconID == 154 && GetPetGUID())
7406             {
7407                 CastingTime = 3360;                         // 96% from +shadow damage
7408                 DoneTotalMod = 1.0f;
7409                 TakenTotalMod = 1.0f;
7410             }
7411             // Soul Fire - 115% of Fire Damage
7412             else if((spellProto->SpellFamilyFlags & 0x8000000000LL) && spellProto->SpellIconID == 184)
7413             {
7414                 CastingTime = 4025;
7415             }
7416             // Curse of Agony - 120% of Shadow Damage
7417             else if((spellProto->SpellFamilyFlags & 0x0000000400LL) && spellProto->SpellIconID == 544)
7418             {
7419                 DotFactor = 1.2f;
7420             }
7421             // Drain Mana - 0% of Shadow Damage
7422             else if((spellProto->SpellFamilyFlags & 0x10LL) && spellProto->SpellIconID == 548)
7423             {
7424                 CastingTime = 0;
7425             }
7426             // Drain Soul 214.3%
7427             else if ((spellProto->SpellFamilyFlags & 0x4000LL) && spellProto->SpellIconID == 113 )
7428             {
7429                 CastingTime = 7500;
7430             }
7431             // Hellfire
7432             else if ((spellProto->SpellFamilyFlags & 0x40LL) && spellProto->SpellIconID == 937)
7433             {
7434                 CastingTime = damagetype == DOT ? 5000 : 500; // self damage seems to be so
7435             }
7436             // Unstable Affliction - 180%
7437             else if (spellProto->Id == 31117 && spellProto->SpellIconID == 232)
7438             {
7439                 CastingTime = 6300;
7440             }
7441             // Corruption 93%
7442             else if ((spellProto->SpellFamilyFlags & 0x2LL) && spellProto->SpellIconID == 313)
7443             {
7444                 DotFactor = 0.93f;
7445             }
7446             break;
7447         case SPELLFAMILY_PALADIN:
7448             // Consecration - 95% of Holy Damage
7449             if((spellProto->SpellFamilyFlags & 0x20LL) && spellProto->SpellIconID == 51)
7450             {
7451                 DotFactor = 0.95f;
7452                 CastingTime = 3500;
7453             }
7454             // Seal of Righteousness - 10.2%/9.8% ( based on weapon type ) of Holy Damage, multiplied by weapon speed
7455             else if((spellProto->SpellFamilyFlags & 0x8000000LL) && spellProto->SpellIconID == 25)
7456             {
7457                 Item *item = ((Player*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
7458                 float wspeed = GetAttackTime(BASE_ATTACK)/1000.0f;
7459
7460                 if( item && item->GetProto()->InventoryType == INVTYPE_2HWEAPON)
7461                    CastingTime = uint32(wspeed*3500*0.102f);
7462                 else
7463                    CastingTime = uint32(wspeed*3500*0.098f);
7464             }
7465             // Judgement of Righteousness - 73%
7466             else if ((spellProto->SpellFamilyFlags & 1024) && spellProto->SpellIconID == 25)
7467             {
7468                 CastingTime = 2555;
7469             }
7470             // Seal of Vengeance - 17% per Fully Stacked Tick - 5 Applications
7471             else if ((spellProto->SpellFamilyFlags & 0x80000000000LL) && spellProto->SpellIconID == 2292)
7472             {
7473                 DotFactor = 0.17f;
7474                 CastingTime = 3500;
7475             }
7476             // Holy shield - 5% of Holy Damage
7477             else if ((spellProto->SpellFamilyFlags & 0x4000000000LL) && spellProto->SpellIconID == 453)
7478             {
7479                 CastingTime = 175;
7480             }
7481             // Blessing of Sanctuary - 0%
7482             else if ((spellProto->SpellFamilyFlags & 0x10000000LL) && spellProto->SpellIconID == 29)
7483             {
7484                 CastingTime = 0;
7485             }
7486             // Seal of Righteousness trigger - already computed for parent spell
7487             else if ( spellProto->SpellFamilyName==SPELLFAMILY_PALADIN && spellProto->SpellIconID==25 && spellProto->AttributesEx4 & 0x00800000LL )
7488             {
7489                 return pdamage;
7490             }
7491             break;
7492         case  SPELLFAMILY_SHAMAN:
7493             // totem attack
7494             if (spellProto->SpellFamilyFlags & 0x000040000000LL)
7495             {
7496                 if (spellProto->SpellIconID == 33)          // Fire Nova totem attack must be 21.4%(untested)
7497                     CastingTime = 749;                      // ignore CastingTime and use as modifier
7498                 else if (spellProto->SpellIconID == 680)    // Searing Totem attack 8%
7499                     CastingTime = 280;                      // ignore CastingTime and use as modifier
7500                 else if (spellProto->SpellIconID == 37)     // Magma totem attack must be 6.67%(untested)
7501                     CastingTime = 234;                      // ignore CastingTimePenalty and use as modifier
7502             }
7503             // Lightning Shield (and proc shield from T2 8 pieces bonus ) 33% per charge
7504             else if( (spellProto->SpellFamilyFlags & 0x00000000400LL) || spellProto->Id == 23552)
7505                 CastingTime = 1155;                         // ignore CastingTimePenalty and use as modifier
7506             break;
7507         case SPELLFAMILY_PRIEST:
7508             // Mana Burn - 0% of Shadow Damage
7509             if((spellProto->SpellFamilyFlags & 0x10LL) && spellProto->SpellIconID == 212)
7510             {
7511                 CastingTime = 0;
7512             }
7513             // Mind Flay - 59% of Shadow Damage
7514             else if((spellProto->SpellFamilyFlags & 0x800000LL) && spellProto->SpellIconID == 548)
7515             {
7516                 CastingTime = 2065;
7517             }
7518             // Holy Fire - 86.71%, DoT - 16.5%
7519             else if ((spellProto->SpellFamilyFlags & 0x100000LL) && spellProto->SpellIconID == 156)
7520             {
7521                 DotFactor = damagetype == DOT ? 0.165f : 1.0f;
7522                 CastingTime = damagetype == DOT ? 3500 : 3035;
7523             }
7524             // Shadowguard - 28% per charge
7525             else if ((spellProto->SpellFamilyFlags & 0x2000000LL) && spellProto->SpellIconID == 19)
7526             {
7527                 CastingTime = 980;
7528             }
7529             // Touch of Weakeness - 10%
7530             else if ((spellProto->SpellFamilyFlags & 0x80000LL) && spellProto->SpellIconID == 1591)
7531             {
7532                 CastingTime = 350;
7533             }
7534             // Reflective Shield (back damage) - 0% (other spells fit to check not have damage effects/auras)
7535             else if (spellProto->SpellFamilyFlags == 0 && spellProto->SpellIconID == 566)
7536             {
7537                 CastingTime = 0;
7538             }
7539             // Holy Nova - 14%
7540             else if ((spellProto->SpellFamilyFlags & 0x400000LL) && spellProto->SpellIconID == 1874)
7541             {
7542                 CastingTime = 500;
7543             }
7544             break;
7545         case SPELLFAMILY_DRUID:
7546             // Hurricane triggered spell
7547             if((spellProto->SpellFamilyFlags & 0x400000LL) && spellProto->SpellIconID == 220)
7548             {
7549                 CastingTime = 500;
7550             }
7551             break;
7552         case SPELLFAMILY_WARRIOR:
7553         case SPELLFAMILY_HUNTER:
7554         case SPELLFAMILY_ROGUE:
7555             CastingTime = 0;
7556             break;
7557         default:
7558             break;
7559     }
7560
7561     float LvlPenalty = CalculateLevelPenalty(spellProto);
7562
7563     // Spellmod SpellDamage
7564     float SpellModSpellDamage = 100.0f;
7565
7566     if(Player* modOwner = GetSpellModOwner())
7567         modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_SPELL_BONUS_DAMAGE,SpellModSpellDamage);
7568
7569     SpellModSpellDamage /= 100.0f;
7570
7571     float DoneActualBenefit = DoneAdvertisedBenefit * (CastingTime / 3500.0f) * DotFactor * SpellModSpellDamage * LvlPenalty;
7572     float TakenActualBenefit = TakenAdvertisedBenefit * (CastingTime / 3500.0f) * DotFactor * LvlPenalty;
7573
7574     float tmpDamage = (float(pdamage)+DoneActualBenefit)*DoneTotalMod;
7575
7576     // Add flat bonus from spell damage versus
7577     tmpDamage += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS, creatureTypeMask);
7578
7579     // apply spellmod to Done damage
7580     if(Player* modOwner = GetSpellModOwner())
7581         modOwner->ApplySpellMod(spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE, tmpDamage);
7582
7583     tmpDamage = (tmpDamage+TakenActualBenefit)*TakenTotalMod;
7584
7585     if( GetTypeId() == TYPEID_UNIT && !((Creature*)this)->isPet() )
7586         tmpDamage *= ((Creature*)this)->GetSpellDamageMod(((Creature*)this)->GetCreatureInfo()->rank);
7587
7588     return tmpDamage > 0 ? uint32(tmpDamage) : 0;
7589 }
7590
7591 int32 Unit::SpellBaseDamageBonus(SpellSchoolMask schoolMask)
7592 {
7593     int32 DoneAdvertisedBenefit = 0;
7594
7595     // ..done
7596     AuraList const& mDamageDone = GetAurasByType(SPELL_AURA_MOD_DAMAGE_DONE);
7597     for(AuraList::const_iterator i = mDamageDone.begin();i != mDamageDone.end(); ++i)
7598         if(((*i)->GetModifier()->m_miscvalue & schoolMask) != 0 &&
7599         (*i)->GetSpellProto()->EquippedItemClass == -1 &&
7600                                                             // -1 == any item class (not wand then)
7601         (*i)->GetSpellProto()->EquippedItemInventoryTypeMask == 0 )
7602                                                             // 0 == any inventory type (not wand then)
7603             DoneAdvertisedBenefit += (*i)->GetModifier()->m_amount;
7604
7605     if (GetTypeId() == TYPEID_PLAYER)
7606     {
7607         // Damage bonus from stats
7608         AuraList const& mDamageDoneOfStatPercent = GetAurasByType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT);
7609         for(AuraList::const_iterator i = mDamageDoneOfStatPercent.begin();i != mDamageDoneOfStatPercent.end(); ++i)
7610         {
7611             if((*i)->GetModifier()->m_miscvalue & schoolMask)
7612             {
7613                 SpellEntry const* iSpellProto = (*i)->GetSpellProto();
7614                 uint8 eff = (*i)->GetEffIndex();
7615
7616                 // stat used dependent from next effect aura SPELL_AURA_MOD_SPELL_HEALING presence and misc value (stat index)
7617                 Stats usedStat = STAT_INTELLECT;
7618                 if(eff < 2 && iSpellProto->EffectApplyAuraName[eff+1]==SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT)
7619                     usedStat = Stats(iSpellProto->EffectMiscValue[eff+1]);
7620
7621                 DoneAdvertisedBenefit += int32(GetStat(usedStat) * (*i)->GetModifier()->m_amount / 100.0f);
7622             }
7623         }
7624         // ... and attack power
7625         AuraList const& mDamageDonebyAP = GetAurasByType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER);
7626         for(AuraList::const_iterator i =mDamageDonebyAP.begin();i != mDamageDonebyAP.end(); ++i)
7627             if ((*i)->GetModifier()->m_miscvalue & schoolMask)
7628                 DoneAdvertisedBenefit += int32(GetTotalAttackPowerValue(BASE_ATTACK) * (*i)->GetModifier()->m_amount / 100.0f);
7629
7630     }
7631     return DoneAdvertisedBenefit;
7632 }
7633
7634 int32 Unit::SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit *pVictim)
7635 {
7636     uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
7637
7638     int32 TakenAdvertisedBenefit = 0;
7639     // ..done (for creature type by mask) in taken
7640     AuraList const& mDamageDoneCreature = GetAurasByType(SPELL_AURA_MOD_DAMAGE_DONE_CREATURE);
7641     for(AuraList::const_iterator i = mDamageDoneCreature.begin();i != mDamageDoneCreature.end(); ++i)
7642         if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
7643             TakenAdvertisedBenefit += (*i)->GetModifier()->m_amount;
7644
7645     // ..taken
7646     AuraList const& mDamageTaken = pVictim->GetAurasByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
7647     for(AuraList::const_iterator i = mDamageTaken.begin();i != mDamageTaken.end(); ++i)
7648         if(((*i)->GetModifier()->m_miscvalue & schoolMask) != 0)
7649             TakenAdvertisedBenefit += (*i)->GetModifier()->m_amount;
7650
7651     return TakenAdvertisedBenefit;
7652 }
7653
7654 bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto, SpellSchoolMask schoolMask, WeaponAttackType attackType)
7655 {
7656     // not critting spell
7657     if((spellProto->AttributesEx2 & SPELL_ATTR_EX2_CANT_CRIT))
7658         return false;
7659
7660     float crit_chance = 0.0f;
7661     switch(spellProto->DmgClass)
7662     {
7663         case SPELL_DAMAGE_CLASS_NONE:
7664             return false;
7665         case SPELL_DAMAGE_CLASS_MAGIC:
7666         {
7667             if (schoolMask & SPELL_SCHOOL_MASK_NORMAL)
7668                 crit_chance = 0.0f;
7669             // For other schools
7670             else if (GetTypeId() == TYPEID_PLAYER)
7671                 crit_chance = GetFloatValue( PLAYER_SPELL_CRIT_PERCENTAGE1 + GetFirstSchoolInMask(schoolMask));
7672             else
7673             {
7674                 crit_chance = m_baseSpellCritChance;
7675                 crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
7676             }
7677             // taken
7678             if (pVictim && !IsPositiveSpell(spellProto->Id))
7679             {
7680                 // Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE
7681                 crit_chance += pVictim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
7682                 // Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE
7683                 crit_chance += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
7684                 // Modify by player victim resilience
7685                 if (pVictim->GetTypeId() == TYPEID_PLAYER)
7686                     crit_chance -= ((Player*)pVictim)->GetRatingBonusValue(CR_CRIT_TAKEN_SPELL);
7687                 // scripted (increase crit chance ... against ... target by x%
7688                 if(pVictim->isFrozen()) // Shatter
7689                 {
7690                     AuraList const& mOverrideClassScript = GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
7691                     for(AuraList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
7692                     {
7693                         switch((*i)->GetModifier()->m_miscvalue)
7694                         {
7695                             case 849: crit_chance+= 10.0f; break; //Shatter Rank 1
7696                             case 910: crit_chance+= 20.0f; break; //Shatter Rank 2
7697                             case 911: crit_chance+= 30.0f; break; //Shatter Rank 3
7698                             case 912: crit_chance+= 40.0f; break; //Shatter Rank 4
7699                             case 913: crit_chance+= 50.0f; break; //Shatter Rank 5
7700                         }
7701                     }
7702                 }
7703             }
7704             break;
7705         }
7706         case SPELL_DAMAGE_CLASS_MELEE:
7707         case SPELL_DAMAGE_CLASS_RANGED:
7708         {
7709             if (pVictim)
7710             {
7711                 crit_chance = GetUnitCriticalChance(attackType, pVictim);
7712                 crit_chance+= (int32(GetMaxSkillValueForLevel(pVictim)) - int32(pVictim->GetDefenseSkillValue(this))) * 0.04f;
7713                 crit_chance+= GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
7714             }
7715             break;
7716         }
7717         default:
7718             return false;
7719     }
7720     // percent done
7721     // only players use intelligence for critical chance computations
7722     if(Player* modOwner = GetSpellModOwner())
7723         modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRITICAL_CHANCE, crit_chance);
7724
7725     crit_chance = crit_chance > 0.0f ? crit_chance : 0.0f;
7726     if (roll_chance_f(crit_chance))
7727         return true;
7728     return false;
7729 }
7730
7731 uint32 Unit::SpellCriticalBonus(SpellEntry const *spellProto, uint32 damage, Unit *pVictim)
7732 {
7733     // Calculate critical bonus
7734     int32 crit_bonus;
7735     switch(spellProto->DmgClass)
7736     {
7737         case SPELL_DAMAGE_CLASS_MELEE:                      // for melee based spells is 100%
7738         case SPELL_DAMAGE_CLASS_RANGED:
7739             // TODO: write here full calculation for melee/ranged spells
7740             crit_bonus = damage;
7741             break;
7742         default:
7743             crit_bonus = damage / 2;                        // for spells is 50%
7744             break;
7745     }
7746
7747     // adds additional damage to crit_bonus (from talents)
7748     if(Player* modOwner = GetSpellModOwner())
7749         modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
7750
7751     if(pVictim)
7752     {
7753         uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
7754         crit_bonus = int32(crit_bonus * GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, creatureTypeMask));
7755     }
7756
7757     if(crit_bonus > 0)
7758         damage += crit_bonus;
7759
7760     return damage;
7761 }
7762
7763 uint32 Unit::SpellHealingBonus(SpellEntry const *spellProto, uint32 healamount, DamageEffectType damagetype, Unit *pVictim)
7764 {
7765     // For totems get healing bonus from owner (statue isn't totem in fact)
7766     if( GetTypeId()==TYPEID_UNIT && ((Creature*)this)->isTotem() && ((Totem*)this)->GetTotemType()!=TOTEM_STATUE)
7767         if(Unit* owner = GetOwner())
7768             return owner->SpellHealingBonus(spellProto, healamount, damagetype, pVictim);
7769
7770     // Healing Done
7771
7772     // These Spells are doing fixed amount of healing (TODO found less hack-like check)
7773     if (spellProto->Id == 15290 || spellProto->Id == 39373 ||
7774         spellProto->Id == 33778 || spellProto->Id == 379   ||
7775         spellProto->Id == 38395 || spellProto->Id == 40972)
7776         return healamount;
7777
7778     int32 AdvertisedBenefit = SpellBaseHealingBonus(GetSpellSchoolMask(spellProto));
7779     uint32 CastingTime = GetSpellCastTime(spellProto);
7780
7781     // Healing Taken
7782     AdvertisedBenefit += SpellBaseHealingBonusForVictim(GetSpellSchoolMask(spellProto), pVictim);
7783
7784     // Blessing of Light dummy effects healing taken from Holy Light and Flash of Light
7785     if (spellProto->SpellFamilyName == SPELLFAMILY_PALADIN && (spellProto->SpellFamilyFlags & 0x00000000C0000000LL))
7786     {
7787         AuraList const& mDummyAuras = pVictim->GetAurasByType(SPELL_AURA_DUMMY);
7788         for(AuraList::const_iterator i = mDummyAuras.begin();i != mDummyAuras.end(); ++i)
7789         {
7790             if((*i)->GetSpellProto()->SpellVisual[0] == 9180)
7791             {
7792                 // Flash of Light
7793                 if ((spellProto->SpellFamilyFlags & 0x0000000040000000LL) && (*i)->GetEffIndex() == 1)
7794                     AdvertisedBenefit += (*i)->GetModifier()->m_amount;
7795                 // Holy Light
7796                 else if ((spellProto->SpellFamilyFlags & 0x0000000080000000LL) && (*i)->GetEffIndex() == 0)
7797                     AdvertisedBenefit += (*i)->GetModifier()->m_amount;
7798             }
7799         }
7800     }
7801
7802     float ActualBenefit = 0.0f;
7803
7804     if (AdvertisedBenefit != 0)
7805     {
7806         // Healing over Time spells
7807         float DotFactor = 1.0f;
7808         if(damagetype == DOT)
7809         {
7810             int32 DotDuration = GetSpellDuration(spellProto);
7811             if(DotDuration > 0)
7812             {
7813                 // 200% limit
7814                 if(DotDuration > 30000) DotDuration = 30000;
7815                 if(!IsChanneledSpell(spellProto)) DotFactor = DotDuration / 15000.0f;
7816                 int x = 0;
7817                 for(int j = 0; j < 3; j++)
7818                 {
7819                     if( spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && (
7820                         spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_HEAL ||
7821                         spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH) )
7822                     {
7823                         x = j;
7824                         break;
7825                     }
7826                 }
7827                 int DotTicks = 6;
7828                 if(spellProto->EffectAmplitude[x] != 0)
7829                     DotTicks = DotDuration / spellProto->EffectAmplitude[x];
7830                 if(DotTicks)
7831                     AdvertisedBenefit /= DotTicks;
7832             }
7833         }
7834
7835         // distribute healing to all effects, reduce AoE damage
7836         CastingTime = GetCastingTimeForBonus( spellProto, damagetype, CastingTime );
7837
7838         // 0% bonus for damage and healing spells for leech spells from healing bonus
7839         for(int j = 0; j < 3; ++j)
7840         {
7841             if( spellProto->Effect[j] == SPELL_EFFECT_HEALTH_LEECH ||
7842                 spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH )
7843             {
7844                 CastingTime = 0;
7845                 break;
7846             }
7847         }
7848
7849         // Exception
7850         switch (spellProto->SpellFamilyName)
7851         {
7852             case  SPELLFAMILY_SHAMAN:
7853                 // Healing stream from totem (add 6% per tick from hill bonus owner)
7854                 if (spellProto->SpellFamilyFlags & 0x000000002000LL)
7855                     CastingTime = 210;
7856                 // Earth Shield 30% per charge
7857                 else if (spellProto->SpellFamilyFlags & 0x40000000000LL)
7858                     CastingTime = 1050;
7859                 break;
7860             case  SPELLFAMILY_DRUID:
7861                 // Lifebloom
7862                 if (spellProto->SpellFamilyFlags & 0x1000000000LL)
7863                 {
7864                     CastingTime = damagetype == DOT ? 3500 : 1200;
7865                     DotFactor = damagetype == DOT ? 0.519f : 1.0f;
7866                 }
7867                 // Tranquility triggered spell
7868                 else if (spellProto->SpellFamilyFlags & 0x80LL)
7869                     CastingTime = 667;
7870                 // Rejuvenation
7871                 else if (spellProto->SpellFamilyFlags & 0x10LL)
7872                     DotFactor = 0.845f;
7873                 // Regrowth
7874                 else if (spellProto->SpellFamilyFlags & 0x40LL)
7875                 {
7876                     DotFactor = damagetype == DOT ? 0.705f : 1.0f;
7877                     CastingTime = damagetype == DOT ? 3500 : 1010;
7878                 }
7879                 break;
7880             case SPELLFAMILY_PRIEST:
7881                 // Holy Nova - 14%
7882                 if ((spellProto->SpellFamilyFlags & 0x8000000LL) && spellProto->SpellIconID == 1874)
7883                     CastingTime = 500;
7884                 break;
7885             case SPELLFAMILY_PALADIN:
7886                 // Seal and Judgement of Light
7887                 if ( spellProto->SpellFamilyFlags & 0x100040000LL )
7888                     CastingTime = 0;
7889                 break;
7890             case SPELLFAMILY_WARRIOR:
7891             case SPELLFAMILY_ROGUE:
7892             case SPELLFAMILY_HUNTER:
7893                 CastingTime = 0;
7894                 break;
7895         }
7896
7897         float LvlPenalty = CalculateLevelPenalty(spellProto);
7898
7899         // Spellmod SpellDamage
7900         float SpellModSpellDamage = 100.0f;
7901
7902         if(Player* modOwner = GetSpellModOwner())
7903             modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_SPELL_BONUS_DAMAGE,SpellModSpellDamage);
7904
7905         SpellModSpellDamage /= 100.0f;
7906
7907         ActualBenefit = (float)AdvertisedBenefit * ((float)CastingTime / 3500.0f) * DotFactor * SpellModSpellDamage * LvlPenalty;
7908     }
7909
7910     // use float as more appropriate for negative values and percent applying
7911     float heal = healamount + ActualBenefit;
7912
7913     // TODO: check for ALL/SPELLS type
7914     // Healing done percent
7915     AuraList const& mHealingDonePct = GetAurasByType(SPELL_AURA_MOD_HEALING_DONE_PERCENT);
7916     for(AuraList::const_iterator i = mHealingDonePct.begin();i != mHealingDonePct.end(); ++i)
7917         heal *= (100.0f + (*i)->GetModifier()->m_amount) / 100.0f;
7918
7919     // apply spellmod to Done amount
7920     if(Player* modOwner = GetSpellModOwner())
7921         modOwner->ApplySpellMod(spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE, heal);
7922
7923     // Healing Wave cast
7924     if (spellProto->SpellFamilyName == SPELLFAMILY_SHAMAN && spellProto->SpellFamilyFlags & 0x0000000000000040LL)
7925     {
7926         // Search for Healing Way on Victim (stack up to 3 time)
7927         int32 pctMod = 0;
7928         Unit::AuraList const& auraDummy = pVictim->GetAurasByType(SPELL_AURA_DUMMY);
7929         for(Unit::AuraList::const_iterator itr = auraDummy.begin(); itr!=auraDummy.end(); ++itr)
7930             if((*itr)->GetId() == 29203)
7931                 pctMod += (*itr)->GetModifier()->m_amount;
7932         // Apply bonus
7933         if (pctMod)
7934             heal = heal * (100 + pctMod) / 100;
7935     }
7936
7937     // Healing taken percent
7938     float minval = pVictim->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
7939     if(minval)
7940         heal *= (100.0f + minval) / 100.0f;
7941
7942     float maxval = pVictim->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_PCT);
7943     if(maxval)
7944         heal *= (100.0f + maxval) / 100.0f;
7945
7946     if (heal < 0) heal = 0;
7947
7948     return uint32(heal);
7949 }
7950
7951 int32 Unit::SpellBaseHealingBonus(SpellSchoolMask schoolMask)
7952 {
7953     int32 AdvertisedBenefit = 0;
7954
7955     AuraList const& mHealingDone = GetAurasByType(SPELL_AURA_MOD_HEALING_DONE);
7956     for(AuraList::const_iterator i = mHealingDone.begin();i != mHealingDone.end(); ++i)
7957         if(((*i)->GetModifier()->m_miscvalue & schoolMask) != 0)
7958             AdvertisedBenefit += (*i)->GetModifier()->m_amount;
7959
7960     // Healing bonus of spirit, intellect and strength
7961     if (GetTypeId() == TYPEID_PLAYER)
7962     {
7963         // Healing bonus from stats
7964         AuraList const& mHealingDoneOfStatPercent = GetAurasByType(SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT);
7965         for(AuraList::const_iterator i = mHealingDoneOfStatPercent.begin();i != mHealingDoneOfStatPercent.end(); ++i)
7966         {
7967             // stat used dependent from misc value (stat index)
7968             Stats usedStat = Stats((*i)->GetSpellProto()->EffectMiscValue[(*i)->GetEffIndex()]);
7969             AdvertisedBenefit += int32(GetStat(usedStat) * (*i)->GetModifier()->m_amount / 100.0f);
7970         }
7971
7972         // ... and attack power
7973         AuraList const& mHealingDonebyAP = GetAurasByType(SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER);
7974         for(AuraList::const_iterator i = mHealingDonebyAP.begin();i != mHealingDonebyAP.end(); ++i)
7975             if ((*i)->GetModifier()->m_miscvalue & schoolMask)
7976                 AdvertisedBenefit += int32(GetTotalAttackPowerValue(BASE_ATTACK) * (*i)->GetModifier()->m_amount / 100.0f);
7977     }
7978     return AdvertisedBenefit;
7979 }
7980
7981 int32 Unit::SpellBaseHealingBonusForVictim(SpellSchoolMask schoolMask, Unit *pVictim)
7982 {
7983     int32 AdvertisedBenefit = 0;
7984     AuraList const& mDamageTaken = pVictim->GetAurasByType(SPELL_AURA_MOD_HEALING);
7985     for(AuraList::const_iterator i = mDamageTaken.begin();i != mDamageTaken.end(); ++i)
7986         if(((*i)->GetModifier()->m_miscvalue & schoolMask) != 0)
7987             AdvertisedBenefit += (*i)->GetModifier()->m_amount;
7988     return AdvertisedBenefit;
7989 }
7990
7991 bool Unit::IsImmunedToDamage(SpellSchoolMask shoolMask, bool useCharges)
7992 {
7993     // no charges dependent checks
7994     SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
7995     for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
7996         if(itr->type & shoolMask)
7997             return true;
7998
7999     // charges dependent checks
8000     SpellImmuneList const& damageList = m_spellImmune[IMMUNITY_DAMAGE];
8001     for (SpellImmuneList::const_iterator itr = damageList.begin(); itr != damageList.end(); ++itr)
8002     {
8003         if(itr->type & shoolMask)
8004         {
8005             if(useCharges)
8006             {
8007                 AuraList const& auraDamageImmunity = GetAurasByType(SPELL_AURA_DAMAGE_IMMUNITY);
8008                 for(AuraList::const_iterator auraItr = auraDamageImmunity.begin(); auraItr != auraDamageImmunity.end(); ++auraItr)
8009                 {
8010                     if((*auraItr)->GetId()==itr->spellId)
8011                     {
8012                         if((*auraItr)->m_procCharges > 0)
8013                         {
8014                             --(*auraItr)->m_procCharges;
8015                             if((*auraItr)->m_procCharges==0)
8016                                 RemoveAurasDueToSpell(itr->spellId);
8017                         }
8018                         break;
8019                     }
8020                 }
8021             }
8022             return true;
8023         }
8024     }
8025
8026     return false;
8027 }
8028
8029 bool Unit::IsImmunedToSpell(SpellEntry const* spellInfo, bool useCharges)
8030 {
8031     if (!spellInfo)
8032         return false;
8033
8034     // no charges first
8035
8036     //FIX ME this hack: don't get feared if stunned
8037     if (spellInfo->Mechanic == MECHANIC_FEAR )
8038     {
8039         if ( hasUnitState(UNIT_STAT_STUNNED) )
8040             return true;
8041     }
8042
8043     // not have spells with charges currently
8044     SpellImmuneList const& dispelList = m_spellImmune[IMMUNITY_DISPEL];
8045     for(SpellImmuneList::const_iterator itr = dispelList.begin(); itr != dispelList.end(); ++itr)
8046         if(itr->type == spellInfo->Dispel)
8047             return true;
8048
8049     if( !(spellInfo->AttributesEx & SPELL_ATTR_EX_UNAFFECTED_BY_SCHOOL_IMMUNE))               // unaffected by school immunity
8050     {
8051         // not have spells with charges currently
8052         SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
8053         for(SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
8054             if( !(IsPositiveSpell(itr->spellId) && IsPositiveSpell(spellInfo->Id)) &&
8055                 (itr->type & GetSpellSchoolMask(spellInfo)) )
8056                 return true;
8057     }
8058
8059     // charges dependent checks
8060
8061     SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
8062     for(SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
8063     {
8064         if(itr->type == spellInfo->Mechanic)
8065         {
8066             if(useCharges)
8067             {
8068                 AuraList const& auraMechImmunity = GetAurasByType(SPELL_AURA_MECHANIC_IMMUNITY);
8069                 for(AuraList::const_iterator auraItr = auraMechImmunity.begin(); auraItr != auraMechImmunity.end(); ++auraItr)
8070                 {
8071                     if((*auraItr)->GetId()==itr->spellId)
8072                     {
8073                         if((*auraItr)->m_procCharges > 0)
8074                         {
8075                             --(*auraItr)->m_procCharges;
8076                             if((*auraItr)->m_procCharges==0)
8077                                 RemoveAurasDueToSpell(itr->spellId);
8078                         }
8079                         break;
8080                     }
8081                 }
8082             }
8083             return true;
8084         }
8085     }
8086
8087     return false;
8088 }
8089
8090 bool Unit::IsImmunedToSpellEffect(uint32 effect, uint32 mechanic) const
8091 {
8092     //If m_immuneToEffect type contain this effect type, IMMUNE effect.
8093     SpellImmuneList const& effectList = m_spellImmune[IMMUNITY_EFFECT];
8094     for (SpellImmuneList::const_iterator itr = effectList.begin(); itr != effectList.end(); ++itr)
8095         if(itr->type == effect)
8096             return true;
8097
8098     SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
8099     for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
8100         if(itr->type == mechanic)
8101             return true;
8102
8103     return false;
8104 }
8105
8106 bool Unit::IsDamageToThreatSpell(SpellEntry const * spellInfo) const
8107 {
8108     if(!spellInfo)
8109         return false;
8110
8111     uint32 family = spellInfo->SpellFamilyName;
8112     uint64 flags = spellInfo->SpellFamilyFlags;
8113
8114     if((family == 5 && flags == 256) ||                     //Searing Pain
8115         (family == 6 && flags == 8192) ||                   //Mind Blast
8116         (family == 11 && flags == 1048576))                 //Earth Shock
8117         return true;
8118
8119     return false;
8120 }
8121
8122 void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage,WeaponAttackType attType, SpellEntry const *spellProto)
8123 {
8124     if(!pVictim)
8125         return;
8126
8127     if(*pdamage == 0)
8128         return;
8129
8130     uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
8131
8132     // Taken/Done fixed damage bonus auras
8133     int32 DoneFlatBenefit = 0;
8134     int32 TakenFlatBenefit = 0;
8135
8136     // ..done (for creature type by mask) in taken
8137     AuraList const& mDamageDoneCreature = GetAurasByType(SPELL_AURA_MOD_DAMAGE_DONE_CREATURE);
8138     for(AuraList::const_iterator i = mDamageDoneCreature.begin();i != mDamageDoneCreature.end(); ++i)
8139         if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
8140             DoneFlatBenefit += (*i)->GetModifier()->m_amount;
8141
8142     // ..done
8143     // SPELL_AURA_MOD_DAMAGE_DONE included in weapon damage
8144
8145     // ..done (base at attack power for marked target and base at attack power for creature type)
8146     int32 APbonus = 0;
8147     if(attType == RANGED_ATTACK)
8148     {
8149         APbonus += pVictim->GetTotalAuraModifier(SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
8150
8151         // ..done (base at attack power and creature type)
8152         AuraList const& mCreatureAttackPower = GetAurasByType(SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS);
8153         for(AuraList::const_iterator i = mCreatureAttackPower.begin();i != mCreatureAttackPower.end(); ++i)
8154             if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
8155                 APbonus += (*i)->GetModifier()->m_amount;
8156     }
8157     else
8158     {
8159         APbonus += pVictim->GetTotalAuraModifier(SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
8160
8161         // ..done (base at attack power and creature type)
8162         AuraList const& mCreatureAttackPower = GetAurasByType(SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS);
8163         for(AuraList::const_iterator i = mCreatureAttackPower.begin();i != mCreatureAttackPower.end(); ++i)
8164             if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
8165                 APbonus += (*i)->GetModifier()->m_amount;
8166     }
8167
8168     if (APbonus!=0)                                         // Can be negative
8169     {
8170         bool normalized = false;
8171         if(spellProto)
8172         {
8173             for (uint8 i = 0; i<3;i++)
8174             {
8175                 if (spellProto->Effect[i] == SPELL_EFFECT_NORMALIZED_WEAPON_DMG)
8176                 {
8177                     normalized = true;
8178                     break;
8179                 }
8180             }
8181         }
8182
8183         DoneFlatBenefit += int32(APbonus/14.0f * GetAPMultiplier(attType,normalized));
8184     }
8185
8186     // ..taken
8187     AuraList const& mDamageTaken = pVictim->GetAurasByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
8188     for(AuraList::const_iterator i = mDamageTaken.begin();i != mDamageTaken.end(); ++i)
8189         if((*i)->GetModifier()->m_miscvalue & GetMeleeDamageSchoolMask())
8190             TakenFlatBenefit += (*i)->GetModifier()->m_amount;
8191
8192     if(attType!=RANGED_ATTACK)
8193         TakenFlatBenefit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN);
8194     else
8195         TakenFlatBenefit += pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN);
8196
8197     // Done/Taken total percent damage auras
8198     float DoneTotalMod = 1;
8199     float TakenTotalMod = 1;
8200
8201     // ..done
8202     // SPELL_AURA_MOD_DAMAGE_PERCENT_DONE included in weapon damage
8203     // SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT  included in weapon damage
8204
8205     AuraList const& mDamageDoneVersus = GetAurasByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
8206     for(AuraList::const_iterator i = mDamageDoneVersus.begin();i != mDamageDoneVersus.end(); ++i)
8207         if(creatureTypeMask & uint32((*i)->GetModifier()->m_miscvalue))
8208             DoneTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
8209
8210     // ..taken
8211     AuraList const& mModDamagePercentTaken = pVictim->GetAurasByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
8212     for(AuraList::const_iterator i = mModDamagePercentTaken.begin(); i != mModDamagePercentTaken.end(); ++i)
8213         if((*i)->GetModifier()->m_miscvalue & GetMeleeDamageSchoolMask())
8214             TakenTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
8215
8216     // .. taken pct: dummy auras
8217     AuraList const& mDummyAuras = pVictim->GetAurasByType(SPELL_AURA_DUMMY);
8218     for(AuraList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
8219     {
8220         switch((*i)->GetSpellProto()->SpellIconID)
8221         {
8222             //Cheat Death
8223             case 2109:
8224                 if((*i)->GetModifier()->m_miscvalue & SPELL_SCHOOL_MASK_NORMAL)
8225                 {
8226                     if(pVictim->GetTypeId() != TYPEID_PLAYER)
8227                         continue;
8228                     float mod = ((Player*)pVictim)->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE)*(-8.0f);
8229                     if (mod < (*i)->GetModifier()->m_amount)
8230                         mod = (*i)->GetModifier()->m_amount;
8231                     TakenTotalMod *= (mod+100.0f)/100.0f;
8232                 }
8233                 break;
8234             //Mangle
8235             case 2312:
8236                 if(spellProto==NULL)
8237                     break;
8238                 // Should increase Shred (initial Damage of Lacerate and Rake handled in Spell::EffectSchoolDMG)
8239                 if(spellProto->SpellFamilyName==SPELLFAMILY_DRUID && (spellProto->SpellFamilyFlags==0x00008000LL))
8240                     TakenTotalMod *= (100.0f+(*i)->GetModifier()->m_amount)/100.0f;
8241                 break;
8242         }
8243     }
8244
8245     // .. taken pct: class scripts
8246     AuraList const& mclassScritAuras = GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
8247     for(AuraList::const_iterator i = mclassScritAuras.begin(); i != mclassScritAuras.end(); ++i)
8248     {
8249         switch((*i)->GetMiscValue())
8250         {
8251             case 6427: case 6428:                           // Dirty Deeds
8252                 if(pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT))
8253                 {
8254                     Aura* eff0 = GetAura((*i)->GetId(),0);
8255                     if(!eff0 || (*i)->GetEffIndex()!=1)
8256                     {
8257                         sLog.outError("Spell structure of DD (%u) changed.",(*i)->GetId());
8258                         continue;
8259                     }
8260
8261                     // effect 0 have expected value but in negative state
8262                     TakenTotalMod *= (-eff0->GetModifier()->m_amount+100.0f)/100.0f;
8263                 }
8264                 break;
8265         }
8266     }
8267
8268     if(attType != RANGED_ATTACK)
8269     {
8270         AuraList const& mModMeleeDamageTakenPercent = pVictim->GetAurasByType(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT);
8271         for(AuraList::const_iterator i = mModMeleeDamageTakenPercent.begin(); i != mModMeleeDamageTakenPercent.end(); ++i)
8272             TakenTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
8273     }
8274     else
8275     {
8276         AuraList const& mModRangedDamageTakenPercent = pVictim->GetAurasByType(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT);
8277         for(AuraList::const_iterator i = mModRangedDamageTakenPercent.begin(); i != mModRangedDamageTakenPercent.end(); ++i)
8278             TakenTotalMod *= ((*i)->GetModifier()->m_amount+100.0f)/100.0f;
8279     }
8280
8281     float tmpDamage = float(int32(*pdamage) + DoneFlatBenefit) * DoneTotalMod;
8282
8283     // apply spellmod to Done damage
8284     if(spellProto)
8285     {
8286         if(Player* modOwner = GetSpellModOwner())
8287             modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_DAMAGE, tmpDamage);
8288     }
8289
8290     tmpDamage = (tmpDamage + TakenFlatBenefit)*TakenTotalMod;
8291
8292     // bonus result can be negative
8293     *pdamage =  tmpDamage > 0 ? uint32(tmpDamage) : 0;
8294 }
8295
8296 void Unit::ApplySpellImmune(uint32 spellId, uint32 op, uint32 type, bool apply)
8297 {
8298     if (apply)
8299     {
8300         for (SpellImmuneList::iterator itr = m_spellImmune[op].begin(), next; itr != m_spellImmune[op].end(); itr = next)
8301         {
8302             next = itr; ++next;
8303             if(itr->type == type)
8304             {
8305                 m_spellImmune[op].erase(itr);
8306                 next = m_spellImmune[op].begin();
8307             }
8308         }
8309         SpellImmune Immune;
8310         Immune.spellId = spellId;
8311         Immune.type = type;
8312         m_spellImmune[op].push_back(Immune);
8313     }
8314     else
8315     {
8316         for (SpellImmuneList::iterator itr = m_spellImmune[op].begin(); itr != m_spellImmune[op].end(); ++itr)
8317         {
8318             if(itr->spellId == spellId)
8319             {
8320                 m_spellImmune[op].erase(itr);
8321                 break;
8322             }
8323         }
8324     }
8325
8326 }
8327
8328 void Unit::ApplySpellDispelImmunity(const SpellEntry * spellProto, DispelType type, bool apply)
8329 {
8330     ApplySpellImmune(spellProto->Id,IMMUNITY_DISPEL, type, apply);
8331
8332     if (apply && spellProto->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY)
8333         RemoveAurasWithDispelType(type);
8334 }
8335
8336 float Unit::GetWeaponProcChance() const
8337 {
8338     // normalized proc chance for weapon attack speed
8339     // (odd formula...)
8340     if(isAttackReady(BASE_ATTACK))
8341         return (GetAttackTime(BASE_ATTACK) * 1.8f / 1000.0f);
8342     else if (haveOffhandWeapon() && isAttackReady(OFF_ATTACK))
8343         return (GetAttackTime(OFF_ATTACK) * 1.6f / 1000.0f);
8344     return 0;
8345 }
8346
8347 float Unit::GetPPMProcChance(uint32 WeaponSpeed, float PPM) const
8348 {
8349     // proc per minute chance calculation
8350     if (PPM <= 0) return 0.0f;
8351     uint32 result = uint32((WeaponSpeed * PPM) / 600.0f);   // result is chance in percents (probability = Speed_in_sec * (PPM / 60))
8352     return result;
8353 }
8354
8355 void Unit::Mount(uint32 mount)
8356 {
8357     if(!mount)
8358         return;
8359
8360     RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MOUNTING);
8361
8362     SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, mount);
8363
8364     SetFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT );
8365
8366     // unsummon pet
8367     if(GetTypeId() == TYPEID_PLAYER)
8368     {
8369         Pet* pet = GetPet();
8370         if(pet)
8371         {
8372             if(pet->isControlled())
8373             {
8374                 ((Player*)this)->SetTemporaryUnsummonedPetNumber(pet->GetCharmInfo()->GetPetNumber());
8375                 ((Player*)this)->SetOldPetSpell(pet->GetUInt32Value(UNIT_CREATED_BY_SPELL));
8376             }
8377
8378             ((Player*)this)->RemovePet(NULL,PET_SAVE_NOT_IN_SLOT);
8379         }
8380         else
8381             ((Player*)this)->SetTemporaryUnsummonedPetNumber(0);
8382     }
8383 }
8384
8385 void Unit::Unmount()
8386 {
8387     if(!IsMounted())
8388         return;
8389
8390     RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_MOUNTED);
8391
8392     SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 0);
8393     RemoveFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT );
8394
8395     // only resummon old pet if the player is already added to a map
8396     // this prevents adding a pet to a not created map which would otherwise cause a crash
8397     // (it could probably happen when logging in after a previous crash)
8398     if(GetTypeId() == TYPEID_PLAYER && IsInWorld() && ((Player*)this)->GetTemporaryUnsummonedPetNumber() && isAlive())
8399     {
8400         Pet* NewPet = new Pet;
8401         if(!NewPet->LoadPetFromDB(this, 0, ((Player*)this)->GetTemporaryUnsummonedPetNumber(), true))
8402             delete NewPet;
8403
8404         ((Player*)this)->SetTemporaryUnsummonedPetNumber(0);
8405     }
8406 }
8407
8408 void Unit::SetInCombatWith(Unit* enemy)
8409 {
8410     Unit* eOwner = enemy->GetCharmerOrOwnerOrSelf();
8411     if(eOwner->IsPvP())
8412     {
8413         SetInCombatState(true);
8414         return;
8415     }
8416
8417     //check for duel
8418     if(eOwner->GetTypeId() == TYPEID_PLAYER && ((Player*)eOwner)->duel)
8419     {
8420         Unit const* myOwner = GetCharmerOrOwnerOrSelf();
8421         if(((Player const*)eOwner)->duel->opponent == myOwner)
8422         {
8423             SetInCombatState(true);
8424             return;
8425         }
8426     }
8427     SetInCombatState(false);
8428 }
8429
8430 void Unit::SetInCombatState(bool PvP)
8431 {
8432     // only alive units can be in combat
8433     if(!isAlive())
8434         return;
8435
8436     if(PvP)
8437         m_CombatTimer = 5000;
8438     SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
8439
8440     if(isCharmed() || (GetTypeId()!=TYPEID_PLAYER && ((Creature*)this)->isPet()))
8441         SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
8442 }
8443
8444 void Unit::ClearInCombat()
8445 {
8446     m_CombatTimer = 0;
8447     RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
8448
8449     if(isCharmed() || (GetTypeId()!=TYPEID_PLAYER && ((Creature*)this)->isPet()))
8450         RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
8451
8452     // Player's state will be cleared in Player::UpdateContestedPvP
8453     if(GetTypeId()!=TYPEID_PLAYER)
8454         clearUnitState(UNIT_STAT_ATTACK_PLAYER);
8455 }
8456
8457 bool Unit::isTargetableForAttack() const
8458 {
8459     if (GetTypeId()==TYPEID_PLAYER && ((Player *)this)->isGameMaster())
8460         return false;
8461
8462     if(HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE))
8463         return false;
8464
8465     return isAlive() && !hasUnitState(UNIT_STAT_DIED)&& !isInFlight() /*&& !isStealth()*/;
8466 }
8467
8468 int32 Unit::ModifyHealth(int32 dVal)
8469 {
8470     int32 gain = 0;
8471
8472     if(dVal==0)
8473         return 0;
8474
8475     int32 curHealth = (int32)GetHealth();
8476
8477     int32 val = dVal + curHealth;
8478     if(val <= 0)
8479     {
8480         SetHealth(0);
8481         return -curHealth;
8482     }
8483
8484     int32 maxHealth = (int32)GetMaxHealth();
8485
8486     if(val < maxHealth)
8487     {
8488         SetHealth(val);
8489         gain = val - curHealth;
8490     }
8491     else if(curHealth != maxHealth)
8492     {
8493         SetHealth(maxHealth);
8494         gain = maxHealth - curHealth;
8495     }
8496
8497     return gain;
8498 }
8499
8500 int32 Unit::ModifyPower(Powers power, int32 dVal)
8501 {
8502     int32 gain = 0;
8503
8504     if(dVal==0)
8505         return 0;
8506
8507     int32 curPower = (int32)GetPower(power);
8508
8509     int32 val = dVal + curPower;
8510     if(val <= 0)
8511     {
8512         SetPower(power,0);
8513         return -curPower;
8514     }
8515
8516     int32 maxPower = (int32)GetMaxPower(power);
8517
8518     if(val < maxPower)
8519     {
8520         SetPower(power,val);
8521         gain = val - curPower;
8522     }
8523     else if(curPower != maxPower)
8524     {
8525         SetPower(power,maxPower);
8526         gain = maxPower - curPower;
8527     }
8528
8529     return gain;
8530 }
8531
8532 bool Unit::isVisibleForOrDetect(Unit const* u, bool detect, bool inVisibleList) const
8533 {
8534     if(!u)
8535         return false;
8536
8537     // Always can see self
8538     if (u==this)
8539         return true;
8540
8541     // player visible for other player if not logout and at same transport
8542     // including case when player is out of world
8543     bool at_same_transport =
8544         GetTypeId() == TYPEID_PLAYER &&  u->GetTypeId()==TYPEID_PLAYER &&
8545         !((Player*)this)->GetSession()->PlayerLogout() && !((Player*)u)->GetSession()->PlayerLogout() &&
8546         !((Player*)this)->GetSession()->PlayerLoading() && !((Player*)u)->GetSession()->PlayerLoading() &&
8547         ((Player*)this)->GetTransport() && ((Player*)this)->GetTransport() == ((Player*)u)->GetTransport();
8548
8549     // not in world
8550     if(!at_same_transport && (!IsInWorld() || !u->IsInWorld()))
8551         return false;
8552
8553     // forbidden to seen (at GM respawn command)
8554     if(m_Visibility==VISIBILITY_RESPAWN)
8555         return false;
8556
8557     // always seen by owner
8558     if(GetCharmerOrOwnerGUID()==u->GetGUID())
8559         return true;
8560
8561     // Grid dead/alive checks
8562     if( u->GetTypeId()==TYPEID_PLAYER)
8563     {
8564         // non visible at grid for any stealth state
8565         if(!IsVisibleInGridForPlayer((Player *)u))
8566             return false;
8567
8568         // if player is dead then he can't detect anyone in any cases
8569         if(!u->isAlive())
8570             detect = false;
8571     }
8572     else
8573     {
8574         // all dead creatures/players not visible for any creatures
8575         if(!u->isAlive() || !isAlive())
8576             return false;
8577     }
8578
8579     // different visible distance checks
8580     if(u->isInFlight())                                     // what see player in flight
8581     {
8582         // use object grey distance for all (only see objects any way)
8583         if (!IsWithinDistInMap(u,World::GetMaxVisibleDistanceInFlight()+(inVisibleList ? World::GetVisibleObjectGreyDistance() : 0.0f)))
8584             return false;
8585     }
8586     else if(!isAlive())                                     // distance for show body
8587     {
8588         if (!IsWithinDistInMap(u,World::GetMaxVisibleDistanceForObject()+(inVisibleList ? World::GetVisibleObjectGreyDistance() : 0.0f)))
8589             return false;
8590     }
8591     else if(GetTypeId()==TYPEID_PLAYER)                     // distance for show player
8592     {
8593         if(u->GetTypeId()==TYPEID_PLAYER)
8594         {
8595             // Players far than max visible distance for player or not in our map are not visible too
8596             if (!at_same_transport && !IsWithinDistInMap(u,World::GetMaxVisibleDistanceForPlayer()+(inVisibleList ? World::GetVisibleUnitGreyDistance() : 0.0f)))
8597                 return false;
8598         }
8599         else
8600         {
8601             // Units far than max visible distance for creature or not in our map are not visible too
8602             if (!IsWithinDistInMap(u,World::GetMaxVisibleDistanceForCreature()+(inVisibleList ? World::GetVisibleUnitGreyDistance() : 0.0f)))
8603                 return false;
8604         }
8605     }
8606     else if(GetCharmerOrOwnerGUID())                        // distance for show pet/charmed
8607     {
8608         // Pet/charmed far than max visible distance for player or not in our map are not visible too
8609         if (!IsWithinDistInMap(u,World::GetMaxVisibleDistanceForPlayer()+(inVisibleList ? World::GetVisibleUnitGreyDistance() : 0.0f)))
8610             return false;
8611     }
8612     else                                                    // distance for show creature
8613     {
8614         // Units far than max visible distance for creature or not in our map are not visible too
8615         if (!IsWithinDistInMap(u,World::GetMaxVisibleDistanceForCreature()+(inVisibleList ? World::GetVisibleUnitGreyDistance() : 0.0f)))
8616             return false;
8617     }
8618
8619     // Visible units, always are visible for all units, except for units under invisibility
8620     if (m_Visibility == VISIBILITY_ON && u->m_invisibilityMask==0)
8621         return true;
8622
8623     // GMs see any players, not higher GMs and all units
8624     if (u->GetTypeId() == TYPEID_PLAYER && ((Player *)u)->isGameMaster())
8625     {
8626         if(GetTypeId() == TYPEID_PLAYER)
8627             return ((Player *)this)->GetSession()->GetSecurity() <= ((Player *)u)->GetSession()->GetSecurity();
8628         else
8629             return true;
8630     }
8631
8632     // non faction visibility non-breakable for non-GMs
8633     if (m_Visibility == VISIBILITY_OFF)
8634         return false;
8635
8636     // raw invisibility
8637     bool invisible = (m_invisibilityMask != 0 || u->m_invisibilityMask !=0);
8638
8639     // detectable invisibility case
8640     if( invisible && (
8641         // Invisible units, always are visible for units under same invisibility type
8642         (m_invisibilityMask & u->m_invisibilityMask)!=0 ||
8643         // Invisible units, always are visible for unit that can detect this invisibility (have appropriate level for detect)
8644         u->canDetectInvisibilityOf(this) ||
8645         // Units that can detect invisibility always are visible for units that can be detected
8646         canDetectInvisibilityOf(u) ))
8647     {
8648         invisible = false;
8649     }
8650
8651     // special cases for always overwrite invisibility/stealth
8652     if(invisible || m_Visibility == VISIBILITY_GROUP_STEALTH)
8653     {
8654         // non-hostile case
8655         if (!u->IsHostileTo(this))
8656         {
8657             // player see other player with stealth/invisibility only if he in same group or raid or same team (raid/team case dependent from conf setting)
8658             if(GetTypeId()==TYPEID_PLAYER && u->GetTypeId()==TYPEID_PLAYER)
8659             {
8660                 if(((Player*)this)->IsGroupVisibleFor(((Player*)u)))
8661                     return true;
8662
8663                 // else apply same rules as for hostile case (detecting check for stealth)
8664             }
8665         }
8666         // hostile case
8667         else
8668         {
8669             // Hunter mark functionality
8670             AuraList const& auras = GetAurasByType(SPELL_AURA_MOD_STALKED);
8671             for(AuraList::const_iterator iter = auras.begin(); iter != auras.end(); ++iter)
8672                 if((*iter)->GetCasterGUID()==u->GetGUID())
8673                     return true;
8674
8675             // else apply detecting check for stealth
8676         }
8677
8678         // none other cases for detect invisibility, so invisible
8679         if(invisible)
8680             return false;
8681
8682         // else apply stealth detecting check
8683     }
8684
8685     // unit got in stealth in this moment and must ignore old detected state
8686     if (m_Visibility == VISIBILITY_GROUP_NO_DETECT)
8687         return false;
8688
8689     // GM invisibility checks early, invisibility if any detectable, so if not stealth then visible
8690     if (m_Visibility != VISIBILITY_GROUP_STEALTH)
8691         return true;
8692
8693     // NOW ONLY STEALTH CASE
8694
8695     // stealth and detected and visible for some seconds
8696     if (u->GetTypeId() == TYPEID_PLAYER  && ((Player*)u)->m_DetectInvTimer > 300 && ((Player*)u)->HaveAtClient(this))
8697         return true;
8698
8699     //if in non-detect mode then invisible for unit
8700     if (!detect)
8701         return false;
8702
8703     // Special cases
8704
8705     // If is attacked then stealth is lost, some creature can use stealth too
8706     if( !getAttackers().empty() )
8707         return true;
8708
8709     // If there is collision rogue is seen regardless of level difference
8710     // TODO: check sizes in DB
8711     float distance = GetDistance(u);
8712     if (distance < 0.24f)
8713         return true;
8714
8715     //If a mob or player is stunned he will not be able to detect stealth
8716     if (u->hasUnitState(UNIT_STAT_STUNNED) && (u != this))
8717         return false;
8718
8719     // Creature can detect target only in aggro radius
8720     if(u->GetTypeId() != TYPEID_PLAYER)
8721     {
8722         //Always invisible from back and out of aggro range
8723         bool isInFront = u->isInFront(this,((Creature const*)u)->GetAttackDistance(this));
8724         if(!isInFront)
8725             return false;
8726     }
8727     else
8728     {
8729         //Always invisible from back
8730         bool isInFront = u->isInFront(this,(GetTypeId()==TYPEID_PLAYER || GetCharmerOrOwnerGUID()) ? World::GetMaxVisibleDistanceForPlayer() : World::GetMaxVisibleDistanceForCreature());
8731         if(!isInFront)
8732             return false;
8733     }
8734
8735     // if doesn't have stealth detection (Shadow Sight), then check how stealthy the unit is, otherwise just check los
8736     if(!u->HasAuraType(SPELL_AURA_DETECT_STEALTH))
8737     {
8738         //Calculation if target is in front
8739
8740         //Visible distance based on stealth value (stealth rank 4 300MOD, 10.5 - 3 = 7.5)
8741         float visibleDistance = 10.5f - (GetTotalAuraModifier(SPELL_AURA_MOD_STEALTH)/100.0f);
8742
8743         //Visible distance is modified by
8744         //-Level Diff (every level diff = 1.0f in visible distance)
8745         visibleDistance += int32(u->getLevelForTarget(this)) - int32(getLevelForTarget(u));
8746
8747         //This allows to check talent tree and will add addition stealth dependent on used points)
8748         int32 stealthMod = GetTotalAuraModifier(SPELL_AURA_MOD_STEALTH_LEVEL);
8749         if(stealthMod < 0)
8750             stealthMod = 0;
8751
8752         //-Stealth Mod(positive like Master of Deception) and Stealth Detection(negative like paranoia)
8753         //based on wowwiki every 5 mod we have 1 more level diff in calculation
8754         visibleDistance += (int32(u->GetTotalAuraModifier(SPELL_AURA_MOD_DETECT)) - stealthMod)/5.0f;
8755
8756         if(distance > visibleDistance)
8757             return false;
8758     }
8759
8760     // Now check is target visible with LoS
8761     float ox,oy,oz;
8762     u->GetPosition(ox,oy,oz);
8763     return IsWithinLOS(ox,oy,oz);
8764 }
8765
8766 void Unit::SetVisibility(UnitVisibility x)
8767 {
8768     m_Visibility = x;
8769
8770     if(IsInWorld())
8771     {
8772         Map *m = MapManager::Instance().GetMap(GetMapId(), this);
8773
8774         if(GetTypeId()==TYPEID_PLAYER)
8775             m->PlayerRelocation((Player*)this,GetPositionX(),GetPositionY(),GetPositionZ(),GetOrientation());
8776         else
8777             m->CreatureRelocation((Creature*)this,GetPositionX(),GetPositionY(),GetPositionZ(),GetOrientation());
8778     }
8779 }
8780
8781 bool Unit::canDetectInvisibilityOf(Unit const* u) const
8782 {
8783     if(uint32 mask = (m_detectInvisibilityMask & u->m_invisibilityMask))
8784     {
8785         for(uint32 i = 0; i < 10; ++i)
8786         {
8787             if(((1 << i) & mask)==0)
8788                 continue;
8789
8790             // find invisibility level
8791             uint32 invLevel = 0;
8792             Unit::AuraList const& iAuras = u->GetAurasByType(SPELL_AURA_MOD_INVISIBILITY);
8793             for(Unit::AuraList::const_iterator itr = iAuras.begin(); itr != iAuras.end(); ++itr)
8794                 if(((*itr)->GetModifier()->m_miscvalue)==i && invLevel < (*itr)->GetModifier()->m_amount)
8795                     invLevel = (*itr)->GetModifier()->m_amount;
8796
8797             // find invisibility detect level
8798             uint32 detectLevel = 0;
8799             Unit::AuraList const& dAuras = GetAurasByType(SPELL_AURA_MOD_INVISIBILITY_DETECTION);
8800             for(Unit::AuraList::const_iterator itr = dAuras.begin(); itr != dAuras.end(); ++itr)
8801                 if(((*itr)->GetModifier()->m_miscvalue)==i && detectLevel < (*itr)->GetModifier()->m_amount)
8802                     detectLevel = (*itr)->GetModifier()->m_amount;
8803
8804             if(i==6 && GetTypeId()==TYPEID_PLAYER)          // special drunk detection case
8805             {
8806                 detectLevel = ((Player*)this)->GetDrunkValue();
8807             }
8808
8809             if(invLevel <= detectLevel)
8810                 return true;
8811         }
8812     }
8813
8814     return false;
8815 }
8816
8817 void Unit::UpdateSpeed(UnitMoveType mtype, bool forced)
8818 {
8819     int32 main_speed_mod  = 0;
8820     float stack_bonus     = 1.0f;
8821     float non_stack_bonus = 1.0f;
8822
8823     switch(mtype)
8824     {
8825         case MOVE_WALK:
8826             return;
8827         case MOVE_RUN:
8828         {
8829             if (IsMounted()) // Use on mount auras
8830             {
8831                 main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED);
8832                 stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS);
8833                 non_stack_bonus = (100.0f + GetMaxPositiveAuraModifier(SPELL_AURA_MOD_MOUNTED_SPEED_NOT_STACK))/100.0f;
8834             }
8835             else
8836             {
8837                 main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_SPEED);
8838                 stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_SPEED_ALWAYS);
8839                 non_stack_bonus = (100.0f + GetMaxPositiveAuraModifier(SPELL_AURA_MOD_SPEED_NOT_STACK))/100.0f;
8840             }
8841             break;
8842         }
8843         case MOVE_WALKBACK:
8844             return;
8845         case MOVE_SWIM:
8846         {
8847             main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_SWIM_SPEED);
8848             break;
8849         }
8850         case MOVE_SWIMBACK:
8851             return;
8852         case MOVE_FLY:
8853         {
8854             if (IsMounted()) // Use on mount auras
8855                 main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED);
8856             else             // Use not mount (shapeshift for example) auras (should stack)
8857                 main_speed_mod  = GetTotalAuraModifier(SPELL_AURA_MOD_SPEED_FLIGHT);
8858             stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_FLIGHT_SPEED_ALWAYS);
8859             non_stack_bonus = (100.0 + GetMaxPositiveAuraModifier(SPELL_AURA_MOD_FLIGHT_SPEED_NOT_STACK))/100.0f;
8860             break;
8861         }
8862         case MOVE_FLYBACK:
8863             return;
8864         default:
8865             sLog.outError("Unit::UpdateSpeed: Unsupported move type (%d)", mtype);
8866             return;
8867     }
8868
8869     float bonus = non_stack_bonus > stack_bonus ? non_stack_bonus : stack_bonus;
8870     // now we ready for speed calculation
8871     float speed  = main_speed_mod ? bonus*(100.0f + main_speed_mod)/100.0f : bonus;
8872
8873     switch(mtype)
8874     {
8875         case MOVE_RUN:
8876         case MOVE_SWIM:
8877         case MOVE_FLY:
8878         {
8879             // Normalize speed by 191 aura SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED if need
8880             // TODO: possible affect only on MOVE_RUN
8881             if(int32 normalization = GetMaxPositiveAuraModifier(SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED))
8882             {
8883                 // Use speed from aura
8884                 float max_speed = normalization / baseMoveSpeed[mtype];
8885                 if (speed > max_speed)
8886                     speed = max_speed;
8887             }
8888             break;
8889         }
8890         default:
8891             break;
8892     }
8893
8894     // Apply strongest slow aura mod to speed
8895     int32 slow = GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
8896     if (slow)
8897         speed *=(100.0f + slow)/100.0f;
8898     SetSpeed(mtype, speed, forced);
8899 }
8900
8901 float Unit::GetSpeed( UnitMoveType mtype ) const
8902 {
8903     return m_speed_rate[mtype]*baseMoveSpeed[mtype];
8904 }
8905
8906 void Unit::SetSpeed(UnitMoveType mtype, float rate, bool forced)
8907 {
8908     if (rate < 0)
8909         rate = 0.0f;
8910
8911     // Update speed only on change
8912     if (m_speed_rate[mtype] == rate)
8913         return;
8914
8915     m_speed_rate[mtype] = rate;
8916
8917     propagateSpeedChange();
8918
8919     // Send speed change packet only for player
8920     if (GetTypeId()!=TYPEID_PLAYER)
8921         return;
8922
8923     WorldPacket data;
8924     if(!forced)
8925     {
8926         switch(mtype)
8927         {
8928             case MOVE_WALK:
8929                 data.Initialize(MSG_MOVE_SET_WALK_SPEED, 8+4+1+4+4+4+4+4+4+4);
8930                 break;
8931             case MOVE_RUN:
8932                 data.Initialize(MSG_MOVE_SET_RUN_SPEED, 8+4+1+4+4+4+4+4+4+4);
8933                 break;
8934             case MOVE_WALKBACK:
8935                 data.Initialize(MSG_MOVE_SET_RUN_BACK_SPEED, 8+4+1+4+4+4+4+4+4+4);
8936                 break;
8937             case MOVE_SWIM:
8938                 data.Initialize(MSG_MOVE_SET_SWIM_SPEED, 8+4+1+4+4+4+4+4+4+4);
8939                 break;
8940             case MOVE_SWIMBACK:
8941                 data.Initialize(MSG_MOVE_SET_SWIM_BACK_SPEED, 8+4+1+4+4+4+4+4+4+4);
8942                 break;
8943             case MOVE_TURN:
8944                 data.Initialize(MSG_MOVE_SET_TURN_RATE, 8+4+1+4+4+4+4+4+4+4);
8945                 break;
8946             case MOVE_FLY:
8947                 data.Initialize(MSG_MOVE_SET_FLIGHT_SPEED, 8+4+1+4+4+4+4+4+4+4);
8948                 break;
8949             case MOVE_FLYBACK:
8950                 data.Initialize(MSG_MOVE_SET_FLIGHT_BACK_SPEED, 8+4+1+4+4+4+4+4+4+4);
8951                 break;
8952             default:
8953                 sLog.outError("Unit::SetSpeed: Unsupported move type (%d), data not sent to client.",mtype);
8954                 return;
8955         }
8956
8957         data.append(GetPackGUID());
8958         data << uint32(0);                                  //movement flags
8959         data << uint16(0);                                  //unk
8960         data << uint32(getMSTime());
8961         data << float(GetPositionX());
8962         data << float(GetPositionY());
8963         data << float(GetPositionZ());
8964         data << float(GetOrientation());
8965         data << uint32(0);                                  //flag unk
8966         data << float(GetSpeed(mtype));
8967         SendMessageToSet( &data, true );
8968     }
8969     else
8970     {
8971         // register forced speed changes for WorldSession::HandleForceSpeedChangeAck
8972         // and do it only for real sent packets and use run for run/mounted as client expected
8973         ++((Player*)this)->m_forced_speed_changes[mtype];
8974         switch(mtype)
8975         {
8976             case MOVE_WALK:
8977                 data.Initialize(SMSG_FORCE_WALK_SPEED_CHANGE, 16);
8978                 break;
8979             case MOVE_RUN:
8980                 data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE, 17);
8981                 break;
8982             case MOVE_WALKBACK:
8983                 data.Initialize(SMSG_FORCE_RUN_BACK_SPEED_CHANGE, 16);
8984                 break;
8985             case MOVE_SWIM:
8986                 data.Initialize(SMSG_FORCE_SWIM_SPEED_CHANGE, 16);
8987                 break;
8988             case MOVE_SWIMBACK:
8989                 data.Initialize(SMSG_FORCE_SWIM_BACK_SPEED_CHANGE, 16);
8990                 break;
8991             case MOVE_TURN:
8992                 data.Initialize(SMSG_FORCE_TURN_RATE_CHANGE, 16);
8993                 break;
8994             case MOVE_FLY:
8995                 data.Initialize(SMSG_FORCE_FLIGHT_SPEED_CHANGE, 16);
8996                 break;
8997             case MOVE_FLYBACK:
8998                 data.Initialize(SMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE, 16);
8999                 break;
9000             default:
9001                 sLog.outError("Unit::SetSpeed: Unsupported move type (%d), data not sent to client.",mtype);
9002                 return;
9003         }
9004         data.append(GetPackGUID());
9005         data << (uint32)0;
9006         if (mtype == MOVE_RUN)
9007             data << uint8(0);                               // new 2.1.0
9008         data << float(GetSpeed(mtype));
9009         SendMessageToSet( &data, true );
9010     }
9011     if(Pet* pet = GetPet())
9012         pet->SetSpeed(MOVE_RUN, m_speed_rate[mtype],forced);
9013 }
9014
9015 void Unit::SetHover(bool on)
9016 {
9017     if(on)
9018         CastSpell(this,11010,true);
9019     else
9020         RemoveAurasDueToSpell(11010);
9021 }
9022
9023 void Unit::setDeathState(DeathState s)
9024 {
9025     if (s != ALIVE && s!= JUST_ALIVED)
9026     {
9027         CombatStop();
9028         DeleteThreatList();
9029         ClearComboPointHolders();                           // any combo points pointed to unit lost at it death
9030
9031         if(IsNonMeleeSpellCasted(false))
9032             InterruptNonMeleeSpells(false);
9033     }
9034
9035     if (s == JUST_DIED)
9036     {
9037         RemoveAllAurasOnDeath();
9038         UnsummonAllTotems();
9039
9040         ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, false);
9041         ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, false);
9042         // remove aurastates allowing special moves
9043         ClearAllReactives();
9044         ClearDiminishings();
9045     }
9046     else if(s == JUST_ALIVED)
9047     {
9048         RemoveFlag (UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); // clear skinnable for creature and player (at battleground)
9049     }
9050
9051     if (m_deathState != ALIVE && s == ALIVE)
9052     {
9053         //_ApplyAllAuraMods();
9054     }
9055     m_deathState = s;
9056 }
9057
9058 /*########################################
9059 ########                          ########
9060 ########       AGGRO SYSTEM       ########
9061 ########                          ########
9062 ########################################*/
9063 bool Unit::CanHaveThreatList() const
9064 {
9065     // only creatures can have threat list
9066     if( GetTypeId() != TYPEID_UNIT )
9067         return false;
9068
9069     // only alive units can have threat list
9070     if( !isAlive() )
9071         return false;
9072
9073     // pets and totems can not have threat list
9074     if( ((Creature*)this)->isPet() || ((Creature*)this)->isTotem() || ((Creature*)this)->isVehicle() )
9075         return false;
9076
9077     return true;
9078 }
9079
9080 //======================================================================
9081
9082 float Unit::ApplyTotalThreatModifier(float threat, SpellSchoolMask schoolMask)
9083 {
9084     if(!HasAuraType(SPELL_AURA_MOD_THREAT))
9085         return threat;
9086
9087     SpellSchools school = GetFirstSchoolInMask(schoolMask);
9088
9089     return threat * m_threatModifier[school];
9090 }
9091
9092 //======================================================================
9093
9094 void Unit::AddThreat(Unit* pVictim, float threat, SpellSchoolMask schoolMask, SpellEntry const *threatSpell)
9095 {
9096     // Only mobs can manage threat lists
9097     if(CanHaveThreatList())
9098         m_ThreatManager.addThreat(pVictim, threat, schoolMask, threatSpell);
9099 }
9100
9101 //======================================================================
9102
9103 void Unit::DeleteThreatList()
9104 {
9105     m_ThreatManager.clearReferences();
9106 }
9107
9108 //======================================================================
9109
9110 void Unit::TauntApply(Unit* taunter)
9111 {
9112     assert(GetTypeId()== TYPEID_UNIT);
9113
9114     if(!taunter || (taunter->GetTypeId() == TYPEID_PLAYER && ((Player*)taunter)->isGameMaster()))
9115         return;
9116
9117     if(!CanHaveThreatList())
9118         return;
9119
9120     Unit *target = getVictim();
9121     if(target && target == taunter)
9122         return;
9123
9124     SetInFront(taunter);
9125     if (((Creature*)this)->AI())
9126         ((Creature*)this)->AI()->AttackStart(taunter);
9127
9128     m_ThreatManager.tauntApply(taunter);
9129 }
9130
9131 //======================================================================
9132
9133 void Unit::TauntFadeOut(Unit *taunter)
9134 {
9135     assert(GetTypeId()== TYPEID_UNIT);
9136
9137     if(!taunter || (taunter->GetTypeId() == TYPEID_PLAYER && ((Player*)taunter)->isGameMaster()))
9138         return;
9139
9140     if(!CanHaveThreatList())
9141         return;
9142
9143     Unit *target = getVictim();
9144     if(!target || target != taunter)
9145         return;
9146
9147     if(m_ThreatManager.isThreatListEmpty())
9148     {
9149         if(((Creature*)this)->AI())
9150             ((Creature*)this)->AI()->EnterEvadeMode();
9151         return;
9152     }
9153
9154     m_ThreatManager.tauntFadeOut(taunter);
9155     target = m_ThreatManager.getHostilTarget();
9156
9157     if (target && target != taunter)
9158     {
9159         SetInFront(target);
9160         if (((Creature*)this)->AI())
9161             ((Creature*)this)->AI()->AttackStart(target);
9162     }
9163 }
9164
9165 //======================================================================
9166
9167 bool Unit::SelectHostilTarget()
9168 {
9169     //function provides main threat functionality
9170     //next-victim-selection algorithm and evade mode are called
9171     //threat list sorting etc.
9172
9173     assert(GetTypeId()== TYPEID_UNIT);
9174     Unit* target = NULL;
9175
9176     //This function only useful once AI has been initialized
9177     if (!((Creature*)this)->AI())
9178         return false;
9179
9180     if(!m_ThreatManager.isThreatListEmpty())
9181     {
9182         if(!HasAuraType(SPELL_AURA_MOD_TAUNT))
9183         {
9184             target = m_ThreatManager.getHostilTarget();
9185         }
9186     }
9187
9188     if(target)
9189     {
9190         if(!hasUnitState(UNIT_STAT_STUNNED))
9191             SetInFront(target);
9192         ((Creature*)this)->AI()->AttackStart(target);
9193         return true;
9194     }
9195
9196     // no target but something prevent go to evade mode
9197     if( !isInCombat() || HasAuraType(SPELL_AURA_MOD_TAUNT) )
9198         return false;
9199
9200     // last case when creature don't must go to evade mode:
9201     // it in combat but attacker not make any damage and not enter to aggro radius to have record in threat list
9202     // for example at owner command to pet attack some far away creature
9203     // Note: creature not have targeted movement generator but have attacker in this case
9204     if( GetMotionMaster()->GetCurrentMovementGeneratorType() != TARGETED_MOTION_TYPE )
9205     {
9206         for(AttackerSet::const_iterator itr = m_attackers.begin(); itr != m_attackers.end(); ++itr)
9207         {
9208             if( (*itr)->IsInMap(this) && (*itr)->isTargetableForAttack() && (*itr)->isInAccessablePlaceFor((Creature*)this) )
9209                 return false;
9210         }
9211     }
9212
9213     // enter in evade mode in other case
9214     ((Creature*)this)->AI()->EnterEvadeMode();
9215
9216     return false;
9217 }
9218
9219 //======================================================================
9220 //======================================================================
9221 //======================================================================
9222
9223 int32 Unit::CalculateSpellDamage(SpellEntry const* spellProto, uint8 effect_index, int32 effBasePoints, Unit const* target)
9224 {
9225     Player* unitPlayer = (GetTypeId() == TYPEID_PLAYER) ? (Player*)this : NULL;
9226
9227     uint8 comboPoints = unitPlayer ? unitPlayer->GetComboPoints() : 0;
9228
9229     int32 level = int32(getLevel()) - int32(spellProto->spellLevel);
9230     if (level > spellProto->maxLevel && spellProto->maxLevel > 0)
9231         level = spellProto->maxLevel;
9232
9233     float basePointsPerLevel = spellProto->EffectRealPointsPerLevel[effect_index];
9234     float randomPointsPerLevel = spellProto->EffectDicePerLevel[effect_index];
9235     int32 basePoints = int32(effBasePoints + level * basePointsPerLevel);
9236     int32 randomPoints = int32(spellProto->EffectDieSides[effect_index] + level * randomPointsPerLevel);
9237     float comboDamage = spellProto->EffectPointsPerComboPoint[effect_index];
9238
9239     // prevent random generator from getting confused by spells casted with Unit::CastCustomSpell
9240     int32 randvalue = spellProto->EffectBaseDice[effect_index] >= randomPoints ? spellProto->EffectBaseDice[effect_index]:irand(spellProto->EffectBaseDice[effect_index], randomPoints);
9241     int32 value = basePoints + randvalue;
9242     //random damage
9243     if(comboDamage != 0 && unitPlayer && target && (target->GetGUID() == unitPlayer->GetComboTarget()))
9244         value += (int32)(comboDamage * comboPoints);
9245
9246     if(Player* modOwner = GetSpellModOwner())
9247     {
9248         modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_ALL_EFFECTS, value);
9249         switch(effect_index)
9250         {
9251             case 0:
9252                 modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_EFFECT1, value);
9253                 break;
9254             case 1:
9255                 modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_EFFECT2, value);
9256                 break;
9257             case 2:
9258                 modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_EFFECT3, value);
9259                 break;
9260         }
9261     }
9262
9263     if(spellProto->Attributes & SPELL_ATTR_LEVEL_DAMAGE_CALCULATION && spellProto->spellLevel &&
9264             spellProto->Effect[effect_index] != SPELL_EFFECT_WEAPON_PERCENT_DAMAGE &&
9265             spellProto->Effect[effect_index] != SPELL_EFFECT_KNOCK_BACK)
9266         value = int32(value*0.25f*exp(getLevel()*(70-spellProto->spellLevel)/1000.0f));
9267
9268     return value;
9269 }
9270
9271 int32 Unit::CalculateSpellDuration(SpellEntry const* spellProto, uint8 effect_index, Unit const* target)
9272 {
9273     Player* unitPlayer = (GetTypeId() == TYPEID_PLAYER) ? (Player*)this : NULL;
9274
9275     uint8 comboPoints = unitPlayer ? unitPlayer->GetComboPoints() : 0;
9276
9277     int32 minduration = GetSpellDuration(spellProto);
9278     int32 maxduration = GetSpellMaxDuration(spellProto);
9279
9280     int32 duration;
9281
9282     if( minduration != -1 && minduration != maxduration )
9283         duration = minduration + int32((maxduration - minduration) * comboPoints / 5);
9284     else
9285         duration = minduration;
9286
9287     if (duration > 0)
9288     {
9289         int32 mechanic = GetEffectMechanic(spellProto, effect_index);
9290         // Find total mod value (negative bonus)
9291         int32 durationMod_always = target->GetTotalAuraModifierByMiscValue(SPELL_AURA_MECHANIC_DURATION_MOD, mechanic);
9292         // Find max mod (negative bonus)
9293         int32 durationMod_not_stack = target->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MECHANIC_DURATION_MOD_NOT_STACK, mechanic);
9294
9295         int32 durationMod = 0;
9296         // Select strongest negative mod
9297         if (durationMod_always > durationMod_not_stack)
9298             durationMod = durationMod_not_stack;
9299         else
9300             durationMod = durationMod_always;
9301
9302         if (durationMod != 0)
9303             duration = int32(int64(duration) * (100+durationMod) /100);
9304
9305         if (duration < 0) duration = 0;
9306     }
9307
9308     return duration;
9309 }
9310
9311 DiminishingLevels Unit::GetDiminishing(DiminishingGroup group)
9312 {
9313     for(Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
9314     {
9315         if(i->DRGroup != group)
9316             continue;
9317
9318         if(!i->hitCount)
9319             return DIMINISHING_LEVEL_1;
9320
9321         if(!i->hitTime)
9322             return DIMINISHING_LEVEL_1;
9323
9324         // If last spell was casted more than 15 seconds ago - reset the count.
9325         if(i->stack==0 && getMSTimeDiff(i->hitTime,getMSTime()) > 15000)
9326         {
9327             i->hitCount = DIMINISHING_LEVEL_1;
9328             return DIMINISHING_LEVEL_1;
9329         }
9330         // or else increase the count.
9331         else
9332         {
9333             return DiminishingLevels(i->hitCount);
9334         }
9335     }
9336     return DIMINISHING_LEVEL_1;
9337 }
9338
9339 void Unit::IncrDiminishing(DiminishingGroup group)
9340 {
9341     // Checking for existing in the table
9342     bool IsExist = false;
9343     for(Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
9344     {
9345         if(i->DRGroup != group)
9346             continue;
9347
9348         IsExist = true;
9349         if(i->hitCount < DIMINISHING_LEVEL_IMMUNE)
9350             i->hitCount += 1;
9351
9352         break;
9353     }
9354
9355     if(!IsExist)
9356         m_Diminishing.push_back(DiminishingReturn(group,getMSTime(),DIMINISHING_LEVEL_2));
9357 }
9358
9359 void Unit::ApplyDiminishingToDuration(DiminishingGroup group, int32 &duration,Unit* caster,DiminishingLevels Level)
9360 {
9361     if(duration == -1 || group == DIMINISHING_NONE || caster->IsFriendlyTo(this) )
9362         return;
9363
9364     // Duration of crowd control abilities on pvp target is limited by 10 sec. (2.2.0)
9365     if(duration > 10000 && IsDiminishingReturnsGroupDurationLimited(group))
9366     {
9367         // test pet/charm masters instead pets/charmeds
9368         Unit const* targetOwner = GetCharmerOrOwner();
9369         Unit const* casterOwner = caster->GetCharmerOrOwner();
9370
9371         Unit const* target = targetOwner ? targetOwner : this;
9372         Unit const* source = casterOwner ? casterOwner : caster;
9373
9374         if(target->GetTypeId() == TYPEID_PLAYER && source->GetTypeId() == TYPEID_PLAYER)
9375             duration = 10000;
9376     }
9377
9378     float mod = 1.0f;
9379
9380     // Some diminishings applies to mobs too (for example, Stun)
9381     if((GetDiminishingReturnsGroupType(group) == DRTYPE_PLAYER && GetTypeId() == TYPEID_PLAYER) || GetDiminishingReturnsGroupType(group) == DRTYPE_ALL)
9382     {
9383         DiminishingLevels diminish = Level;
9384         switch(diminish)
9385         {
9386             case DIMINISHING_LEVEL_1: break;
9387             case DIMINISHING_LEVEL_2: mod = 0.5f; break;
9388             case DIMINISHING_LEVEL_3: mod = 0.25f; break;
9389             case DIMINISHING_LEVEL_IMMUNE: mod = 0.0f;break;
9390             default: break;
9391         }
9392     }
9393
9394     duration = int32(duration * mod);
9395 }
9396
9397 void Unit::ApplyDiminishingAura( DiminishingGroup group, bool apply )
9398 {
9399     // Checking for existing in the table
9400     for(Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
9401     {
9402         if(i->DRGroup != group)
9403             continue;
9404
9405         i->hitTime = getMSTime();
9406
9407         if(apply)
9408             i->stack += 1;
9409         else if(i->stack)
9410             i->stack -= 1;
9411
9412         break;
9413     }
9414 }
9415
9416 Unit* Unit::GetUnit(WorldObject& object, uint64 guid)
9417 {
9418     return ObjectAccessor::GetUnit(object,guid);
9419 }
9420
9421 bool Unit::isVisibleForInState( Player const* u, bool inVisibleList ) const
9422 {
9423     return isVisibleForOrDetect(u,false,inVisibleList);
9424 }
9425
9426 uint32 Unit::GetCreatureType() const
9427 {
9428     if(GetTypeId() == TYPEID_PLAYER)
9429     {
9430         SpellShapeshiftEntry const* ssEntry = sSpellShapeshiftStore.LookupEntry(((Player*)this)->m_form);
9431         if(ssEntry && ssEntry->creatureType > 0)
9432             return ssEntry->creatureType;
9433         else
9434             return CREATURE_TYPE_HUMANOID;
9435     }
9436     else
9437         return ((Creature*)this)->GetCreatureInfo()->type;
9438 }
9439
9440 /*#######################################
9441 ########                         ########
9442 ########       STAT SYSTEM       ########
9443 ########                         ########
9444 #######################################*/
9445
9446 bool Unit::HandleStatModifier(UnitMods unitMod, UnitModifierType modifierType, float amount, bool apply)
9447 {
9448     if(unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
9449     {
9450         sLog.outError("ERROR in HandleStatModifier(): non existed UnitMods or wrong UnitModifierType!");
9451         return false;
9452     }
9453
9454     float val = 1.0f;
9455
9456     switch(modifierType)
9457     {
9458         case BASE_VALUE:
9459         case TOTAL_VALUE:
9460             m_auraModifiersGroup[unitMod][modifierType] += apply ? amount : -amount;
9461             break;
9462         case BASE_PCT:
9463         case TOTAL_PCT:
9464             if(amount <= -100.0f)                           //small hack-fix for -100% modifiers
9465                 amount = -200.0f;
9466
9467             val = (100.0f + amount) / 100.0f;
9468             m_auraModifiersGroup[unitMod][modifierType] *= apply ? val : (1.0f/val);
9469             break;
9470
9471         default:
9472             break;
9473     }
9474
9475     if(!CanModifyStats())
9476         return false;
9477
9478     switch(unitMod)
9479     {
9480         case UNIT_MOD_STAT_STRENGTH:
9481         case UNIT_MOD_STAT_AGILITY:
9482         case UNIT_MOD_STAT_STAMINA:
9483         case UNIT_MOD_STAT_INTELLECT:
9484         case UNIT_MOD_STAT_SPIRIT:         UpdateStats(GetStatByAuraGroup(unitMod));  break;
9485
9486         case UNIT_MOD_ARMOR:               UpdateArmor();           break;
9487         case UNIT_MOD_HEALTH:              UpdateMaxHealth();       break;
9488
9489         case UNIT_MOD_MANA:
9490         case UNIT_MOD_RAGE:
9491         case UNIT_MOD_FOCUS:
9492         case UNIT_MOD_ENERGY:
9493         case UNIT_MOD_HAPPINESS:           UpdateMaxPower(GetPowerTypeByAuraGroup(unitMod));         break;
9494
9495         case UNIT_MOD_RESISTANCE_HOLY:
9496         case UNIT_MOD_RESISTANCE_FIRE:
9497         case UNIT_MOD_RESISTANCE_NATURE:
9498         case UNIT_MOD_RESISTANCE_FROST:
9499         case UNIT_MOD_RESISTANCE_SHADOW:
9500         case UNIT_MOD_RESISTANCE_ARCANE:   UpdateResistances(GetSpellSchoolByAuraGroup(unitMod));      break;
9501
9502         case UNIT_MOD_ATTACK_POWER:        UpdateAttackPowerAndDamage();         break;
9503         case UNIT_MOD_ATTACK_POWER_RANGED: UpdateAttackPowerAndDamage(true);     break;
9504
9505         case UNIT_MOD_DAMAGE_MAINHAND:     UpdateDamagePhysical(BASE_ATTACK);    break;
9506         case UNIT_MOD_DAMAGE_OFFHAND:      UpdateDamagePhysical(OFF_ATTACK);     break;
9507         case UNIT_MOD_DAMAGE_RANGED:       UpdateDamagePhysical(RANGED_ATTACK);  break;
9508
9509         default:
9510             break;
9511     }
9512
9513     return true;
9514 }
9515
9516 float Unit::GetModifierValue(UnitMods unitMod, UnitModifierType modifierType) const
9517 {
9518     if( unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
9519     {
9520         sLog.outError("ERROR: trial to access non existed modifier value from UnitMods!");
9521         return 0.0f;
9522     }
9523
9524     if(modifierType == TOTAL_PCT && m_auraModifiersGroup[unitMod][modifierType] <= 0.0f)
9525         return 0.0f;
9526
9527     return m_auraModifiersGroup[unitMod][modifierType];
9528 }
9529
9530 float Unit::GetTotalStatValue(Stats stat) const
9531 {
9532     UnitMods unitMod = UnitMods(UNIT_MOD_STAT_START + stat);
9533
9534     if(m_auraModifiersGroup[unitMod][TOTAL_PCT] <= 0.0f)
9535         return 0.0f;
9536
9537     // value = ((base_value * base_pct) + total_value) * total_pct
9538     float value  = m_auraModifiersGroup[unitMod][BASE_VALUE] + GetCreateStat(stat);
9539     value *= m_auraModifiersGroup[unitMod][BASE_PCT];
9540     value += m_auraModifiersGroup[unitMod][TOTAL_VALUE];
9541     value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];
9542
9543     return value;
9544 }
9545
9546 float Unit::GetTotalAuraModValue(UnitMods unitMod) const
9547 {
9548     if(unitMod >= UNIT_MOD_END)
9549     {
9550         sLog.outError("ERROR: trial to access non existed UnitMods in GetTotalAuraModValue()!");
9551         return 0.0f;
9552     }
9553
9554     if(m_auraModifiersGroup[unitMod][TOTAL_PCT] <= 0.0f)
9555         return 0.0f;
9556
9557     float value  = m_auraModifiersGroup[unitMod][BASE_VALUE];
9558     value *= m_auraModifiersGroup[unitMod][BASE_PCT];
9559     value += m_auraModifiersGroup[unitMod][TOTAL_VALUE];
9560     value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];
9561
9562     return value;
9563 }
9564
9565 SpellSchools Unit::GetSpellSchoolByAuraGroup(UnitMods unitMod) const
9566 {
9567     SpellSchools school = SPELL_SCHOOL_NORMAL;
9568
9569     switch(unitMod)
9570     {
9571         case UNIT_MOD_RESISTANCE_HOLY:     school = SPELL_SCHOOL_HOLY;          break;
9572         case UNIT_MOD_RESISTANCE_FIRE:     school = SPELL_SCHOOL_FIRE;          break;
9573         case UNIT_MOD_RESISTANCE_NATURE:   school = SPELL_SCHOOL_NATURE;        break;
9574         case UNIT_MOD_RESISTANCE_FROST:    school = SPELL_SCHOOL_FROST;         break;
9575         case UNIT_MOD_RESISTANCE_SHADOW:   school = SPELL_SCHOOL_SHADOW;        break;
9576         case UNIT_MOD_RESISTANCE_ARCANE:   school = SPELL_SCHOOL_ARCANE;        break;
9577
9578         default:
9579             break;
9580     }
9581
9582     return school;
9583 }
9584
9585 Stats Unit::GetStatByAuraGroup(UnitMods unitMod) const
9586 {
9587     Stats stat = STAT_STRENGTH;
9588
9589     switch(unitMod)
9590     {
9591         case UNIT_MOD_STAT_STRENGTH:    stat = STAT_STRENGTH;      break;
9592         case UNIT_MOD_STAT_AGILITY:     stat = STAT_AGILITY;       break;
9593         case UNIT_MOD_STAT_STAMINA:     stat = STAT_STAMINA;       break;
9594         case UNIT_MOD_STAT_INTELLECT:   stat = STAT_INTELLECT;     break;
9595         case UNIT_MOD_STAT_SPIRIT:      stat = STAT_SPIRIT;        break;
9596
9597         default:
9598             break;
9599     }
9600
9601     return stat;
9602 }
9603
9604 Powers Unit::GetPowerTypeByAuraGroup(UnitMods unitMod) const
9605 {
9606     Powers power = POWER_MANA;
9607
9608     switch(unitMod)
9609     {
9610         case UNIT_MOD_MANA:       power = POWER_MANA;       break;
9611         case UNIT_MOD_RAGE:       power = POWER_RAGE;       break;
9612         case UNIT_MOD_FOCUS:      power = POWER_FOCUS;      break;
9613         case UNIT_MOD_ENERGY:     power = POWER_ENERGY;     break;
9614         case UNIT_MOD_HAPPINESS:  power = POWER_HAPPINESS;  break;
9615
9616         default:
9617             break;
9618     }
9619
9620     return power;
9621 }
9622
9623 float Unit::GetTotalAttackPowerValue(WeaponAttackType attType) const
9624 {
9625     UnitMods unitMod = (attType == RANGED_ATTACK) ? UNIT_MOD_ATTACK_POWER_RANGED : UNIT_MOD_ATTACK_POWER;
9626
9627     float val = GetTotalAuraModValue(unitMod);
9628     if(val < 0.0f)
9629         val = 0.0f;
9630
9631     return val;
9632 }
9633
9634 float Unit::GetWeaponDamageRange(WeaponAttackType attType ,WeaponDamageRange type) const
9635 {
9636     if (attType == OFF_ATTACK && !haveOffhandWeapon())
9637         return 0.0f;
9638
9639     return m_weaponDamage[attType][type];
9640 }
9641
9642 void Unit::SetLevel(uint32 lvl)
9643 {
9644     SetUInt32Value(UNIT_FIELD_LEVEL, lvl);
9645
9646     // group update
9647     if ((GetTypeId() == TYPEID_PLAYER) && ((Player*)this)->GetGroup())
9648         ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_LEVEL);
9649 }
9650
9651 void Unit::SetHealth(uint32 val)
9652 {
9653     uint32 maxHealth = GetMaxHealth();
9654     if(maxHealth < val)
9655         val = maxHealth;
9656
9657     SetUInt32Value(UNIT_FIELD_HEALTH, val);
9658
9659     // group update
9660     if(GetTypeId() == TYPEID_PLAYER)
9661     {
9662         if(((Player*)this)->GetGroup())
9663             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_HP);
9664     }
9665     else if(((Creature*)this)->isPet())
9666     {
9667         Pet *pet = ((Pet*)this);
9668         if(pet->isControlled())
9669         {
9670             Unit *owner = GetOwner();
9671             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
9672                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_HP);
9673         }
9674     }
9675 }
9676
9677 void Unit::SetMaxHealth(uint32 val)
9678 {
9679     uint32 health = GetHealth();
9680     SetUInt32Value(UNIT_FIELD_MAXHEALTH, val);
9681
9682     // group update
9683     if(GetTypeId() == TYPEID_PLAYER)
9684     {
9685         if(((Player*)this)->GetGroup())
9686             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_HP);
9687     }
9688     else if(((Creature*)this)->isPet())
9689     {
9690         Pet *pet = ((Pet*)this);
9691         if(pet->isControlled())
9692         {
9693             Unit *owner = GetOwner();
9694             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
9695                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_HP);
9696         }
9697     }
9698
9699     if(val < health)
9700         SetHealth(val);
9701 }
9702
9703 void Unit::SetPower(Powers power, uint32 val)
9704 {
9705     uint32 maxPower = GetMaxPower(power);
9706     if(maxPower < val)
9707         val = maxPower;
9708
9709     SetStatInt32Value(UNIT_FIELD_POWER1 + power, val);
9710
9711     WorldPacket data(SMSG_POWER_UPDATE);
9712     data.append(GetPackGUID());
9713     data << uint8(power);
9714     data << uint32(val);
9715     SendMessageToSet(&data, GetTypeId() == TYPEID_PLAYER ? true : false);
9716
9717     // group update
9718     if(GetTypeId() == TYPEID_PLAYER)
9719     {
9720         if(((Player*)this)->GetGroup())
9721             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_POWER);
9722     }
9723     else if(((Creature*)this)->isPet())
9724     {
9725         Pet *pet = ((Pet*)this);
9726         if(pet->isControlled())
9727         {
9728             Unit *owner = GetOwner();
9729             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
9730                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_POWER);
9731         }
9732
9733         // Update the pet's character sheet with happiness damage bonus
9734         if(pet->getPetType() == HUNTER_PET && power == POWER_HAPPINESS)
9735         {
9736             pet->UpdateDamagePhysical(BASE_ATTACK);
9737         }
9738     }
9739 }
9740
9741 void Unit::SetMaxPower(Powers power, uint32 val)
9742 {
9743     uint32 cur_power = GetPower(power);
9744     SetStatInt32Value(UNIT_FIELD_MAXPOWER1 + power, val);
9745
9746     // group update
9747     if(GetTypeId() == TYPEID_PLAYER)
9748     {
9749         if(((Player*)this)->GetGroup())
9750             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_POWER);
9751     }
9752     else if(((Creature*)this)->isPet())
9753     {
9754         Pet *pet = ((Pet*)this);
9755         if(pet->isControlled())
9756         {
9757             Unit *owner = GetOwner();
9758             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
9759                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_POWER);
9760         }
9761     }
9762
9763     if(val < cur_power)
9764         SetPower(power, val);
9765 }
9766
9767 void Unit::ApplyPowerMod(Powers power, uint32 val, bool apply)
9768 {
9769     ApplyModUInt32Value(UNIT_FIELD_POWER1+power, val, apply);
9770
9771     // group update
9772     if(GetTypeId() == TYPEID_PLAYER)
9773     {
9774         if(((Player*)this)->GetGroup())
9775             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_POWER);
9776     }
9777     else if(((Creature*)this)->isPet())
9778     {
9779         Pet *pet = ((Pet*)this);
9780         if(pet->isControlled())
9781         {
9782             Unit *owner = GetOwner();
9783             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
9784                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_POWER);
9785         }
9786     }
9787 }
9788
9789 void Unit::ApplyMaxPowerMod(Powers power, uint32 val, bool apply)
9790 {
9791     ApplyModUInt32Value(UNIT_FIELD_MAXPOWER1+power, val, apply);
9792
9793     // group update
9794     if(GetTypeId() == TYPEID_PLAYER)
9795     {
9796         if(((Player*)this)->GetGroup())
9797             ((Player*)this)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_POWER);
9798     }
9799     else if(((Creature*)this)->isPet())
9800     {
9801         Pet *pet = ((Pet*)this);
9802         if(pet->isControlled())
9803         {
9804             Unit *owner = GetOwner();
9805             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
9806                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_POWER);
9807         }
9808     }
9809 }
9810
9811 void Unit::ApplyAuraProcTriggerDamage( Aura* aura, bool apply )
9812 {
9813     AuraList& tAuraProcTriggerDamage = m_modAuras[SPELL_AURA_PROC_TRIGGER_DAMAGE];
9814     if(apply)
9815         tAuraProcTriggerDamage.push_back(aura);
9816     else
9817         tAuraProcTriggerDamage.remove(aura);
9818 }
9819
9820 uint32 Unit::GetCreatePowers( Powers power ) const
9821 {
9822     // POWER_FOCUS and POWER_HAPPINESS only have hunter pet
9823     switch(power)
9824     {
9825         case POWER_MANA:      return GetCreateMana();
9826         case POWER_RAGE:      return 1000;
9827         case POWER_FOCUS:     return (GetTypeId()==TYPEID_PLAYER || !((Creature const*)this)->isPet() || ((Pet const*)this)->getPetType()!=HUNTER_PET ? 0 : 100);
9828         case POWER_ENERGY:    return 100;
9829         case POWER_HAPPINESS: return (GetTypeId()==TYPEID_PLAYER || !((Creature const*)this)->isPet() || ((Pet const*)this)->getPetType()!=HUNTER_PET ? 0 : 1050000);
9830         case POWER_RUNIC_POWER: return 1000;
9831     }
9832
9833     return 0;
9834 }
9835
9836 void Unit::AddToWorld()
9837 {
9838     Object::AddToWorld();
9839 }
9840
9841 void Unit::RemoveFromWorld()
9842 {
9843     // cleanup
9844     if(IsInWorld())
9845     {
9846         RemoveNotOwnSingleTargetAuras();
9847     }
9848
9849     Object::RemoveFromWorld();
9850 }
9851
9852 void Unit::CleanupsBeforeDelete()
9853 {
9854     if(m_uint32Values)                                      // only for fully created object
9855     {
9856         InterruptNonMeleeSpells(true);
9857         m_Events.KillAllEvents(false);                      // non-delatable (currently casted spells) will not deleted now but it will deleted at call in Map::RemoveAllObjectsInRemoveList
9858         CombatStop();
9859         ClearComboPointHolders();
9860         DeleteThreatList();
9861         getHostilRefManager().setOnlineOfflineState(false);
9862         RemoveAllAuras();
9863         RemoveAllGameObjects();
9864         RemoveAllDynObjects();
9865         GetMotionMaster()->Clear(false);                    // remove different non-standard movement generators.
9866     }
9867     RemoveFromWorld();
9868 }
9869
9870 CharmInfo* Unit::InitCharmInfo(Unit *charm)
9871 {
9872     if(!m_charmInfo)
9873         m_charmInfo = new CharmInfo(charm);
9874     return m_charmInfo;
9875 }
9876
9877 CharmInfo::CharmInfo(Unit* unit)
9878 : m_unit(unit), m_CommandState(COMMAND_FOLLOW), m_reactState(REACT_PASSIVE), m_petnumber(0)
9879 {
9880     for(int i =0; i<4; ++i)
9881     {
9882         m_charmspells[i].spellId = 0;
9883         m_charmspells[i].active = ACT_DISABLED;
9884     }
9885 }
9886
9887 void CharmInfo::InitPetActionBar()
9888 {
9889     // the first 3 SpellOrActions are attack, follow and stay
9890     for(uint32 i = 0; i < 3; i++)
9891     {
9892         PetActionBar[i].Type = ACT_COMMAND;
9893         PetActionBar[i].SpellOrAction = COMMAND_ATTACK - i;
9894
9895         PetActionBar[i + 7].Type = ACT_REACTION;
9896         PetActionBar[i + 7].SpellOrAction = COMMAND_ATTACK - i;
9897     }
9898     for(uint32 i=0; i < 4; i++)
9899     {
9900         PetActionBar[i + 3].Type = ACT_DISABLED;
9901         PetActionBar[i + 3].SpellOrAction = 0;
9902     }
9903 }
9904
9905 void CharmInfo::InitEmptyActionBar()
9906 {
9907     for(uint32 x = 1; x < 10; ++x)
9908     {
9909         PetActionBar[x].Type = ACT_PASSIVE;
9910         PetActionBar[x].SpellOrAction = 0;
9911     }
9912     PetActionBar[0].Type = ACT_COMMAND;
9913     PetActionBar[0].SpellOrAction = COMMAND_ATTACK;
9914 }
9915
9916 void CharmInfo::InitPossessCreateSpells()
9917 {
9918     if(m_unit->GetTypeId() == TYPEID_PLAYER)
9919         return;
9920
9921     InitEmptyActionBar();                                   //charm action bar
9922
9923     for(uint32 x = 0; x < CREATURE_MAX_SPELLS; ++x)
9924     {
9925         if (IsPassiveSpell(((Creature*)m_unit)->m_spells[x]))
9926             m_unit->CastSpell(m_unit, ((Creature*)m_unit)->m_spells[x], true);
9927         else
9928             AddSpellToAB(0, ((Creature*)m_unit)->m_spells[x], ACT_PASSIVE);
9929     }
9930 }
9931
9932 void CharmInfo::InitCharmCreateSpells()
9933 {
9934     if(m_unit->GetTypeId() == TYPEID_PLAYER)                //charmed players don't have spells
9935     {
9936         InitEmptyActionBar();
9937         return;
9938     }
9939
9940     InitPetActionBar();
9941
9942     for(uint32 x = 0; x < CREATURE_MAX_SPELLS; ++x)
9943     {
9944         uint32 spellId = ((Creature*)m_unit)->m_spells[x];
9945         m_charmspells[x].spellId = spellId;
9946
9947         if(!spellId)
9948             continue;
9949
9950         if (IsPassiveSpell(spellId))
9951         {
9952             m_unit->CastSpell(m_unit, spellId, true);
9953             m_charmspells[x].active = ACT_PASSIVE;
9954         }
9955         else
9956         {
9957             ActiveStates newstate;
9958             bool onlyselfcast = true;
9959             SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
9960
9961             if(!spellInfo) onlyselfcast = false;
9962             for(uint32 i = 0;i<3 && onlyselfcast;++i)       //non existent spell will not make any problems as onlyselfcast would be false -> break right away
9963             {
9964                 if(spellInfo->EffectImplicitTargetA[i] != TARGET_SELF && spellInfo->EffectImplicitTargetA[i] != 0)
9965                     onlyselfcast = false;
9966             }
9967
9968             if(onlyselfcast || !IsPositiveSpell(spellId))   //only self cast and spells versus enemies are autocastable
9969                 newstate = ACT_DISABLED;
9970             else
9971                 newstate = ACT_PASSIVE;
9972
9973             AddSpellToAB(0, spellId, newstate);
9974         }
9975     }
9976 }
9977
9978 bool CharmInfo::AddSpellToAB(uint32 oldid, uint32 newid, ActiveStates newstate)
9979 {
9980     for(uint8 i = 0; i < 10; i++)
9981     {
9982         if((PetActionBar[i].Type == ACT_DISABLED || PetActionBar[i].Type == ACT_ENABLED || PetActionBar[i].Type == ACT_PASSIVE) && PetActionBar[i].SpellOrAction == oldid)
9983         {
9984             PetActionBar[i].SpellOrAction = newid;
9985             if(!oldid)
9986             {
9987                 if(newstate == ACT_DECIDE)
9988                     PetActionBar[i].Type = ACT_DISABLED;
9989                 else
9990                     PetActionBar[i].Type = newstate;
9991             }
9992
9993             return true;
9994         }
9995     }
9996     return false;
9997 }
9998
9999 void CharmInfo::ToggleCreatureAutocast(uint32 spellid, bool apply)
10000 {
10001     if(IsPassiveSpell(spellid))
10002         return;
10003
10004     for(uint32 x = 0; x < CREATURE_MAX_SPELLS; ++x)
10005     {
10006         if(spellid == m_charmspells[x].spellId)
10007         {
10008             m_charmspells[x].active = apply ? ACT_ENABLED : ACT_DISABLED;
10009         }
10010     }
10011 }
10012
10013 void CharmInfo::SetPetNumber(uint32 petnumber, bool statwindow)
10014 {
10015     m_petnumber = petnumber;
10016     if(statwindow)
10017         m_unit->SetUInt32Value(UNIT_FIELD_PETNUMBER, m_petnumber);
10018     else
10019         m_unit->SetUInt32Value(UNIT_FIELD_PETNUMBER, 0);
10020 }
10021
10022 bool Unit::isFrozen() const
10023 {
10024     AuraList const& mRoot = GetAurasByType(SPELL_AURA_MOD_ROOT);
10025     for(AuraList::const_iterator i = mRoot.begin(); i != mRoot.end(); ++i)
10026         if( GetSpellSchoolMask((*i)->GetSpellProto()) & SPELL_SCHOOL_MASK_FROST)
10027             return true;
10028     return false;
10029 }
10030
10031 struct ProcTriggeredData
10032 {
10033     ProcTriggeredData(Aura* _triggeredByAura, uint32 _cooldown)
10034         : triggeredByAura(_triggeredByAura),
10035         triggeredByAura_SpellPair(Unit::spellEffectPair(triggeredByAura->GetId(),triggeredByAura->GetEffIndex())),
10036         cooldown(_cooldown)
10037     {}
10038
10039     Aura* triggeredByAura;                                  // triggred aura, can be invalidate at triggered aura proccessing
10040     Unit::spellEffectPair triggeredByAura_SpellPair;        // spell pair, used for re-find aura (by pointer comparison in range)
10041     uint32 cooldown;                                        // possible hidden cooldown
10042 };
10043
10044 typedef std::list< ProcTriggeredData > ProcTriggeredList;
10045
10046 void Unit::ProcDamageAndSpellFor( bool isVictim, Unit * pTarget, uint32 procFlag, AuraTypeSet const& procAuraTypes, WeaponAttackType attType, SpellEntry const * procSpell, uint32 damage, SpellSchoolMask damageSchoolMask )
10047 {
10048     for(AuraTypeSet::const_iterator aur = procAuraTypes.begin(); aur != procAuraTypes.end(); ++aur)
10049     {
10050         // List of spells (effects) that proceed. Spell prototype and aura-specific value (damage for TRIGGER_DAMAGE)
10051         ProcTriggeredList procTriggered;
10052
10053         AuraList const& auras = GetAurasByType(*aur);
10054         for(AuraList::const_iterator i = auras.begin(), next; i != auras.end(); i = next)
10055         {
10056             next = i; ++next;
10057
10058             Aura* i_aura = *i;
10059
10060             uint32 cooldown;                                // returned at next line
10061             if(!IsTriggeredAtSpellProcEvent(i_aura->GetSpellProto(), procSpell, procFlag,attType,isVictim,cooldown))
10062                 continue;
10063
10064             procTriggered.push_back( ProcTriggeredData(i_aura, cooldown) );
10065         }
10066
10067         // Handle effects proceed this time
10068         for(ProcTriggeredList::iterator i = procTriggered.begin(); i != procTriggered.end(); ++i)
10069         {
10070             // Some auras can be deleted in function called in this loop (except first, ofc)
10071             // Until storing auras in std::multimap to hard check deleting by another way
10072             if(i != procTriggered.begin())
10073             {
10074                 bool found = false;
10075                 AuraMap::const_iterator lower = GetAuras().lower_bound(i->triggeredByAura_SpellPair);
10076                 AuraMap::const_iterator upper = GetAuras().upper_bound(i->triggeredByAura_SpellPair);
10077                 for(AuraMap::const_iterator itr = lower; itr!= upper; ++itr)
10078                 {
10079                     if(itr->second==i->triggeredByAura)
10080                     {
10081                         found = true;
10082                         break;
10083                     }
10084                 }
10085
10086                 if(!found)
10087                 {
10088                     sLog.outError("Spell aura %u (id:%u effect:%u) has been deleted before call spell proc event handler",*aur,i->triggeredByAura_SpellPair.first,i->triggeredByAura_SpellPair.second);
10089                     sLog.outError("It can be deleted one from early processed auras:");
10090                     for(ProcTriggeredList::iterator i2 = procTriggered.begin(); i != i2; ++i2)
10091                         sLog.outError("     Spell aura %u (id:%u effect:%u)",*aur,i2->triggeredByAura_SpellPair.first,i2->triggeredByAura_SpellPair.second);
10092                     sLog.outError("     <end of list>");
10093                     continue;
10094                 }
10095             }
10096
10097             /// this is aura triggering code call
10098             Aura* triggeredByAura = i->triggeredByAura;
10099
10100             /// save charges existence before processing to prevent crash at access to deleted triggered aura after
10101             /// used in speedup code check before check aura existance.
10102             bool triggeredByAuraWithCharges =  triggeredByAura->m_procCharges > 0;
10103
10104             /// success in event proccesing
10105             /// used in speedup code check before check aura existance.
10106             bool casted = false;
10107
10108             /// process triggered code
10109             switch(*aur)
10110             {
10111                 case SPELL_AURA_PROC_TRIGGER_SPELL:
10112                 {
10113                     sLog.outDebug("ProcDamageAndSpell: casting spell (triggered by %s proc aura of spell %u)",
10114                         (isVictim?"a victim's":"an attacker's"),triggeredByAura->GetId());
10115                     casted = HandleProcTriggerSpell(pTarget, damage, triggeredByAura, procSpell, procFlag, attType, i->cooldown);
10116                     break;
10117                 }
10118                 case SPELL_AURA_PROC_TRIGGER_DAMAGE:
10119                 {
10120                     uint32 triggered_damage = triggeredByAura->GetModifier()->m_amount;
10121                     sLog.outDebug("ProcDamageAndSpell: doing %u damage (triggered by %s aura of spell %u)",
10122                         triggered_damage, (isVictim?"a victim's":"an attacker's"),triggeredByAura->GetId());
10123                     SpellNonMeleeDamageLog(pTarget, triggeredByAura->GetId(), triggered_damage, true, true);
10124                     casted = true;
10125                     break;
10126                 }
10127                 case SPELL_AURA_DUMMY:
10128                 {
10129                     uint32 effect = triggeredByAura->GetEffIndex();
10130                     sLog.outDebug("ProcDamageAndSpell: casting spell (triggered by %s dummy aura of spell %u)",
10131                         (isVictim?"a victim's":"an attacker's"),triggeredByAura->GetId());
10132                     casted = HandleDummyAuraProc(pTarget, damage, triggeredByAura, procSpell, procFlag,i->cooldown);
10133                     break;
10134                 }
10135                 case SPELL_AURA_PRAYER_OF_MENDING:
10136                 {
10137                     sLog.outDebug("ProcDamageAndSpell: casting mending (triggered by %s dummy aura of spell %u)",
10138                         (isVictim?"a victim's":"an attacker's"),triggeredByAura->GetId());
10139
10140                     casted = HandleMeandingAuraProc(triggeredByAura);
10141                     break;
10142                 }
10143                 case SPELL_AURA_MOD_HASTE:
10144                 {
10145                     sLog.outDebug("ProcDamageAndSpell: casting spell (triggered by %s haste aura of spell %u)",
10146                         (isVictim?"a victim's":"an attacker's"),triggeredByAura->GetId());
10147                     casted = HandleHasteAuraProc(pTarget, damage, triggeredByAura, procSpell, procFlag,i->cooldown);
10148                     break;
10149                 }
10150                 case SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN:
10151                 {
10152                     // nothing do, just charges counter
10153                     // but count only in case appropriate school damage
10154                     casted = triggeredByAura->GetModifier()->m_miscvalue & damageSchoolMask;
10155                     break;
10156                 }
10157                 case SPELL_AURA_OVERRIDE_CLASS_SCRIPTS:
10158                 {
10159                     sLog.outDebug("ProcDamageAndSpell: casting spell (triggered by %s class script aura of spell %u)",
10160                         (isVictim?"a victim's":"an attacker's"),triggeredByAura->GetId());
10161                     casted = HandleOverrideClassScriptAuraProc(pTarget, triggeredByAura, procSpell,i->cooldown);
10162                     break;
10163                 }
10164                 default:
10165                 {
10166                     // nothing do, just charges counter
10167                     casted = true;
10168                     break;
10169                 }
10170             }
10171
10172             /// Update charge (aura can be removed by triggers)
10173             if(casted && triggeredByAuraWithCharges)
10174             {
10175                 /// need re-found aura (can be dropped by triggers)
10176                 AuraMap::const_iterator lower = GetAuras().lower_bound(i->triggeredByAura_SpellPair);
10177                 AuraMap::const_iterator upper = GetAuras().upper_bound(i->triggeredByAura_SpellPair);
10178                 for(AuraMap::const_iterator itr = lower; itr!= upper; ++itr)
10179                 {
10180                     if(itr->second == triggeredByAura)      // pointer still valid
10181                     {
10182                         if(triggeredByAura->m_procCharges > 0)
10183                             triggeredByAura->m_procCharges -= 1;
10184
10185                         triggeredByAura->UpdateAuraCharges();
10186                         break;
10187                     }
10188                 }
10189             }
10190         }
10191
10192         /// Safely remove auras with zero charges
10193         for(AuraList::const_iterator i = auras.begin(), next; i != auras.end(); i = next)
10194         {
10195             next = i; ++next;
10196             if((*i)->m_procCharges == 0)
10197             {
10198                 RemoveAurasDueToSpell((*i)->GetId());
10199                 next = auras.begin();
10200             }
10201         }
10202     }
10203 }
10204
10205 SpellSchoolMask Unit::GetMeleeDamageSchoolMask() const
10206 {
10207     return SPELL_SCHOOL_MASK_NORMAL;
10208 }
10209
10210 Player* Unit::GetSpellModOwner()
10211 {
10212     if(GetTypeId()==TYPEID_PLAYER)
10213         return (Player*)this;
10214     if(((Creature*)this)->isPet() || ((Creature*)this)->isTotem())
10215     {
10216         Unit* owner = GetOwner();
10217         if(owner && owner->GetTypeId()==TYPEID_PLAYER)
10218             return (Player*)owner;
10219     }
10220     return NULL;
10221 }
10222
10223 ///----------Pet responses methods-----------------
10224 void Unit::SendPetCastFail(uint32 spellid, uint8 msg)
10225 {
10226     Unit *owner = GetCharmerOrOwner();
10227     if(!owner || owner->GetTypeId() != TYPEID_PLAYER)
10228         return;
10229
10230     WorldPacket data(SMSG_PET_CAST_FAILED, (4+1));
10231     data << uint8(0);                                       // cast count?
10232     data << uint32(spellid);
10233     data << uint8(msg);
10234     // uint32 for some reason
10235     // uint32 for some reason
10236     ((Player*)owner)->GetSession()->SendPacket(&data);
10237 }
10238
10239 void Unit::SendPetActionFeedback (uint8 msg)
10240 {
10241     Unit* owner = GetOwner();
10242     if(!owner || owner->GetTypeId() != TYPEID_PLAYER)
10243         return;
10244
10245     WorldPacket data(SMSG_PET_ACTION_FEEDBACK, 1);
10246     data << uint8(msg);
10247     ((Player*)owner)->GetSession()->SendPacket(&data);
10248 }
10249
10250 void Unit::SendPetTalk (uint32 pettalk)
10251 {
10252     Unit* owner = GetOwner();
10253     if(!owner || owner->GetTypeId() != TYPEID_PLAYER)
10254         return;
10255
10256     WorldPacket data(SMSG_PET_ACTION_SOUND, 8+4);
10257     data << uint64(GetGUID());
10258     data << uint32(pettalk);
10259     ((Player*)owner)->GetSession()->SendPacket(&data);
10260 }
10261
10262 void Unit::SendPetSpellCooldown (uint32 spellid, time_t cooltime)
10263 {
10264     Unit* owner = GetOwner();
10265     if(!owner || owner->GetTypeId() != TYPEID_PLAYER)
10266         return;
10267
10268     WorldPacket data(SMSG_SPELL_COOLDOWN, 8+1+4+4);
10269     data << uint64(GetGUID());
10270     data << uint8(0x0);                                     // flags (0x1, 0x2)
10271     data << uint32(spellid);
10272     data << uint32(cooltime);
10273
10274     ((Player*)owner)->GetSession()->SendPacket(&data);
10275 }
10276
10277 void Unit::SendPetClearCooldown (uint32 spellid)
10278 {
10279     Unit* owner = GetOwner();
10280     if(!owner || owner->GetTypeId() != TYPEID_PLAYER)
10281         return;
10282
10283     WorldPacket data(SMSG_CLEAR_COOLDOWN, (4+8));
10284     data << uint32(spellid);
10285     data << uint64(GetGUID());
10286     ((Player*)owner)->GetSession()->SendPacket(&data);
10287 }
10288
10289 void Unit::SendPetAIReaction(uint64 guid)
10290 {
10291     Unit* owner = GetOwner();
10292     if(!owner || owner->GetTypeId() != TYPEID_PLAYER)
10293         return;
10294
10295     WorldPacket data(SMSG_AI_REACTION, 12);
10296     data << uint64(guid) << uint32(00000002);
10297     ((Player*)owner)->GetSession()->SendPacket(&data);
10298 }
10299
10300 ///----------End of Pet responses methods----------
10301
10302 void Unit::StopMoving()
10303 {
10304     clearUnitState(UNIT_STAT_MOVING);
10305
10306     // send explicit stop packet
10307     // rely on vmaps here because for example stormwind is in air
10308     //float z = MapManager::Instance().GetBaseMap(GetMapId())->GetHeight(GetPositionX(), GetPositionY(), GetPositionZ(), true);
10309     //if (fabs(GetPositionZ() - z) < 2.0f)
10310     //    Relocate(GetPositionX(), GetPositionY(), z);
10311     Relocate(GetPositionX(), GetPositionY(),GetPositionZ());
10312
10313     SendMonsterMove(GetPositionX(), GetPositionY(), GetPositionZ(), 0, true, 0);
10314
10315     // update position and orientation;
10316     WorldPacket data;
10317     BuildHeartBeatMsg(&data);
10318     SendMessageToSet(&data,false);
10319 }
10320
10321 void Unit::SetFeared(bool apply, uint64 casterGUID, uint32 spellID)
10322 {
10323     if( apply )
10324     {
10325         if(HasAuraType(SPELL_AURA_PREVENTS_FLEEING))
10326             return;
10327
10328         SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_FLEEING);
10329
10330         GetMotionMaster()->MovementExpired(false);
10331         CastStop(GetGUID()==casterGUID ? spellID : 0);
10332
10333         Unit* caster = ObjectAccessor::GetUnit(*this,casterGUID);
10334
10335         GetMotionMaster()->MoveFleeing(caster);             // caster==NULL processed in MoveFleeing
10336     }
10337     else
10338     {
10339         RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_FLEEING);
10340
10341         GetMotionMaster()->MovementExpired(false);
10342
10343         if( GetTypeId() != TYPEID_PLAYER && isAlive() )
10344         {
10345             // restore appropriate movement generator
10346             if(getVictim())
10347                 GetMotionMaster()->MoveChase(getVictim());
10348             else
10349                 GetMotionMaster()->Initialize();
10350
10351             // attack caster if can
10352             Unit* caster = ObjectAccessor::GetObjectInWorld(casterGUID, (Unit*)NULL);
10353             if(caster && caster != getVictim() && ((Creature*)this)->AI())
10354                 ((Creature*)this)->AI()->AttackStart(caster);
10355         }
10356     }
10357
10358     if (GetTypeId() == TYPEID_PLAYER)
10359         ((Player*)this)->SetClientControl(this, !apply);
10360 }
10361
10362 void Unit::SetConfused(bool apply, uint64 casterGUID, uint32 spellID)
10363 {
10364     if( apply )
10365     {
10366         SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_CONFUSED);
10367
10368         CastStop(GetGUID()==casterGUID ? spellID : 0);
10369
10370         GetMotionMaster()->MoveConfused();
10371     }
10372     else
10373     {
10374         RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_CONFUSED);
10375
10376         GetMotionMaster()->MovementExpired(false);
10377
10378         if (GetTypeId() == TYPEID_UNIT)
10379         {
10380             // if in combat restore movement generator
10381             if(getVictim())
10382                 GetMotionMaster()->MoveChase(getVictim());
10383         }
10384     }
10385
10386     if(GetTypeId() == TYPEID_PLAYER)
10387         ((Player*)this)->SetClientControl(this, !apply);
10388 }
10389
10390 bool Unit::IsSitState() const
10391 {
10392     uint8 s = getStandState();
10393     return s == PLAYER_STATE_SIT_CHAIR || s == PLAYER_STATE_SIT_LOW_CHAIR ||
10394         s == PLAYER_STATE_SIT_MEDIUM_CHAIR || s == PLAYER_STATE_SIT_HIGH_CHAIR ||
10395         s == PLAYER_STATE_SIT;
10396 }
10397
10398 bool Unit::IsStandState() const
10399 {
10400     uint8 s = getStandState();
10401     return !IsSitState() && s != PLAYER_STATE_SLEEP && s != PLAYER_STATE_KNEEL;
10402 }
10403
10404 void Unit::SetStandState(uint8 state)
10405 {
10406     SetByteValue(UNIT_FIELD_BYTES_1, 0, state);
10407
10408     if (IsStandState())
10409        RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_SEATED);
10410
10411     if(GetTypeId()==TYPEID_PLAYER)
10412     {
10413         WorldPacket data(SMSG_STANDSTATE_UPDATE, 1);
10414         data << (uint8)state;
10415         ((Player*)this)->GetSession()->SendPacket(&data);
10416     }
10417 }
10418
10419 bool Unit::IsPolymorphed() const
10420 {
10421     return GetSpellSpecific(getTransForm())==SPELL_MAGE_POLYMORPH;
10422 }
10423
10424 void Unit::SetDisplayId(uint32 modelId)
10425 {
10426     SetUInt32Value(UNIT_FIELD_DISPLAYID, modelId);
10427
10428     if(GetTypeId() == TYPEID_UNIT && ((Creature*)this)->isPet())
10429     {
10430         Pet *pet = ((Pet*)this);
10431         if(!pet->isControlled())
10432             return;
10433         Unit *owner = GetOwner();
10434         if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
10435             ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MODEL_ID);
10436     }
10437 }
10438
10439 void Unit::ClearComboPointHolders()
10440 {
10441     while(!m_ComboPointHolders.empty())
10442     {
10443         uint32 lowguid = *m_ComboPointHolders.begin();
10444
10445         Player* plr = objmgr.GetPlayer(MAKE_NEW_GUID(lowguid, 0, HIGHGUID_PLAYER));
10446         if(plr && plr->GetComboTarget()==GetGUID())         // recheck for safe
10447             plr->ClearComboPoints();                        // remove also guid from m_ComboPointHolders;
10448         else
10449             m_ComboPointHolders.erase(lowguid);             // or remove manually
10450     }
10451 }
10452
10453 void Unit::ClearAllReactives()
10454 {
10455
10456     for(int i=0; i < MAX_REACTIVE; ++i)
10457         m_reactiveTimer[i] = 0;
10458
10459     if (HasAuraState( AURA_STATE_DEFENSE))
10460         ModifyAuraState(AURA_STATE_DEFENSE, false);
10461     if (getClass() == CLASS_HUNTER && HasAuraState( AURA_STATE_HUNTER_PARRY))
10462         ModifyAuraState(AURA_STATE_HUNTER_PARRY, false);
10463     if (HasAuraState( AURA_STATE_CRIT))
10464         ModifyAuraState(AURA_STATE_CRIT, false);
10465     if (getClass() == CLASS_HUNTER && HasAuraState( AURA_STATE_HUNTER_CRIT_STRIKE)  )
10466         ModifyAuraState(AURA_STATE_HUNTER_CRIT_STRIKE, false);
10467
10468     if(getClass() == CLASS_WARRIOR && GetTypeId() == TYPEID_PLAYER)
10469         ((Player*)this)->ClearComboPoints();
10470 }
10471
10472 void Unit::UpdateReactives( uint32 p_time )
10473 {
10474     for(int i = 0; i < MAX_REACTIVE; ++i)
10475     {
10476         ReactiveType reactive = ReactiveType(i);
10477
10478         if(!m_reactiveTimer[reactive])
10479             continue;
10480
10481         if ( m_reactiveTimer[reactive] <= p_time)
10482         {
10483             m_reactiveTimer[reactive] = 0;
10484
10485             switch ( reactive )
10486             {
10487                 case REACTIVE_DEFENSE:
10488                     if (HasAuraState(AURA_STATE_DEFENSE))
10489                         ModifyAuraState(AURA_STATE_DEFENSE, false);
10490                     break;
10491                 case REACTIVE_HUNTER_PARRY:
10492                     if ( getClass() == CLASS_HUNTER && HasAuraState(AURA_STATE_HUNTER_PARRY))
10493                         ModifyAuraState(AURA_STATE_HUNTER_PARRY, false);
10494                     break;
10495                 case REACTIVE_CRIT:
10496                     if (HasAuraState(AURA_STATE_CRIT))
10497                         ModifyAuraState(AURA_STATE_CRIT, false);
10498                     break;
10499                 case REACTIVE_HUNTER_CRIT:
10500                     if ( getClass() == CLASS_HUNTER && HasAuraState(AURA_STATE_HUNTER_CRIT_STRIKE) )
10501                         ModifyAuraState(AURA_STATE_HUNTER_CRIT_STRIKE, false);
10502                     break;
10503                 case REACTIVE_OVERPOWER:
10504                     if(getClass() == CLASS_WARRIOR && GetTypeId() == TYPEID_PLAYER)
10505                         ((Player*)this)->ClearComboPoints();
10506                     break;
10507                 default:
10508                     break;
10509             }
10510         }
10511         else
10512         {
10513             m_reactiveTimer[reactive] -= p_time;
10514         }
10515     }
10516 }
10517
10518 Unit* Unit::SelectNearbyTarget() const
10519 {
10520     CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
10521     Cell cell(p);
10522     cell.data.Part.reserved = ALL_DISTRICT;
10523     cell.SetNoCreate();
10524
10525     std::list<Unit *> targets;
10526
10527     {
10528         MaNGOS::AnyUnfriendlyUnitInObjectRangeCheck u_check(this, this, ATTACK_DISTANCE);
10529         MaNGOS::UnitListSearcher<MaNGOS::AnyUnfriendlyUnitInObjectRangeCheck> searcher(targets, u_check);
10530
10531         TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyUnfriendlyUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
10532         TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyUnfriendlyUnitInObjectRangeCheck>, GridTypeMapContainer >  grid_unit_searcher(searcher);
10533
10534         CellLock<GridReadGuard> cell_lock(cell, p);
10535         cell_lock->Visit(cell_lock, world_unit_searcher, *MapManager::Instance().GetMap(GetMapId(), this));
10536         cell_lock->Visit(cell_lock, grid_unit_searcher, *MapManager::Instance().GetMap(GetMapId(), this));
10537     }
10538
10539     // remove current target
10540     if(getVictim())
10541         targets.remove(getVictim());
10542
10543     // remove not LoS targets
10544     for(std::list<Unit *>::iterator tIter = targets.begin(); tIter != targets.end();)
10545     {
10546         if(!IsWithinLOSInMap(*tIter))
10547         {
10548             std::list<Unit *>::iterator tIter2 = tIter;
10549             ++tIter;
10550             targets.erase(tIter2);
10551         }
10552         else
10553             ++tIter;
10554     }
10555
10556     // no appropriate targets
10557     if(targets.empty())
10558         return NULL;
10559
10560     // select random
10561     uint32 rIdx = urand(0,targets.size()-1);
10562     std::list<Unit *>::const_iterator tcIter = targets.begin();
10563     for(uint32 i = 0; i < rIdx; ++i)
10564         ++tcIter;
10565
10566     return *tcIter;
10567 }
10568
10569 void Unit::ApplyAttackTimePercentMod( WeaponAttackType att,float val, bool apply )
10570 {
10571     if(val > 0)
10572     {
10573         ApplyPercentModFloatVar(m_modAttackSpeedPct[att], val, !apply);
10574         ApplyPercentModFloatValue(UNIT_FIELD_BASEATTACKTIME+att,val,!apply);
10575     }
10576     else
10577     {
10578         ApplyPercentModFloatVar(m_modAttackSpeedPct[att], -val, apply);
10579         ApplyPercentModFloatValue(UNIT_FIELD_BASEATTACKTIME+att,-val,apply);
10580     }
10581 }
10582
10583 void Unit::ApplyCastTimePercentMod(float val, bool apply )
10584 {
10585     if(val > 0)
10586         ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED,val,!apply);
10587     else
10588         ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED,-val,apply);
10589 }
10590
10591 uint32 Unit::GetCastingTimeForBonus( SpellEntry const *spellProto, DamageEffectType damagetype, uint32 CastingTime )
10592 {
10593     if (CastingTime > 7000) CastingTime = 7000;
10594     if (CastingTime < 1500) CastingTime = 1500;
10595
10596     if(damagetype == DOT && !IsChanneledSpell(spellProto))
10597         CastingTime = 3500;
10598
10599     int32 overTime    = 0;
10600     uint8 effects     = 0;
10601     bool DirectDamage = false;
10602     bool AreaEffect   = false;
10603
10604     for ( uint32 i=0; i<3;i++)
10605     {
10606         switch ( spellProto->Effect[i] )
10607         {
10608             case SPELL_EFFECT_SCHOOL_DAMAGE:
10609             case SPELL_EFFECT_POWER_DRAIN:
10610             case SPELL_EFFECT_HEALTH_LEECH:
10611             case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE:
10612             case SPELL_EFFECT_POWER_BURN:
10613             case SPELL_EFFECT_HEAL:
10614                 DirectDamage = true;
10615                 break;
10616             case SPELL_EFFECT_APPLY_AURA:
10617                 switch ( spellProto->EffectApplyAuraName[i] )
10618                 {
10619                     case SPELL_AURA_PERIODIC_DAMAGE:
10620                     case SPELL_AURA_PERIODIC_HEAL:
10621                     case SPELL_AURA_PERIODIC_LEECH:
10622                         if ( GetSpellDuration(spellProto) )
10623                             overTime = GetSpellDuration(spellProto);
10624                         break;
10625                     default:
10626                         // -5% per additional effect
10627                         ++effects;
10628                         break;
10629                 }
10630             default:
10631                 break;
10632         }
10633
10634         if(IsAreaEffectTarget(Targets(spellProto->EffectImplicitTargetA[i])) || IsAreaEffectTarget(Targets(spellProto->EffectImplicitTargetB[i])))
10635             AreaEffect = true;
10636     }
10637
10638     // Combined Spells with Both Over Time and Direct Damage
10639     if ( overTime > 0 && CastingTime > 0 && DirectDamage )
10640     {
10641         // mainly for DoTs which are 3500 here otherwise
10642         uint32 OriginalCastTime = GetSpellCastTime(spellProto);
10643         if (OriginalCastTime > 7000) OriginalCastTime = 7000;
10644         if (OriginalCastTime < 1500) OriginalCastTime = 1500;
10645         // Portion to Over Time
10646         float PtOT = (overTime / 15000.f) / ((overTime / 15000.f) + (OriginalCastTime / 3500.f));
10647
10648         if ( damagetype == DOT )
10649             CastingTime = uint32(CastingTime * PtOT);
10650         else if ( PtOT < 1.0f )
10651             CastingTime  = uint32(CastingTime * (1 - PtOT));
10652         else
10653             CastingTime = 0;
10654     }
10655
10656     // Area Effect Spells receive only half of bonus
10657     if ( AreaEffect )
10658         CastingTime /= 2;
10659
10660     // -5% of total per any additional effect
10661     for ( uint8 i=0; i<effects; ++i)
10662     {
10663         if ( CastingTime > 175 )
10664         {
10665             CastingTime -= 175;
10666         }
10667         else
10668         {
10669             CastingTime = 0;
10670             break;
10671         }
10672     }
10673
10674     return CastingTime;
10675 }
10676
10677 void Unit::UpdateAuraForGroup(uint8 slot)
10678 {
10679     if(GetTypeId() == TYPEID_PLAYER)
10680     {
10681         Player* player = (Player*)this;
10682         if(player->GetGroup())
10683         {
10684             player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_AURAS);
10685             player->SetAuraUpdateMask(slot);
10686         }
10687     }
10688     else if(GetTypeId() == TYPEID_UNIT && ((Creature*)this)->isPet())
10689     {
10690         Pet *pet = ((Pet*)this);
10691         if(pet->isControlled())
10692         {
10693             Unit *owner = GetOwner();
10694             if(owner && (owner->GetTypeId() == TYPEID_PLAYER) && ((Player*)owner)->GetGroup())
10695             {
10696                 ((Player*)owner)->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_AURAS);
10697                 pet->SetAuraUpdateMask(slot);
10698             }
10699         }
10700     }
10701 }
10702
10703 float Unit::GetAPMultiplier(WeaponAttackType attType, bool normalized)
10704 {
10705     if (!normalized || GetTypeId() != TYPEID_PLAYER)
10706         return float(GetAttackTime(attType))/1000.0f;
10707
10708     Item *Weapon = ((Player*)this)->GetWeaponForAttack(attType);
10709     if (!Weapon)
10710         return 2.4;                                         // fist attack
10711
10712     switch (Weapon->GetProto()->InventoryType)
10713     {
10714         case INVTYPE_2HWEAPON:
10715             return 3.3;
10716         case INVTYPE_RANGED:
10717         case INVTYPE_RANGEDRIGHT:
10718         case INVTYPE_THROWN:
10719             return 2.8;
10720         case INVTYPE_WEAPON:
10721         case INVTYPE_WEAPONMAINHAND:
10722         case INVTYPE_WEAPONOFFHAND:
10723         default:
10724             return Weapon->GetProto()->SubClass==ITEM_SUBCLASS_WEAPON_DAGGER ? 1.7 : 2.4;
10725     }
10726 }
10727
10728 Aura* Unit::GetDummyAura( uint32 spell_id ) const
10729 {
10730     Unit::AuraList const& mDummy = GetAurasByType(SPELL_AURA_DUMMY);
10731     for(Unit::AuraList::const_iterator itr = mDummy.begin(); itr != mDummy.end(); ++itr)
10732         if ((*itr)->GetId() == spell_id)
10733             return *itr;
10734
10735     return NULL;
10736 }
10737
10738 bool Unit::IsUnderLastManaUseEffect() const
10739 {
10740     return  getMSTimeDiff(m_lastManaUse,getMSTime()) < 5000;
10741 }
10742
10743 void Unit::SetContestedPvP(Player *attackedPlayer)
10744 {
10745     Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
10746
10747     if(!player || attackedPlayer && (attackedPlayer == player || player->duel && player->duel->opponent == attackedPlayer))
10748         return;
10749
10750     player->SetContestedPvPTimer(30000);
10751     if(!player->hasUnitState(UNIT_STAT_ATTACK_PLAYER))
10752     {
10753         player->addUnitState(UNIT_STAT_ATTACK_PLAYER);
10754         player->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP);
10755         // call MoveInLineOfSight for nearby contested guards
10756         SetVisibility(GetVisibility());
10757     }
10758     if(!hasUnitState(UNIT_STAT_ATTACK_PLAYER))
10759     {
10760         addUnitState(UNIT_STAT_ATTACK_PLAYER);
10761         // call MoveInLineOfSight for nearby contested guards
10762         SetVisibility(GetVisibility());
10763     }
10764 }
10765
10766 void Unit::AddPetAura(PetAura const* petSpell)
10767 {
10768     m_petAuras.insert(petSpell);
10769     if(Pet* pet = GetPet())
10770         pet->CastPetAura(petSpell);
10771 }
10772
10773 void Unit::RemovePetAura(PetAura const* petSpell)
10774 {
10775     m_petAuras.erase(petSpell);
10776     if(Pet* pet = GetPet())
10777         pet->RemoveAurasDueToSpell(petSpell->GetAura(pet->GetEntry()));
10778 }
10779
10780 Pet* Unit::CreateTamedPetFrom(Creature* creatureTarget,uint32 spell_id)
10781 {
10782     Pet* pet = new Pet(HUNTER_PET);
10783
10784     if(!pet->CreateBaseAtCreature(creatureTarget))
10785     {
10786         delete pet;
10787         return NULL;
10788     }
10789
10790     pet->SetOwnerGUID(GetGUID());
10791     pet->SetCreatorGUID(GetGUID());
10792     pet->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, getFaction());
10793     pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, spell_id);
10794
10795     uint32 level = (creatureTarget->getLevel() < (getLevel() - 5)) ? (getLevel() - 5) : creatureTarget->getLevel();
10796     pet->SetFreeTalentPoints(pet->GetMaxTalentPointsForLevel(level));
10797
10798     if(!pet->InitStatsForLevel(level))
10799     {
10800         sLog.outError("ERROR: Pet::InitStatsForLevel() failed for creature (Entry: %u)!",creatureTarget->GetEntry());
10801         delete pet;
10802         return NULL;
10803     }
10804
10805     pet->GetCharmInfo()->SetPetNumber(objmgr.GeneratePetNumber(), true);
10806     // this enables pet details window (Shift+P)
10807     pet->AIM_Initialize();
10808     pet->InitPetCreateSpells();
10809     pet->SetHealth(pet->GetMaxHealth());
10810
10811     return pet;
10812 }
10813
10814 bool Unit::IsTriggeredAtSpellProcEvent(SpellEntry const* spellProto, SpellEntry const* procSpell, uint32 procFlag, WeaponAttackType attType, bool isVictim, uint32& cooldown )
10815 {
10816     SpellProcEventEntry const * spellProcEvent = spellmgr.GetSpellProcEvent(spellProto->Id);
10817
10818     if(!spellProcEvent)
10819     {
10820         // used to prevent spam in log about same non-handled spells
10821         static std::set<uint32> nonHandledSpellProcSet;
10822
10823         if(spellProto->procFlags != 0 && nonHandledSpellProcSet.find(spellProto->Id)==nonHandledSpellProcSet.end())
10824         {
10825             sLog.outError("ProcDamageAndSpell: spell %u (%s aura source) not have record in `spell_proc_event`)",spellProto->Id,(isVictim?"a victim's":"an attacker's"));
10826             nonHandledSpellProcSet.insert(spellProto->Id);
10827         }
10828
10829         // spell.dbc use totally different flags, that only can create problems if used.
10830         return false;
10831     }
10832
10833     // Check spellProcEvent data requirements
10834     if(!SpellMgr::IsSpellProcEventCanTriggeredBy(spellProcEvent, procSpell,procFlag))
10835         return false;
10836
10837     // Check if current equipment allows aura to proc
10838     if(!isVictim && GetTypeId() == TYPEID_PLAYER )
10839     {
10840         if(spellProto->EquippedItemClass == ITEM_CLASS_WEAPON)
10841         {
10842             Item *item = ((Player*)this)->GetWeaponForAttack(attType,true);
10843
10844             if(!item || !((1<<item->GetProto()->SubClass) & spellProto->EquippedItemSubClassMask))
10845                 return false;
10846         }
10847         else if(spellProto->EquippedItemClass == ITEM_CLASS_ARMOR)
10848         {
10849             // Check if player is wearing shield
10850             Item *item = ((Player*)this)->GetShield(true);
10851             if(!item || !((1<<item->GetProto()->SubClass) & spellProto->EquippedItemSubClassMask))
10852                 return false;
10853         }
10854     }
10855
10856     float chance = (float)spellProto->procChance;
10857
10858     if(Player* modOwner = GetSpellModOwner())
10859         modOwner->ApplySpellMod(spellProto->Id,SPELLMOD_CHANCE_OF_SUCCESS,chance);
10860
10861     if(!isVictim && spellProcEvent && spellProcEvent->ppmRate != 0)
10862     {
10863         uint32 WeaponSpeed = GetAttackTime(attType);
10864         chance = GetPPMProcChance(WeaponSpeed, spellProcEvent->ppmRate);
10865     }
10866
10867     cooldown = spellProcEvent ? spellProcEvent->cooldown : 0;
10868     return roll_chance_f(chance);
10869 }
10870
10871 bool Unit::HandleMeandingAuraProc( Aura* triggeredByAura )
10872 {
10873     // aura can be deleted at casts
10874     SpellEntry const* spellProto = triggeredByAura->GetSpellProto();
10875     uint32 effIdx = triggeredByAura->GetEffIndex();
10876     int32 heal = triggeredByAura->GetModifier()->m_amount;
10877     uint64 caster_guid = triggeredByAura->GetCasterGUID();
10878
10879     // jumps
10880     int32 jumps = triggeredByAura->m_procCharges-1;
10881
10882     // current aura expire
10883     triggeredByAura->m_procCharges = 1;             // will removed at next charges decrease
10884
10885     // next target selection
10886     if(jumps > 0 && GetTypeId()==TYPEID_PLAYER && IS_PLAYER_GUID(caster_guid))
10887     {
10888         float radius;
10889         if (spellProto->EffectRadiusIndex[effIdx])
10890             radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(spellProto->EffectRadiusIndex[effIdx]));
10891         else
10892             radius = GetSpellMaxRange(sSpellRangeStore.LookupEntry(spellProto->rangeIndex));
10893
10894         if(Player* caster = ((Player*)triggeredByAura->GetCaster()))
10895         {
10896             caster->ApplySpellMod(spellProto->Id, SPELLMOD_RADIUS, radius,NULL);
10897
10898             if(Player* target = ((Player*)this)->GetNextRandomRaidMember(radius))
10899             {
10900                 // aura will applied from caster, but spell casted from current aura holder
10901                 SpellModifier *mod = new SpellModifier;
10902                 mod->op = SPELLMOD_CHARGES;
10903                 mod->value = jumps-5;               // negative
10904                 mod->type = SPELLMOD_FLAT;
10905                 mod->spellId = spellProto->Id;
10906                 mod->effectId = effIdx;
10907                 mod->lastAffected = NULL;
10908                 mod->mask = spellProto->SpellFamilyFlags;
10909                 mod->charges = 0;
10910
10911                 caster->AddSpellMod(mod, true);
10912                 CastCustomSpell(target,spellProto->Id,&heal,NULL,NULL,true,NULL,triggeredByAura,caster->GetGUID());
10913                 caster->AddSpellMod(mod, false);
10914             }
10915         }
10916     }
10917
10918     // heal
10919     CastCustomSpell(this,33110,&heal,NULL,NULL,true,NULL,NULL,caster_guid);
10920     return true;
10921 }