#include "PetAI.h"

Inheritance diagram for PetAI:

Public Member Functions
	PetAI (Creature *c)

void	UpdateAI (uint32) override
	Use to start attacking a target. Called just before JustEngagedWith()

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

void	SpellHit (Unit caster, SpellInfo const spellInfo) override

void	PetStopAttack () override

Public Member Functions inherited from CreatureAI
void	Talk (uint8 id, WorldObject const *whisperTarget=nullptr, Milliseconds delay=0ms)
	Causes the creature to talk/say the text assigned to their entry in the `creature_text` database table.

void	Talk (uint8 id, Milliseconds delay)

WorldObject *	GetSummoner () const
	Returns the summoner creature/object, if the creature is a temporary summon.

	CreatureAI (Creature *creature)

	~CreatureAI () override

bool	IsEngaged () const
	Check if creature is currently engaged in combat.

void	MoveCircleChecks ()

void	MoveBackwardsChecks ()

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

void	TriggerAlert (Unit const *who) const

virtual bool	CanRespawn ()

void	JustEnteredCombat (Unit *who) override
	Called when the unit enters combat.

virtual void	JustStartedThreateningMe (Unit *who)

virtual void	JustEngagedWith (Unit *)
	Called for reaction when initially engaged - this happens after JustEnteredCombat.

void	EngagementStart (Unit *who)

void	EngagementOver ()

void	JustExitedCombat () override
	Called when the unit leaves combat.

virtual void	JustDied (Unit *)

virtual void	JustSummoned (Creature *)

virtual void	IsSummonedBy (WorldObject *)

virtual void	SummonedCreatureDespawn (Creature *)

virtual void	SummonedCreatureDies (Creature , Unit )

virtual void	SummonedCreatureDespawnAll ()

virtual void	SummonedCreatureEvade (Creature *)

virtual void	SpellHitTarget (Unit , SpellInfo const )

virtual void	OnSpellStart (SpellInfo const *)

virtual void	OnSpellCast (SpellInfo const *)

virtual void	OnSpellFailed (SpellInfo const *)

virtual void	OnChannelFinished (SpellInfo const *)

virtual bool	IsEscorted ()

virtual void	JustRespawned ()

virtual void	PathEndReached (uint32)

virtual void	WaypointPathStarted (uint32)
	== Waypoints system =============================

virtual void	WaypointStarted (uint32, uint32)

virtual void	WaypointReached (uint32, uint32)

virtual void	WaypointPathEnded (uint32, uint32)

void	OnCharmed (bool apply) override
	Called when unit is charmed.

virtual void	JustReachedHome ()

void	DoZoneInCombat (Creature *creature=nullptr, float maxRangeToNearestTarget=250.0f)

void	OnOwnerCombatInteraction (Unit *target)

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

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

virtual bool	BeforeSpellClick (Unit *)

virtual void	OnSpellClick (Unit *, bool &)

virtual bool	CanSeeAlways (WorldObject const *)

virtual bool	CanBeSeen (Player const *)

virtual bool	CanAlwaysBeDetectable (WorldObject const *)

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

virtual bool	CheckInRoom ()

CreatureBoundary const *	GetBoundary () const

void	SetBoundary (CreatureBoundary const *boundary, bool negativeBoundaries=false)

bool	IsInBoundary (Position const *who=nullptr) const

virtual void	CalculateThreat (Unit , float &, SpellInfo const )

virtual bool	OnTeleportUnreacheablePlayer (Player *)

virtual void	OnAuraRemove (AuraApplication *, AuraRemoveMode)

virtual void	DistancingStarted ()

virtual void	DistancingEnded ()

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 const &, int32=0)

virtual ObjectGuid	GetGUID (int32=0) const

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

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

void	SelectTargetList (std::list< Unit * > &targetList, uint32 num, SelectTargetMethod targetType, uint32 position=0, float dist=0.0f, bool playerOnly=false, bool withTank=true, int32 aura=0)
	Select the best (up to) <num> targets (in <targetType> order) from the threat list that fulfill the following:

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

virtual void	EvadeTimerExpired ()
	Called when evade timer expires (target unreachable for too long)

virtual void	DamageDealt (Unit *, uint32 &, DamageEffectType, SpellSchoolMask)
	Called at any Damage to any victim (before damage apply)

virtual void	DamageTaken (Unit *, uint32 &, DamageEffectType, SpellSchoolMask)
	Called at any Damage from any attacker (before damage apply)

virtual void	HealReceived (Unit *, uint32 &)
	Called when the creature receives heal.

virtual void	OnPowerUpdate (Powers, int32, int32, uint32)
	Called when the creature power updates.

virtual void	HealDone (Unit *, uint32 &)
	Called when the unit heals.

virtual void	OnCalculateMeleeDamageReceived (uint32 &, Unit *)
	Called during damage calculations.

virtual void	OnCalculateSpellDamageReceived (int32 &, Unit *)

virtual void	OnCalculatePeriodicTickReceived (uint32 &, Unit *)
	Called during calculation when receiving periodic healing or damage (DoT or HoT)

void	AttackStartCaster (Unit *victim, float dist)

SpellCastResult	DoAddAuraToAllHostilePlayers (uint32 spellid)

SpellCastResult	DoCast (uint32 spellId)

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

SpellCastResult	DoCastSelf (uint32 spellId, bool triggered=false)

SpellCastResult	DoCastToAllHostilePlayers (uint32 spellid, bool triggered=false)
	To specify the caster as target if the spell is self-cast.

SpellCastResult	DoCastVictim (uint32 spellId, bool triggered=false)

SpellCastResult	DoCastAOE (uint32 spellId, bool triggered=false)

SpellCastResult	DoCastRandomTarget (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false, bool withTank=true)
	Cast the spell on a random unit from the threat list.

SpellCastResult	DoCastMaxThreat (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false)
	Cast spell on the top threat target, which may not be the current victim.

float	DoGetSpellMaxRange (uint32 spellId, bool positive=false)

void	DoMeleeAttackIfReady ()

bool	DoSpellAttackIfReady (uint32 spell)

void	DoSpellAttackToRandomTargetIfReady (uint32 spell, uint32 threatTablePosition=0, float dist=0.f, bool playerOnly=true)

virtual void	SummonMovementInform (Creature *, uint32, uint32)
	Called when a summon reaches a waypoint or point movement finished.

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	sQuestComplete (Player , Quest const )

virtual void	sQuestReward (Player , Quest const , uint32)

virtual void	sOnGameEvent (bool, uint16)

virtual std::string	GetDebugInfo () const

Static Public Member Functions
static int32	Permissible (Creature const *creature)

Static Public Member Functions inherited from CreatureAI
static bool	IsInBounds (CreatureBoundary const &boundary, Position const *who)

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

Private Member Functions
bool	_isVisible (Unit *) const

bool	_needToStop (void)

void	_stopAttack (void)

void	_doMeleeAttack ()

bool	_canMeleeAttack ()

void	UpdateAllies ()

Unit *	SelectNextTarget (bool allowAutoSelect) const

void	HandleReturnMovement ()

void	DoAttack (Unit *target, bool chase)

bool	CanAttack (Unit target, SpellInfo const spellInfo=nullptr)

void	ClearCharmInfoFlags ()

Private Attributes
TimeTracker	i_tracker

GuidSet	m_AllySet

uint32	m_updateAlliesTimer

float	combatRange

Additional Inherited Members
Public Types inherited from CreatureAI
enum	EvadeReason { EVADE_REASON_NO_HOSTILES , EVADE_REASON_BOUNDARY , EVADE_REASON_SEQUENCE_BREAK , EVADE_REASON_NO_PATH , 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	_EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

Protected Attributes inherited from CreatureAI
Creature *const	me

EventMap	events

TaskScheduler	scheduler

CreatureBoundary const *	_boundary

bool	_negateBoundary

bool	_isEngaged

Protected Attributes inherited from UnitAI
Unit *const	me

Detailed Description

Constructor & Destructor Documentation

◆ PetAI()

PetAI::PetAI ( Creature * c )

explicit

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

References UpdateAllies().

Member Function Documentation

◆ _canMeleeAttack()

bool PetAI::_canMeleeAttack ( )

private

{
    combatRange = 0.f;
    switch (me->GetEntry())
    {
        case ENTRY_IMP:
        case ENTRY_WATER_ELEMENTAL:
        case ENTRY_WATER_ELEMENTAL_PERM:
            {
                for (uint8 i = 0; i < me->GetPetAutoSpellSize(); ++i)
                {
                    uint32 spellID = me->GetPetAutoSpellOnPos(i);
                    switch (spellID)
                    {
                        case IMP_FIREBOLT_RANK_1:
                        case IMP_FIREBOLT_RANK_2:
                        case IMP_FIREBOLT_RANK_3:
                        case IMP_FIREBOLT_RANK_4:
                        case IMP_FIREBOLT_RANK_5:
                        case IMP_FIREBOLT_RANK_6:
                        case IMP_FIREBOLT_RANK_7:
                        case IMP_FIREBOLT_RANK_8:
                        case IMP_FIREBOLT_RANK_9:
                        case WATER_ELEMENTAL_WATERBOLT_1:
                        case WATER_ELEMENTAL_WATERBOLT_2:
                            {
                                SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellID);
                                int32 mana = me->GetPower(POWER_MANA);
 
                                if (mana >= spellInfo->CalcPowerCost(me, spellInfo->GetSchoolMask()))
                                {
                                    combatRange = spellInfo->GetMaxRange();
                                    return true;
                                }
                            }
                        default:
                            break;
                    }
                }
                return false;
            }
        default:
            break;
    }
 
    return true;
}

References SpellInfo::CalcPowerCost(), combatRange, ENTRY_IMP, ENTRY_WATER_ELEMENTAL, ENTRY_WATER_ELEMENTAL_PERM, Object::GetEntry(), SpellInfo::GetMaxRange(), Creature::GetPetAutoSpellOnPos(), Creature::GetPetAutoSpellSize(), Unit::GetPower(), SpellInfo::GetSchoolMask(), IMP_FIREBOLT_RANK_1, IMP_FIREBOLT_RANK_2, IMP_FIREBOLT_RANK_3, IMP_FIREBOLT_RANK_4, IMP_FIREBOLT_RANK_5, IMP_FIREBOLT_RANK_6, IMP_FIREBOLT_RANK_7, IMP_FIREBOLT_RANK_8, IMP_FIREBOLT_RANK_9, CreatureAI::me, POWER_MANA, sSpellMgr, WATER_ELEMENTAL_WATERBOLT_1, and WATER_ELEMENTAL_WATERBOLT_2.

Referenced by _doMeleeAttack(), and DoAttack().

◆ _doMeleeAttack()

void PetAI::_doMeleeAttack ( )

private

{
    // Xinef: Imps cannot attack with melee
    if (!_canMeleeAttack())
        return;
 
    DoMeleeAttackIfReady();
}

References _canMeleeAttack(), and UnitAI::DoMeleeAttackIfReady().

Referenced by UpdateAI().

◆ _isVisible()

bool PetAI::_isVisible ( Unit * ) const

private

◆ _needToStop()

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;
 
    // xinef: dont allow to follow targets out of visibility range
    if (me->GetExactDist(me->GetVictim()) > me->GetVisibilityRange() - 5.0f)
        return true;
 
    // dont allow pets to follow targets far away from owner
    if (Unit* owner = me->GetCharmerOrOwner())
        if (owner->GetExactDist(me) >= (owner->GetVisibilityRange() - 10.0f))
            return true;
 
    return !me->CanCreatureAttack(me->GetVictim());
}

References Creature::CanCreatureAttack(), Unit::GetCharmer(), Unit::GetCharmerOrOwner(), Position::GetExactDist(), Unit::GetVictim(), WorldObject::GetVisibilityRange(), Unit::IsCharmed(), and CreatureAI::me.

Referenced by UpdateAI().

◆ _stopAttack()

void PetAI::_stopAttack ( void )

private

{
    if (!me->IsAlive())
    {
        LOG_DEBUG("entities.unit.ai", "Creature stoped attacking cuz his dead [{}]", me->GetGUID().ToString());
        me->GetMotionMaster()->Clear();
        me->GetMotionMaster()->MoveIdle();
        me->CombatStop();
        me->GetThreatMgr().RemoveMeFromThreatLists();
        return;
    }
 
    me->AttackStop();
    me->InterruptNonMeleeSpells(false);
    me->GetCharmInfo()->SetIsCommandAttack(false);
    ClearCharmInfoFlags();
    HandleReturnMovement();
}

References Unit::AttackStop(), MotionMaster::Clear(), ClearCharmInfoFlags(), Unit::CombatStop(), Unit::GetCharmInfo(), Object::GetGUID(), Unit::GetMotionMaster(), Unit::GetThreatMgr(), HandleReturnMovement(), Unit::InterruptNonMeleeSpells(), Unit::IsAlive(), LOG_DEBUG, CreatureAI::me, MotionMaster::MoveIdle(), ThreatManager::RemoveMeFromThreatLists(), CharmInfo::SetIsCommandAttack(), and ObjectGuid::ToString().

Referenced by PetStopAttack(), and UpdateAI().

◆ AttackedBy()

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->GetVictim()->IsAlive())
        return;
 
    // Continue to evaluate and attack if necessary
    AttackStart(attacker);
}

References AttackStart(), Unit::GetVictim(), Creature::HasReactState(), Unit::IsAlive(), CreatureAI::me, and REACT_PASSIVE.

◆ AttackStart()

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()));
}

References CanAttack(), COMMAND_STAY, DoAttack(), Unit::GetCharmInfo(), CharmInfo::HasCommandState(), CharmInfo::IsCommandAttack(), and CreatureAI::me.

Referenced by AttackedBy(), KilledUnit(), OwnerAttacked(), OwnerAttackedBy(), and UpdateAI().

◆ CanAttack()

bool PetAI::CanAttack	(	Unit *	target,
		SpellInfo const *	spellInfo = `nullptr`
	)

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())
    {
        // xinef: if target is invalid, pet should evade automaticly
        // Clear target to prevent getting stuck on dead targets
        //me->AttackStop();
        //me->InterruptNonMeleeSpells(false);
        return false;
    }
 
    // xinef: check unit states of pet
    if (me->HasUnitState(UNIT_STATE_LOST_CONTROL))
        return false;
 
    // xinef: pets of mounted players have stunned flag only, check this also
    if (me->HasUnitFlag(UNIT_FLAG_STUNNED))
        return false;
 
    // pussywizard: TEMP!
    if (!me->GetCharmInfo())
    {
        LOG_INFO("misc", "PetAI::CanAttack (A1) - {}, {}", me->GetEntry(), me->GetOwnerGUID().ToString());
        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() && (!spellInfo || !spellInfo->HasAttribute(SPELL_ATTR4_DAMAGE_DOESNT_BREAK_AURAS)))
        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)
    {
        // Forced change target if it's taunt
        if (spellInfo && spellInfo->HasAura(SPELL_AURA_MOD_TAUNT))
        {
            return true;
        }
 
        // Check if our owner selected this target and clicked "attack"
        Unit* ownerTarget = nullptr;
        Unit* charmerOrOwner = me->GetCharmerOrOwner();
 
        if (charmerOrOwner)
        {
            if (Player* owner = charmerOrOwner->ToPlayer())
                ownerTarget = owner->GetSelectedUnit();
            else
                ownerTarget = charmerOrOwner->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;
}

References COMMAND_FOLLOW, COMMAND_STAY, Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), Object::GetEntry(), Object::GetGUID(), Unit::GetOwnerGUID(), Unit::GetVictim(), SpellInfo::HasAttribute(), SpellInfo::HasAura(), Unit::HasBreakableByDamageCrowdControlAura(), CharmInfo::HasCommandState(), Creature::HasReactState(), Unit::HasUnitFlag(), Unit::HasUnitState(), Unit::IsAlive(), CharmInfo::IsCommandAttack(), CharmInfo::IsCommandFollow(), CharmInfo::IsReturning(), Unit::IsWithinMeleeRange(), LOG_INFO, CreatureAI::me, REACT_PASSIVE, SPELL_ATTR4_DAMAGE_DOESNT_BREAK_AURAS, SPELL_AURA_MOD_TAUNT, Object::ToPlayer(), ObjectGuid::ToString(), UNIT_FLAG_STUNNED, and UNIT_STATE_LOST_CONTROL.

Referenced by AttackStart(), SpellHit(), and UpdateAI().

◆ ClearCharmInfoFlags()

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);
    }
}

References Unit::GetCharmInfo(), CreatureAI::me, CharmInfo::SetIsAtStay(), CharmInfo::SetIsCommandAttack(), CharmInfo::SetIsCommandFollow(), CharmInfo::SetIsFollowing(), and CharmInfo::SetIsReturning().

Referenced by _stopAttack(), DoAttack(), HandleReturnMovement(), and MovementInform().

◆ DoAttack()

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))
    {
        // xinef: properly fix fake combat after pet is sent to attack
        if (Unit* owner = me->GetOwner())
            owner->SetUnitFlag(UNIT_FLAG_PET_IN_COMBAT);
 
        me->SetUnitFlag(UNIT_FLAG_PET_IN_COMBAT);
 
        // 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
 
            if (_canMeleeAttack())
            {
                std::optional<ChaseAngle> chaseAngle;
                if (combatRange == 0.f && !target->IsPlayer() && !target->IsPet())
                    chaseAngle.emplace(float(M_PI), float(M_PI_4));
 
                me->GetMotionMaster()->MoveChase(target, ChaseRange(0.f, combatRange), chaseAngle);
            }
        }
        else // (Stay && ((Aggressive || Defensive) && In Melee Range)))
        {
            ClearCharmInfoFlags();
 
            me->GetCharmInfo()->SetIsAtStay(true);
            me->GetMotionMaster()->MovementExpiredOnSlot(MOTION_SLOT_ACTIVE, false);
            me->GetMotionMaster()->MoveIdle();
        }
    }
}

References _canMeleeAttack(), Unit::Attack(), ClearCharmInfoFlags(), combatRange, Unit::GetCharmInfo(), Object::GetGUID(), Unit::GetMotionMaster(), Unit::GetOwner(), Creature::HasReactState(), CharmInfo::IsCommandAttack(), Unit::IsPet(), Object::IsPlayer(), CreatureAI::me, MOTION_SLOT_ACTIVE, MotionMaster::MoveChase(), MotionMaster::MoveIdle(), MotionMaster::MovementExpiredOnSlot(), REACT_AGGRESSIVE, Unit::SendPetAIReaction(), CharmInfo::SetIsAtStay(), CharmInfo::SetIsCommandAttack(), Unit::SetUnitFlag(), and UNIT_FLAG_PET_IN_COMBAT.

Referenced by AttackStart(), and SpellHit().

◆ EnterEvadeMode()

void PetAI::EnterEvadeMode ( EvadeReason )

inlineoverridevirtual

Reimplemented from CreatureAI.

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

◆ HandleReturnMovement()

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->isPossessed())
        return;
 
    if (me->GetCharmInfo()->HasCommandState(COMMAND_STAY))
    {
        if (!me->GetCharmInfo()->IsAtStay() && !me->GetCharmInfo()->IsReturning())
        {
            if (me->GetCharmInfo()->HasStayPosition())
            {
                // Return to previous position where stay was clicked
                if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == NULL_MOTION_TYPE)
                {
                    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())
        {
            if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == NULL_MOTION_TYPE)
            {
                ClearCharmInfoFlags();
                me->GetCharmInfo()->SetIsReturning(true);
                me->GetMotionMaster()->Clear();
                me->GetMotionMaster()->MoveFollow(me->GetCharmerOrOwner(), PET_FOLLOW_DIST, me->GetFollowAngle());
            }
        }
    }
 
    me->GetCharmInfo()->SetForcedSpell(0);
    me->GetCharmInfo()->SetForcedTargetGUID();
 
    // xinef: remember that npcs summoned by npcs can also be pets
    me->GetThreatMgr().ClearAllThreat();
    me->ClearInPetCombat();
}

References MotionMaster::Clear(), ThreatManager::ClearAllThreat(), ClearCharmInfoFlags(), Unit::ClearInPetCombat(), COMMAND_STAY, Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), ObjectGuid::GetCounter(), Unit::GetFollowAngle(), Object::GetGUID(), Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), CharmInfo::GetStayPosition(), Unit::GetThreatMgr(), CharmInfo::HasCommandState(), CharmInfo::HasStayPosition(), CharmInfo::IsAtStay(), CharmInfo::IsFollowing(), Unit::isPossessed(), CharmInfo::IsReturning(), CreatureAI::me, MOTION_SLOT_CONTROLLED, MotionMaster::MoveFollow(), MotionMaster::MovePoint(), NULL_MOTION_TYPE, PET_FOLLOW_DIST, CharmInfo::SetForcedSpell(), CharmInfo::SetForcedTargetGUID(), and CharmInfo::SetIsReturning().

Referenced by _stopAttack(), KilledUnit(), and UpdateAI().

◆ KilledUnit()

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;
 
    // Xinef: if pet is channeling a spell and owner killed something different, dont interrupt it
    if (me->HasUnitState(UNIT_STATE_CASTING) && me->GetGuidValue(UNIT_FIELD_CHANNEL_OBJECT) && me->GetGuidValue(UNIT_FIELD_CHANNEL_OBJECT) != victim->GetGUID())
        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);
 
    // Before returning to owner, see if there are more things to attack
    if (Unit* nextTarget = SelectNextTarget(false))
        AttackStart(nextTarget);
    else
        HandleReturnMovement(); // Return
}

References AttackStart(), Unit::AttackStop(), Object::GetGUID(), Object::GetGuidValue(), Unit::GetVictim(), HandleReturnMovement(), Unit::HasUnitState(), Unit::InterruptNonMeleeSpells(), CreatureAI::me, SelectNextTarget(), UNIT_FIELD_CHANNEL_OBJECT, and UNIT_STATE_CASTING.

◆ MoveInLineOfSight()

void PetAI::MoveInLineOfSight ( Unit * )

inlineoverridevirtual

Reimplemented from CreatureAI.

65{} // CreatureAI interferes with returning pets

◆ MoveInLineOfSight_Safe()

void PetAI::MoveInLineOfSight_Safe ( Unit * )

inline

66{} // CreatureAI interferes with returning pets

◆ MovementInform()

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

overridevirtual

Reimplemented from CreatureAI.

{
    // 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;
    }
}

References MotionMaster::Clear(), ClearCharmInfoFlags(), FOLLOW_MOTION_TYPE, Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), ObjectGuid::GetCounter(), Object::GetGUID(), Unit::GetMotionMaster(), CharmInfo::IsReturning(), CreatureAI::me, MotionMaster::MoveIdle(), POINT_MOTION_TYPE, CharmInfo::SetIsAtStay(), and CharmInfo::SetIsFollowing().

◆ OwnerAttacked()

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 nullptr 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->GetVictim()->IsAlive())
        return;
 
    // Continue to evaluate and attack if necessary
    AttackStart(target);
}

References AttackStart(), Unit::GetVictim(), Creature::HasReactState(), Unit::IsAlive(), CreatureAI::me, and REACT_PASSIVE.

◆ OwnerAttackedBy()

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->GetVictim()->IsAlive())
        return;
 
    // Continue to evaluate and attack if necessary
    AttackStart(attacker);
}

References AttackStart(), Unit::GetVictim(), Creature::HasReactState(), Unit::IsAlive(), CreatureAI::me, and REACT_PASSIVE.

◆ Permissible()

int32 PetAI::Permissible ( Creature const * creature )

static

{
    if (creature->HasUnitTypeMask(UNIT_MASK_CONTROLLABLE_GUARDIAN))
    {
        if (reinterpret_cast<Guardian const*>(creature)->GetOwner()->IsPlayer())
            return PERMIT_BASE_PROACTIVE;
        return PERMIT_BASE_REACTIVE;
    }
 
    return PERMIT_BASE_NO;
}

References Unit::HasUnitTypeMask(), PERMIT_BASE_NO, PERMIT_BASE_PROACTIVE, PERMIT_BASE_REACTIVE, and UNIT_MASK_CONTROLLABLE_GUARDIAN.

◆ PetStopAttack()

void PetAI::PetStopAttack ( )

overridevirtual

Reimplemented from CreatureAI.

{
    _stopAttack();
}

References _stopAttack().

◆ ReceiveEmote()

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

overridevirtual

Reimplemented from CreatureAI.

{
    if (me->GetOwnerGUID() && 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;
        }
}

References EMOTE_ONESHOT_OMNICAST_GHOUL, EMOTE_STATE_STUN, Object::GetGUID(), Unit::GetOwnerGUID(), Unit::HandleEmoteCommand(), Unit::IsPet(), Minion::IsPetGhoul(), CreatureAI::me, TEXT_EMOTE_ANGRY, TEXT_EMOTE_COWER, TEXT_EMOTE_GLARE, TEXT_EMOTE_SOOTHE, and Unit::ToPet().

◆ SelectNextTarget()

Unit * PetAI::SelectNextTarget ( bool allowAutoSelect ) const

private

Todo:: : try for another target

{
    // 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 nullptr;
 
    // Check pet attackers first so we don't drag a bunch of targets to the owner
    if (Unit* myAttacker = me->getAttackerForHelper())
        if (!myAttacker->HasBreakableByDamageCrowdControlAura() && me->CanCreatureAttack(myAttacker))
            return myAttacker;
 
    // Check pet's attackers first to prevent dragging mobs back to owner
    if (me->HasTauntAura())
    {
        const Unit::AuraEffectList& tauntAuras = me->GetAuraEffectsByType(SPELL_AURA_MOD_TAUNT);
        if (!tauntAuras.empty())
            for (Unit::AuraEffectList::const_reverse_iterator itr = tauntAuras.rbegin(); itr != tauntAuras.rend(); ++itr)
                if (Unit* caster = (*itr)->GetCaster())
                    if (me->CanCreatureAttack(caster) && !caster->HasAuraTypeWithCaster(SPELL_AURA_MOD_DETAUNT, me->GetGUID()))
                        return caster;
    }
 
    // Not sure why we wouldn't have an owner but just in case...
    Unit* owner = me->GetCharmerOrOwner();
    if (!owner)
        return nullptr;
 
    // Check owner attackers
    if (Unit* ownerAttacker = owner->getAttackerForHelper())
        if (!ownerAttacker->HasBreakableByDamageCrowdControlAura() && me->CanCreatureAttack(ownerAttacker))
            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 = owner->GetVictim())
        if (me->CanCreatureAttack(ownerVictim))
            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 (allowAutoSelect)
    {
        if (!me->GetCharmInfo()->IsReturning() || me->GetCharmInfo()->IsFollowing() || me->GetCharmInfo()->IsAtStay())
        {
            if (Unit* nearTarget = me->ToCreature()->SelectNearestTargetInAttackDistance(MAX_AGGRO_RADIUS))
            {
                if (nearTarget->IsPlayer() && nearTarget->ToPlayer()->IsPvP() && !owner->IsPvP()) // If owner is not PvP flagged and target is PvP flagged, do not attack
                {
                    return nullptr; 
                }
                else
                {
                    return nearTarget;
                }
            }
        }
    }
 
    // Default - no valid targets
    return nullptr;
}

References Creature::CanCreatureAttack(), Unit::getAttackerForHelper(), Unit::GetAuraEffectsByType(), Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), Object::GetGUID(), Unit::GetVictim(), Creature::HasReactState(), Unit::HasTauntAura(), CharmInfo::IsAtStay(), CharmInfo::IsFollowing(), Unit::IsPvP(), CharmInfo::IsReturning(), MAX_AGGRO_RADIUS, CreatureAI::me, REACT_PASSIVE, Creature::SelectNearestTargetInAttackDistance(), SPELL_AURA_MOD_DETAUNT, SPELL_AURA_MOD_TAUNT, and Object::ToCreature().

Referenced by KilledUnit(), and UpdateAI().

◆ SpellHit()

void PetAI::SpellHit	(	Unit *	caster,
		SpellInfo const *	spellInfo
	)

overridevirtual

Reimplemented from CreatureAI.

{
    // Xinef: taunt behavior code
    if (spellInfo->HasAura(SPELL_AURA_MOD_TAUNT) && !me->HasReactState(REACT_PASSIVE))
    {
        me->GetCharmInfo()->SetForcedSpell(0);
        me->GetCharmInfo()->SetForcedTargetGUID();
 
        if (CanAttack(caster, spellInfo))
        {
            // Only chase if not commanded to stay or if stay but commanded to attack
            DoAttack(caster, (!me->GetCharmInfo()->HasCommandState(COMMAND_STAY) || me->GetCharmInfo()->IsCommandAttack()));
        }
    }
}

References CanAttack(), COMMAND_STAY, DoAttack(), Unit::GetCharmInfo(), SpellInfo::HasAura(), CharmInfo::HasCommandState(), Creature::HasReactState(), CharmInfo::IsCommandAttack(), CreatureAI::me, REACT_PASSIVE, CharmInfo::SetForcedSpell(), CharmInfo::SetForcedTargetGUID(), and SPELL_AURA_MOD_TAUNT.

◆ UpdateAI()

void PetAI::UpdateAI ( uint32 )

overridevirtual

Use to start attacking a target. Called just before JustEngagedWith()

Implements UnitAI.

{
    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->GetVictim()->IsAlive())
    {
        // is only necessary to stop casting, the pet must not exit combat
        if (me->GetVictim()->HasBreakableByDamageCrowdControlAura(me))
        {
            me->InterruptNonMeleeSpells(false);
            return;
        }
 
        if (_needToStop())
        {
            LOG_DEBUG("entities.unit.ai", "Pet AI stopped attacking [{}]", me->GetGUID().ToString());
            _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())))
                _doMeleeAttack();
        }
        else
            _doMeleeAttack();
    }
    else if (!me->GetCharmInfo() || (!me->GetCharmInfo()->GetForcedSpell() && !(me->IsPet() && me->ToPet()->HasTempSpell()) && !me->HasUnitState(UNIT_STATE_CASTING)))
    {
        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();
    }
 
    // xinef: charm info must be always available
    if (!me->GetCharmInfo())
        return;
 
    // Autocast (casted only in combat or persistent spells in any state)
    if (!me->HasUnitState(UNIT_STATE_CASTING))
    {
        if (owner && owner->IsPlayer() && me->GetCharmInfo()->GetForcedSpell() && me->GetCharmInfo()->GetForcedTarget())
        {
            owner->ToPlayer()->GetSession()->HandlePetActionHelper(me, me->GetGUID(), std::abs(me->GetCharmInfo()->GetForcedSpell()), ACT_ENABLED, me->GetCharmInfo()->GetForcedTarget());
 
            // xinef: if spell was casted properly and we are in passive mode, handle return
            if (!me->GetCharmInfo()->GetForcedSpell() && me->HasReactState(REACT_PASSIVE))
            {
                if (me->HasUnitState(UNIT_STATE_CASTING))
                {
                    me->GetMotionMaster()->Clear(false);
                    me->StopMoving();
                }
                else
                    _stopAttack();
            }
            return;
        }
 
        // xinef: dont allow ghouls to cast spells below 75 energy
        if (me->IsPet() && me->ToPet()->IsPetGhoul() && me->GetPower(POWER_ENERGY) < 75)
            return;
 
        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()->GetGlobalCooldownMgr().HasGlobalCooldown(spellInfo))
                continue;
 
            // check spell cooldown, this should be checked in CheckCast...
            if (me->HasSpellCooldown(spellInfo->Id))
                continue;
 
            if (spellInfo->IsPositive())
            {
                if (spellInfo->CanBeUsedInCombat())
                {
                    // Check if we're in combat or commanded to attack (exlude auras with infinity duration)
                    if (!me->IsInCombat() && spellInfo->GetMaxDuration() != -1 && !me->IsPetInCombat())
                    {
                        continue;
                    }
                }
 
                Spell* spell = new Spell(me, spellInfo, TRIGGERED_NONE);
                spell->LoadScripts(); // xinef: load for CanAutoCast (calling CheckPetCast)
                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.emplace_back(target, spell);
                        spellUsed = true;
                    }
                }
 
                if (spellInfo->HasEffect(SPELL_EFFECT_JUMP_DEST))
                {
                    if (!spellUsed)
                        delete spell;
 
                    continue; // Pets must only jump to target
                }
 
                // No enemy, check friendly
                if (!spellUsed)
                {
                    for (ObjectGuid const& guid : m_AllySet)
                    {
                        Unit* ally = ObjectAccessor::GetUnit(*me, guid);
 
                        //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.emplace_back(ally, spell);
                            spellUsed = true;
                            break;
                        }
                    }
                }
 
                // No valid targets at all
                if (!spellUsed)
                    delete spell;
            }
            else if (me->GetVictim() && CanAttack(me->GetVictim(), spellInfo) && spellInfo->CanBeUsedInCombat())
            {
                Spell* spell = new Spell(me, spellInfo, TRIGGERED_NONE);
                if (spell->CanAutoCast(me->GetVictim()))
                    targetSpellStore.emplace_back(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(M_PI, target))
            {
                me->SetInFront(target);
                if (target && target->IsPlayer())
                    me->SendUpdateToPlayer(target->ToPlayer());
 
                if (owner && owner->IsPlayer())
                    me->SendUpdateToPlayer(owner->ToPlayer());
            }
 
            me->AddSpellCooldown(spell->m_spellInfo->Id, 0, 0);
 
            spell->prepare(&targets);
        }
 
        // deleted cached Spell objects
        for (TargetSpellList::const_iterator itr = targetSpellStore.begin(); itr != targetSpellStore.end(); ++itr)
            delete itr->second;
    }
}

References _doMeleeAttack(), _needToStop(), _stopAttack(), ACT_ENABLED, Creature::AddSpellCooldown(), AttackStart(), CanAttack(), Spell::CanAutoCast(), SpellInfo::CanBeUsedInCombat(), MotionMaster::Clear(), COMMAND_STAY, Unit::getAttackerForHelper(), Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), CharmInfo::GetForcedSpell(), CharmInfo::GetForcedTarget(), CharmInfo::GetGlobalCooldownMgr(), Object::GetGUID(), SpellInfo::GetMaxDuration(), Unit::GetMotionMaster(), Creature::GetPetAutoSpellOnPos(), Creature::GetPetAutoSpellSize(), Unit::GetPower(), Player::GetSession(), ObjectAccessor::GetUnit(), Unit::GetVictim(), WorldSession::HandlePetActionHelper(), HandleReturnMovement(), Unit::HasBreakableByDamageCrowdControlAura(), CharmInfo::HasCommandState(), SpellInfo::HasEffect(), GlobalCooldownMgr::HasGlobalCooldown(), Position::HasInArc(), Creature::HasReactState(), Creature::HasSpellCooldown(), Pet::HasTempSpell(), Unit::HasUnitState(), SpellInfo::Id, Unit::InterruptNonMeleeSpells(), Unit::IsAlive(), CharmInfo::IsAtStay(), CharmInfo::IsCommandAttack(), Unit::IsInCombat(), Unit::IsPet(), Minion::IsPetGhoul(), Unit::IsPetInCombat(), Object::IsPlayer(), SpellInfo::IsPositive(), Unit::IsWithinMeleeRange(), Spell::LoadScripts(), LOG_DEBUG, m_AllySet, Spell::m_spellInfo, m_updateAlliesTimer, CreatureAI::me, POWER_ENERGY, Spell::prepare(), REACT_AGGRESSIVE, REACT_PASSIVE, SelectNextTarget(), Object::SendUpdateToPlayer(), Unit::SetInFront(), SpellCastTargets::SetUnitTarget(), SPELL_EFFECT_JUMP_DEST, sSpellMgr, Unit::StopMoving(), Unit::ToPet(), Object::ToPlayer(), ObjectGuid::ToString(), TRIGGERED_NONE, UNIT_STATE_CASTING, UpdateAllies(), and urand().

◆ UpdateAllies()

void PetAI::UpdateAllies ( )

private

{
    Unit* owner = me->GetCharmerOrOwner();
    Group* group = nullptr;
 
    m_updateAlliesTimer = 10 * IN_MILLISECONDS;              //update friendly targets every 10 seconds, lesser checks increase performance
 
    if (!owner)
        return;
    else if (owner->IsPlayer())
        group = owner->ToPlayer()->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 != nullptr; itr = itr->next())
        {
            Player* Target = itr->GetSource();
            if (!Target || !Target->IsInMap(owner) || !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());
}

References Unit::GetCharmerOrOwner(), Group::GetFirstMember(), Player::GetGroup(), Object::GetGUID(), Group::GetMembersCount(), IN_MILLISECONDS, WorldObject::IsInMap(), Object::IsPlayer(), Group::isRaidGroup(), m_AllySet, m_updateAlliesTimer, CreatureAI::me, Group::SameSubGroup(), and Object::ToPlayer().

Referenced by PetAI(), and UpdateAI().

Member Data Documentation

◆ combatRange

float PetAI::combatRange

private

Referenced by _canMeleeAttack(), and DoAttack().

◆ i_tracker

TimeTracker PetAI::i_tracker

private

◆ m_AllySet

GuidSet PetAI::m_AllySet

private

Referenced by UpdateAI(), and UpdateAllies().

◆ m_updateAlliesTimer

uint32 PetAI::m_updateAlliesTimer

private

Referenced by UpdateAI(), and UpdateAllies().

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

azerothcore-wotlk/src/server/game/AI/CoreAI/PetAI.h
azerothcore-wotlk/src/server/game/AI/CoreAI/PetAI.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PetAI()

Member Function Documentation

◆ _canMeleeAttack()

◆ _doMeleeAttack()

◆ _isVisible()

◆ _needToStop()

◆ _stopAttack()

◆ AttackedBy()

◆ AttackStart()

◆ CanAttack()

◆ ClearCharmInfoFlags()

◆ DoAttack()

◆ EnterEvadeMode()

◆ HandleReturnMovement()

◆ KilledUnit()

◆ MoveInLineOfSight()

◆ MoveInLineOfSight_Safe()

◆ MovementInform()

◆ OwnerAttacked()

◆ OwnerAttackedBy()

◆ Permissible()

◆ PetStopAttack()

◆ ReceiveEmote()

◆ SelectNextTarget()

◆ SpellHit()

◆ UpdateAI()

◆ UpdateAllies()

Member Data Documentation

◆ combatRange

◆ i_tracker

◆ m_AllySet

◆ m_updateAlliesTimer