#include <SmartAI.h>

Public Member Functions
	~SmartAI ()

	SmartAI (Creature *c)

void	StartPath (bool run=false, uint32 path=0, bool repeat=false, Unit *invoker=NULL)

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

bool	HasEscortState (uint32 uiEscortState) const

void	AddEscortState (uint32 uiEscortState)

void	RemoveEscortState (uint32 uiEscortState)

void	SetAutoAttack (bool on)

void	SetCombatMove (bool on)

bool	CanCombatMove ()

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

void	StopFollow ()

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

SmartScript *	GetScript ()

bool	IsEscortInvokerInRange ()

void	JustRespawned () override

void	JustReachedHome () override

void	EnterCombat (Unit *enemy) override

void	EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER) override

void	JustDied (Unit *killer) override

void	KilledUnit (Unit *victim) override

void	JustSummoned (Creature *creature) override

void	AttackStart (Unit *who) override

void	MoveInLineOfSight (Unit *who) override

void	SpellHit (Unit unit, const SpellInfo spellInfo) override

void	SpellHitTarget (Unit target, const SpellInfo spellInfo) override

void	DamageTaken (Unit *doneBy, uint32 &damage) override

void	HealReceived (Unit *doneBy, uint32 &addhealth) override

void	UpdateAI (uint32 diff) override

void	ReceiveEmote (Player *player, uint32 textEmote) override

void	MovementInform (uint32 MovementType, uint32 Data) override

void	IsSummonedBy (Unit *summoner) override

void	DamageDealt (Unit *doneTo, uint32 &damage, DamageEffectType) override

void	SummonedCreatureDespawn (Creature *unit) override

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

void	UpdateAIWhileCharmed (const uint32 diff)

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

void	InitializeAI () override

void	OnCharmed (bool apply) override

bool	CanAIAttack (const Unit *who) const override

void	DoAction (int32 param=0) override

uint32	GetData (uint32 id=0) const override

void	SetData (uint32 id, uint32 value) override

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	SetInvincibilityHpLevel (uint32 level)

void	sGossipHello (Player *player) override

void	sGossipSelect (Player *player, uint32 menuId, uint32 gossipListId) override

void	sGossipSelectCode (Player player, uint32 menuId, uint32 gossipListId, const char code) override

void	sQuestAccept (Player player, Quest const quest) override

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

bool	sOnDummyEffect (Unit *caster, uint32 spellId, SpellEffIndex effIndex) override

void	sOnGameEvent (bool start, uint16 eventId) override

void	SetDespawnTime (uint32 t)

void	StartDespawn ()

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

Public Member Functions inherited from CreatureAI
void	Talk (uint8 id, WorldObject const *whisperTarget=nullptr)

	CreatureAI (Creature *creature)

virtual	~CreatureAI ()

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

void	TriggerAlert (Unit const *who) const

virtual bool	CanRespawn ()

virtual void	SummonedCreatureDies (Creature , Unit )

virtual void	AttackedBy (Unit *)

virtual bool	IsEscorted () const

void	DoZoneInCombat (Creature *creature=NULL, float maxRangeToNearestTarget=50.0f)

virtual void	OwnerAttackedBy (Unit *)

virtual void	OwnerAttacked (Unit *)

virtual bool	CanSeeAlways (WorldObject const *)

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

virtual bool	CheckInRoom ()

CreatureBoundary const *	GetBoundary () const

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

virtual	~UnitAI ()

virtual void	Reset ()

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

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

void	SelectTargetList (std::list< Unit * > &targetList, uint32 num, SelectAggroTarget targetType, float dist=0.0f, bool playerOnly=false, int32 aura=0)

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

virtual void	HealDone (Unit *, uint32 &)

virtual void	SpellInterrupted (uint32, uint32)

void	AttackStartCaster (Unit *victim, float dist)

void	DoCast (uint32 spellId)

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

void	DoCastVictim (uint32 spellId, bool triggered=false)

void	DoCastAOE (uint32 spellId, bool triggered=false)

void	DoMeleeAttackIfReady ()

bool	DoSpellAttackIfReady (uint32 spellId)

virtual void	sQuestSelect (Player , Quest const )

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

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

bool	AssistPlayerInCombat (Unit *who)

void	UpdateDespawn (const uint32 diff)

Additional Inherited Members
Public Types inherited from CreatureAI
enum	EvadeReason { EVADE_REASON_NO_HOSTILES, EVADE_REASON_BOUNDARY, EVADE_REASON_SEQUENCE_BREAK, 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	CheckBoundary (Position const *who=nullptr) const

void	SetBoundary (CreatureBoundary const *boundary)

bool	_EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

Protected Attributes inherited from CreatureAI
Creature *const	me

CreatureBoundary const *	_boundary

Protected Attributes inherited from UnitAI
Unit *const	me

Constructor & Destructor Documentation

SmartAI::~SmartAI ( )

inline

48 { }

SmartAI::SmartAI ( Creature * c )

explicit

  : CreatureAI(c)
 {
  // copy script to local (protection for table reload)
 
  mWayPoints = NULL;
  mEscortState = SMART_ESCORT_NONE;
  mCurrentWPID = 0;//first wp id is 1 !!
  mWPReached = false;
  mWPPauseTimer = 0;
  mLastWP = NULL;
 
  mCanRepeatPath = false;
 
  // spawn in run mode
  me->SetWalk(false);
  mRun = false;
 
  mLastOOCPos = me->GetPosition();
 
  mCanAutoAttack = true;
  mCanCombatMove = true;
 
  mForcedPaused = false;
  mLastWPIDReached = 0;
 
  mEscortQuestID = 0;
 
  mDespawnTime = 0;
  mDespawnState = 0;
 
  mEscortInvokerCheckTimer = 1000;
  mFollowGuid.Clear();
  mFollowDist = 0;
  mFollowAngle = 0;
  mFollowCredit = 0;
  mFollowArrivedEntry = 0;
  mFollowCreditType = 0;
  mFollowArrivedTimer = 0;
  mInvincibilityHpLevel = 0;
 
  mJustReset = false;
 }

Here is the call graph for this function:

Member Function Documentation

void SmartAI::AddEscortState ( uint32 uiEscortState )

inline

60 { mEscortState |= uiEscortState; }

SmartAI::mEscortState

uint32 mEscortState

Definition: SmartAI.h:210

Here is the caller graph for this function:

bool SmartAI::AssistPlayerInCombat ( Unit * who )

private

 {
  if (!who || !who->GetVictim())
  return false;
 
  //experimental (unknown) flag not present
  if (!(me->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_CAN_ASSIST))
  return false;
 
  //not a player
  if (!who->EnsureVictim()->GetCharmerOrOwnerPlayerOrPlayerItself())
  return false;
 
  //never attack friendly
  if (me->IsFriendlyTo(who))
  return false;
 
  //too far away and no free sight?
  if (me->IsWithinDistInMap(who, SMART_MAX_AID_DIST) && me->IsWithinLOSInMap(who))
  {
  //already fighting someone?
  if (!me->GetVictim())
  {
  AttackStart(who);
  return true;
  }
  else
  {
  who->SetInCombatWith(me);
  me->AddThreat(who, 0.0f);
  return true;
  }
  }
 
  return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::AttackStart ( Unit * who )

overridevirtual

Reimplemented from UnitAI.

 {
  if (who && me->Attack(who, me->IsWithinMeleeRange(who)))
  {
  if (mCanCombatMove)
  me->GetMotionMaster()->MoveChase(who);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

Reimplemented in npc_frostwing_vrykul::npc_frostwing_vrykulAI.

 {
  return !(me->HasReactState(REACT_PASSIVE));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SmartAI::CanCombatMove ( )

inline

64 { return mCanCombatMove; }

SmartAI::mCanCombatMove

bool mCanCombatMove

Definition: SmartAI.h:221

void SmartAI::CorpseRemoved ( uint32 & )

overridevirtual

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

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

Reimplemented from CreatureAI.

 {
  GetScript()->ProcessEventsFor(SMART_EVENT_CORPSE_REMOVED, NULL, respawnDelay);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

void SmartAI::DamageTaken	(	Unit *	doneBy,
		uint32 &	damage
	)

overridevirtual

Reimplemented from UnitAI.

 {
  GetScript()->ProcessEventsFor(SMART_EVENT_DAMAGED, doneBy, damage);
  if (mInvincibilityHpLevel && (damage >= me->GetHealth() - mInvincibilityHpLevel))
  damage = me->GetHealth() - mInvincibilityHpLevel; // damage should not be nullified, because of player damage req.
 }

Here is the call graph for this function:

void SmartAI::DoAction ( int32 param = 0 )

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

void SmartAI::EndPath ( bool fail = false )

 {
  GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_ENDED, NULL, mLastWP->id, GetScript()->GetPathId());
 
  RemoveEscortState(SMART_ESCORT_ESCORTING | SMART_ESCORT_PAUSED | SMART_ESCORT_RETURNING);
  mWayPoints = NULL;
  mCurrentWPID = 0;
  mWPPauseTimer = 0;
  mLastWP = NULL;
 
  if (mCanRepeatPath)
  StartPath(mRun, GetScript()->GetPathId(), true);
  else
  GetScript()->SetPathId(0);
 
  ObjectList* targets = GetScript()->GetTargetList(SMART_ESCORT_TARGETS);
  if (targets && mEscortQuestID)
  {
  if (targets->size() == 1 && GetScript()->IsPlayer((*targets->begin())))
  {
  Player* player = (*targets->begin())->ToPlayer();
  if (!fail && player->IsAtGroupRewardDistance(me) && !player->HasCorpse())
  player->GroupEventHappens(mEscortQuestID, me);
 
  if (fail && player->GetQuestStatus(mEscortQuestID) == QUEST_STATUS_INCOMPLETE)
  player->FailQuest(mEscortQuestID);
 
  if (Group* group = player->GetGroup())
  {
  for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
  {
  Player* groupGuy = groupRef->GetSource();
 
  if (!fail && groupGuy->IsAtGroupRewardDistance(me) && !groupGuy->HasCorpse())
  groupGuy->AreaExploredOrEventHappens(mEscortQuestID);
  if (fail && groupGuy->GetQuestStatus(mEscortQuestID) == QUEST_STATUS_INCOMPLETE)
  groupGuy->FailQuest(mEscortQuestID);
  }
  }
  }else
  {
  for (ObjectList::iterator iter = targets->begin(); iter != targets->end(); ++iter)
  {
  if (GetScript()->IsPlayer((*iter)))
  {
  Player* player = (*iter)->ToPlayer();
  if (!fail && player->IsAtGroupRewardDistance(me) && !player->HasCorpse())
  player->AreaExploredOrEventHappens(mEscortQuestID);
  if (fail && player->GetQuestStatus(mEscortQuestID) == QUEST_STATUS_INCOMPLETE)
  player->FailQuest(mEscortQuestID);
  }
  }
  }
  }
  if (mDespawnState == 1)
  StartDespawn();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::EnterCombat ( Unit * enemy )

overridevirtual

Reimplemented from CreatureAI.

 {
  me->InterruptNonMeleeSpells(false); // must be before ProcessEvents
  GetScript()->ProcessEventsFor(SMART_EVENT_AGGRO, enemy);
  mLastOOCPos = me->GetPosition();
  SetRun(mRun);
  if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_ACTIVE) == POINT_MOTION_TYPE)
  me->GetMotionMaster()->MovementExpired();
 }

Here is the call graph for this function:

void SmartAI::EnterEvadeMode ( EvadeReason why = EVADE_REASON_OTHER )

overridevirtual

Reimplemented from CreatureAI.

 {
  if (!me->IsAlive() || me->IsInEvadeMode())
  return;
 
  me->RemoveAllAurasExceptType(SPELL_AURA_CONTROL_VEHICLE, SPELL_AURA_CLONE_CASTER);
 
  me->AddUnitState(UNIT_STATE_EVADE);
  me->DeleteThreatList();
  me->CombatStop(true);
  me->LoadCreaturesAddon();
  me->SetLootRecipient(NULL);
  me->ResetPlayerDamageReq();
  me->SetLastDamagedTime(0);
 
  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.IsEmpty())
  {
  if (Unit* target = ObjectAccessor::GetUnit(*me, mFollowGuid))
  me->GetMotionMaster()->MoveFollow(target, mFollowDist, mFollowAngle);
 
  // evade is not cleared in MoveFollow, so we can't keep it
  me->ClearUnitState(UNIT_STATE_EVADE);
  }
  else
  me->GetMotionMaster()->MoveTargetedHome();
 
  if (!HasEscortState(SMART_ESCORT_ESCORTING))//dont mess up escort movement after combat
  SetRun(mRun);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

 {
  return 0;
 }

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

overridevirtual

Reimplemented from UnitAI.

 {
  return ObjectGuid::Empty;
 }

WayPoint * SmartAI::GetNextWayPoint ( )

 {
  if (!mWayPoints || mWayPoints->empty())
  return NULL;
 
  mCurrentWPID++;
  WPPath::const_iterator itr = mWayPoints->find(mCurrentWPID);
  if (itr != mWayPoints->end())
  {
  mLastWP = (*itr).second;
  if (mLastWP->id != mCurrentWPID)
  {
  TC_LOG_ERROR("misc", "SmartAI::GetNextWayPoint: Got not expected waypoint id %u, expected %u", mLastWP->id, mCurrentWPID);
  }
  return (*itr).second;
  }
  return NULL;
 }

Here is the caller graph for this function:

SmartScript* SmartAI::GetScript ( )

inline

69 { return &mScript; }

SmartAI::mScript

SmartScript mScript

Definition: SmartAI.h:208

Here is the caller graph for this function:

uint32 SmartAI::GetWPCount ( ) const

inlineprivate

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

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

SmartAI::mWayPoints

WPPath * mWayPoints

Definition: SmartAI.h:209

Here is the caller graph for this function:

bool SmartAI::HasEscortState ( uint32 uiEscortState ) const

inline

59 { return (mEscortState & uiEscortState) != 0; }

SmartAI::mEscortState

uint32 mEscortState

Definition: SmartAI.h:210

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

void SmartAI::InitializeAI ( )

overridevirtual

Reimplemented from UnitAI.

 {
  GetScript()->OnInitialize(me);
  if (!me->isDead())
  mJustReset = true;
  JustReachedHome();
  GetScript()->ProcessEventsFor(SMART_EVENT_RESPAWN);
 }

Here is the call graph for this function:

bool SmartAI::IsEscortInvokerInRange ( )

 {
  ObjectList* targets = GetScript()->GetTargetList(SMART_ESCORT_TARGETS);
  if (targets)
  {
  if (targets->size() == 1 && GetScript()->IsPlayer((*targets->begin())))
  {
  Player* player = (*targets->begin())->ToPlayer();
  if (me->GetDistance(player) <= SMART_ESCORT_MAX_PLAYER_DIST)
  return true;
 
  if (Group* group = player->GetGroup())
  {
  for (GroupReference* groupRef = group->GetFirstMember(); groupRef != NULL; groupRef = groupRef->next())
  {
  Player* groupGuy = groupRef->GetSource();
 
  if (me->GetDistance(groupGuy) <= SMART_ESCORT_MAX_PLAYER_DIST)
  return true;
  }
  }
  }else
  {
  for (ObjectList::iterator iter = targets->begin(); iter != targets->end(); ++iter)
  {
  if (GetScript()->IsPlayer((*iter)))
  {
  if (me->GetDistance((*iter)->ToPlayer()) <= SMART_ESCORT_MAX_PLAYER_DIST)
  return true;
  }
             }
         }
     }
     return true;//escort targets were not set, ignore range check
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::IsSummonedBy ( Unit * summoner )

overridevirtual

Reimplemented from CreatureAI.

 {
     GetScript()->ProcessEventsFor(SMART_EVENT_JUST_SUMMONED, summoner);
 }

Here is the call graph for this function:

void SmartAI::JustDied ( Unit * killer )

overridevirtual

Reimplemented from CreatureAI.

 {
     GetScript()->ProcessEventsFor(SMART_EVENT_DEATH, killer);
     if (HasEscortState(SMART_ESCORT_ESCORTING))
     {
         EndPath(true);
         me->StopMoving();//force stop
         me->GetMotionMaster()->MoveIdle();
     }
 }

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

void SmartAI::JustSummoned ( Creature * creature )

overridevirtual

Reimplemented from CreatureAI.

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

Here is the call graph for this function:

void SmartAI::KilledUnit ( Unit * victim )

overridevirtual

Reimplemented from CreatureAI.

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::MoveInLineOfSight ( Unit * who )

overridevirtual

Reimplemented from CreatureAI.

 {
     if (!who)
         return;
 
     GetScript()->OnMoveInLineOfSight(who);
 
     if (AssistPlayerInCombat(who))
         return;
 
     CreatureAI::MoveInLineOfSight(who);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from CreatureAI.

 {
     if ((MovementType == POINT_MOTION_TYPE && Data == SMART_ESCORT_LAST_OOC_POINT) || MovementType == FOLLOW_MOTION_TYPE)
         me->ClearUnitState(UNIT_STATE_EVADE);
 
     GetScript()->ProcessEventsFor(SMART_EVENT_MOVEMENTINFORM, NULL, MovementType, Data);
     if (MovementType != POINT_MOTION_TYPE || !HasEscortState(SMART_ESCORT_ESCORTING))
         return;
     MovepointReached(Data);
 }

Here is the call graph for this function:

void SmartAI::MovepointReached ( uint32 id )

 {
     if (id != SMART_ESCORT_LAST_OOC_POINT && mLastWPIDReached != id)
         GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_REACHED, NULL, id);
 
     mLastWPIDReached = id;
     mWPReached = true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::OnCharmed ( bool apply )

overridevirtual

Reimplemented from CreatureAI.

 {
     GetScript()->ProcessEventsFor(SMART_EVENT_CHARMED, NULL, 0, 0, apply);
 
     if (!apply && !me->IsInEvadeMode() && !me->GetCharmerGUID().IsEmpty())
         if (Unit* charmer = ObjectAccessor::GetUnit(*me, me->GetCharmerGUID()))
             AttackStart(charmer);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from CreatureAI.

 {
     if (!result)
         return;
 
     GetScript()->ProcessEventsFor(SMART_EVENT_ON_SPELLCLICK, clicker);
 }

Here is the call graph for this function:

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

Here is the call graph for this function:

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

 {
     if (!HasEscortState(SMART_ESCORT_ESCORTING))
         return;
     if (HasEscortState(SMART_ESCORT_PAUSED))
     {
         TC_LOG_ERROR("misc", "SmartAI::StartPath: Creature entry %u wanted to pause waypoint movement while already paused, ignoring.", me->GetEntry());
         return;
     }
     mForcedPaused = forced;
     mLastOOCPos = me->GetPosition();
     AddEscortState(SMART_ESCORT_PAUSED);
     mWPPauseTimer = delay;
     if (forced)
     {
         SetRun(mRun);
         me->StopMoving();//force stop
         me->GetMotionMaster()->MoveIdle();//force stop
     }
     GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_PAUSED, NULL, mLastWP->id, GetScript()->GetPathId());
 }

Here is the call graph for this function:

int SmartAI::Permissible ( const Creature * creature )

static

 {
     if (creature->GetAIName() == "SmartAI")
         return PERMIT_BASE_SPECIAL;
     return PERMIT_BASE_NO;
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from CreatureAI.

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

Here is the call graph for this function:

void SmartAI::RemoveEscortState ( uint32 uiEscortState )

inline

61 { mEscortState &= ~uiEscortState; }

SmartAI::mEscortState

uint32 mEscortState

Definition: SmartAI.h:210

Here is the caller graph for this function:

void SmartAI::ResumePath ( )

 {
     //mWPReached = false;
     SetRun(mRun);
     if (mLastWP)
         me->GetMotionMaster()->MovePoint(mLastWP->id, mLastWP->x, mLastWP->y, mLastWP->z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::ReturnToLastOOCPos ( )

private

 {
     SetRun(mRun);
     me->GetMotionMaster()->MovePoint(SMART_ESCORT_LAST_OOC_POINT, mLastOOCPos);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::SetAutoAttack ( bool on )

inline

62 { mCanAutoAttack = on; }

SmartAI::mCanAutoAttack

bool mCanAutoAttack

Definition: SmartAI.h:220

void SmartAI::SetCombatMove ( bool on )

 {
     if (mCanCombatMove == on)
         return;
     mCanCombatMove = on;
     if (!HasEscortState(SMART_ESCORT_ESCORTING))
     {
         if (on && me->GetVictim())
         {
             if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == IDLE_MOTION_TYPE)
             {
                 SetRun(mRun);
                 me->GetMotionMaster()->MoveChase(me->GetVictim());
                 me->CastStop();
             }
         }
         else
         {
             if (me->HasUnitState(UNIT_STATE_CONFUSED_MOVE | UNIT_STATE_FLEEING_MOVE))
                 return;
 
             me->GetMotionMaster()->MovementExpired();
             me->GetMotionMaster()->Clear(true);
             me->StopMoving();
             me->GetMotionMaster()->MoveIdle();
         }
     }
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

 {
     GetScript()->ProcessEventsFor(SMART_EVENT_DATA_SET, NULL, id, value);
 }

Here is the call graph for this function:

void SmartAI::SetDespawnTime ( uint32 t )

inline

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

Here is the caller graph for this function:

void SmartAI::SetFly ( bool fly = true )

 {
     me->SetDisableGravity(fly);
 }

Here is the call graph for this function:

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

 {
     if (!target)
     {
         StopFollow();
         return;
     }
 
     SetRun(mRun);
     mFollowGuid = target->GetGUID();
     mFollowDist = dist >= 0.0f ? dist : PET_FOLLOW_DIST;
     mFollowAngle = angle >= 0.0f ? angle : me->GetFollowAngle();
     mFollowArrivedTimer = 1000;
     mFollowCredit = credit;
     mFollowArrivedEntry = end;
     me->GetMotionMaster()->MoveFollow(target, mFollowDist, mFollowAngle);
     mFollowCreditType = creditType;
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

673 { }

void SmartAI::SetInvincibilityHpLevel ( uint32 level )

inline

175 { mInvincibilityHpLevel = level; }

SmartAI::mInvincibilityHpLevel

uint32 mInvincibilityHpLevel

Definition: SmartAI.h:223

Here is the caller graph for this function:

void SmartAI::SetRun ( bool run = true )

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

void SmartAI::SetSwim ( bool swim = true )

 {
     me->SetSwim(swim);
 }

Here is the call graph for this function:

void SmartAI::sGossipHello ( Player * player )

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

void SmartAI::sGossipSelect	(	Player *	player,
		uint32	menuId,
		uint32	gossipListId
	)

overridevirtual

Reimplemented from UnitAI.

 {
     GetScript()->ProcessEventsFor(SMART_EVENT_GOSSIP_SELECT, player, menuId, gossipListId);
 }

Here is the call graph for this function:

void SmartAI::sGossipSelectCode	(	Player *	player,
		uint32	menuId,
		uint32	gossipListId,
		const char *	code
	)

overridevirtual

Reimplemented from UnitAI.

706 { }

bool SmartAI::sOnDummyEffect	(	Unit *	caster,
		uint32	spellId,
		SpellEffIndex	effIndex
	)

overridevirtual

Reimplemented from UnitAI.

 {
     GetScript()->ProcessEventsFor(SMART_EVENT_DUMMY_EFFECT, caster, spellId, (uint32)effIndex);
     return true;
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

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

overridevirtual

Reimplemented from CreatureAI.

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

Here is the call graph for this function:

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

overridevirtual

Reimplemented from CreatureAI.

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

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

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

overridevirtual

Reimplemented from UnitAI.

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

Here is the call graph for this function:

void SmartAI::StartDespawn ( )

inline

193 { mDespawnState = 2; }

SmartAI::mDespawnState

uint32 mDespawnState

Definition: SmartAI.h:227

Here is the caller graph for this function:

void SmartAI::StartPath	(	bool	run = `false`,
		uint32	path = `0`,
		bool	repeat = `false`,
		Unit *	invoker = `NULL`
	)

 {
     if (me->IsInCombat())// no wp movement in combat
     {
         TC_LOG_ERROR("misc", "SmartAI::StartPath: Creature entry %u wanted to start waypoint movement while in combat, ignoring.", me->GetEntry());
         return;
     }
     if (HasEscortState(SMART_ESCORT_ESCORTING))
         StopPath();
     if (path)
         if (!LoadPath(path))
             return;
     if (!mWayPoints || mWayPoints->empty())
         return;
 
     AddEscortState(SMART_ESCORT_ESCORTING);
     mCanRepeatPath = repeat;
 
     SetRun(run);
 
     if (WayPoint* wp = GetNextWayPoint())
     {
         mLastOOCPos = me->GetPosition();
         me->GetMotionMaster()->MovePoint(wp->id, wp->x, wp->y, wp->z);
         GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_START, NULL, wp->id, GetScript()->GetPathId());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::StopFollow ( )

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!HasEscortState(SMART_ESCORT_ESCORTING))
         return;
 
     if (quest)
         mEscortQuestID = quest;
     SetDespawnTime(DespawnTime);
     //mDespawnTime = DespawnTime;
 
     mLastOOCPos = me->GetPosition();
     me->StopMoving();//force stop
     me->GetMotionMaster()->MoveIdle();
     GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_STOPPED, NULL, mLastWP->id, GetScript()->GetPathId());
     EndPath(fail);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::SummonedCreatureDespawn ( Creature * unit )

overridevirtual

Reimplemented from CreatureAI.

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

Here is the call graph for this function:

void SmartAI::UpdateAI ( uint32 diff )

overridevirtual

Todo:: move to void

Implements UnitAI.

 {
     GetScript()->OnUpdate(diff);
     UpdatePath(diff);
     UpdateDespawn(diff);
 
     if (!mFollowGuid.IsEmpty())
     {
         if (mFollowArrivedTimer < diff)
         {
             if (me->FindNearestCreature(mFollowArrivedEntry, INTERACTION_DISTANCE, true))
             {
                 StopFollow();
                 return;
             }
 
             mFollowArrivedTimer = 1000;
         }
         else
             mFollowArrivedTimer -= diff;
     }
 
     if (!UpdateVictim())
         return;
 
     if (mCanAutoAttack)
         DoMeleeAttackIfReady();
 }

Here is the call graph for this function:

void SmartAI::UpdateAIWhileCharmed ( const uint32 diff )

628 { }

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

Here is the call graph for this function:

Here is the caller graph for this function:

void SmartAI::UpdatePath ( const uint32 diff )

private

 {
     if (!HasEscortState(SMART_ESCORT_ESCORTING))
         return;
     if (mEscortInvokerCheckTimer < diff)
     {
         if (!IsEscortInvokerInRange())
         {
             StopPath(mDespawnTime, mEscortQuestID, true);
         }
         mEscortInvokerCheckTimer = 1000;
     } else mEscortInvokerCheckTimer -= diff;
     // handle pause
     if (HasEscortState(SMART_ESCORT_PAUSED))
     {
         if (mWPPauseTimer < diff)
         {
             if (!me->IsInCombat() && !HasEscortState(SMART_ESCORT_RETURNING) && (mWPReached || mLastWPIDReached == SMART_ESCORT_LAST_OOC_POINT || mForcedPaused))
             {
                 GetScript()->ProcessEventsFor(SMART_EVENT_WAYPOINT_RESUMED, NULL, mLastWP->id, GetScript()->GetPathId());
                 RemoveEscortState(SMART_ESCORT_PAUSED);
                 if (mForcedPaused)// if paused between 2 wps resend movement
                 {
                     ResumePath();
                     mWPReached = false;
                     mForcedPaused = false;
                 }
                 if (mLastWPIDReached == SMART_ESCORT_LAST_OOC_POINT)
                     mWPReached = true;
             }
             mWPPauseTimer = 0;
         } else {
             mWPPauseTimer -= diff;
         }
     }
     if (HasEscortState(SMART_ESCORT_RETURNING))
     {
         if (mWPReached)//reached OOC WP
         {
             RemoveEscortState(SMART_ESCORT_RETURNING);
             if (!HasEscortState(SMART_ESCORT_PAUSED))
                 ResumePath();
             mWPReached = false;
         }
     }
     if ((!me->HasReactState(REACT_PASSIVE) && me->IsInCombat()) || HasEscortState(SMART_ESCORT_PAUSED | SMART_ESCORT_RETURNING))
         return;
     // handle next wp
     if (mWPReached)//reached WP
     {
         mWPReached = false;
         if (mCurrentWPID == GetWPCount())
         {
             EndPath();
         }
         else if (WayPoint* wp = GetNextWayPoint())
         {
             SetRun(mRun);
             me->GetMotionMaster()->MovePoint(wp->id, wp->x, wp->y, wp->z);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bool SmartAI::mCanAutoAttack

private

bool SmartAI::mCanCombatMove

private

bool SmartAI::mCanRepeatPath

private

uint32 SmartAI::mCurrentWPID

private

uint32 SmartAI::mDespawnState

private

uint32 SmartAI::mDespawnTime

private

uint32 SmartAI::mEscortInvokerCheckTimer

private

uint32 SmartAI::mEscortQuestID

uint32 SmartAI::mEscortState

private

float SmartAI::mFollowAngle

private

uint32 SmartAI::mFollowArrivedEntry

private

uint32 SmartAI::mFollowArrivedTimer

private

uint32 SmartAI::mFollowCredit

private

uint32 SmartAI::mFollowCreditType

private

float SmartAI::mFollowDist

private

ObjectGuid SmartAI::mFollowGuid

private

bool SmartAI::mForcedPaused

private

uint32 SmartAI::mInvincibilityHpLevel

private

bool SmartAI::mJustReset

private

Position SmartAI::mLastOOCPos

private

WayPoint* SmartAI::mLastWP

private

uint32 SmartAI::mLastWPIDReached

private

bool SmartAI::mRun

private

SmartScript SmartAI::mScript

private

WPPath* SmartAI::mWayPoints

private

uint32 SmartAI::mWPPauseTimer

private

bool SmartAI::mWPReached

private

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

src/server/game/AI/SmartScripts/SmartAI.h
src/server/game/AI/SmartScripts/SmartAI.cpp

Private Attributes
uint32	mFollowCreditType

uint32	mFollowArrivedTimer

uint32	mFollowCredit

uint32	mFollowArrivedEntry

ObjectGuid	mFollowGuid

float	mFollowDist

float	mFollowAngle

SmartScript	mScript

WPPath *	mWayPoints

uint32	mEscortState

uint32	mCurrentWPID

uint32	mLastWPIDReached

bool	mWPReached

uint32	mWPPauseTimer

WayPoint *	mLastWP

Position	mLastOOCPos

bool	mCanRepeatPath

bool	mRun

bool	mCanAutoAttack

bool	mCanCombatMove

bool	mForcedPaused

uint32	mInvincibilityHpLevel

uint32	mDespawnTime

uint32	mDespawnState

uint32	mEscortInvokerCheckTimer

bool	mJustReset

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation