#include <PetAI.h>

Public Member Functions
	PetAI (Creature *c)

void	UpdateAI (uint32) override

void	KilledUnit (Unit *) override

void	AttackStart (Unit *target) override

void	MovementInform (uint32 moveType, uint32 data) override

void	OwnerAttackedBy (Unit *attacker) override

void	OwnerAttacked (Unit *target) override

void	AttackedBy (Unit *attacker) override

void	ReceiveEmote (Player *player, uint32 textEmote) override

void	MoveInLineOfSight (Unit *) override

void	MoveInLineOfSight_Safe (Unit *)

void	EnterEvadeMode (EvadeReason) override

Public Member Functions inherited from CreatureAI
void	Talk (uint8 id, WorldObject const *whisperTarget=nullptr)

	CreatureAI (Creature *creature)

virtual	~CreatureAI ()

void	MoveInLineOfSight_Safe (Unit *who)
	== Reactions At ================================= More...

void	TriggerAlert (Unit const *who) const

virtual bool	CanRespawn ()

virtual void	EnterCombat (Unit *)

virtual void	JustDied (Unit *)

virtual void	JustSummoned (Creature *)

virtual void	IsSummonedBy (Unit *)

virtual void	SummonedCreatureDespawn (Creature *)

virtual void	SummonedCreatureDies (Creature , Unit )

virtual void	SpellHit (Unit , SpellInfo const )

virtual void	SpellHitTarget (Unit , SpellInfo const )

virtual bool	IsEscorted () const

virtual void	JustRespawned ()

void	OnCharmed (bool apply) override

virtual void	JustReachedHome ()

void	DoZoneInCombat (Creature *creature=NULL, float maxRangeToNearestTarget=50.0f)

virtual void	CorpseRemoved (uint32 &)
	== Triggered Actions Requested ================== More...

virtual void	PassengerBoarded (Unit *, int8, bool)
	== Fields ======================================= More...

virtual void	OnSpellClick (Unit *, bool &)

virtual bool	CanSeeAlways (WorldObject const *)

int32	VisualizeBoundary (uint32 duration, Unit *owner=nullptr, bool fill=false) const

virtual bool	CheckInRoom ()

CreatureBoundary const *	GetBoundary () const

Public Member Functions inherited from UnitAI
	UnitAI (Unit *unit)

virtual	~UnitAI ()

virtual bool	CanAIAttack (Unit const *) const

virtual void	InitializeAI ()

virtual void	Reset ()

virtual void	DoAction (int32)

virtual uint32	GetData (uint32) const

virtual void	SetData (uint32, uint32)

virtual void	SetGUID (ObjectGuid, int32=0)

virtual ObjectGuid	GetGUID (int32=0) const

Unit *	SelectTarget (SelectAggroTarget targetType, uint32 position=0, float dist=0.0f, bool playerOnly=false, int32 aura=0)

template<class PREDICATE >
Unit *	SelectTarget (SelectAggroTarget targetType, uint32 position, PREDICATE const &predicate)

void	SelectTargetList (std::list< Unit * > &targetList, uint32 num, SelectAggroTarget targetType, float dist=0.0f, bool playerOnly=false, int32 aura=0)

template<class PREDICATE >
void	SelectTargetList (std::list< Unit * > &targetList, PREDICATE const &predicate, uint32 maxTargets, SelectAggroTarget targetType)

virtual void	DamageDealt (Unit *, uint32 &, DamageEffectType)

virtual void	DamageTaken (Unit *, uint32 &)

virtual void	HealReceived (Unit *, uint32 &)

virtual void	HealDone (Unit *, uint32 &)

virtual void	SpellInterrupted (uint32, uint32)

void	AttackStartCaster (Unit *victim, float dist)

void	DoCast (uint32 spellId)

void	DoCast (Unit *victim, uint32 spellId, bool triggered=false)

void	DoCastVictim (uint32 spellId, bool triggered=false)

void	DoCastAOE (uint32 spellId, bool triggered=false)

void	DoMeleeAttackIfReady ()

bool	DoSpellAttackIfReady (uint32 spellId)

virtual void	sGossipHello (Player *)

virtual void	sGossipSelect (Player *, uint32, uint32)

virtual void	sGossipSelectCode (Player , uint32, uint32, char const )

