src/game/PetAI.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #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() && m_creature->GetCharmInfo() &&
  48         m_creature->GetCharmInfo()->HasReactState(REACT_AGGRESSIVE) &&
  49         u->isTargetableForAttack() && m_creature->IsHostileTo( u ) &&
  50         u->isInAccessablePlaceFor(m_creature))
  51     {
  52         float attackRadius = m_creature->GetAttackDistance(u);
  53         if(m_creature->IsWithinDistInMap(u, attackRadius) && m_creature->GetDistanceZ(u) <= CREATURE_Z_ATTACK_RANGE)
  54         {
  55             if(m_creature->IsWithinLOSInMap(u))
  56             {
  57                 AttackStart(u);
  58                 u->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
  59             }
  60         }
  61     }
  62 }
  63
  64 void PetAI::AttackStart(Unit *u)
  65 {
  66     if( inCombat || !u || (m_creature->isPet() && ((Pet*)m_creature)->getPetType() == MINI_PET) )
  67         return;
  68
  69     if(m_creature->Attack(u,true))
  70     {
  71         m_creature->clearUnitState(UNIT_STAT_FOLLOW);
  72         // TMGs call CreatureRelocation which via MoveInLineOfSight can call this function
  73         // thus with the following clear the original TMG gets invalidated and crash, doh
  74         // hope it doesn't start to leak memory without this :-/
  75         //i_pet->Clear();
  76         m_creature->GetMotionMaster()->MoveChase(u);
  77         inCombat = true;
  78     }
  79 }
  80
  81 void PetAI::EnterEvadeMode()
  82 {
  83 }
  84
  85 bool PetAI::IsVisible(Unit *pl) const
  86 {
  87     return _isVisible(pl);
  88 }
  89
  90 bool PetAI::_needToStop() const
  91 {
  92     // This is needed for charmed creatures, as once their target was reset other effects can trigger threat
  93     if(m_creature->isCharmed() && m_creature->getVictim() == m_creature->GetCharmer())
  94         return true;
  95
  96     return !m_creature->getVictim()->isTargetableForAttack();
  97 }
  98
  99 void PetAI::_stopAttack()
 100 {
 101     inCombat = false;
 102     if( !m_creature->isAlive() )
 103     {
 104         DEBUG_LOG("Creature stoped attacking cuz his dead [guid=%u]", m_creature->GetGUIDLow());
 105         m_creature->StopMoving();
 106         m_creature->GetMotionMaster()->Clear();
 107         m_creature->GetMotionMaster()->MoveIdle();
 108         m_creature->CombatStop();
 109         m_creature->getHostilRefManager().deleteReferences();
 110
 111         return;
 112     }
 113
 114     Unit* owner = m_creature->GetCharmerOrOwner();
 115
 116     if(owner && m_creature->GetCharmInfo() && m_creature->GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
 117     {
 118         m_creature->GetMotionMaster()->MoveFollow(owner,PET_FOLLOW_DIST,PET_FOLLOW_ANGLE);
 119     }
 120     else
 121     {
 122         m_creature->clearUnitState(UNIT_STAT_FOLLOW);
 123         m_creature->GetMotionMaster()->Clear();
 124         m_creature->GetMotionMaster()->MoveIdle();
 125     }
 126     m_creature->AttackStop();
 127 }
 128
 129 void PetAI::UpdateAI(const uint32 diff)
 130 {
 131     if (!m_creature->isAlive())
 132         return;
 133
 134     Unit* owner = m_creature->GetCharmerOrOwner();
 135
 136     if(m_updateAlliesTimer <= diff)
 137         // UpdateAllies self set update timer
 138         UpdateAllies();
 139     else
 140         m_updateAlliesTimer -= diff;
 141
 142     if (inCombat && !m_creature->getVictim())
 143         _stopAttack();
 144
 145     // i_pet.getVictim() can't be used for check in case stop fighting, i_pet.getVictim() clear at Unit death etc.
 146     if (m_creature->getVictim())
 147     {
 148         if (_needToStop())
 149         {
 150             DEBUG_LOG("Pet AI stoped attacking [guid=%u]", m_creature->GetGUIDLow());
 151             _stopAttack();
 152             return;
 153         }
 154         else if (m_creature->IsStopped() || m_creature->IsWithinDistInMap(m_creature->getVictim(), ATTACK_DISTANCE))
 155         {
 156             // required to be stopped cases
 157             if (m_creature->IsStopped() && m_creature->IsNonMeleeSpellCasted(false))
 158             {
 159                 if (m_creature->hasUnitState(UNIT_STAT_FOLLOW))
 160                     m_creature->InterruptNonMeleeSpells(false);
 161                 else
 162                     return;
 163             }
 164             // not required to be stopped case
 165             else if (m_creature->isAttackReady() && m_creature->canReachWithAttack(m_creature->getVictim()))
 166             {
 167                 m_creature->AttackerStateUpdate(m_creature->getVictim());
 168
 169                 m_creature->resetAttackTimer();
 170
 171                 if (!m_creature->getVictim())
 172                     return;
 173
 174                 //if pet misses its target, it will also be the first in threat list
 175                 m_creature->getVictim()->AddThreat(m_creature,0.0f);
 176
 177                 if( _needToStop() )
 178                     _stopAttack();
 179             }
 180         }
 181     }
 182     else if (owner && m_creature->GetCharmInfo())
 183     {
 184         if (owner->isInCombat() && !(m_creature->GetCharmInfo()->HasReactState(REACT_PASSIVE) || m_creature->GetCharmInfo()->HasCommandState(COMMAND_STAY)))
 185         {
 186             AttackStart(owner->getAttackerForHelper());
 187         }
 188         else if(m_creature->GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
 189         {
 190             if (!m_creature->hasUnitState(UNIT_STAT_FOLLOW) )
 191             {
 192                 m_creature->GetMotionMaster()->MoveFollow(owner,PET_FOLLOW_DIST,PET_FOLLOW_ANGLE);
 193             }
 194         }
 195     }
 196
 197     if (m_creature->GetGlobalCooldown() == 0 && !m_creature->IsNonMeleeSpellCasted(false))
 198     {
 199         //Autocast
 200         for (uint8 i = 0; i < m_creature->GetPetAutoSpellSize(); ++i)
 201         {
 202             uint32 spellID = m_creature->GetPetAutoSpellOnPos(i);
 203             if (!spellID)
 204                 continue;
 205
 206             SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellID);
 207             if (!spellInfo)
 208                 continue;
 209
 210             // ignore some combinations of combat state and combat/noncombat spells
 211             if (!inCombat)
 212             {
 213                 if (!IsPositiveSpell(spellInfo->Id))
 214                     continue;
 215             }
 216             else
 217             {
 218                 if (IsNonCombatSpell(spellInfo))
 219                     continue;
 220             }
 221
 222             Spell *spell = new Spell(m_creature, spellInfo, false, 0);
 223
 224             if (inCombat && !m_creature->hasUnitState(UNIT_STAT_FOLLOW) && spell->CanAutoCast(m_creature->getVictim()))
 225             {
 226                 m_targetSpellStore.push_back(std::make_pair<Unit*, Spell*>(m_creature->getVictim(), spell));
 227                 continue;
 228             }
 229             else
 230             {
 231                 bool spellUsed = false;
 232                 for(std::set<uint64>::const_iterator tar = m_AllySet.begin(); tar != m_AllySet.end(); ++tar)
 233                 {
 234                     Unit* Target = ObjectAccessor::GetUnit(*m_creature,*tar);
 235
 236                     //only buff targets that are in combat, unless the spell can only be cast while out of combat
 237                     if(!Target)
 238                         continue;
 239
 240                     if(spell->CanAutoCast(Target))
 241                     {
 242                         m_targetSpellStore.push_back(std::make_pair<Unit*, Spell*>(Target, spell));
 243                         spellUsed = true;
 244                         break;
 245                     }
 246                 }
 247                 if (!spellUsed)
 248                     delete spell;
 249             }
 250         }
 251
 252         //found units to cast on to
 253         if (!m_targetSpellStore.empty())
 254         {
 255             uint32 index = urand(0, m_targetSpellStore.size() - 1);
 256
 257             Spell* spell  = m_targetSpellStore[index].second;
 258             Unit*  target = m_targetSpellStore[index].first;
 259
 260             m_targetSpellStore.erase(m_targetSpellStore.begin() + index);
 261
 262             SpellCastTargets targets;
 263             targets.setUnitTarget( target );
 264
 265             if (!m_creature->HasInArc(M_PI, target))
 266             {
 267                 m_creature->SetInFront(target);
 268                 if (target->GetTypeId() == TYPEID_PLAYER)
 269                     m_creature->SendUpdateToPlayer((Player*)target);
 270
 271                 if (owner && owner->GetTypeId() == TYPEID_PLAYER)
 272                     m_creature->SendUpdateToPlayer( (Player*)owner );
 273             }
 274
 275             m_creature->AddCreatureSpellCooldown(spell->m_spellInfo->Id);
 276             if (m_creature->isPet())
 277                 ((Pet*)m_creature)->CheckLearning(spell->m_spellInfo->Id);
 278
 279             spell->prepare(&targets);
 280         }
 281         while (!m_targetSpellStore.empty())
 282         {
 283             delete m_targetSpellStore.begin()->second;
 284             m_targetSpellStore.erase(m_targetSpellStore.begin());
 285         }
 286     }
 287 }
 288
 289 bool PetAI::_isVisible(Unit *u) const
 290 {
 291     return m_creature->IsWithinDist(u,sWorld.getConfig(CONFIG_SIGHT_GUARDER))
 292         && u->isVisibleForOrDetect(m_creature,true);
 293 }
 294
 295 void PetAI::UpdateAllies()
 296 {
 297     Unit* owner = m_creature->GetCharmerOrOwner();
 298     Group *pGroup = NULL;
 299
 300     m_updateAlliesTimer = 10*IN_MILISECONDS;                //update friendly targets every 10 seconds, lesser checks increase performance
 301
 302     if(!owner)
 303         return;
 304     else if(owner->GetTypeId() == TYPEID_PLAYER)
 305         pGroup = ((Player*)owner)->GetGroup();
 306
 307     //only pet and owner/not in group->ok
 308     if(m_AllySet.size() == 2 && !pGroup)
 309         return;
 310     //owner is in group; group members filled in already (no raid -> subgroupcount = whole count)
 311     if(pGroup && !pGroup->isRaidGroup() && m_AllySet.size() == (pGroup->GetMembersCount() + 2))
 312         return;
 313
 314     m_AllySet.clear();
 315     m_AllySet.insert(m_creature->GetGUID());
 316     if(pGroup)                                              //add group
 317     {
 318         for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
 319         {
 320             Player* Target = itr->getSource();
 321             if(!Target || !pGroup->SameSubGroup((Player*)owner, Target))
 322                 continue;
 323
 324             if(Target->GetGUID() == owner->GetGUID())
 325                 continue;
 326
 327             m_AllySet.insert(Target->GetGUID());
 328         }
 329     }
 330     else                                                    //remove group
 331         m_AllySet.insert(owner->GetGUID());
 332 }
 333
 334 void PetAI::AttackedBy(Unit *attacker)
 335 {
 336     //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
 337     if(!m_creature->getVictim() && m_creature->GetCharmInfo() && !m_creature->GetCharmInfo()->HasReactState(REACT_PASSIVE) &&
 338         (!m_creature->GetCharmInfo()->HasCommandState(COMMAND_STAY) || m_creature->canReachWithAttack(attacker)))
 339         AttackStart(attacker);
 340 }