#include "SmartAI.h"

Inheritance diagram for SmartAI:

Public Member Functions
	~SmartAI () override

	SmartAI (Creature *c)

bool	IsAIControlled () const

void	StartPath (ForcedMovement forcedMovement=FORCED_MOVEMENT_NONE, uint32 path=0, bool repeat=false, Unit *invoker=nullptr, PathSource pathSource=PathSource::SMART_WAYPOINT_MGR)

bool	LoadPath (uint32 entry, PathSource pathSource)

void	PausePath (uint32 delay, bool forced=false)

void	StopPath (uint32 DespawnTime=0, uint32 quest=0, bool fail=false)

void	EndPath (bool fail=false)

void	ResumePath ()

WaypointNode const *	GetNextWayPoint ()

void	GenerateWayPointArray (Movement::PointsArray *points)

bool	HasEscortState (uint32 uiEscortState)

void	AddEscortState (uint32 uiEscortState)

bool	IsEscorted () override

void	RemoveEscortState (uint32 uiEscortState)

void	SetAutoAttack (bool on)

void	SetCombatMovement (bool on, bool stopOrStartMovement)

void	SetCurrentRangeMode (bool on, float range=0.f)

void	SetMainSpell (uint32 spellId)

void	DistanceYourself (float range)

void	SetFollow (Unit *target, float dist=0.0f, float angle=0.0f, uint32 credit=0, uint32 end=0, uint32 creditType=0, bool aliveState=true)

void	StopFollow (bool complete)

void	SetScript9 (SmartScriptHolder &e, uint32 entry, WorldObject *invoker)

SmartScript *	GetScript ()

bool	IsEscortInvokerInRange ()

void	JustRespawned () override

void	JustReachedHome () override

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

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

void	EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER) override

void	JustDied (Unit *killer) override

void	KilledUnit (Unit *victim) override

void	JustSummoned (Creature *creature) override

void	SummonedCreatureDies (Creature summon, Unit killer) override

void	SummonedCreatureEvade (Creature *summon) override

void	AttackStart (Unit *who) override

void	MoveInLineOfSight (Unit *who) override

void	SpellHit (Unit unit, SpellInfo const spellInfo) override

void	SpellHitTarget (Unit target, SpellInfo const spellInfo) override

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

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

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

void	ReceiveEmote (Player *player, uint32 textEmote) override

void	MovementInform (uint32 MovementType, uint32 Data) override

void	IsSummonedBy (WorldObject *summoner) override

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

void	SummonedCreatureDespawn (Creature *unit) override

void	CorpseRemoved (uint32 &respawnDelay) override
	== Triggered Actions Requested ==================

void	PassengerBoarded (Unit *who, int8 seatId, bool apply) override
	== Fields =======================================

void	InitializeAI () override

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

bool	CanAIAttack (Unit const *who) const override

void	DoAction (int32 param=0) override

uint32	GetData (uint32 id=0) const override

void	SetData (uint32 id, uint32 value) override

void	SetData (uint32 id, uint32 value, WorldObject *invoker)

void	SetGUID (ObjectGuid const &guid, int32 id=0) override

ObjectGuid	GetGUID (int32 id=0) const override

void	MovepointReached (uint32 id)

void	SetFly (bool fly=true)

void	SetSwim (bool swim=true)

void	SetEvadeDisabled (bool disable=true)

void	SetSuppressEvade (bool suppress)

void	SetInvincibilityHpLevel (uint32 level)

void	sGossipHello (Player *player) override

void	sGossipSelect (Player *player, uint32 sender, uint32 action) override

void	sGossipSelectCode (Player player, uint32 sender, uint32 action, char const code) override

void	sQuestAccept (Player player, Quest const quest) override

void	sQuestReward (Player player, Quest const quest, uint32 opt) override

void	sOnGameEvent (bool start, uint16 eventId) override

void	SetDespawnTime (uint32 t)

void	StartDespawn ()

void	OnSpellClick (Unit *clicker, bool &result) override

void	PathEndReached (uint32 pathId) override

void	WaypointPathStarted (uint32 pathId) override
	== Waypoints system =============================

void	WaypointStarted (uint32 nodeId, uint32 pathId) override

void	WaypointReached (uint32 nodeId, uint32 pathId) override

void	WaypointPathEnded (uint32 nodeId, uint32 pathId) override

bool	CanRespawn () override

void	SetCanRespawn (bool canSpawn)

void	SetWPPauseTimer (uint32 time)

void	DistancingEnded () override

bool	IsMainSpellPrevented (SpellInfo const *spellInfo) const

void	OnSpellFailed (SpellInfo const *spell) 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	IsEscortNPC (bool=true) const

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

virtual void	JustStartedThreateningMe (Unit *who)

void	EngagementStart (Unit *who)

void	EngagementOver ()

virtual void	SummonedCreatureDespawnAll ()

virtual void	OnSpellStart (SpellInfo const *)

virtual void	OnSpellCast (SpellInfo const *)

virtual void	OnChannelFinished (SpellInfo const *)

virtual void	AttackedBy (Unit *)

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

virtual void	OwnerAttackedBy (Unit *attacker)

virtual void	OwnerAttacked (Unit *target)

void	OnOwnerCombatInteraction (Unit *target)

virtual bool	BeforeSpellClick (Unit *)

virtual bool	CanSeeAlways (WorldObject const *)

virtual bool	CanBeSeen (Player const *)

virtual bool	CanAlwaysBeDetectable (WorldObject const *)

virtual void	PetStopAttack ()

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

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

virtual	~UnitAI ()

virtual void	Reset ()

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	OnDespawn ()
	Called when the unit is about to be removed from the world (despawn, grid unload, corpse disappearing, player logging out etc.)

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

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, int32 aura=0)
	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	sQuestSelect (Player , Quest const )

virtual void	sQuestComplete (Player , Quest const )

virtual std::string	GetDebugInfo () const

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

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
uint32	mEscortQuestID

Private Member Functions
void	ReturnToLastOOCPos ()

void	UpdatePath (const uint32 diff)

uint32	GetWPCount ()

bool	AssistPlayerInCombatAgainst (Unit *who)

void	UpdateDespawn (const uint32 diff)

void	UpdateFollow (const uint32 diff)

void	UpdateMeleeStance ()

void	CheckConditions (const uint32 diff)

Private Attributes
bool	mIsCharmed

uint32	mFollowCreditType

uint32	mFollowArrivedTimer

uint32	_followCheckTimer

uint32	mFollowCredit

uint32	mFollowArrivedEntry

bool	mFollowArrivedAlive

ObjectGuid	mFollowGuid

float	mFollowDist

float	mFollowAngle

SmartScript	mScript

WaypointPath const *	mWayPoints

uint32	mEscortState

uint32	mCurrentWPID

bool	mWPReached

bool	mOOCReached

uint32	mWPPauseTimer

WaypointNode const *	mLastWP

uint32	mEscortNPCFlags

bool	mCanRepeatPath

bool	mEvadeDisabled

bool	mSuppressEvade

bool	mCanAutoAttack

bool	mForcedPaused

uint32	mInvincibilityHpLevel

ForcedMovement	mForcedMovement

uint32	mDespawnTime

uint32	mDespawnState

uint32	mEscortInvokerCheckTimer

bool	mJustReset

bool	mcanSpawn

ConditionList	conditions

uint32	m_ConditionsTimer

bool	_chaseOnInterrupt

std::unordered_map< uint32, uint32 >	aiDataSet

bool	_currentRangeMode

float	_attackDistance

float	_pendingDistancing

uint32	_mainSpellId

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

◆ ~SmartAI()

SmartAI::~SmartAI ( )

inlineoverride

48{};

◆ SmartAI()

SmartAI::SmartAI ( Creature * c )

explicit

                            : CreatureAI(c)
{
    mIsCharmed = false;
    // copy script to local (protection for table reload)
 
    mWayPoints = nullptr;
    mEscortState = SMART_ESCORT_NONE;
    mCurrentWPID = 0;//first wp id is 1 !!
    mWPReached = false;
    mOOCReached = false;
    mWPPauseTimer = 0;
    mLastWP = nullptr;
    mEscortNPCFlags = 0;
 
    mCanRepeatPath = false;
 
    mEvadeDisabled = false;
    mSuppressEvade = false;
 
    mCanAutoAttack = true;
 
    mForcedPaused = false;
 
    mForcedMovement = FORCED_MOVEMENT_NONE;
 
    mEscortQuestID = 0;
 
    mDespawnTime = 0;
    mDespawnState = 0;
 
    mEscortInvokerCheckTimer = 1000;
    mFollowDist = 0;
    mFollowAngle = 0;
    mFollowCredit = 0;
    mFollowArrivedEntry = 0;
    mFollowCreditType = 0;
    mFollowArrivedAlive = 0;
    mFollowArrivedTimer = 0;
    _followCheckTimer = 0;
    mInvincibilityHpLevel = 0;
 
    mJustReset = false;
 
    mcanSpawn = true;
 
    _chaseOnInterrupt = false;
 
    aiDataSet.clear();
 
    // Xinef: Vehicle conditions
    m_ConditionsTimer = 0;
    if (me->GetVehicleKit())
        conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE, me->GetEntry());
 
    _currentRangeMode = false;
    _attackDistance = 0.f;
    _mainSpellId = 0;
}

References _attackDistance, _chaseOnInterrupt, _currentRangeMode, _followCheckTimer, _mainSpellId, aiDataSet, CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE, conditions, FORCED_MOVEMENT_NONE, Object::GetEntry(), Unit::GetVehicleKit(), m_ConditionsTimer, mCanAutoAttack, mCanRepeatPath, mcanSpawn, mCurrentWPID, mDespawnState, mDespawnTime, CreatureAI::me, mEscortInvokerCheckTimer, mEscortNPCFlags, mEscortQuestID, mEscortState, mEvadeDisabled, mFollowAngle, mFollowArrivedAlive, mFollowArrivedEntry, mFollowArrivedTimer, mFollowCredit, mFollowCreditType, mFollowDist, mForcedMovement, mForcedPaused, mInvincibilityHpLevel, mIsCharmed, mJustReset, mLastWP, mOOCReached, mSuppressEvade, mWayPoints, mWPPauseTimer, mWPReached, sConditionMgr, and SMART_ESCORT_NONE.

Member Function Documentation

◆ AddEscortState()

void SmartAI::AddEscortState ( uint32 uiEscortState )

inline

64{ mEscortState |= uiEscortState; }

References mEscortState.

Referenced by EnterEvadeMode(), PausePath(), and StartPath().

◆ AssistPlayerInCombatAgainst()

bool SmartAI::AssistPlayerInCombatAgainst ( Unit * who )

private

{
    if (!IsAIControlled())
        return false;
 
    // Xinef: if unit has no victim, or victim is player controlled thing
    if (!who->GetVictim() || who->GetCharmerOrOwnerOrOwnGUID().IsPlayer())
        return false;
 
    //experimental (unknown) flag not present
    if (!(me->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_CAN_ASSIST))
        return false;
 
    // Xinef: victim of unit has to be a player controlled unit
    if (!who->GetVictim()->GetCharmerOrOwnerOrOwnGUID().IsPlayer())
        return false;
 
    // Xinef: Check if victim can be assisted
    if (!me->IsValidAssistTarget(who->GetVictim()))
        return false;
 
    // Do not engage if we cannot actually attack the attacker (e.g. neutral faction)
    if (!me->IsValidAttackTarget(who))
        return false;
 
    //too far away and no free sight?
    if (me->IsWithinDistInMap(who, SMART_MAX_AID_DIST) && me->IsWithinLOSInMap(who))
    {
        AttackStart(who);
        return true;
    }
 
    return false;
}

References AttackStart(), CREATURE_TYPE_FLAG_CAN_ASSIST, Unit::GetCharmerOrOwnerOrOwnGUID(), Creature::GetCreatureTemplate(), Unit::GetVictim(), IsAIControlled(), ObjectGuid::IsPlayer(), Unit::IsValidAssistTarget(), Unit::IsValidAttackTarget(), WorldObject::IsWithinDistInMap(), WorldObject::IsWithinLOSInMap(), CreatureAI::me, SMART_MAX_AID_DIST, and CreatureTemplate::type_flags.

Referenced by MoveInLineOfSight().

◆ AttackStart()

void SmartAI::AttackStart ( Unit * who )

overridevirtual

Reimplemented from UnitAI.

{
    // xinef: dont allow charmed npcs to act on their own
    if (me->HasUnitFlag(UNIT_FLAG_POSSESSED))
    {
        if (who)
            me->Attack(who, mCanAutoAttack);
        return;
    }
 
    if (who && me->Attack(who, mCanAutoAttack && !_currentRangeMode))
    {
        if (!me->HasUnitState(UNIT_STATE_NO_COMBAT_MOVEMENT))
        {
            MovementGeneratorType type = me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE);
            if (type == ESCORT_MOTION_TYPE || type == POINT_MOTION_TYPE)
            {
                me->GetMotionMaster()->MovementExpired();
                me->StopMoving();
                me->GetMotionMaster()->Clear(false);
            }
 
            me->GetMotionMaster()->MoveChase(who, _attackDistance);
        }
    }
}

References _attackDistance, _currentRangeMode, Unit::Attack(), MotionMaster::Clear(), ESCORT_MOTION_TYPE, Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), Unit::HasUnitFlag(), Unit::HasUnitState(), mCanAutoAttack, CreatureAI::me, MOTION_SLOT_ACTIVE, MotionMaster::MoveChase(), MotionMaster::MovementExpired(), POINT_MOTION_TYPE, Unit::StopMoving(), UNIT_FLAG_POSSESSED, and UNIT_STATE_NO_COMBAT_MOVEMENT.

Referenced by AssistPlayerInCombatAgainst(), and MoveInLineOfSight().

◆ CanAIAttack()

bool SmartAI::CanAIAttack ( Unit const * who ) const

overridevirtual

Reimplemented from UnitAI.

{
    return true;
}

◆ CanRespawn()

bool SmartAI::CanRespawn ( )

inlineoverridevirtual

Reimplemented from CreatureAI.

218{ return mcanSpawn; };

References mcanSpawn.

◆ CheckConditions()

void SmartAI::CheckConditions ( const uint32 diff )

private

{
    Vehicle* vehicle = me->GetVehicleKit();
    if (!vehicle)
        return;
 
    if (m_ConditionsTimer < diff)
    {
        if (!conditions.empty())
        {
            for (SeatMap::iterator itr = vehicle->Seats.begin(); itr != vehicle->Seats.end(); ++itr)
                if (Unit* passenger = ObjectAccessor::GetUnit(*me, itr->second.Passenger.Guid))
                {
                    if (Player* player = passenger->ToPlayer())
                    {
                        if (!sConditionMgr->IsObjectMeetToConditions(player, me, conditions))
                        {
                            player->ExitVehicle();
                            return;//check other pessanger in next tick
                        }
                    }
                }
        }
        m_ConditionsTimer = 1000;
    }
    else
        m_ConditionsTimer -= diff;
}

References conditions, ObjectAccessor::GetUnit(), Unit::GetVehicleKit(), m_ConditionsTimer, CreatureAI::me, sConditionMgr, Vehicle::Seats, and Object::ToPlayer().

Referenced by UpdateAI().

◆ CorpseRemoved()

void SmartAI::CorpseRemoved ( uint32 & )

overridevirtual

== Triggered Actions Requested ==================

== State checks =================================

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_CORPSE_REMOVED, nullptr, respawnDelay);
 
    // xinef: end escort upon corpse remove, safe check in case of immediate despawn
    if (IsEscorted())
        EndPath(true);
}

References EndPath(), GetScript(), IsEscorted(), SmartScript::ProcessEventsFor(), and SMART_EVENT_CORPSE_REMOVED.

◆ DamageDealt()

void SmartAI::DamageDealt	(	Unit *	,
		uint32 &	,
		DamageEffectType	,
		SpellSchoolMask
	)

overridevirtual

Called at any Damage to any victim (before damage apply)

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_DAMAGED_TARGET, doneTo, damage);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_DAMAGED_TARGET.

◆ DamageTaken()

void SmartAI::DamageTaken	(	Unit *	,
		uint32 &	,
		DamageEffectType	,
		SpellSchoolMask
	)

overridevirtual

Called at any Damage from any attacker (before damage apply)

Note: It use for recalculation damage or special reaction at damage for attack reaction use AttackedBy called for non DOT damage in Unit::DealDamage also

Reimplemented from UnitAI.

{
    if (doneBy)
        GetScript()->ProcessEventsFor(SMART_EVENT_DAMAGED, doneBy, damage);
 
    if (!IsAIControlled()) // don't allow players to use unkillable units
        return;
 
    // Xinef: skip nodamage type (eg. instakill effect)
    if (damagetype != NODAMAGE && mInvincibilityHpLevel && (damage >= me->GetHealth() - mInvincibilityHpLevel))
        damage = me->GetHealth() - mInvincibilityHpLevel; // damage should not be nullified, because of player damage req.
}

References Unit::GetHealth(), GetScript(), IsAIControlled(), CreatureAI::me, mInvincibilityHpLevel, NODAMAGE, SmartScript::ProcessEventsFor(), and SMART_EVENT_DAMAGED.

◆ DistanceYourself()

void SmartAI::DistanceYourself ( float range )

{
    Unit* victim = me->GetVictim();
    if (!victim || !victim->IsWithinMeleeRange(me))
        return;
 
    float combatReach = me->GetMeleeRange(victim);
    float distance = DISTANCING_CONSTANT + std::max(combatReach * 1.5f, combatReach + range);
    me->GetMotionMaster()->DistanceYourself(distance);
    _pendingDistancing = distance;
}

References _pendingDistancing, MotionMaster::DistanceYourself(), DISTANCING_CONSTANT, Unit::GetMeleeRange(), Unit::GetMotionMaster(), Unit::GetVictim(), Unit::IsWithinMeleeRange(), and CreatureAI::me.

◆ DistancingEnded()

void SmartAI::DistancingEnded ( )

overridevirtual

Reimplemented from CreatureAI.

{
    SetCurrentRangeMode(true, _pendingDistancing);
    _pendingDistancing = 0.f;
}

References _pendingDistancing, and SetCurrentRangeMode().

◆ DoAction()

void SmartAI::DoAction ( int32 param = 0 )

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_ACTION_DONE, nullptr, param);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_ACTION_DONE.

◆ EndPath()

void SmartAI::EndPath ( bool fail = false )

{
    RemoveEscortState(SMART_ESCORT_ESCORTING | SMART_ESCORT_PAUSED | SMART_ESCORT_RETURNING);
    mWayPoints = nullptr;
    mLastWP = nullptr;
    mWPPauseTimer = 0;
 
    if (mEscortNPCFlags)
    {
        me->ReplaceAllNpcFlags(NPCFlags(mEscortNPCFlags));
        mEscortNPCFlags = 0;
    }
 
    ObjectVector const* targets = GetScript()->GetStoredTargetVector(SMART_ESCORT_TARGETS, *me);
    if (targets && mEscortQuestID)
    {
        if (targets->size() == 1 && GetScript()->IsPlayer((*targets->begin())))
        {
            Player* player = targets->front()->ToPlayer();
            if (Group* group = player->GetGroup())
            {
                for (GroupReference* groupRef = group->GetFirstMember(); groupRef != nullptr; groupRef = groupRef->next())
                {
                    Player* groupGuy = groupRef->GetSource();
                    if (!groupGuy || !player->IsInMap(groupGuy))
                        continue;
 
                    if (!fail && groupGuy->IsAtGroupRewardDistance(me) && !groupGuy->HasCorpse())
                        groupGuy->AreaExploredOrEventHappens(mEscortQuestID);
                    else if (fail && groupGuy->GetQuestStatus(mEscortQuestID) == QUEST_STATUS_INCOMPLETE)
                        groupGuy->FailQuest(mEscortQuestID);
                }
            }
            else
            {
                if (!fail && player->IsAtGroupRewardDistance(me) && !player->HasCorpse())
                    player->GroupEventHappens(mEscortQuestID, me);
                else if (fail && player->GetQuestStatus(mEscortQuestID) == QUEST_STATUS_INCOMPLETE)
                    player->FailQuest(mEscortQuestID);
            }
        }
        else
        {
            for (WorldObject* target : *targets)
            {
                if (GetScript()->IsPlayer(target))
                {
                    Player* player = target->ToPlayer();
                    if (!fail && player->IsAtGroupRewardDistance(me) && !player->HasCorpse())
                        player->AreaExploredOrEventHappens(mEscortQuestID);
                    else if (fail && player->GetQuestStatus(mEscortQuestID) == QUEST_STATUS_INCOMPLETE)
                        player->FailQuest(mEscortQuestID);
                }
            }
        }
    }
 
    // Xinef: if the escort failed - DO NOT PROCESS ANYTHING
    // Xinef: End Path events should be only processed if it was SUCCESSFUL stop or stop called by SMART_ACTION_WAYPOINT_STOP
    if (fail)
    {
        mCurrentWPID = 0;
        return;
    }
 
    GetScript()->ProcessEventsFor(SMART_EVENT_ESCORT_ENDED, nullptr, mCurrentWPID, GetScript()->GetPathId());
    mCurrentWPID = 0;
 
    if (mCanRepeatPath)
    {
        if (IsAIControlled())
            StartPath(mForcedMovement, GetScript()->GetPathId(), true);
    }
    else
        GetScript()->SetPathId(0);
 
    if (mDespawnState == 1)
        StartDespawn();
}

References Player::AreaExploredOrEventHappens(), Player::FailQuest(), Player::GetGroup(), Player::GetQuestStatus(), GetScript(), SmartScript::GetStoredTargetVector(), Player::GroupEventHappens(), Player::HasCorpse(), IsAIControlled(), Player::IsAtGroupRewardDistance(), WorldObject::IsInMap(), SmartScript::IsPlayer(), mCanRepeatPath, mCurrentWPID, mDespawnState, CreatureAI::me, mEscortNPCFlags, mEscortQuestID, mForcedMovement, mLastWP, mWayPoints, mWPPauseTimer, SmartScript::ProcessEventsFor(), QUEST_STATUS_INCOMPLETE, RemoveEscortState(), Unit::ReplaceAllNpcFlags(), SmartScript::SetPathId(), SMART_ESCORT_ESCORTING, SMART_ESCORT_PAUSED, SMART_ESCORT_RETURNING, SMART_ESCORT_TARGETS, SMART_EVENT_ESCORT_ENDED, StartDespawn(), StartPath(), and Object::ToPlayer().

Referenced by CorpseRemoved(), JustDied(), MovepointReached(), OnCharmed(), StopPath(), and UpdatePath().

◆ EnterEvadeMode()

void SmartAI::EnterEvadeMode ( EvadeReason why = EVADE_REASON_OTHER )

overridevirtual

Reimplemented from CreatureAI.

{
    if (mSuppressEvade)
        return;
 
    if (mEvadeDisabled)
    {
        GetScript()->ProcessEventsFor(SMART_EVENT_EVADE);
        return;
    }
 
    if (me->GetCharmerGUID().IsPlayer() || me->HasUnitFlag(UNIT_FLAG_POSSESSED))
    {
        me->AttackStop();
        me->RemoveUnitFlag(UNIT_FLAG_IN_COMBAT);
        return;
    }
 
    if (!_EnterEvadeMode())
        return;
 
    me->AddUnitState(UNIT_STATE_EVADE);
 
    GetScript()->ProcessEventsFor(SMART_EVENT_EVADE); //must be after aura clear so we can cast spells from db
 
    if (Unit* owner = me->GetCharmerOrOwner())
    {
        if (!me->IsVehicle()) // vehicles should not follow their owner (passenger)
            me->GetMotionMaster()->MoveFollow(owner, PET_FOLLOW_DIST, me->GetFollowAngle());
 
        me->ClearUnitState(UNIT_STATE_EVADE);
    }
    else if (HasEscortState(SMART_ESCORT_ESCORTING))
    {
        AddEscortState(SMART_ESCORT_RETURNING);
        ReturnToLastOOCPos();
    }
    else if (mFollowGuid)
    {
        if (Unit* target = ObjectAccessor::GetUnit(*me, mFollowGuid))
            me->GetMotionMaster()->MoveFollow(target, mFollowDist, mFollowAngle);
        me->ClearUnitState(UNIT_STATE_EVADE);
 
        // xinef: do not forget to reset scripts as we wont call reached home
        GetScript()->OnReset();
    }
    else
    {
        me->GetMotionMaster()->MoveTargetedHome();
 
        // xinef: do not forget to reset scripts as we wont call reached home
        if (!me->HasUnitState(UNIT_STATE_EVADE))
            GetScript()->OnReset();
    }
 
    sScriptMgr->OnUnitEnterEvadeMode(me, why);
}

References CreatureAI::_EnterEvadeMode(), AddEscortState(), Unit::AddUnitState(), Unit::AttackStop(), Unit::ClearUnitState(), Unit::GetCharmerGUID(), Unit::GetCharmerOrOwner(), Unit::GetFollowAngle(), Unit::GetMotionMaster(), GetScript(), ObjectAccessor::GetUnit(), HasEscortState(), Unit::HasUnitFlag(), Unit::HasUnitState(), ObjectGuid::IsPlayer(), Unit::IsVehicle(), CreatureAI::me, mEvadeDisabled, mFollowAngle, mFollowDist, mFollowGuid, MotionMaster::MoveFollow(), MotionMaster::MoveTargetedHome(), mSuppressEvade, SmartScript::OnReset(), PET_FOLLOW_DIST, SmartScript::ProcessEventsFor(), Unit::RemoveUnitFlag(), ReturnToLastOOCPos(), SMART_ESCORT_ESCORTING, SMART_ESCORT_RETURNING, SMART_EVENT_EVADE, sScriptMgr, UNIT_FLAG_IN_COMBAT, UNIT_FLAG_POSSESSED, and UNIT_STATE_EVADE.

Referenced by npc_black_morass_summoned_add::EnterEvadeMode(), and OnCharmed().

◆ GenerateWayPointArray()

void SmartAI::GenerateWayPointArray ( Movement::PointsArray * points )

{
    if (!mWayPoints || mWayPoints->Nodes.empty())
        return;
 
    // Flying unit, just fill array
    if (me->m_movementInfo.HasMovementFlag((MovementFlags)(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_DISABLE_GRAVITY)))
    {
        // xinef: first point in vector is unit real position
        points->clear();
        points->push_back(G3D::Vector3(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()));
        // mCurrentWPID is 1-based
        for (uint32 i = mCurrentWPID > 0 ? mCurrentWPID - 1 : 0; i < mWayPoints->Nodes.size(); ++i)
        {
            WaypointNode const& wp = mWayPoints->Nodes[i];
            points->push_back(G3D::Vector3(wp.X, wp.Y, wp.Z));
        }
    }
    else
    {
        for (float size = 1.0f; size; size *= 0.5f)
        {
            std::vector<G3D::Vector3> pVector;
            // xinef: first point in vector is unit real position
            pVector.push_back(G3D::Vector3(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()));
 
            uint32 startIdx = mCurrentWPID > 0 ? mCurrentWPID - 1 : 0;
            uint32 length = (uint32)((mWayPoints->Nodes.size() - startIdx) * size);
 
            uint32 cnt = 0;
            for (uint32 i = startIdx; i < mWayPoints->Nodes.size() && cnt++ <= length; ++i)
            {
                WaypointNode const& wp = mWayPoints->Nodes[i];
                pVector.push_back(G3D::Vector3(wp.X, wp.Y, wp.Z));
            }
 
            if (pVector.size() > 2) // more than source + dest
            {
                G3D::Vector3 middle = (pVector[0] + pVector[pVector.size() - 1]) / 2.f;
                G3D::Vector3 offset;
 
                bool continueLoop = false;
                for (uint32 i = 1; i < pVector.size() - 1; ++i)
                {
                    offset = middle - pVector[i];
                    if (std::fabs(offset.x) >= 0xFF || std::fabs(offset.y) >= 0xFF || std::fabs(offset.z) >= 0x7F)
                    {
                        // offset is too big, split points
                        continueLoop = true;
                        break;
                    }
                }
                if (continueLoop)
                    continue;
            }
            // everything ok
            *points = pVector;
            break;
        }
    }
}

References Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), MovementInfo::HasMovementFlag(), WorldObject::m_movementInfo, mCurrentWPID, CreatureAI::me, MOVEMENTFLAG_CAN_FLY, MOVEMENTFLAG_DISABLE_GRAVITY, mWayPoints, WaypointPath::Nodes, WaypointNode::X, WaypointNode::Y, and WaypointNode::Z.

Referenced by ResumePath(), and StartPath().

◆ GetData()

uint32 SmartAI::GetData ( uint32 id = 0 ) const

overridevirtual

Reimplemented from UnitAI.

{
    auto const& itr = aiDataSet.find(id);
    if (itr != aiDataSet.end())
        return itr->second;
 
    return 0;
}

References aiDataSet.

◆ GetGUID()

ObjectGuid SmartAI::GetGUID ( int32 id = 0 ) const

overridevirtual

Reimplemented from UnitAI.

{
    return ObjectGuid::Empty;
}

References ObjectGuid::Empty.

◆ GetNextWayPoint()

WaypointNode const * SmartAI::GetNextWayPoint ( )

{
    if (!mWayPoints || mWayPoints->Nodes.empty())
        return nullptr;
 
    mCurrentWPID++;
    // mCurrentWPID is 1-based for SmartAI escort paths
    if (mCurrentWPID > mWayPoints->Nodes.size())
        return nullptr;
 
    // Nodes are 0-indexed, mCurrentWPID is 1-based
    WaypointNode const& node = mWayPoints->Nodes[mCurrentWPID - 1];
    mLastWP = &node;
    if (mLastWP->Id != mCurrentWPID)
        LOG_ERROR("scripts.ai.sai", "SmartAI::GetNextWayPoint: Got not expected waypoint id {}, expected {}", mLastWP->Id, mCurrentWPID);
 
    return mLastWP;
}

References WaypointNode::Id, LOG_ERROR, mCurrentWPID, mLastWP, mWayPoints, and WaypointPath::Nodes.

Referenced by MovepointReached(), StartPath(), and UpdatePath().

◆ GetScript()

SmartScript * SmartAI::GetScript ( )

inline

76{ return &mScript; }

SmartAI::mScript

SmartScript mScript

Definition SmartAI.h:244

References mScript.

Referenced by CorpseRemoved(), DamageDealt(), DamageTaken(), DoAction(), EndPath(), EnterEvadeMode(), HealReceived(), InitializeAI(), IsEscortInvokerInRange(), IsSummonedBy(), JustDied(), JustEngagedWith(), JustReachedHome(), JustRespawned(), JustSummoned(), KilledUnit(), LoadPath(), MoveInLineOfSight(), MovementInform(), MovepointReached(), OnCharmed(), OnSpellClick(), PassengerBoarded(), PathEndReached(), PausePath(), ReceiveEmote(), SetData(), SetScript9(), sGossipHello(), sGossipSelect(), sOnGameEvent(), SpellHit(), SpellHitTarget(), sQuestAccept(), sQuestReward(), StartPath(), StopFollow(), StopPath(), SummonedCreatureDespawn(), SummonedCreatureDies(), SummonedCreatureEvade(), UpdateAI(), UpdatePath(), WaypointPathEnded(), and WaypointReached().

◆ GetWPCount()

uint32 SmartAI::GetWPCount ( )

inlineprivate

253{ return mWayPoints ? mWayPoints->Nodes.size() : 0; }

References mWayPoints, and WaypointPath::Nodes.

Referenced by MovepointReached(), and UpdatePath().

◆ HasEscortState()

bool SmartAI::HasEscortState ( uint32 uiEscortState )

inline

63{ return (mEscortState & uiEscortState); }

References mEscortState.

Referenced by EnterEvadeMode(), JustDied(), LoadPath(), MovementInform(), MovepointReached(), OnCharmed(), PausePath(), SetCombatMovement(), StartPath(), StopPath(), UpdatePath(), WaypointPathEnded(), and WaypointReached().

◆ HealReceived()

void SmartAI::HealReceived	(	Unit *	,
		uint32 &
	)

overridevirtual

Called when the creature receives heal.

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_RECEIVE_HEAL, doneBy, addhealth);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_RECEIVE_HEAL.

◆ InitializeAI()

void SmartAI::InitializeAI ( )

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->OnInitialize(me);
 
    auto getSpellAndFlags = [](SmartScriptHolder const& event, uint32& spellId, uint32& flags) -> bool
    {
        if (event.GetActionType() == SMART_ACTION_CAST)
        {
            spellId = event.action.cast.spell;
            flags = event.action.cast.castFlags;
            return true;
        }
        else if (event.GetActionType() == SMART_ACTION_CUSTOM_CAST)
        {
            spellId = event.action.castCustom.spell;
            flags = event.action.castCustom.flags;
            return true;
        }
        return false;
    };
 
    for (SmartScriptHolder const& event : GetScript()->GetEvents())
    {
        uint32 spellId = 0;
        uint32 flags = 0;
        if (!getSpellAndFlags(event, spellId, flags))
            continue;
 
        if (!(flags & SMARTCAST_MAIN_SPELL))
            continue;
 
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
        if (spellInfo && spellInfo->IsPositive())
        {
            LOG_WARN("scripts.ai",
                "SmartAI: Creature {} has SMARTCAST_MAIN_SPELL on positive spell {} - "
                "positive spells should not be used as main spell", me->GetEntry(), spellId);
            continue;
        }
 
        SetMainSpell(spellId);
        break;
    }
 
    // Fallback: use first SMARTCAST_COMBAT_MOVE if no MAIN_SPELL found
    if (!_currentRangeMode)
    {
        for (SmartScriptHolder const& event : GetScript()->GetEvents())
        {
            uint32 spellId = 0;
            uint32 flags = 0;
            if (!getSpellAndFlags(event, spellId, flags))
                continue;
 
            if (!(flags & SMARTCAST_COMBAT_MOVE))
                continue;
 
            // Don't use positive (healing/buff) spells to determine attack distance
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
            if (spellInfo && spellInfo->IsPositive())
                continue;
 
            SetMainSpell(spellId);
            break;
        }
    }
 
    if (!me->isDead())
    {
        mJustReset = true;
        JustReachedHome();
        GetScript()->ProcessEventsFor(SMART_EVENT_RESPAWN);
    }
}

References _currentRangeMode, SmartScriptHolder::GetActionType(), Object::GetEntry(), SmartScript::GetEvents(), GetScript(), Unit::isDead(), SpellInfo::IsPositive(), JustReachedHome(), LOG_WARN, CreatureAI::me, mJustReset, SmartScript::OnInitialize(), SmartScript::ProcessEventsFor(), SetMainSpell(), SMART_ACTION_CAST, SMART_ACTION_CUSTOM_CAST, SMART_EVENT_RESPAWN, SMARTCAST_COMBAT_MOVE, SMARTCAST_MAIN_SPELL, and sSpellMgr.

◆ IsAIControlled()

bool SmartAI::IsAIControlled ( ) const

{
    return !mIsCharmed;
}

References mIsCharmed.

Referenced by AssistPlayerInCombatAgainst(), DamageTaken(), EndPath(), JustEngagedWith(), MoveInLineOfSight(), ReturnToLastOOCPos(), SetCombatMovement(), and UpdateAI().

◆ IsEscorted()

bool SmartAI::IsEscorted ( )

inlineoverridevirtual

Reimplemented from CreatureAI.

65{ return (mEscortState & SMART_ESCORT_ESCORTING); }

References mEscortState, and SMART_ESCORT_ESCORTING.

Referenced by CorpseRemoved().

◆ IsEscortInvokerInRange()

bool SmartAI::IsEscortInvokerInRange ( )

{
    if (ObjectVector const* targets = GetScript()->GetStoredTargetVector(SMART_ESCORT_TARGETS, *me))
    {
        float checkDist = me->GetInstanceScript() ? SMART_ESCORT_MAX_PLAYER_DIST * 2 : SMART_ESCORT_MAX_PLAYER_DIST;
        if (targets->size() == 1 && GetScript()->IsPlayer((*targets->begin())))
        {
            Player* player = (*targets->begin())->ToPlayer();
            if (me->GetDistance(player) <= checkDist)
                return true;
 
            if (Group* group = player->GetGroup())
            {
                for (GroupReference* groupRef = group->GetFirstMember(); groupRef != nullptr; groupRef = groupRef->next())
                {
                    Player* groupGuy = groupRef->GetSource();
 
                    if (groupGuy && me->IsInMap(groupGuy) && me->GetDistance(groupGuy) <= checkDist)
                        return true;
                }
            }
        }
        else
        {
            for (WorldObject* target : *targets)
            {
                if (GetScript()->IsPlayer(target))
                {
                    if (me->GetDistance(target->ToPlayer()) <= checkDist)
                        return true;
                }
            }
        }
 
        // Xinef: no valid target found
        return false;
    }
    // Xinef: no player invoker was stored, just ignore range check
    return true;
}

References WorldObject::GetDistance(), Player::GetGroup(), WorldObject::GetInstanceScript(), GetScript(), WorldObject::IsInMap(), SmartScript::IsPlayer(), CreatureAI::me, GroupReference::next(), SMART_ESCORT_MAX_PLAYER_DIST, and SMART_ESCORT_TARGETS.

Referenced by UpdatePath().

◆ IsMainSpellPrevented()

bool SmartAI::IsMainSpellPrevented ( SpellInfo const * spellInfo ) const

{
    if (me->IsSpellProhibited(spellInfo->GetSchoolMask()))
        return true;
 
    if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
        return true;
 
    if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
        return true;
 
    int32 powerCost = spellInfo->CalcPowerCost(me, spellInfo->GetSchoolMask());
    if (spellInfo->PowerType == POWER_HEALTH)
    {
        if ((int32)me->GetHealth() <= powerCost)
            return true;
    }
    else
    {
        Powers power = (spellInfo->PowerType < MAX_POWERS)
            ? Powers(spellInfo->PowerType)
            : me->getPowerType();
        if ((int32)me->GetPower(power) < powerCost)
            return true;
    }
 
    return false;
}

References SpellInfo::CalcPowerCost(), Unit::GetHealth(), Unit::GetPower(), Unit::getPowerType(), SpellInfo::GetSchoolMask(), Object::HasFlag(), Creature::IsSpellProhibited(), MAX_POWERS, CreatureAI::me, POWER_HEALTH, SpellInfo::PowerType, SpellInfo::PreventionType, SPELL_PREVENTION_TYPE_PACIFY, SPELL_PREVENTION_TYPE_SILENCE, UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED, and UNIT_FLAG_SILENCED.

Referenced by OnSpellFailed().

◆ IsSummonedBy()

void SmartAI::IsSummonedBy ( WorldObject * summoner )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_JUST_SUMMONED, summoner->ToUnit(), 0, 0, false, nullptr, summoner->ToGameObject());
}

References GetScript(), SmartScript::ProcessEventsFor(), SMART_EVENT_JUST_SUMMONED, Object::ToGameObject(), and Object::ToUnit().

◆ JustDied()

void SmartAI::JustDied ( Unit * killer )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_DEATH, killer);
    if (HasEscortState(SMART_ESCORT_ESCORTING))
        EndPath(true);
}

References EndPath(), GetScript(), HasEscortState(), SmartScript::ProcessEventsFor(), SMART_ESCORT_ESCORTING, and SMART_EVENT_DEATH.

◆ JustEngagedWith()

void SmartAI::JustEngagedWith ( Unit * )

overridevirtual

Called for reaction when initially engaged - this happens after JustEnteredCombat.

Reimplemented from CreatureAI.

{
    // Xinef: Interrupt channeled spells
    if (IsAIControlled())
    {
        if (Spell* spell = me->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
        {
            if (!spell->GetSpellInfo()->IsActionAllowedChannel())
                me->InterruptSpell(CURRENT_CHANNELED_SPELL, true, true);
        }
    }
 
    GetScript()->ProcessEventsFor(SMART_EVENT_AGGRO, enemy);
}

References CURRENT_CHANNELED_SPELL, Unit::GetCurrentSpell(), GetScript(), Unit::InterruptSpell(), IsAIControlled(), CreatureAI::me, SmartScript::ProcessEventsFor(), and SMART_EVENT_AGGRO.

◆ JustExitedCombat()

void SmartAI::JustExitedCombat ( )

overridevirtual

Called when the unit leaves combat.

Reimplemented from CreatureAI.

{
    // When evade is suppressed or disabled, don't auto-evade on combat exit.
    // This prevents scripted encounters (e.g. Mograine/Whitemane) from resetting
    // when bosses temporarily stop fighting during scripted phases.
    if (mSuppressEvade || mEvadeDisabled)
    {
        EngagementOver();
        return;
    }
 
    CreatureAI::JustExitedCombat();
}

References CreatureAI::EngagementOver(), CreatureAI::JustExitedCombat(), mEvadeDisabled, and mSuppressEvade.

◆ JustReachedHome()

void SmartAI::JustReachedHome ( )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->OnReset();
 
    if (!mJustReset)
    {
        GetScript()->ProcessEventsFor(SMART_EVENT_REACHED_HOME);
 
        if (!UpdateVictim() && me->GetMotionMaster()->GetCurrentMovementGeneratorType() == IDLE_MOTION_TYPE && me->GetWaypointPath())
            me->GetMotionMaster()->MoveWaypoint(me->GetWaypointPath(), true);
    }
 
    if (_mainSpellId)
    {
        SetMainSpell(_mainSpellId);
        SetCombatMovement(true, false);
    }
 
    mJustReset = false;
}

References _mainSpellId, MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), GetScript(), Creature::GetWaypointPath(), IDLE_MOTION_TYPE, CreatureAI::me, mJustReset, MotionMaster::MoveWaypoint(), SmartScript::OnReset(), SmartScript::ProcessEventsFor(), SetCombatMovement(), SetMainSpell(), SMART_EVENT_REACHED_HOME, and CreatureAI::UpdateVictim().

Referenced by InitializeAI(), and JustRespawned().

◆ JustRespawned()

void SmartAI::JustRespawned ( )

overridevirtual

Reimplemented from CreatureAI.

{
    mDespawnTime = 0;
    mDespawnState = 0;
    mEscortState = SMART_ESCORT_NONE;
    me->SetVisible(true);
    if (me->GetFaction() != me->GetCreatureTemplate()->faction)
        me->RestoreFaction();
    mJustReset = true;
    JustReachedHome();
    GetScript()->ProcessEventsFor(SMART_EVENT_RESPAWN);
    mFollowGuid.Clear();//do not reset follower on Reset(), we need it after combat evade
    mFollowDist = 0;
    mFollowAngle = 0;
    mFollowCredit = 0;
    mFollowArrivedTimer = 1000;
    mFollowArrivedEntry = 0;
    mFollowCreditType = 0;
    mFollowArrivedAlive = true;
    aiDataSet.clear();
}

References aiDataSet, ObjectGuid::Clear(), CreatureTemplate::faction, Creature::GetCreatureTemplate(), Unit::GetFaction(), GetScript(), JustReachedHome(), mDespawnState, mDespawnTime, CreatureAI::me, mEscortState, mFollowAngle, mFollowArrivedAlive, mFollowArrivedEntry, mFollowArrivedTimer, mFollowCredit, mFollowCreditType, mFollowDist, mFollowGuid, mJustReset, SmartScript::ProcessEventsFor(), Unit::RestoreFaction(), Unit::SetVisible(), SMART_ESCORT_NONE, and SMART_EVENT_RESPAWN.

◆ JustSummoned()

void SmartAI::JustSummoned ( Creature * creature )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_SUMMONED_UNIT, creature);
    GetScript()->AddCreatureSummon(creature->GetGUID());
}

References SmartScript::AddCreatureSummon(), Object::GetGUID(), GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_SUMMONED_UNIT.

◆ KilledUnit()

void SmartAI::KilledUnit ( Unit * victim )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_KILL, victim);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_KILL.

◆ LoadPath()

bool SmartAI::LoadPath	(	uint32	entry,
		PathSource	pathSource
	)

{
    if (HasEscortState(SMART_ESCORT_ESCORTING))
        return false;
 
    switch (pathSource)
    {
        case PathSource::SMART_WAYPOINT_MGR:
        {
            mWayPoints = sSmartWaypointMgr->GetPath(entry);
            if (!mWayPoints)
            {
                GetScript()->SetPathId(0);
                return false;
            }
            break;
        }
        case PathSource::WAYPOINT_MGR:
        {
            mWayPoints = sWaypointMgr->GetPath(entry);
            if (!mWayPoints)
            {
                GetScript()->SetPathId(0);
                return false;
            }
            break;
        }
    }
 
    GetScript()->SetPathId(entry);
    return true;
}

References GetScript(), HasEscortState(), mWayPoints, SmartScript::SetPathId(), SMART_ESCORT_ESCORTING, SMART_WAYPOINT_MGR, sSmartWaypointMgr, sWaypointMgr, and WAYPOINT_MGR.

Referenced by StartPath().

◆ MoveInLineOfSight()

void SmartAI::MoveInLineOfSight ( Unit * who )

overridevirtual

Reimplemented from CreatureAI.

{
    if (!who)
        return;
 
    GetScript()->OnMoveInLineOfSight(who);
 
    if (!IsAIControlled())
        return;
 
    if (me->GetVictim())
        return;
 
    if (me->HasReactState(REACT_PASSIVE) || 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(), GetScript(), Unit::GetVictim(), Creature::HasReactState(), Unit::HasUnitState(), IsAIControlled(), CreatureAI::me, SmartScript::OnMoveInLineOfSight(), REACT_AGGRESSIVE, REACT_PASSIVE, and UNIT_STATE_DISTRACTED.

◆ MovementInform()

void SmartAI::MovementInform	(	uint32	MovementType,
		uint32	Data
	)

overridevirtual

Reimplemented from CreatureAI.

{
    if (MovementType == POINT_MOTION_TYPE && Data == SMART_ESCORT_LAST_OOC_POINT)
        me->ClearUnitState(UNIT_STATE_EVADE);
 
    if (MovementType == WAYPOINT_MOTION_TYPE)
        GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_REACHED, nullptr, Data); // data now corresponds to columns
 
    GetScript()->ProcessEventsFor(SMART_EVENT_MOVEMENTINFORM, nullptr, MovementType, Data);
    if (!HasEscortState(SMART_ESCORT_ESCORTING))
        return;
 
    if (MovementType == ESCORT_MOTION_TYPE || (MovementType == POINT_MOTION_TYPE && Data == SMART_ESCORT_LAST_OOC_POINT))
        MovepointReached(Data);
}

References Unit::ClearUnitState(), ESCORT_MOTION_TYPE, GetScript(), HasEscortState(), CreatureAI::me, MovepointReached(), POINT_MOTION_TYPE, SmartScript::ProcessEventsFor(), SMART_ESCORT_ESCORTING, SMART_ESCORT_LAST_OOC_POINT, SMART_EVENT_MOVEMENTINFORM, SMART_EVENT_WAYPOINT_REACHED, UNIT_STATE_EVADE, and WAYPOINT_MOTION_TYPE.

◆ MovepointReached()

void SmartAI::MovepointReached ( uint32 id )

{
    // override the id, path can be resumed any time and counter will reset
    // mCurrentWPID holds proper id
 
    // xinef: both point movement and escort generator can enter this function
    if (id == SMART_ESCORT_LAST_OOC_POINT)
    {
        mOOCReached = true;
        return;
    }
 
    mWPReached = true;
    GetScript()->ProcessEventsFor(SMART_EVENT_ESCORT_REACHED, nullptr, mCurrentWPID);
 
    if (mLastWP)
    {
        me->SetPosition(mLastWP->X, mLastWP->Y, mLastWP->Z, me->GetOrientation());
        me->SetHomePosition(me->GetPosition());
    }
 
    if (HasEscortState(SMART_ESCORT_PAUSED))
    {
        if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == ESCORT_MOTION_TYPE)
            me->GetMotionMaster()->MovementExpired();
 
        me->StopMovingOnCurrentPos();
        me->GetMotionMaster()->MoveIdle();
    }
    // Xinef: Can be unset in ProcessEvents
    else if (HasEscortState(SMART_ESCORT_ESCORTING) && me->GetMotionMaster()->GetCurrentMovementGeneratorType() == ESCORT_MOTION_TYPE)
    {
        mWPReached = false;
        if (mCurrentWPID == GetWPCount())
            EndPath();
        else if (GetNextWayPoint())
        {
            // xinef: if we have reached waypoint, and there is no working spline movement it means our splitted array has ended, make new one
            if (me->movespline->Finalized())
                ResumePath();
        }
    }
}

References EndPath(), ESCORT_MOTION_TYPE, Movement::MoveSpline::Finalized(), MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), GetNextWayPoint(), Position::GetOrientation(), Position::GetPosition(), GetScript(), GetWPCount(), HasEscortState(), mCurrentWPID, CreatureAI::me, mLastWP, mOOCReached, MOTION_SLOT_ACTIVE, MotionMaster::MoveIdle(), MotionMaster::MovementExpired(), Unit::movespline, mWPReached, SmartScript::ProcessEventsFor(), ResumePath(), Creature::SetHomePosition(), Creature::SetPosition(), SMART_ESCORT_ESCORTING, SMART_ESCORT_LAST_OOC_POINT, SMART_ESCORT_PAUSED, SMART_EVENT_ESCORT_REACHED, Unit::StopMovingOnCurrentPos(), WaypointNode::X, WaypointNode::Y, and WaypointNode::Z.

Referenced by MovementInform().

◆ OnCharmed()

void SmartAI::OnCharmed ( bool apply )

overridevirtual

Called when unit is charmed.

Reimplemented from CreatureAI.

{
    bool const charmed = me->IsCharmed();
    if (charmed) // do this before we change charmed state, as charmed state might prevent these things from processing
    {
        if (HasEscortState(SMART_ESCORT_ESCORTING | SMART_ESCORT_PAUSED | SMART_ESCORT_RETURNING))
            EndPath(true);
    }
 
    mIsCharmed = charmed;
 
    if (charmed && !me->isPossessed() && !me->IsVehicle())
        me->GetMotionMaster()->MoveFollow(me->GetCharmer(), PET_FOLLOW_DIST, me->GetFollowAngle());
 
    if (!charmed && !me->IsInEvadeMode())
    {
        if (mCanRepeatPath)
            StartPath(mForcedMovement, GetScript()->GetPathId(), true);
 
        if (!me->LastCharmerGUID.IsEmpty())
        {
            if (!me->HasReactState(REACT_PASSIVE))
                if (Unit* lastCharmer = ObjectAccessor::GetUnit(*me, me->LastCharmerGUID))
                    me->EngageWithTarget(lastCharmer);
            me->LastCharmerGUID.Clear();
 
            if (!me->IsInCombat())
                EnterEvadeMode(EVADE_REASON_NO_HOSTILES);
        }
    }
 
    GetScript()->ProcessEventsFor(SMART_EVENT_CHARMED, nullptr, 0, 0, charmed);
}

References ObjectGuid::Clear(), EndPath(), Unit::EngageWithTarget(), EnterEvadeMode(), CreatureAI::EVADE_REASON_NO_HOSTILES, Unit::GetCharmer(), Unit::GetFollowAngle(), Unit::GetMotionMaster(), GetScript(), ObjectAccessor::GetUnit(), HasEscortState(), Creature::HasReactState(), Unit::IsCharmed(), ObjectGuid::IsEmpty(), Unit::IsInCombat(), Creature::IsInEvadeMode(), Unit::isPossessed(), Unit::IsVehicle(), Unit::LastCharmerGUID, mCanRepeatPath, CreatureAI::me, mForcedMovement, mIsCharmed, MotionMaster::MoveFollow(), PET_FOLLOW_DIST, SmartScript::ProcessEventsFor(), REACT_PASSIVE, SMART_ESCORT_ESCORTING, SMART_ESCORT_PAUSED, SMART_ESCORT_RETURNING, SMART_EVENT_CHARMED, and StartPath().

◆ OnSpellClick()

void SmartAI::OnSpellClick	(	Unit *	clicker,
		bool &	result
	)

overridevirtual

Reimplemented from CreatureAI.

{
    // Xinef: i dont think this is necessery (can be made as event parameter)
    //if (!result)
    //    return;
 
    GetScript()->ProcessEventsFor(SMART_EVENT_ON_SPELLCLICK, clicker);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_ON_SPELLCLICK.

◆ OnSpellFailed()

void SmartAI::OnSpellFailed ( SpellInfo const * spell )

overridevirtual

Reimplemented from CreatureAI.

{
    CreatureAI::OnSpellFailed(spell);
 
    // If another cast or channel is still active, do not resume combat movement
    if (me->IsMovementPreventedByCasting())
        return;
 
    if (_mainSpellId == spell->Id)
    {
        if (_currentRangeMode && IsMainSpellPrevented(spell))
        {
            SetCombatMovement(true, false);
            SetCurrentRangeMode(false, 0.f);
        }
    }
}

References _currentRangeMode, _mainSpellId, SpellInfo::Id, IsMainSpellPrevented(), Creature::IsMovementPreventedByCasting(), CreatureAI::me, CreatureAI::OnSpellFailed(), SetCombatMovement(), and SetCurrentRangeMode().

◆ PassengerBoarded()

void SmartAI::PassengerBoarded	(	Unit *	,
		int8	,
		bool
	)

overridevirtual

== Fields =======================================

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(apply ? SMART_EVENT_PASSENGER_BOARDED : SMART_EVENT_PASSENGER_REMOVED, who, uint32(seatId), 0, apply);
}

References GetScript(), SmartScript::ProcessEventsFor(), SMART_EVENT_PASSENGER_BOARDED, and SMART_EVENT_PASSENGER_REMOVED.

◆ PathEndReached()

void SmartAI::PathEndReached ( uint32 pathId )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_ENDED, nullptr, 0, me->GetWaypointPath());
    me->LoadPath(0);
}

References GetScript(), Creature::GetWaypointPath(), Creature::LoadPath(), CreatureAI::me, SmartScript::ProcessEventsFor(), and SMART_EVENT_WAYPOINT_ENDED.

◆ PausePath()

void SmartAI::PausePath	(	uint32	delay,
		bool	forced = `false`
	)

{
    if (!HasEscortState(SMART_ESCORT_ESCORTING))
        return;
 
    if (HasEscortState(SMART_ESCORT_PAUSED))
    {
        LOG_ERROR("scripts.ai.sai", "SmartAI::StartPath: Creature entry {} wanted to pause waypoint movement while already paused, ignoring.", me->GetEntry());
        return;
    }
 
    AddEscortState(SMART_ESCORT_PAUSED);
    mWPPauseTimer = delay;
    if (forced && !mWPReached)
    {
        mForcedPaused = forced;
        if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == ESCORT_MOTION_TYPE)
            me->GetMotionMaster()->MovementExpired();
 
        me->StopMoving();
        me->GetMotionMaster()->MoveIdle();//force stop
 
        if (mCurrentWPID > 0 && mCurrentWPID <= mWayPoints->Nodes.size())
        {
            WaypointNode const& waypoint = mWayPoints->Nodes[mCurrentWPID - 1];
            if (waypoint.Orientation.has_value())
                me->SetFacingTo(*waypoint.Orientation);
        }
    }
    GetScript()->ProcessEventsFor(SMART_EVENT_ESCORT_PAUSED, nullptr, mCurrentWPID, GetScript()->GetPathId());
}

References AddEscortState(), ESCORT_MOTION_TYPE, Object::GetEntry(), Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), GetScript(), HasEscortState(), LOG_ERROR, mCurrentWPID, CreatureAI::me, mForcedPaused, MOTION_SLOT_ACTIVE, MotionMaster::MoveIdle(), MotionMaster::MovementExpired(), mWayPoints, mWPPauseTimer, mWPReached, WaypointPath::Nodes, WaypointNode::Orientation, SmartScript::ProcessEventsFor(), Unit::SetFacingTo(), SMART_ESCORT_ESCORTING, SMART_ESCORT_PAUSED, SMART_EVENT_ESCORT_PAUSED, and Unit::StopMoving().

◆ Permissible()

static int32 SmartAI::Permissible ( Creature const * )

inlinestatic

177{ return PERMIT_BASE_NO; }

PERMIT_BASE_NO

@ PERMIT_BASE_NO

Definition CreatureAI.h:288

References PERMIT_BASE_NO.

◆ ReceiveEmote()

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

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_RECEIVE_EMOTE, player, textEmote);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_RECEIVE_EMOTE.

◆ RemoveEscortState()

void SmartAI::RemoveEscortState ( uint32 uiEscortState )

inline

66{ mEscortState &= ~uiEscortState; }

References mEscortState.

Referenced by EndPath(), and UpdatePath().

◆ ResumePath()

void SmartAI::ResumePath ( )

{
    if (mLastWP)
    {
        Movement::PointsArray pathPoints;
        GenerateWayPointArray(&pathPoints);
 
        me->GetMotionMaster()->MoveSplinePath(&pathPoints, mForcedMovement);
    }
}

References GenerateWayPointArray(), Unit::GetMotionMaster(), CreatureAI::me, mForcedMovement, mLastWP, and MotionMaster::MoveSplinePath().

Referenced by MovepointReached(), and UpdatePath().

◆ ReturnToLastOOCPos()

void SmartAI::ReturnToLastOOCPos ( )

private

{
    if (!IsAIControlled())
        return;
 
    float x, y, z, o;
    me->GetHomePosition(x, y, z, o);
    me->GetMotionMaster()->MovePoint(SMART_ESCORT_LAST_OOC_POINT, x, y, z, FORCED_MOVEMENT_RUN);
}

References FORCED_MOVEMENT_RUN, Creature::GetHomePosition(), Unit::GetMotionMaster(), IsAIControlled(), CreatureAI::me, MotionMaster::MovePoint(), and SMART_ESCORT_LAST_OOC_POINT.

Referenced by EnterEvadeMode().

◆ SetAutoAttack()

void SmartAI::SetAutoAttack ( bool on )

inline

67{ mCanAutoAttack = on; }

References mCanAutoAttack.

◆ SetCanRespawn()

void SmartAI::SetCanRespawn ( bool canSpawn )

inline

219{ mcanSpawn = canSpawn; }

References mcanSpawn.

◆ SetCombatMovement()

void SmartAI::SetCombatMovement	(	bool	on,
		bool	stopOrStartMovement
	)

{
    if (on)
        me->ClearUnitState(UNIT_STATE_NO_COMBAT_MOVEMENT);
    else
        me->AddUnitState(UNIT_STATE_NO_COMBAT_MOVEMENT);
 
    if (!IsAIControlled() || HasEscortState(SMART_ESCORT_ESCORTING))
        return;
 
    if (stopOrStartMovement && me->GetVictim()) // Only change current movement while in combat
    {
        if (!me->IsCrowdControlled())
        {
            if (on)
                me->GetMotionMaster()->MoveChase(me->GetVictim(), _currentRangeMode ? _attackDistance : 0.0f);
            else if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
                me->StopMoving();
        }
    }
}

References _attackDistance, _currentRangeMode, Unit::AddUnitState(), CHASE_MOTION_TYPE, Unit::ClearUnitState(), MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), Unit::GetVictim(), HasEscortState(), IsAIControlled(), Unit::IsCrowdControlled(), CreatureAI::me, MotionMaster::MoveChase(), SMART_ESCORT_ESCORTING, Unit::StopMoving(), and UNIT_STATE_NO_COMBAT_MOVEMENT.

Referenced by JustReachedHome(), and OnSpellFailed().

◆ SetCurrentRangeMode()

void SmartAI::SetCurrentRangeMode	(	bool	on,
		float	range = `0.f`
	)

{
    _currentRangeMode = on;
    _attackDistance = range;
 
    if (Unit* victim = me->GetVictim())
    {
        if (me->IsCombatMovementAllowed() && !me->HasUnitState(UNIT_STATE_NO_COMBAT_MOVEMENT)
            && !me->IsMovementPreventedByCasting())
            me->GetMotionMaster()->MoveChase(victim, _attackDistance);
 
        if (!on && mCanAutoAttack && !me->HasUnitState(UNIT_STATE_MELEE_ATTACKING))
            me->Attack(victim, true);
    }
}

References _attackDistance, _currentRangeMode, Unit::Attack(), Unit::GetMotionMaster(), Unit::GetVictim(), Unit::HasUnitState(), Creature::IsCombatMovementAllowed(), Creature::IsMovementPreventedByCasting(), mCanAutoAttack, CreatureAI::me, MotionMaster::MoveChase(), UNIT_STATE_MELEE_ATTACKING, and UNIT_STATE_NO_COMBAT_MOVEMENT.

Referenced by DistancingEnded(), and OnSpellFailed().

◆ SetData() [1/2]

void SmartAI::SetData	(	uint32	id,
		uint32	value
	)

inlineoverridevirtual

Reimplemented from UnitAI.

167{ SetData(id, value, nullptr); }

SmartAI::SetData

void SetData(uint32 id, uint32 value) override

Definition SmartAI.h:167

References SetData().

Referenced by SetData().

◆ SetData() [2/2]

void SmartAI::SetData	(	uint32	id,
		uint32	value,
		WorldObject *	invoker
	)

{
    Unit* unit = nullptr;
    GameObject* gob = nullptr;
 
    if (invoker)
    {
        unit = invoker->ToUnit();
        if (!unit)
            gob = invoker->ToGameObject();
    }
 
    aiDataSet[id] = value;
    GetScript()->ProcessEventsFor(SMART_EVENT_DATA_SET, unit, id, value, false, nullptr, gob);
}

References aiDataSet, GetScript(), SmartScript::ProcessEventsFor(), SMART_EVENT_DATA_SET, Object::ToGameObject(), and Object::ToUnit().

◆ SetDespawnTime()

void SmartAI::SetDespawnTime ( uint32 t )

inline

    {
        mDespawnTime = t;
        mDespawnState = t ? 1 : 0;
    }

References mDespawnState, and mDespawnTime.

Referenced by StopFollow(), and StopPath().

◆ SetEvadeDisabled()

void SmartAI::SetEvadeDisabled ( bool disable = true )

{
    mEvadeDisabled = disable;
}

References mEvadeDisabled.

◆ SetFly()

void SmartAI::SetFly ( bool fly = true )

{
    // xinef: set proper flag!
    //me->SetDisableGravity(fly);
    me->SetCanFly(fly);
}

References CreatureAI::me, and Unit::SetCanFly().

◆ SetFollow()

void SmartAI::SetFollow	(	Unit *	target,
		float	dist = `0.0f`,
		float	angle = `0.0f`,
		uint32	credit = `0`,
		uint32	end = `0`,
		uint32	creditType = `0`,
		bool	aliveState = `true`
	)

{
    if (!target)
    {
        StopFollow(false);
        return;
    }
 
    mFollowGuid = target->GetGUID();
    mFollowDist = dist;
    mFollowAngle = angle;
    mFollowArrivedTimer = 1000;
    _followCheckTimer = 0;
    mFollowCredit = credit;
    mFollowArrivedEntry = end;
    mFollowArrivedAlive = !aliveState; // negate - 0 is alive
    mFollowCreditType = creditType;
    me->GetMotionMaster()->MoveFollow(target, mFollowDist, mFollowAngle, MOTION_SLOT_ACTIVE, true, false);
}

References _followCheckTimer, Object::GetGUID(), Unit::GetMotionMaster(), CreatureAI::me, mFollowAngle, mFollowArrivedAlive, mFollowArrivedEntry, mFollowArrivedTimer, mFollowCredit, mFollowCreditType, mFollowDist, mFollowGuid, MOTION_SLOT_ACTIVE, MotionMaster::MoveFollow(), and StopFollow().

◆ SetGUID()

void SmartAI::SetGUID	(	ObjectGuid const &	guid,
		int32	id = `0`
	)

overridevirtual

Reimplemented from UnitAI.

1177{

1178}

◆ SetInvincibilityHpLevel()

void SmartAI::SetInvincibilityHpLevel ( uint32 level )

inline

189{ mInvincibilityHpLevel = level; }

References mInvincibilityHpLevel.

Referenced by SmartScript::ProcessAction().

◆ SetMainSpell()

void SmartAI::SetMainSpell ( uint32 spellId )

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
        return;
 
    float maxRange = spellInfo->GetMaxRange(false);
    if (maxRange <= NOMINAL_MELEE_RANGE)
        return;
 
    _mainSpellId = spellId;
    _attackDistance = std::max(maxRange - NOMINAL_MELEE_RANGE, 0.0f);
    _currentRangeMode = true;
}

References _attackDistance, _currentRangeMode, _mainSpellId, SpellInfo::GetMaxRange(), NOMINAL_MELEE_RANGE, and sSpellMgr.

Referenced by InitializeAI(), and JustReachedHome().

◆ SetScript9()

void SmartAI::SetScript9	(	SmartScriptHolder &	e,
		uint32	entry,
		WorldObject *	invoker
	)

{
    if (invoker)
        GetScript()->mLastInvoker = invoker->GetGUID();
    GetScript()->SetScript9(e, entry);
}

References Object::GetGUID(), GetScript(), SmartScript::mLastInvoker, and SmartScript::SetScript9().

◆ SetSuppressEvade()

void SmartAI::SetSuppressEvade ( bool suppress )

inline

187{ mSuppressEvade = suppress; }

References mSuppressEvade.

◆ SetSwim()

void SmartAI::SetSwim ( bool swim = true )

{
    me->SetSwim(swim);
}

References CreatureAI::me, and Creature::SetSwim().

◆ SetWPPauseTimer()

void SmartAI::SetWPPauseTimer ( uint32 time )

inline

222{ mWPPauseTimer = time; }

References mWPPauseTimer.

◆ sGossipHello()

void SmartAI::sGossipHello ( Player * player )

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_GOSSIP_HELLO, player);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_GOSSIP_HELLO.

◆ sGossipSelect()

void SmartAI::sGossipSelect	(	Player *	player,
		uint32	sender,
		uint32	action
	)

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_GOSSIP_SELECT, player, sender, action);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_GOSSIP_SELECT.

Referenced by npc_stable_master::npc_stable_masterAI::sGossipSelect().

◆ sGossipSelectCode()

void SmartAI::sGossipSelectCode	(	Player *	player,
		uint32	sender,
		uint32	action,
		char const *	code
	)

overridevirtual

Reimplemented from UnitAI.

1213{

1214}

◆ sOnGameEvent()

void SmartAI::sOnGameEvent	(	bool	start,
		uint16	eventId
	)

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(start ? SMART_EVENT_GAME_EVENT_START : SMART_EVENT_GAME_EVENT_END, nullptr, eventId);
}

References GetScript(), SmartScript::ProcessEventsFor(), SMART_EVENT_GAME_EVENT_END, and SMART_EVENT_GAME_EVENT_START.

◆ SpellHit()

void SmartAI::SpellHit	(	Unit *	unit,
		SpellInfo const *	spellInfo
	)

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_SPELLHIT, unit, 0, 0, false, spellInfo);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_SPELLHIT.

◆ SpellHitTarget()

void SmartAI::SpellHitTarget	(	Unit *	target,
		SpellInfo const *	spellInfo
	)

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_SPELLHIT_TARGET, target, 0, 0, false, spellInfo);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_SPELLHIT_TARGET.

◆ sQuestAccept()

void SmartAI::sQuestAccept	(	Player *	player,
		Quest const *	quest
	)

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_ACCEPTED_QUEST, player, quest->GetQuestId());
}

References Quest::GetQuestId(), GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_ACCEPTED_QUEST.

◆ sQuestReward()

void SmartAI::sQuestReward	(	Player *	player,
		Quest const *	quest,
		uint32	opt
	)

overridevirtual

Reimplemented from UnitAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_REWARD_QUEST, player, quest->GetQuestId(), opt);
}

References Quest::GetQuestId(), GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_REWARD_QUEST.

◆ StartDespawn()

void SmartAI::StartDespawn ( )

inline

207{ mDespawnState = 2; }

References mDespawnState.

Referenced by EndPath(), and StopFollow().

◆ StartPath()

void SmartAI::StartPath	(	ForcedMovement	forcedMovement = `FORCED_MOVEMENT_NONE`,
		uint32	path = `0`,
		bool	repeat = `false`,
		Unit *	invoker = `nullptr`,
		PathSource	pathSource = `PathSource::SMART_WAYPOINT_MGR`
	)

{
    if (HasEscortState(SMART_ESCORT_ESCORTING))
        StopPath();
 
    if (path)
    {
        if (!LoadPath(path, pathSource))
            return;
    }
 
    if (!mWayPoints || mWayPoints->Nodes.empty())
        return;
 
    if (WaypointNode const* wp = GetNextWayPoint())
    {
        AddEscortState(SMART_ESCORT_ESCORTING);
        mCanRepeatPath = repeat;
        mForcedMovement = forcedMovement;
 
        if (invoker && invoker->IsPlayer())
        {
            mEscortNPCFlags = me->GetNpcFlags();
            me->ReplaceAllNpcFlags(UNIT_NPC_FLAG_NONE);
        }
 
        Movement::PointsArray pathPoints;
        GenerateWayPointArray(&pathPoints);
 
        me->GetMotionMaster()->MoveSplinePath(&pathPoints, mForcedMovement);
        GetScript()->ProcessEventsFor(SMART_EVENT_ESCORT_START, nullptr, wp->Id, GetScript()->GetPathId());
    }
}

References AddEscortState(), GenerateWayPointArray(), Unit::GetMotionMaster(), GetNextWayPoint(), Unit::GetNpcFlags(), GetScript(), HasEscortState(), Object::IsPlayer(), LoadPath(), mCanRepeatPath, CreatureAI::me, mEscortNPCFlags, mForcedMovement, MotionMaster::MoveSplinePath(), mWayPoints, WaypointPath::Nodes, SmartScript::ProcessEventsFor(), Unit::ReplaceAllNpcFlags(), SMART_ESCORT_ESCORTING, SMART_EVENT_ESCORT_START, StopPath(), and UNIT_NPC_FLAG_NONE.

Referenced by EndPath(), and OnCharmed().

◆ StopFollow()

void SmartAI::StopFollow ( bool complete )

{
    if (complete)
    {
        Player* player = ObjectAccessor::GetPlayer(*me, mFollowGuid);
        if (player && mFollowCredit > 0)
        {
            if (!mFollowCreditType)
                player->RewardPlayerAndGroupAtEvent(mFollowCredit, me);
            else
                player->GroupEventHappens(mFollowCredit, me);
        }
 
        SetDespawnTime(5000);
        StartDespawn();
 
        GetScript()->ProcessEventsFor(SMART_EVENT_FOLLOW_COMPLETED, player);
    }
 
    mFollowGuid.Clear();
    mFollowDist = 0;
    mFollowAngle = 0;
    mFollowCredit = 0;
    mFollowArrivedTimer = 1000;
    mFollowArrivedEntry = 0;
    mFollowCreditType = 0;
 
    me->GetMotionMaster()->Clear(false);
    me->StopMoving();
    me->GetMotionMaster()->MoveIdle();
}

References ObjectGuid::Clear(), MotionMaster::Clear(), Unit::GetMotionMaster(), ObjectAccessor::GetPlayer(), GetScript(), Player::GroupEventHappens(), CreatureAI::me, mFollowAngle, mFollowArrivedEntry, mFollowArrivedTimer, mFollowCredit, mFollowCreditType, mFollowDist, mFollowGuid, MotionMaster::MoveIdle(), SmartScript::ProcessEventsFor(), Player::RewardPlayerAndGroupAtEvent(), SetDespawnTime(), SMART_EVENT_FOLLOW_COMPLETED, StartDespawn(), and Unit::StopMoving().

Referenced by SetFollow(), and UpdateFollow().

◆ StopPath()

void SmartAI::StopPath	(	uint32	DespawnTime = `0`,
		uint32	quest = `0`,
		bool	fail = `false`
	)

{
    if (!HasEscortState(SMART_ESCORT_ESCORTING))
        return;
 
    if (quest)
        mEscortQuestID = quest;
 
    mCanRepeatPath = false;
 
    SetDespawnTime(DespawnTime);
 
    if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == ESCORT_MOTION_TYPE)
        me->GetMotionMaster()->MovementExpired();
 
    me->StopMoving();
    me->GetMotionMaster()->MoveIdle();
    GetScript()->ProcessEventsFor(SMART_EVENT_ESCORT_STOPPED, nullptr, mCurrentWPID, GetScript()->GetPathId());
    EndPath(fail);
}

References EndPath(), ESCORT_MOTION_TYPE, Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), GetScript(), HasEscortState(), mCanRepeatPath, mCurrentWPID, CreatureAI::me, mEscortQuestID, MOTION_SLOT_ACTIVE, MotionMaster::MoveIdle(), MotionMaster::MovementExpired(), SmartScript::ProcessEventsFor(), SetDespawnTime(), SMART_ESCORT_ESCORTING, SMART_EVENT_ESCORT_STOPPED, and Unit::StopMoving().

Referenced by StartPath(), and UpdatePath().

◆ SummonedCreatureDespawn()

void SmartAI::SummonedCreatureDespawn ( Creature * unit )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_SUMMON_DESPAWNED, unit);
    GetScript()->RemoveCreatureSummon(unit->GetGUID());
}

References Object::GetGUID(), GetScript(), SmartScript::ProcessEventsFor(), SmartScript::RemoveCreatureSummon(), and SMART_EVENT_SUMMON_DESPAWNED.

◆ SummonedCreatureDies()

void SmartAI::SummonedCreatureDies	(	Creature *	summon,
		Unit *	killer
	)

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_SUMMONED_UNIT_DIES, summon);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_SUMMONED_UNIT_DIES.

◆ SummonedCreatureEvade()

void SmartAI::SummonedCreatureEvade ( Creature * summon )

overridevirtual

Reimplemented from CreatureAI.

{
    GetScript()->ProcessEventsFor(SMART_EVENT_SUMMONED_UNIT_EVADE, summon);
}

References GetScript(), SmartScript::ProcessEventsFor(), and SMART_EVENT_SUMMONED_UNIT_EVADE.

◆ UpdateAI()

void SmartAI::UpdateAI ( uint32 )

overridevirtual

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

Implements UnitAI.

{
    if (!me->IsAlive())
    {
        if (IsEngaged())
            EngagementOver();
        return;
    }
 
    CheckConditions(diff);
 
    bool hasVictim = UpdateVictim();
    GetScript()->OnUpdate(diff);
    UpdatePath(diff);
    UpdateDespawn(diff);
    UpdateFollow(diff);
 
    if (!IsAIControlled())
    {
        if (CharmInfo* charmInfo = me->GetCharmInfo())
        {
            if (charmInfo->IsCommandAttack() && mCanAutoAttack)
            {
                DoMeleeAttackIfReady();
            }
        }
 
        return;
    }
 
    if (!hasVictim)
        return;
 
    if (mCanAutoAttack)
    {
        UpdateMeleeStance();
        DoMeleeAttackIfReady();
    }
}

References CheckConditions(), UnitAI::DoMeleeAttackIfReady(), CreatureAI::EngagementOver(), Unit::GetCharmInfo(), GetScript(), IsAIControlled(), Unit::IsAlive(), CreatureAI::IsEngaged(), mCanAutoAttack, CreatureAI::me, SmartScript::OnUpdate(), UpdateDespawn(), UpdateFollow(), UpdateMeleeStance(), UpdatePath(), and CreatureAI::UpdateVictim().

◆ UpdateDespawn()

void SmartAI::UpdateDespawn ( const uint32 diff )

private

{
    if (mDespawnState <= 1 || mDespawnState > 3)
        return;
 
    if (mDespawnTime < diff)
    {
        if (mDespawnState == 2)
        {
            me->SetVisible(false);
            mDespawnTime = 5000;
            mDespawnState++;
        }
        else
            me->DespawnOrUnsummon();
    }
    else
        mDespawnTime -= diff;
}

References Creature::DespawnOrUnsummon(), mDespawnState, mDespawnTime, CreatureAI::me, and Unit::SetVisible().

Referenced by UpdateAI().

◆ UpdateFollow()

void SmartAI::UpdateFollow ( const uint32 diff )

private

{
    if (!mFollowGuid)
        return;
 
    if (mFollowArrivedTimer < diff)
    {
        if (me->FindNearestCreature(mFollowArrivedEntry, INTERACTION_DISTANCE, mFollowArrivedAlive))
            StopFollow(true);
        else
            mFollowArrivedTimer = 1000;
    }
    else
        mFollowArrivedTimer -= diff;
 
    if (mFollowGuid.IsPlayer())
    {
        if (_followCheckTimer < diff)
        {
            bool shouldDespawn = false;
            if (Player* player = ObjectAccessor::FindPlayer(mFollowGuid))
            {
                float checkDist = me->GetInstanceScript() ? SMART_ESCORT_MAX_PLAYER_DIST * 2 : SMART_ESCORT_MAX_PLAYER_DIST;
                if (!me->IsWithinDistInMap(player, checkDist))
                    shouldDespawn = true;
            }
            else
                shouldDespawn = true;
 
            if (shouldDespawn)
                me->DespawnOrUnsummon();
 
            _followCheckTimer = 1000;
        }
        else
            _followCheckTimer -= diff;
    }
}

References _followCheckTimer, Creature::DespawnOrUnsummon(), WorldObject::FindNearestCreature(), ObjectAccessor::FindPlayer(), WorldObject::GetInstanceScript(), INTERACTION_DISTANCE, ObjectGuid::IsPlayer(), WorldObject::IsWithinDistInMap(), CreatureAI::me, mFollowArrivedAlive, mFollowArrivedEntry, mFollowArrivedTimer, mFollowGuid, SMART_ESCORT_MAX_PLAYER_DIST, and StopFollow().

Referenced by UpdateAI().

◆ UpdateMeleeStance()

void SmartAI::UpdateMeleeStance ( )

private

{
    // Ranged creatures should not switch to melee stance at distance
    if (!_currentRangeMode || me->IsCrowdControlled())
        return;
 
    Unit* victim = me->GetVictim();
    if (!victim)
        return;
 
    bool const canMelee = me->IsWithinMeleeRange(victim);
    if (canMelee != me->HasUnitState(UNIT_STATE_MELEE_ATTACKING))
        me->Attack(victim, canMelee);
}

References _currentRangeMode, Unit::Attack(), Unit::GetVictim(), Unit::HasUnitState(), Unit::IsCrowdControlled(), Unit::IsWithinMeleeRange(), CreatureAI::me, and UNIT_STATE_MELEE_ATTACKING.

Referenced by UpdateAI().

◆ UpdatePath()

void SmartAI::UpdatePath ( const uint32 diff )

private

{
    if (!HasEscortState(SMART_ESCORT_ESCORTING))
        return;
 
    if (mEscortInvokerCheckTimer < diff)
    {
        // Xinef: Escort failed - no players in range
        // Xinef: Despawn immediately
        if (!IsEscortInvokerInRange())
        {
            StopPath(0, mEscortQuestID, true);
 
            // Xinef: allow to properly hook out of range despawn action, which in most cases should perform the same operation as dying
            GetScript()->ProcessEventsFor(SMART_EVENT_DEATH, me);
            me->DespawnOrUnsummon(1ms);
            return;
        }
        mEscortInvokerCheckTimer = 1000;
    }
    else
        mEscortInvokerCheckTimer -= diff;
 
    // handle pause
    if (HasEscortState(SMART_ESCORT_PAUSED))
    {
        if (mWPPauseTimer < diff)
        {
            if (!me->IsInCombat() && !HasEscortState(SMART_ESCORT_RETURNING) && (mWPReached || mForcedPaused))
            {
                GetScript()->ProcessEventsFor(SMART_EVENT_ESCORT_RESUMED, nullptr, mCurrentWPID, GetScript()->GetPathId());
                RemoveEscortState(SMART_ESCORT_PAUSED);
                if (mForcedPaused)// if paused between 2 wps resend movement
                {
                    mWPReached = false;
                    mForcedPaused = false;
                    ResumePath();
                }
 
                mWPPauseTimer = 0;
            }
        }
        else
            mWPPauseTimer -= diff;
    }
 
    if (HasEscortState(SMART_ESCORT_RETURNING))
    {
        if (mOOCReached)//reached OOC WP
        {
            mOOCReached = false;
            RemoveEscortState(SMART_ESCORT_RETURNING);
            if (!HasEscortState(SMART_ESCORT_PAUSED))
                ResumePath();
        }
    }
 
    if ((me->GetVictim() && me->IsInCombat()) || HasEscortState(SMART_ESCORT_PAUSED | SMART_ESCORT_RETURNING))
        return;
 
    // handle next wp
    if (!me->HasUnitState(UNIT_STATE_NOT_MOVE) && me->movespline->Finalized())//reached WP
    {
        if (!mWPReached)
        {
            ResumePath();
            return;
        }
 
        mWPReached = false;
        if (mCurrentWPID == GetWPCount())
            EndPath();
        else if (GetNextWayPoint())
        {
            // xinef: if we have reached waypoint, and there is no working spline movement it means our splitted array has ended, make new one
            if (me->movespline->Finalized())
                ResumePath();
        }
    }
}

References Creature::DespawnOrUnsummon(), EndPath(), Movement::MoveSpline::Finalized(), GetNextWayPoint(), GetScript(), Unit::GetVictim(), GetWPCount(), HasEscortState(), Unit::HasUnitState(), IsEscortInvokerInRange(), Unit::IsInCombat(), mCurrentWPID, CreatureAI::me, mEscortInvokerCheckTimer, mEscortQuestID, mForcedPaused, mOOCReached, Unit::movespline, mWPPauseTimer, mWPReached, SmartScript::ProcessEventsFor(), RemoveEscortState(), ResumePath(), SMART_ESCORT_ESCORTING, SMART_ESCORT_PAUSED, SMART_ESCORT_RETURNING, SMART_EVENT_DEATH, SMART_EVENT_ESCORT_RESUMED, StopPath(), and UNIT_STATE_NOT_MOVE.

Referenced by UpdateAI().

◆ WaypointPathEnded()

void SmartAI::WaypointPathEnded	(	uint32	nodeId,
		uint32	pathId
	)

overridevirtual

Reimplemented from CreatureAI.

{
    if (!HasEscortState(SMART_ESCORT_ESCORTING))
    {
        GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_ENDED, nullptr, nodeId, pathId);
        return;
    }
}

References GetScript(), HasEscortState(), SmartScript::ProcessEventsFor(), SMART_ESCORT_ESCORTING, and SMART_EVENT_WAYPOINT_ENDED.

◆ WaypointPathStarted()

void SmartAI::WaypointPathStarted ( uint32 )

overridevirtual

== Waypoints system =============================

Reimplemented from CreatureAI.

1371{

1372}

◆ WaypointReached()

void SmartAI::WaypointReached	(	uint32	nodeId,
		uint32	pathId
	)

overridevirtual

Reimplemented from CreatureAI.

{
    if (!HasEscortState(SMART_ESCORT_ESCORTING))
    {
        GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_REACHED, nullptr, nodeId, pathId);
        return;
    }
}