src/game/PetAI.cpp

   1 /*
   2  * Copyright (C) 2005-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 "PetAI.h"
  20 #include "Errors.h"
  21 #include "Pet.h"
  22 #include "Player.h"
  23 #include "DBCStores.h"
  24 #include "Spell.h"
  25 #include "ObjectAccessor.h"
  26 #include "SpellMgr.h"
  27 #include "Creature.h"
  28 #include "World.h"
  29 #include "Util.h"
  30
  31 int PetAI::Permissible(const Creature *creature)
  32 {
  33     if( creature->isPet())
  34         return PERMIT_BASE_SPECIAL;
  35
  36     return PERMIT_BASE_NO;
  37 }
  38
  39 PetAI::PetAI(Creature *c) : CreatureAI(c), i_tracker(TIME_INTERVAL_LOOK), inCombat(false)
  40 {
  41     m_AllySet.clear();
  42     UpdateAllies();
  43 }
  44
  45 void PetAI::MoveInLineOfSight(Unit *u)
  46 {
  47     if (m_creature->getVictim())
  48         return;
  49
  50     if (m_creature->isPet() && ((Pet*)m_creature)->GetModeFlags() & PET_MODE_DISABLE_ACTIONS)
  51         return;
  52
  53     if (!m_creature->GetCharmInfo() || !m_creature->GetCharmInfo()->HasReactState(REACT_AGGRESSIVE))
  54         return;
  55
  56     if (u->isTargetableForAttack() && m_creature->IsHostileTo( u ) &&
  57         u->isInAccessablePlaceFor(m_creature))
  58     {
  59         float attackRadius = m_creature->GetAttackDistance(u);
  60         if(m_creature->IsWithinDistInMap(u, attackRadius) && m_creature->GetDistanceZ(u) <= CREATURE_Z_ATTACK_RANGE)
  61         {
  62             if(m_creature->IsWithinLOSInMap(u))
  63             {
  64                 AttackStart(u);
  65                 u->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
  66             }
  67         }
  68     }
  69 }
  70
  71 void PetAI::AttackStart(Unit *u)
  72 {
  73     if(!u || (m_creature->isPet() && ((Pet*)m_creature)->getPetType() == MINI_PET))
  74         return;
  75
  76     if(m_creature->Attack(u,true))
  77     {
  78         // TMGs call CreatureRelocation which via MoveInLineOfSight can call this function
  79         // thus with the following clear the original TMG gets invalidated and crash, doh
  80         // hope it doesn't start to leak memory without this :-/
  81         //i_pet->Clear();
  82         m_creature->GetMotionMaster()->MoveChase(u);
  83         inCombat = true;
  84     }
  85 }
  86
  87 void PetAI::EnterEvadeMode()
  88 {
  89 }
  90
  91 bool PetAI::IsVisible(Unit *pl) const
  92 {
  93     return _isVisible(pl);
  94 }
  95
  96 bool PetAI::_needToStop() const
  97 {
  98     // This is needed for charmed creatures, as once their target was reset other effects can trigger threat
  99     if(m_creature->isCharmed() && m_creature->getVictim() == m_creature->GetCharmer())
 100         return true;
 101
 102     return !m_creature->getVictim()->isTargetableForAttack();
 103 }
 104
 105 void PetAI::_stopAttack()
 106 {
 107     inCombat = false;
 108     if( !m_creature->isAlive() )
 109     {
 110         DEBUG_LOG("PetAI (guid = %u) stopped attack, he is dead.", m_creature->GetGUIDLow());
 111         m_creature->StopMoving();
 112         m_creature->GetMotionMaster()->Clear();
 113         m_creature->GetMotionMaster()->MoveIdle();
 114         m_creature->CombatStop();
 115         m_creature->getHostileRefManager().deleteReferences();
 116
 117         return;
 118     }
 119
 120     Unit* owner = m_creature->GetCharmerOrOwner();
 121
 122     if(owner && m_creature->GetCharmInfo() && m_creature->GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
 123     {
 124         m_creature->GetMotionMaster()->MoveFollow(owner,PET_FOLLOW_DIST,PET_FOLLOW_ANGLE);
 125     }
 126     else
 127     {
 128         m_creature->GetMotionMaster()->Clear(false);
 129         m_creature->GetMotionMaster()->MoveIdle();
 130     }
 131     m_creature->AttackStop();
 132 }
 133
 134 void PetAI::UpdateAI(const uint32 diff)
 135 {
 136     if (!m_creature->isAlive())
 137         return;
 138
 139     Unit* owner = m_creature->GetCharmerOrOwner();
 140
 141     if(m_updateAlliesTimer <= diff)
 142         // UpdateAllies self set update timer
 143         UpdateAllies();
 144     else
 145         m_updateAlliesTimer -= diff;
 146
 147     if (inCombat && (!m_creature->getVictim() || m_creature->isPet() && ((Pet*)m_creature)->GetModeFlags() & PET_MODE_DISABLE_ACTIONS))
 148         _stopAttack();
 149
 150     // i_pet.getVictim() can't be used for check in case stop fighting, i_pet.getVictim() clear at Unit death etc.
 151     if (m_creature->getVictim())
 152     {
 153         if (_needToStop())
 154         {
 155             DEBUG_LOG("PetAI (guid = %u) is stopping attack.", m_creature->GetGUIDLow());
 156             _stopAttack();
 157             return;
 158         }
 159         else if (m_creature->IsStopped() || m_creature->IsWithinDistInMap(m_creature->getVictim(), ATTACK_DISTANCE))
 160         {
 161             // required to be stopped cases
 162             if (m_creature->IsStopped() && m_creature->IsNonMeleeSpellCasted(false))
 163             {
 164                 if (m_creature->hasUnitState(UNIT_STAT_FOLLOW_MOVE))
 165                     m_creature->InterruptNonMeleeSpells(false);
 166                 else
 167                     return;
 168             }
 169             // not required to be stopped case
 170             else if (m_creature->isAttackReady() && m_creature->canReachWithAttack(m_creature->getVictim()))
 171             {
 172                 m_creature->AttackerStateUpdate(m_creature->getVictim());
 173
 174                 m_creature->resetAttackTimer();
 175
 176                 if (!m_creature->getVictim())
 177                     return;
 178
 179                 //if pet misses its target, it will also be the first in threat list
 180                 m_creature->getVictim()->AddThreat(m_creature);
 181
 182                 if( _needToStop() )
 183                     _stopAttack();
 184             }
 185         }
 186     }
 187     else if (owner && m_creature->GetCharmInfo())
 188     {
 189         if (owner->isInCombat() && !(m_creature->GetCharmInfo()->HasReactState(REACT_PASSIVE) || m_creature->GetCharmInfo()->HasCommandState(COMMAND_STAY)))
 190         {
 191             AttackStart(owner->getAttackerForHelper());
 192         }
 193         else if(m_creature->GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
 194         {
 195             if (!m_creature->hasUnitState(UNIT_STAT_FOLLOW) )
 196             {
 197                 m_creature->GetMotionMaster()->MoveFollow(owner,PET_FOLLOW_DIST,PET_FOLLOW_ANGLE);
 198             }
 199         }
 200     }
 201
 202     // Autocast (casted only in combat or persistent spells in any state)
 203     if (m_creature->GetGlobalCooldown() == 0 && !m_creature->IsNonMeleeSpellCasted(false))
 204     {
 205         typedef std::vector<std::pair<Unit*, Spell*> > TargetSpellList;
 206         TargetSpellList targetSpellStore;
 207
 208         for (uint8 i = 0; i < m_creature->GetPetAutoSpellSize(); ++i)
 209         {
 210             uint32 spellID = m_creature->GetPetAutoSpellOnPos(i);
 211             if (!spellID)
 212                 continue;
 213
 214             SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellID);
 215             if (!spellInfo)
 216                 continue;
 217
 218             // ignore some combinations of combat state and combat/noncombat spells
 219             if (!inCombat)
 220             {
 221                 // ignore attacking spells, and allow only self/around spells
 222                 if (!IsPositiveSpell(spellInfo->Id))
 223                     continue;
 224
 225                 // non combat spells allowed
 226                 // only pet spells have IsNonCombatSpell and not fit this reqs:
 227                 // Consume Shadows, Lesser Invisibility, so ignore checks for its
 228                 if (!IsNonCombatSpell(spellInfo))
 229                 {
 230                     // allow only spell without spell cost or with spell cost but not duration limit
 231                     int32 duration = GetSpellDuration(spellInfo);
 232                     if ((spellInfo->manaCost || spellInfo->ManaCostPercentage || spellInfo->manaPerSecond) && duration > 0)
 233                         continue;
 234
 235                     // allow only spell without cooldown > duration
 236                     int32 cooldown = GetSpellRecoveryTime(spellInfo);
 237                     if (cooldown >= 0 && duration >= 0 && cooldown > duration)
 238                         continue;
 239                 }
 240             }
 241             else
 242             {
 243                 // just ignore non-combat spells
 244                 if (IsNonCombatSpell(spellInfo))
 245                     continue;
 246             }
 247
 248             Spell *spell = new Spell(m_creature, spellInfo, false, 0);
 249
 250             if (inCombat && !m_creature->hasUnitState(UNIT_STAT_FOLLOW) && spell->CanAutoCast(m_creature->getVictim()))
 251             {
 252                 targetSpellStore.push_back(std::make_pair<Unit*, Spell*>(m_creature->getVictim(), spell));
 253                 continue;
 254             }
 255             else
 256             {
 257                 bool spellUsed = false;
 258                 for(std::set<uint64>::const_iterator tar = m_AllySet.begin(); tar != m_AllySet.end(); ++tar)
 259                 {
 260                     Unit* Target = ObjectAccessor::GetUnit(*m_creature,*tar);
 261
 262                     //only buff targets that are in combat, unless the spell can only be cast while out of combat
 263                     if(!Target)
 264                         continue;
 265
 266                     if(spell->CanAutoCast(Target))
 267                     {
 268                         targetSpellStore.push_back(std::make_pair<Unit*, Spell*>(Target, spell));
 269                         spellUsed = true;
 270                         break;
 271                     }
 272                 }
 273                 if (!spellUsed)
 274                     delete spell;
 275             }
 276         }
 277
 278         //found units to cast on to
 279         if (!targetSpellStore.empty())
 280         {
 281             uint32 index = urand(0, targetSpellStore.size() - 1);
 282
 283             Spell* spell  = targetSpellStore[index].second;
 284             Unit*  target = targetSpellStore[index].first;
 285
 286             targetSpellStore.erase(targetSpellStore.begin() + index);
 287
 288             SpellCastTargets targets;
 289             targets.setUnitTarget( target );
 290
 291             if (!m_creature->HasInArc(M_PI_F, target))
 292             {
 293                 m_creature->SetInFront(target);
 294                 if (target->GetTypeId() == TYPEID_PLAYER)
 295                     m_creature->SendCreateUpdateToPlayer((Player*)target);
 296
 297                 if (owner && owner->GetTypeId() == TYPEID_PLAYER)
 298                     m_creature->SendCreateUpdateToPlayer( (Player*)owner );
 299             }
 300
 301             m_creature->AddCreatureSpellCooldown(spell->m_spellInfo->Id);
 302
 303             spell->prepare(&targets);
 304         }
 305
 306         // deleted cached Spell objects
 307         for(TargetSpellList::const_iterator itr = targetSpellStore.begin(); itr != targetSpellStore.end(); ++itr)
 308             delete itr->second;
 309     }
 310 }
 311
 312 bool PetAI::_isVisible(Unit *u) const
 313 {
 314     return m_creature->IsWithinDist(u,sWorld.getConfig(CONFIG_FLOAT_SIGHT_GUARDER))
 315         && u->isVisibleForOrDetect(m_creature,m_creature,true);
 316 }
 317
 318 void PetAI::UpdateAllies()
 319 {
 320     Unit* owner = m_creature->GetCharmerOrOwner();
 321     Group *pGroup = NULL;
 322
 323     m_updateAlliesTimer = 10*IN_MILISECONDS;                //update friendly targets every 10 seconds, lesser checks increase performance
 324
 325     if(!owner)
 326         return;
 327     else if(owner->GetTypeId() == TYPEID_PLAYER)
 328         pGroup = ((Player*)owner)->GetGroup();
 329
 330     //only pet and owner/not in group->ok
 331     if(m_AllySet.size() == 2 && !pGroup)
 332         return;
 333     //owner is in group; group members filled in already (no raid -> subgroupcount = whole count)
 334     if(pGroup && !pGroup->isRaidGroup() && m_AllySet.size() == (pGroup->GetMembersCount() + 2))
 335         return;
 336
 337     m_AllySet.clear();
 338     m_AllySet.insert(m_creature->GetGUID());
 339     if(pGroup)                                              //add group
 340     {
 341         for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
 342         {
 343             Player* Target = itr->getSource();
 344             if(!Target || !pGroup->SameSubGroup((Player*)owner, Target))
 345                 continue;
 346
 347             if(Target->GetGUID() == owner->GetGUID())
 348                 continue;
 349
 350             m_AllySet.insert(Target->GetGUID());
 351         }
 352     }
 353     else                                                    //remove group
 354         m_AllySet.insert(owner->GetGUID());
 355 }
 356
 357 void PetAI::AttackedBy(Unit *attacker)
 358 {
 359     //when attacked, fight back in case 1)no victim already AND 2)not set to passive AND 3)not set to stay, unless can it can reach attacker with melee attack anyway
 360     if(!m_creature->getVictim() && m_creature->GetCharmInfo() && !m_creature->GetCharmInfo()->HasReactState(REACT_PASSIVE) &&
 361         (!m_creature->GetCharmInfo()->HasCommandState(COMMAND_STAY) || m_creature->canReachWithAttack(attacker)))
 362         AttackStart(attacker);
 363 }