virtual void	sQuestAccept (Player , Quest const )

virtual void	sQuestSelect (Player , Quest const )

virtual void	sQuestReward (Player , Quest const , uint32)

virtual bool	sOnDummyEffect (Unit *, uint32, SpellEffIndex)

virtual void	sOnGameEvent (bool, uint16)

Static Public Member Functions
static int	Permissible (const Creature *)

Static Public Member Functions inherited from UnitAI
static void	FillAISpellInfo ()

Private Member Functions
bool	_isVisible (Unit *) const

bool	_needToStop (void)

void	_stopAttack (void)

void	UpdateAllies ()

Unit *	SelectNextTarget (bool allowAutoSelect) const

void	HandleReturnMovement ()

void	DoAttack (Unit *target, bool chase)

bool	CanAttack (Unit *target)

void	ClearCharmInfoFlags ()

Private Attributes
TimeTracker	i_tracker

GuidSet	m_AllySet

uint32	m_updateAlliesTimer

Additional Inherited Members
Public Types inherited from CreatureAI
enum	EvadeReason { EVADE_REASON_NO_HOSTILES, EVADE_REASON_BOUNDARY, EVADE_REASON_SEQUENCE_BREAK, EVADE_REASON_OTHER }

Static Public Attributes inherited from UnitAI
static AISpellInfoType *	AISpellInfo

Protected Member Functions inherited from CreatureAI
bool	UpdateVictim ()

bool	UpdateVictimWithGaze ()

void	SetGazeOn (Unit *target)

Creature *	DoSummon (uint32 entry, Position const &pos, uint32 despawnTime=30000, TempSummonType summonType=TEMPSUMMON_CORPSE_TIMED_DESPAWN)

Creature *	DoSummon (uint32 entry, WorldObject *obj, float radius=5.0f, uint32 despawnTime=30000, TempSummonType summonType=TEMPSUMMON_CORPSE_TIMED_DESPAWN)

Creature *	DoSummonFlyer (uint32 entry, WorldObject *obj, float flightZ, float radius=5.0f, uint32 despawnTime=30000, TempSummonType summonType=TEMPSUMMON_CORPSE_TIMED_DESPAWN)

bool	CheckBoundary (Position const *who=nullptr) const

void	SetBoundary (CreatureBoundary const *boundary)

bool	_EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

Protected Attributes inherited from CreatureAI
Creature *const	me

CreatureBoundary const *	_boundary

Protected Attributes inherited from UnitAI
Unit *const	me

Constructor & Destructor Documentation

PetAI::PetAI ( Creature * c )

explicit

  : CreatureAI(c), i_tracker(TIME_INTERVAL_LOOK)
 {
  UpdateAllies();
 }

Here is the call graph for this function:

Member Function Documentation

bool PetAI::_isVisible ( Unit * ) const

private

bool PetAI::_needToStop ( void )

