src/game/CreatureEventAI.cpp

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