SmartAI Class Reference

#include "SmartAI.h"

Inheritance diagram for SmartAI:

Public Member Functions
	~SmartAI () override
	SmartAI (Creature *c)
bool	IsAIControlled () const
void	StartPath (bool run=false, uint32 path=0, bool repeat=false, Unit *invoker=nullptr)
bool	LoadPath (uint32 entry)
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 ()
WayPoint *	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	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.
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 guid, int32 id=0) override
ObjectGuid	GetGUID (int32 id=0) const override
void	MovepointReached (uint32 id)
void	SetRun (bool run=true)
void	SetFly (bool fly=true)
void	SetSwim (bool swim=true)
void	SetEvadeDisabled (bool disable=true)
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, const char *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
bool	CanRespawn () override
void	SetCanRespawn (bool canSpawn)
void	SetWPPauseTimer (uint32 time)
void	DistancingEnded () override
Public Member Functions inherited from CreatureAI
void	Talk (uint8 id, WorldObject const *whisperTarget=nullptr, Milliseconds delay=0s)
	Causes the creature to talk/say the text assigned to their entry in the creature_text database table.
void	Talk (uint8 id, Milliseconds delay)
WorldObject *	GetSummoner () const
	Returns the summoner creature/object, if the creature is a temporary summon.
	CreatureAI (Creature *creature)
	~CreatureAI () override
void	MoveCircleChecks ()
void	MoveBackwardsChecks ()
void	MoveInLineOfSight_Safe (Unit *who)
	== Reactions At =================================
void	TriggerAlert (Unit const *who) const
virtual void	SummonedCreatureDespawnAll ()
virtual void	OnSpellCastFinished (SpellInfo const *, SpellFinishReason)
virtual void	AttackedBy (Unit *)
void	DoZoneInCombat (Creature *creature=nullptr, float maxRangeToNearestTarget=250.0f)
virtual void	OwnerAttackedBy (Unit *)
virtual void	OwnerAttacked (Unit *)
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	JustEnteredCombat (Unit *)
	Called when the unit enters combat.
virtual void	JustExitedCombat ()
	Called when the unit leaves combat.
virtual void	OnPowerUpdate (Powers, int32, int32, uint32)
	Called when the creature power updates.
virtual void	HealDone (Unit *, uint32 &)
	Called when the unit heals.
virtual void	OnCalculateMeleeDamageReceived (uint32 &, Unit *)
	Called during damage calculations.
virtual void	OnCalculateSpellDamageReceived (int32 &, Unit *)
virtual void	OnCalculatePeriodicTickReceived (uint32 &, Unit *)
	Called during calculation when receiving periodic healing or damage (DoT or HoT)
void	AttackStartCaster (Unit *victim, float dist)
SpellCastResult	DoAddAuraToAllHostilePlayers (uint32 spellid)
SpellCastResult	DoCast (uint32 spellId)
SpellCastResult	DoCast (Unit *victim, uint32 spellId, bool triggered=false)
SpellCastResult	DoCastSelf (uint32 spellId, bool triggered=false)
SpellCastResult	DoCastToAllHostilePlayers (uint32 spellid, bool triggered=false)
	To specify the caster as target if the spell is self-cast.
SpellCastResult	DoCastVictim (uint32 spellId, bool triggered=false)
SpellCastResult	DoCastAOE (uint32 spellId, bool triggered=false)
SpellCastResult	DoCastRandomTarget (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false, bool withTank=true)
	Cast the spell on a random unit from the threat list.
SpellCastResult	DoCastMaxThreat (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false)
	Cast spell on the top threat target, which may not be the current victim.
float	DoGetSpellMaxRange (uint32 spellId, bool positive=false)
void	DoMeleeAttackIfReady ()
bool	DoSpellAttackIfReady (uint32 spell)
void	DoSpellAttackToRandomTargetIfReady (uint32 spell, uint32 threatTablePosition=0, float dist=0.f, bool playerOnly=true)
virtual void	SummonMovementInform (Creature *, uint32, uint32)
	Called when a summon reaches a waypoint or point movement finished.
virtual void	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	CheckConditions (const uint32 diff)

Private Attributes
bool	mIsCharmed
uint32	mFollowCreditType
uint32	mFollowArrivedTimer
uint32	mFollowCredit
uint32	mFollowArrivedEntry
bool	mFollowArrivedAlive
ObjectGuid	mFollowGuid
float	mFollowDist
float	mFollowAngle
SmartScript	mScript
WPPath *	mWayPoints
uint32	mEscortState
uint32	mCurrentWPID
bool	mWPReached
bool	mOOCReached
uint32	mWPPauseTimer
WayPoint *	mLastWP
uint32	mEscortNPCFlags
bool	mCanRepeatPath
bool	mRun
bool	mEvadeDisabled
bool	mCanAutoAttack
bool	mForcedPaused
uint32	mInvincibilityHpLevel
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

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
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;
 
    // spawn in run mode
    // Xinef: spawn in run mode and set mRun to run... this overrides SetWalk EVERYWHERE
    mRun = true;
    mEvadeDisabled = false;
 
    mCanAutoAttack = true;
 
    mForcedPaused = false;
 
    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;
}

References _attackDistance, _chaseOnInterrupt, _currentRangeMode, aiDataSet, CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE, conditions, 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, mForcedPaused, mInvincibilityHpLevel, mIsCharmed, mJustReset, mLastWP, mOOCReached, mRun, 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;
 
    //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(), 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, me->IsWithinMeleeRange(who)))
    {
        if (!me->HasUnitState(UNIT_STATE_NO_COMBAT_MOVEMENT))
        {
            SetRun(mRun);
            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);
        }
    }
}

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

Referenced by AssistPlayerInCombatAgainst(), MoveInLineOfSight(), and OnCharmed().

CanAIAttack()

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

overridevirtual

Reimplemented from UnitAI.

{
    return !(me->GetReactState() == REACT_PASSIVE);
}

References Creature::GetReactState(), CreatureAI::me, and REACT_PASSIVE.

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_WAYPOINT_ENDED, nullptr, mCurrentWPID, GetScript()->GetPathId());
    mCurrentWPID = 0;
 
    if (mCanRepeatPath)
    {
        if (IsAIControlled())
            StartPath(mRun, 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, mLastWP, mRun, 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_WAYPOINT_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 (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
 
    SetRun(mRun);
    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();
    }
}

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

Referenced by npc_black_morass_summoned_add::EnterEvadeMode().

GenerateWayPointArray()

void SmartAI::GenerateWayPointArray

(

Movement::PointsArray *

points

)

{
    if (!mWayPoints || mWayPoints->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()));
        uint32 wpCounter = mCurrentWPID;
        WPPath::const_iterator itr;
        while ((itr = mWayPoints->find(wpCounter++)) != mWayPoints->end())
        {
            WayPoint* wp = (*itr).second;
            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 length = (mWayPoints->size() - mCurrentWPID) * size;
 
            uint32 cnt = 0;
            uint32 wpCounter = mCurrentWPID;
            WPPath::const_iterator itr;
            while ((itr = mWayPoints->find(wpCounter++)) != mWayPoints->end() && cnt++ <= length)
            {
                WayPoint* wp = (*itr).second;
                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, WayPoint::x, WayPoint::y, and WayPoint::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()

WayPoint * SmartAI::GetNextWayPoint

(

)

{
    if (!mWayPoints || mWayPoints->empty())
        return nullptr;
 
    mCurrentWPID++;
    WPPath::const_iterator itr = mWayPoints->find(mCurrentWPID);
    if (itr != mWayPoints->end())
    {
        mLastWP = (*itr).second;
        if (mLastWP->id != mCurrentWPID)
            LOG_ERROR("scripts.ai.sai", "SmartAI::GetNextWayPoint: Got not expected waypoint id {}, expected {}", mLastWP->id, mCurrentWPID);
 
        return (*itr).second;
    }
    return nullptr;
}

References WayPoint::id, LOG_ERROR, mCurrentWPID, mLastWP, and mWayPoints.

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(), and UpdatePath().

GetWPCount()

uint32 SmartAI::GetWPCount ( )

inlineprivate

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

References mWayPoints.

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(), and UpdatePath().

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);
    if (!me->isDead())
    {
        mJustReset = true;
        JustReachedHome();
        GetScript()->ProcessEventsFor(SMART_EVENT_RESPAWN);
    }
}

References GetScript(), Unit::isDead(), JustReachedHome(), CreatureAI::me, mJustReset, SmartScript::OnInitialize(), SmartScript::ProcessEventsFor(), and SMART_EVENT_RESPAWN.

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

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.

Reimplemented from CreatureAI.

{
    // Xinef: Interrupt channeled spells
    if (IsAIControlled())
        me->InterruptSpell(CURRENT_CHANNELED_SPELL, true, true);
    GetScript()->ProcessEventsFor(SMART_EVENT_AGGRO, enemy);
}

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

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()->MovePath(me->GetWaypointPath(), true);
    }
 
    mJustReset = false;
}

References MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), GetScript(), Creature::GetWaypointPath(), IDLE_MOTION_TYPE, CreatureAI::me, mJustReset, MotionMaster::MovePath(), 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

)

{
    if (HasEscortState(SMART_ESCORT_ESCORTING))
        return false;
 
    mWayPoints = sSmartWaypointMgr->GetPath(entry);
    if (!mWayPoints)
    {
        GetScript()->SetPathId(0);
        return false;
    }
 
    GetScript()->SetPathId(entry);
    return true;
}

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

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_DATA_REACHED, nullptr, Data + 1); // Data + 1 to align smart_scripts and waypoint_data Id rows
 
    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_DATA_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_WAYPOINT_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())
        {
            SetRun(mRun);
            // 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, mRun, mWPReached, SmartScript::ProcessEventsFor(), ResumePath(), Creature::SetHomePosition(), Creature::SetPosition(), SetRun(), SMART_ESCORT_ESCORTING, SMART_ESCORT_LAST_OOC_POINT, SMART_ESCORT_PAUSED, SMART_EVENT_WAYPOINT_REACHED, Unit::StopMovingOnCurrentPos(), WayPoint::x, WayPoint::y, and WayPoint::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->IsInEvadeMode())
    {
        if (mCanRepeatPath)
            StartPath(mRun, GetScript()->GetPathId(), true);
        else
            me->SetWalk(!mRun);
 
        if (Unit* charmer = me->GetCharmer())
            AttackStart(charmer);
    }
 
    GetScript()->ProcessEventsFor(SMART_EVENT_CHARMED, nullptr, 0, 0, charmed);
}

References AttackStart(), EndPath(), Unit::GetCharmer(), GetScript(), HasEscortState(), Unit::IsCharmed(), Creature::IsInEvadeMode(), mCanRepeatPath, CreatureAI::me, mIsCharmed, mRun, SmartScript::ProcessEventsFor(), Creature::SetWalk(), 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.

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_DATA_ENDED, nullptr, 0, me->GetWaypointPath());
    me->LoadPath(0);
}

References GetScript(), Creature::GetWaypointPath(), Creature::LoadPath(), CreatureAI::me, SmartScript::ProcessEventsFor(), and SMART_EVENT_WAYPOINT_DATA_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;
        SetRun(mRun);
        if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == ESCORT_MOTION_TYPE)
            me->GetMotionMaster()->MovementExpired();
 
        me->StopMoving();
        me->GetMotionMaster()->MoveIdle();//force stop
 
        auto waypoint = mWayPoints->find(mCurrentWPID);
        if (waypoint->second->o.has_value())
        {
            me->SetFacingTo(waypoint->second->o.has_value());
        }
    }
    GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_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(), mRun, mWayPoints, mWPPauseTimer, mWPReached, SmartScript::ProcessEventsFor(), Unit::SetFacingTo(), SetRun(), SMART_ESCORT_ESCORTING, SMART_ESCORT_PAUSED, SMART_EVENT_WAYPOINT_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

(

)

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

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

Referenced by MovepointReached(), and UpdatePath().

ReturnToLastOOCPos()

void SmartAI::ReturnToLastOOCPos ( )

private

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

References Creature::GetHomePosition(), Unit::GetMotionMaster(), IsAIControlled(), CreatureAI::me, MotionMaster::MovePoint(), Creature::SetWalk(), 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);
}

References _attackDistance, _currentRangeMode, Unit::GetMotionMaster(), Unit::GetVictim(), CreatureAI::me, and MotionMaster::MoveChase().

Referenced by DistancingEnded().

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 Creature::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;
    SetRun(mRun);
    me->GetMotionMaster()->MoveFollow(target, mFollowDist, mFollowAngle);
}

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

SetGUID()

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

overridevirtual

Reimplemented from UnitAI.

{
}

SetInvincibilityHpLevel()

void SmartAI::SetInvincibilityHpLevel ( uint32  level )

inline

{ mInvincibilityHpLevel = level; }

References mInvincibilityHpLevel.

Referenced by SmartScript::ProcessAction().

SetRun()

void SmartAI::SetRun

(

bool

run = true

)

{
    me->SetWalk(!run);
    mRun = run;
}

References CreatureAI::me, mRun, and Creature::SetWalk().

Referenced by AttackStart(), EnterEvadeMode(), MovepointReached(), PausePath(), ResumePath(), SetFollow(), StartPath(), and UpdatePath().

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

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, const char *  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	(	bool	run = false,
		uint32	path = 0,
		bool	repeat = false,
		Unit *	invoker = nullptr
	)

{
    if (HasEscortState(SMART_ESCORT_ESCORTING))
        StopPath();
 
    if (path)
    {
        if (!LoadPath(path))
            return;
    }
 
    if (!mWayPoints || mWayPoints->empty())
        return;
 
    if (WayPoint* wp = GetNextWayPoint())
    {
        AddEscortState(SMART_ESCORT_ESCORTING);
        mCanRepeatPath = repeat;
        SetRun(run);
 
        if (invoker && invoker->IsPlayer())
        {
            mEscortNPCFlags = me->GetNpcFlags();
            me->ReplaceAllNpcFlags(UNIT_NPC_FLAG_NONE);
        }
 
        Movement::PointsArray pathPoints;
        GenerateWayPointArray(&pathPoints);
 
        me->GetMotionMaster()->MoveSplinePath(&pathPoints);
        GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_START, nullptr, wp->id, GetScript()->GetPathId());
    }
}

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

Referenced by EndPath(), and OnCharmed().

StopFollow()

void SmartAI::StopFollow

(

bool

complete

)

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

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

StopPath()

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

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

References EndPath(), ESCORT_MOTION_TYPE, Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), GetScript(), HasEscortState(), mCurrentWPID, CreatureAI::me, mEscortQuestID, MOTION_SLOT_ACTIVE, MotionMaster::MoveIdle(), MotionMaster::MovementExpired(), SmartScript::ProcessEventsFor(), SetDespawnTime(), SMART_ESCORT_ESCORTING, SMART_EVENT_WAYPOINT_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.

{
    bool hasVictim = UpdateVictim();
    CheckConditions(diff);
    GetScript()->OnUpdate(diff);
    UpdatePath(diff);
    UpdateDespawn(diff);
 
    //TODO move to void
    if (mFollowGuid)
    {
        if (mFollowArrivedTimer < diff)
        {
            if (me->FindNearestCreature(mFollowArrivedEntry, INTERACTION_DISTANCE, mFollowArrivedAlive))
            {
                StopFollow(true);
                return;
            }
 
            mFollowArrivedTimer = 1000;
        }
        else
            mFollowArrivedTimer -= diff;
    }
 
    if (!IsAIControlled())
    {
        if (CharmInfo* charmInfo = me->GetCharmInfo())
        {
            if (charmInfo->IsCommandAttack() && mCanAutoAttack)
            {
                DoMeleeAttackIfReady();
            }
        }
 
        return;
    }
 
    if (!hasVictim)
        return;
 
    if (mCanAutoAttack)
        DoMeleeAttackIfReady();
}

References CheckConditions(), UnitAI::DoMeleeAttackIfReady(), WorldObject::FindNearestCreature(), Unit::GetCharmInfo(), GetScript(), INTERACTION_DISTANCE, IsAIControlled(), mCanAutoAttack, CreatureAI::me, mFollowArrivedAlive, mFollowArrivedEntry, mFollowArrivedTimer, mFollowGuid, SmartScript::OnUpdate(), StopFollow(), UpdateDespawn(), 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().

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(1);
            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_WAYPOINT_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())
        {
            SetRun(mRun);
            // 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, mRun, mWPPauseTimer, mWPReached, SmartScript::ProcessEventsFor(), RemoveEscortState(), ResumePath(), SetRun(), SMART_ESCORT_ESCORTING, SMART_ESCORT_PAUSED, SMART_ESCORT_RETURNING, SMART_EVENT_DEATH, SMART_EVENT_WAYPOINT_RESUMED, StopPath(), and UNIT_STATE_NOT_MOVE.

Referenced by UpdateAI().

Member Data Documentation

_attackDistance

float SmartAI::_attackDistance

private

Referenced by SetCurrentRangeMode(), and SmartAI().

_chaseOnInterrupt

bool SmartAI::_chaseOnInterrupt

private

Referenced by SmartAI().

_currentRangeMode

bool SmartAI::_currentRangeMode

private

Referenced by SetCurrentRangeMode(), 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(), SmartAI(), and UpdateAI().

mCanRepeatPath

bool SmartAI::mCanRepeatPath

private

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

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(), 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 UpdateAI().

mFollowArrivedEntry

uint32 SmartAI::mFollowArrivedEntry

private

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

mFollowArrivedTimer

uint32 SmartAI::mFollowArrivedTimer

private

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

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

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

WayPoint* SmartAI::mLastWP

private

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

mOOCReached

bool SmartAI::mOOCReached

private

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

mRun

bool SmartAI::mRun

private

Referenced by AttackStart(), EndPath(), EnterEvadeMode(), MovepointReached(), OnCharmed(), PausePath(), ResumePath(), SetFollow(), SetRun(), SmartAI(), and UpdatePath().

mScript

SmartScript SmartAI::mScript

private

Referenced by GetScript().

mWayPoints

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