src/game/CreatureEventAI.cpp

   1 /*
   2  * Copyright (C) 2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "CreatureEventAI.h"
  21 #include "CreatureEventAIMgr.h"
  22 #include "ObjectMgr.h"
  23 #include "Spell.h"
  24 #include "World.h"
  25 #include "Cell.h"
  26 #include "CellImpl.h"
  27 #include "GameEventMgr.h"
  28 #include "GridNotifiers.h"
  29 #include "GridNotifiersImpl.h"
  30 #include "WorldPacket.h"
  31 #include "InstanceData.h"
  32
  33 namespace MaNGOS
  34 {
  35     class CallOfHelpCreatureInRangeDo                       // do attack at call of help to friendly crearture
  36     {
  37     public:
  38         CallOfHelpCreatureInRangeDo(Unit* funit, Unit* enemy, float range)
  39             : i_funit(funit), i_enemy(enemy), i_range(range)
  40         {}
  41         void operator()(Creature* u)
  42         {
  43             if (u == i_funit)
  44                 return;
  45
  46             if (!u->CanAssistTo(i_funit, i_enemy, false))
  47                 return;
  48
  49             // too far
  50             if( !i_funit->IsWithinDistInMap(u, i_range) )
  51                 return;
  52
  53             // only if see assisted creature
  54             if( !i_funit->IsWithinLOSInMap(u) )
  55                 return;
  56
  57             if(u->AI())
  58                 u->AI()->AttackStart(i_enemy);
  59         }
  60     private:
  61         Unit* const i_funit;
  62         Unit* const i_enemy;
  63         float i_range;
  64     };
  65 }
  66
  67 bool CreatureEventAIHolder::UpdateRepeatTimer( Creature* creature, uint32 repeatMin, uint32 repeatMax )
  68 {
  69     if (repeatMin == repeatMax)
  70         Time = repeatMin;
  71     else if (repeatMax > repeatMin)
  72         Time = urand(repeatMin, repeatMax);
  73     else
  74     {
  75         sLog.outErrorDb("CreatureEventAI: Creature %u using Event %u (Type = %u) has RandomMax < RandomMin. Event repeating disabled.", creature->GetEntry(), Event.event_id, Event.event_type);
  76         Enabled = false;
  77         return false;
  78     }
  79
  80     return true;
  81 }
  82
  83 int CreatureEventAI::Permissible(const Creature *creature)
  84 {
  85     if( creature->GetAIName() == "EventAI" )
  86         return PERMIT_BASE_SPECIAL;
  87     return PERMIT_BASE_NO;
  88 }
  89
  90 CreatureEventAI::CreatureEventAI(Creature *c ) : CreatureAI(c)
  91 {
  92     // Need make copy for filter unneeded steps and safe in case table reload
  93     CreatureEventAI_Event_Map::const_iterator CreatureEvents = CreatureEAI_Mgr.GetCreatureEventAIMap().find(m_creature->GetEntry());
  94     if (CreatureEvents != CreatureEAI_Mgr.GetCreatureEventAIMap().end())
  95     {
  96         std::vector<CreatureEventAI_Event>::const_iterator i;
  97         for (i = (*CreatureEvents).second.begin(); i != (*CreatureEvents).second.end(); ++i)
  98         {
  99
 100             //Debug check
 101             #ifndef MANGOS_DEBUG
 102             if ((*i).event_flags & EFLAG_DEBUG_ONLY)
 103                 continue;
 104             #endif
 105             if (m_creature->GetMap()->IsDungeon())
 106             {
 107                 if( (m_creature->GetMap()->IsHeroic() && (*i).event_flags & EFLAG_HEROIC) ||
 108                     (!m_creature->GetMap()->IsHeroic() && (*i).event_flags & EFLAG_NORMAL))
 109                 {
 110                     //event flagged for instance mode
 111                     CreatureEventAIList.push_back(CreatureEventAIHolder(*i));
 112                 }
 113                 continue;
 114             }
 115             CreatureEventAIList.push_back(CreatureEventAIHolder(*i));
 116         }
 117         //EventMap had events but they were not added because they must be for instance
 118         if (CreatureEventAIList.empty())
 119             sLog.outError("CreatureEventAI: Creature %u has events but no events added to list because of instance flags.", m_creature->GetEntry());
 120     }
 121     else
 122         sLog.outError("CreatureEventAI: EventMap for Creature %u is empty but creature is using CreatureEventAI.", m_creature->GetEntry());
 123
 124     bEmptyList = CreatureEventAIList.empty();
 125     Phase = 0;
 126     CombatMovementEnabled = true;
 127     MeleeEnabled = true;
 128     AttackDistance = 0;
 129     AttackAngle = 0.0f;
 130
 131     //Handle Spawned Events
 132     if (!bEmptyList)
 133     {
 134         for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 135             if (SpawnedEventConditionsCheck((*i).Event))
 136                 ProcessEvent(*i);
 137     }
 138     Reset();
 139 }
 140
 141 bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pActionInvoker)
 142 {
 143     if (!pHolder.Enabled || pHolder.Time)
 144         return false;
 145
 146     //Check the inverse phase mask (event doesn't trigger if current phase bit is set in mask)
 147     if (pHolder.Event.event_inverse_phase_mask & (1 << Phase))
 148         return false;
 149
 150     //Store random here so that all random actions match up
 151     uint32 rnd = rand();
 152
 153     //Return if chance for event is not met
 154     if (pHolder.Event.event_chance <= rnd % 100)
 155         return false;
 156
 157     CreatureEventAI_Event const& event = pHolder.Event;
 158
 159     //Check event conditions based on the event type, also reset events
 160     switch (event.event_type)
 161     {
 162         case EVENT_T_TIMER:
 163             if (!m_creature->isInCombat())
 164                 return false;
 165
 166             //Repeat Timers
 167             pHolder.UpdateRepeatTimer(m_creature,event.timer.repeatMin,event.timer.repeatMax);
 168             break;
 169         case EVENT_T_TIMER_OOC:
 170             if (m_creature->isInCombat())
 171                 return false;
 172
 173             //Repeat Timers
 174             pHolder.UpdateRepeatTimer(m_creature,event.timer.repeatMin,event.timer.repeatMax);
 175             break;
 176         case EVENT_T_HP:
 177         {
 178             if (!m_creature->isInCombat() || !m_creature->GetMaxHealth())
 179                 return false;
 180
 181             uint32 perc = (m_creature->GetHealth()*100) / m_creature->GetMaxHealth();
 182
 183             if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
 184                 return false;
 185
 186             //Repeat Timers
 187             pHolder.UpdateRepeatTimer(m_creature,event.percent_range.repeatMin,event.percent_range.repeatMax);
 188             break;
 189         }
 190         case EVENT_T_MANA:
 191         {
 192             if (!m_creature->isInCombat() || !m_creature->GetMaxPower(POWER_MANA))
 193                 return false;
 194
 195             uint32 perc = (m_creature->GetPower(POWER_MANA)*100) / m_creature->GetMaxPower(POWER_MANA);
 196
 197             if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
 198                 return false;
 199
 200             //Repeat Timers
 201             pHolder.UpdateRepeatTimer(m_creature,event.percent_range.repeatMin,event.percent_range.repeatMax);
 202             break;
 203         }
 204         case EVENT_T_AGGRO:
 205             break;
 206         case EVENT_T_KILL:
 207             //Repeat Timers
 208             pHolder.UpdateRepeatTimer(m_creature,event.kill.repeatMin,event.kill.repeatMax);
 209             break;
 210         case EVENT_T_DEATH:
 211         case EVENT_T_EVADE:
 212             break;
 213         case EVENT_T_SPELLHIT:
 214             //Spell hit is special case, param1 and param2 handled within CreatureEventAI::SpellHit
 215
 216             //Repeat Timers
 217             pHolder.UpdateRepeatTimer(m_creature,event.spell_hit.repeatMin,event.spell_hit.repeatMax);
 218             break;
 219         case EVENT_T_RANGE:
 220             //Repeat Timers
 221             pHolder.UpdateRepeatTimer(m_creature,event.range.repeatMin,event.range.repeatMax);
 222             break;
 223         case EVENT_T_OOC_LOS:
 224             //Repeat Timers
 225             pHolder.UpdateRepeatTimer(m_creature,event.ooc_los.repeatMin,event.ooc_los.repeatMax);
 226             break;
 227         case EVENT_T_SPAWNED:
 228             break;
 229         case EVENT_T_TARGET_HP:
 230         {
 231             if (!m_creature->isInCombat() || !m_creature->getVictim() || !m_creature->getVictim()->GetMaxHealth())
 232                 return false;
 233
 234             uint32 perc = (m_creature->getVictim()->GetHealth()*100) / m_creature->getVictim()->GetMaxHealth();
 235
 236             if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
 237                 return false;
 238
 239             //Repeat Timers
 240             pHolder.UpdateRepeatTimer(m_creature,event.percent_range.repeatMin,event.percent_range.repeatMax);
 241             break;
 242         }
 243         case EVENT_T_TARGET_CASTING:
 244             if (!m_creature->isInCombat() || !m_creature->getVictim() || !m_creature->getVictim()->IsNonMeleeSpellCasted(false, false, true))
 245                 return false;
 246
 247             //Repeat Timers
 248             pHolder.UpdateRepeatTimer(m_creature,event.target_casting.repeatMin,event.target_casting.repeatMax);
 249             break;
 250         case EVENT_T_FRIENDLY_HP:
 251         {
 252             if (!m_creature->isInCombat())
 253                 return false;
 254
 255             Unit* pUnit = DoSelectLowestHpFriendly(event.friendly_hp.radius, event.friendly_hp.hpDeficit);
 256             if (!pUnit)
 257                 return false;
 258
 259             pActionInvoker = pUnit;
 260
 261             //Repeat Timers
 262             pHolder.UpdateRepeatTimer(m_creature,event.friendly_hp.repeatMin,event.friendly_hp.repeatMax);
 263             break;
 264         }
 265         case EVENT_T_FRIENDLY_IS_CC:
 266         {
 267             if (!m_creature->isInCombat())
 268                 return false;
 269
 270             std::list<Creature*> pList;
 271             DoFindFriendlyCC(pList, event.friendly_is_cc.radius);
 272
 273             //List is empty
 274             if (pList.empty())
 275                 return false;
 276
 277             //We don't really care about the whole list, just return first available
 278             pActionInvoker = *(pList.begin());
 279
 280             //Repeat Timers
 281             pHolder.UpdateRepeatTimer(m_creature,event.friendly_is_cc.repeatMin,event.friendly_is_cc.repeatMax);
 282             break;
 283         }
 284         case EVENT_T_FRIENDLY_MISSING_BUFF:
 285         {
 286             std::list<Creature*> pList;
 287             DoFindFriendlyMissingBuff(pList, event.friendly_buff.radius, event.friendly_buff.spellId);
 288
 289             //List is empty
 290             if (pList.empty())
 291                 return false;
 292
 293             //We don't really care about the whole list, just return first available
 294             pActionInvoker = *(pList.begin());
 295
 296             //Repeat Timers
 297             pHolder.UpdateRepeatTimer(m_creature,event.friendly_buff.repeatMin,event.friendly_buff.repeatMax);
 298             break;
 299         }
 300         case EVENT_T_SUMMONED_UNIT:
 301         {
 302             //Prevent event from occuring on no unit or non creatures
 303             if (!pActionInvoker || pActionInvoker->GetTypeId()!=TYPEID_UNIT)
 304                 return false;
 305
 306             //Creature id doesn't match up
 307             if (((Creature*)pActionInvoker)->GetEntry() != event.summon_unit.creatureId)
 308                 return false;
 309
 310             //Repeat Timers
 311             pHolder.UpdateRepeatTimer(m_creature,event.summon_unit.repeatMin,event.summon_unit.repeatMax);
 312         }
 313         break;
 314         case EVENT_T_TARGET_MANA:
 315         {
 316             if (!m_creature->isInCombat() || !m_creature->getVictim() || !m_creature->getVictim()->GetMaxPower(POWER_MANA))
 317                 return false;
 318
 319             uint32 perc = (m_creature->getVictim()->GetPower(POWER_MANA)*100) / m_creature->getVictim()->GetMaxPower(POWER_MANA);
 320
 321             if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
 322                 return false;
 323
 324             //Repeat Timers
 325             pHolder.UpdateRepeatTimer(m_creature,event.percent_range.repeatMin,event.percent_range.repeatMax);
 326             break;
 327         }
 328         case EVENT_T_REACHED_HOME:
 329         case EVENT_T_RECEIVE_EMOTE:
 330             break;
 331         default:
 332             sLog.outErrorDb("CreatureEventAI: Creature %u using Event %u has invalid Event Type(%u), missing from ProcessEvent() Switch.", m_creature->GetEntry(), pHolder.Event.event_id, pHolder.Event.event_type);
 333             break;
 334     }
 335
 336     //Disable non-repeatable events
 337     if (!(pHolder.Event.event_flags & EFLAG_REPEATABLE))
 338         pHolder.Enabled = false;
 339
 340     //Process actions
 341     for (uint32 j = 0; j < MAX_ACTIONS; j++)
 342         ProcessAction(pHolder.Event.action[j], rnd, pHolder.Event.event_id, pActionInvoker);
 343
 344     return true;
 345 }
 346
 347 void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32 rnd, uint32 EventId, Unit* pActionInvoker)
 348 {
 349     switch (action.type)
 350     {
 351         case ACTION_T_TEXT:
 352         {
 353             if (!action.text.TextId1)
 354                 return;
 355
 356             int32 temp = 0;
 357
 358             if (action.text.TextId2 && action.text.TextId3)
 359             {
 360                 switch( rand()%3 )
 361                 {
 362                     case 0: temp = action.text.TextId1; break;
 363                     case 1: temp = action.text.TextId2; break;
 364                     case 2: temp = action.text.TextId3; break;
 365                 }
 366             }
 367             else if (action.text.TextId2 && urand(0,1))
 368                 temp = action.text.TextId2;
 369             else
 370                 temp = action.text.TextId1;
 371
 372             if (temp)
 373             {
 374                 Unit* target = NULL;
 375
 376                 if (pActionInvoker)
 377                 {
 378                     if (pActionInvoker->GetTypeId() == TYPEID_PLAYER)
 379                         target = pActionInvoker;
 380                     else if (Unit* owner = pActionInvoker->GetOwner())
 381                     {
 382                         if (owner->GetTypeId() == TYPEID_PLAYER)
 383                             target = owner;
 384                     }
 385                 }
 386                 else if (target = m_creature->getVictim())
 387                 {
 388                     if (target->GetTypeId() != TYPEID_PLAYER)
 389                         if (Unit* owner = target->GetOwner())
 390                             if (owner->GetTypeId() == TYPEID_PLAYER)
 391                                 target = owner;
 392                 }
 393
 394                 DoScriptText(temp, m_creature, target);
 395             }
 396             break;
 397         }
 398         case ACTION_T_SET_FACTION:
 399         {
 400             if (action.set_faction.factionId)
 401                 m_creature->setFaction(action.set_faction.factionId);
 402             else
 403             {
 404                 if (CreatureInfo const* ci = GetCreatureTemplateStore(m_creature->GetEntry()))
 405                 {
 406                     //if no id provided, assume reset and then use default
 407                     if (m_creature->getFaction() != ci->faction_A)
 408                         m_creature->setFaction(ci->faction_A);
 409                 }
 410             }
 411             break;
 412         }
 413         case ACTION_T_MORPH_TO_ENTRY_OR_MODEL:
 414         {
 415             if (action.morph.creatureId || action.morph.modelId)
 416             {
 417                 //set model based on entry from creature_template
 418                 if (action.morph.creatureId)
 419                 {
 420                     if (CreatureInfo const* ci = GetCreatureTemplateStore(action.morph.creatureId))
 421                     {
 422                         //use default display
 423                         if (ci->DisplayID_A)
 424                             m_creature->SetDisplayId(ci->DisplayID_A);
 425                     }
 426                 }
 427                 //if no param1, then use value from param2 (modelId)
 428                 else
 429                     m_creature->SetDisplayId(action.morph.modelId);
 430             }
 431             else
 432                 m_creature->DeMorph();
 433             break;
 434         }
 435         case ACTION_T_SOUND:
 436             m_creature->PlayDirectSound(action.sound.soundId);
 437             break;
 438         case ACTION_T_EMOTE:
 439             m_creature->HandleEmoteCommand(action.emote.emoteId);
 440             break;
 441         case ACTION_T_RANDOM_SOUND:
 442         {
 443             int32 temp = GetRandActionParam(rnd, action.random_sound.soundId1, action.random_sound.soundId2, action.random_sound.soundId3);
 444             if (temp >= 0)
 445                 m_creature->PlayDirectSound(temp);
 446             break;
 447         }
 448         case ACTION_T_RANDOM_EMOTE:
 449         {
 450             int32 temp = GetRandActionParam(rnd, action.random_emote.emoteId1, action.random_emote.emoteId2, action.random_emote.emoteId3);
 451             if (temp >= 0)
 452                 m_creature->HandleEmoteCommand(temp);
 453             break;
 454         }
 455         case ACTION_T_CAST:
 456         {
 457             Unit* target = GetTargetByType(action.cast.target, pActionInvoker);
 458             Unit* caster = m_creature;
 459
 460             if (!target)
 461                 return;
 462
 463             if (action.cast.castFlags & CAST_FORCE_TARGET_SELF)
 464                 caster = target;
 465
 466             //Allowed to cast only if not casting (unless we interrupt ourself) or if spell is triggered
 467             bool canCast = !caster->IsNonMeleeSpellCasted(false) || (action.cast.castFlags & (CAST_TRIGGERED | CAST_INTURRUPT_PREVIOUS));
 468
 469             // If cast flag CAST_AURA_NOT_PRESENT is active, check if target already has aura on them
 470             if(action.cast.castFlags & CAST_AURA_NOT_PRESENT)
 471             {
 472                 for(uint8 i = 0; i < 3; ++i)
 473                     if(target->HasAura(action.cast.spellId, i))
 474                         return;
 475             }
 476
 477             if (canCast)
 478             {
 479                 const SpellEntry* tSpell = GetSpellStore()->LookupEntry(action.cast.spellId);
 480
 481                 //Verify that spell exists
 482                 if (tSpell)
 483                 {
 484                     //Check if cannot cast spell
 485                     if (!(action.cast.castFlags & (CAST_FORCE_TARGET_SELF | CAST_FORCE_CAST)) &&
 486                         !CanCast(target, tSpell, (action.cast.castFlags & CAST_TRIGGERED)))
 487                     {
 488                         //Melee current victim if flag not set
 489                         if (!(action.cast.castFlags & CAST_NO_MELEE_IF_OOM))
 490                         {
 491                             if (m_creature->GetMotionMaster()->GetCurrentMovementGeneratorType() == TARGETED_MOTION_TYPE)
 492                             {
 493                                 AttackDistance = 0;
 494                                 AttackAngle = 0;
 495
 496                                 m_creature->GetMotionMaster()->Clear(false);
 497                                 m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim(), AttackDistance, AttackAngle);
 498                             }
 499                         }
 500
 501                     }
 502                     else
 503                     {
 504                         //Interrupt any previous spell
 505                         if (caster->IsNonMeleeSpellCasted(false) && action.cast.castFlags & CAST_INTURRUPT_PREVIOUS)
 506                             caster->InterruptNonMeleeSpells(false);
 507
 508                         caster->CastSpell(target, action.cast.spellId, (action.cast.castFlags & CAST_TRIGGERED));
 509                     }
 510
 511                 }
 512                 else
 513                     sLog.outErrorDb("CreatureEventAI: event %d creature %d attempt to cast spell that doesn't exist %d", EventId, m_creature->GetEntry(), action.cast.spellId);
 514             }
 515             break;
 516         }
 517         case ACTION_T_SUMMON:
 518         {
 519             Unit* target = GetTargetByType(action.summon.target, pActionInvoker);
 520
 521             Creature* pCreature = NULL;
 522
 523             if (action.summon.duration)
 524                 pCreature = m_creature->SummonCreature(action.summon.creatureId, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, action.summon.duration);
 525             else
 526                 pCreature = m_creature->SummonCreature(action.summon.creatureId, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 0);
 527
 528             if (!pCreature)
 529                 sLog.outErrorDb( "CreatureEventAI: failed to spawn creature %u. Spawn event %d is on creature %d", action.summon.creatureId, EventId, m_creature->GetEntry());
 530             else if (action.summon.target != TARGET_T_SELF && target)
 531                 pCreature->AI()->AttackStart(target);
 532             break;
 533         }
 534         case ACTION_T_THREAT_SINGLE_PCT:
 535             if (Unit* target = GetTargetByType(action.threat_single_pct.target, pActionInvoker))
 536                 m_creature->getThreatManager().modifyThreatPercent(target, action.threat_single_pct.percent);
 537             break;
 538         case ACTION_T_THREAT_ALL_PCT:
 539         {
 540             std::list<HostilReference*>& threatList = m_creature->getThreatManager().getThreatList();
 541             for (std::list<HostilReference*>::iterator i = threatList.begin(); i != threatList.end(); ++i)
 542                 if(Unit* Temp = Unit::GetUnit(*m_creature,(*i)->getUnitGuid()))
 543                     m_creature->getThreatManager().modifyThreatPercent(Temp, action.threat_all_pct.percent);
 544             break;
 545         }
 546         case ACTION_T_QUEST_EVENT:
 547             if (Unit* target = GetTargetByType(action.quest_event.target, pActionInvoker))
 548                 if (target->GetTypeId() == TYPEID_PLAYER)
 549                     ((Player*)target)->AreaExploredOrEventHappens(action.quest_event.questId);
 550             break;
 551         case ACTION_T_CAST_EVENT:
 552             if (Unit* target = GetTargetByType(action.cast_event.target, pActionInvoker))
 553                 if (target->GetTypeId() == TYPEID_PLAYER)
 554                     ((Player*)target)->CastedCreatureOrGO(action.cast_event.creatureId, m_creature->GetGUID(), action.cast_event.spellId);
 555             break;
 556         case ACTION_T_SET_UNIT_FIELD:
 557         {
 558             Unit* target = GetTargetByType(action.set_unit_field.target, pActionInvoker);
 559
 560             // not allow modify important for integrity object fields
 561             if (action.set_unit_field.field < OBJECT_END || action.set_unit_field.field >= UNIT_END)
 562                 return;
 563
 564             if (target)
 565                 target->SetUInt32Value(action.set_unit_field.field, action.set_unit_field.value);
 566
 567             break;
 568         }
 569         case ACTION_T_SET_UNIT_FLAG:
 570             if (Unit* target = GetTargetByType(action.unit_flag.target, pActionInvoker))
 571                 target->SetFlag(UNIT_FIELD_FLAGS, action.unit_flag.value);
 572             break;
 573         case ACTION_T_REMOVE_UNIT_FLAG:
 574             if (Unit* target = GetTargetByType(action.unit_flag.target, pActionInvoker))
 575                 target->RemoveFlag(UNIT_FIELD_FLAGS, action.unit_flag.value);
 576             break;
 577         case ACTION_T_AUTO_ATTACK:
 578             MeleeEnabled = action.auto_attack.state != 0;
 579             break;
 580         case ACTION_T_COMBAT_MOVEMENT:
 581             CombatMovementEnabled = action.combat_movement.state != 0;
 582
 583             //Allow movement (create new targeted movement gen only if idle)
 584             if (CombatMovementEnabled)
 585             {
 586                 if (m_creature->GetMotionMaster()->GetCurrentMovementGeneratorType() == IDLE_MOTION_TYPE)
 587                 {
 588                     m_creature->GetMotionMaster()->Clear(false);
 589                     m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim(), AttackDistance, AttackAngle);
 590                 }
 591             }
 592             else
 593             if (m_creature->GetMotionMaster()->GetCurrentMovementGeneratorType() == TARGETED_MOTION_TYPE)
 594             {
 595                 m_creature->GetMotionMaster()->Clear(false);
 596                 m_creature->GetMotionMaster()->MoveIdle();
 597                 m_creature->StopMoving();
 598             }
 599             break;
 600         case ACTION_T_SET_PHASE:
 601             Phase = action.set_phase.phase;
 602             break;
 603         case ACTION_T_INC_PHASE:
 604         {
 605             int32 new_phase = int32(Phase)+action.set_inc_phase.step;
 606             if (new_phase < 0)
 607             {
 608                 sLog.outErrorDb( "CreatureEventAI: Event %d decrease Phase under 0. CreatureEntry = %d", EventId, m_creature->GetEntry());
 609                 Phase = 0;
 610             }
 611             else if (new_phase >= MAX_PHASE)
 612             {
 613                 sLog.outErrorDb( "CreatureEventAI: Event %d incremented Phase above %u. Phase mask cannot be used with phases past %u. CreatureEntry = %d", EventId, MAX_PHASE-1, MAX_PHASE-1, m_creature->GetEntry());
 614                 Phase = MAX_PHASE-1;
 615             }
 616             else
 617                 Phase = new_phase;
 618
 619             break;
 620         }
 621         case ACTION_T_EVADE:
 622             EnterEvadeMode();
 623             break;
 624         case ACTION_T_FLEE_FOR_ASSIST:
 625             m_creature->DoFleeToGetAssistance();
 626             break;
 627         case ACTION_T_QUEST_EVENT_ALL:
 628             if (pActionInvoker && pActionInvoker->GetTypeId() == TYPEID_PLAYER)
 629             {
 630                 if (Unit* Temp = Unit::GetUnit(*m_creature,pActionInvoker->GetGUID()))
 631                     if (Temp->GetTypeId() == TYPEID_PLAYER)
 632                         ((Player*)Temp)->GroupEventHappens(action.quest_event_all.questId,m_creature);
 633             }
 634             break;
 635         case ACTION_T_CAST_EVENT_ALL:
 636         {
 637             std::list<HostilReference*>& threatList = m_creature->getThreatManager().getThreatList();
 638             for (std::list<HostilReference*>::iterator i = threatList.begin(); i != threatList.end(); ++i)
 639                 if (Unit* Temp = Unit::GetUnit(*m_creature,(*i)->getUnitGuid()))
 640                     if (Temp->GetTypeId() == TYPEID_PLAYER)
 641                         ((Player*)Temp)->CastedCreatureOrGO(action.cast_event_all.creatureId, m_creature->GetGUID(), action.cast_event_all.spellId);
 642             break;
 643         }
 644         case ACTION_T_REMOVEAURASFROMSPELL:
 645             if (Unit* target = GetTargetByType(action.remove_aura.target, pActionInvoker))
 646                 target->RemoveAurasDueToSpell(action.remove_aura.spellId);
 647             break;
 648         case ACTION_T_RANGED_MOVEMENT:
 649             AttackDistance = action.ranged_movement.distance;
 650             AttackAngle = ((float)action.ranged_movement.angle/180)*M_PI;
 651
 652             if (CombatMovementEnabled)
 653             {
 654                 if (m_creature->GetMotionMaster()->GetCurrentMovementGeneratorType() == TARGETED_MOTION_TYPE)
 655                 {
 656                     //Drop current movement gen
 657                     m_creature->GetMotionMaster()->Clear(false);
 658                     m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim(), AttackDistance, AttackAngle);
 659                 }
 660             }
 661             break;
 662         case ACTION_T_RANDOM_PHASE:
 663             Phase = GetRandActionParam(rnd, action.random_phase.phase1, action.random_phase.phase2, action.random_phase.phase3);
 664             break;
 665         case ACTION_T_RANDOM_PHASE_RANGE:
 666             if (action.random_phase_range.phaseMax > action.random_phase_range.phaseMin)
 667                 Phase = action.random_phase_range.phaseMin + (rnd % (action.random_phase_range.phaseMax - action.random_phase_range.phaseMin));
 668             else
 669                 sLog.outErrorDb( "CreatureEventAI: ACTION_T_RANDOM_PHASE_RANGE cannot have Param2 <= Param1. Divide by Zero. Event = %d. CreatureEntry = %d", EventId, m_creature->GetEntry());
 670             break;
 671         case ACTION_T_SUMMON_ID:
 672         {
 673             Unit* target = GetTargetByType(action.summon_id.target, pActionInvoker);
 674
 675             CreatureEventAI_Summon_Map::const_iterator i = CreatureEAI_Mgr.GetCreatureEventAISummonMap().find(action.summon_id.spawnId);
 676             if (i == CreatureEAI_Mgr.GetCreatureEventAISummonMap().end())
 677             {
 678                 sLog.outErrorDb( "CreatureEventAI: failed to spawn creature %u. Summon map index %u does not exist. EventID %d. CreatureID %d", action.summon_id.creatureId, action.summon_id.spawnId, EventId, m_creature->GetEntry());
 679                 return;
 680             }
 681
 682             Creature* pCreature = NULL;
 683             if ((*i).second.SpawnTimeSecs)
 684                 pCreature = m_creature->SummonCreature(action.summon_id.creatureId, (*i).second.position_x, (*i).second.position_y, (*i).second.position_z, (*i).second.orientation, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, (*i).second.SpawnTimeSecs);
 685             else
 686                 pCreature = m_creature->SummonCreature(action.summon_id.creatureId, (*i).second.position_x, (*i).second.position_y, (*i).second.position_z, (*i).second.orientation, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 0);
 687
 688             if (!pCreature)
 689                 sLog.outErrorDb( "CreatureEventAI: failed to spawn creature %u. EventId %d.Creature %d", action.summon_id.creatureId, EventId, m_creature->GetEntry());
 690             else if (action.summon_id.target != TARGET_T_SELF && target)
 691                 pCreature->AI()->AttackStart(target);
 692
 693             break;
 694         }
 695         case ACTION_T_KILLED_MONSTER:
 696             //first attempt player who tapped creature
 697             if (Player* pPlayer = m_creature->GetLootRecipient())
 698                 pPlayer->RewardPlayerAndGroupAtEvent(action.killed_monster.creatureId, m_creature);
 699             else
 700             {
 701                 //if not available, use pActionInvoker
 702                 if (Unit* pTarget = GetTargetByType(action.killed_monster.target, pActionInvoker))
 703                     if (Player* pPlayer2 = pTarget->GetCharmerOrOwnerPlayerOrPlayerItself())
 704                         pPlayer2->RewardPlayerAndGroupAtEvent(action.killed_monster.creatureId, m_creature);
 705             }
 706             break;
 707         case ACTION_T_SET_INST_DATA:
 708         {
 709             InstanceData* pInst = (InstanceData*)m_creature->GetInstanceData();
 710             if (!pInst)
 711             {
 712                 sLog.outErrorDb("CreatureEventAI: Event %d attempt to set instance data without instance script. Creature %d", EventId, m_creature->GetEntry());
 713                 return;
 714             }
 715
 716             pInst->SetData(action.set_inst_data.field, action.set_inst_data.value);
 717             break;
 718         }
 719         case ACTION_T_SET_INST_DATA64:
 720         {
 721             Unit* target = GetTargetByType(action.set_inst_data64.target, pActionInvoker);
 722             if (!target)
 723             {
 724                 sLog.outErrorDb("CreatureEventAI: Event %d attempt to set instance data64 but Target == NULL. Creature %d", EventId, m_creature->GetEntry());
 725                 return;
 726             }
 727
 728             InstanceData* pInst = (InstanceData*)m_creature->GetInstanceData();
 729             if (!pInst)
 730             {
 731                 sLog.outErrorDb("CreatureEventAI: Event %d attempt to set instance data64 without instance script. Creature %d", EventId, m_creature->GetEntry());
 732                 return;
 733             }
 734
 735             pInst->SetData64(action.set_inst_data64.field, target->GetGUID());
 736             break;
 737         }
 738         case ACTION_T_UPDATE_TEMPLATE:
 739             if (m_creature->GetEntry() == action.update_template.creatureId)
 740             {
 741
 742                 sLog.outErrorDb("CreatureEventAI: Event %d ACTION_T_UPDATE_TEMPLATE call with param1 == current entry. Creature %d", EventId, m_creature->GetEntry());
 743                 return;
 744             }
 745
 746             m_creature->UpdateEntry(action.update_template.creatureId, action.update_template.team ? HORDE : ALLIANCE);
 747             break;
 748         case ACTION_T_DIE:
 749             if (m_creature->isDead())
 750             {
 751
 752                 sLog.outErrorDb("CreatureEventAI: Event %d ACTION_T_DIE on dead creature. Creature %d", EventId, m_creature->GetEntry());
 753                 return;
 754             }
 755             m_creature->DealDamage(m_creature, m_creature->GetMaxHealth(),NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
 756             break;
 757         case ACTION_T_ZONE_COMBAT_PULSE:
 758             if (!m_creature->isInCombat() || !m_creature->GetMap()->IsDungeon())
 759             {
 760
 761                 sLog.outErrorDb("CreatureEventAI: Event %d ACTION_T_ZONE_COMBAT_PULSE on creature out of combat or in non-dungeon map. Creature %d", EventId, m_creature->GetEntry());
 762                 return;
 763             }
 764
 765             DoZoneInCombat(m_creature);
 766             break;
 767         case ACTION_T_CALL_FOR_HELP:
 768         {
 769             if (!m_creature->getVictim())
 770                 return;
 771
 772             CellPair p(MaNGOS::ComputeCellPair(m_creature->GetPositionX(), m_creature->GetPositionY()));
 773             Cell cell(p);
 774             cell.data.Part.reserved = ALL_DISTRICT;
 775             cell.SetNoCreate();
 776
 777             MaNGOS::CallOfHelpCreatureInRangeDo u_do(m_creature, m_creature->getVictim(), action.call_for_help.radius);
 778             MaNGOS::CreatureWorker<MaNGOS::CallOfHelpCreatureInRangeDo> worker(m_creature, u_do);
 779
 780             TypeContainerVisitor<MaNGOS::CreatureWorker<MaNGOS::CallOfHelpCreatureInRangeDo>, GridTypeMapContainer >  grid_creature_searcher(worker);
 781
 782             CellLock<GridReadGuard> cell_lock(cell, p);
 783             cell_lock->Visit(cell_lock, grid_creature_searcher, *m_creature->GetMap());
 784             break;
 785         }
 786         case ACTION_T_SET_SHEATH:
 787         {
 788             m_creature->SetSheath(SheathState(action.set_sheath.sheath));
 789             break;
 790         }
 791     }
 792 }
 793
 794 void CreatureEventAI::JustRespawned()
 795 {
 796     Reset();
 797
 798     if (bEmptyList)
 799         return;
 800
 801     //Handle Spawned Events
 802     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 803         if (SpawnedEventConditionsCheck((*i).Event))
 804             ProcessEvent(*i);
 805 }
 806
 807 void CreatureEventAI::Reset()
 808 {
 809     EventUpdateTime = EVENT_UPDATE_TIME;
 810     EventDiff = 0;
 811
 812     if (bEmptyList)
 813         return;
 814
 815     //Reset all events to enabled
 816     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 817     {
 818         CreatureEventAI_Event const& event = (*i).Event;
 819         switch (event.event_type)
 820         {
 821             //Reset all out of combat timers
 822             case EVENT_T_TIMER_OOC:
 823             {
 824                 if ((*i).UpdateRepeatTimer(m_creature,event.timer.initialMin,event.timer.initialMax))
 825                     (*i).Enabled = true;
 826                 break;
 827             }
 828             //default:
 829             //TODO: enable below code line / verify this is correct to enable events previously disabled (ex. aggro yell), instead of enable this in void Aggro()
 830             //(*i).Enabled = true;
 831             //(*i).Time = 0;
 832             //break;
 833         }
 834     }
 835 }
 836
 837 void CreatureEventAI::JustReachedHome()
 838 {
 839     m_creature->LoadCreaturesAddon();
 840
 841     if (!bEmptyList)
 842     {
 843         for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 844         {
 845             if ((*i).Event.event_type == EVENT_T_REACHED_HOME)
 846                 ProcessEvent(*i);
 847         }
 848     }
 849
 850     Reset();
 851 }
 852
 853 void CreatureEventAI::EnterEvadeMode()
 854 {
 855     m_creature->RemoveAllAuras();
 856     m_creature->DeleteThreatList();
 857     m_creature->CombatStop(true);
 858
 859     if (m_creature->isAlive())
 860         m_creature->GetMotionMaster()->MoveTargetedHome();
 861
 862     m_creature->SetLootRecipient(NULL);
 863
 864     if (bEmptyList)
 865         return;
 866
 867     //Handle Evade events
 868     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 869     {
 870         if ((*i).Event.event_type == EVENT_T_EVADE)
 871             ProcessEvent(*i);
 872     }
 873 }
 874
 875 void CreatureEventAI::JustDied(Unit* killer)
 876 {
 877     Reset();
 878
 879     if (bEmptyList)
 880         return;
 881
 882     //Handle Evade events
 883     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 884     {
 885         if ((*i).Event.event_type == EVENT_T_DEATH)
 886             ProcessEvent(*i, killer);
 887     }
 888 }
 889
 890 void CreatureEventAI::KilledUnit(Unit* victim)
 891 {
 892     if (bEmptyList || victim->GetTypeId() != TYPEID_PLAYER)
 893         return;
 894
 895     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 896     {
 897         if ((*i).Event.event_type == EVENT_T_KILL)
 898             ProcessEvent(*i, victim);
 899     }
 900 }
 901
 902 void CreatureEventAI::JustSummoned(Creature* pUnit)
 903 {
 904     if (bEmptyList || !pUnit)
 905         return;
 906
 907     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 908     {
 909         if ((*i).Event.event_type == EVENT_T_SUMMONED_UNIT)
 910             ProcessEvent(*i, pUnit);
 911     }
 912 }
 913
 914 void CreatureEventAI::EnterCombat(Unit *enemy)
 915 {
 916     //Check for on combat start events
 917     if (!bEmptyList)
 918     {
 919         for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
 920         {
 921             CreatureEventAI_Event const& event = (*i).Event;
 922             switch (event.event_type)
 923             {
 924                 case EVENT_T_AGGRO:
 925                     (*i).Enabled = true;
 926                     ProcessEvent(*i, enemy);
 927                     break;
 928                     //Reset all in combat timers
 929                 case EVENT_T_TIMER:
 930                     if ((*i).UpdateRepeatTimer(m_creature,event.timer.initialMin,event.timer.initialMax))
 931                         (*i).Enabled = true;
 932                     break;
 933                     //All normal events need to be re-enabled and their time set to 0
 934                 default:
 935                     (*i).Enabled = true;
 936                     (*i).Time = 0;
 937                     break;
 938             }
 939         }
 940     }
 941
 942     EventUpdateTime = EVENT_UPDATE_TIME;
 943     EventDiff = 0;
 944 }
 945
 946 void CreatureEventAI::AttackStart(Unit *who)
 947 {
 948     if (!who)
 949         return;
 950
 951     if (m_creature->Attack(who, MeleeEnabled))
 952     {
 953         m_creature->AddThreat(who, 0.0f);
 954         m_creature->SetInCombatWith(who);
 955         who->SetInCombatWith(m_creature);
 956
 957         if (CombatMovementEnabled)
 958         {
 959             m_creature->GetMotionMaster()->MoveChase(who, AttackDistance, AttackAngle);
 960         }
 961         else
 962         {
 963             m_creature->GetMotionMaster()->MoveIdle();
 964             m_creature->StopMoving();
 965         }
 966     }
 967 }
 968
 969 void CreatureEventAI::MoveInLineOfSight(Unit *who)
 970 {
 971     if (!who)
 972         return;
 973
 974     //Check for OOC LOS Event
 975     if (!bEmptyList && !m_creature->getVictim())
 976     {
 977         for (std::list<CreatureEventAIHolder>::iterator itr = CreatureEventAIList.begin(); itr != CreatureEventAIList.end(); ++itr)
 978         {
 979             if ((*itr).Event.event_type == EVENT_T_OOC_LOS)
 980             {
 981                 //can trigger if closer than fMaxAllowedRange
 982                 float fMaxAllowedRange = (*itr).Event.ooc_los.maxRange;
 983
 984                 //if range is ok and we are actually in LOS
 985                 if (m_creature->IsWithinDistInMap(who, fMaxAllowedRange) && m_creature->IsWithinLOSInMap(who))
 986                 {
 987                     //if friendly event&&who is not hostile OR hostile event&&who is hostile
 988                     if (((*itr).Event.ooc_los.noHostile && !m_creature->IsHostileTo(who)) ||
 989                         ((!(*itr).Event.ooc_los.noHostile) && m_creature->IsHostileTo(who)))
 990                         ProcessEvent(*itr, who);
 991                 }
 992             }
 993         }
 994     }
 995
 996     if (m_creature->isCivilian() || m_creature->IsNeutralToAll())
 997         return;
 998
 999     if (!m_creature->hasUnitState(UNIT_STAT_STUNNED) && who->isTargetableForAttack() &&
1000         m_creature->IsHostileTo(who) && who->isInAccessablePlaceFor(m_creature))
1001     {
1002         if (!m_creature->canFly() && m_creature->GetDistanceZ(who) > CREATURE_Z_ATTACK_RANGE)
1003             return;
1004
1005         float attackRadius = m_creature->GetAttackDistance(who);
1006         if (m_creature->IsWithinDistInMap(who, attackRadius) && m_creature->IsWithinLOSInMap(who))
1007         {
1008             if (!m_creature->getVictim())
1009             {
1010                 AttackStart(who);
1011                 who->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
1012             }
1013             else if (m_creature->GetMap()->IsDungeon())
1014             {
1015                 m_creature->AddThreat(who, 0.0f);
1016                 who->SetInCombatWith(m_creature);
1017             }
1018         }
1019     }
1020 }
1021
1022 void CreatureEventAI::SpellHit(Unit* pUnit, const SpellEntry* pSpell)
1023 {
1024
1025     if (bEmptyList)
1026         return;
1027
1028     for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
1029         if ((*i).Event.event_type == EVENT_T_SPELLHIT)
1030             //If spell id matches (or no spell id) & if spell school matches (or no spell school)
1031             if (!(*i).Event.spell_hit.spellId || pSpell->Id == (*i).Event.spell_hit.spellId)
1032                 if (pSpell->SchoolMask & (*i).Event.spell_hit.schoolMask)
1033                     ProcessEvent(*i, pUnit);
1034 }
1035
1036 void CreatureEventAI::UpdateAI(const uint32 diff)
1037 {
1038     //Check if we are in combat (also updates calls threat update code)
1039     bool Combat = m_creature->SelectHostilTarget() && m_creature->getVictim();
1040
1041     //Must return if creature isn't alive. Normally select hostil target and get victim prevent this
1042     if (!m_creature->isAlive())
1043         return;
1044
1045     if (!bEmptyList)
1046     {
1047         //Events are only updated once every EVENT_UPDATE_TIME ms to prevent lag with large amount of events
1048         if (EventUpdateTime < diff)
1049         {
1050             EventDiff += diff;
1051
1052             //Check for time based events
1053             for (std::list<CreatureEventAIHolder>::iterator i = CreatureEventAIList.begin(); i != CreatureEventAIList.end(); ++i)
1054             {
1055                 //Decrement Timers
1056                 if ((*i).Time)
1057                 {
1058                     if ((*i).Time > EventDiff)
1059                     {
1060                         //Do not decrement timers if event cannot trigger in this phase
1061                         if (!((*i).Event.event_inverse_phase_mask & (1 << Phase)))
1062                             (*i).Time -= EventDiff;
1063
1064                         //Skip processing of events that have time remaining
1065                         continue;
1066                     }
1067                     else (*i).Time = 0;
1068                 }
1069
1070                 //Events that are updated every EVENT_UPDATE_TIME
1071                 switch ((*i).Event.event_type)
1072                 {
1073                     case EVENT_T_TIMER_OOC:
1074                         ProcessEvent(*i);
1075                         break;
1076                     case EVENT_T_TIMER:
1077                     case EVENT_T_MANA:
1078                     case EVENT_T_HP:
1079                     case EVENT_T_TARGET_HP:
1080                     case EVENT_T_TARGET_CASTING:
1081                     case EVENT_T_FRIENDLY_HP:
1082                         if (Combat)
1083                             ProcessEvent(*i);
1084                         break;
1085                     case EVENT_T_RANGE:
1086                         if (Combat)
1087                             if (m_creature->IsInMap(m_creature->getVictim()))
1088                                 if (m_creature->IsInRange(m_creature->getVictim(),(float)(*i).Event.range.minDist,(float)(*i).Event.range.maxDist))
1089                                     ProcessEvent(*i);
1090                         break;
1091                 }
1092             }
1093
1094             EventDiff = 0;
1095             EventUpdateTime = EVENT_UPDATE_TIME;
1096         }
1097         else
1098         {
1099             EventDiff += diff;
1100             EventUpdateTime -= diff;
1101         }
1102     }
1103
1104     //Melee Auto-Attack
1105     if (Combat && MeleeEnabled)
1106         DoMeleeAttackIfReady();
1107 }
1108
1109 bool CreatureEventAI::IsVisible(Unit *pl) const
1110 {
1111     return m_creature->IsWithinDist(pl,sWorld.getConfig(CONFIG_SIGHT_MONSTER))
1112         && pl->isVisibleForOrDetect(m_creature,true);
1113 }
1114
1115 inline Unit* CreatureEventAI::SelectUnit(AttackingTarget target, uint32 position)
1116 {
1117     //ThreatList m_threatlist;
1118     std::list<HostilReference*>& m_threatlist = m_creature->getThreatManager().getThreatList();
1119     std::list<HostilReference*>::iterator i = m_threatlist.begin();
1120     std::list<HostilReference*>::reverse_iterator r = m_threatlist.rbegin();
1121
1122     if (position >= m_threatlist.size() || !m_threatlist.size())
1123         return NULL;
1124
1125     switch (target)
1126     {
1127         case ATTACKING_TARGET_RANDOM:
1128         {
1129             advance ( i , position +  (rand() % (m_threatlist.size() - position ) ));
1130             return Unit::GetUnit(*m_creature,(*i)->getUnitGuid());
1131         }
1132         case ATTACKING_TARGET_TOPAGGRO:
1133         {
1134             advance ( i , position);
1135             return Unit::GetUnit(*m_creature,(*i)->getUnitGuid());
1136         }
1137         case ATTACKING_TARGET_BOTTOMAGGRO:
1138         {
1139             advance ( r , position);
1140             return Unit::GetUnit(*m_creature,(*r)->getUnitGuid());
1141         }
1142     }
1143     return NULL;
1144 }
1145
1146 inline uint32 CreatureEventAI::GetRandActionParam(uint32 rnd, uint32 param1, uint32 param2, uint32 param3)
1147 {
1148     switch (rnd % 3)
1149     {
1150         case 0: return param1;
1151         case 1: return param2;
1152         case 2: return param3;
1153     }
1154     return 0;
1155 }
1156
1157 inline int32 CreatureEventAI::GetRandActionParam(uint32 rnd, int32 param1, int32 param2, int32 param3)
1158 {
1159     switch (rnd % 3)
1160     {
1161         case 0: return param1;
1162         case 1: return param2;
1163         case 2: return param3;
1164     }
1165     return 0;
1166 }
1167
1168 inline Unit* CreatureEventAI::GetTargetByType(uint32 Target, Unit* pActionInvoker)
1169 {
1170     switch (Target)
1171     {
1172         case TARGET_T_SELF:
1173             return m_creature;
1174         case TARGET_T_HOSTILE:
1175             return m_creature->getVictim();
1176         case TARGET_T_HOSTILE_SECOND_AGGRO:
1177             return SelectUnit(ATTACKING_TARGET_TOPAGGRO,1);
1178         case TARGET_T_HOSTILE_LAST_AGGRO:
1179             return SelectUnit(ATTACKING_TARGET_BOTTOMAGGRO,0);
1180         case TARGET_T_HOSTILE_RANDOM:
1181             return SelectUnit(ATTACKING_TARGET_RANDOM,0);
1182         case TARGET_T_HOSTILE_RANDOM_NOT_TOP:
1183             return SelectUnit(ATTACKING_TARGET_RANDOM,1);
1184         case TARGET_T_ACTION_INVOKER:
1185             return pActionInvoker;
1186         default:
1187             return NULL;
1188     };
1189 }
1190
1191 Unit* CreatureEventAI::DoSelectLowestHpFriendly(float range, uint32 MinHPDiff)
1192 {
1193     CellPair p(MaNGOS::ComputeCellPair(m_creature->GetPositionX(), m_creature->GetPositionY()));
1194     Cell cell(p);
1195     cell.data.Part.reserved = ALL_DISTRICT;
1196     cell.SetNoCreate();
1197
1198     Unit* pUnit = NULL;
1199
1200     MaNGOS::MostHPMissingInRange u_check(m_creature, range, MinHPDiff);
1201     MaNGOS::UnitLastSearcher<MaNGOS::MostHPMissingInRange> searcher(m_creature, pUnit, u_check);
1202
1203     /*
1204     typedef TYPELIST_4(GameObject, Creature*except pets*, DynamicObject, Corpse*Bones*) AllGridObjectTypes;
1205     This means that if we only search grid then we cannot possibly return pets or players so this is safe
1206     */
1207     TypeContainerVisitor<MaNGOS::UnitLastSearcher<MaNGOS::MostHPMissingInRange>, GridTypeMapContainer >  grid_unit_searcher(searcher);
1208
1209     CellLock<GridReadGuard> cell_lock(cell, p);
1210     cell_lock->Visit(cell_lock, grid_unit_searcher, *m_creature->GetMap());
1211     return pUnit;
1212 }
1213
1214 void CreatureEventAI::DoFindFriendlyCC(std::list<Creature*>& _list, float range)
1215 {
1216     CellPair p(MaNGOS::ComputeCellPair(m_creature->GetPositionX(), m_creature->GetPositionY()));
1217     Cell cell(p);
1218     cell.data.Part.reserved = ALL_DISTRICT;
1219     cell.SetNoCreate();
1220
1221     MaNGOS::FriendlyCCedInRange u_check(m_creature, range);
1222     MaNGOS::CreatureListSearcher<MaNGOS::FriendlyCCedInRange> searcher(m_creature, _list, u_check);
1223
1224     TypeContainerVisitor<MaNGOS::CreatureListSearcher<MaNGOS::FriendlyCCedInRange>, GridTypeMapContainer >  grid_creature_searcher(searcher);
1225
1226     CellLock<GridReadGuard> cell_lock(cell, p);
1227     cell_lock->Visit(cell_lock, grid_creature_searcher, *m_creature->GetMap());
1228 }
1229
1230 void CreatureEventAI::DoFindFriendlyMissingBuff(std::list<Creature*>& _list, float range, uint32 spellid)
1231 {
1232     CellPair p(MaNGOS::ComputeCellPair(m_creature->GetPositionX(), m_creature->GetPositionY()));
1233     Cell cell(p);
1234     cell.data.Part.reserved = ALL_DISTRICT;
1235     cell.SetNoCreate();
1236
1237     MaNGOS::FriendlyMissingBuffInRange u_check(m_creature, range, spellid);
1238     MaNGOS::CreatureListSearcher<MaNGOS::FriendlyMissingBuffInRange> searcher(m_creature, _list, u_check);
1239
1240     TypeContainerVisitor<MaNGOS::CreatureListSearcher<MaNGOS::FriendlyMissingBuffInRange>, GridTypeMapContainer >  grid_creature_searcher(searcher);
1241
1242     CellLock<GridReadGuard> cell_lock(cell, p);
1243     cell_lock->Visit(cell_lock, grid_creature_searcher, *m_creature->GetMap());
1244 }
1245
1246 //*********************************
1247 //*** Functions used globally ***
1248
1249 void CreatureEventAI::DoScriptText(int32 textEntry, WorldObject* pSource, Unit* target)
1250 {
1251     if (!pSource)
1252     {
1253         sLog.outErrorDb("CreatureEventAI: DoScriptText entry %i, invalid Source pointer.",textEntry);
1254         return;
1255     }
1256
1257     if (textEntry >= 0)
1258     {
1259         sLog.outErrorDb("CreatureEventAI: DoScriptText with source entry %u (TypeId=%u, guid=%u) attempts to process text entry %i, but text entry must be negative.",pSource->GetEntry(),pSource->GetTypeId(),pSource->GetGUIDLow(),textEntry);
1260         return;
1261     }
1262
1263     CreatureEventAI_TextMap::const_iterator i = CreatureEAI_Mgr.GetCreatureEventAITextMap().find(textEntry);
1264
1265     if (i == CreatureEAI_Mgr.GetCreatureEventAITextMap().end())
1266     {
1267         sLog.outErrorDb("CreatureEventAI: DoScriptText with source entry %u (TypeId=%u, guid=%u) could not find text entry %i.",pSource->GetEntry(),pSource->GetTypeId(),pSource->GetGUIDLow(),textEntry);
1268         return;
1269     }
1270
1271     sLog.outDebug("CreatureEventAI: DoScriptText: text entry=%i, Sound=%u, Type=%u, Language=%u, Emote=%u",textEntry,(*i).second.SoundId,(*i).second.Type,(*i).second.Language,(*i).second.Emote);
1272
1273     if((*i).second.SoundId)
1274     {
1275         if (GetSoundEntriesStore()->LookupEntry((*i).second.SoundId))
1276             pSource->PlayDirectSound((*i).second.SoundId);
1277         else
1278             sLog.outErrorDb("CreatureEventAI: DoScriptText entry %i tried to process invalid sound id %u.",textEntry,(*i).second.SoundId);
1279     }
1280
1281     if((*i).second.Emote)
1282     {
1283         if (pSource->GetTypeId() == TYPEID_UNIT || pSource->GetTypeId() == TYPEID_PLAYER)
1284         {
1285             ((Unit*)pSource)->HandleEmoteCommand((*i).second.Emote);
1286         }
1287         else
1288             sLog.outErrorDb("CreatureEventAI: DoScriptText entry %i tried to process emote for invalid TypeId (%u).",textEntry,pSource->GetTypeId());
1289     }
1290
1291     switch((*i).second.Type)
1292     {
1293         case CHAT_TYPE_SAY:
1294             pSource->MonsterSay(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
1295             break;
1296         case CHAT_TYPE_YELL:
1297             pSource->MonsterYell(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
1298             break;
1299         case CHAT_TYPE_TEXT_EMOTE:
1300             pSource->MonsterTextEmote(textEntry, target ? target->GetGUID() : 0);
1301             break;
1302         case CHAT_TYPE_BOSS_EMOTE:
1303             pSource->MonsterTextEmote(textEntry, target ? target->GetGUID() : 0, true);
1304             break;
1305         case CHAT_TYPE_WHISPER:
1306         {
1307             if (target && target->GetTypeId() == TYPEID_PLAYER)
1308                 pSource->MonsterWhisper(textEntry, target->GetGUID());
1309             else sLog.outErrorDb("CreatureEventAI: DoScriptText entry %i cannot whisper without target unit (TYPEID_PLAYER).", textEntry);
1310         }break;
1311         case CHAT_TYPE_BOSS_WHISPER:
1312         {
1313             if (target && target->GetTypeId() == TYPEID_PLAYER)
1314                 pSource->MonsterWhisper(textEntry, target->GetGUID(), true);
1315             else sLog.outErrorDb("CreatureEventAI: DoScriptText entry %i cannot whisper without target unit (TYPEID_PLAYER).", textEntry);
1316         }break;
1317         case CHAT_TYPE_ZONE_YELL:
1318             pSource->MonsterYellToZone(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
1319             break;
1320     }
1321 }
1322
1323 void CreatureEventAI::DoZoneInCombat(Unit* pUnit)
1324 {
1325     if (!pUnit)
1326         pUnit = m_creature;
1327
1328     Map *map = pUnit->GetMap();
1329
1330     if (!map->IsDungeon())                                  //use IsDungeon instead of Instanceable, in case battlegrounds will be instantiated
1331     {
1332         sLog.outErrorDb("CreatureEventAI: DoZoneInCombat call for map that isn't an instance (pUnit entry = %d)", pUnit->GetTypeId() == TYPEID_UNIT ? ((Creature*)pUnit)->GetEntry() : 0);
1333         return;
1334     }
1335
1336     if (!pUnit->CanHaveThreatList() || pUnit->getThreatManager().isThreatListEmpty())
1337     {
1338         sLog.outErrorDb("CreatureEventAI: DoZoneInCombat called for creature that either cannot have threat list or has empty threat list (pUnit entry = %d)", pUnit->GetTypeId() == TYPEID_UNIT ? ((Creature*)pUnit)->GetEntry() : 0);
1339
1340         return;
1341     }
1342
1343     Map::PlayerList const &PlayerList = map->GetPlayers();
1344     for(Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
1345         if (Player* i_pl = i->getSource())
1346             if (!i_pl->isGameMaster())
1347                 pUnit->AddThreat(i_pl, 0.0f);
1348 }
1349
1350 void CreatureEventAI::DoMeleeAttackIfReady()
1351 {
1352     //Make sure our attack is ready before checking distance
1353     if (m_creature->isAttackReady())
1354     {
1355         //If we are within range melee the target
1356         if (m_creature->IsWithinDistInMap(m_creature->getVictim(), ATTACK_DISTANCE))
1357         {
1358             m_creature->AttackerStateUpdate(m_creature->getVictim());
1359             m_creature->resetAttackTimer();
1360         }
1361     }
1362 }
1363
1364 bool CreatureEventAI::CanCast(Unit* Target, SpellEntry const *Spell, bool Triggered)
1365 {
1366     //No target so we can't cast
1367     if (!Target || !Spell)
1368         return false;
1369
1370     //Silenced so we can't cast
1371     if (!Triggered && m_creature->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
1372         return false;
1373
1374     //Check for power
1375     if (!Triggered && m_creature->GetPower((Powers)Spell->powerType) < Spell->manaCost)
1376         return false;
1377
1378     SpellRangeEntry const *TempRange = NULL;
1379
1380     TempRange = GetSpellRangeStore()->LookupEntry(Spell->rangeIndex);
1381
1382     //Spell has invalid range store so we can't use it
1383     if (!TempRange)
1384         return false;
1385
1386     //Unit is out of range of this spell
1387     if (!m_creature->IsInRange(Target,TempRange->minRange,TempRange->maxRange))
1388         return false;
1389
1390     return true;
1391 }
1392
1393 void CreatureEventAI::ReceiveEmote(Player* pPlayer, uint32 text_emote)
1394 {
1395     if (bEmptyList)
1396         return;
1397
1398     for (std::list<CreatureEventAIHolder>::iterator itr = CreatureEventAIList.begin(); itr != CreatureEventAIList.end(); ++itr)
1399     {
1400         if ((*itr).Event.event_type == EVENT_T_RECEIVE_EMOTE)
1401         {
1402             if ((*itr).Event.receive_emote.emoteId != text_emote)
1403                 return;
1404
1405             PlayerCondition pcon((*itr).Event.receive_emote.condition,(*itr).Event.receive_emote.conditionValue1,(*itr).Event.receive_emote.conditionValue2);
1406             if (pcon.Meets(pPlayer))
1407             {
1408                 sLog.outDebug("CreatureEventAI: ReceiveEmote CreatureEventAI: Condition ok, processing");
1409                 ProcessEvent(*itr, pPlayer);
1410             }
1411         }
1412     }
1413 }
1414
1415 bool CreatureEventAI::SpawnedEventConditionsCheck(CreatureEventAI_Event const& event)
1416 {
1417     if(event.event_type != EVENT_T_SPAWNED)
1418         return false;
1419
1420     switch (event.spawned.condition)
1421     {
1422         case SPAWNED_EVENT_ALWAY:
1423             // always
1424             return true;
1425         case SPAWNED_EVENT_MAP:
1426             // map ID check
1427             return m_creature->GetMapId() == event.spawned.conditionValue1;
1428         case SPAWNED_EVENT_ZONE:
1429         {
1430             // zone ID check
1431             uint32 zone, area;
1432             m_creature->GetZoneAndAreaId(zone,area);
1433             return zone == event.spawned.conditionValue1 || area == event.spawned.conditionValue1;
1434         }
1435         default:
1436             break;
1437     }
1438
1439     return false;
1440 }