SmartAI Class Reference

#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	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

{};

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;
    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, _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

{ 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.

{ 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

{ return &mScript; }

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

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

References mWayPoints, and WaypointPath::Nodes.

Referenced by MovepointReached(), and UpdatePath().

HasEscortState()

bool SmartAI::HasEscortState ( uint32  uiEscortState )

inline

{ 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);
 
    for (SmartScriptHolder const& event : GetScript()->GetEvents())
    {
        if (event.GetActionType() != SMART_ACTION_CAST)
            continue;
 
        if (!(event.action.cast.castFlags & SMARTCAST_MAIN_SPELL))
            continue;
 
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(event.action.cast.spell);
        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(), event.action.cast.spell);
            continue;
        }
 
        SetMainSpell(event.action.cast.spell);
        break;
    }
 
    // Fallback: use first SMARTCAST_COMBAT_MOVE if no MAIN_SPELL found
    if (!_currentRangeMode)
    {
        for (SmartScriptHolder const& event : GetScript()->GetEvents())
        {
            if (event.GetActionType() != SMART_ACTION_CAST)
                continue;
 
            if (!(event.action.cast.castFlags & SMARTCAST_COMBAT_MOVE))
                continue;
 
            // Don't use positive (healing/buff) spells to determine attack distance
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(event.action.cast.spell);
            if (spellInfo && spellInfo->IsPositive())
                continue;
 
            SetMainSpell(event.action.cast.spell);
            break;
        }
    }
 
    if (!me->isDead())
    {
        mJustReset = true;
        JustReachedHome();
        GetScript()->ProcessEventsFor(SMART_EVENT_RESPAWN);
    }
}

References _currentRangeMode, Object::GetEntry(), SmartScript::GetEvents(), GetScript(), Unit::isDead(), SpellInfo::IsPositive(), JustReachedHome(), LOG_WARN, CreatureAI::me, mJustReset, SmartScript::OnInitialize(), SmartScript::ProcessEventsFor(), SetMainSpell(), SMART_ACTION_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.

{ 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->HasSpellCooldown(spellInfo->Id))
        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;
 
    return false;
}

References Object::HasFlag(), Creature::HasSpellCooldown(), SpellInfo::Id, CreatureAI::me, 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);
    }
 
    mJustReset = false;
}

References MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), GetScript(), Creature::GetWaypointPath(), IDLE_MOTION_TYPE, CreatureAI::me, mJustReset, MotionMaster::MoveWaypoint(), SmartScript::OnReset(), SmartScript::ProcessEventsFor(), 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 (_mainSpellId == spell->Id)
        if (_currentRangeMode && IsMainSpellPrevented(spell))
            SetCurrentRangeMode(false);
}

References _currentRangeMode, _mainSpellId, SpellInfo::Id, IsMainSpellPrevented(), CreatureAI::OnSpellFailed(), 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

{ return PERMIT_BASE_NO; }

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

{ 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

{ mCanAutoAttack = on; }

References mCanAutoAttack.

SetCanRespawn()

void SmartAI::SetCanRespawn ( bool  canSpawn )

inline

{ 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());
            else if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
                me->StopMoving();
        }
    }
}

References 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.

SetCurrentRangeMode()

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

{
    _currentRangeMode = on;
    _attackDistance = range;
 
    if (Unit* victim = me->GetVictim())
    {
        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(), mCanAutoAttack, CreatureAI::me, MotionMaster::MoveChase(), and UNIT_STATE_MELEE_ATTACKING.

Referenced by DistancingEnded(), and OnSpellFailed().

SetData() [1/2]

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

inlineoverridevirtual

Reimplemented from UnitAI.

{ SetData(id, value, nullptr); }

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;
    mFollowCredit = credit;
    mFollowArrivedEntry = end;
    mFollowArrivedAlive = !aliveState; // negate - 0 is alive
    mFollowCreditType = creditType;
    me->GetMotionMaster()->MoveFollow(target, mFollowDist, mFollowAngle, MOTION_SLOT_ACTIVE, true, false);
}

References 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.

{
}

SetInvincibilityHpLevel()

void SmartAI::SetInvincibilityHpLevel ( uint32  level )

inline

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

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

{ 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

{ 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.

{
}

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

{ 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.

{
}

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

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

WaypointStarted()

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

overridevirtual

Reimplemented from CreatureAI.

{
}

Member Data Documentation

_attackDistance

float SmartAI::_attackDistance

private

Referenced by AttackStart(), SetCurrentRangeMode(), SetMainSpell(), and SmartAI().

_chaseOnInterrupt

bool SmartAI::_chaseOnInterrupt

private

Referenced by SmartAI().

_currentRangeMode

bool SmartAI::_currentRangeMode

private

Referenced by AttackStart(), InitializeAI(), OnSpellFailed(), SetCurrentRangeMode(), SetMainSpell(), SmartAI(), and UpdateMeleeStance().

_followCheckTimer

uint32 SmartAI::_followCheckTimer

private

Referenced by UpdateFollow().

_mainSpellId

uint32 SmartAI::_mainSpellId

private

Referenced by OnSpellFailed(), SetMainSpell(), and SmartAI().

_pendingDistancing

float SmartAI::_pendingDistancing

private

Referenced by DistanceYourself(), and DistancingEnded().

aiDataSet

std::unordered_map<uint32, uint32> SmartAI::aiDataSet

private

Referenced by GetData(), JustRespawned(), SetData(), and SmartAI().

conditions

ConditionList SmartAI::conditions

private

Referenced by CheckConditions(), and SmartAI().

m_ConditionsTimer

uint32 SmartAI::m_ConditionsTimer

private

Referenced by CheckConditions(), and SmartAI().

mCanAutoAttack

bool SmartAI::mCanAutoAttack

private

Referenced by AttackStart(), SetAutoAttack(), SetCurrentRangeMode(), SmartAI(), and UpdateAI().

mCanRepeatPath

bool SmartAI::mCanRepeatPath

private

Referenced by EndPath(), OnCharmed(), SmartAI(), StartPath(), and StopPath().

mcanSpawn

bool SmartAI::mcanSpawn

private

Referenced by CanRespawn(), SetCanRespawn(), and SmartAI().

mCurrentWPID

uint32 SmartAI::mCurrentWPID

private

Referenced by EndPath(), GenerateWayPointArray(), GetNextWayPoint(), MovepointReached(), PausePath(), SmartAI(), StopPath(), and UpdatePath().

mDespawnState

uint32 SmartAI::mDespawnState

private

Referenced by EndPath(), JustRespawned(), SetDespawnTime(), SmartAI(), StartDespawn(), and UpdateDespawn().

mDespawnTime

uint32 SmartAI::mDespawnTime

private

Referenced by JustRespawned(), SetDespawnTime(), SmartAI(), and UpdateDespawn().

mEscortInvokerCheckTimer

uint32 SmartAI::mEscortInvokerCheckTimer

private

Referenced by SmartAI(), and UpdatePath().

mEscortNPCFlags

uint32 SmartAI::mEscortNPCFlags

private

Referenced by EndPath(), SmartAI(), and StartPath().

mEscortQuestID

uint32 SmartAI::mEscortQuestID

Referenced by EndPath(), SmartAI(), StopPath(), and UpdatePath().

mEscortState

uint32 SmartAI::mEscortState

private

Referenced by AddEscortState(), HasEscortState(), IsEscorted(), JustRespawned(), RemoveEscortState(), and SmartAI().

mEvadeDisabled

bool SmartAI::mEvadeDisabled

private

Referenced by EnterEvadeMode(), JustExitedCombat(), SetEvadeDisabled(), and SmartAI().

mFollowAngle

float SmartAI::mFollowAngle

private

Referenced by EnterEvadeMode(), JustRespawned(), SetFollow(), SmartAI(), and StopFollow().

mFollowArrivedAlive

bool SmartAI::mFollowArrivedAlive

private

Referenced by JustRespawned(), SetFollow(), SmartAI(), and UpdateFollow().

mFollowArrivedEntry

uint32 SmartAI::mFollowArrivedEntry

private

Referenced by JustRespawned(), SetFollow(), SmartAI(), StopFollow(), and UpdateFollow().

mFollowArrivedTimer

uint32 SmartAI::mFollowArrivedTimer

private

Referenced by JustRespawned(), SetFollow(), SmartAI(), StopFollow(), and UpdateFollow().

mFollowCredit

uint32 SmartAI::mFollowCredit

private

Referenced by JustRespawned(), SetFollow(), SmartAI(), and StopFollow().

mFollowCreditType

uint32 SmartAI::mFollowCreditType

private

Referenced by JustRespawned(), SetFollow(), SmartAI(), and StopFollow().

mFollowDist

float SmartAI::mFollowDist

private

Referenced by EnterEvadeMode(), JustRespawned(), SetFollow(), SmartAI(), and StopFollow().

mFollowGuid

ObjectGuid SmartAI::mFollowGuid

private

Referenced by EnterEvadeMode(), JustRespawned(), SetFollow(), StopFollow(), and UpdateFollow().

mForcedMovement

ForcedMovement SmartAI::mForcedMovement

private

Referenced by EndPath(), OnCharmed(), ResumePath(), SmartAI(), and StartPath().

mForcedPaused

bool SmartAI::mForcedPaused

private

Referenced by PausePath(), SmartAI(), and UpdatePath().

mInvincibilityHpLevel

uint32 SmartAI::mInvincibilityHpLevel

private

Referenced by DamageTaken(), SetInvincibilityHpLevel(), and SmartAI().

mIsCharmed

bool SmartAI::mIsCharmed

private

Referenced by IsAIControlled(), OnCharmed(), and SmartAI().

mJustReset

bool SmartAI::mJustReset

private

Referenced by InitializeAI(), JustReachedHome(), JustRespawned(), and SmartAI().

mLastWP

WaypointNode const* SmartAI::mLastWP

private

Referenced by EndPath(), GetNextWayPoint(), MovepointReached(), ResumePath(), and SmartAI().

mOOCReached

bool SmartAI::mOOCReached

private

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

mScript

SmartScript SmartAI::mScript

private

Referenced by GetScript().

mSuppressEvade

bool SmartAI::mSuppressEvade

private

Referenced by EnterEvadeMode(), JustExitedCombat(), SetSuppressEvade(), and SmartAI().

mWayPoints

WaypointPath const* SmartAI::mWayPoints

private

Referenced by EndPath(), GenerateWayPointArray(), GetNextWayPoint(), GetWPCount(), LoadPath(), PausePath(), SmartAI(), and StartPath().

mWPPauseTimer

uint32 SmartAI::mWPPauseTimer

private

Referenced by EndPath(), PausePath(), SetWPPauseTimer(), SmartAI(), and UpdatePath().

mWPReached

bool SmartAI::mWPReached

private

Referenced by MovepointReached(), PausePath(), SmartAI(), and UpdatePath().

---

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

• azerothcore-wotlk/src/server/game/AI/SmartScripts/SmartAI.h
• azerothcore-wotlk/src/server/game/AI/SmartScripts/SmartAI.cpp