private

 {
  // This is needed for charmed creatures, as once their target was reset other effects can trigger threat
  if (me->IsCharmed() && me->GetVictim() == me->GetCharmer())
  return true;
 
  return !me->IsValidAttackTarget(me->GetVictim());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::_stopAttack ( void )

private

 {
  if (!me->IsAlive())
  {
  TC_LOG_DEBUG("misc", "Creature stoped attacking cuz his dead [%s]", me->GetGUID().ToString().c_str());
  me->GetMotionMaster()->Clear();
  me->GetMotionMaster()->MoveIdle();
  me->CombatStop();
  me->getHostileRefManager().deleteReferences();
  return;
  }
 
  me->AttackStop();
  me->InterruptNonMeleeSpells(false);
  me->SendMeleeAttackStop(); // Should stop pet's attack button from flashing
  me->GetCharmInfo()->SetIsCommandAttack(false);
  ClearCharmInfoFlags();
  HandleReturnMovement();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::AttackedBy ( Unit * attacker )

overridevirtual

Reimplemented from CreatureAI.

 {
  // Called when pet takes damage. This function helps keep pets from running off
  // simply due to gaining aggro.
 
  if (!attacker)
  return;
 
  // Passive pets don't do anything
  if (me->HasReactState(REACT_PASSIVE))
  return;
 
  // Prevent pet from disengaging from current target
  if (me->GetVictim() && me->EnsureVictim()->IsAlive())
  return;
 
  // Continue to evaluate and attack if necessary
  AttackStart(attacker);
 }

Here is the call graph for this function:

void PetAI::AttackStart ( Unit * target )

overridevirtual

Reimplemented from UnitAI.

 {
  // Overrides Unit::AttackStart to correctly evaluate Pet states
 
  // Check all pet states to decide if we can attack this target
  if (!CanAttack(target))
  return;
 
  // Only chase if not commanded to stay or if stay but commanded to attack
  DoAttack(target, (!me->GetCharmInfo()->HasCommandState(COMMAND_STAY) || me->GetCharmInfo()->IsCommandAttack()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool PetAI::CanAttack ( Unit * target )

private

 {
  // Evaluates wether a pet can attack a specific target based on CommandState, ReactState and other flags
  // IMPORTANT: The order in which things are checked is important, be careful if you add or remove checks
 
  // Hmmm...
  if (!target)
  return false;
 
  if (!target->IsAlive())
  {
  // Clear target to prevent getting stuck on dead targets
  me->AttackStop();
  me->InterruptNonMeleeSpells(false);
  me->SendMeleeAttackStop();
  return false;
  }
 
  // Passive - passive pets can attack if told to
  if (me->HasReactState(REACT_PASSIVE))
  return me->GetCharmInfo()->IsCommandAttack();
 
  // CC - mobs under crowd control can be attacked if owner commanded
  if (target->HasBreakableByDamageCrowdControlAura())
  return me->GetCharmInfo()->IsCommandAttack();
 
  // Returning - pets ignore attacks only if owner clicked follow
  if (me->GetCharmInfo()->IsReturning())
  return !me->GetCharmInfo()->IsCommandFollow();
 
  // Stay - can attack if target is within range or commanded to
  if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
  return (me->IsWithinMeleeRange(target) || me->GetCharmInfo()->IsCommandAttack());
 
  // Pets attacking something (or chasing) should only switch targets if owner tells them to
  if (me->GetVictim() && me->GetVictim() != target)
  {
  // Check if our owner selected this target and clicked "attack"
  Unit* ownerTarget = NULL;
  if (Player* owner = me->GetCharmerOrOwner()->ToPlayer())
  ownerTarget = owner->GetSelectedUnit();
  else
  ownerTarget = me->GetCharmerOrOwner()->GetVictim();
 
  if (ownerTarget && me->GetCharmInfo()->IsCommandAttack())
  return (target->GetGUID() == ownerTarget->GetGUID());
  }
 
  // Follow
  if (me->GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
  return !me->GetCharmInfo()->IsReturning();
 
  // default, though we shouldn't ever get here
  return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::ClearCharmInfoFlags ( )

private

 {
  // Quick access to set all flags to FALSE
 
  CharmInfo* ci = me->GetCharmInfo();
 
  if (ci)
  {
  ci->SetIsAtStay(false);
  ci->SetIsCommandAttack(false);
  ci->SetIsCommandFollow(false);
  ci->SetIsFollowing(false);
  ci->SetIsReturning(false);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::DoAttack	(	Unit *	target,
		bool	chase
	)

private

 {
  // Handles attack with or without chase and also resets flags
  // for next update / creature kill
 
  if (me->Attack(target, true))
  {
  // Play sound to let the player know the pet is attacking something it picked on its own
  if (me->HasReactState(REACT_AGGRESSIVE) && !me->GetCharmInfo()->IsCommandAttack())
  me->SendPetAIReaction(me->GetGUID());
 
  if (chase)
  {
  bool oldCmdAttack = me->GetCharmInfo()->IsCommandAttack(); // This needs to be reset after other flags are cleared
  ClearCharmInfoFlags();
  me->GetCharmInfo()->SetIsCommandAttack(oldCmdAttack); // For passive pets commanded to attack so they will use spells
  me->GetMotionMaster()->Clear();
  me->GetMotionMaster()->MoveChase(target);
  }
  else // (Stay && ((Aggressive || Defensive) && In Melee Range)))
  {
  ClearCharmInfoFlags();
  me->GetCharmInfo()->SetIsAtStay(true);
  me->GetMotionMaster()->Clear();
  me->GetMotionMaster()->MoveIdle();
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::EnterEvadeMode ( EvadeReason )

inlineoverridevirtual

Reimplemented from CreatureAI.

50 { } // For fleeing, pets don't use this type of Evade mechanic

void PetAI::HandleReturnMovement ( )

private

 {
  // Handles moving the pet back to stay or owner
 
  // Prevent activating movement when under control of spells
  // such as "Eyes of the Beast"
  if (me->IsCharmed())
  return;
 
  if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
  {
  if (!me->GetCharmInfo()->IsAtStay() && !me->GetCharmInfo()->IsReturning())
  {
  // Return to previous position where stay was clicked
  float x, y, z;
 
  me->GetCharmInfo()->GetStayPosition(x, y, z);
  ClearCharmInfoFlags();
  me->GetCharmInfo()->SetIsReturning(true);
  me->GetMotionMaster()->Clear();
  me->GetMotionMaster()->MovePoint(me->GetGUID().GetCounter(), x, y, z);
  }
  }
  else // COMMAND_FOLLOW
  {
  if (!me->GetCharmInfo()->IsFollowing() && !me->GetCharmInfo()->IsReturning())
  {
  ClearCharmInfoFlags();
  me->GetCharmInfo()->SetIsReturning(true);
  me->GetMotionMaster()->Clear();
  me->GetMotionMaster()->MoveFollow(me->GetCharmerOrOwner(), PET_FOLLOW_DIST, me->GetFollowAngle());
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::KilledUnit ( Unit * victim )

overridevirtual

Reimplemented from CreatureAI.

 {
  // Called from Unit::Kill() in case where pet or owner kills something
  // if owner killed this victim, pet may still be attacking something else
  if (me->GetVictim() && me->GetVictim() != victim)
  return;
 
  // Clear target just in case. May help problem where health / focus / mana
  // regen gets stuck. Also resets attack command.
  // Can't use _stopAttack() because that activates movement handlers and ignores
  // next target selection
  me->AttackStop();
  me->InterruptNonMeleeSpells(false);
  me->SendMeleeAttackStop(); // Stops the pet's 'Attack' button from flashing
 
  // Before returning to owner, see if there are more things to attack
  if (Unit* nextTarget = SelectNextTarget(false))
  AttackStart(nextTarget);
  else
  HandleReturnMovement(); // Return
 }

Here is the call graph for this function:

void PetAI::MoveInLineOfSight ( Unit * )

inlineoverridevirtual

Reimplemented from CreatureAI.

48 { } // CreatureAI interferes with returning pets

void PetAI::MoveInLineOfSight_Safe ( Unit * )

inline

49 { } // CreatureAI interferes with returning pets

void PetAI::MovementInform	(	uint32	moveType,
		uint32	data
	)

overridevirtual

Reimplemented from CreatureAI.

Reimplemented in npc_snufflenose_gopher::npc_snufflenose_gopherAI.

 {
  // Receives notification when pet reaches stay or follow owner
  switch (moveType)
  {
  case POINT_MOTION_TYPE:
  {
  // Pet is returning to where stay was clicked. data should be
  // pet's GUIDLow since we set that as the waypoint ID
  if (data == me->GetGUID().GetCounter() && me->GetCharmInfo()->IsReturning())
  {
  ClearCharmInfoFlags();
  me->GetCharmInfo()->SetIsAtStay(true);
  me->GetMotionMaster()->Clear();
  me->GetMotionMaster()->MoveIdle();
  }
  break;
  }
  case FOLLOW_MOTION_TYPE:
  {
  // If data is owner's GUIDLow then we've reached follow point,
  // otherwise we're probably chasing a creature
  if (me->GetCharmerOrOwner() && me->GetCharmInfo() && data == me->GetCharmerOrOwner()->GetGUID().GetCounter() && me->GetCharmInfo()->IsReturning())
  {
  ClearCharmInfoFlags();
  me->GetCharmInfo()->SetIsFollowing(true);
  }
  break;
  }
  default:
  break;
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::OwnerAttacked ( Unit * target )

overridevirtual

Reimplemented from CreatureAI.

 {
  // Called when owner attacks something. Allows defensive pets to know
  // that they need to assist
 
  // Target might be NULL if called from spell with invalid cast targets
  if (!target)
  return;
 
  // Passive pets don't do anything
  if (me->HasReactState(REACT_PASSIVE))
  return;
 
  // Prevent pet from disengaging from current target
  if (me->GetVictim() && me->EnsureVictim()->IsAlive())
  return;
 
  // Continue to evaluate and attack if necessary
  AttackStart(target);
 }

Here is the call graph for this function:

void PetAI::OwnerAttackedBy ( Unit * attacker )

overridevirtual

Reimplemented from CreatureAI.

 {
  // Called when owner takes damage. This function helps keep pets from running off
  // simply due to owner gaining aggro.
 
  if (!attacker)
  return;
 
  // Passive pets don't do anything
  if (me->HasReactState(REACT_PASSIVE))
  return;
 
  // Prevent pet from disengaging from current target
  if (me->GetVictim() && me->EnsureVictim()->IsAlive())
  return;
 
  // Continue to evaluate and attack if necessary
  AttackStart(attacker);
 }

Here is the call graph for this function:

int PetAI::Permissible ( const Creature * creature )

static

 {
  if (creature->IsPet())
  return PERMIT_BASE_SPECIAL;
 
  return PERMIT_BASE_NO;
 }

Here is the call graph for this function:

void PetAI::ReceiveEmote	(	Player *	player,
		uint32	textEmote
	)

overridevirtual

Reimplemented from CreatureAI.

 {
  if (!me->GetOwnerGUID().IsEmpty() && me->GetOwnerGUID() == player->GetGUID())
  {
  switch (emote)
  {
  case TEXT_EMOTE_COWER:
  if (me->IsPet() && me->ToPet()->IsPetGhoul())
  me->HandleEmoteCommand(/*EMOTE_ONESHOT_ROAR*/EMOTE_ONESHOT_OMNICAST_GHOUL);
  break;
  case TEXT_EMOTE_ANGRY:
  if (me->IsPet() && me->ToPet()->IsPetGhoul())
  me->HandleEmoteCommand(/*EMOTE_ONESHOT_COWER*/EMOTE_STATE_STUN);
  break;
  case TEXT_EMOTE_GLARE:
  if (me->IsPet() && me->ToPet()->IsPetGhoul())
  me->HandleEmoteCommand(EMOTE_STATE_STUN);
  break;
  case TEXT_EMOTE_SOOTHE:
  if (me->IsPet() && me->ToPet()->IsPetGhoul())
  me->HandleEmoteCommand(EMOTE_ONESHOT_OMNICAST_GHOUL);
  break;
  }
  }
 }

Here is the call graph for this function:

Unit * PetAI::SelectNextTarget ( bool allowAutoSelect ) const

private

 {
  // Provides next target selection after current target death.
  // This function should only be called internally by the AI
  // Targets are not evaluated here for being valid targets, that is done in _CanAttack()
  // The parameter: allowAutoSelect lets us disable aggressive pet auto targeting for certain situations
 
  // Passive pets don't do next target selection
  if (me->HasReactState(REACT_PASSIVE))
  return NULL;
 
  // Check pet attackers first so we don't drag a bunch of targets to the owner
  if (Unit* myAttacker = me->getAttackerForHelper())
  if (!myAttacker->HasBreakableByDamageCrowdControlAura())
  return myAttacker;
 
  // Not sure why we wouldn't have an owner but just in case...
  if (!me->GetCharmerOrOwner())
  return NULL;
 
  // Check owner attackers
  if (Unit* ownerAttacker = me->GetCharmerOrOwner()->getAttackerForHelper())
  if (!ownerAttacker->HasBreakableByDamageCrowdControlAura())
  return ownerAttacker;
 
  // Check owner victim
  // 3.0.2 - Pets now start attacking their owners victim in defensive mode as soon as the hunter does
  if (Unit* ownerVictim = me->GetCharmerOrOwner()->GetVictim())
  return ownerVictim;
 
  // Neither pet or owner had a target and aggressive pets can pick any target
  // To prevent aggressive pets from chain selecting targets and running off, we
  // only select a random target if certain conditions are met.
  if (me->HasReactState(REACT_AGGRESSIVE) && allowAutoSelect)
  {
  if (!me->GetCharmInfo()->IsReturning() || me->GetCharmInfo()->IsFollowing() || me->GetCharmInfo()->IsAtStay())
  if (Unit* nearTarget = me->SelectNearestHostileUnitInAggroRange(true))
  return nearTarget;
  }
 
  // Default - no valid targets
  return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::UpdateAI ( uint32 diff )

overridevirtual

Implements UnitAI.

Reimplemented in npc_egbert::npc_egbertAI, and npc_snufflenose_gopher::npc_snufflenose_gopherAI.

 {
     if (!me->IsAlive() || !me->GetCharmInfo())
         return;
 
     Unit* owner = me->GetCharmerOrOwner();
 
     if (m_updateAlliesTimer <= diff)
         // UpdateAllies self set update timer
         UpdateAllies();
     else
         m_updateAlliesTimer -= diff;
 
     if (me->GetVictim() && me->EnsureVictim()->IsAlive())
     {
         // is only necessary to stop casting, the pet must not exit combat
         if (!me->GetCurrentSpell(CURRENT_CHANNELED_SPELL) && // ignore channeled spells (Pin, Seduction)
             me->EnsureVictim()->HasBreakableByDamageCrowdControlAura(me))
         {
             me->InterruptNonMeleeSpells(false);
             return;
         }
 
         if (_needToStop())
         {
             TC_LOG_DEBUG("misc", "Pet AI stopped attacking [%s]", me->GetGUID().ToString().c_str());
             _stopAttack();
             return;
         }
 
         // Check before attacking to prevent pets from leaving stay position
         if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
         {
             if (me->GetCharmInfo()->IsCommandAttack() || (me->GetCharmInfo()->IsAtStay() && me->IsWithinMeleeRange(me->GetVictim())))
                 DoMeleeAttackIfReady();
         }
         else
             DoMeleeAttackIfReady();
     }
     else
     {
         if (me->HasReactState(REACT_AGGRESSIVE) || me->GetCharmInfo()->IsAtStay())
         {
             // Every update we need to check targets only in certain cases
             // Aggressive - Allow auto select if owner or pet don't have a target
             // Stay - Only pick from pet or owner targets / attackers so targets won't run by
             //   while chasing our owner. Don't do auto select.
             // All other cases (ie: defensive) - Targets are assigned by AttackedBy(), OwnerAttackedBy(), OwnerAttacked(), etc.
             Unit* nextTarget = SelectNextTarget(me->HasReactState(REACT_AGGRESSIVE));
 
             if (nextTarget)
                 AttackStart(nextTarget);
             else
                 HandleReturnMovement();
         }
         else
             HandleReturnMovement();
     }
 
     // Autocast (cast only in combat or persistent spells in any state)
     if (!me->HasUnitState(UNIT_STATE_CASTING))
     {
         typedef std::vector<std::pair<Unit*, Spell*> > TargetSpellList;
         TargetSpellList targetSpellStore;
 
         for (uint8 i = 0; i < me->GetPetAutoSpellSize(); ++i)
         {
             uint32 spellID = me->GetPetAutoSpellOnPos(i);
             if (!spellID)
                 continue;
 
             SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellID);
             if (!spellInfo)
                 continue;
 
             if (me->GetCharmInfo() && me->GetSpellHistory()->HasGlobalCooldown(spellInfo))
                 continue;
     
             // check spell cooldown
             if (!me->GetSpellHistory()->IsReady(spellInfo))
                 continue;
 
             if (spellInfo->IsPositive())
             {
                 if (spellInfo->CanBeUsedInCombat())
                 {
                     // Check if we're in combat or commanded to attack
                     if (!me->IsInCombat() && !me->GetCharmInfo()->IsCommandAttack())
                         continue;
                 }
 
                 Spell* spell = new Spell(me, spellInfo, TRIGGERED_NONE);
                 bool spellUsed = false;
 
                 // Some spells can target enemy or friendly (DK Ghoul's Leap)
                 // Check for enemy first (pet then owner)
                 Unit* target = me->getAttackerForHelper();
                 if (!target && owner)
                     target = owner->getAttackerForHelper();
 
                 if (target)
                 {
                     if (CanAttack(target) && spell->CanAutoCast(target))
                     {
                         targetSpellStore.push_back(std::make_pair(target, spell));
                         spellUsed = true;
                     }
                 }
 
                 if (spellInfo->HasEffect(DIFFICULTY_NONE, SPELL_EFFECT_JUMP_DEST))
                 {
                     if (!spellUsed)
                         delete spell;
                     continue; // Pets must only jump to target
                 }
 
                 // No enemy, check friendly
                 if (!spellUsed)
                 {
                     for (GuidSet::const_iterator tar = m_AllySet.begin(); tar != m_AllySet.end(); ++tar)
                     {
                         Unit* ally = ObjectAccessor::GetUnit(*me, *tar);
 
                         //only buff targets that are in combat, unless the spell can only be cast while out of combat
                         if (!ally)
                             continue;
 
                         if (spell->CanAutoCast(ally))
                         {
                             targetSpellStore.push_back(std::make_pair(ally, spell));
                             spellUsed = true;
                             break;
                         }
                     }
                 }
 
                 // No valid targets at all
                 if (!spellUsed)
                     delete spell;
             }
             else if (me->GetVictim() && CanAttack(me->GetVictim()) && spellInfo->CanBeUsedInCombat())
             {
                 Spell* spell = new Spell(me, spellInfo, TRIGGERED_NONE);
                 if (spell->CanAutoCast(me->GetVictim()))
                     targetSpellStore.push_back(std::make_pair(me->GetVictim(), spell));
                 else
                     delete spell;
             }
         }
 
         //found units to cast on to
         if (!targetSpellStore.empty())
         {
             uint32 index = urand(0, targetSpellStore.size() - 1);
 
             Spell* spell  = targetSpellStore[index].second;
             Unit*  target = targetSpellStore[index].first;
 
             targetSpellStore.erase(targetSpellStore.begin() + index);
 
             SpellCastTargets targets;
             targets.SetUnitTarget(target);
 
             if (!me->HasInArc(float(M_PI), target))
             {
                 me->SetInFront(target);
                 if (target && target->GetTypeId() == TYPEID_PLAYER)
                     me->SendUpdateToPlayer(target->ToPlayer());
 
                 if (owner && owner->GetTypeId() == TYPEID_PLAYER)
                     me->SendUpdateToPlayer(owner->ToPlayer());
             }
 
             spell->prepare(&targets);
         }
 
         // deleted cached Spell objects
         for (TargetSpellList::const_iterator itr = targetSpellStore.begin(); itr != targetSpellStore.end(); ++itr)
             delete itr->second;
     }
 
     // Update speed as needed to prevent dropping too far behind and despawning
     me->UpdateSpeed(MOVE_RUN, true);
     me->UpdateSpeed(MOVE_WALK, true);
     me->UpdateSpeed(MOVE_FLIGHT, true);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PetAI::UpdateAllies ( )

private

 {
     m_updateAlliesTimer = 10 * IN_MILLISECONDS;                 // update friendly targets every 10 seconds, lesser checks increase performance
 
     Unit* owner = me->GetCharmerOrOwner();
     if (!owner)
         return;
 
     Group* group = NULL;
     if (Player* player = owner->ToPlayer())
         group = player->GetGroup();
 
     //only pet and owner/not in group->ok
     if (m_AllySet.size() == 2 && !group)
         return;
 
     //owner is in group; group members filled in already (no raid -> subgroupcount = whole count)
     if (group && !group->isRaidGroup() && m_AllySet.size() == (group->GetMembersCount() + 2))
         return;
 
     m_AllySet.clear();
     m_AllySet.insert(me->GetGUID());
     if (group)                                              //add group
     {
         for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
         {
             Player* Target = itr->GetSource();
             if (!Target || !group->SameSubGroup(owner->ToPlayer(), Target))
                 continue;
 
             if (Target->GetGUID() == owner->GetGUID())
                 continue;
 
             m_AllySet.insert(Target->GetGUID());
         }
     }
     else                                                    //remove group
         m_AllySet.insert(owner->GetGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

TimeTracker PetAI::i_tracker

private

GuidSet PetAI::m_AllySet

private

uint32 PetAI::m_updateAlliesTimer

private

The documentation for this class was generated from the following files:

src/server/game/AI/CoreAI/PetAI.h
src/server/game/AI/CoreAI/PetAI.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation