#include "ScriptedFollowerAI.h"

Inheritance diagram for FollowerAI:

Public Member Functions
	FollowerAI (Creature *creature)

	~FollowerAI () override

void	MovementInform (uint32 motionType, uint32 pointId) override

void	AttackStart (Unit *) override

void	MoveInLineOfSight (Unit *) override

void	EnterEvadeMode (EvadeReason=EVADE_REASON_OTHER) override

void	JustDied (Unit *) override

void	JustRespawned () override

void	UpdateAI (uint32) override

virtual void	UpdateFollowerAI (uint32)

void	StartFollow (Player player, uint32 factionForFollower=0, const Quest quest=nullptr)

void	SetFollowPaused (bool bPaused)

void	SetFollowComplete (bool bWithEndEvent=false)

bool	HasFollowState (uint32 uiFollowState)

Public Member Functions inherited from ScriptedAI
	ScriptedAI (Creature *creature)

	~ScriptedAI () override

void	AttackStartNoMove (Unit *target)

void	DamageTaken (Unit *, uint32 &, DamageEffectType, SpellSchoolMask) override

void	UpdateAI (uint32 diff) override

void	JustDied (Unit *) override

void	KilledUnit (Unit *) override

void	JustSummoned (Creature *) override

void	SummonedCreatureDespawn (Creature *) override

void	SpellHit (Unit , SpellInfo const ) override

void	SpellHitTarget (Unit , SpellInfo const ) override

void	MovementInform (uint32, uint32) override

void	OnPossess (bool)

bool	IsInRoom (const Position *pos, Axis axis, bool above)

void	Reset () override

void	JustEngagedWith (Unit *) override
	Called for reaction when initially engaged.

void	AttackStart (Unit *) override

void	DoStartMovement (Unit *target, float distance=0.0f, float angle=0.0f)

void	DoStartNoMovement (Unit *target)

void	DoStopAttack ()

void	DoCastSpell (Unit target, SpellInfo const spellInfo, bool triggered=false)

void	DoPlaySoundToSet (WorldObject *source, uint32 soundId)

void	DoPlayMusic (uint32 soundId, bool zone)

void	DoAddThreat (Unit *unit, float amount)

void	DoModifyThreatByPercent (Unit *unit, int32 pct)

void	DoResetThreat (Unit *unit)

void	DoResetThreatList ()

float	DoGetThreat (Unit *unit)

void	DoTeleportPlayer (Unit *unit, float x, float y, float z, float o)

void	DoTeleportAll (float x, float y, float z, float o)

Unit *	DoSelectLowestHpFriendly (float range, uint32 minHPDiff=1)

std::list< Creature * >	DoFindFriendlyCC (float range)

std::list< Creature * >	DoFindFriendlyMissingBuff (float range, uint32 spellId)

Player *	GetPlayerAtMinimumRange (float minRange)

Creature *	DoSpawnCreature (uint32 entry, float offsetX, float offsetY, float offsetZ, float angle, uint32 type, uint32 despawntime)

bool	HealthBelowPct (uint32 pct) const

bool	HealthAbovePct (uint32 pct) const

SpellInfo const *	SelectSpell (Unit *target, uint32 school, uint32 mechanic, SelectTargetType targets, uint32 powerCostMin, uint32 powerCostMax, float rangeMin, float rangeMax, SelectEffect effect)

void	SetEquipmentSlots (bool loadDefault, int32 mainHand=EQUIP_NO_CHANGE, int32 offHand=EQUIP_NO_CHANGE, int32 ranged=EQUIP_NO_CHANGE)

void	SetCombatMovement (bool allowMovement)

bool	IsCombatMovementAllowed () const

virtual bool	CheckEvadeIfOutOfCombatArea () const

bool	IsHeroic () const

Difficulty	GetDifficulty () const

bool	Is25ManRaid () const

template<class T >
const T &	DUNGEON_MODE (const T &normal5, const T &heroic10) const

template<class T >
const T &	RAID_MODE (const T &normal10, const T &normal25) const

template<class T >
const T &	RAID_MODE (const T &normal10, const T &normal25, const T &heroic10, const T &heroic25) const

Player *	SelectTargetFromPlayerList (float maxdist, uint32 excludeAura=0, bool mustBeInLOS=false) const

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

void	Talk (uint8 id, Milliseconds delay)

	CreatureAI (Creature *creature)

	~CreatureAI () override

void	MoveCircleChecks ()

void	MoveBackwardsChecks ()

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

void	TriggerAlert (Unit const *who) const

virtual bool	CanRespawn ()

virtual void	EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

virtual void	JustEngagedWith (Unit *)
	Called for reaction when initially engaged.

virtual void	JustDied (Unit *)

virtual void	KilledUnit (Unit *)

virtual void	JustSummoned (Creature *)

virtual void	IsSummonedBy (WorldObject *)

virtual void	SummonedCreatureDespawn (Creature *)

virtual void	SummonedCreatureDies (Creature , Unit )

virtual void	SummonedCreatureDespawnAll ()

virtual void	SpellHit (Unit , SpellInfo const )

virtual void	SpellHitTarget (Unit , SpellInfo const )

virtual void	AttackedBy (Unit *)

virtual bool	IsEscorted ()

virtual void	JustRespawned ()

virtual void	MovementInform (uint32, uint32)

virtual void	PathEndReached (uint32)

void	OnCharmed (bool apply) override

virtual void	JustReachedHome ()

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

virtual void	ReceiveEmote (Player *, uint32)

virtual void	OwnerAttackedBy (Unit *)

virtual void	OwnerAttacked (Unit *)

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 *)

virtual void	PetStopAttack ()

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 *)

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

virtual	~UnitAI ()

virtual bool	CanAIAttack (Unit const *) const

virtual void	AttackStart (Unit *)

virtual void	UpdateAI (uint32)=0

virtual void	InitializeAI ()

virtual void	Reset ()

virtual void	OnCharmed (bool apply)=0

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

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

virtual void	JustEnteredCombat (Unit *)
	Called when the unit enters combat (NOTE: Creature engage logic should NOT be here, but in JustEngagedWith, which happens once threat is established!)

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

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

virtual void	DamageTaken (Unit *, uint32 &, DamageEffectType, SpellSchoolMask)

virtual void	HealReceived (Unit *, uint32 &)

virtual void	HealDone (Unit *, uint32 &)

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)

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)

SpellCastResult	DoCastMaxThreat (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false)
	Cast spell on the max threat target, which may not always 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)

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

Protected Member Functions
Player *	GetLeaderForFollower ()

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)

virtual void	MoveInLineOfSight (Unit *)

bool	_EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

Private Member Functions
void	AddFollowState (uint32 uiFollowState)

void	RemoveFollowState (uint32 uiFollowState)

bool	AssistPlayerInCombatAgainst (Unit *who)

Private Attributes
ObjectGuid	m_uiLeaderGUID

uint32	m_uiUpdateFollowTimer

uint32	m_uiFollowState

const Quest *	m_pQuestForFollow

Additional Inherited Members
Public Types inherited from ScriptedAI
enum class	Axis { AXIS_X , AXIS_Y }

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 Member Functions inherited from CreatureAI
static bool	IsInBounds (CreatureBoundary const &boundary, Position const *who)

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

Public Attributes inherited from ScriptedAI
Creature *	me

bool	IsFleeing

Static Public Attributes inherited from UnitAI
static AISpellInfoType *	AISpellInfo

Protected Attributes inherited from CreatureAI
Creature *const	me

EventMap	events

CreatureBoundary const *	_boundary

bool	_negateBoundary

Protected Attributes inherited from UnitAI
Unit *const	me

Detailed Description

Constructor & Destructor Documentation

◆ FollowerAI()

FollowerAI::FollowerAI ( Creature * creature )

explicit

                                         : ScriptedAI(creature),
    m_uiUpdateFollowTimer(2500),
    m_uiFollowState(STATE_FOLLOW_NONE),
    m_pQuestForFollow(nullptr)
{}

◆ ~FollowerAI()

FollowerAI::~FollowerAI ( )

inlineoverride

39{ }

Member Function Documentation

◆ AddFollowState()

void FollowerAI::AddFollowState ( uint32 uiFollowState )

inlineprivate

69{ m_uiFollowState |= uiFollowState; }

References m_uiFollowState.

Referenced by MovementInform(), SetFollowComplete(), SetFollowPaused(), and StartFollow().

◆ AssistPlayerInCombatAgainst()

bool FollowerAI::AssistPlayerInCombatAgainst ( Unit * who )

private

{
    if (!who || !who->GetVictim())
        return false;
 
    //experimental (unknown) flag not present
    if (!(me->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_CAN_ASSIST))
        return false;
 
    //not a player
    if (!who->GetVictim()->GetCharmerOrOwnerPlayerOrPlayerItself())
        return false;
 
    //never attack friendly
    if (me->IsFriendlyTo(who))
        return false;
 
    //too far away and no free sight?
    if (me->IsWithinDistInMap(who, MAX_PLAYER_DISTANCE) && me->IsWithinLOSInMap(who))
    {
        AttackStart(who);
        return true;
    }
 
    return false;
}

References AttackStart(), CREATURE_TYPE_FLAG_CAN_ASSIST, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), Creature::GetCreatureTemplate(), Unit::GetVictim(), Unit::IsFriendlyTo(), WorldObject::IsWithinDistInMap(), WorldObject::IsWithinLOSInMap(), MAX_PLAYER_DISTANCE, ScriptedAI::me, and CreatureTemplate::type_flags.

Referenced by MoveInLineOfSight().

◆ AttackStart()

void FollowerAI::AttackStart ( Unit * who )

overridevirtual

Reimplemented from ScriptedAI.

{
    if (!who)
        return;
 
    if (me->Attack(who, true))
    {
        // This is done in Unit::Attack function which wont bug npcs by not adding threat upon combat start...
        //me->AddThreat(who, 0.0f);
        //me->SetInCombatWith(who);
        //who->SetInCombatWith(me);
 
        if (me->HasUnitState(UNIT_STATE_FOLLOW))
            me->ClearUnitState(UNIT_STATE_FOLLOW);
 
        if (IsCombatMovementAllowed())
            me->GetMotionMaster()->MoveChase(who);
    }
}

References Unit::Attack(), Unit::ClearUnitState(), Unit::GetMotionMaster(), Unit::HasUnitState(), ScriptedAI::IsCombatMovementAllowed(), ScriptedAI::me, MotionMaster::MoveChase(), and UNIT_STATE_FOLLOW.

Referenced by AssistPlayerInCombatAgainst(), and MoveInLineOfSight().

◆ EnterEvadeMode()

void FollowerAI::EnterEvadeMode ( EvadeReason = EVADE_REASON_OTHER )

overridevirtual

Reimplemented from CreatureAI.

{
    me->RemoveAllAuras();
    me->GetThreatMgr().ClearAllThreat();
    me->CombatStop(true);
    me->SetLootRecipient(nullptr);
 
    if (HasFollowState(STATE_FOLLOW_INPROGRESS))
    {
        LOG_DEBUG("scripts.ai", "FollowerAI left combat, returning to CombatStartPosition.");
 
        if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
        {
            float fPosX, fPosY, fPosZ;
            me->GetPosition(fPosX, fPosY, fPosZ);
            me->GetMotionMaster()->MovePoint(POINT_COMBAT_START, fPosX, fPosY, fPosZ);
        }
    }
    else
    {
        if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
            me->GetMotionMaster()->MoveTargetedHome();
    }
 
    Reset();
}

References CHASE_MOTION_TYPE, ThreatMgr::ClearAllThreat(), Unit::CombatStop(), MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), Position::GetPosition(), Unit::GetThreatMgr(), HasFollowState(), LOG_DEBUG, ScriptedAI::me, MotionMaster::MovePoint(), MotionMaster::MoveTargetedHome(), POINT_COMBAT_START, Unit::RemoveAllAuras(), ScriptedAI::Reset(), Creature::SetLootRecipient(), and STATE_FOLLOW_INPROGRESS.

◆ GetLeaderForFollower()

Player * FollowerAI::GetLeaderForFollower ( )

protected

{
    if (Player* player = ObjectAccessor::GetPlayer(*me, m_uiLeaderGUID))
    {
        if (player->IsAlive())
            return player;
        else
        {
            if (Group* group = player->GetGroup())
            {
                for (GroupReference* groupRef = group->GetFirstMember(); groupRef != nullptr; groupRef = groupRef->next())
                {
                    Player* member = groupRef->GetSource();
 
                    if (member && me->IsWithinDistInMap(member, MAX_PLAYER_DISTANCE) && member->IsAlive())
                    {
                        LOG_DEBUG("scripts.ai", "FollowerAI GetLeader changed and returned new leader.");
                        m_uiLeaderGUID = member->GetGUID();
                        return member;
                    }
                }
            }
        }
    }
 
    LOG_DEBUG("scripts.ai", "FollowerAI GetLeader can not find suitable leader.");
    return nullptr;
}

References Object::GetGUID(), ObjectAccessor::GetPlayer(), Unit::IsAlive(), WorldObject::IsWithinDistInMap(), LOG_DEBUG, m_uiLeaderGUID, MAX_PLAYER_DISTANCE, ScriptedAI::me, and GroupReference::next().

Referenced by JustDied(), npc_kerlonian::npc_kerlonianAI::MoveInLineOfSight(), npc_tooga::npc_toogaAI::MoveInLineOfSight(), npc_ringo::npc_ringoAI::MoveInLineOfSight(), MovementInform(), SetFollowPaused(), and UpdateAI().

◆ HasFollowState()

bool FollowerAI::HasFollowState ( uint32 uiFollowState )

inline

◆ JustDied()

void FollowerAI::JustDied ( Unit * )

overridevirtual

Reimplemented from ScriptedAI.

{
    if (!HasFollowState(STATE_FOLLOW_INPROGRESS) || !m_uiLeaderGUID || !m_pQuestForFollow)
        return;
 
    //TODO: need a better check for quests with time limit.
    if (Player* player = GetLeaderForFollower())
    {
        if (Group* group = player->GetGroup())
        {
            for (GroupReference* groupRef = group->GetFirstMember(); groupRef != nullptr; groupRef = groupRef->next())
            {
                if (Player* member = groupRef->GetSource())
                {
                    if (member->IsInMap(player) && member->GetQuestStatus(m_pQuestForFollow->GetQuestId()) == QUEST_STATUS_INCOMPLETE)
                        member->FailQuest(m_pQuestForFollow->GetQuestId());
                }
            }
        }
        else
        {
            if (player->GetQuestStatus(m_pQuestForFollow->GetQuestId()) == QUEST_STATUS_INCOMPLETE)
                player->FailQuest(m_pQuestForFollow->GetQuestId());
        }
    }
}

References GetLeaderForFollower(), Quest::GetQuestId(), HasFollowState(), m_pQuestForFollow, m_uiLeaderGUID, GroupReference::next(), QUEST_STATUS_INCOMPLETE, and STATE_FOLLOW_INPROGRESS.

◆ JustRespawned()

void FollowerAI::JustRespawned ( )

overridevirtual

Reimplemented from CreatureAI.

{
    m_uiFollowState = STATE_FOLLOW_NONE;
 
    if (!IsCombatMovementAllowed())
        SetCombatMovement(true);
 
    if (me->GetFaction() != me->GetCreatureTemplate()->faction)
        me->SetFaction(me->GetCreatureTemplate()->faction);
 
    Reset();
}

References CreatureTemplate::faction, Creature::GetCreatureTemplate(), Unit::GetFaction(), ScriptedAI::IsCombatMovementAllowed(), m_uiFollowState, ScriptedAI::me, ScriptedAI::Reset(), ScriptedAI::SetCombatMovement(), Unit::SetFaction(), and STATE_FOLLOW_NONE.

◆ MoveInLineOfSight()

void FollowerAI::MoveInLineOfSight ( Unit * who )

overridevirtual

Reimplemented from CreatureAI.

Reimplemented in npc_kerlonian::npc_kerlonianAI, npc_tooga::npc_toogaAI, npc_ringo::npc_ringoAI, and npc_captured_beryl_sorcerer::npc_captured_beryl_sorcererAI.

{
    if (me->GetVictim())
        return;
 
    if (!me->HasUnitState(UNIT_STATE_STUNNED) && who->isTargetableForAttack(true, me) && who->isInAccessiblePlaceFor(me))
        if (HasFollowState(STATE_FOLLOW_INPROGRESS) && AssistPlayerInCombatAgainst(who))
            return;
 
    if (me->HasReactState(REACT_AGGRESSIVE) && me->CanStartAttack(who))
    {
        if (me->HasUnitState(UNIT_STATE_DISTRACTED))
        {
            me->ClearUnitState(UNIT_STATE_DISTRACTED);
            me->GetMotionMaster()->Clear();
        }
        AttackStart(who);
    }
}

References AssistPlayerInCombatAgainst(), AttackStart(), Creature::CanStartAttack(), MotionMaster::Clear(), Unit::ClearUnitState(), Unit::GetMotionMaster(), Unit::GetVictim(), HasFollowState(), Creature::HasReactState(), Unit::HasUnitState(), Unit::isInAccessiblePlaceFor(), Unit::isTargetableForAttack(), ScriptedAI::me, REACT_AGGRESSIVE, STATE_FOLLOW_INPROGRESS, UNIT_STATE_DISTRACTED, and UNIT_STATE_STUNNED.

Referenced by npc_kerlonian::npc_kerlonianAI::MoveInLineOfSight(), npc_tooga::npc_toogaAI::MoveInLineOfSight(), npc_ringo::npc_ringoAI::MoveInLineOfSight(), and npc_captured_beryl_sorcerer::npc_captured_beryl_sorcererAI::MoveInLineOfSight().

◆ MovementInform()

void FollowerAI::MovementInform	(	uint32	motionType,
		uint32	pointId
	)

overridevirtual

Reimplemented from ScriptedAI.

Reimplemented in npc_tooga::npc_toogaAI.

{
    if (motionType != POINT_MOTION_TYPE || !HasFollowState(STATE_FOLLOW_INPROGRESS))
        return;
 
    if (pointId == POINT_COMBAT_START)
    {
        if (GetLeaderForFollower())
        {
            if (!HasFollowState(STATE_FOLLOW_PAUSED))
                AddFollowState(STATE_FOLLOW_RETURNING);
        }
        else
            me->DespawnOrUnsummon();
    }
}

References AddFollowState(), Creature::DespawnOrUnsummon(), GetLeaderForFollower(), HasFollowState(), ScriptedAI::me, POINT_COMBAT_START, POINT_MOTION_TYPE, STATE_FOLLOW_INPROGRESS, STATE_FOLLOW_PAUSED, and STATE_FOLLOW_RETURNING.

Referenced by npc_tooga::npc_toogaAI::MovementInform().

◆ RemoveFollowState()

void FollowerAI::RemoveFollowState ( uint32 uiFollowState )

inlineprivate

70{ m_uiFollowState &= ~uiFollowState; }

References m_uiFollowState.

Referenced by SetFollowComplete(), SetFollowPaused(), and UpdateAI().

◆ SetFollowComplete()

void FollowerAI::SetFollowComplete ( bool bWithEndEvent = false )

{
    if (me->HasUnitState(UNIT_STATE_FOLLOW))
    {
        me->ClearUnitState(UNIT_STATE_FOLLOW);
 
        me->StopMoving();
        me->GetMotionMaster()->Clear();
        me->GetMotionMaster()->MoveIdle();
    }
 
    if (bWithEndEvent)
        AddFollowState(STATE_FOLLOW_POSTEVENT);
    else
    {
        if (HasFollowState(STATE_FOLLOW_POSTEVENT))
            RemoveFollowState(STATE_FOLLOW_POSTEVENT);
    }
 
    AddFollowState(STATE_FOLLOW_COMPLETE);
}

References AddFollowState(), MotionMaster::Clear(), Unit::ClearUnitState(), Unit::GetMotionMaster(), HasFollowState(), Unit::HasUnitState(), ScriptedAI::me, MotionMaster::MoveIdle(), RemoveFollowState(), STATE_FOLLOW_COMPLETE, STATE_FOLLOW_POSTEVENT, Unit::StopMoving(), and UNIT_STATE_FOLLOW.

Referenced by npc_kerlonian::npc_kerlonianAI::MoveInLineOfSight(), npc_tooga::npc_toogaAI::MoveInLineOfSight(), npc_ringo::npc_ringoAI::MoveInLineOfSight(), npc_captured_beryl_sorcerer::npc_captured_beryl_sorcererAI::MoveInLineOfSight(), npc_tooga::npc_toogaAI::MovementInform(), npc_tooga::npc_toogaAI::UpdateFollowerAI(), and npc_ringo::npc_ringoAI::UpdateFollowerAI().

◆ SetFollowPaused()

void FollowerAI::SetFollowPaused ( bool bPaused )

{
    if (!HasFollowState(STATE_FOLLOW_INPROGRESS) || HasFollowState(STATE_FOLLOW_COMPLETE))
        return;
 
    if (paused)
    {
        AddFollowState(STATE_FOLLOW_PAUSED);
 
        if (me->HasUnitState(UNIT_STATE_FOLLOW))
        {
            me->ClearUnitState(UNIT_STATE_FOLLOW);
 
            me->StopMoving();
            me->GetMotionMaster()->Clear();
            me->GetMotionMaster()->MoveIdle();
        }
    }
    else
    {
        RemoveFollowState(STATE_FOLLOW_PAUSED);
 
        if (Player* leader = GetLeaderForFollower())
            me->GetMotionMaster()->MoveFollow(leader, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
    }
}

References AddFollowState(), MotionMaster::Clear(), Unit::ClearUnitState(), GetLeaderForFollower(), Unit::GetMotionMaster(), HasFollowState(), Unit::HasUnitState(), ScriptedAI::me, MotionMaster::MoveFollow(), MotionMaster::MoveIdle(), PET_FOLLOW_ANGLE, PET_FOLLOW_DIST, RemoveFollowState(), STATE_FOLLOW_COMPLETE, STATE_FOLLOW_INPROGRESS, STATE_FOLLOW_PAUSED, Unit::StopMoving(), and UNIT_STATE_FOLLOW.

Referenced by npc_ringo::npc_ringoAI::ClearFaint(), npc_kerlonian::npc_kerlonianAI::ClearSleeping(), npc_ringo::npc_ringoAI::SetFaint(), and npc_kerlonian::npc_kerlonianAI::SetSleeping().

◆ StartFollow()

void FollowerAI::StartFollow	(	Player *	player,
		uint32	factionForFollower = `0`,
		const Quest *	quest = `nullptr`
	)

{
    if (me->GetVictim())
    {
        LOG_DEBUG("scripts.ai", "FollowerAI attempt to StartFollow while in combat.");
        return;
    }
 
    if (HasFollowState(STATE_FOLLOW_INPROGRESS))
    {
        LOG_ERROR("entities.unit.ai", "FollowerAI attempt to StartFollow while already following.");
        return;
    }
 
    //set variables
    m_uiLeaderGUID = player->GetGUID();
 
    if (factionForFollower)
        me->SetFaction(factionForFollower);
 
    m_pQuestForFollow = quest;
 
    if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == WAYPOINT_MOTION_TYPE)
    {
        me->GetMotionMaster()->Clear();
        me->GetMotionMaster()->MoveIdle();
        LOG_DEBUG("scripts.ai", "FollowerAI start with WAYPOINT_MOTION_TYPE, set to MoveIdle.");
    }
 
    me->ReplaceAllNpcFlags(UNIT_NPC_FLAG_NONE);
 
    AddFollowState(STATE_FOLLOW_INPROGRESS);
 
    me->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
 
    LOG_DEBUG("scripts.ai", "FollowerAI start follow {} ({})", player->GetName(), m_uiLeaderGUID.ToString());
}

References AddFollowState(), MotionMaster::Clear(), MotionMaster::GetCurrentMovementGeneratorType(), Object::GetGUID(), Unit::GetMotionMaster(), WorldObject::GetName(), Unit::GetVictim(), HasFollowState(), LOG_DEBUG, LOG_ERROR, m_pQuestForFollow, m_uiLeaderGUID, ScriptedAI::me, MotionMaster::MoveFollow(), MotionMaster::MoveIdle(), PET_FOLLOW_ANGLE, PET_FOLLOW_DIST, Unit::ReplaceAllNpcFlags(), Unit::SetFaction(), STATE_FOLLOW_INPROGRESS, ObjectGuid::ToString(), UNIT_NPC_FLAG_NONE, and WAYPOINT_MOTION_TYPE.

Referenced by npc_captured_beryl_sorcerer::npc_captured_beryl_sorcererAI::UpdateAI().

◆ UpdateAI()

void FollowerAI::UpdateAI ( uint32 uiDiff )

overridevirtual

Reimplemented from ScriptedAI.

Reimplemented in npc_rabid_thistle_bear::npc_rabid_thistle_bearAI, and npc_captured_beryl_sorcerer::npc_captured_beryl_sorcererAI.

{
    if (HasFollowState(STATE_FOLLOW_INPROGRESS) && !me->GetVictim())
    {
        if (m_uiUpdateFollowTimer <= uiDiff)
        {
            if (HasFollowState(STATE_FOLLOW_COMPLETE) && !HasFollowState(STATE_FOLLOW_POSTEVENT))
            {
                LOG_DEBUG("scripts.ai", "FollowerAI is set completed, despawns.");
                me->DespawnOrUnsummon();
                return;
            }
 
            bool bIsMaxRangeExceeded = true;
 
            if (Player* player = GetLeaderForFollower())
            {
                if (HasFollowState(STATE_FOLLOW_RETURNING))
                {
                    LOG_DEBUG("scripts.ai", "FollowerAI is returning to leader.");
 
                    RemoveFollowState(STATE_FOLLOW_RETURNING);
                    me->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
                    return;
                }
 
                if (Group* group = player->GetGroup())
                {
                    for (GroupReference* groupRef = group->GetFirstMember(); groupRef != nullptr; groupRef = groupRef->next())
                    {
                        Player* member = groupRef->GetSource();
 
                        if (member && me->IsWithinDistInMap(member, MAX_PLAYER_DISTANCE, true, false))
                        {
                            bIsMaxRangeExceeded = false;
                            break;
                        }
                    }
                }
                else
                {
                    if (me->IsWithinDistInMap(player, MAX_PLAYER_DISTANCE, true, false))
                        bIsMaxRangeExceeded = false;
                }
            }
 
            if (bIsMaxRangeExceeded)
            {
                LOG_DEBUG("scripts.ai", "FollowerAI failed because player/group was to far away or not found");
                me->DespawnOrUnsummon();
                return;
            }
 
            m_uiUpdateFollowTimer = 1000;
        }
        else
            m_uiUpdateFollowTimer -= uiDiff;
    }
 
    UpdateFollowerAI(uiDiff);
}

References Creature::DespawnOrUnsummon(), GetLeaderForFollower(), Unit::GetMotionMaster(), Unit::GetVictim(), HasFollowState(), WorldObject::IsWithinDistInMap(), LOG_DEBUG, m_uiUpdateFollowTimer, MAX_PLAYER_DISTANCE, ScriptedAI::me, MotionMaster::MoveFollow(), GroupReference::next(), PET_FOLLOW_ANGLE, PET_FOLLOW_DIST, RemoveFollowState(), STATE_FOLLOW_COMPLETE, STATE_FOLLOW_INPROGRESS, STATE_FOLLOW_POSTEVENT, STATE_FOLLOW_RETURNING, and UpdateFollowerAI().

◆ UpdateFollowerAI()

void FollowerAI::UpdateFollowerAI ( uint32 )

virtual

Reimplemented in npc_kerlonian::npc_kerlonianAI, npc_tooga::npc_toogaAI, and npc_ringo::npc_ringoAI.

{
    if (!UpdateVictim())
        return;
 
    DoMeleeAttackIfReady();
}

References UnitAI::DoMeleeAttackIfReady(), and CreatureAI::UpdateVictim().

Referenced by UpdateAI().

Member Data Documentation

◆ m_pQuestForFollow

const Quest* FollowerAI::m_pQuestForFollow

private

Referenced by JustDied(), and StartFollow().

◆ m_uiFollowState

uint32 FollowerAI::m_uiFollowState

private

Referenced by AddFollowState(), HasFollowState(), JustRespawned(), and RemoveFollowState().

◆ m_uiLeaderGUID

ObjectGuid FollowerAI::m_uiLeaderGUID

private

Referenced by GetLeaderForFollower(), JustDied(), and StartFollow().

◆ m_uiUpdateFollowTimer

uint32 FollowerAI::m_uiUpdateFollowTimer

private

Referenced by UpdateAI().

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FollowerAI()

◆ ~FollowerAI()

Member Function Documentation

◆ AddFollowState()

◆ AssistPlayerInCombatAgainst()

◆ AttackStart()

◆ EnterEvadeMode()

◆ GetLeaderForFollower()

◆ HasFollowState()

◆ JustDied()

◆ JustRespawned()

◆ MoveInLineOfSight()

◆ MovementInform()

◆ RemoveFollowState()

◆ SetFollowComplete()

◆ SetFollowPaused()

◆ StartFollow()

◆ UpdateAI()

◆ UpdateFollowerAI()

Member Data Documentation

◆ m_pQuestForFollow

◆ m_uiFollowState

◆ m_uiLeaderGUID

◆ m_uiUpdateFollowTimer