SmartScript Class Reference

#include "SmartScript.h"

Public Types
typedef std::unordered_map< uint32, uint32 >	CounterMap

Public Member Functions
	SmartScript ()
	~SmartScript ()
void	OnInitialize (WorldObject *obj, AreaTrigger const *at=nullptr)
void	GetScript ()
void	FillScript (SmartAIEventList e, WorldObject *obj, AreaTrigger const *at)
void	ProcessEventsFor (SMART_EVENT e, Unit *unit=nullptr, uint32 var0=0, uint32 var1=0, bool bvar=false, SpellInfo const *spell=nullptr, GameObject *gob=nullptr)
void	ProcessEvent (SmartScriptHolder &e, Unit *unit=nullptr, uint32 var0=0, uint32 var1=0, bool bvar=false, SpellInfo const *spell=nullptr, GameObject *gob=nullptr)
bool	CheckTimer (SmartScriptHolder const &e) const
void	UpdateTimer (SmartScriptHolder &e, uint32 const diff)
void	ProcessAction (SmartScriptHolder &e, Unit *unit=nullptr, uint32 var0=0, uint32 var1=0, bool bvar=false, SpellInfo const *spell=nullptr, GameObject *gob=nullptr)
void	ProcessTimedAction (SmartScriptHolder &e, uint32 const &min, uint32 const &max, Unit *unit=nullptr, uint32 var0=0, uint32 var1=0, bool bvar=false, SpellInfo const *spell=nullptr, GameObject *gob=nullptr)
void	GetTargets (ObjectVector &targets, SmartScriptHolder const &e, Unit *invoker=nullptr) const
void	GetWorldObjectsInDist (ObjectVector &objects, float dist) const
void	InstallTemplate (SmartScriptHolder const &e)
void	AddEvent (SMART_EVENT e, uint32 event_flags, uint32 event_param1, uint32 event_param2, uint32 event_param3, uint32 event_param4, uint32 event_param5, SMART_ACTION action, uint32 action_param1, uint32 action_param2, uint32 action_param3, uint32 action_param4, uint32 action_param5, uint32 action_param6, SMARTAI_TARGETS t, uint32 target_param1, uint32 target_param2, uint32 target_param3, uint32 target_param4, uint32 phaseMask)
void	SetPathId (uint32 id)
uint32	GetPathId () const
WorldObject *	GetBaseObject () const
void	OnUpdate (const uint32 diff)
void	OnMoveInLineOfSight (Unit *who)
Unit *	DoSelectLowestHpFriendly (float range, uint32 MinHPDiff) const
Unit *	DoSelectLowestHpPercentFriendly (float range, uint32 minHpPct, uint32 maxHpPct) const
void	DoFindFriendlyCC (std::vector< Creature * > &creatures, float range) const
void	DoFindFriendlyMissingBuff (std::vector< Creature * > &creatures, float range, uint32 spellid) const
Unit *	DoFindClosestFriendlyInRange (float range, bool playerOnly) const
void	StoreTargetList (ObjectVector const &targets, uint32 id)
bool	IsSmart (Creature *c=nullptr)
bool	IsSmartGO (GameObject *g=nullptr)
ObjectVector const *	GetStoredTargetVector (uint32 id, WorldObject const &ref) const
void	StoreCounter (uint32 id, uint32 value, uint32 reset, uint32 subtract)
uint32	GetCounterValue (uint32 id)
GameObject *	FindGameObjectNear (WorldObject *searchObject, ObjectGuid::LowType guid) const
Creature *	FindCreatureNear (WorldObject *searchObject, ObjectGuid::LowType guid) const
void	OnReset ()
void	ResetBaseObject ()
void	SetScript9 (SmartScriptHolder &e, uint32 entry)
Unit *	GetLastInvoker (Unit *invoker=nullptr) const
void	SetActualCombatDist (uint32 dist)
void	RestoreMaxCombatDist ()
uint32	GetActualCombatDist () const
uint32	GetMaxCombatDist () const
void	SetCasterActualDist (float dist)
void	RestoreCasterMaxDist ()
Powers	GetCasterPowerType () const
float	GetCasterActualDist () const
float	GetCasterMaxDist () const
bool	AllowPhaseReset () const
void	SetPhaseReset (bool allow)
void	AddCreatureSummon (ObjectGuid const &guid)
void	RemoveCreatureSummon (ObjectGuid const &guid)

Static Public Member Functions
static void	RecalcTimer (SmartScriptHolder &e, uint32 min, uint32 max)
static void	InitTimer (SmartScriptHolder &e)
static SmartScriptHolder	CreateSmartEvent (SMART_EVENT e, uint32 event_flags, uint32 event_param1, uint32 event_param2, uint32 event_param3, uint32 event_param4, uint32 event_param5, SMART_ACTION action, uint32 action_param1, uint32 action_param2, uint32 action_param3, uint32 action_param4, uint32 action_param5, uint32 action_param6, SMARTAI_TARGETS t, uint32 target_param1, uint32 target_param2, uint32 target_param3, uint32 target_param4, uint32 phaseMask)
static bool	IsUnit (WorldObject *obj)
static bool	IsPlayer (WorldObject *obj)
static bool	IsCreature (WorldObject *obj)
static bool	IsCharmedCreature (WorldObject *obj)
static bool	IsGameObject (WorldObject *obj)

Public Attributes
ObjectGuid	mLastInvoker
CounterMap	mCounterList

Private Member Functions
void	IncPhase (uint32 p)
void	DecPhase (uint32 p)
void	SetPhase (uint32 p)
bool	IsInPhase (uint32 p) const
void	InstallEvents ()
void	RemoveStoredEvent (uint32 id)
SmartScriptHolder	FindLinkedEvent (uint32 link)

Private Attributes
SmartAIEventList	mEvents
SmartAIEventList	mInstallEvents
SmartAIEventList	mTimedActionList
bool	isProcessingTimedActionList
Creature *	me
ObjectGuid	meOrigGUID
GameObject *	go
ObjectGuid	goOrigGUID
AreaTrigger const *	trigger
SmartScriptType	mScriptType
uint32	mEventPhase
std::unordered_map< int32, int32 >	mStoredDecimals
uint32	mPathId
SmartAIEventStoredList	mStoredEvents
std::list< uint32 >	mRemIDs
uint32	mTextTimer
uint32	mLastTextID
uint32	mTalkerEntry
bool	mUseTextTimer
uint32	mActualCombatDist
uint32	mMaxCombatDist
uint32	smartCasterActualDist
uint32	smartCasterMaxDist
Powers	smartCasterPowerType
bool	_allowPhaseReset
ObjectVectorMap	_storedTargets
SMARTAI_TEMPLATE	mTemplate
GuidUnorderedSet	_summonList

Detailed Description

Member Typedef Documentation

CounterMap

typedef std::unordered_map<uint32, uint32> SmartScript::CounterMap

Constructor & Destructor Documentation

SmartScript()

SmartScript::SmartScript

(

)

{
    go = nullptr;
    me = nullptr;
    trigger = nullptr;
    mEventPhase = 0;
    mPathId = 0;
    mTextTimer = 0;
    mLastTextID = 0;
    mUseTextTimer = false;
    mTalkerEntry = 0;
    mTemplate = SMARTAI_TEMPLATE_BASIC;
    mScriptType = SMART_SCRIPT_TYPE_CREATURE;
    isProcessingTimedActionList = false;
 
    // Xinef: Fix Combat Movement
    mActualCombatDist = 0;
    mMaxCombatDist = 0;
 
    smartCasterActualDist = 0.0f;
    smartCasterMaxDist = 0.0f;
    smartCasterPowerType = POWER_MANA;
 
    _allowPhaseReset = true;
}

References _allowPhaseReset, go, isProcessingTimedActionList, mActualCombatDist, me, mEventPhase, mLastTextID, mMaxCombatDist, mPathId, mScriptType, mTalkerEntry, mTemplate, mTextTimer, mUseTextTimer, POWER_MANA, SMART_SCRIPT_TYPE_CREATURE, SMARTAI_TEMPLATE_BASIC, smartCasterActualDist, smartCasterMaxDist, smartCasterPowerType, and trigger.

~SmartScript()

SmartScript::~SmartScript

(

)

{
 
}

Member Function Documentation

AddCreatureSummon()

void SmartScript::AddCreatureSummon

(

ObjectGuid const &

guid

)

{
    _summonList.insert(guid);
}

References _summonList.

Referenced by SmartAI::JustSummoned().

AddEvent()

void SmartScript::AddEvent	(	SMART_EVENT	e,
		uint32	event_flags,
		uint32	event_param1,
		uint32	event_param2,
		uint32	event_param3,
		uint32	event_param4,
		uint32	event_param5,
		SMART_ACTION	action,
		uint32	action_param1,
		uint32	action_param2,
		uint32	action_param3,
		uint32	action_param4,
		uint32	action_param5,
		uint32	action_param6,
		SMARTAI_TARGETS	t,
		uint32	target_param1,
		uint32	target_param2,
		uint32	target_param3,
		uint32	target_param4,
		uint32	phaseMask
	)

{
    mInstallEvents.push_back(CreateSmartEvent(e, event_flags, event_param1, event_param2, event_param3, event_param4, event_param5, action, action_param1, action_param2, action_param3, action_param4, action_param5, action_param6, t, target_param1, target_param2, target_param3, target_param4, phaseMask));
}

References CreateSmartEvent(), and mInstallEvents.

Referenced by InstallTemplate().

AllowPhaseReset()

bool SmartScript::AllowPhaseReset ( ) const

inline

{ return _allowPhaseReset; }

References _allowPhaseReset.

Referenced by OnReset().

CheckTimer()

bool SmartScript::CheckTimer

(

SmartScriptHolder const &

e

)

const

{
    return e.active;
}

References SmartScriptHolder::active.

CreateSmartEvent()

SmartScriptHolder SmartScript::CreateSmartEvent ( SMART_EVENT  e, uint32  event_flags, uint32  event_param1, uint32  event_param2, uint32  event_param3, uint32  event_param4, uint32  event_param5, SMART_ACTION  action, uint32  action_param1, uint32  action_param2, uint32  action_param3, uint32  action_param4, uint32  action_param5, uint32  action_param6, SMARTAI_TARGETS  t, uint32  target_param1, uint32  target_param2, uint32  target_param3, uint32  target_param4, uint32  phaseMask  )

static

{
    SmartScriptHolder script;
    script.event.type = e;
    script.event.raw.param1 = event_param1;
    script.event.raw.param2 = event_param2;
    script.event.raw.param3 = event_param3;
    script.event.raw.param4 = event_param4;
    script.event.raw.param5 = event_param5;
    script.event.event_phase_mask = phaseMask;
    script.event.event_flags = event_flags;
    script.event.event_chance = 100;
 
    script.action.type = action;
    script.action.raw.param1 = action_param1;
    script.action.raw.param2 = action_param2;
    script.action.raw.param3 = action_param3;
    script.action.raw.param4 = action_param4;
    script.action.raw.param5 = action_param5;
    script.action.raw.param6 = action_param6;
 
    script.target.type = t;
    script.target.raw.param1 = target_param1;
    script.target.raw.param2 = target_param2;
    script.target.raw.param3 = target_param3;
    script.target.raw.param4 = target_param4;
 
    script.source_type = SMART_SCRIPT_TYPE_CREATURE;
    InitTimer(script);
    return script;
}

References SmartScriptHolder::action, SmartScriptHolder::event, SmartEvent::event_chance, SmartEvent::event_flags, SmartEvent::event_phase_mask, InitTimer(), SmartEvent::param1, SmartAction::param1, SmartTarget::param1, SmartEvent::param2, SmartAction::param2, SmartTarget::param2, SmartEvent::param3, SmartAction::param3, SmartTarget::param3, SmartEvent::param4, SmartAction::param4, SmartTarget::param4, SmartEvent::param5, SmartAction::param5, SmartAction::param6, SmartEvent::raw, SmartAction::raw, SmartTarget::raw, SMART_SCRIPT_TYPE_CREATURE, SmartScriptHolder::source_type, SmartScriptHolder::target, SmartEvent::type, SmartAction::type, and SmartTarget::type.

Referenced by AddEvent().

DecPhase()

void SmartScript::DecPhase ( uint32  p )

private

{
    if (p >= mEventPhase)
    {
        SetPhase(0);
    }
    else
    {
        SetPhase(mEventPhase - p);
    }
}

References mEventPhase, and SetPhase().

Referenced by ProcessAction().

DoFindClosestFriendlyInRange()

Unit * SmartScript::DoFindClosestFriendlyInRange	(	float	range,
		bool	playerOnly
	)		const

{
    if (!me)
        return nullptr;
 
    Unit* unit = nullptr;
    Acore::AnyFriendlyNotSelfUnitInObjectRangeCheck u_check(me, me, range, playerOnly);
    Acore::UnitLastSearcher<Acore::AnyFriendlyNotSelfUnitInObjectRangeCheck> searcher(me, unit, u_check);
    Cell::VisitAllObjects(me, searcher, range);
    return unit;
}

References me, and Cell::VisitAllObjects().

Referenced by GetTargets().

DoFindFriendlyCC()

void SmartScript::DoFindFriendlyCC	(	std::vector< Creature * > &	creatures,
		float	range
	)		const

{
    if (!me)
        return;
 
    Acore::FriendlyCCedInRange u_check(me, range);
    Acore::CreatureListSearcher<Acore::FriendlyCCedInRange> searcher(me, creatures, u_check);
    Cell::VisitGridObjects(me, searcher, range);
}

References me, and Cell::VisitGridObjects().

Referenced by ProcessEvent().

DoFindFriendlyMissingBuff()

void SmartScript::DoFindFriendlyMissingBuff	(	std::vector< Creature * > &	creatures,
		float	range,
		uint32	spellid
	)		const

{
    if (!me)
        return;
 
    Acore::FriendlyMissingBuffInRange u_check(me, range, spellid);
    Acore::CreatureListSearcher<Acore::FriendlyMissingBuffInRange> searcher(me, creatures, u_check);
    Cell::VisitGridObjects(me, searcher, range);
}

References me, and Cell::VisitGridObjects().

Referenced by ProcessEvent().

DoSelectLowestHpFriendly()

Unit * SmartScript::DoSelectLowestHpFriendly	(	float	range,
		uint32	MinHPDiff
	)		const

{
    if (!me)
        return nullptr;
 
    Unit* unit = nullptr;
 
    Acore::MostHPMissingInRange u_check(me, range, MinHPDiff);
    Acore::UnitLastSearcher<Acore::MostHPMissingInRange> searcher(me, unit, u_check);
    Cell::VisitGridObjects(me, searcher, range);
    return unit;
}

References me, and Cell::VisitGridObjects().

Referenced by ProcessEvent().

DoSelectLowestHpPercentFriendly()

Unit * SmartScript::DoSelectLowestHpPercentFriendly	(	float	range,
		uint32	minHpPct,
		uint32	maxHpPct
	)		const

{
    if (!me)
    {
        return nullptr;
    }
 
    Unit* unit = nullptr;
    Acore::MostHPPercentMissingInRange u_check(me, range, minHpPct, maxHpPct);
    Acore::UnitLastSearcher<Acore::MostHPPercentMissingInRange> searcher(me, unit, u_check);
    Cell::VisitGridObjects(me, searcher, range);
    return unit;
}

References me, and Cell::VisitGridObjects().

Referenced by ProcessEvent().

FillScript()

void SmartScript::FillScript	(	SmartAIEventList	e,
		WorldObject *	obj,
		AreaTrigger const *	at
	)

{
    (void)at; // ensure that the variable is referenced even if extra logs are disabled in order to pass compiler checks
 
    if (e.empty())
    {
        if (obj)
            LOG_DEBUG("sql.sql", "SmartScript: EventMap for Entry {} is empty but is using SmartScript.", obj->GetEntry());
 
        if (at)
            LOG_DEBUG("sql.sql", "SmartScript: EventMap for AreaTrigger {} is empty but is using SmartScript.", at->entry);
        return;
    }
    for (SmartAIEventList::iterator i = e.begin(); i != e.end(); ++i)
    {
#ifndef ACORE_DEBUG
        if ((*i).event.event_flags & SMART_EVENT_FLAG_DEBUG_ONLY)
            continue;
#endif
 
        if ((*i).event.event_flags & SMART_EVENT_FLAG_DIFFICULTY_ALL)//if has instance flag add only if in it
        {
            if (obj && obj->GetMap()->IsDungeon())
            {
                if ((1 << (obj->GetMap()->GetSpawnMode() + 1)) & (*i).event.event_flags)
                {
                    mEvents.push_back((*i));
                }
            }
            continue;
        }
        mEvents.push_back((*i));//NOTE: 'world(0)' events still get processed in ANY instance mode
    }
}

References AreaTrigger::entry, Object::GetEntry(), WorldObject::GetMap(), Map::GetSpawnMode(), Map::IsDungeon(), LOG_DEBUG, mEvents, SMART_EVENT_FLAG_DEBUG_ONLY, and SMART_EVENT_FLAG_DIFFICULTY_ALL.

Referenced by GetScript().

FindCreatureNear()

Creature * SmartScript::FindCreatureNear ( WorldObject *  searchObject, ObjectGuid::LowType  guid  ) const

inline

    {
        auto bounds = searchObject->GetMap()->GetCreatureBySpawnIdStore().equal_range(guid);
        if (bounds.first == bounds.second)
            return nullptr;
 
        auto creatureItr = std::find_if(bounds.first, bounds.second, [](Map::CreatureBySpawnIdContainer::value_type const& pair)
        {
            return pair.second->IsAlive();
        });
 
        return creatureItr != bounds.second ? creatureItr->second : bounds.first->second;
    }

References Map::GetCreatureBySpawnIdStore(), and WorldObject::GetMap().

Referenced by GetTargets(), and ProcessEvent().

FindGameObjectNear()

GameObject * SmartScript::FindGameObjectNear ( WorldObject *  searchObject, ObjectGuid::LowType  guid  ) const

inline

    {
        auto bounds = searchObject->GetMap()->GetGameObjectBySpawnIdStore().equal_range(guid);
        if (bounds.first == bounds.second)
            return nullptr;
 
        return bounds.first->second;
    }

References Map::GetGameObjectBySpawnIdStore(), and WorldObject::GetMap().

Referenced by GetTargets(), and ProcessEvent().

FindLinkedEvent()

SmartScriptHolder SmartScript::FindLinkedEvent ( uint32  link )

inlineprivate

    {
        if (!mEvents.empty())
        {
            for (SmartAIEventList::iterator i = mEvents.begin(); i != mEvents.end(); ++i)
            {
                if (i->event_id == link)
                {
                    return (*i);
                }
            }
        }
        SmartScriptHolder s;
        return s;
    }

References mEvents.

GetActualCombatDist()

uint32 SmartScript::GetActualCombatDist ( ) const

inline

{ return mActualCombatDist; }

References mActualCombatDist.

Referenced by SmartAI::AttackStart().

GetBaseObject()

WorldObject * SmartScript::GetBaseObject ( ) const

inline

    {
        WorldObject* obj = nullptr;
        if (me)
            obj = me;
        else if (go)
            obj = go;
        return obj;
    }

References go, and me.

Referenced by GetLastInvoker(), GetTargets(), GetWorldObjectsInDist(), InstallTemplate(), OnUpdate(), ProcessAction(), ProcessEvent(), ProcessEventsFor(), and ProcessTimedAction().

GetCasterActualDist()

float SmartScript::GetCasterActualDist ( ) const

inline

{ return smartCasterActualDist; }

References smartCasterActualDist.

Referenced by SmartAI::AttackStart(), and ProcessAction().

GetCasterMaxDist()

float SmartScript::GetCasterMaxDist ( ) const

inline

{ return smartCasterMaxDist; }

References smartCasterMaxDist.

Referenced by ProcessAction().

GetCasterPowerType()

Powers SmartScript::GetCasterPowerType ( ) const

inline

{ return smartCasterPowerType; }

References smartCasterPowerType.

Referenced by ProcessAction().

GetCounterValue()

uint32 SmartScript::GetCounterValue ( uint32  id )

inline

    {
        CounterMap::iterator itr = mCounterList.find(id);
        if (itr != mCounterList.end())
            return itr->second;
        return 0;
    }

References mCounterList.

Referenced by ProcessEvent().

GetLastInvoker()

Unit * SmartScript::GetLastInvoker

(

Unit *

invoker = nullptr

)

const

{
    // Xinef: Look for invoker only on map of base object... Prevents multithreaded crashes
    if (GetBaseObject())
        return ObjectAccessor::GetUnit(*GetBaseObject(), mLastInvoker);
    // xinef: used for area triggers invoker cast
    else if (invoker)
        return ObjectAccessor::GetUnit(*invoker, mLastInvoker);
    return nullptr;
}

References GetBaseObject(), ObjectAccessor::GetUnit(), and mLastInvoker.

Referenced by GetTargets(), ProcessAction(), and ProcessEvent().

GetMaxCombatDist()

uint32 SmartScript::GetMaxCombatDist ( ) const

inline

{ return mMaxCombatDist; }

References mMaxCombatDist.

Referenced by ProcessAction().

GetPathId()

uint32 SmartScript::GetPathId ( ) const

inline

{ return mPathId; }

References mPathId.

Referenced by ProcessEvent().

GetScript()

void SmartScript::GetScript

(

)

{
    SmartAIEventList e;
    if (me)
    {
        e = sSmartScriptMgr->GetScript(-((int32)me->GetSpawnId()), mScriptType);
        if (e.empty())
            e = sSmartScriptMgr->GetScript((int32)me->GetEntry(), mScriptType);
        FillScript(e, me, nullptr);
    }
    else if (go)
    {
        e = sSmartScriptMgr->GetScript(-((int32)go->GetSpawnId()), mScriptType);
        if (e.empty())
            e = sSmartScriptMgr->GetScript((int32)go->GetEntry(), mScriptType);
        FillScript(e, go, nullptr);
    }
    else if (trigger)
    {
        e = sSmartScriptMgr->GetScript((int32)trigger->entry, mScriptType);
        FillScript(e, nullptr, trigger);
    }
}

References AreaTrigger::entry, FillScript(), Object::GetEntry(), Creature::GetSpawnId(), GameObject::GetSpawnId(), go, me, mScriptType, sSmartScriptMgr, and trigger.

Referenced by OnInitialize().

GetStoredTargetVector()

ObjectVector const * SmartScript::GetStoredTargetVector ( uint32  id, WorldObject const &  ref  ) const

inline

    {
        auto itr = _storedTargets.find(id);
        if (itr != _storedTargets.end())
            return itr->second.GetObjectVector(ref);
        return nullptr;
    }

References _storedTargets.

Referenced by SmartAI::EndPath(), and GetTargets().

GetTargets()

void SmartScript::GetTargets	(	ObjectVector &	targets,
		SmartScriptHolder const &	e,
		Unit *	invoker = nullptr
	)		const

{
    Unit* scriptTrigger = nullptr;
    if (invoker)
        scriptTrigger = invoker;
    else if (Unit* tempLastInvoker = GetLastInvoker())
        scriptTrigger = tempLastInvoker;
 
    WorldObject* baseObject = GetBaseObject();
 
    switch (e.GetTargetType())
    {
        case SMART_TARGET_SELF:
            if (baseObject)
                targets.push_back(baseObject);
            break;
        case SMART_TARGET_VICTIM:
            if (me)
                if (Unit* victim = me->GetVictim())
                    targets.push_back(victim);
            break;
        case SMART_TARGET_HOSTILE_SECOND_AGGRO:
            if (me)
            {
                if (e.target.hostileRandom.powerType)
                {
                    if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::MaxThreat, 1, PowerUsersSelector(me, Powers(e.target.hostileRandom.powerType - 1), (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly)))
                        targets.push_back(u);
                }
                else if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::MaxThreat, 1, (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly))
                    targets.push_back(u);
            }
            break;
        case SMART_TARGET_HOSTILE_LAST_AGGRO:
            if (me)
            {
                if (e.target.hostileRandom.powerType)
                {
                    if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::MinThreat, 0, PowerUsersSelector(me, Powers(e.target.hostileRandom.powerType - 1), (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly)))
                        targets.push_back(u);
                }
                else if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::MinThreat, 0, (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly))
                    targets.push_back(u);
            }
            break;
        case SMART_TARGET_HOSTILE_RANDOM:
            if (me)
            {
                if (e.target.hostileRandom.powerType)
                {
                    if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::Random, 0, PowerUsersSelector(me, Powers(e.target.hostileRandom.powerType - 1), (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly)))
                        targets.push_back(u);
                }
                else if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::Random, 0, (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly))
                    targets.push_back(u);
            }
            break;
        case SMART_TARGET_HOSTILE_RANDOM_NOT_TOP:
            if (me)
            {
                if (e.target.hostileRandom.powerType)
                {
                    if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::Random, 1, PowerUsersSelector(me, Powers(e.target.hostileRandom.powerType - 1), (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly)))
                        targets.push_back(u);
                }
                else if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::Random, 1, (float)e.target.hostileRandom.maxDist, e.target.hostileRandom.playerOnly))
                    targets.push_back(u);
            }
            break;
        case SMART_TARGET_FARTHEST:
            if (me)
            {
                if (Unit* u = me->AI()->SelectTarget(SelectTargetMethod::MinDistance, 0, FarthestTargetSelector(me, e.target.farthest.maxDist, e.target.farthest.playerOnly, e.target.farthest.isInLos)))
                    targets.push_back(u);
            }
            break;
        case SMART_TARGET_ACTION_INVOKER:
            if (scriptTrigger)
                targets.push_back(scriptTrigger);
            break;
        case SMART_TARGET_ACTION_INVOKER_VEHICLE:
            if (scriptTrigger && scriptTrigger->GetVehicle() && scriptTrigger->GetVehicle()->GetBase())
                targets.push_back(scriptTrigger->GetVehicle()->GetBase());
            break;
        case SMART_TARGET_INVOKER_PARTY:
            if (scriptTrigger)
            {
                if (Player* player = scriptTrigger->ToPlayer())
                {
                    if (Group* group = player->GetGroup())
                    {
                        for (GroupReference* groupRef = group->GetFirstMember(); groupRef != nullptr; groupRef = groupRef->next())
                            if (Player* member = groupRef->GetSource())
                                if (member->IsInMap(player))
                                    targets.push_back(member);
                    }
                    // We still add the player to the list if there is no group. If we do
                    // this even if there is a group (thus the else-check), it will add the
                    // same player to the list twice. We don't want that to happen.
                    else
                        targets.push_back(scriptTrigger);
                }
            }
            break;
        case SMART_TARGET_CREATURE_RANGE:
        {
            WorldObject* ref = baseObject;
            if (!ref)
                ref = scriptTrigger;
 
            if (!ref)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_CREATURE_RANGE: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.unitRange.maxDist));
 
            for (WorldObject* unit : units)
            {
                if (!IsCreature(unit))
                    continue;
 
                if (me && me->GetGUID() == unit->GetGUID())
                    continue;
 
                // check alive state - 1 alive, 2 dead, 0 both
                if (uint32 state = e.target.unitRange.livingState)
                {
                    if (unit->ToCreature()->IsAlive() && state == 2)
                        continue;
                    if (!unit->ToCreature()->IsAlive() && state == 1)
                        continue;
                }
 
                if (((e.target.unitRange.creature && unit->ToCreature()->GetEntry() == e.target.unitRange.creature) || !e.target.unitRange.creature) && ref->IsInRange(unit, (float)e.target.unitRange.minDist, (float)e.target.unitRange.maxDist))
                    targets.push_back(unit);
            }
 
            break;
        }
        case SMART_TARGET_CREATURE_DISTANCE:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.unitDistance.dist));
 
            for (WorldObject* unit : units)
            {
                if (!IsCreature(unit))
                    continue;
 
                if (me && me->GetGUID() == unit->GetGUID())
                    continue;
 
                // check alive state - 1 alive, 2 dead, 0 both
                if (uint32 state = e.target.unitDistance.livingState)
                {
                    if (unit->ToCreature()->IsAlive() && state == 2)
                        continue;
                    if (!unit->ToCreature()->IsAlive() && state == 1)
                        continue;
                }
 
                if ((e.target.unitDistance.creature && unit->ToCreature()->GetEntry() == e.target.unitDistance.creature) || !e.target.unitDistance.creature)
                    targets.push_back(unit);
            }
 
            break;
        }
        case SMART_TARGET_GAMEOBJECT_DISTANCE:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.goDistance.dist));
 
            for (WorldObject* unit : units)
            {
                if (!IsGameObject(unit))
                    continue;
 
                if (go && go->GetGUID() == unit->GetGUID())
                    continue;
 
                if ((e.target.goDistance.entry && unit->ToGameObject()->GetEntry() == e.target.goDistance.entry) || !e.target.goDistance.entry)
                    targets.push_back(unit);
            }
 
            break;
        }
        case SMART_TARGET_GAMEOBJECT_RANGE:
        {
 
            WorldObject* ref = baseObject;
            if (!ref)
                ref = scriptTrigger;
 
            if (!ref)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_GAMEOBJECT_RANGE: Entry: {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.goRange.maxDist));
 
            for (WorldObject* unit : units)
            {
                if (!IsGameObject(unit))
                    continue;
 
                if (go && go->GetGUID() == unit->GetGUID())
                    continue;
 
                if (((e.target.goRange.entry && IsGameObject(unit) && unit->ToGameObject()->GetEntry() == e.target.goRange.entry) || !e.target.goRange.entry) && ref->IsInRange((unit), (float)e.target.goRange.minDist, (float)e.target.goRange.maxDist))
                    targets.push_back(unit);
            }
 
            break;
        }
        case SMART_TARGET_CREATURE_GUID:
        {
            if (!scriptTrigger && !baseObject)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_CREATURE_GUID: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            Creature* target = FindCreatureNear(scriptTrigger ? scriptTrigger : GetBaseObject(), e.target.unitGUID.dbGuid);
            if (target && (!e.target.unitGUID.entry || target->GetEntry() == e.target.unitGUID.entry))
                targets.push_back(target);
            break;
        }
        case SMART_TARGET_GAMEOBJECT_GUID:
        {
            if (!scriptTrigger && !GetBaseObject())
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_GAMEOBJECT_GUID: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            GameObject* target = FindGameObjectNear(scriptTrigger ? scriptTrigger : GetBaseObject(), e.target.goGUID.dbGuid);
            if (target && (!e.target.goGUID.entry || target->GetEntry() == e.target.goGUID.entry))
                targets.push_back(target);
            break;
        }
        case SMART_TARGET_PLAYER_RANGE:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.playerRange.maxDist));
 
            if (!units.empty() && baseObject)
                for (WorldObject* unit : units)
                    if (IsPlayer(unit) && baseObject->IsInRange(unit, float(e.target.playerRange.minDist), float(e.target.playerRange.maxDist)))
                        targets.push_back(unit);
            break;
        }
        case SMART_TARGET_PLAYER_DISTANCE:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.playerDistance.dist));
 
            for (WorldObject* unit : units)
                if (IsPlayer(unit))
                    targets.push_back(unit);
            break;
        }
        case SMART_TARGET_STORED:
        {
            WorldObject* ref = baseObject;
            if (!ref)
                ref = scriptTrigger;
 
            if (!ref)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_STORED: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            if (ObjectVector const* stored = GetStoredTargetVector(e.target.stored.id, *ref))
                targets.assign(stored->begin(), stored->end());
            break;
        }
        case SMART_TARGET_CLOSEST_CREATURE:
        {
            WorldObject* ref = baseObject;
 
            if (!ref)
                ref = scriptTrigger;
 
            if (!ref)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_CLOSEST_CREATURE: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            Creature* target = GetClosestCreatureWithEntry(ref, e.target.unitClosest.entry, (float)(e.target.unitClosest.dist ? e.target.unitClosest.dist : 100), !e.target.unitClosest.dead);
            if (target)
                targets.push_back(target);
            break;
        }
        case SMART_TARGET_CLOSEST_GAMEOBJECT:
        {
            WorldObject* ref = baseObject;
 
            if (!ref)
                ref = scriptTrigger;
 
            if (!ref)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_CLOSEST_GAMEOBJECT: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            GameObject* target = GetClosestGameObjectWithEntry(ref, e.target.goClosest.entry, (float)(e.target.goClosest.dist ? e.target.goClosest.dist : 100), e.target.goClosest.onlySpawned);
            if (target)
                targets.push_back(target);
            break;
        }
        case SMART_TARGET_CLOSEST_PLAYER:
        {
            WorldObject* ref = baseObject;
 
            if (!ref)
                ref = scriptTrigger;
 
            if (!ref)
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_CLOSEST_PLAYER: Entry {} SourceType {} Event {} Action {} Target {} is missing base object or invoker.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
                break;
            }
 
            if (Player* target = ref->SelectNearestPlayer((float)e.target.playerDistance.dist))
                targets.push_back(target);
            break;
        }
        case SMART_TARGET_OWNER_OR_SUMMONER:
        /*
         * Owners/Summoners should be WorldObjects. This allows to have other objects
         * such as gameobjects to execute SmartScripts using this type of target.
         * Otherwise, only Units like creatures can summon other creatures.
         */
        {
            if (me)
            {
                if (WorldObject* owner = ObjectAccessor::GetWorldObject(*me, me->GetCharmerOrOwnerGUID()))
                {
                    targets.push_back(owner);
                }
                else if (me->IsSummon() && me->ToTempSummon()->GetSummonerUnit())
                {
                    targets.push_back(me->ToTempSummon()->GetSummonerUnit());
                }
            }
            else if (go)
            {
                if (WorldObject* owner = ObjectAccessor::GetWorldObject(*go, go->GetOwnerGUID()))
                {
                    targets.push_back(owner);
                }
            }
 
            // xinef: Get owner of owner
            if (e.target.owner.useCharmerOrOwner && !targets.empty())
            {
                if (WorldObject* owner = targets.front())
                {
                    targets.clear();
 
                    if (owner->ToCreature())
                    {
                        if (Unit* base = ObjectAccessor::GetUnit(*owner, owner->ToCreature()->GetCharmerOrOwnerGUID()))
                        {
                            targets.push_back(base);
                        }
                    }
                    else
                    {
                        if (Unit* base = ObjectAccessor::GetUnit(*owner, owner->ToGameObject()->GetOwnerGUID()))
                        {
                            targets.push_back(base);
                        }
                    }
                }
            }
            break;
        }
        case SMART_TARGET_THREAT_LIST:
        {
            if (me)
            {
                ThreatContainer::StorageType threatList = me->GetThreatMgr().GetThreatList();
                for (ThreatContainer::StorageType::const_iterator i = threatList.begin(); i != threatList.end(); ++i)
                    if (Unit* temp = ObjectAccessor::GetUnit(*me, (*i)->getUnitGuid()))
                        // Xinef: added distance check
                        if (e.target.threatList.maxDist == 0 || me->IsWithinCombatRange(temp, (float)e.target.threatList.maxDist))
                            targets.push_back(temp);
            }
            break;
        }
        case SMART_TARGET_CLOSEST_ENEMY:
        {
            if (me)
                if (Unit* target = me->SelectNearestTarget(e.target.closestAttackable.maxDist, e.target.closestAttackable.playerOnly))
                    targets.push_back(target);
 
            break;
        }
        case SMART_TARGET_CLOSEST_FRIENDLY:
        {
            if (me)
                if (Unit* target = DoFindClosestFriendlyInRange(e.target.closestFriendly.maxDist, e.target.closestFriendly.playerOnly))
                    targets.push_back(target);
 
            break;
        }
        case SMART_TARGET_PLAYER_WITH_AURA:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.playerDistance.dist));
 
            for (WorldObject* unit : units)
                if (IsPlayer(unit) && unit->ToPlayer()->IsAlive() && !unit->ToPlayer()->IsGameMaster())
                    if (GetBaseObject()->IsInRange(unit, (float)e.target.playerWithAura.distMin, (float)e.target.playerWithAura.distMax))
                        if (bool(e.target.playerWithAura.negation) != unit->ToPlayer()->HasAura(e.target.playerWithAura.spellId))
                            targets.push_back(unit);
 
            if (e.target.o > 0)
                Acore::Containers::RandomResize(targets, e.target.o);
 
            break;
        }
        case SMART_TARGET_ROLE_SELECTION:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.target.playerDistance.dist));
            // 1 = Tanks, 2 = Healer, 4 = Damage
            uint32 roleMask = e.target.roleSelection.roleMask;
            for (WorldObject* unit : units)
                if (Player* targetPlayer = unit->ToPlayer())
                    if (targetPlayer->IsAlive() && !targetPlayer->IsGameMaster())
                    {
                        if (roleMask & SMART_TARGET_ROLE_FLAG_TANKS)
                        {
                            if (targetPlayer->HasTankSpec())
                            {
                                targets.push_back(unit);
                                continue;
                            }
                        }
                        if (roleMask & SMART_TARGET_ROLE_FLAG_HEALERS)
                        {
                            if (targetPlayer->HasHealSpec())
                            {
                                targets.push_back(unit);
                                continue;
                            }
                        }
                        if (roleMask & SMART_TARGET_ROLE_FLAG_DAMAGERS)
                        {
                            if (targetPlayer->HasCasterSpec() || targetPlayer->HasMeleeSpec())
                            {
                                targets.push_back(unit);
                                continue;
                            }
                        }
                    }
 
            if (e.target.roleSelection.resize > 0)
                Acore::Containers::RandomResize(targets, e.target.roleSelection.resize);
 
            break;
        }
        case SMART_TARGET_VEHICLE_PASSENGER:
        {
            if (me && me->IsVehicle())
            {
                if (Unit* target = me->GetVehicleKit()->GetPassenger(e.target.vehicle.seatMask))
                {
                    targets.push_back(target);
                }
            }
            break;
        }
        case SMART_TARGET_LOOT_RECIPIENTS:
        {
            if (me)
            {
                if (Group* lootGroup = me->GetLootRecipientGroup())
                {
                    for (GroupReference* it = lootGroup->GetFirstMember(); it != nullptr; it = it->next())
                    {
                        if (Player* recipient = it->GetSource())
                        {
                            targets.push_back(recipient);
                        }
                    }
                }
                else
                {
                    if (Player* recipient = me->GetLootRecipient())
                    {
                        targets.push_back(recipient);
                    }
                }
            }
            break;
        }
        case SMART_TARGET_SUMMONED_CREATURES:
        {
            if (me)
            {
                for (ObjectGuid const& guid : _summonList)
                {
                    if (!e.target.summonedCreatures.entry || guid.GetEntry() == e.target.summonedCreatures.entry)
                    {
                        if (Creature* creature = me->GetMap()->GetCreature(guid))
                        {
                            targets.push_back(creature);
                        }
                    }
                }
            }
            break;
        }
        case SMART_TARGET_INSTANCE_STORAGE:
        {
            if (InstanceScript* instance = GetBaseObject()->GetInstanceScript())
            {
                if (e.target.instanceStorage.type == 1)
                {
                    if (Creature* creature = instance->GetCreature(e.target.instanceStorage.index))
                    {
                        targets.push_back(creature);
                    }
                }
                else if (e.target.instanceStorage.type == 2)
                {
                    if (GameObject* go = instance->GetGameObject(e.target.instanceStorage.index))
                    {
                        targets.push_back(go);
                    }
                }
            }
            else
            {
                LOG_ERROR("scripts.ai.sai", "SMART_TARGET_INSTANCE_STORAGE: Entry {} SourceType {} Event {} Action {} Target {} called outside an instance map.",
                    e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType(), e.GetTargetType());
            }
 
            break;
        }
        case SMART_TARGET_NONE:
        case SMART_TARGET_POSITION:
        default:
            break;
    }
}

References _summonList, Creature::AI(), SmartTarget::closestAttackable, SmartTarget::closestFriendly, SmartTarget::creature, SmartTarget::dbGuid, SmartTarget::dead, SmartTarget::dist, SmartTarget::distMax, SmartTarget::distMin, DoFindClosestFriendlyInRange(), SmartTarget::entry, SmartScriptHolder::entryOrGuid, SmartScriptHolder::event_id, SmartTarget::farthest, FindCreatureNear(), FindGameObjectNear(), SmartScriptHolder::GetActionType(), Vehicle::GetBase(), GetBaseObject(), Unit::GetCharmerOrOwnerGUID(), GetClosestCreatureWithEntry(), GetClosestGameObjectWithEntry(), Map::GetCreature(), Object::GetEntry(), Object::GetGUID(), GetLastInvoker(), Creature::GetLootRecipient(), Creature::GetLootRecipientGroup(), WorldObject::GetMap(), GameObject::GetOwnerGUID(), Vehicle::GetPassenger(), SmartScriptHolder::GetScriptType(), GetStoredTargetVector(), TempSummon::GetSummonerUnit(), SmartScriptHolder::GetTargetType(), ThreatMgr::GetThreatList(), Unit::GetThreatMgr(), ObjectAccessor::GetUnit(), Unit::GetVehicle(), Unit::GetVehicleKit(), Unit::GetVictim(), ObjectAccessor::GetWorldObject(), GetWorldObjectsInDist(), go, SmartTarget::goClosest, SmartTarget::goDistance, SmartTarget::goGUID, SmartTarget::goRange, SmartTarget::hostileRandom, SmartTarget::id, SmartTarget::index, SmartTarget::instanceStorage, IsCreature(), IsGameObject(), SmartTarget::isInLos, WorldObject::IsInRange(), IsPlayer(), Unit::IsSummon(), Unit::IsVehicle(), Unit::IsWithinCombatRange(), SmartTarget::livingState, LOG_ERROR, SmartTarget::maxDist, me, SmartTarget::minDist, SmartTarget::negation, GroupReference::next(), SmartTarget::o, SmartTarget::onlySpawned, SmartTarget::owner, SmartTarget::playerDistance, SmartTarget::playerOnly, SmartTarget::playerRange, SmartTarget::playerWithAura, SmartTarget::powerType, Acore::Containers::RandomResize(), SmartTarget::resize, SmartTarget::roleMask, SmartTarget::roleSelection, SmartTarget::seatMask, WorldObject::SelectNearestPlayer(), Creature::SelectNearestTarget(), UnitAI::SelectTarget(), SMART_TARGET_ACTION_INVOKER, SMART_TARGET_ACTION_INVOKER_VEHICLE, SMART_TARGET_CLOSEST_CREATURE, SMART_TARGET_CLOSEST_ENEMY, SMART_TARGET_CLOSEST_FRIENDLY, SMART_TARGET_CLOSEST_GAMEOBJECT, SMART_TARGET_CLOSEST_PLAYER, SMART_TARGET_CREATURE_DISTANCE, SMART_TARGET_CREATURE_GUID, SMART_TARGET_CREATURE_RANGE, SMART_TARGET_FARTHEST, SMART_TARGET_GAMEOBJECT_DISTANCE, SMART_TARGET_GAMEOBJECT_GUID, SMART_TARGET_GAMEOBJECT_RANGE, SMART_TARGET_HOSTILE_LAST_AGGRO, SMART_TARGET_HOSTILE_RANDOM, SMART_TARGET_HOSTILE_RANDOM_NOT_TOP, SMART_TARGET_HOSTILE_SECOND_AGGRO, SMART_TARGET_INSTANCE_STORAGE, SMART_TARGET_INVOKER_PARTY, SMART_TARGET_LOOT_RECIPIENTS, SMART_TARGET_NONE, SMART_TARGET_OWNER_OR_SUMMONER, SMART_TARGET_PLAYER_DISTANCE, SMART_TARGET_PLAYER_RANGE, SMART_TARGET_PLAYER_WITH_AURA, SMART_TARGET_POSITION, SMART_TARGET_ROLE_FLAG_DAMAGERS, SMART_TARGET_ROLE_FLAG_HEALERS, SMART_TARGET_ROLE_FLAG_TANKS, SMART_TARGET_ROLE_SELECTION, SMART_TARGET_SELF, SMART_TARGET_STORED, SMART_TARGET_SUMMONED_CREATURES, SMART_TARGET_THREAT_LIST, SMART_TARGET_VEHICLE_PASSENGER, SMART_TARGET_VICTIM, SmartTarget::spellId, SmartTarget::stored, SmartTarget::summonedCreatures, SmartScriptHolder::target, SmartTarget::threatList, Object::ToPlayer(), Unit::ToTempSummon(), SmartTarget::type, SmartTarget::unitClosest, SmartTarget::unitDistance, SmartTarget::unitGUID, SmartTarget::unitRange, SmartTarget::useCharmerOrOwner, and SmartTarget::vehicle.

Referenced by ProcessAction().

GetWorldObjectsInDist()

void SmartScript::GetWorldObjectsInDist	(	ObjectVector &	objects,
		float	dist
	)		const

{
    WorldObject* obj = GetBaseObject();
    if (!obj)
        return;
 
    Acore::AllWorldObjectsInRange u_check(obj, dist);
    Acore::WorldObjectListSearcher<Acore::AllWorldObjectsInRange> searcher(obj, targets, u_check);
    Cell::VisitAllObjects(obj, searcher, dist);
}

References GetBaseObject(), and Cell::VisitAllObjects().

Referenced by GetTargets(), ProcessAction(), and ProcessEvent().

IncPhase()

void SmartScript::IncPhase ( uint32  p )

private

{
    // protect phase from overflowing
    SetPhase(std::min<uint32>(SMART_EVENT_PHASE_12, mEventPhase + p));
}

References mEventPhase, SetPhase(), and SMART_EVENT_PHASE_12.

Referenced by ProcessAction().

InitTimer()

void SmartScript::InitTimer ( SmartScriptHolder &  e )

static

{
    switch (e.GetEventType())
    {
        //set only events which have initial timers
        case SMART_EVENT_RANGE:
            // If onlyFireOnRepeat is true set to 2 before entering combat. Will be set back to 1 after entering combat to ignore initial firing.
            if (e.event.rangeRepeat.onlyFireOnRepeat == 1)
                e.event.rangeRepeat.onlyFireOnRepeat = 2;
            // make it predictable
            RecalcTimer(e, 500, 500);
            break;
        case SMART_EVENT_NEAR_PLAYERS:
        case SMART_EVENT_NEAR_PLAYERS_NEGATION:
            RecalcTimer(e, e.event.nearPlayer.firstTimer, e.event.nearPlayer.firstTimer);
            break;
        case SMART_EVENT_UPDATE:
        case SMART_EVENT_UPDATE_IC:
        case SMART_EVENT_UPDATE_OOC:
            RecalcTimer(e, e.event.minMaxRepeat.min, e.event.minMaxRepeat.max);
            break;
        case SMART_EVENT_OOC_LOS:
        case SMART_EVENT_IC_LOS:
        // Xinef: cooldown should be processed AFTER action is done, not before...
        //RecalcTimer(e, e.event.los.cooldownMin, e.event.los.cooldownMax);
        //break;
        case SMART_EVENT_DISTANCE_CREATURE:
        case SMART_EVENT_DISTANCE_GAMEOBJECT:
            RecalcTimer(e, e.event.distance.repeat, e.event.distance.repeat);
            break;
        default:
            e.active = true;
            break;
    }
}

References SmartScriptHolder::active, SmartEvent::distance, SmartScriptHolder::event, SmartEvent::firstTimer, SmartScriptHolder::GetEventType(), SmartEvent::max, SmartEvent::min, SmartEvent::minMaxRepeat, SmartEvent::nearPlayer, SmartEvent::onlyFireOnRepeat, SmartEvent::rangeRepeat, RecalcTimer(), SmartEvent::repeat, SMART_EVENT_DISTANCE_CREATURE, SMART_EVENT_DISTANCE_GAMEOBJECT, SMART_EVENT_IC_LOS, SMART_EVENT_NEAR_PLAYERS, SMART_EVENT_NEAR_PLAYERS_NEGATION, SMART_EVENT_OOC_LOS, SMART_EVENT_RANGE, SMART_EVENT_UPDATE, SMART_EVENT_UPDATE_IC, and SMART_EVENT_UPDATE_OOC.

Referenced by CreateSmartEvent(), OnInitialize(), OnReset(), and SetScript9().

InstallEvents()

void SmartScript::InstallEvents ( )

private

{
    if (!mInstallEvents.empty())
    {
        for (SmartAIEventList::iterator i = mInstallEvents.begin(); i != mInstallEvents.end(); ++i)
            mEvents.push_back(*i);//must be before UpdateTimers
 
        mInstallEvents.clear();
    }
}

References mEvents, and mInstallEvents.

Referenced by OnInitialize(), and OnUpdate().

InstallTemplate()

void SmartScript::InstallTemplate

(

SmartScriptHolder const &

e

)

{
    if (!GetBaseObject())
        return;
    if (mTemplate != SMARTAI_TEMPLATE_BASIC)
    {
        LOG_ERROR("sql.sql", "SmartScript::InstallTemplate: Entry {} SourceType {} AI Template can not be set more then once, skipped.", e.entryOrGuid, e.GetScriptType());
        return;
    }
    mTemplate = (SMARTAI_TEMPLATE)e.action.installTtemplate.id;
    switch ((SMARTAI_TEMPLATE)e.action.installTtemplate.id)
    {
        case SMARTAI_TEMPLATE_CASTER:
            {
                AddEvent(SMART_EVENT_UPDATE_IC, 0, 0, 0, e.action.installTtemplate.param2, e.action.installTtemplate.param3, 0, SMART_ACTION_CAST, e.action.installTtemplate.param1, e.target.raw.param1, 0, 0, 0, 0, SMART_TARGET_VICTIM, 0, 0, 0, 0, 1);
                AddEvent(SMART_EVENT_RANGE, 0, e.action.installTtemplate.param4, 300, 0, 0, 0, SMART_ACTION_ALLOW_COMBAT_MOVEMENT, 1, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 1);
                AddEvent(SMART_EVENT_RANGE, 0, 0, e.action.installTtemplate.param4 > 10 ? e.action.installTtemplate.param4 - 10 : 0, 0, 0, 0, SMART_ACTION_ALLOW_COMBAT_MOVEMENT, 0, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 1);
                AddEvent(SMART_EVENT_MANA_PCT, 0, e.action.installTtemplate.param5 - 15 > 100 ? 100 : e.action.installTtemplate.param5 + 15, 100, 1000, 1000, 0, SMART_ACTION_SET_EVENT_PHASE, 1, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
                AddEvent(SMART_EVENT_MANA_PCT, 0, 0, e.action.installTtemplate.param5, 1000, 1000, 0, SMART_ACTION_SET_EVENT_PHASE, 0, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
                AddEvent(SMART_EVENT_MANA_PCT, 0, 0, e.action.installTtemplate.param5, 1000, 1000, 0, SMART_ACTION_ALLOW_COMBAT_MOVEMENT, 1, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
                break;
            }
        case SMARTAI_TEMPLATE_TURRET:
            {
                AddEvent(SMART_EVENT_UPDATE_IC, 0, 0, 0, e.action.installTtemplate.param2, e.action.installTtemplate.param3, 0, SMART_ACTION_CAST, e.action.installTtemplate.param1, e.target.raw.param1, 0, 0, 0, 0, SMART_TARGET_VICTIM, 0, 0, 0, 0, 0);
                AddEvent(SMART_EVENT_JUST_CREATED, 0, 0, 0, 0, 0, 0, SMART_ACTION_ALLOW_COMBAT_MOVEMENT, 0, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
                break;
            }
        case SMARTAI_TEMPLATE_CAGED_NPC_PART:
            {
                if (!me)
                    return;
                //store cage as id1
                AddEvent(SMART_EVENT_DATA_SET, 0, 0, 0, 0, 0, 0, SMART_ACTION_STORE_TARGET_LIST, 1, 0, 0, 0, 0, 0, SMART_TARGET_CLOSEST_GAMEOBJECT, e.action.installTtemplate.param1, 10, 0, 0, 0);
 
                //reset(close) cage on hostage(me) respawn
                AddEvent(SMART_EVENT_UPDATE, SMART_EVENT_FLAG_NOT_REPEATABLE, 0, 0, 0, 0, 0, SMART_ACTION_RESET_GOBJECT, 0, 0, 0, 0, 0, 0, SMART_TARGET_GAMEOBJECT_DISTANCE, e.action.installTtemplate.param1, 5, 0, 0, 0);
 
                AddEvent(SMART_EVENT_DATA_SET, 0, 0, 0, 0, 0, 0, SMART_ACTION_SET_RUN, e.action.installTtemplate.param3, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
                AddEvent(SMART_EVENT_DATA_SET, 0, 0, 0, 0, 0, 0, SMART_ACTION_SET_EVENT_PHASE, 1, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
 
                AddEvent(SMART_EVENT_UPDATE, SMART_EVENT_FLAG_NOT_REPEATABLE, 1000, 1000, 0, 0, 0, SMART_ACTION_MOVE_FORWARD, e.action.installTtemplate.param4, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 1);
                //phase 1: give quest credit on movepoint reached
                AddEvent(SMART_EVENT_MOVEMENTINFORM, 0, POINT_MOTION_TYPE, SMART_RANDOM_POINT, 0, 0, 0, SMART_ACTION_SET_DATA, 0, 0, 0, 0, 0, 0, SMART_TARGET_STORED, 1, 0, 0, 0, 1);
                //phase 1: despawn after time on movepoint reached
                AddEvent(SMART_EVENT_MOVEMENTINFORM, 0, POINT_MOTION_TYPE, SMART_RANDOM_POINT, 0, 0, 0, SMART_ACTION_FORCE_DESPAWN, e.action.installTtemplate.param2, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 1);
 
                if (sCreatureTextMgr->TextExist(me->GetEntry(), (uint8)e.action.installTtemplate.param5))
                    AddEvent(SMART_EVENT_MOVEMENTINFORM, 0, POINT_MOTION_TYPE, SMART_RANDOM_POINT, 0, 0, 0, SMART_ACTION_TALK, e.action.installTtemplate.param5, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 1);
                break;
            }
        case SMARTAI_TEMPLATE_CAGED_GO_PART:
            {
                if (!go)
                    return;
                //store hostage as id1
                AddEvent(SMART_EVENT_GO_STATE_CHANGED, 0, 2, 0, 0, 0, 0, SMART_ACTION_STORE_TARGET_LIST, 1, 0, 0, 0, 0, 0, SMART_TARGET_CLOSEST_CREATURE, e.action.installTtemplate.param1, 10, 0, 0, 0);
                //store invoker as id2
                AddEvent(SMART_EVENT_GO_STATE_CHANGED, 0, 2, 0, 0, 0, 0, SMART_ACTION_STORE_TARGET_LIST, 2, 0, 0, 0, 0, 0, SMART_TARGET_NONE, 0, 0, 0, 0, 0);
                //signal hostage
                AddEvent(SMART_EVENT_GO_STATE_CHANGED, 0, 2, 0, 0, 0, 0, SMART_ACTION_SET_DATA, 0, 0, 0, 0, 0, 0, SMART_TARGET_STORED, 1, 0, 0, 0, 0);
                //when hostage raeched end point, give credit to invoker
                if (e.action.installTtemplate.param2)
                    AddEvent(SMART_EVENT_DATA_SET, 0, 0, 0, 0, 0, 0, SMART_ACTION_CALL_KILLEDMONSTER, e.action.installTtemplate.param1, 0, 0, 0, 0, 0, SMART_TARGET_STORED, 2, 0, 0, 0, 0);
                else
                    AddEvent(SMART_EVENT_GO_STATE_CHANGED, 0, 2, 0, 0, 0, 0, SMART_ACTION_CALL_KILLEDMONSTER, e.action.installTtemplate.param1, 0, 0, 0, 0, 0, SMART_TARGET_STORED, 2, 0, 0, 0, 0);
                break;
            }
        case SMARTAI_TEMPLATE_BASIC:
        default:
            return;
    }
}

References SmartScriptHolder::action, AddEvent(), SmartScriptHolder::entryOrGuid, GetBaseObject(), Object::GetEntry(), SmartScriptHolder::GetScriptType(), go, SmartAction::id, SmartAction::installTtemplate, LOG_ERROR, me, mTemplate, SmartAction::param1, SmartTarget::param1, SmartAction::param2, SmartAction::param3, SmartAction::param4, SmartAction::param5, POINT_MOTION_TYPE, SmartTarget::raw, sCreatureTextMgr, SMART_ACTION_ALLOW_COMBAT_MOVEMENT, SMART_ACTION_CALL_KILLEDMONSTER, SMART_ACTION_CAST, SMART_ACTION_FORCE_DESPAWN, SMART_ACTION_MOVE_FORWARD, SMART_ACTION_RESET_GOBJECT, SMART_ACTION_SET_DATA, SMART_ACTION_SET_EVENT_PHASE, SMART_ACTION_SET_RUN, SMART_ACTION_STORE_TARGET_LIST, SMART_ACTION_TALK, SMART_EVENT_DATA_SET, SMART_EVENT_FLAG_NOT_REPEATABLE, SMART_EVENT_GO_STATE_CHANGED, SMART_EVENT_JUST_CREATED, SMART_EVENT_MANA_PCT, SMART_EVENT_MOVEMENTINFORM, SMART_EVENT_RANGE, SMART_EVENT_UPDATE, SMART_EVENT_UPDATE_IC, SMART_RANDOM_POINT, SMART_TARGET_CLOSEST_CREATURE, SMART_TARGET_CLOSEST_GAMEOBJECT, SMART_TARGET_GAMEOBJECT_DISTANCE, SMART_TARGET_NONE, SMART_TARGET_STORED, SMART_TARGET_VICTIM, SMARTAI_TEMPLATE_BASIC, SMARTAI_TEMPLATE_CAGED_GO_PART, SMARTAI_TEMPLATE_CAGED_NPC_PART, SMARTAI_TEMPLATE_CASTER, SMARTAI_TEMPLATE_TURRET, and SmartScriptHolder::target.

Referenced by ProcessAction().

IsCharmedCreature()

bool SmartScript::IsCharmedCreature ( WorldObject *  obj )

static

{
    if (!obj)
        return false;
 
    if (Creature* creatureObj = obj->ToCreature())
        return creatureObj->IsCharmed();
 
    return false;
}

References Object::ToCreature().

Referenced by ProcessEvent().

IsCreature()

bool SmartScript::IsCreature ( WorldObject *  obj )

static

{
    return obj && obj->GetTypeId() == TYPEID_UNIT;
}

References Object::GetTypeId(), and TYPEID_UNIT.

Referenced by GetTargets(), ProcessAction(), and ProcessEvent().

IsGameObject()

bool SmartScript::IsGameObject ( WorldObject *  obj )

static

{
    return obj && obj->GetTypeId() == TYPEID_GAMEOBJECT;
}

References Object::GetTypeId(), and TYPEID_GAMEOBJECT.

Referenced by GetTargets(), and ProcessAction().

IsInPhase()

bool SmartScript::IsInPhase ( uint32  p ) const

private

{
    if (mEventPhase == 0)
    {
        return false;
    }
 
    return ((1 << (mEventPhase - 1)) & p) != 0;
}

References mEventPhase.

Referenced by ProcessEvent(), and UpdateTimer().

IsPlayer()

bool SmartScript::IsPlayer ( WorldObject *  obj )

static

{
    return obj && obj->GetTypeId() == TYPEID_PLAYER;
}

References Object::GetTypeId(), and TYPEID_PLAYER.

Referenced by GetTargets(), SmartAI::IsEscortInvokerInRange(), and ProcessAction().

IsSmart()

bool SmartScript::IsSmart ( Creature *  c = nullptr )

inline

    {
        bool smart = true;
        if (c && c->GetAIName() != "SmartAI")
            smart = false;
 
        if (!me || me->GetAIName() != "SmartAI")
            smart = false;
 
        if (!smart)
            LOG_ERROR("sql.sql", "SmartScript: Action target Creature(entry: {}) is not using SmartAI, action skipped to prevent crash.", c ? c->GetEntry() : (me ? me->GetEntry() : 0));
 
        return smart;
    }

References Creature::GetAIName(), Object::GetEntry(), LOG_ERROR, and me.

Referenced by ProcessAction().

IsSmartGO()

bool SmartScript::IsSmartGO ( GameObject *  g = nullptr )

inline

    {
        bool smart = true;
        if (g && g->GetAIName() != "SmartGameObjectAI")
            smart = false;
 
        if (!go || go->GetAIName() != "SmartGameObjectAI")
            smart = false;
        if (!smart)
            LOG_ERROR("sql.sql", "SmartScript: Action target GameObject(entry: {}) is not using SmartGameObjectAI, action skipped to prevent crash.", g ? g->GetEntry() : (go ? go->GetEntry() : 0));
 
        return smart;
    }

References GameObject::GetAIName(), Object::GetEntry(), go, and LOG_ERROR.

IsUnit()

bool SmartScript::IsUnit ( WorldObject *  obj )

static

{
    return obj && (obj->GetTypeId() == TYPEID_UNIT || obj->GetTypeId() == TYPEID_PLAYER);
}

References Object::GetTypeId(), TYPEID_PLAYER, and TYPEID_UNIT.

Referenced by ProcessAction(), and ProcessEvent().

OnInitialize()

void SmartScript::OnInitialize	(	WorldObject *	obj,
		AreaTrigger const *	at = nullptr
	)

{
    if (obj)//handle object based scripts
    {
        switch (obj->GetTypeId())
        {
            case TYPEID_UNIT:
                mScriptType = SMART_SCRIPT_TYPE_CREATURE;
                me = obj->ToCreature();
                LOG_DEBUG("sql.sql", "SmartScript::OnInitialize: source is Creature {}", me->GetEntry());
                break;
            case TYPEID_GAMEOBJECT:
                mScriptType = SMART_SCRIPT_TYPE_GAMEOBJECT;
                go = obj->ToGameObject();
                LOG_DEBUG("sql.sql", "SmartScript::OnInitialize: source is GameObject {}", go->GetEntry());
                break;
            default:
                LOG_ERROR("scripts.ai.sai", "SmartScript::OnInitialize: Unhandled TypeID !WARNING!");
                return;
        }
    }
    else if (at)
    {
        mScriptType = SMART_SCRIPT_TYPE_AREATRIGGER;
        trigger = at;
        LOG_DEBUG("sql.sql", "SmartScript::OnInitialize: source is AreaTrigger {}", trigger->entry);
    }
    else
    {
        LOG_ERROR("scripts.ai.sai", "SmartScript::OnInitialize: !WARNING! Initialized objects are nullptr.");
        return;
    }
 
    GetScript();//load copy of script
 
    uint32 maxDisableDist = 0;
    uint32 minEnableDist = 0;
    for (SmartAIEventList::iterator i = mEvents.begin(); i != mEvents.end(); ++i)
    {
        InitTimer((*i));//calculate timers for first time use
        if (i->GetEventType() == SMART_EVENT_RANGE && i->GetActionType() == SMART_ACTION_ALLOW_COMBAT_MOVEMENT)
        {
            if (i->action.combatMove.move == 1 && i->event.rangeRepeat.minRange > minEnableDist)
                minEnableDist = i->event.rangeRepeat.minRange;
            else if (i->action.combatMove.move == 0 && (i->event.rangeRepeat.maxRange < maxDisableDist || maxDisableDist == 0))
                maxDisableDist = i->event.rangeRepeat.maxRange;
        }
 
        // Xinef: if smartcast combat move flag is present
        if (i->GetActionType() == SMART_ACTION_CAST && (i->action.cast.flags & SMARTCAST_COMBAT_MOVE))
        {
            if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(i->action.cast.spell))
            {
                float maxRange = spellInfo->GetMaxRange(spellInfo->IsPositive());
                float minRange = spellInfo->GetMinRange(spellInfo->IsPositive());
 
                if (maxRange > 0 && minRange <= maxRange)
                {
                    smartCasterMaxDist = minRange + ((maxRange - minRange) * 0.65f);
                    smartCasterPowerType = (Powers)spellInfo->PowerType;
                }
            }
        }
    }
    if (maxDisableDist > 0 && minEnableDist >= maxDisableDist)
        mMaxCombatDist = uint32(maxDisableDist + ((minEnableDist - maxDisableDist) / 2));
 
    ProcessEventsFor(SMART_EVENT_AI_INIT);
    InstallEvents();
    ProcessEventsFor(SMART_EVENT_JUST_CREATED);
}

References AreaTrigger::entry, Object::GetEntry(), SpellInfo::GetMaxRange(), SpellInfo::GetMinRange(), GetScript(), Object::GetTypeId(), go, InitTimer(), InstallEvents(), SpellInfo::IsPositive(), LOG_DEBUG, LOG_ERROR, me, mEvents, mMaxCombatDist, mScriptType, SpellInfo::PowerType, ProcessEventsFor(), SMART_ACTION_ALLOW_COMBAT_MOVEMENT, SMART_ACTION_CAST, SMART_EVENT_AI_INIT, SMART_EVENT_JUST_CREATED, SMART_EVENT_RANGE, SMART_SCRIPT_TYPE_AREATRIGGER, SMART_SCRIPT_TYPE_CREATURE, SMART_SCRIPT_TYPE_GAMEOBJECT, SMARTCAST_COMBAT_MOVE, smartCasterMaxDist, smartCasterPowerType, sSpellMgr, Object::ToCreature(), Object::ToGameObject(), trigger, TYPEID_GAMEOBJECT, and TYPEID_UNIT.

Referenced by SmartAI::InitializeAI(), SmartGameObjectAI::InitializeAI(), and SmartTrigger::OnTrigger().

OnMoveInLineOfSight()

void SmartScript::OnMoveInLineOfSight

(

Unit *

who

)

{
    if (!me)
        return;
 
    ProcessEventsFor(me->IsEngaged() ? SMART_EVENT_IC_LOS : SMART_EVENT_OOC_LOS, who);
}

References Unit::IsEngaged(), me, ProcessEventsFor(), SMART_EVENT_IC_LOS, and SMART_EVENT_OOC_LOS.

Referenced by SmartAI::MoveInLineOfSight().

OnReset()

void SmartScript::OnReset

(

)

{
    // xinef: check if we allow phase reset
    if (AllowPhaseReset())
        SetPhase(0);
 
    ResetBaseObject();
    for (SmartAIEventList::iterator i = mEvents.begin(); i != mEvents.end(); ++i)
    {
        if (!((*i).event.event_flags & SMART_EVENT_FLAG_DONT_RESET))
        {
            InitTimer((*i));
            (*i).runOnce = false;
        }
    }
    ProcessEventsFor(SMART_EVENT_RESET);
    mLastInvoker.Clear();
    mCounterList.clear();
 
    // Xinef: Fix Combat Movement
    RestoreMaxCombatDist();
    RestoreCasterMaxDist();
}

References AllowPhaseReset(), ObjectGuid::Clear(), InitTimer(), mCounterList, mEvents, mLastInvoker, ProcessEventsFor(), ResetBaseObject(), RestoreCasterMaxDist(), RestoreMaxCombatDist(), SetPhase(), SMART_EVENT_FLAG_DONT_RESET, and SMART_EVENT_RESET.

Referenced by SmartAI::EnterEvadeMode(), SmartAI::JustReachedHome(), and SmartGameObjectAI::Reset().

OnUpdate()

void SmartScript::OnUpdate

(

const uint32

diff

)

{
    if ((mScriptType == SMART_SCRIPT_TYPE_CREATURE || mScriptType == SMART_SCRIPT_TYPE_GAMEOBJECT) && !GetBaseObject())
        return;
 
    InstallEvents();//before UpdateTimers
 
    for (SmartAIEventList::iterator i = mEvents.begin(); i != mEvents.end(); ++i)
        UpdateTimer(*i, diff);
 
    if (!mStoredEvents.empty())
    {
        SmartAIEventStoredList::iterator i, icurr;
        for (i = mStoredEvents.begin(); i != mStoredEvents.end();)
        {
            icurr = i++;
            UpdateTimer(*icurr, diff);
        }
    }
 
    bool needCleanup = true;
    if (!mTimedActionList.empty())
    {
        isProcessingTimedActionList = true;
        for (SmartAIEventList::iterator i = mTimedActionList.begin(); i != mTimedActionList.end(); ++i)
        {
            if ((*i).enableTimed)
            {
                UpdateTimer(*i, diff);
                needCleanup = false;
            }
        }
 
        isProcessingTimedActionList = false;
    }
    if (needCleanup)
        mTimedActionList.clear();
 
    if (!mRemIDs.empty())
    {
        for (std::list<uint32>::const_iterator i = mRemIDs.begin(); i != mRemIDs.end(); ++i)
            RemoveStoredEvent(*i);
 
        // xinef: clear list after cleaning...
        mRemIDs.clear();
    }
    if (mUseTextTimer && me)
    {
        if (mTextTimer < diff)
        {
            uint32 textID = mLastTextID;
            mLastTextID = 0;
            uint32 entry = mTalkerEntry;
            mTalkerEntry = 0;
            mTextTimer = 0;
            mUseTextTimer = false;
            ProcessEventsFor(SMART_EVENT_TEXT_OVER, nullptr, textID, entry);
        }
        else mTextTimer -= diff;
    }
}

References GetBaseObject(), InstallEvents(), isProcessingTimedActionList, me, mEvents, mLastTextID, mRemIDs, mScriptType, mStoredEvents, mTalkerEntry, mTextTimer, mTimedActionList, mUseTextTimer, ProcessEventsFor(), RemoveStoredEvent(), SMART_EVENT_TEXT_OVER, SMART_SCRIPT_TYPE_CREATURE, SMART_SCRIPT_TYPE_GAMEOBJECT, and UpdateTimer().

Referenced by SmartAI::UpdateAI(), and SmartGameObjectAI::UpdateAI().

ProcessAction()

void SmartScript::ProcessAction	(	SmartScriptHolder &	e,
		Unit *	unit = nullptr,
		uint32	var0 = 0,
		uint32	var1 = 0,
		bool	bvar = false,
		SpellInfo const *	spell = nullptr,
		GameObject *	gob = nullptr
	)

{
    //calc random
    if (e.GetEventType() != SMART_EVENT_LINK && e.event.event_chance < 100 && e.event.event_chance)
    {
        uint32 rnd = urand(1, 100);
        if (e.event.event_chance <= rnd)
            return;
    }
    e.runOnce = true;//used for repeat check
 
    if (unit)
        mLastInvoker = unit->GetGUID();
 
    if (Unit* tempInvoker = GetLastInvoker())
        LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: Invoker: {} ({})", tempInvoker->GetName(), tempInvoker->GetGUID().ToString());
 
    bool isControlled = e.action.moveToPos.controlled > 0;
 
    ObjectVector targets;
    GetTargets(targets, e, unit);
 
    switch (e.GetActionType())
    {
        case SMART_ACTION_TALK:
        {
            Creature* talker = e.target.type == 0 ? me : nullptr;
            Unit* talkTarget = nullptr;
 
            for (WorldObject* target : targets)
            {
                if (IsCreature((target)) && !target->ToCreature()->IsPet()) // Prevented sending text to pets.
                {
                    if (e.action.talk.useTalkTarget)
                    {
                        talker = me;
                        talkTarget = target->ToCreature();
                    }
                    else
                        talker = target->ToCreature();
                    break;
                }
                else if (IsPlayer((target)))
                {
                    talker = me; // xinef: added
                    talkTarget = target->ToPlayer();
                    break;
                }
            }
 
            if (!talkTarget)
                talkTarget = GetLastInvoker();
 
            if (!talker)
                break;
 
            if (!sCreatureTextMgr->TextExist(talker->GetEntry(), uint8(e.action.talk.textGroupID)))
            {
                LOG_ERROR("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_TALK: EntryOrGuid {} SourceType {} EventType {} TargetType {} using non-existent Text id {} for talker {}, ignored.", e.entryOrGuid, e.GetScriptType(), e.GetEventType(), e.GetTargetType(), e.action.talk.textGroupID, talker->GetEntry());
                break;
            }
 
            mTalkerEntry = talker->GetEntry();
            mLastTextID = e.action.talk.textGroupID;
            mTextTimer = e.action.talk.duration;
            mUseTextTimer = true;
            sCreatureTextMgr->SendChat(talker, uint8(e.action.talk.textGroupID), talkTarget);
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_TALK: talker: {} ({}), textId: {}", talker->GetName(), talker->GetGUID().ToString(), mLastTextID);
            break;
        }
        case SMART_ACTION_SIMPLE_TALK:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                    sCreatureTextMgr->SendChat(target->ToCreature(), uint8(e.action.simpleTalk.textGroupID), IsPlayer(GetLastInvoker()) ? GetLastInvoker() : 0);
                else if (IsPlayer(target) && me)
                {
                    Unit* templastInvoker = GetLastInvoker();
                    sCreatureTextMgr->SendChat(me, uint8(e.action.simpleTalk.textGroupID), IsPlayer(templastInvoker) ? templastInvoker : 0, CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_NORMAL, 0, TEAM_NEUTRAL, false, target->ToPlayer());
                }
 
                LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_SIMPLE_TALK: talker: {} ({}), textGroupId: {}",
                               target->GetName(), target->GetGUID().ToString(), uint8(e.action.simpleTalk.textGroupID));
            }
            break;
        }
        case SMART_ACTION_PLAY_EMOTE:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    target->ToUnit()->HandleEmoteCommand(e.action.emote.emote);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_PLAY_EMOTE: target: {} ({}), emote: {}",
                                   target->GetName(), target->GetGUID().ToString(), e.action.emote.emote);
                }
            }
            break;
        }
        case SMART_ACTION_SOUND:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    if (e.action.sound.distance == 1)
                        target->PlayDistanceSound(e.action.sound.sound, e.action.sound.onlySelf ? target->ToPlayer() : nullptr);
                    else
                        target->PlayDirectSound(e.action.sound.sound, e.action.sound.onlySelf ? target->ToPlayer() : nullptr);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_SOUND: target: {} ({}), sound: {}, onlyself: {}",
                                   target->GetName(), target->GetGUID().ToString(), e.action.sound.sound, e.action.sound.onlySelf);
                }
            }
            break;
        }
        case SMART_ACTION_RANDOM_SOUND:
        {
            uint32 sounds[4];
            sounds[0] = e.action.randomSound.sound1;
            sounds[1] = e.action.randomSound.sound2;
            sounds[2] = e.action.randomSound.sound3;
            sounds[3] = e.action.randomSound.sound4;
            uint32 temp[4];
            uint32 count = 0;
            for (unsigned int sound : sounds)
            {
                if (sound)
                {
                    temp[count] = sound;
                    ++count;
                }
            }
 
            if (count == 0)
            {
                break;
            }
 
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    uint32 sound = temp[urand(0, count - 1)];
                    target->PlayDirectSound(sound, e.action.randomSound.onlySelf ? target->ToPlayer() : nullptr);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_RANDOM_SOUND: target: {} ({}), sound: {}, onlyself: {}",
                              target->GetName(), target->GetGUID().ToString(), sound, e.action.randomSound.onlySelf);
                }
            }
 
            break;
        }
        case SMART_ACTION_MUSIC:
        {
            ObjectVector targets;
 
            if (e.action.music.type > 0)
            {
                if (me && me->FindMap())
                {
                    Map::PlayerList const& players = me->GetMap()->GetPlayers();
 
                    if (!players.IsEmpty())
                    {
                        for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
                            if (Player* player = i->GetSource())
                            {
                                if (player->GetZoneId() == me->GetZoneId())
                                {
                                    if (e.action.music.type > 1)
                                    {
                                        if (player->GetAreaId() == me->GetAreaId())
                                            targets.push_back(player);
                                    }
                                    else
                                        targets.push_back(player);
                                }
                            }
                    }
                }
            }
            else
                GetTargets(targets, e);
 
            if (!targets.empty())
            {
                for (WorldObject* target : targets)
                {
                    if (IsUnit(target))
                    {
                        target->SendPlayMusic(e.action.music.sound, e.action.music.onlySelf > 0);
                        LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_MUSIC: target: {} ({}), sound: {}, onlySelf: {}, type: {}",
                                  target->GetName(), target->GetGUID().ToString(), e.action.music.sound, e.action.music.onlySelf, e.action.music.type);
                    }
                }
            }
            break;
        }
        case SMART_ACTION_RANDOM_MUSIC:
        {
            ObjectVector targets;
 
            if (e.action.randomMusic.type > 0)
            {
                if (me && me->FindMap())
                {
                    Map::PlayerList const& players = me->GetMap()->GetPlayers();
 
                    if (!players.IsEmpty())
                    {
                        for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
                            if (Player* player = i->GetSource())
                            {
                                if (player->GetZoneId() == me->GetZoneId())
                                {
                                    if (e.action.randomMusic.type > 1)
                                    {
                                        if (player->GetAreaId() == me->GetAreaId())
                                            targets.push_back(player);
                                    }
                                    else
                                        targets.push_back(player);
                                }
                            }
                    }
                }
            }
            else
                GetTargets(targets, e);
 
            if (targets.empty())
                break;
 
            uint32 sounds[4];
            sounds[0] = e.action.randomMusic.sound1;
            sounds[1] = e.action.randomMusic.sound2;
            sounds[2] = e.action.randomMusic.sound3;
            sounds[3] = e.action.randomMusic.sound4;
            uint32 temp[4];
            uint32 count = 0;
            for (unsigned int sound : sounds)
            {
                if (sound)
                {
                    temp[count] = sound;
                    ++count;
                }
            }
 
            if (count == 0)
            {
                break;
            }
 
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    uint32 sound = temp[urand(0, count - 1)];
                    target->SendPlayMusic(sound, e.action.randomMusic.onlySelf > 0);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_RANDOM_MUSIC: target: {} ({}), sound: {}, onlyself: {}, type: {}",
                                   target->GetName(), target->GetGUID().ToString(), sound, e.action.randomMusic.onlySelf, e.action.randomMusic.type);
                }
            }
 
            break;
        }
        case SMART_ACTION_SET_FACTION:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    if (e.action.faction.factionID)
                    {
                        target->ToCreature()->SetFaction(e.action.faction.factionID);
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_SET_FACTION: Creature entry {}, GuidLow {} set faction to {}",
                                  target->GetEntry(), target->GetGUID().ToString(), e.action.faction.factionID);
                    }
                    else
                    {
                        if (CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(target->ToCreature()->GetEntry()))
                        {
                            if (target->ToCreature()->GetFaction() != ci->faction)
                            {
                                target->ToCreature()->SetFaction(ci->faction);
                                LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_SET_FACTION: Creature entry {}, GuidLow {} set faction to {}",
                                          target->GetEntry(), target->GetGUID().ToString(), ci->faction);
                            }
                        }
                    }
                }
            }
            break;
        }
        case SMART_ACTION_MORPH_TO_ENTRY_OR_MODEL:
        {
            for (WorldObject* target : targets)
            {
                if (!IsCreature(target))
                    continue;
 
                if (e.action.morphOrMount.creature || e.action.morphOrMount.model)
                {
                    //set model based on entry from creature_template
                    if (e.action.morphOrMount.creature)
                    {
                        if (CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(e.action.morphOrMount.creature))
                        {
                            uint32 displayId = ObjectMgr::ChooseDisplayId(ci);
                            target->ToCreature()->SetDisplayId(displayId);
                            LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_MORPH_TO_ENTRY_OR_MODEL: Creature entry {}, GuidLow {} set displayid to {}",
                                      target->GetEntry(), target->GetGUID().ToString(), displayId);
                        }
                    }
                        //if no param1, then use value from param2 (modelId)
                    else
                    {
                        target->ToCreature()->SetDisplayId(e.action.morphOrMount.model);
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_MORPH_TO_ENTRY_OR_MODEL: Creature entry {}, GuidLow {} set displayid to {}",
                                  target->GetEntry(), target->GetGUID().ToString(), e.action.morphOrMount.model);
                    }
                }
                else
                {
                    target->ToCreature()->DeMorph();
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_MORPH_TO_ENTRY_OR_MODEL: Creature entry {}, GuidLow {} demorphs.",
                              target->GetEntry(), target->GetGUID().ToString());
                }
            }
            break;
        }
        case SMART_ACTION_FAIL_QUEST:
        {
            for (WorldObject* target : targets)
            {
                if (IsPlayer(target))
                {
                    target->ToPlayer()->FailQuest(e.action.quest.quest);
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_FAIL_QUEST: Player guidLow {} fails quest {}",
                              target->GetGUID().ToString(), e.action.quest.quest);
                }
            }
            break;
        }
        case SMART_ACTION_OFFER_QUEST:
        {
            for (WorldObject* target : targets)
            {
                if (Player* player = target->ToPlayer())
                {
                    if (Quest const* q = sObjectMgr->GetQuestTemplate(e.action.questOffer.questID))
                    {
                        if (me && e.action.questOffer.directAdd == 0)
                        {
                            if (player->CanTakeQuest(q, true))
                            {
                                if (WorldSession* session = player->GetSession())
                                {
                                    PlayerMenu menu(session);
                                    menu.SendQuestGiverQuestDetails(q, me->GetGUID(), true);
                                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_OFFER_QUEST: Player guidLow {} - offering quest {}",
                                              player->GetGUID().ToString(), e.action.questOffer.questID);
                                }
                            }
                        }
                        else
                        {
                            player->AddQuestAndCheckCompletion(q, nullptr);
                            LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_OFFER_QUEST: Player guidLow {} - quest {} added",
                                      player->GetGUID().ToString(), e.action.questOffer.questID);
                        }
                    }
                }
            }
            break;
        }
        case SMART_ACTION_SET_REACT_STATE:
        {
            for (WorldObject* target : targets)
            {
                if (!IsCreature(target))
                    continue;
 
                target->ToCreature()->SetReactState(ReactStates(e.action.react.state));
            }
            break;
        }
        case SMART_ACTION_RANDOM_EMOTE:
        {
            std::vector<uint32> emotes;
            std::copy_if(e.action.randomEmote.emotes.begin(), e.action.randomEmote.emotes.end(),
                         std::back_inserter(emotes), [](uint32 emote) { return emote != 0; });
 
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    uint32 emote = Acore::Containers::SelectRandomContainerElement(emotes);
                    target->ToUnit()->HandleEmoteCommand(emote);
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_RANDOM_EMOTE: Creature guidLow {} handle random emote {}",
                              target->GetGUID().ToString(), emote);
                }
            }
            break;
        }
        case SMART_ACTION_THREAT_ALL_PCT:
        {
            if (!me)
                break;
 
            ThreatContainer::StorageType threatList = me->GetThreatMgr().GetThreatList();
            for (ThreatContainer::StorageType::const_iterator i = threatList.begin(); i != threatList.end(); ++i)
            {
                if (Unit* target = ObjectAccessor::GetUnit(*me, (*i)->getUnitGuid()))
                {
                    me->GetThreatMgr().ModifyThreatByPercent(target, e.action.threatPCT.threatINC ? (int32)e.action.threatPCT.threatINC : -(int32)e.action.threatPCT.threatDEC);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_THREAT_ALL_PCT: Creature {} modify threat for unit {}, value {}",
                                   me->GetGUID().ToString(), target->GetGUID().ToString(), e.action.threatPCT.threatINC ? (int32)e.action.threatPCT.threatINC : -(int32)e.action.threatPCT.threatDEC);
                }
            }
            break;
        }
        case SMART_ACTION_THREAT_SINGLE_PCT:
        {
            if (!me)
                break;
 
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    me->GetThreatMgr().ModifyThreatByPercent(target->ToUnit(), e.action.threatPCT.threatINC ? (int32)e.action.threatPCT.threatINC : -(int32)e.action.threatPCT.threatDEC);
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_THREAT_SINGLE_PCT: Creature guidLow {} modify threat for unit {}, value %i",
                              me->GetGUID().ToString(), target->GetGUID().ToString(), e.action.threatPCT.threatINC ? (int32)e.action.threatPCT.threatINC : -(int32)e.action.threatPCT.threatDEC);
                }
            }
            break;
        }
        case SMART_ACTION_CALL_AREAEXPLOREDOREVENTHAPPENS:
        {
            for (WorldObject* target : targets)
            {
                // Special handling for vehicles
                if (IsUnit(target))
                    if (Vehicle* vehicle = target->ToUnit()->GetVehicleKit())
                        for (auto & Seat : vehicle->Seats)
                            if (Player* player = ObjectAccessor::GetPlayer(*target, Seat.second.Passenger.Guid))
                                player->AreaExploredOrEventHappens(e.action.quest.quest);
 
                if (IsPlayer(target))
                {
                    target->ToPlayer()->AreaExploredOrEventHappens(e.action.quest.quest);
 
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_CALL_AREAEXPLOREDOREVENTHAPPENS: Player guidLow {} credited quest {}",
                              target->GetGUID().ToString(), e.action.quest.quest);
                }
            }
            break;
        }
        case SMART_ACTION_CAST:
        {
            if (targets.empty())
                break;
 
            Unit* caster = me;
            // Areatrigger Cast!
            if (e.GetScriptType() == SMART_SCRIPT_TYPE_AREATRIGGER)
                caster = unit->SummonTrigger(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), unit->GetOrientation(), 5000);
 
            if (e.action.cast.targetsLimit > 0 && targets.size() > e.action.cast.targetsLimit)
                Acore::Containers::RandomResize(targets, e.action.cast.targetsLimit);
 
            for (WorldObject* target : targets)
            {
                // may be nullptr
                if (go)
                {
                    go->CastSpell(target->ToUnit(), e.action.cast.spell);
                }
 
                if (!IsUnit(target))
                    continue;
 
                if (caster && caster != me) // Areatrigger cast
                {
                    caster->CastSpell(target->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED));
                }
                else if (me && (!(e.action.cast.flags & SMARTCAST_AURA_NOT_PRESENT) || !target->ToUnit()->HasAura(e.action.cast.spell)))
                {
                    if (e.action.cast.flags & SMARTCAST_INTERRUPT_PREVIOUS)
                        me->InterruptNonMeleeSpells(false);
 
                    // Xinef: flag usable only if caster has max dist set
                    if ((e.action.cast.flags & SMARTCAST_COMBAT_MOVE) && GetCasterMaxDist() > 0.0f && me->GetMaxPower(GetCasterPowerType()) > 0)
                    {
                        // Xinef: check mana case only and operate movement accordingly, LoS and range is checked in targetet movement generator
                        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(e.action.cast.spell);
                        int32 currentPower = me->GetPower(GetCasterPowerType());
 
                        if ((spellInfo && (currentPower < spellInfo->CalcPowerCost(me, spellInfo->GetSchoolMask()) || me->IsSpellProhibited(spellInfo->GetSchoolMask()))) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
                        {
                            SetCasterActualDist(0);
                            CAST_AI(SmartAI, me->AI())->SetForcedCombatMove(0);
                        }
                        else if (GetCasterActualDist() == 0.0f && me->GetPowerPct(GetCasterPowerType()) > 30.0f)
                        {
                            RestoreCasterMaxDist();
                            CAST_AI(SmartAI, me->AI())->SetForcedCombatMove(GetCasterActualDist());
                        }
                    }
 
                    me->CastSpell(target->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED));
                }
            }
 
            break;
        }
        case SMART_ACTION_INVOKER_CAST:
        {
            Unit* tempLastInvoker = GetLastInvoker(unit); // xinef: can be used for area triggers cast
            if (!tempLastInvoker)
                break;
 
            if (targets.empty())
                break;
 
            if (e.action.cast.targetsLimit > 0 && targets.size() > e.action.cast.targetsLimit)
                Acore::Containers::RandomResize(targets, e.action.cast.targetsLimit);
 
            for (WorldObject* target : targets)
            {
                if (!IsUnit(target))
                    continue;
 
                if (!(e.action.cast.flags & SMARTCAST_AURA_NOT_PRESENT) || !target->ToUnit()->HasAura(e.action.cast.spell))
                {
                    if (e.action.cast.flags & SMARTCAST_INTERRUPT_PREVIOUS)
                        tempLastInvoker->InterruptNonMeleeSpells(false);
 
                    tempLastInvoker->CastSpell(target->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED));
                }
            }
 
            break;
        }
        case SMART_ACTION_ADD_AURA:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    target->ToUnit()->AddAura(e.action.cast.spell, target->ToUnit());
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_ADD_AURA: Adding aura {} to unit {}",
                              e.action.cast.spell, target->GetGUID().ToString());
                }
            }
            break;
        }
        case SMART_ACTION_ACTIVATE_GOBJECT:
        {
            for (WorldObject* target : targets)
            {
                if (IsGameObject(target))
                {
                    GameObject* go = target->ToGameObject();
 
                    // Activate
                    if (go->GetGoType() != GAMEOBJECT_TYPE_DOOR)
                    {
                        go->SetLootState(GO_READY);
                    }
 
                    go->UseDoorOrButton(0, !!e.action.activateObject.alternative, unit);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_ACTIVATE_GOBJECT. Gameobject {} activated", go->GetGUID().ToString());
                }
            }
 
            break;
        }
        case SMART_ACTION_RESET_GOBJECT:
        {
            for (WorldObject* target : targets)
            {
                if (IsGameObject(target))
                {
                    target->ToGameObject()->ResetDoorOrButton();
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_RESET_GOBJECT. Gameobject {} (entry: {}) reset",
                              target->GetGUID().ToString(), target->GetEntry());
                }
            }
            break;
        }
        case SMART_ACTION_SET_EMOTE_STATE:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    target->ToUnit()->SetUInt32Value(UNIT_NPC_EMOTESTATE, e.action.emote.emote);
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_SET_EMOTE_STATE. Unit {} set emotestate to {}",
                              target->GetGUID().ToString(), e.action.emote.emote);
                }
            }
            break;
        }
        case SMART_ACTION_SET_UNIT_FLAG:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    if (!e.action.unitFlag.type)
                    {
                        target->ToUnit()->SetFlag(UNIT_FIELD_FLAGS, e.action.unitFlag.flag);
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_SET_UNIT_FLAG. Unit {} added flag {} to UNIT_FIELD_FLAGS",
                                  target->GetGUID().ToString(), e.action.unitFlag.flag);
                    }
                    else
                    {
                        target->ToUnit()->SetFlag(UNIT_FIELD_FLAGS_2, e.action.unitFlag.flag);
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_SET_UNIT_FLAG. Unit {} added flag {} to UNIT_FIELD_FLAGS_2",
                                  target->GetGUID().ToString(), e.action.unitFlag.flag);
                    }
                }
            }
            break;
        }
        case SMART_ACTION_REMOVE_UNIT_FLAG:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    if (!e.action.unitFlag.type)
                    {
                        target->ToUnit()->RemoveFlag(UNIT_FIELD_FLAGS, e.action.unitFlag.flag);
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_REMOVE_UNIT_FLAG. Unit {} removed flag {} to UNIT_FIELD_FLAGS",
                                  target->GetGUID().ToString(), e.action.unitFlag.flag);
                    }
                    else
                    {
                        target->ToUnit()->RemoveFlag(UNIT_FIELD_FLAGS_2, e.action.unitFlag.flag);
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_REMOVE_UNIT_FLAG. Unit {} removed flag {} to UNIT_FIELD_FLAGS_2",
                                  target->GetGUID().ToString(), e.action.unitFlag.flag);
                    }
                }
            }
            break;
        }
        case SMART_ACTION_AUTO_ATTACK:
        {
            if (!IsSmart())
                break;
 
            CAST_AI(SmartAI, me->AI())->SetAutoAttack(e.action.autoAttack.attack);
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_AUTO_ATTACK: Creature: {} bool on = {}",
                           me->GetGUID().ToString(), e.action.autoAttack.attack);
            break;
        }
        case SMART_ACTION_ALLOW_COMBAT_MOVEMENT:
        {
            if (!IsSmart())
                break;
 
            // Xinef: Fix Combat Movement
            bool move = e.action.combatMove.move;
            if (move && GetMaxCombatDist() && e.GetEventType() == SMART_EVENT_MANA_PCT)
            {
                SetActualCombatDist(0);
                CAST_AI(SmartAI, me->AI())->SetForcedCombatMove(0);
            }
            else
                CAST_AI(SmartAI, me->AI())->SetCombatMove(move);
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_ALLOW_COMBAT_MOVEMENT: Creature {} bool on = {}",
                           me->GetGUID().ToString(), e.action.combatMove.move);
            break;
        }
        case SMART_ACTION_SET_EVENT_PHASE:
        {
            if (!GetBaseObject())
                break;
 
            SetPhase(e.action.setEventPhase.phase);
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_SET_EVENT_PHASE: Creature {} set event phase {}",
                           GetBaseObject()->GetGUID().ToString(), e.action.setEventPhase.phase);
            break;
        }
        case SMART_ACTION_INC_EVENT_PHASE:
        {
            if (!GetBaseObject())
                break;
 
            IncPhase(e.action.incEventPhase.inc);
            DecPhase(e.action.incEventPhase.dec);
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_INC_EVENT_PHASE: Creature {} inc event phase by {}, "
                           "decrease by {}", GetBaseObject()->GetGUID().ToString(), e.action.incEventPhase.inc, e.action.incEventPhase.dec);
            break;
        }
        case SMART_ACTION_EVADE:
        {
            if (!GetBaseObject())
                break;
 
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    if (target->ToCreature()->IsAIEnabled)
                        target->ToCreature()->AI()->EnterEvadeMode();
 
            break;
        }
        case SMART_ACTION_FLEE_FOR_ASSIST:
        {
            // Xinef: do not allow to flee without control (stun, fear etc)
            if (!me || me->HasUnitState(UNIT_STATE_LOST_CONTROL) || me->GetSpeed(MOVE_RUN) < 0.1f)
                break;
 
            me->DoFleeToGetAssistance();
            if (e.action.flee.withEmote)
            {
                Acore::BroadcastTextBuilder builder(me, CHAT_MSG_MONSTER_EMOTE, BROADCAST_TEXT_FLEE_FOR_ASSIST, me->getGender());
                sCreatureTextMgr->SendChatPacket(me, builder, CHAT_MSG_MONSTER_EMOTE);
            }
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_FLEE_FOR_ASSIST: Creature {} DoFleeToGetAssistance", me->GetGUID().ToString());
            break;
        }
        case SMART_ACTION_COMBAT_STOP:
        {
            if (!me)
                break;
 
            me->CombatStop(true);
            break;
        }
        case SMART_ACTION_CALL_GROUPEVENTHAPPENS:
        {
            for (WorldObject* target : targets)
            {
                if (!IsUnit(target))
                    continue;
 
                Unit* unitTarget = target->ToUnit();
                // If invoker was pet or charm
                Player* player = unitTarget->GetCharmerOrOwnerPlayerOrPlayerItself();
                if (player && GetBaseObject())
                {
                    player->GroupEventHappens(e.action.quest.quest, GetBaseObject());
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_CALL_GROUPEVENTHAPPENS: Player {}, group credit for quest {}",
                        player->GetGUID().ToString(), e.action.quest.quest);
                }
 
                // Special handling for vehicles
                if (Vehicle* vehicle = unitTarget->GetVehicleKit())
                {
                    for (auto& Seat : vehicle->Seats)
                    {
                        if (Player* player = ObjectAccessor::GetPlayer(*unitTarget, Seat.second.Passenger.Guid))
                        {
                            player->GroupEventHappens(e.action.quest.quest, GetBaseObject());
                        }
                    }
                }
            }
            break;
        }
        case SMART_ACTION_REMOVEAURASFROMSPELL:
        {
            for (WorldObject* target : targets)
            {
                if (!IsUnit(target))
                    continue;
 
                if (e.action.removeAura.spell)
                {
                    if (e.action.removeAura.charges)
                    {
                        if (Aura* aur = target->ToUnit()->GetAura(e.action.removeAura.spell))
                            aur->ModCharges(-static_cast<int32>(e.action.removeAura.charges), AURA_REMOVE_BY_EXPIRE);
                    }
                    else
                        target->ToUnit()->RemoveAurasDueToSpell(e.action.removeAura.spell);
                }
                else
                    target->ToUnit()->RemoveAllAuras();
 
                LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_REMOVEAURASFROMSPELL: Unit {}, spell {}",
                          target->GetGUID().ToString(), e.action.removeAura.spell);
            }
            break;
        }
        case SMART_ACTION_FOLLOW:
        {
            if (!IsSmart())
                break;
 
            if (targets.empty())
            {
                CAST_AI(SmartAI, me->AI())->StopFollow(false);
                break;
            }
 
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    float angle = e.action.follow.angle > 6 ? (e.action.follow.angle * M_PI / 180.0f) : e.action.follow.angle;
                    CAST_AI(SmartAI, me->AI())->SetFollow(target->ToUnit(), float(e.action.follow.dist) + 0.1f, angle, e.action.follow.credit, e.action.follow.entry, e.action.follow.creditType, e.action.follow.aliveState);
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_FOLLOW: Creature {} following target {}",
                              me->GetGUID().ToString(), target->GetGUID().ToString());
                    break;
                }
            }
            break;
        }
        case SMART_ACTION_RANDOM_PHASE:
        {
            if (!GetBaseObject())
                break;
 
            std::vector<uint32> phases;
            std::copy_if(e.action.randomPhase.phases.begin(), e.action.randomPhase.phases.end(),
                         std::back_inserter(phases), [](uint32 phase) { return phase != 0; });
 
            uint32 phase = Acore::Containers::SelectRandomContainerElement(phases);
            SetPhase(phase);
            LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_RANDOM_PHASE: Creature {} sets event phase to {}",
                      GetBaseObject()->GetGUID().ToString(), phase);
            break;
        }
        case SMART_ACTION_RANDOM_PHASE_RANGE:
        {
            if (!GetBaseObject())
                break;
 
            uint32 phase = urand(e.action.randomPhaseRange.phaseMin, e.action.randomPhaseRange.phaseMax);
            SetPhase(phase);
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_RANDOM_PHASE_RANGE: Creature {} sets event phase to {}",
                           GetBaseObject()->GetGUID().ToString(), phase);
            break;
        }
        case SMART_ACTION_CALL_KILLEDMONSTER:
        {
            if (trigger && IsPlayer(unit))
            {
                unit->ToPlayer()->RewardPlayerAndGroupAtEvent(e.action.killedMonster.creature, unit);
                LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_CALL_KILLEDMONSTER: (trigger == true) Player {}, Killcredit: {}",
                          unit->GetGUID().ToString(), e.action.killedMonster.creature);
            }
            else if (e.target.type == SMART_TARGET_NONE || e.target.type == SMART_TARGET_SELF) // Loot recipient and his group members
            {
                if (!me)
                    break;
 
                if (Player* player = me->GetLootRecipient())
                {
                    player->RewardPlayerAndGroupAtEvent(e.action.killedMonster.creature, player);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_CALL_KILLEDMONSTER: Player {}, Killcredit: {}",
                              player->GetGUID().ToString(), e.action.killedMonster.creature);
                }
            }
            else // Specific target type
            {
                for (WorldObject* target : targets)
                {
                    if (!IsUnit(target))
                        continue;
 
                    Player* player = target->ToUnit()->GetCharmerOrOwnerPlayerOrPlayerItself();
                    if (!player)
                        continue;
 
                    player->RewardPlayerAndGroupAtEvent(e.action.killedMonster.creature, player);
                    LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_CALL_KILLEDMONSTER: Player {}, Killcredit: {}",
                              target->GetGUID().ToString(), e.action.killedMonster.creature);
                }
            }
            break;
        }
        case SMART_ACTION_SET_INST_DATA:
        {
            WorldObject* obj = GetBaseObject();
            if (!obj)
                obj = unit;
 
            if (!obj)
                break;
 
            InstanceScript* instance = obj->GetInstanceScript();
            if (!instance)
            {
                LOG_ERROR("scripts.ai.sai", "SmartScript: Event {} attempt to set instance data without instance script. EntryOrGuid {}", e.GetEventType(), e.entryOrGuid);
                break;
            }
 
            switch (e.action.setInstanceData.type)
            {
                case 0:
                {
                    instance->SetData(e.action.setInstanceData.field, e.action.setInstanceData.data);
                    LOG_DEBUG("scripts.ai.sai", "SmartScript::ProcessAction: SMART_ACTION_SET_INST_DATA: Field: {}, data: {}", e.action.setInstanceData.field, e.action.setInstanceData.data);
                } break;
                case 1:
                {
                    instance->SetBossState(e.action.setInstanceData.field, static_cast<EncounterState>(e.action.setInstanceData.data));
                    LOG_DEBUG("scripts.ai.sai", "SmartScript::ProcessAction: SMART_ACTION_SET_INST_DATA: SetBossState BossId: {}, State: {} ({})", e.action.setInstanceData.field, e.action.setInstanceData.data, InstanceScript::GetBossStateName(e.action.setInstanceData.data));
                } break;
                default:
                {
                    break;
                }
            }
            break;
        }
        case SMART_ACTION_SET_INST_DATA64:
        {
            WorldObject* obj = GetBaseObject();
            if (!obj)
                obj = unit;
 
            if (!obj)
                break;
 
            InstanceScript* instance = obj->GetInstanceScript();
            if (!instance)
            {
                LOG_ERROR("sql.sql", "SmartScript: Event {} attempt to set instance data without instance script. EntryOrGuid {}", e.GetEventType(), e.entryOrGuid);
                break;
            }
 
            if (targets.empty())
                break;
 
            instance->SetGuidData(e.action.setInstanceData64.field, targets.front()->GetGUID());
            LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_SET_INST_DATA64: Field: {}, data: {}",
                      e.action.setInstanceData64.field, targets.front()->GetGUID().ToString());
            break;
        }
        case SMART_ACTION_UPDATE_TEMPLATE:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToCreature()->UpdateEntry(e.action.updateTemplate.creature, target->ToCreature()->GetCreatureData(), e.action.updateTemplate.updateLevel != 0);
            break;
        }
        case SMART_ACTION_DIE:
        {
            if (me && !me->isDead())
            {
                me->KillSelf();
                LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_DIE: Creature {}", me->GetGUID().ToString());
            }
            break;
        }
        case SMART_ACTION_SET_IN_COMBAT_WITH_ZONE:
        {
            if (targets.empty())
                break;
 
            if (!me->GetMap()->IsDungeon())
            {
                ObjectVector units;
                GetWorldObjectsInDist(units, static_cast<float>(e.target.unitRange.maxDist));
 
                if (!units.empty() && GetBaseObject())
                    for (WorldObject* unit : units)
                        if (IsPlayer(unit) && !unit->ToPlayer()->isDead())
                        {
                            me->SetInCombatWith(unit->ToPlayer());
                            unit->ToPlayer()->SetInCombatWith(me);
                            me->AddThreat(unit->ToPlayer(), 0.0f);
                        }
            }
            else
            {
                for (WorldObject* target : targets)
                {
                    if (IsCreature(target))
                    {
                        target->ToCreature()->SetInCombatWithZone();
                        LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_SET_IN_COMBAT_WITH_ZONE: Creature {}, target: {}",
                                  me->GetGUID().ToString(), target->GetGUID().ToString());
                    }
                }
            }
 
            break;
        }
        case SMART_ACTION_CALL_FOR_HELP:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    target->ToCreature()->CallForHelp(float(e.action.callHelp.range));
                    if (e.action.callHelp.withEmote)
                    {
                        Acore::BroadcastTextBuilder builder(target, CHAT_MSG_MONSTER_EMOTE, BROADCAST_TEXT_CALL_FOR_HELP, LANG_UNIVERSAL, nullptr);
                        sCreatureTextMgr->SendChatPacket(target, builder, CHAT_MSG_MONSTER_EMOTE);
                    }
                    LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction: SMART_ACTION_CALL_FOR_HELP: Creature {}, target: {}",
                              me->GetGUID().ToString(), target->GetGUID().ToString());
                }
            }
            break;
        }
        case SMART_ACTION_SET_SHEATH:
        {
            if (me)
            {
                me->SetSheath(SheathState(e.action.setSheath.sheath));
                LOG_DEBUG("sql.sql", "SmartScript::ProcessAction: SMART_ACTION_SET_SHEATH: Creature {}, State: {}",
                               me->GetGUID().ToString(), e.action.setSheath.sheath);
            }
            break;
        }
        case SMART_ACTION_FORCE_DESPAWN:
        {
            for (WorldObject* target : targets)
            {
                Milliseconds despawnDelay(e.action.forceDespawn.delay);
 
                // Wait at least one world update tick before despawn, so it doesn't break linked actions.
                if (despawnDelay <= 0ms)
                {
                    despawnDelay = 1ms;
                }
 
                Seconds forceRespawnTimer(e.action.forceDespawn.forceRespawnTimer);
                if (Creature* creature = target->ToCreature())
                {
                    creature->DespawnOrUnsummon(despawnDelay, forceRespawnTimer);
                }
                else if (GameObject* go = target->ToGameObject())
                {
                    go->DespawnOrUnsummon(despawnDelay, forceRespawnTimer);
                }
            }
 
            break;
        }
        case SMART_ACTION_SET_INGAME_PHASE_MASK:
        {
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                    target->ToUnit()->SetPhaseMask(e.action.ingamePhaseMask.mask, true);
                else if (IsGameObject(target))
                    target->ToGameObject()->SetPhaseMask(e.action.ingamePhaseMask.mask, true);
            }
            break;
        }
        case SMART_ACTION_MOUNT_TO_ENTRY_OR_MODEL:
        {
            for (WorldObject* target : targets)
            {
                if (!IsUnit(target))
                    continue;
 
                if (e.action.morphOrMount.creature || e.action.morphOrMount.model)
                {
                    if (e.action.morphOrMount.creature > 0)
                    {
                        if (CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(e.action.morphOrMount.creature))
                            target->ToUnit()->Mount(ObjectMgr::ChooseDisplayId(cInfo));
                    }
                    else
                        target->ToUnit()->Mount(e.action.morphOrMount.model);
                }
                else
                    target->ToUnit()->Dismount();
            }
            break;
        }
        case SMART_ACTION_SET_INVINCIBILITY_HP_LEVEL:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    SmartAI* ai = CAST_AI(SmartAI, target->ToCreature()->AI());
                    if (!ai)
                        continue;
 
                    if (e.action.invincHP.percent)
                        ai->SetInvincibilityHpLevel(target->ToCreature()->CountPctFromMaxHealth(e.action.invincHP.percent));
                    else
                        ai->SetInvincibilityHpLevel(e.action.invincHP.minHP);
                }
            }
            break;
        }
        case SMART_ACTION_SET_DATA:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                    target->ToCreature()->AI()->SetData(e.action.setData.field, e.action.setData.data);
                else if (IsGameObject(target))
                    target->ToGameObject()->AI()->SetData(e.action.setData.field, e.action.setData.data);
            }
            break;
        }
        case SMART_ACTION_MOVE_FORWARD:
        {
            if (!me)
                break;
 
            float x, y, z;
            me->GetClosePoint(x, y, z, me->GetObjectSize() / 3, (float)e.action.moveRandom.distance);
            me->GetMotionMaster()->MovePoint(SMART_RANDOM_POINT, x, y, z);
            break;
        }
        case SMART_ACTION_RISE_UP:
        {
            if (!me)
                break;
 
            me->GetMotionMaster()->MovePoint(SMART_RANDOM_POINT, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ() + (float)e.action.moveRandom.distance);
            break;
        }
        case SMART_ACTION_SET_VISIBILITY:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetVisible(!!e.action.visibility.state);
 
            break;
        }
        case SMART_ACTION_SET_ACTIVE:
        {
            for (WorldObject* target : targets)
                target->setActive(!!e.action.setActive.state);
            break;
        }
        case SMART_ACTION_ATTACK_START:
        {
            if (!me)
                break;
 
            if (targets.empty())
                break;
 
            // attack random target
            if (Unit* target = Acore::Containers::SelectRandomContainerElement(targets)->ToUnit())
                me->AI()->AttackStart(target);
            break;
        }
        case SMART_ACTION_ATTACK_STOP:
        {
            for (WorldObject* target : targets)
                if (Unit* unitTarget = target->ToUnit())
                    unitTarget->AttackStop();
            break;
        }
        case SMART_ACTION_SUMMON_CREATURE:
        {
            EnumFlag<SmartActionSummonCreatureFlags> flags(static_cast<SmartActionSummonCreatureFlags>(e.action.summonCreature.flags));
            bool preferUnit = flags.HasFlag(SmartActionSummonCreatureFlags::PreferUnit);
            WorldObject* summoner = preferUnit ? unit : Coalesce<WorldObject>(GetBaseObject(), unit);
            if (!summoner)
                break;
 
            bool personalSpawn = flags.HasFlag(SmartActionSummonCreatureFlags::PersonalSpawn);
 
            if (e.GetTargetType() == SMART_TARGET_RANDOM_POINT)
            {
                float range = (float)e.target.randomPoint.range;
                Position randomPoint;
                Position srcPos = { e.target.x, e.target.y, e.target.z, e.target.o };
                for (uint32 i = 0; i < e.target.randomPoint.amount; i++)
                {
                    if (e.target.randomPoint.self > 0)
                        randomPoint = me->GetRandomPoint(me->GetPosition(), range);
                    else
                        randomPoint = me->GetRandomPoint(srcPos, range);
                    if (Creature* summon = summoner->SummonCreature(e.action.summonCreature.creature, randomPoint, (TempSummonType)e.action.summonCreature.type, e.action.summonCreature.duration, 0, nullptr, personalSpawn))
                    {
                        if (unit && e.action.summonCreature.attackInvoker)
                            summon->AI()->AttackStart(unit);
                        else if (me && e.action.summonCreature.attackScriptOwner)
                            summon->AI()->AttackStart(me);
                    }
                }
                break;
            }
 
            float x, y, z, o;
            for (WorldObject* target : targets)
            {
                target->GetPosition(x, y, z, o);
                x += e.target.x;
                y += e.target.y;
                z += e.target.z;
                o += e.target.o;
                if (Creature* summon = summoner->SummonCreature(e.action.summonCreature.creature, x, y, z, o, (TempSummonType)e.action.summonCreature.type, e.action.summonCreature.duration, nullptr, personalSpawn))
                {
                    if (e.action.summonCreature.attackInvoker == 2) // pussywizard: proper attackInvoker implementation
                        summon->AI()->AttackStart(unit);
                    else if (e.action.summonCreature.attackInvoker)
                        summon->AI()->AttackStart(target->ToUnit());
                    else if (me && e.action.summonCreature.attackScriptOwner)
                        summon->AI()->AttackStart(me);
                }
            }
 
            if (e.GetTargetType() != SMART_TARGET_POSITION)
                break;
 
            if (Creature* summon = summoner->SummonCreature(e.action.summonCreature.creature, e.target.x, e.target.y, e.target.z, e.target.o, (TempSummonType)e.action.summonCreature.type, e.action.summonCreature.duration))
            {
                if (unit && e.action.summonCreature.attackInvoker)
                    summon->AI()->AttackStart(unit);
                else if (me && e.action.summonCreature.attackScriptOwner)
                    summon->AI()->AttackStart(me);
            }
            break;
        }
        case SMART_ACTION_SUMMON_GO:
        {
            if (!GetBaseObject())
                break;
 
            if (!targets.empty())
            {
                float x, y, z, o;
                for (WorldObject* target : targets)
                {
                    // xinef: allow gameobjects to summon gameobjects!
                    //if(!IsUnit((*itr)))
                    //  continue;
 
                    target->GetPosition(x, y, z, o);
                    x += e.target.x;
                    y += e.target.y;
                    z += e.target.z;
                    o += e.target.o;
                    if (!e.action.summonGO.targetsummon)
                        GetBaseObject()->SummonGameObject(e.action.summonGO.entry, x, y, z, o, 0, 0, 0, 0, e.action.summonGO.despawnTime);
                    else
                        target->SummonGameObject(e.action.summonGO.entry, GetBaseObject()->GetPositionX(), GetBaseObject()->GetPositionY(), GetBaseObject()->GetPositionZ(), GetBaseObject()->GetOrientation(), 0, 0, 0, 0, e.action.summonGO.despawnTime);
                }
            }
 
            if (e.GetTargetType() != SMART_TARGET_POSITION)
                break;
 
            GetBaseObject()->SummonGameObject(e.action.summonGO.entry, e.target.x, e.target.y, e.target.z, e.target.o, 0, 0, 0, 0, e.action.summonGO.despawnTime);
            break;
        }
        case SMART_ACTION_KILL_UNIT:
        {
            for (WorldObject* target : targets)
            {
                if (!IsUnit(target))
                    continue;
 
                Unit::Kill(target->ToUnit(), target->ToUnit());
            }
 
            break;
        }
        case SMART_ACTION_INSTALL_AI_TEMPLATE:
        {
            InstallTemplate(e);
            break;
        }
        case SMART_ACTION_ADD_ITEM:
        {
            for (WorldObject* target : targets)
            {
                if (!IsPlayer(target))
                    continue;
 
                target->ToPlayer()->AddItem(e.action.item.entry, e.action.item.count);
            }
            break;
        }
        case SMART_ACTION_REMOVE_ITEM:
        {
            for (WorldObject* target : targets)
            {
                if (!IsPlayer(target))
                    continue;
 
                target->ToPlayer()->DestroyItemCount(e.action.item.entry, e.action.item.count, true);
            }
            break;
        }
        case SMART_ACTION_STORE_TARGET_LIST:
        {
            StoreTargetList(targets, e.action.storeTargets.id);
            break;
        }
        case SMART_ACTION_TELEPORT:
        {
            for (WorldObject* target : targets)
            {
                if (IsPlayer(target))
                    target->ToPlayer()->TeleportTo(e.action.teleport.mapID, e.target.x, e.target.y, e.target.z, e.target.o);
                else if (IsCreature(target))
                    target->ToCreature()->NearTeleportTo(e.target.x, e.target.y, e.target.z, e.target.o);
            }
            break;
        }
        case SMART_ACTION_SET_FLY:
        {
            if (!IsSmart())
                break;
 
            CAST_AI(SmartAI, me->AI())->SetFly(e.action.setFly.fly);
            // Xinef: Set speed if any
            if (e.action.setFly.speed)
                me->SetSpeed(MOVE_RUN, float(e.action.setFly.speed / 100.0f), true);
 
            // Xinef: this wil be executed only if state is different
            me->SetDisableGravity(e.action.setFly.disableGravity);
            break;
        }
        case SMART_ACTION_SET_RUN:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    if (IsSmart(target->ToCreature()))
                        CAST_AI(SmartAI, target->ToCreature()->AI())->SetRun(e.action.setRun.run);
                    else
                        target->ToCreature()->SetWalk(e.action.setRun.run ? false : true); // Xinef: reversed
                }
            }
 
            break;
        }
        case SMART_ACTION_SET_SWIM:
        {
            if (!IsSmart())
                break;
 
            CAST_AI(SmartAI, me->AI())->SetSwim(e.action.setSwim.swim);
            break;
        }
        case SMART_ACTION_SET_COUNTER:
        {
            if (!targets.empty())
            {
                for (WorldObject* target : targets)
                {
                    if (IsCreature(target))
                    {
                        if (SmartAI* ai = CAST_AI(SmartAI, target->ToCreature()->AI()))
                            ai->GetScript()->StoreCounter(e.action.setCounter.counterId, e.action.setCounter.value, e.action.setCounter.reset, e.action.setCounter.subtract);
                        else
                            LOG_ERROR("sql.sql", "SmartScript: Action target for SMART_ACTION_SET_COUNTER is not using SmartAI, skipping");
                    }
                    else if (IsGameObject(target))
                    {
                        if (SmartGameObjectAI* ai = CAST_AI(SmartGameObjectAI, target->ToGameObject()->AI()))
                            ai->GetScript()->StoreCounter(e.action.setCounter.counterId, e.action.setCounter.value, e.action.setCounter.reset, e.action.setCounter.subtract);
                        else
                            LOG_ERROR("sql.sql", "SmartScript: Action target for SMART_ACTION_SET_COUNTER is not using SmartGameObjectAI, skipping");
                    }
                }
            }
            else
                StoreCounter(e.action.setCounter.counterId, e.action.setCounter.value, e.action.setCounter.reset, e.action.setCounter.subtract);
            break;
        }
        case SMART_ACTION_WP_START:
        {
            if (!IsSmart())
                break;
 
            bool run = e.action.wpStart.run != 0;
            uint32 entry = e.action.wpStart.pathID;
            bool repeat = e.action.wpStart.repeat != 0;
 
            for (WorldObject* target : targets)
            {
                if (IsPlayer(target))
                {
                    StoreTargetList(targets, SMART_ESCORT_TARGETS);
                    break;
                }
            }
 
            me->SetReactState((ReactStates)e.action.wpStart.reactState);
            CAST_AI(SmartAI, me->AI())->StartPath(run, entry, repeat, unit);
 
            uint32 quest = e.action.wpStart.quest;
            uint32 DespawnTime = e.action.wpStart.despawnTime;
            CAST_AI(SmartAI, me->AI())->mEscortQuestID = quest;
            CAST_AI(SmartAI, me->AI())->SetDespawnTime(DespawnTime);
            break;
        }
        case SMART_ACTION_WP_PAUSE:
        {
            if (!IsSmart())
                break;
 
            uint32 delay = e.action.wpPause.delay;
            CAST_AI(SmartAI, me->AI())->PausePath(delay, e.GetEventType() == SMART_EVENT_WAYPOINT_REACHED ? false : true);
            break;
        }
        case SMART_ACTION_WP_STOP:
        {
            if (!IsSmart())
                break;
 
            uint32 DespawnTime = e.action.wpStop.despawnTime;
            uint32 quest = e.action.wpStop.quest;
            bool fail = e.action.wpStop.fail;
            CAST_AI(SmartAI, me->AI())->StopPath(DespawnTime, quest, fail);
            break;
        }
        case SMART_ACTION_WP_RESUME:
        {
            if (!IsSmart())
                break;
 
            CAST_AI(SmartAI, me->AI())->SetWPPauseTimer(0);
            break;
        }
        case SMART_ACTION_SET_ORIENTATION:
        {
            if (!me)
                break;
 
            if (e.action.orientation.random > 0)
            {
                float randomOri = frand(0.0f, 2 * M_PI);
                me->SetFacingTo(randomOri);
                if (e.action.orientation.quickChange)
                    me->SetOrientation(randomOri);
                break;
            }
 
            if (e.GetTargetType() == SMART_TARGET_SELF)
            {
                me->SetFacingTo((me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && me->GetTransGUID() ? me->GetTransportHomePosition() : me->GetHomePosition()).GetOrientation());
                if (e.action.orientation.quickChange)
                    me->SetOrientation((me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && me->GetTransGUID() ? me->GetTransportHomePosition() : me->GetHomePosition()).GetOrientation());
            }
            else if (e.GetTargetType() == SMART_TARGET_POSITION)
            {
                me->SetFacingTo(e.target.o);
                if (e.action.orientation.quickChange)
                    me->SetOrientation(e.target.o);
            }
            else if (!targets.empty())
            {
                me->SetFacingToObject(*targets.begin());
                if (e.action.orientation.quickChange)
                    me->SetInFront(*targets.begin());
            }
 
            break;
        }
        case SMART_ACTION_PLAYMOVIE:
        {
            for (WorldObject* target : targets)
            {
                if (!IsPlayer(target))
                    continue;
 
                target->ToPlayer()->SendMovieStart(e.action.movie.entry);
            }
            break;
        }
        case SMART_ACTION_MOVE_TO_POS:
        {
            if (!IsSmart())
                break;
 
            WorldObject* target = nullptr;
 
            if (e.GetTargetType() == SMART_TARGET_RANDOM_POINT)
            {
                if (me)
                {
                    float range = (float)e.target.randomPoint.range;
                    Position srcPos = { e.target.x, e.target.y, e.target.z, e.target.o };
                    Position randomPoint = me->GetRandomPoint(srcPos, range);
                    me->GetMotionMaster()->MovePoint(
                            e.action.moveToPos.pointId,
                            randomPoint.m_positionX,
                            randomPoint.m_positionY,
                            randomPoint.m_positionZ,
                            true,
                            true,
                            isControlled ? MOTION_SLOT_CONTROLLED : MOTION_SLOT_ACTIVE
                    );
                }
 
                break;
            }
 
            /*if (e.GetTargetType() == SMART_TARGET_CREATURE_RANGE || e.GetTargetType() == SMART_TARGET_CREATURE_GUID ||
            e.GetTargetType() == SMART_TARGET_CREATURE_DISTANCE || e.GetTargetType() == SMART_TARGET_GAMEOBJECT_RANGE ||
            e.GetTargetType() == SMART_TARGET_GAMEOBJECT_GUID || e.GetTargetType() == SMART_TARGET_GAMEOBJECT_DISTANCE ||
            e.GetTargetType() == SMART_TARGET_CLOSEST_CREATURE || e.GetTargetType() == SMART_TARGET_CLOSEST_GAMEOBJECT ||
            e.GetTargetType() == SMART_TARGET_OWNER_OR_SUMMONER || e.GetTargetType() == SMART_TARGET_ACTION_INVOKER ||
            e.GetTargetType() == SMART_TARGET_CLOSEST_ENEMY || e.GetTargetType() == SMART_TARGET_CLOSEST_FRIENDLY ||
            e.GetTargetType() == SMART_TARGET_SELF || e.GetTargetType() == SMART_TARGET_STORED) // Xinef: bieda i rozpierdol TC)*/
            {
                // we want to move to random element
                if (!targets.empty())
                    target = Acore::Containers::SelectRandomContainerElement(targets);
            }
 
            if (!target)
            {
                G3D::Vector3 dest(e.target.x, e.target.y, e.target.z);
                if (e.action.moveToPos.transport)
                    if (TransportBase* trans = me->GetDirectTransport())
                        trans->CalculatePassengerPosition(dest.x, dest.y, dest.z);
 
                me->GetMotionMaster()->MovePoint(e.action.moveToPos.pointId, dest.x, dest.y, dest.z, true, true,
                                                 isControlled ? MOTION_SLOT_CONTROLLED : MOTION_SLOT_ACTIVE, e.target.o);
            }
            else // Xinef: we can use dest.x, dest.y, dest.z to make offset
            {
                float x, y, z;
                target->GetPosition(x, y, z);
                if (e.action.moveToPos.ContactDistance > 0)
                    target->GetContactPoint(me, x, y, z, e.action.moveToPos.ContactDistance);
                me->GetMotionMaster()->MovePoint(e.action.moveToPos.pointId, x + e.target.x, y + e.target.y, z + e.target.z, true, true, isControlled ? MOTION_SLOT_CONTROLLED : MOTION_SLOT_ACTIVE);
            }
            break;
        }
        case SMART_ACTION_MOVE_TO_POS_TARGET:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    Creature* ctarget = target->ToCreature();
                    ctarget->GetMotionMaster()->MovePoint(e.action.moveToPos.pointId, e.target.x, e.target.y, e.target.z, true, true, isControlled ? MOTION_SLOT_CONTROLLED : MOTION_SLOT_ACTIVE);
                }
            }
 
            break;
        }
        case SMART_ACTION_RESPAWN_TARGET:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                    target->ToCreature()->Respawn();
                else if (IsGameObject(target))
                {
                    // do not modify respawndelay of already spawned gameobjects
                    if (target->ToGameObject()->isSpawnedByDefault())
                        target->ToGameObject()->Respawn();
                    else
                        target->ToGameObject()->SetRespawnTime(e.action.RespawnTarget.goRespawnTime);
                }
            }
            break;
        }
        case SMART_ACTION_CLOSE_GOSSIP:
        {
            for (WorldObject* target : targets)
                if (IsPlayer(target))
                    target->ToPlayer()->PlayerTalkClass->SendCloseGossip();
            break;
        }
        case SMART_ACTION_EQUIP:
        {
            for (WorldObject* target : targets)
            {
                if (Creature* npc = target->ToCreature())
                {
                    std::array<uint32, MAX_EQUIPMENT_ITEMS> slot;
                    if (int8 equipId = static_cast<int8>(e.action.equip.entry))
                    {
                        EquipmentInfo const* eInfo = sObjectMgr->GetEquipmentInfo(npc->GetEntry(), equipId);
                        if (!eInfo)
                        {
                            LOG_ERROR("sql.sql", "SmartScript: SMART_ACTION_EQUIP uses non-existent equipment info id {} for creature {}", equipId, npc->GetEntry());
                            break;
                        }
 
                        npc->SetCurrentEquipmentId(equipId);
 
                        std::copy(std::begin(eInfo->ItemEntry), std::end(eInfo->ItemEntry), std::begin(slot));
                    }
                    else
                        std::copy(std::begin(e.action.equip.slots), std::end(e.action.equip.slots), std::begin(slot));
 
                    for (uint32 i = 0; i < MAX_EQUIPMENT_ITEMS; ++i)
                        if (!e.action.equip.mask || (e.action.equip.mask & (1 << i)))
                            npc->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i, slot[i]);
                }
            }
            break;
        }
        case SMART_ACTION_CREATE_TIMED_EVENT:
        {
            SmartEvent ne = SmartEvent();
            ne.type = (SMART_EVENT)SMART_EVENT_UPDATE;
            ne.event_chance = e.action.timeEvent.chance;
            if (!ne.event_chance) ne.event_chance = 100;
 
            ne.minMaxRepeat.min = e.action.timeEvent.min;
            ne.minMaxRepeat.max = e.action.timeEvent.max;
            ne.minMaxRepeat.repeatMin = e.action.timeEvent.repeatMin;
            ne.minMaxRepeat.repeatMax = e.action.timeEvent.repeatMax;
 
            ne.event_flags = 0;
            if (!ne.minMaxRepeat.repeatMin && !ne.minMaxRepeat.repeatMax)
                ne.event_flags |= SMART_EVENT_FLAG_NOT_REPEATABLE;
 
            SmartAction ac = SmartAction();
            ac.type = (SMART_ACTION)SMART_ACTION_TRIGGER_TIMED_EVENT;
            ac.timeEvent.id = e.action.timeEvent.id;
 
            SmartScriptHolder ev = SmartScriptHolder();
            ev.event = ne;
            ev.event_id = e.action.timeEvent.id;
            ev.target = e.target;
            ev.action = ac;
            InitTimer(ev);
            mStoredEvents.push_back(ev);
            break;
        }
        case SMART_ACTION_TRIGGER_TIMED_EVENT:
            ProcessEventsFor((SMART_EVENT)SMART_EVENT_TIMED_EVENT_TRIGGERED, nullptr, e.action.timeEvent.id);
 
            // xinef: remove this event if not repeatable
            if (e.event.event_flags & SMART_EVENT_FLAG_NOT_REPEATABLE)
                mRemIDs.push_back(e.action.timeEvent.id);
            break;
        case SMART_ACTION_REMOVE_TIMED_EVENT:
            mRemIDs.push_back(e.action.timeEvent.id);
            break;
        case SMART_ACTION_OVERRIDE_SCRIPT_BASE_OBJECT:
        {
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    if (!meOrigGUID)
                        meOrigGUID = me ? me->GetGUID() : ObjectGuid::Empty;
                    if (!goOrigGUID)
                        goOrigGUID = go ? go->GetGUID() : ObjectGuid::Empty;
                    go = nullptr;
                    me = target->ToCreature();
                    break;
                }
                else if (IsGameObject(target))
                {
                    if (!meOrigGUID)
                        meOrigGUID = me ? me->GetGUID() : ObjectGuid::Empty;
                    if (!goOrigGUID)
                        goOrigGUID = go ? go->GetGUID() : ObjectGuid::Empty;
                    go = target->ToGameObject();
                    me = nullptr;
                    break;
                }
            }
 
            break;
        }
        case SMART_ACTION_RESET_SCRIPT_BASE_OBJECT:
            ResetBaseObject();
            break;
        case SMART_ACTION_CALL_SCRIPT_RESET:
            OnReset();
            break;
        case SMART_ACTION_SET_RANGED_MOVEMENT:
        {
            if (!IsSmart())
                break;
 
            float attackDistance = float(e.action.setRangedMovement.distance);
            float attackAngle = float(e.action.setRangedMovement.angle) / 180.0f * float(M_PI);
 
            for (WorldObject* target : targets)
                if (Creature* creature = target->ToCreature())
                    if (IsSmart(creature) && creature->GetVictim())
                        if (CAST_AI(SmartAI, creature->AI())->CanCombatMove())
                            creature->GetMotionMaster()->MoveChase(creature->GetVictim(), attackDistance, attackAngle);
 
            break;
        }
        case SMART_ACTION_CALL_TIMED_ACTIONLIST:
        {
            if (e.GetTargetType() == SMART_TARGET_NONE)
            {
                LOG_ERROR("sql.sql", "SmartScript: Entry {} SourceType {} Event {} Action {} is using TARGET_NONE(0) for Script9 target. Please correct target_type in database.", e.entryOrGuid, e.GetScriptType(), e.GetEventType(), e.GetActionType());
                break;
            }
 
            for (WorldObject* target : targets)
            {
                if (Creature* creature = target->ToCreature())
                {
                    if (IsSmart(creature))
                        CAST_AI(SmartAI, creature->AI())->SetScript9(e, e.action.timedActionList.id, GetLastInvoker());
                }
                else if (GameObject* go = target->ToGameObject())
                {
                    if (IsSmartGO(go))
                        CAST_AI(SmartGameObjectAI, go->AI())->SetScript9(e, e.action.timedActionList.id, GetLastInvoker());
                }
            }
            break;
        }
        case SMART_ACTION_SET_NPC_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToUnit()->SetUInt32Value(UNIT_NPC_FLAGS, e.action.unitFlag.flag);
            break;
        }
        case SMART_ACTION_ADD_NPC_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToUnit()->SetFlag(UNIT_NPC_FLAGS, e.action.unitFlag.flag);
            break;
        }
        case SMART_ACTION_REMOVE_NPC_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToUnit()->RemoveFlag(UNIT_NPC_FLAGS, e.action.unitFlag.flag);
            break;
        }
        case SMART_ACTION_CROSS_CAST:
        {
            if (targets.empty())
                break;
 
            ObjectVector casters;
            GetTargets(casters, CreateSmartEvent(SMART_EVENT_UPDATE_IC, 0, 0, 0, 0, 0, 0, SMART_ACTION_NONE, 0, 0, 0, 0, 0, 0, (SMARTAI_TARGETS)e.action.crossCast.targetType, e.action.crossCast.targetParam1, e.action.crossCast.targetParam2, e.action.crossCast.targetParam3, 0, 0), unit);
 
            for (WorldObject* caster : casters)
            {
                if (!IsUnit(caster))
                    continue;
 
                Unit* casterUnit = caster->ToUnit();
 
                bool interruptedSpell = false;
 
                for (WorldObject* target : targets)
                {
                    if (!IsUnit(target))
                        continue;
 
                    if (!(e.action.crossCast.flags & SMARTCAST_AURA_NOT_PRESENT) || !target->ToUnit()->HasAura(e.action.crossCast.spell))
                    {
                        if (!interruptedSpell && e.action.crossCast.flags & SMARTCAST_INTERRUPT_PREVIOUS)
                        {
                            casterUnit->InterruptNonMeleeSpells(false);
                            interruptedSpell = true;
                        }
 
                        casterUnit->CastSpell(target->ToUnit(), e.action.crossCast.spell, (e.action.crossCast.flags & SMARTCAST_TRIGGERED) != 0);
                    }
                    else
                        LOG_DEBUG("scripts.ai", "Spell {} not cast because it has flag SMARTCAST_AURA_NOT_PRESENT and the target ({}) already has the aura", e.action.crossCast.spell, target->GetGUID().ToString());
                }
            }
            break;
        }
        case SMART_ACTION_CALL_RANDOM_TIMED_ACTIONLIST:
        {
            std::vector<uint32> actionLists;
            std::copy_if(e.action.randTimedActionList.actionLists.begin(), e.action.randTimedActionList.actionLists.end(),
                         std::back_inserter(actionLists), [](uint32 actionList) { return actionList != 0; });
 
            uint32 id = Acore::Containers::SelectRandomContainerElement(actionLists);
            if (e.GetTargetType() == SMART_TARGET_NONE)
            {
                LOG_ERROR("sql.sql", "SmartScript: Entry {} SourceType {} Event {} Action {} is using TARGET_NONE(0) for Script9 target. Please correct target_type in database.", e.entryOrGuid, e.GetScriptType(), e.GetEventType(), e.GetActionType());
                break;
            }
 
            for (WorldObject* target : targets)
            {
                if (Creature* creature = target->ToCreature())
                {
                    if (IsSmart(creature))
                        CAST_AI(SmartAI, creature->AI())->SetScript9(e, id, GetLastInvoker());
                }
                else if (GameObject* go = target->ToGameObject())
                {
                    if (IsSmartGO(go))
                        CAST_AI(SmartGameObjectAI, go->AI())->SetScript9(e, id, GetLastInvoker());
                }
            }
            break;
        }
        case SMART_ACTION_CALL_RANDOM_RANGE_TIMED_ACTIONLIST:
        {
            uint32 id = urand(e.action.randTimedActionList.actionLists[0], e.action.randTimedActionList.actionLists[1]);
            if (e.GetTargetType() == SMART_TARGET_NONE)
            {
                LOG_ERROR("sql.sql", "SmartScript: Entry {} SourceType {} Event {} Action {} is using TARGET_NONE(0) for Script9 target. Please correct target_type in database.", e.entryOrGuid, e.GetScriptType(), e.GetEventType(), e.GetActionType());
                break;
            }
 
            for (WorldObject* target : targets)
            {
                if (Creature* creature = target->ToCreature())
                {
                    if (IsSmart(creature))
                        CAST_AI(SmartAI, creature->AI())->SetScript9(e, id, GetLastInvoker());
                }
                else if (GameObject* go = target->ToGameObject())
                {
                    if (IsSmartGO(go))
                        CAST_AI(SmartGameObjectAI, go->AI())->SetScript9(e, id, GetLastInvoker());
                }
            }
            break;
        }
        case SMART_ACTION_ACTIVATE_TAXI:
        {
            for (WorldObject* target : targets)
                if (IsPlayer(target))
                    target->ToPlayer()->ActivateTaxiPathTo(e.action.taxi.id);
            break;
        }
        case SMART_ACTION_RANDOM_MOVE:
        {
            bool foundTarget = false;
 
            for (WorldObject* target : targets)
            {
                if (IsCreature((target)))
                {
                    foundTarget = true;
 
                    if (e.action.moveRandom.distance)
                        target->ToCreature()->GetMotionMaster()->MoveRandom(float(e.action.moveRandom.distance));
                    else
                        target->ToCreature()->GetMotionMaster()->MoveIdle();
                }
            }
 
            if (!foundTarget && me && IsCreature(me) && me->IsAlive())
            {
                if (e.action.moveRandom.distance)
                    me->GetMotionMaster()->MoveRandom(float(e.action.moveRandom.distance));
                else
                    me->GetMotionMaster()->MoveIdle();
            }
            break;
        }
        case SMART_ACTION_SET_UNIT_FIELD_BYTES_1:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetByteFlag(UNIT_FIELD_BYTES_1, e.action.setunitByte.type, e.action.setunitByte.byte1);
            break;
        }
        case SMART_ACTION_REMOVE_UNIT_FIELD_BYTES_1:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->RemoveByteFlag(UNIT_FIELD_BYTES_1, e.action.delunitByte.type, e.action.delunitByte.byte1);
            break;
        }
        case SMART_ACTION_INTERRUPT_SPELL:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->InterruptNonMeleeSpells(e.action.interruptSpellCasting.withDelayed != 0, e.action.interruptSpellCasting.spell_id, e.action.interruptSpellCasting.withInstant != 0);
            break;
        }
        case SMART_ACTION_SEND_GO_CUSTOM_ANIM:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->SendCustomAnim(e.action.sendGoCustomAnim.anim);
            break;
        }
        case SMART_ACTION_SET_DYNAMIC_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetUInt32Value(UNIT_DYNAMIC_FLAGS, e.action.unitFlag.flag);
            break;
        }
        case SMART_ACTION_ADD_DYNAMIC_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetFlag(UNIT_DYNAMIC_FLAGS, e.action.unitFlag.flag);
            break;
        }
        case SMART_ACTION_REMOVE_DYNAMIC_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->RemoveFlag(UNIT_DYNAMIC_FLAGS, e.action.unitFlag.flag);
            break;
        }
        case SMART_ACTION_JUMP_TO_POS:
        {
            if (e.GetTargetType() == SMART_TARGET_RANDOM_POINT)
            {
                if (me)
                {
                    float range = (float)e.target.randomPoint.range;
                    Position srcPos = { e.target.x, e.target.y, e.target.z, e.target.o };
                    Position randomPoint = me->GetRandomPoint(srcPos, range);
                    me->GetMotionMaster()->MoveJump(randomPoint, (float)e.action.jump.speedxy, (float)e.action.jump.speedz);
                }
 
                break;
            }
 
            if (targets.empty())
                break;
 
            // xinef: my implementation
            if (e.action.jump.selfJump)
            {
                if (WorldObject* target = Acore::Containers::SelectRandomContainerElement(targets))
                    if (me)
                        me->GetMotionMaster()->MoveJump(target->GetPositionX() + e.target.x, target->GetPositionY() + e.target.y, target->GetPositionZ() + e.target.z, (float)e.action.jump.speedxy, (float)e.action.jump.speedz);
            }
            else
            {
                for (WorldObject* target : targets)
                    if (WorldObject* obj = (target))
                    {
                        if (Creature* creature = obj->ToCreature())
                            creature->GetMotionMaster()->MoveJump(e.target.x, e.target.y, e.target.z, (float)e.action.jump.speedxy, (float)e.action.jump.speedz);
                    }
            }
 
            break;
        }
        case SMART_ACTION_GO_SET_LOOT_STATE:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->SetLootState((LootState)e.action.setGoLootState.state);
            break;
        }
        case SMART_ACTION_GO_SET_GO_STATE:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->SetGoState((GOState)e.action.goState.state);
            break;
        }
        case SMART_ACTION_SEND_TARGET_TO_TARGET:
        {
            WorldObject* ref = GetBaseObject();
 
            if (!ref)
                ref = unit;
 
            if (!ref)
                break;
 
            ObjectVector const* storedTargets = GetStoredTargetVector(e.action.sendTargetToTarget.id, *ref);
            if (!storedTargets)
                break;
 
            for (WorldObject* target : targets)
            {
                if (IsCreature(target))
                {
                    if (SmartAI* ai = CAST_AI(SmartAI, target->ToCreature()->AI()))
                        ai->GetScript()->StoreTargetList(ObjectVector(*storedTargets), e.action.sendTargetToTarget.id);   // store a copy of target list
                    else
                        LOG_ERROR("sql.sql", "SmartScript: Action target for SMART_ACTION_SEND_TARGET_TO_TARGET is not using SmartAI, skipping");
                }
                else if (IsGameObject(target))
                {
                    if (SmartGameObjectAI* ai = CAST_AI(SmartGameObjectAI, target->ToGameObject()->AI()))
                        ai->GetScript()->StoreTargetList(ObjectVector(*storedTargets), e.action.sendTargetToTarget.id);   // store a copy of target list
                    else
                        LOG_ERROR("sql.sql", "SmartScript: Action target for SMART_ACTION_SEND_TARGET_TO_TARGET is not using SmartGameObjectAI, skipping");
                }
            }
            break;
        }
        case SMART_ACTION_SEND_GOSSIP_MENU:
        {
            if (!GetBaseObject())
                break;
 
            LOG_DEBUG("sql.sql", "SmartScript::ProcessAction:: SMART_ACTION_SEND_GOSSIP_MENU: gossipMenuId {}, gossipNpcTextId {}",
                      e.action.sendGossipMenu.gossipMenuId, e.action.sendGossipMenu.gossipNpcTextId);
 
            for (WorldObject* target : targets)
                if (Player* player = target->ToPlayer())
                {
                    if (e.action.sendGossipMenu.gossipMenuId)
                        player->PrepareGossipMenu(GetBaseObject(), e.action.sendGossipMenu.gossipMenuId, true);
                    else
                        ClearGossipMenuFor(player);
 
                    SendGossipMenuFor(player, e.action.sendGossipMenu.gossipNpcTextId, GetBaseObject()->GetGUID());
                }
 
            break;
        }
        case SMART_ACTION_SET_HOME_POS:
        {
            if (!targets.empty())
            {
                float x, y, z, o;
                for (WorldObject* target : targets)
                    if (IsCreature(target))
                    {
                        if (e.action.setHomePos.spawnPos)
                        {
                            target->ToCreature()->GetRespawnPosition(x, y, z, &o);
                            target->ToCreature()->SetHomePosition(x, y, z, o);
                        }
                        else
                            target->ToCreature()->SetHomePosition(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), target->GetOrientation());
                    }
            }
            else if (me && e.GetTargetType() == SMART_TARGET_POSITION)
            {
                if (e.action.setHomePos.spawnPos)
                {
                    float x, y, z, o;
                    me->GetRespawnPosition(x, y, z, &o);
                    me->SetHomePosition(x, y, z, o);
                }
                else
                    me->SetHomePosition(e.target.x, e.target.y, e.target.z, e.target.o);
            }
            break;
        }
        case SMART_ACTION_SET_HEALTH_REGEN:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToCreature()->SetRegeneratingHealth(e.action.setHealthRegen.regenHealth);
 
            break;
        }
        case SMART_ACTION_SET_ROOT:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToCreature()->SetControlled(e.action.setRoot.root != 0, UNIT_STATE_ROOT);
            break;
        }
        case SMART_ACTION_SET_GO_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->SetUInt32Value(GAMEOBJECT_FLAGS, e.action.goFlag.flag);
            break;
        }
        case SMART_ACTION_ADD_GO_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->SetFlag(GAMEOBJECT_FLAGS, e.action.goFlag.flag);
            break;
        }
        case SMART_ACTION_REMOVE_GO_FLAG:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->RemoveFlag(GAMEOBJECT_FLAGS, e.action.goFlag.flag);
            break;
        }
    case SMART_ACTION_SUMMON_CREATURE_GROUP:
        {
            std::list<TempSummon*> summonList;
            GetBaseObject()->SummonCreatureGroup(e.action.creatureGroup.group, &summonList);
 
            for (std::list<TempSummon*>::const_iterator itr = summonList.begin(); itr != summonList.end(); ++itr)
            {
                if (unit && e.action.creatureGroup.attackInvoker)
                    (*itr)->AI()->AttackStart(unit);
                else if (me && e.action.creatureGroup.attackScriptOwner)
                    (*itr)->AI()->AttackStart(me);
            }
 
            break;
        }
        case SMART_ACTION_SET_POWER:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetPower(Powers(e.action.power.powerType), e.action.power.newPower);
            break;
        }
        case SMART_ACTION_ADD_POWER:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetPower(Powers(e.action.power.powerType), target->ToUnit()->GetPower(Powers(e.action.power.powerType)) + e.action.power.newPower);
            break;
        }
        case SMART_ACTION_REMOVE_POWER:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetPower(Powers(e.action.power.powerType), target->ToUnit()->GetPower(Powers(e.action.power.powerType)) - e.action.power.newPower);
            break;
        }
        case SMART_ACTION_GAME_EVENT_STOP:
        {
            uint32 eventId = e.action.gameEventStop.id;
            if (!sGameEventMgr->IsActiveEvent(eventId))
            {
                LOG_ERROR("scripts.ai.sai", "SmartScript::ProcessAction: At case SMART_ACTION_GAME_EVENT_STOP, inactive event (id: {})", eventId);
                break;
            }
            sGameEventMgr->StopEvent(eventId, true);
            break;
        }
        case SMART_ACTION_GAME_EVENT_START:
        {
            uint32 eventId = e.action.gameEventStart.id;
            if (sGameEventMgr->IsActiveEvent(eventId))
            {
                LOG_ERROR("scripts.ai.sai", "SmartScript::ProcessAction: At case SMART_ACTION_GAME_EVENT_START, already activated event (id: {})", eventId);
                break;
            }
            sGameEventMgr->StartEvent(eventId, true);
            break;
        }
        case SMART_ACTION_START_CLOSEST_WAYPOINT:
        {
            std::vector<uint32> waypoints;
            std::copy_if(e.action.closestWaypointFromList.wps.begin(), e.action.closestWaypointFromList.wps.end(),
                         std::back_inserter(waypoints), [](uint32 wp) { return wp != 0; });
 
            float distanceToClosest = std::numeric_limits<float>::max();
            WayPoint* closestWp = nullptr;
 
            for (WorldObject* target : targets)
            {
                if (Creature* creature = target->ToCreature())
                {
                    if (IsSmart(creature))
                    {
                        for (uint32 wp : waypoints)
                        {
                            WPPath* path = sSmartWaypointMgr->GetPath(wp);
                            if (!path || path->empty())
                                continue;
 
                            auto itrWp = path->find(0);
                            if (itrWp != path->end())
                            {
                                if (WayPoint* wp = itrWp->second)
                                {
                                    float distToThisPath = creature->GetDistance(wp->x, wp->y, wp->z);
                                    if (distToThisPath < distanceToClosest)
                                    {
                                        distanceToClosest = distToThisPath;
                                        closestWp = wp;
                                    }
                                }
                            }
                        }
 
                        if (closestWp)
                            CAST_AI(SmartAI, creature->AI())->StartPath(false, closestWp->id, true);
                    }
                }
            }
            break;
        }
        case SMART_ACTION_SET_GO_STATE:
        {
            for (WorldObject* target : targets)
                if (IsGameObject(target))
                    target->ToGameObject()->SetGoState((GOState)e.action.goState.state);
 
            break;
        }
        case SMART_ACTION_EXIT_VEHICLE:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->ExitVehicle();
 
            break;
        }
        case SMART_ACTION_SET_UNIT_MOVEMENT_FLAGS:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                {
                    target->ToUnit()->SetUnitMovementFlags(e.action.movementFlag.flag);
                    target->ToUnit()->SendMovementFlagUpdate();
                }
 
            break;
        }
        case SMART_ACTION_SET_COMBAT_DISTANCE:
        {
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToCreature()->m_CombatDistance = e.action.combatDistance.dist;
 
            break;
        }
        case SMART_ACTION_SET_CASTER_COMBAT_DIST:
        {
            if (e.action.casterDistance.reset)
                RestoreCasterMaxDist();
            else
                SetCasterActualDist(e.action.casterDistance.dist);
 
            if (me->GetVictim() && me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
                me->GetMotionMaster()->MoveChase(me->GetVictim(), GetCasterActualDist());
            break;
        }
        case SMART_ACTION_SET_SIGHT_DIST:
        {
            for (WorldObject* const target : targets)
                if (IsCreature(target))
                    target->ToCreature()->m_SightDistance = e.action.sightDistance.dist;
            break;
        }
        case SMART_ACTION_FLEE:
        {
            for (WorldObject* const target : targets)
                if (IsCreature(target))
                    target->ToCreature()->GetMotionMaster()->MoveFleeing(me, e.action.flee.withEmote);
            break;
        }
        case SMART_ACTION_ADD_THREAT:
        {
            for (WorldObject* const target : targets)
                if (IsUnit(target))
                    me->AddThreat(target->ToUnit(), float(e.action.threatPCT.threatINC) - float(e.action.threatPCT.threatDEC));
            break;
        }
        case SMART_ACTION_LOAD_EQUIPMENT:
        {
            for (WorldObject* const target : targets)
                if (IsCreature(target))
                    target->ToCreature()->LoadEquipment(e.action.loadEquipment.id, e.action.loadEquipment.force != 0);
            break;
        }
        case SMART_ACTION_TRIGGER_RANDOM_TIMED_EVENT:
        {
            uint32 eventId = urand(e.action.randomTimedEvent.minId, e.action.randomTimedEvent.maxId);
            ProcessEventsFor((SMART_EVENT)SMART_EVENT_TIMED_EVENT_TRIGGERED, nullptr, eventId);
            break;
        }
        case SMART_ACTION_SET_HOVER:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->SetHover(e.action.setHover.state);
            break;
        }
        case SMART_ACTION_ADD_IMMUNITY:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->ApplySpellImmune(e.action.immunity.id, e.action.immunity.type, e.action.immunity.value, true);
 
            break;
        }
        case SMART_ACTION_REMOVE_IMMUNITY:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->ApplySpellImmune(e.action.immunity.id, e.action.immunity.type, e.action.immunity.value, false);
            break;
        }
        case SMART_ACTION_FALL:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->GetMotionMaster()->MoveFall();
 
            break;
        }
        case SMART_ACTION_SET_EVENT_FLAG_RESET:
        {
            SetPhaseReset(e.action.setActive.state);
            break;
        }
        case SMART_ACTION_REMOVE_ALL_GAMEOBJECTS:
        {
            for (WorldObject* const target : targets)
                if (IsUnit(target))
                    target->ToUnit()->RemoveAllGameObjects();
            break;
        }
        case SMART_ACTION_STOP_MOTION:
        {
            for (WorldObject* const target : targets)
            {
                if (IsUnit(target))
                {
                    if (e.action.stopMotion.stopMovement)
                        target->ToUnit()->StopMoving();
                    if (e.action.stopMotion.movementExpired)
                        target->ToUnit()->GetMotionMaster()->MovementExpired();
                }
            }
            break;
        }
        case SMART_ACTION_NO_ENVIRONMENT_UPDATE:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    target->ToUnit()->AddUnitState(UNIT_STATE_NO_ENVIRONMENT_UPD);
 
            break;
        }
        case SMART_ACTION_ZONE_UNDER_ATTACK:
        {
            for (WorldObject* target : targets)
                if (IsUnit(target))
                    if (Player* player = target->ToUnit()->GetCharmerOrOwnerPlayerOrPlayerItself())
                    {
                        me->SendZoneUnderAttackMessage(player);
                        break;
                    }
 
            break;
        }
        case SMART_ACTION_LOAD_GRID:
        {
            if (me && me->FindMap())
                me->FindMap()->LoadGrid(e.target.x, e.target.y);
            break;
        }
        case SMART_ACTION_PLAYER_TALK:
        {
            char const* text = sObjectMgr->GetAcoreString(e.action.playerTalk.textId, DEFAULT_LOCALE);
 
            if (!targets.empty())
                for (WorldObject* target : targets)
                    if (IsPlayer(target))
                        !e.action.playerTalk.flag ? target->ToPlayer()->Say(text, LANG_UNIVERSAL) : target->ToPlayer()->Yell(text, LANG_UNIVERSAL);
 
            break;
        }
        case SMART_ACTION_CUSTOM_CAST:
        {
            if (!me)
                break;
 
            for (WorldObject* target : targets)
            {
                if (IsUnit(target))
                {
                    if (e.action.castCustom.flags & SMARTCAST_INTERRUPT_PREVIOUS)
                        me->InterruptNonMeleeSpells(false);
 
                    if (e.action.castCustom.flags & SMARTCAST_COMBAT_MOVE)
                    {
                        // If cast flag SMARTCAST_COMBAT_MOVE is set combat movement will not be allowed
                        // unless target is outside spell range, out of mana, or LOS.
 
                        bool _allowMove = false;
                        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(e.action.castCustom.spell); // AssertSpellInfo?
                        int32 mana = me->GetPower(POWER_MANA);
 
                        if (me->GetDistance(target->ToUnit()) > spellInfo->GetMaxRange(true) ||
                            me->GetDistance(target->ToUnit()) < spellInfo->GetMinRange(true) ||
                            !me->IsWithinLOSInMap(target->ToUnit()) ||
                            mana < spellInfo->CalcPowerCost(me, spellInfo->GetSchoolMask()))
                            _allowMove = true;
 
                        CAST_AI(SmartAI, me->AI())->SetCombatMove(_allowMove);
                    }
 
                    if (!(e.action.castCustom.flags & SMARTCAST_AURA_NOT_PRESENT) || !target->ToUnit()->HasAura(e.action.castCustom.spell))
                    {
                        CustomSpellValues values;
                        if (e.action.castCustom.bp1)
                            values.AddSpellMod(SPELLVALUE_BASE_POINT0, e.action.castCustom.bp1);
                        if (e.action.castCustom.bp2)
                            values.AddSpellMod(SPELLVALUE_BASE_POINT1, e.action.castCustom.bp2);
                        if (e.action.castCustom.bp3)
                            values.AddSpellMod(SPELLVALUE_BASE_POINT2, e.action.castCustom.bp3);
                        me->CastCustomSpell(e.action.castCustom.spell, values, target->ToUnit(), (e.action.castCustom.flags & SMARTCAST_TRIGGERED) ? TRIGGERED_FULL_MASK : TRIGGERED_NONE);
                    }
                }
            }
            break;
        }
        case SMART_ACTION_VORTEX_SUMMON:
        {
            if (!me)
                break;
 
            if (targets.empty())
                break;
 
            TempSummonType summon_type = (e.action.summonVortex.summonDuration > 0) ? TEMPSUMMON_TIMED_DESPAWN : TEMPSUMMON_CORPSE_DESPAWN;
 
            float a = static_cast<float>(e.action.summonVortex.a);
            float k = static_cast<float>(e.action.summonVortex.k) / 1000.0f;
            float r_max = static_cast<float>(e.action.summonVortex.r_max);
            float delta_phi = M_PI * static_cast<float>(e.action.summonVortex.phi_delta) / 180.0f;
 
            // r(phi) = a * e ^ (k * phi)
            // r(phi + delta_phi) = a * e ^ (k * (phi + delta_phi))
            // r(phi + delta_phi) = a * e ^ (k * phi) * e ^ (k * delta_phi)
            // r(phi + delta_phi) = r(phi) * e ^ (k * delta_phi)
            float factor = std::exp(k * delta_phi);
 
            // r(0) = a * e ^ (k * 0) = a * e ^ 0 = a * 1 = a
            float summonRadius = a;
 
            for (WorldObject* target : targets)
            {
                // Offset by orientation, should not count into radius calculation,
                // but is needed for vortex direction (polar coordinates)
                float phi = target->GetOrientation();
 
                do
                {
                    Position summonPosition(*target);
                    summonPosition.RelocatePolarOffset(phi, summonRadius);
 
                    me->SummonCreature(e.action.summonVortex.summonEntry, summonPosition, summon_type, e.action.summonVortex.summonDuration);
 
                    phi += delta_phi;
                    summonRadius *= factor;
                } while (summonRadius <= r_max);
            }
 
            break;
        }
        case SMART_ACTION_CONE_SUMMON:
        {
            if (!me)
                break;
 
            TempSummonType spawnType = (e.action.coneSummon.summonDuration > 0) ? TEMPSUMMON_TIMED_DESPAWN : TEMPSUMMON_CORPSE_DESPAWN;
 
            float distInARow = static_cast<float>(e.action.coneSummon.distanceBetweenSummons);
            float coneAngle = static_cast<float>(e.action.coneSummon.coneAngle) * M_PI / 180.0f;
 
            for (uint32 radius = 0; radius <= e.action.coneSummon.coneLength; radius += e.action.coneSummon.distanceBetweenRings)
            {
                float deltaAngle = 0.0f;
                if (radius > 0)
                    deltaAngle = distInARow / radius;
 
                uint32 count = 1;
                if (deltaAngle > 0)
                    count += coneAngle / deltaAngle;
 
                float currentAngle = -static_cast<float>(count) * deltaAngle / 2.0f;
 
                if (e.GetTargetType() == SMART_TARGET_SELF || e.GetTargetType() == SMART_TARGET_NONE)
                    currentAngle += G3D::fuzzyGt(e.target.o, 0.0f) ? (e.target.o - me->GetOrientation()) : 0.0f;
                else if (!targets.empty())
                {
                    currentAngle += (me->GetAngle(targets.front()) - me->GetOrientation());
                }
 
                for (uint32 index = 0; index < count; ++index)
                {
                    Position spawnPosition(*me);
                    spawnPosition.RelocatePolarOffset(currentAngle, radius);
                    currentAngle += deltaAngle;
 
                    me->SummonCreature(e.action.coneSummon.summonEntry, spawnPosition, spawnType, e.action.coneSummon.summonDuration);
                }
            }
 
            break;
        }
        case SMART_ACTION_CU_ENCOUNTER_START:
        {
            for (WorldObject* target : targets)
            {
                if (Player* playerTarget = target->ToPlayer())
                {
                    playerTarget->RemoveArenaSpellCooldowns();
                    playerTarget->RemoveAurasDueToSpell(57724); // Spell Shaman Debuff - Sated (Heroism)
                    playerTarget->RemoveAurasDueToSpell(57723); // Spell Shaman Debuff - Exhaustion (Bloodlust)
                    playerTarget->RemoveAurasDueToSpell(2825);  // Bloodlust
                    playerTarget->RemoveAurasDueToSpell(32182); // Heroism
                }
            }
 
            break;
        }
        case SMART_ACTION_DO_ACTION:
        {
            int32 const actionId = e.action.doAction.isNegative ? -e.action.doAction.actionId : e.action.doAction.actionId;
            if (!e.action.doAction.instanceTarget)
            {
                if (targets.empty())
                    break;
 
                for (WorldObject* objTarget : targets)
                {
                    if (Creature const* unitTarget = objTarget->ToCreature())
                    {
                        if (unitTarget->IsAIEnabled)
                        {
                            unitTarget->AI()->DoAction(actionId);
                        }
                    }
                    else if (GameObject const* gobjTarget = objTarget->ToGameObject())
                    {
                        gobjTarget->AI()->DoAction(actionId);
                    }
                }
 
            }
            else
            {
                InstanceScript* instanceScript = nullptr;
                if (WorldObject* baseObj = GetBaseObject())
                {
                    instanceScript = baseObj->GetInstanceScript();
                }
                    // Action is triggered by AreaTrigger
                else if (trigger && IsPlayer(unit))
                {
                    instanceScript = unit->GetInstanceScript();
                }
 
                if (instanceScript)
                {
                    instanceScript->DoAction(actionId);
                }
            }
            break;
        }
        case SMART_ACTION_DISABLE_EVADE:
        {
            if (!IsSmart())
                break;
 
            CAST_AI(SmartAI, me->AI())->SetEvadeDisabled(e.action.disableEvade.disable != 0);
            break;
        }
        case SMART_ACTION_SET_CORPSE_DELAY:
        {
            for (WorldObject* const target : targets)
            {
                if (IsCreature(target))
                    target->ToCreature()->SetCorpseDelay(e.action.corpseDelay.timer);
            }
            break;
        }
        case SMART_ACTION_SET_HEALTH_PCT:
        {
            for (WorldObject* target : targets)
                if (Unit* targetUnit = target->ToUnit())
                    targetUnit->SetHealth(targetUnit->CountPctFromMaxHealth(e.action.setHealthPct.percent));
            break;
        }
        case SMART_ACTION_SET_MOVEMENT_SPEED:
        {
            uint32 speedInteger = e.action.movementSpeed.speedInteger;
            uint32 speedFraction = e.action.movementSpeed.speedFraction;
            float speed = float(speedInteger) + float(speedFraction) / std::pow(10, std::floor(std::log10(float(speedFraction ? speedFraction : 1)) + 1));
 
            for (WorldObject* target : targets)
                if (IsCreature(target))
                    target->ToCreature()->SetSpeed(UnitMoveType(e.action.movementSpeed.movementType), speed);
 
            break;
        }
        case SMART_ACTION_PLAY_CINEMATIC:
        {
            for (WorldObject* target : targets)
            {
                if (!IsPlayer(target))
                    continue;
 
                target->ToPlayer()->SendCinematicStart(e.action.cinematic.entry);
            }
            break;
        }
        default:
            LOG_ERROR("sql.sql", "SmartScript::ProcessAction: Entry {} SourceType {}, Event {}, Unhandled Action type {}", e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType());
            break;
    }
 
    if (e.link && e.link != e.event_id)
    {
        SmartScriptHolder linked = FindLinkedEvent(e.link);
        if (linked.GetActionType() && linked.GetEventType() == SMART_EVENT_LINK)
            ProcessEvent(linked, unit, var0, var1, bvar, spell, gob);
        else
            LOG_ERROR("sql.sql", "SmartScript::ProcessAction: Entry {} SourceType {}, Event {}, Link Event {} not found or invalid, skipped.", e.entryOrGuid, e.GetScriptType(), e.event_id, e.link);
    }
}

References SmartScriptHolder::action, SmartAction::activateObject, Unit::AddThreat(), Creature::AI(), SmartAction::aliveState, SmartAction::alternative, SmartTarget::amount, SmartAction::angle, SmartAction::attack, SmartAction::attackInvoker, SmartAction::attackScriptOwner, UnitAI::AttackStart(), AURA_REMOVE_BY_EXPIRE, SmartAction::autoAttack, MapRefMgr::begin(), BROADCAST_TEXT_CALL_FOR_HELP, BROADCAST_TEXT_FLEE_FOR_ASSIST, SmartAction::callHelp, SmartAction::cast, CAST_AI, Unit::CastSpell(), GameObject::CastSpell(), SmartAction::charges, CHAT_MSG_ADDON, CHAT_MSG_MONSTER_EMOTE, ObjectMgr::ChooseDisplayId(), SmartAction::combatMove, Unit::CombatStop(), SmartAction::ContactDistance, SmartAction::controlled, SmartAction::count, SmartAction::counterId, SmartAction::creature, SmartAction::credit, SmartAction::creditType, SmartAction::data, SmartAction::dec, DecPhase(), SmartAction::delay, GameObject::DespawnOrUnsummon(), SmartAction::despawnTime, SmartAction::directAdd, SmartAction::disableGravity, SmartAction::dist, SmartAction::distance, Creature::DoFleeToGetAssistance(), SmartAction::duration, SmartAction::emote, SmartAction::emotes, MapRefMgr::end(), SmartAction::entry, SmartScriptHolder::entryOrGuid, SmartScriptHolder::event, SmartEvent::event_chance, SmartAction::faction, SmartAction::factionID, SmartAction::fail, SmartAction::field, WorldObject::FindMap(), SmartAction::flag, SmartAction::flags, SmartAction::flee, SmartAction::fly, SmartAction::follow, SmartAction::forceDespawn, SmartAction::forceRespawnTimer, frand(), GAMEOBJECT_TYPE_DOOR, SmartScriptHolder::GetActionType(), WorldObject::GetAreaId(), GetBaseObject(), InstanceScript::GetBossStateName(), GetCasterActualDist(), GetCasterMaxDist(), GetCasterPowerType(), Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), WorldObject::GetClosePoint(), Unit::GetDirectTransport(), Object::GetEntry(), SmartScriptHolder::GetEventType(), Unit::getGender(), GameObject::GetGoType(), Object::GetGUID(), Creature::GetHomePosition(), WorldObject::GetInstanceScript(), GetLastInvoker(), Creature::GetLootRecipient(), WorldObject::GetMap(), GetMaxCombatDist(), Unit::GetMaxPower(), Unit::GetMotionMaster(), WorldObject::GetName(), WorldObject::GetObjectSize(), Position::GetOrientation(), ObjectAccessor::GetPlayer(), Map::GetPlayers(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Unit::GetPower(), Unit::GetPowerPct(), WorldObject::GetRandomPoint(), SpellInfo::GetSchoolMask(), SmartScriptHolder::GetScriptType(), Unit::GetSpeed(), GetTargets(), SmartScriptHolder::GetTargetType(), ThreatMgr::GetThreatList(), Unit::GetThreatMgr(), Unit::GetTransGUID(), Creature::GetTransportHomePosition(), ObjectAccessor::GetUnit(), Unit::GetVehicleKit(), GetWorldObjectsInDist(), WorldObject::GetZoneId(), go, GO_READY, Player::GroupEventHappens(), EnumFlag< T >::HasFlag(), Object::HasFlag(), Unit::HasUnitMovementFlag(), Unit::HasUnitState(), SmartAction::id, SmartAction::inc, SmartAction::incEventPhase, IncPhase(), SmartAction::ingamePhaseMask, InstallTemplate(), Unit::InterruptNonMeleeSpells(), SmartAction::invincHP, IsCreature(), Unit::isDead(), Map::IsDungeon(), LinkedListHead::IsEmpty(), IsGameObject(), IsPlayer(), IsSmart(), Creature::IsSpellProhibited(), IsUnit(), SmartAction::item, Unit::Kill(), SmartAction::killedMonster, Unit::KillSelf(), LANG_ADDON, LANG_UNIVERSAL, LOG_DEBUG, LOG_ERROR, Position::m_positionX, Position::m_positionY, Position::m_positionZ, SmartAction::mapID, SmartAction::mask, SmartTarget::maxDist, me, SmartAction::minHP, mLastInvoker, mLastTextID, SmartAction::model, ThreatMgr::ModifyThreatByPercent(), SmartAction::morphOrMount, MOTION_SLOT_ACTIVE, MOTION_SLOT_CONTROLLED, SmartAction::move, MOVE_RUN, MOVEMENTFLAG_ONTRANSPORT, MotionMaster::MovePoint(), SmartAction::moveRandom, SmartAction::moveToPos, SmartAction::movie, mTalkerEntry, mTextTimer, mUseTextTimer, SmartAction::music, SmartTarget::o, SmartAction::onlySelf, SmartAction::orientation, SmartAction::pathID, SmartAction::percent, SmartAction::phase, SmartAction::phaseMax, SmartAction::phaseMin, SmartAction::phases, SmartAction::pointId, SmartAction::quest, SmartAction::questID, SmartAction::questOffer, SmartAction::quickChange, SmartAction::random, SmartAction::randomEmote, SmartAction::randomMusic, SmartAction::randomPhase, SmartAction::randomPhaseRange, SmartTarget::randomPoint, Acore::Containers::RandomResize(), SmartAction::randomSound, SmartAction::range, SmartTarget::range, SmartAction::react, SmartAction::reactState, SmartAction::removeAura, SmartAction::repeat, SmartAction::reset, RestoreCasterMaxDist(), Player::RewardPlayerAndGroupAtEvent(), SmartAction::run, SmartScriptHolder::runOnce, sCreatureTextMgr, Acore::Containers::SelectRandomContainerElement(), SmartTarget::self, PlayerMenu::SendQuestGiverQuestDetails(), SmartAction::setActive, SetActualCombatDist(), InstanceScript::SetBossState(), SetCasterActualDist(), SmartAction::setCounter, SmartAction::setData, ZoneScript::SetData(), Creature::SetDisableGravity(), SmartAction::setEventPhase, Unit::SetFacingTo(), Unit::SetFacingToObject(), SmartAction::setFly, ZoneScript::SetGuidData(), Unit::SetInCombatWith(), Unit::SetInFront(), SmartAction::setInstanceData, SmartAction::setInstanceData64, SmartAI::SetInvincibilityHpLevel(), GameObject::SetLootState(), Position::SetOrientation(), SetPhase(), Creature::SetReactState(), SmartAction::setRun, SmartAction::setSheath, Unit::SetSheath(), Unit::SetSpeed(), SmartAction::setSwim, SmartAction::sheath, SmartAction::simpleTalk, SMART_ACTION_ACTIVATE_GOBJECT, SMART_ACTION_ADD_AURA, SMART_ACTION_ADD_ITEM, SMART_ACTION_ALLOW_COMBAT_MOVEMENT, SMART_ACTION_ATTACK_START, SMART_ACTION_ATTACK_STOP, SMART_ACTION_AUTO_ATTACK, SMART_ACTION_CALL_AREAEXPLOREDOREVENTHAPPENS, SMART_ACTION_CALL_FOR_HELP, SMART_ACTION_CALL_GROUPEVENTHAPPENS, SMART_ACTION_CALL_KILLEDMONSTER, SMART_ACTION_CAST, SMART_ACTION_COMBAT_STOP, SMART_ACTION_DIE, SMART_ACTION_EVADE, SMART_ACTION_FAIL_QUEST, SMART_ACTION_FLEE_FOR_ASSIST, SMART_ACTION_FOLLOW, SMART_ACTION_FORCE_DESPAWN, SMART_ACTION_INC_EVENT_PHASE, SMART_ACTION_INSTALL_AI_TEMPLATE, SMART_ACTION_INVOKER_CAST, SMART_ACTION_KILL_UNIT, SMART_ACTION_MORPH_TO_ENTRY_OR_MODEL, SMART_ACTION_MOUNT_TO_ENTRY_OR_MODEL, SMART_ACTION_MOVE_FORWARD, SMART_ACTION_MOVE_TO_POS, SMART_ACTION_MUSIC, SMART_ACTION_OFFER_QUEST, SMART_ACTION_PLAY_EMOTE, SMART_ACTION_PLAYMOVIE, SMART_ACTION_RANDOM_EMOTE, SMART_ACTION_RANDOM_MUSIC, SMART_ACTION_RANDOM_PHASE, SMART_ACTION_RANDOM_PHASE_RANGE, SMART_ACTION_RANDOM_SOUND, SMART_ACTION_REMOVE_ITEM, SMART_ACTION_REMOVE_UNIT_FLAG, SMART_ACTION_REMOVEAURASFROMSPELL, SMART_ACTION_RESET_GOBJECT, SMART_ACTION_RISE_UP, SMART_ACTION_SET_ACTIVE, SMART_ACTION_SET_COUNTER, SMART_ACTION_SET_DATA, SMART_ACTION_SET_EMOTE_STATE, SMART_ACTION_SET_EVENT_PHASE, SMART_ACTION_SET_FACTION, SMART_ACTION_SET_FLY, SMART_ACTION_SET_IN_COMBAT_WITH_ZONE, SMART_ACTION_SET_INGAME_PHASE_MASK, SMART_ACTION_SET_INST_DATA, SMART_ACTION_SET_INST_DATA64, SMART_ACTION_SET_INVINCIBILITY_HP_LEVEL, SMART_ACTION_SET_ORIENTATION, SMART_ACTION_SET_REACT_STATE, SMART_ACTION_SET_RUN, SMART_ACTION_SET_SHEATH, SMART_ACTION_SET_SWIM, SMART_ACTION_SET_UNIT_FLAG, SMART_ACTION_SET_VISIBILITY, SMART_ACTION_SIMPLE_TALK, SMART_ACTION_SOUND, SMART_ACTION_STORE_TARGET_LIST, SMART_ACTION_SUMMON_CREATURE, SMART_ACTION_SUMMON_GO, SMART_ACTION_TALK, SMART_ACTION_TELEPORT, SMART_ACTION_THREAT_ALL_PCT, SMART_ACTION_THREAT_SINGLE_PCT, SMART_ACTION_UPDATE_TEMPLATE, SMART_ACTION_WP_PAUSE, SMART_ACTION_WP_RESUME, SMART_ACTION_WP_START, SMART_ACTION_WP_STOP, SMART_ESCORT_TARGETS, SMART_EVENT_LINK, SMART_EVENT_MANA_PCT, SMART_EVENT_WAYPOINT_REACHED, SMART_RANDOM_POINT, SMART_SCRIPT_TYPE_AREATRIGGER, SMART_TARGET_NONE, SMART_TARGET_POSITION, SMART_TARGET_RANDOM_POINT, SMART_TARGET_SELF, SMARTCAST_AURA_NOT_PRESENT, SMARTCAST_COMBAT_MOVE, SMARTCAST_INTERRUPT_PREVIOUS, SMARTCAST_TRIGGERED, sObjectMgr, SmartAction::sound, SmartAction::sound1, SmartAction::sound2, SmartAction::sound3, SmartAction::sound4, SmartAction::speed, SmartAction::spell, sSpellMgr, SmartAction::state, StoreCounter(), StoreTargetList(), SmartAction::storeTargets, SmartAction::subtract, SmartAction::summonCreature, WorldObject::SummonCreature(), WorldObject::SummonGameObject(), SmartAction::summonGO, WorldObject::SummonTrigger(), SmartAction::swim, SmartAction::talk, SmartScriptHolder::target, SmartAction::targetsLimit, SmartAction::targetsummon, TEAM_NEUTRAL, SmartAction::teleport, TEXT_RANGE_NORMAL, SmartAction::textGroupID, SmartAction::threatDEC, SmartAction::threatINC, SmartAction::threatPCT, Object::ToCreature(), Object::ToGameObject(), Object::ToPlayer(), ObjectGuid::ToString(), Object::ToUnit(), SmartAction::transport, trigger, SmartAction::type, SmartTarget::type, UNIT_FIELD_FLAGS, UNIT_FIELD_FLAGS_2, UNIT_FLAG_SILENCED, UNIT_NPC_EMOTESTATE, UNIT_STATE_LOST_CONTROL, SmartAction::unitFlag, SmartTarget::unitRange, SmartAction::updateLevel, SmartAction::updateTemplate, urand(), GameObject::UseDoorOrButton(), SmartAction::useTalkTarget, SmartAction::value, SmartAction::visibility, SmartAction::withEmote, SmartAction::wpPause, SmartAction::wpStart, SmartAction::wpStop, SmartTarget::x, SmartTarget::y, and SmartTarget::z.

Referenced by ProcessEvent(), and ProcessTimedAction().

ProcessEvent()

void SmartScript::ProcessEvent	(	SmartScriptHolder &	e,
		Unit *	unit = nullptr,
		uint32	var0 = 0,
		uint32	var1 = 0,
		bool	bvar = false,
		SpellInfo const *	spell = nullptr,
		GameObject *	gob = nullptr
	)

{
    if (!e.active && e.GetEventType() != SMART_EVENT_LINK)
        return;
 
    if ((e.event.event_phase_mask && !IsInPhase(e.event.event_phase_mask)) || ((e.event.event_flags & SMART_EVENT_FLAG_NOT_REPEATABLE) && e.runOnce))
        return;
 
    if (!(e.event.event_flags & SMART_EVENT_FLAG_WHILE_CHARMED) && IsCharmedCreature(me))
        return;
 
    switch (e.GetEventType())
    {
        case SMART_EVENT_LINK://special handling
            ProcessAction(e, unit, var0, var1, bvar, spell, gob);
            break;
        //called from Update tick
        case SMART_EVENT_UPDATE:
            ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax);
            break;
        case SMART_EVENT_UPDATE_OOC:
            if (me && me->IsEngaged())
                return;
            ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax);
            break;
        case SMART_EVENT_UPDATE_IC:
            if (!me || !me->IsEngaged())
                return;
            ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax);
            break;
        case SMART_EVENT_HEALTH_PCT:
            {
                if (!me || !me->IsEngaged() || !me->GetMaxHealth())
                    return;
                uint32 perc = (uint32)me->GetHealthPct();
                if (perc > e.event.minMaxRepeat.max || perc < e.event.minMaxRepeat.min)
                    return;
                ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax);
                break;
            }
        case SMART_EVENT_TARGET_HEALTH_PCT:
            {
                if (!me || !me->IsEngaged() || !me->GetVictim() || !me->GetVictim()->GetMaxHealth())
                    return;
                uint32 perc = (uint32)me->GetVictim()->GetHealthPct();
                if (perc > e.event.minMaxRepeat.max || perc < e.event.minMaxRepeat.min)
                    return;
                ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax, me->GetVictim());
                break;
            }
        case SMART_EVENT_MANA_PCT:
            {
                if (!me || !me->IsEngaged() || !me->GetMaxPower(POWER_MANA))
                    return;
                uint32 perc = uint32(me->GetPowerPct(POWER_MANA));
                if (perc > e.event.minMaxRepeat.max || perc < e.event.minMaxRepeat.min)
                    return;
                ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax);
                break;
            }
        case SMART_EVENT_TARGET_MANA_PCT:
            {
                if (!me || !me->IsEngaged() || !me->GetVictim() || !me->GetVictim()->GetMaxPower(POWER_MANA))
                    return;
                uint32 perc = uint32(me->GetVictim()->GetPowerPct(POWER_MANA));
                if (perc > e.event.minMaxRepeat.max || perc < e.event.minMaxRepeat.min)
                    return;
                ProcessTimedAction(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax, me->GetVictim());
                break;
            }
        case SMART_EVENT_RANGE:
            {
                if (!me || !me->IsEngaged() || !me->GetVictim())
                    return;
 
                if (me->IsInRange(me->GetVictim(), (float)e.event.rangeRepeat.minRange, (float)e.event.rangeRepeat.maxRange))
                {
                    if (e.event.rangeRepeat.onlyFireOnRepeat == 2)
                    {
                        e.event.rangeRepeat.onlyFireOnRepeat = 1;
                        RecalcTimer(e, e.event.rangeRepeat.repeatMin, e.event.rangeRepeat.repeatMax);
                    }
                    else
                        ProcessTimedAction(e, e.event.rangeRepeat.repeatMin, e.event.rangeRepeat.repeatMax, me->GetVictim());
                }
                else
                    RecalcTimer(e, 500, 500); // make it predictable
 
                break;
            }
        case SMART_EVENT_VICTIM_CASTING:
            {
                if (!me || !me->IsEngaged())
                    return;
 
                Unit* victim = me->GetVictim();
 
                if (!victim || !victim->IsNonMeleeSpellCast(false, false, true))
                    return;
 
                if (e.event.targetCasting.spellId > 0)
                    if (Spell* currSpell = victim->GetCurrentSpell(CURRENT_GENERIC_SPELL))
                        if (currSpell->m_spellInfo->Id != e.event.targetCasting.spellId)
                            return;
 
                ProcessTimedAction(e, e.event.targetCasting.repeatMin, e.event.targetCasting.repeatMax, me->GetVictim());
                break;
            }
        case SMART_EVENT_FRIENDLY_HEALTH:
            {
                if (!me || !me->IsEngaged())
                    return;
 
                Unit* target = DoSelectLowestHpFriendly((float)e.event.friendlyHealth.radius, e.event.friendlyHealth.hpDeficit);
                if (!target || !target->IsInCombat())
                {
                    // Xinef: if there are at least two same npcs, they will perform the same action immediately even if this is useless...
                    RecalcTimer(e, 1000, 3000);
                    return;
                }
                ProcessTimedAction(e, e.event.friendlyHealth.repeatMin, e.event.friendlyHealth.repeatMax, target);
                break;
            }
        case SMART_EVENT_FRIENDLY_IS_CC:
            {
                if (!me || !me->IsEngaged())
                    return;
 
                std::vector<Creature*> creatures;
                DoFindFriendlyCC(creatures, float(e.event.friendlyCC.radius));
                if (creatures.empty())
                {
                    // Xinef: if there are at least two same npcs, they will perform the same action immediately even if this is useless...
                    RecalcTimer(e, 1000, 3000);
                    return;
                }
                ProcessTimedAction(e, e.event.friendlyCC.repeatMin, e.event.friendlyCC.repeatMax, Acore::Containers::SelectRandomContainerElement(creatures));
                break;
            }
        case SMART_EVENT_FRIENDLY_MISSING_BUFF:
        {
            if (e.event.missingBuff.onlyInCombat && !me->IsEngaged())
            {
                return;
            }
 
            std::vector<Creature*> creatures;
            DoFindFriendlyMissingBuff(creatures, float(e.event.missingBuff.radius), e.event.missingBuff.spell);
 
            if (creatures.empty())
                return;
 
            ProcessTimedAction(e, e.event.missingBuff.repeatMin, e.event.missingBuff.repeatMax, Acore::Containers::SelectRandomContainerElement(creatures));
            break;
        }
        case SMART_EVENT_HAS_AURA:
            {
                if (!me)
                    return;
                uint32 count = me->GetAuraCount(e.event.aura.spell);
                if ((!e.event.aura.count && !count) || (e.event.aura.count && count >= e.event.aura.count))
                    ProcessTimedAction(e, e.event.aura.repeatMin, e.event.aura.repeatMax);
                break;
            }
        case SMART_EVENT_TARGET_BUFFED:
            {
                if (!me || !me->GetVictim())
                    return;
                uint32 count = me->GetVictim()->GetAuraCount(e.event.aura.spell);
                if (count < e.event.aura.count)
                    return;
                ProcessTimedAction(e, e.event.aura.repeatMin, e.event.aura.repeatMax, me->GetVictim());
                break;
            }
        case SMART_EVENT_CHARMED:
            {
                if (bvar == (e.event.charm.onRemove != 1))
                    ProcessAction(e, unit, var0, var1, bvar, spell, gob);
                break;
            }
        //no params
        case SMART_EVENT_AGGRO:
        case SMART_EVENT_DEATH:
        case SMART_EVENT_EVADE:
        case SMART_EVENT_REACHED_HOME:
        case SMART_EVENT_CHARMED_TARGET:
        case SMART_EVENT_CORPSE_REMOVED:
        case SMART_EVENT_AI_INIT:
        case SMART_EVENT_TRANSPORT_ADDPLAYER:
        case SMART_EVENT_TRANSPORT_REMOVE_PLAYER:
        case SMART_EVENT_QUEST_ACCEPTED:
        case SMART_EVENT_QUEST_OBJ_COMPLETION:
        case SMART_EVENT_QUEST_COMPLETION:
        case SMART_EVENT_QUEST_REWARDED:
        case SMART_EVENT_QUEST_FAIL:
        case SMART_EVENT_JUST_SUMMONED:
        case SMART_EVENT_RESET:
        case SMART_EVENT_JUST_CREATED:
        case SMART_EVENT_FOLLOW_COMPLETED:
        case SMART_EVENT_ON_SPELLCLICK:
            ProcessAction(e, unit, var0, var1, bvar, spell, gob);
            break;
 
        case SMART_EVENT_GOSSIP_HELLO:
            switch (e.event.gossipHello.filter)
            {
            case 0:
                // no filter set, always execute action
                break;
            case 1:
                // GossipHello only filter set, skip action if reportUse
                if (var0)
                {
                    return;
                }
                break;
            case 2:
                // reportUse only filter set, skip action if GossipHello
                if (!var0)
                {
                    return;
                }
                break;
            default:
                // Ignore any other value
                break;
            }
 
            ProcessAction(e, unit, var0, var1, bvar, spell, gob);
            break;
        case SMART_EVENT_IS_BEHIND_TARGET:
            {
                if (!me)
                    return;
 
                if (Unit* victim = me->GetVictim())
                {
                    if (!victim->HasInArc(static_cast<float>(M_PI), me))
                        ProcessTimedAction(e, e.event.behindTarget.cooldownMin, e.event.behindTarget.cooldownMax, victim);
                }
                break;
            }
        case SMART_EVENT_RECEIVE_EMOTE:
            if (e.event.emote.emote == var0)
            {
                ProcessAction(e, unit);
                RecalcTimer(e, e.event.emote.cooldownMin, e.event.emote.cooldownMax);
            }
            break;
        case SMART_EVENT_KILL:
            {
                if (!me || !unit)
                    return;
                if (e.event.kill.playerOnly && unit->GetTypeId() != TYPEID_PLAYER)
                    return;
                if (e.event.kill.creature && unit->GetEntry() != e.event.kill.creature)
                    return;
                RecalcTimer(e, e.event.kill.cooldownMin, e.event.kill.cooldownMax);
                ProcessAction(e, unit);
                break;
            }
        case SMART_EVENT_SPELLHIT_TARGET:
        case SMART_EVENT_SPELLHIT:
            {
                if (!spell)
                    return;
                if ((!e.event.spellHit.spell || spell->Id == e.event.spellHit.spell) &&
                        (!e.event.spellHit.school || (spell->SchoolMask & e.event.spellHit.school)))
                {
                    RecalcTimer(e, e.event.spellHit.cooldownMin, e.event.spellHit.cooldownMax);
                    ProcessAction(e, unit, 0, 0, bvar, spell);
                }
                break;
            }
        case SMART_EVENT_OOC_LOS:
            {
                if (!me || me->IsEngaged())
                    return;
                //can trigger if closer than fMaxAllowedRange
                float range = (float)e.event.los.maxDist;
 
                //if range is ok and we are actually in LOS
                if (me->IsWithinDistInMap(unit, range) && me->IsWithinLOSInMap(unit))
                {
                    SmartEvent::LOSHostilityMode hostilityMode = static_cast<SmartEvent::LOSHostilityMode>(e.event.los.hostilityMode);
                    //if friendly event&&who is not hostile OR hostile event&&who is hostile
                    if ((hostilityMode == SmartEvent::LOSHostilityMode::Any) ||
                        (hostilityMode == SmartEvent::LOSHostilityMode::NotHostile && !me->IsHostileTo(unit)) ||
                        (hostilityMode == SmartEvent::LOSHostilityMode::Hostile && me->IsHostileTo(unit)))
                    {
                        if (e.event.los.playerOnly && unit->GetTypeId() != TYPEID_PLAYER)
                            return;
                        RecalcTimer(e, e.event.los.cooldownMin, e.event.los.cooldownMax);
                        ProcessAction(e, unit);
                    }
                }
                break;
            }
        case SMART_EVENT_IC_LOS:
            {
                if (!me || !me->IsEngaged())
                    return;
                //can trigger if closer than fMaxAllowedRange
                float range = (float)e.event.los.maxDist;
 
                //if range is ok and we are actually in LOS
                if (me->IsWithinDistInMap(unit, range) && me->IsWithinLOSInMap(unit))
                {
                    SmartEvent::LOSHostilityMode hostilityMode = static_cast<SmartEvent::LOSHostilityMode>(e.event.los.hostilityMode);
                    //if friendly event&&who is not hostile OR hostile event&&who is hostile
                    if ((hostilityMode == SmartEvent::LOSHostilityMode::Any) ||
                        (hostilityMode == SmartEvent::LOSHostilityMode::NotHostile && !me->IsHostileTo(unit)) ||
                        (hostilityMode == SmartEvent::LOSHostilityMode::Hostile && me->IsHostileTo(unit)))
                    {
                        if (e.event.los.playerOnly && unit->GetTypeId() != TYPEID_PLAYER)
                            return;
                        RecalcTimer(e, e.event.los.cooldownMin, e.event.los.cooldownMax);
                        ProcessAction(e, unit);
                    }
                }
                break;
            }
        case SMART_EVENT_RESPAWN:
            {
                if (!GetBaseObject())
                    return;
                if (e.event.respawn.type == SMART_SCRIPT_RESPAWN_CONDITION_MAP && GetBaseObject()->GetMapId() != e.event.respawn.map)
                    return;
                if (e.event.respawn.type == SMART_SCRIPT_RESPAWN_CONDITION_AREA && GetBaseObject()->GetZoneId() != e.event.respawn.area)
                    return;
                ProcessAction(e);
                break;
            }
        case SMART_EVENT_SUMMONED_UNIT:
        case SMART_EVENT_SUMMONED_UNIT_DIES:
            {
                if (!IsCreature(unit))
                    return;
                if (e.event.summoned.creature && unit->GetEntry() != e.event.summoned.creature)
                    return;
                RecalcTimer(e, e.event.summoned.cooldownMin, e.event.summoned.cooldownMax);
                ProcessAction(e, unit);
                break;
            }
        case SMART_EVENT_RECEIVE_HEAL:
        case SMART_EVENT_DAMAGED:
        case SMART_EVENT_DAMAGED_TARGET:
            {
                if (var0 > e.event.minMaxRepeat.max || var0 < e.event.minMaxRepeat.min)
                    return;
                RecalcTimer(e, e.event.minMaxRepeat.repeatMin, e.event.minMaxRepeat.repeatMax);
                ProcessAction(e, unit);
                break;
            }
        case SMART_EVENT_MOVEMENTINFORM:
            {
                if ((e.event.movementInform.type && var0 != e.event.movementInform.type) || (e.event.movementInform.id && var1 != e.event.movementInform.id))
                    return;
                ProcessAction(e, unit, var0, var1);
                break;
            }
        case SMART_EVENT_TRANSPORT_RELOCATE:
        case SMART_EVENT_WAYPOINT_START:
            {
                if (e.event.waypoint.pathID && var0 != e.event.waypoint.pathID)
                    return;
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_WAYPOINT_REACHED:
        case SMART_EVENT_WAYPOINT_RESUMED:
        case SMART_EVENT_WAYPOINT_PAUSED:
        case SMART_EVENT_WAYPOINT_STOPPED:
        case SMART_EVENT_WAYPOINT_ENDED:
            {
                if (!me || (e.event.waypoint.pointID && var0 != e.event.waypoint.pointID) || (e.event.waypoint.pathID && GetPathId() != e.event.waypoint.pathID))
                    return;
                ProcessAction(e, unit);
                break;
            }
        case SMART_EVENT_SUMMON_DESPAWNED:
            {
                if (e.event.summoned.creature && e.event.summoned.creature != var0)
                    return;
                RecalcTimer(e, e.event.summoned.cooldownMin, e.event.summoned.cooldownMax);
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_INSTANCE_PLAYER_ENTER:
            {
                if (e.event.instancePlayerEnter.team && var0 != e.event.instancePlayerEnter.team)
                    return;
                RecalcTimer(e, e.event.instancePlayerEnter.cooldownMin, e.event.instancePlayerEnter.cooldownMax);
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_ACCEPTED_QUEST:
        case SMART_EVENT_REWARD_QUEST:
            {
                if (e.event.quest.quest && var0 != e.event.quest.quest)
                    return;
                RecalcTimer(e, e.event.quest.cooldownMin, e.event.quest.cooldownMax);
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_TRANSPORT_ADDCREATURE:
            {
                if (e.event.transportAddCreature.creature && var0 != e.event.transportAddCreature.creature)
                    return;
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_AREATRIGGER_ONTRIGGER:
            {
                if (e.event.areatrigger.id && var0 != e.event.areatrigger.id)
                    return;
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_TEXT_OVER:
            {
                if (var0 != e.event.textOver.textGroupID || (e.event.textOver.creatureEntry && e.event.textOver.creatureEntry != var1))
                    return;
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_DATA_SET:
            {
                if (e.event.dataSet.id != var0 || e.event.dataSet.value != var1)
                    return;
                RecalcTimer(e, e.event.dataSet.cooldownMin, e.event.dataSet.cooldownMax);
                ProcessAction(e, unit, var0, var1);
                break;
            }
        case SMART_EVENT_PASSENGER_REMOVED:
        case SMART_EVENT_PASSENGER_BOARDED:
            {
                if (!unit)
                    return;
                RecalcTimer(e, e.event.minMax.repeatMin, e.event.minMax.repeatMax);
                ProcessAction(e, unit);
                break;
            }
        case SMART_EVENT_TIMED_EVENT_TRIGGERED:
            {
                if (e.event.timedEvent.id == var0)
                    ProcessAction(e, unit);
                break;
            }
        case SMART_EVENT_GOSSIP_SELECT:
            {
                LOG_DEBUG("sql.sql", "SmartScript: Gossip Select:  menu {} action {}", var0, var1); //little help for scripters
                if (e.event.gossip.sender != var0 || e.event.gossip.action != var1)
                    return;
                ProcessAction(e, unit, var0, var1);
                break;
            }
        case SMART_EVENT_EVENT_PHASE_CHANGE:
            {
                if (!IsInPhase(e.event.eventPhaseChange.phasemask))
                {
                    return;
                }
 
                ProcessAction(e, GetLastInvoker());
                break;
            }
        case SMART_EVENT_GAME_EVENT_START:
        case SMART_EVENT_GAME_EVENT_END:
            {
                if (e.event.gameEvent.gameEventId != var0)
                    return;
                ProcessAction(e, nullptr, var0);
                break;
            }
        case SMART_EVENT_GO_STATE_CHANGED:
            {
                if (e.event.goStateChanged.state != var0)
                    return;
                ProcessAction(e, unit, var0, var1);
                break;
            }
        case SMART_EVENT_GO_EVENT_INFORM:
            {
                if (e.event.eventInform.eventId != var0)
                    return;
                ProcessAction(e, nullptr, var0);
                break;
            }
        case SMART_EVENT_ACTION_DONE:
            {
                if (e.event.doAction.eventId != var0)
                    return;
                ProcessAction(e, unit, var0);
                break;
            }
        case SMART_EVENT_FRIENDLY_HEALTH_PCT:
            {
                if (!me || !me->IsEngaged())
                    return;
 
                ObjectVector targets;
                switch (e.GetTargetType())
                {
                    case SMART_TARGET_CREATURE_RANGE:
                    case SMART_TARGET_CREATURE_GUID:
                    case SMART_TARGET_CREATURE_DISTANCE:
                    case SMART_TARGET_CLOSEST_CREATURE:
                    case SMART_TARGET_CLOSEST_PLAYER:
                    case SMART_TARGET_PLAYER_RANGE:
                    case SMART_TARGET_PLAYER_DISTANCE:
                    {
                        if (targets.empty())
                            return;
                        for (WorldObject* target : targets)
                        {
                            if (IsUnit(target) && me->IsFriendlyTo(target->ToUnit()) && target->ToUnit()->IsAlive() && target->ToUnit()->IsInCombat())
                            {
                                uint32 healthPct = uint32(target->ToUnit()->GetHealthPct());
                                if (healthPct > e.event.friendlyHealthPct.maxHpPct || healthPct < e.event.friendlyHealthPct.minHpPct)
                                {
                                    continue;
                                }
 
                                target = target->ToUnit();
                                break;
                            }
                        }
 
                        break;
                    }
                    case SMART_TARGET_SELF:
                    case SMART_TARGET_ACTION_INVOKER:
                        DoSelectLowestHpPercentFriendly((float)e.event.friendlyHealthPct.radius, e.event.friendlyHealthPct.minHpPct, e.event.friendlyHealthPct.maxHpPct);
                        break;
                    default:
                        return;
                }
 
                if (targets.empty())
                    return;
 
                ProcessTimedAction(e, e.event.friendlyHealthPct.repeatMin, e.event.friendlyHealthPct.repeatMax);
                break;
            }
        case SMART_EVENT_DISTANCE_CREATURE:
            {
                if (!me)
                    return;
 
                WorldObject* creature = nullptr;
 
                if (e.event.distance.guid != 0)
                {
                    creature = FindCreatureNear(me, e.event.distance.guid);
 
                    if (!creature)
                        return;
 
                    if (!me->IsInRange(creature, 0, (float)e.event.distance.dist))
                        return;
                }
                else if (e.event.distance.entry != 0)
                {
                    std::list<Creature*> list;
                    me->GetCreatureListWithEntryInGrid(list, e.event.distance.entry, (float)e.event.distance.dist);
 
                    if (!list.empty())
                        creature = list.front();
                }
 
                if (creature)
                    ProcessTimedAction(e, e.event.distance.repeat, e.event.distance.repeat);
 
                break;
            }
        case SMART_EVENT_DISTANCE_GAMEOBJECT:
            {
                if (!me)
                    return;
 
                WorldObject* gameobject = nullptr;
 
                if (e.event.distance.guid != 0)
                {
                    gameobject = FindGameObjectNear(me, e.event.distance.guid);
 
                    if (!gameobject)
                        return;
 
                    if (!me->IsInRange(gameobject, 0, (float)e.event.distance.dist))
                        return;
                }
                else if (e.event.distance.entry != 0)
                {
                    std::list<GameObject*> list;
                    me->GetGameObjectListWithEntryInGrid(list, e.event.distance.entry, (float)e.event.distance.dist);
 
                    if (!list.empty())
                        gameobject = list.front();
                }
 
                if (gameobject)
                    ProcessTimedAction(e, e.event.distance.repeat, e.event.distance.repeat);
 
                break;
            }
        case SMART_EVENT_COUNTER_SET:
            if (e.event.counter.id != var0 || GetCounterValue(e.event.counter.id) != e.event.counter.value)
                return;
 
            ProcessTimedAction(e, e.event.counter.cooldownMin, e.event.counter.cooldownMax);
            break;
        case SMART_EVENT_NEAR_PLAYERS:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.event.nearPlayer.radius));
 
            if (!units.empty())
            {
                if (!unit || unit->GetTypeId() != TYPEID_PLAYER)
                    return;
 
                if (units.size() >= e.event.nearPlayer.minCount)
                    ProcessAction(e, unit);
            }
            RecalcTimer(e, e.event.nearPlayer.checkTimer, e.event.nearPlayer.checkTimer);
            break;
        }
        case SMART_EVENT_NEAR_PLAYERS_NEGATION:
        {
            ObjectVector units;
            GetWorldObjectsInDist(units, static_cast<float>(e.event.nearPlayerNegation.radius));
 
            if (!units.empty())
            {
                if (!unit || unit->GetTypeId() != TYPEID_PLAYER)
                    return;
 
                if (units.size() < e.event.nearPlayerNegation.minCount)
                    ProcessAction(e, unit);
            }
            RecalcTimer(e, e.event.nearPlayerNegation.checkTimer, e.event.nearPlayerNegation.checkTimer);
            break;
        }
        default:
            LOG_ERROR("sql.sql", "SmartScript::ProcessEvent: Unhandled Event type {}", e.GetEventType());
            break;
    }
}

References SmartEvent::action, SmartScriptHolder::active, SmartEvent::Any, SmartEvent::area, SmartEvent::areatrigger, SmartEvent::aura, SmartEvent::behindTarget, SmartEvent::charm, SmartEvent::checkTimer, SmartEvent::cooldownMax, SmartEvent::cooldownMin, SmartEvent::count, SmartEvent::counter, SmartEvent::creature, SmartEvent::creatureEntry, CURRENT_GENERIC_SPELL, SmartEvent::dataSet, SmartEvent::dist, SmartEvent::distance, SmartEvent::doAction, DoFindFriendlyCC(), DoFindFriendlyMissingBuff(), DoSelectLowestHpFriendly(), DoSelectLowestHpPercentFriendly(), SmartEvent::emote, SmartEvent::entry, SmartScriptHolder::event, SmartEvent::event_flags, SmartEvent::event_phase_mask, SmartEvent::eventId, SmartEvent::eventInform, SmartEvent::eventPhaseChange, SmartEvent::filter, FindCreatureNear(), FindGameObjectNear(), SmartEvent::friendlyCC, SmartEvent::friendlyHealth, SmartEvent::friendlyHealthPct, SmartEvent::gameEvent, SmartEvent::gameEventId, Unit::GetAuraCount(), GetBaseObject(), GetCounterValue(), WorldObject::GetCreatureListWithEntryInGrid(), Unit::GetCurrentSpell(), Object::GetEntry(), SmartScriptHolder::GetEventType(), WorldObject::GetGameObjectListWithEntryInGrid(), Unit::GetHealthPct(), GetLastInvoker(), Unit::GetMaxHealth(), Unit::GetMaxPower(), GetPathId(), Unit::GetPowerPct(), SmartScriptHolder::GetTargetType(), Object::GetTypeId(), Unit::GetVictim(), GetWorldObjectsInDist(), SmartEvent::gossip, SmartEvent::gossipHello, SmartEvent::goStateChanged, SmartEvent::guid, SmartEvent::Hostile, SmartEvent::hostilityMode, SmartEvent::hpDeficit, SmartEvent::id, SpellInfo::Id, SmartEvent::instancePlayerEnter, IsCharmedCreature(), IsCreature(), Unit::IsEngaged(), Unit::IsFriendlyTo(), Unit::IsHostileTo(), Unit::IsInCombat(), IsInPhase(), WorldObject::IsInRange(), Unit::IsNonMeleeSpellCast(), IsUnit(), WorldObject::IsWithinDistInMap(), WorldObject::IsWithinLOSInMap(), SmartEvent::kill, LOG_DEBUG, LOG_ERROR, SmartEvent::los, SmartEvent::map, SmartEvent::max, SmartEvent::maxDist, SmartEvent::maxHpPct, SmartEvent::maxRange, me, SmartEvent::min, SmartEvent::minCount, SmartEvent::minHpPct, SmartEvent::minMax, SmartEvent::minMaxRepeat, SmartEvent::minRange, SmartEvent::missingBuff, SmartEvent::movementInform, SmartEvent::nearPlayer, SmartEvent::nearPlayerNegation, SmartEvent::NotHostile, SmartEvent::onlyFireOnRepeat, SmartEvent::onlyInCombat, SmartEvent::onRemove, SmartEvent::pathID, SmartEvent::phasemask, SmartEvent::playerOnly, SmartEvent::pointID, POWER_MANA, ProcessAction(), ProcessTimedAction(), SmartEvent::quest, SmartEvent::radius, SmartEvent::rangeRepeat, RecalcTimer(), SmartEvent::repeat, SmartEvent::repeatMax, SmartEvent::repeatMin, SmartEvent::respawn, SmartScriptHolder::runOnce, SmartEvent::school, SpellInfo::SchoolMask, Acore::Containers::SelectRandomContainerElement(), SmartEvent::sender, SMART_EVENT_ACCEPTED_QUEST, SMART_EVENT_ACTION_DONE, SMART_EVENT_AGGRO, SMART_EVENT_AI_INIT, SMART_EVENT_AREATRIGGER_ONTRIGGER, SMART_EVENT_CHARMED, SMART_EVENT_CHARMED_TARGET, SMART_EVENT_CORPSE_REMOVED, SMART_EVENT_COUNTER_SET, SMART_EVENT_DAMAGED, SMART_EVENT_DAMAGED_TARGET, SMART_EVENT_DATA_SET, SMART_EVENT_DEATH, SMART_EVENT_DISTANCE_CREATURE, SMART_EVENT_DISTANCE_GAMEOBJECT, SMART_EVENT_EVADE, SMART_EVENT_EVENT_PHASE_CHANGE, SMART_EVENT_FLAG_NOT_REPEATABLE, SMART_EVENT_FLAG_WHILE_CHARMED, SMART_EVENT_FOLLOW_COMPLETED, SMART_EVENT_FRIENDLY_HEALTH, SMART_EVENT_FRIENDLY_HEALTH_PCT, SMART_EVENT_FRIENDLY_IS_CC, SMART_EVENT_FRIENDLY_MISSING_BUFF, SMART_EVENT_GAME_EVENT_END, SMART_EVENT_GAME_EVENT_START, SMART_EVENT_GO_EVENT_INFORM, SMART_EVENT_GO_STATE_CHANGED, SMART_EVENT_GOSSIP_HELLO, SMART_EVENT_GOSSIP_SELECT, SMART_EVENT_HAS_AURA, SMART_EVENT_HEALTH_PCT, SMART_EVENT_IC_LOS, SMART_EVENT_INSTANCE_PLAYER_ENTER, SMART_EVENT_IS_BEHIND_TARGET, SMART_EVENT_JUST_CREATED, SMART_EVENT_JUST_SUMMONED, SMART_EVENT_KILL, SMART_EVENT_LINK, SMART_EVENT_MANA_PCT, SMART_EVENT_MOVEMENTINFORM, SMART_EVENT_NEAR_PLAYERS, SMART_EVENT_NEAR_PLAYERS_NEGATION, SMART_EVENT_ON_SPELLCLICK, SMART_EVENT_OOC_LOS, SMART_EVENT_PASSENGER_BOARDED, SMART_EVENT_PASSENGER_REMOVED, SMART_EVENT_QUEST_ACCEPTED, SMART_EVENT_QUEST_COMPLETION, SMART_EVENT_QUEST_FAIL, SMART_EVENT_QUEST_OBJ_COMPLETION, SMART_EVENT_QUEST_REWARDED, SMART_EVENT_RANGE, SMART_EVENT_REACHED_HOME, SMART_EVENT_RECEIVE_EMOTE, SMART_EVENT_RECEIVE_HEAL, SMART_EVENT_RESET, SMART_EVENT_RESPAWN, SMART_EVENT_REWARD_QUEST, SMART_EVENT_SPELLHIT, SMART_EVENT_SPELLHIT_TARGET, SMART_EVENT_SUMMON_DESPAWNED, SMART_EVENT_SUMMONED_UNIT, SMART_EVENT_SUMMONED_UNIT_DIES, SMART_EVENT_TARGET_BUFFED, SMART_EVENT_TARGET_HEALTH_PCT, SMART_EVENT_TARGET_MANA_PCT, SMART_EVENT_TEXT_OVER, SMART_EVENT_TIMED_EVENT_TRIGGERED, SMART_EVENT_TRANSPORT_ADDCREATURE, SMART_EVENT_TRANSPORT_ADDPLAYER, SMART_EVENT_TRANSPORT_RELOCATE, SMART_EVENT_TRANSPORT_REMOVE_PLAYER, SMART_EVENT_UPDATE, SMART_EVENT_UPDATE_IC, SMART_EVENT_UPDATE_OOC, SMART_EVENT_VICTIM_CASTING, SMART_EVENT_WAYPOINT_ENDED, SMART_EVENT_WAYPOINT_PAUSED, SMART_EVENT_WAYPOINT_REACHED, SMART_EVENT_WAYPOINT_RESUMED, SMART_EVENT_WAYPOINT_START, SMART_EVENT_WAYPOINT_STOPPED, SMART_SCRIPT_RESPAWN_CONDITION_AREA, SMART_SCRIPT_RESPAWN_CONDITION_MAP, SMART_TARGET_ACTION_INVOKER, SMART_TARGET_CLOSEST_CREATURE, SMART_TARGET_CLOSEST_PLAYER, SMART_TARGET_CREATURE_DISTANCE, SMART_TARGET_CREATURE_GUID, SMART_TARGET_CREATURE_RANGE, SMART_TARGET_PLAYER_DISTANCE, SMART_TARGET_PLAYER_RANGE, SMART_TARGET_SELF, SmartEvent::spell, SmartEvent::spellHit, SmartEvent::spellId, SmartEvent::state, SmartEvent::summoned, SmartEvent::targetCasting, SmartEvent::team, SmartEvent::textGroupID, SmartEvent::textOver, SmartEvent::timedEvent, SmartEvent::transportAddCreature, SmartEvent::type, TYPEID_PLAYER, SmartEvent::value, and SmartEvent::waypoint.

Referenced by ProcessEventsFor(), and UpdateTimer().

ProcessEventsFor()

void SmartScript::ProcessEventsFor	(	SMART_EVENT	e,
		Unit *	unit = nullptr,
		uint32	var0 = 0,
		uint32	var1 = 0,
		bool	bvar = false,
		SpellInfo const *	spell = nullptr,
		GameObject *	gob = nullptr
	)

{
    for (SmartAIEventList::iterator i = mEvents.begin(); i != mEvents.end(); ++i)
    {
        SMART_EVENT eventType = SMART_EVENT((*i).GetEventType());
        if (eventType == SMART_EVENT_LINK)//special handling
            continue;
 
        if (eventType == e)
        {
            ConditionList conds = sConditionMgr->GetConditionsForSmartEvent((*i).entryOrGuid, (*i).event_id, (*i).source_type);
            ConditionSourceInfo info = ConditionSourceInfo(unit, GetBaseObject(), me ? me->GetVictim() : nullptr);
 
            if (sConditionMgr->IsObjectMeetToConditions(info, conds))
                ProcessEvent(*i, unit, var0, var1, bvar, spell, gob);
        }
    }
}

References GetBaseObject(), Unit::GetVictim(), me, mEvents, ProcessEvent(), sConditionMgr, and SMART_EVENT_LINK.

Referenced by SmartAI::CorpseRemoved(), SmartAI::DamageDealt(), SmartAI::DamageTaken(), SmartGameObjectAI::Destroyed(), SmartAI::DoAction(), SmartAI::EndPath(), SmartAI::EnterEvadeMode(), SmartGameObjectAI::EventInform(), SmartGameObjectAI::GossipHello(), SmartGameObjectAI::GossipSelect(), SmartAI::HealReceived(), SmartAI::InitializeAI(), SmartGameObjectAI::InitializeAI(), SmartAI::IsSummonedBy(), SmartAI::JustDied(), SmartAI::JustEngagedWith(), SmartAI::JustReachedHome(), SmartAI::JustRespawned(), SmartAI::JustSummoned(), SmartGameObjectAI::JustSummoned(), SmartAI::KilledUnit(), SmartAI::MovementInform(), SmartAI::MovepointReached(), SmartAI::OnCharmed(), SmartGameObjectAI::OnGameEvent(), OnInitialize(), OnMoveInLineOfSight(), OnReset(), SmartAI::OnSpellClick(), SmartGameObjectAI::OnStateChanged(), SmartTrigger::OnTrigger(), OnUpdate(), SmartAI::PassengerBoarded(), SmartAI::PausePath(), SmartGameObjectAI::QuestAccept(), SmartGameObjectAI::QuestReward(), SmartAI::ReceiveEmote(), SmartGameObjectAI::Reset(), SmartAI::SetData(), SmartGameObjectAI::SetData(), SetPhase(), SmartAI::sGossipHello(), SmartAI::sGossipSelect(), SmartAI::sOnGameEvent(), SmartAI::SpellHit(), SmartGameObjectAI::SpellHit(), SmartAI::SpellHitTarget(), SmartAI::sQuestAccept(), SmartAI::sQuestReward(), SmartAI::StartPath(), SmartAI::StopFollow(), SmartAI::StopPath(), StoreCounter(), SmartAI::SummonedCreatureDespawn(), SmartGameObjectAI::SummonedCreatureDespawn(), SmartAI::SummonedCreatureDies(), SmartGameObjectAI::SummonedCreatureDies(), and SmartAI::UpdatePath().

ProcessTimedAction()

void SmartScript::ProcessTimedAction	(	SmartScriptHolder &	e,
		uint32 const &	min,
		uint32 const &	max,
		Unit *	unit = nullptr,
		uint32	var0 = 0,
		uint32	var1 = 0,
		bool	bvar = false,
		SpellInfo const *	spell = nullptr,
		GameObject *	gob = nullptr
	)

{
    // xinef: extended by selfs victim
    ConditionList const conds = sConditionMgr->GetConditionsForSmartEvent(e.entryOrGuid, e.event_id, e.source_type);
    ConditionSourceInfo info = ConditionSourceInfo(unit, GetBaseObject(), me ? me->GetVictim() : nullptr);
 
    if (sConditionMgr->IsObjectMeetToConditions(info, conds))
    {
        ProcessAction(e, unit, var0, var1, bvar, spell, gob);
        RecalcTimer(e, min, max);
    }
    else
        RecalcTimer(e, 5000, 5000);
}

References SmartScriptHolder::entryOrGuid, SmartScriptHolder::event_id, GetBaseObject(), Unit::GetVictim(), me, ProcessAction(), RecalcTimer(), sConditionMgr, and SmartScriptHolder::source_type.

Referenced by ProcessEvent().

RecalcTimer()

void SmartScript::RecalcTimer ( SmartScriptHolder &  e, uint32  min, uint32  max  )

static

{
    // min/max was checked at loading!
    e.timer = urand(uint32(min), uint32(max));
    e.active = e.timer ? false : true;
}

References SmartScriptHolder::active, SmartScriptHolder::timer, and urand().

Referenced by InitTimer(), ProcessEvent(), and ProcessTimedAction().

RemoveCreatureSummon()

void SmartScript::RemoveCreatureSummon

(

ObjectGuid const &

guid

)

{
    _summonList.erase(guid);
}

References _summonList.

Referenced by SmartAI::SummonedCreatureDespawn().

RemoveStoredEvent()

void SmartScript::RemoveStoredEvent ( uint32  id )

inlineprivate

    {
        if (!mStoredEvents.empty())
        {
            for (SmartAIEventStoredList::iterator i = mStoredEvents.begin(); i != mStoredEvents.end(); ++i)
            {
                if (i->event_id == id)
                {
                    mStoredEvents.erase(i);
                    return;
                }
            }
        }
    }

References mStoredEvents.

Referenced by OnUpdate().

ResetBaseObject()

void SmartScript::ResetBaseObject ( )

inline

    {
        WorldObject* lookupRoot = me;
        if (!lookupRoot)
            lookupRoot = go;
 
        if (lookupRoot)
        {
            if (meOrigGUID)
            {
                if (Creature* m = ObjectAccessor::GetCreature(*lookupRoot, meOrigGUID))
                {
                    me = m;
                    go = nullptr;
                }
            }
 
            if (goOrigGUID)
            {
                if (GameObject* o = ObjectAccessor::GetGameObject(*lookupRoot, goOrigGUID))
                {
                    me = nullptr;
                    go = o;
                }
            }
        }
 
        goOrigGUID.Clear();
        meOrigGUID.Clear();
    }

References ObjectGuid::Clear(), ObjectAccessor::GetCreature(), ObjectAccessor::GetGameObject(), go, goOrigGUID, me, and meOrigGUID.

Referenced by OnReset().

RestoreCasterMaxDist()

void SmartScript::RestoreCasterMaxDist ( )

inline

{ smartCasterActualDist = smartCasterMaxDist; }

References smartCasterActualDist, and smartCasterMaxDist.

Referenced by OnReset(), and ProcessAction().

RestoreMaxCombatDist()

void SmartScript::RestoreMaxCombatDist ( )

inline

{ mActualCombatDist = mMaxCombatDist; }

References mActualCombatDist, and mMaxCombatDist.

Referenced by OnReset().

SetActualCombatDist()

void SmartScript::SetActualCombatDist ( uint32  dist )

inline

{ mActualCombatDist = dist; }

References mActualCombatDist.

Referenced by ProcessAction().

SetCasterActualDist()

void SmartScript::SetCasterActualDist ( float  dist )

inline

{ smartCasterActualDist = dist; }

References smartCasterActualDist.

Referenced by ProcessAction().

SetPathId()

void SmartScript::SetPathId ( uint32  id )

inline

{ mPathId = id; }

References mPathId.

Referenced by SmartAI::EndPath(), and SmartAI::LoadPath().

SetPhase()

void SmartScript::SetPhase ( uint32  p )

private

{
    uint32 oldPhase = mEventPhase;
 
    mEventPhase = p;
 
    if (oldPhase != mEventPhase)
    {
        ProcessEventsFor(SMART_EVENT_EVENT_PHASE_CHANGE);
    }
}

References mEventPhase, ProcessEventsFor(), and SMART_EVENT_EVENT_PHASE_CHANGE.

Referenced by DecPhase(), IncPhase(), OnReset(), and ProcessAction().

SetPhaseReset()

void SmartScript::SetPhaseReset ( bool  allow )

inline

{ _allowPhaseReset = allow; }

References _allowPhaseReset.

SetScript9()

void SmartScript::SetScript9	(	SmartScriptHolder &	e,
		uint32	entry
	)

{
    //do NOT clear mTimedActionList if it's being iterated because it will invalidate the iterator and delete
    // any SmartScriptHolder contained like the "e" parameter passed to this function
    if (isProcessingTimedActionList)
    {
        LOG_ERROR("scripts.ai.sai", "Entry {} SourceType {} Event {} Action {} is trying to overwrite timed action list from a timed action, this is not allowed!.", e.entryOrGuid, e.GetScriptType(), e.GetEventType(), e.GetActionType());
        return;
    }
 
    // Do NOT allow to start a new actionlist if a previous one is already running, unless explicitly allowed. We need to always finish the current actionlist
    if (!e.action.timedActionList.allowOverride && !mTimedActionList.empty())
    {
        return;
    }
 
    mTimedActionList.clear();
    mTimedActionList = sSmartScriptMgr->GetScript(entry, SMART_SCRIPT_TYPE_TIMED_ACTIONLIST);
    if (mTimedActionList.empty())
        return;
    for (SmartAIEventList::iterator i = mTimedActionList.begin(); i != mTimedActionList.end(); ++i)
    {
        i->enableTimed = i == mTimedActionList.begin();//enable processing only for the first action
 
        if (e.action.timedActionList.timerType == 0)
            i->event.type = SMART_EVENT_UPDATE_OOC;
        else if (e.action.timedActionList.timerType == 1)
            i->event.type = SMART_EVENT_UPDATE_IC;
        else if (e.action.timedActionList.timerType > 1)
            i->event.type = SMART_EVENT_UPDATE;
 
        InitTimer((*i));
    }
}

References SmartScriptHolder::action, SmartAction::allowOverride, SmartScriptHolder::entryOrGuid, SmartScriptHolder::GetActionType(), SmartScriptHolder::GetEventType(), SmartScriptHolder::GetScriptType(), InitTimer(), isProcessingTimedActionList, LOG_ERROR, mTimedActionList, SMART_EVENT_UPDATE, SMART_EVENT_UPDATE_IC, SMART_EVENT_UPDATE_OOC, SMART_SCRIPT_TYPE_TIMED_ACTIONLIST, sSmartScriptMgr, SmartAction::timedActionList, and SmartAction::timerType.

Referenced by SmartAI::SetScript9(), and SmartGameObjectAI::SetScript9().

StoreCounter()

void SmartScript::StoreCounter ( uint32  id, uint32  value, uint32  reset, uint32  subtract  )

inline

    {
        CounterMap::iterator itr = mCounterList.find(id);
        if (itr != mCounterList.end())
        {
            if (!reset && !subtract)
            {
                itr->second += value;
            }
            else if (subtract)
            {
                itr->second -= value;
            }
            else
            {
                itr->second = value;
            }
        }
        else
        {
            mCounterList.insert(std::make_pair(id, value));
        }
 
        ProcessEventsFor(SMART_EVENT_COUNTER_SET, nullptr, id);
    }

References mCounterList, ProcessEventsFor(), and SMART_EVENT_COUNTER_SET.

Referenced by ProcessAction().

StoreTargetList()

void SmartScript::StoreTargetList ( ObjectVector const &  targets, uint32  id  )

inline

    {
        // insert or replace
        _storedTargets.erase(id);
        _storedTargets.emplace(id, ObjectGuidVector(targets));
    }

References _storedTargets.

Referenced by ProcessAction().

UpdateTimer()

void SmartScript::UpdateTimer	(	SmartScriptHolder &	e,
		uint32 const	diff
	)

{
    if (e.GetEventType() == SMART_EVENT_LINK)
        return;
 
    if (e.event.event_phase_mask && !IsInPhase(e.event.event_phase_mask))
        return;
 
    if (e.GetEventType() == SMART_EVENT_UPDATE_IC && (!me || !me->IsEngaged()))
        return;
 
    if (e.GetEventType() == SMART_EVENT_UPDATE_OOC && (me && me->IsEngaged()))//can be used with me=nullptr (go script)
        return;
 
    if (e.timer < diff)
    {
        // delay spell cast event if another spell is being casted
        if (e.GetActionType() == SMART_ACTION_CAST)
        {
            if (!(e.action.cast.flags & (SMARTCAST_INTERRUPT_PREVIOUS | SMARTCAST_TRIGGERED)))
            {
                if (me && me->HasUnitState(UNIT_STATE_CASTING))
                {
                    e.timer = 1;
                    return;
                }
            }
        }
 
        // Delay flee for assist event if casting
        if (e.GetActionType() == SMART_ACTION_FLEE_FOR_ASSIST && me && me->HasUnitState(UNIT_STATE_CASTING))
        {
            e.timer = 1;
            return;
        }
 
        e.active = true;//activate events with cooldown
        switch (e.GetEventType())//process ONLY timed events
        {
            case SMART_EVENT_NEAR_PLAYERS:
            case SMART_EVENT_NEAR_PLAYERS_NEGATION:
            case SMART_EVENT_UPDATE:
            case SMART_EVENT_UPDATE_OOC:
            case SMART_EVENT_UPDATE_IC:
            case SMART_EVENT_HEALTH_PCT:
            case SMART_EVENT_TARGET_HEALTH_PCT:
            case SMART_EVENT_MANA_PCT:
            case SMART_EVENT_TARGET_MANA_PCT:
            case SMART_EVENT_RANGE:
            case SMART_EVENT_VICTIM_CASTING:
            case SMART_EVENT_FRIENDLY_HEALTH:
            case SMART_EVENT_FRIENDLY_IS_CC:
            case SMART_EVENT_FRIENDLY_MISSING_BUFF:
            case SMART_EVENT_HAS_AURA:
            case SMART_EVENT_TARGET_BUFFED:
            case SMART_EVENT_IS_BEHIND_TARGET:
            case SMART_EVENT_FRIENDLY_HEALTH_PCT:
            case SMART_EVENT_DISTANCE_CREATURE:
            case SMART_EVENT_DISTANCE_GAMEOBJECT:
                {
                    ProcessEvent(e);
                    if (e.GetScriptType() == SMART_SCRIPT_TYPE_TIMED_ACTIONLIST)
                    {
                        e.enableTimed = false;//disable event if it is in an ActionList and was processed once
                        for (SmartAIEventList::iterator i = mTimedActionList.begin(); i != mTimedActionList.end(); ++i)
                        {
                            //find the first event which is not the current one and enable it
                            if (i->event_id > e.event_id)
                            {
                                i->enableTimed = true;
                                break;
                            }
                        }
                    }
                    break;
                }
        }
    }
    else
        e.timer -= diff;
}

References SmartScriptHolder::action, SmartScriptHolder::active, SmartAction::cast, SmartScriptHolder::enableTimed, SmartScriptHolder::event, SmartScriptHolder::event_id, SmartEvent::event_phase_mask, SmartAction::flags, SmartScriptHolder::GetActionType(), SmartScriptHolder::GetEventType(), SmartScriptHolder::GetScriptType(), Unit::HasUnitState(), Unit::IsEngaged(), IsInPhase(), me, mTimedActionList, ProcessEvent(), SMART_ACTION_CAST, SMART_ACTION_FLEE_FOR_ASSIST, SMART_EVENT_DISTANCE_CREATURE, SMART_EVENT_DISTANCE_GAMEOBJECT, SMART_EVENT_FRIENDLY_HEALTH, SMART_EVENT_FRIENDLY_HEALTH_PCT, SMART_EVENT_FRIENDLY_IS_CC, SMART_EVENT_FRIENDLY_MISSING_BUFF, SMART_EVENT_HAS_AURA, SMART_EVENT_HEALTH_PCT, SMART_EVENT_IS_BEHIND_TARGET, SMART_EVENT_LINK, SMART_EVENT_MANA_PCT, SMART_EVENT_NEAR_PLAYERS, SMART_EVENT_NEAR_PLAYERS_NEGATION, SMART_EVENT_RANGE, SMART_EVENT_TARGET_BUFFED, SMART_EVENT_TARGET_HEALTH_PCT, SMART_EVENT_TARGET_MANA_PCT, SMART_EVENT_UPDATE, SMART_EVENT_UPDATE_IC, SMART_EVENT_UPDATE_OOC, SMART_EVENT_VICTIM_CASTING, SMART_SCRIPT_TYPE_TIMED_ACTIONLIST, SMARTCAST_INTERRUPT_PREVIOUS, SMARTCAST_TRIGGERED, SmartScriptHolder::timer, and UNIT_STATE_CASTING.

Referenced by OnUpdate().

Member Data Documentation

_allowPhaseReset

bool SmartScript::_allowPhaseReset

private

Referenced by AllowPhaseReset(), SetPhaseReset(), and SmartScript().

_storedTargets

ObjectVectorMap SmartScript::_storedTargets

private

Referenced by GetStoredTargetVector(), and StoreTargetList().

_summonList

GuidUnorderedSet SmartScript::_summonList

private

Referenced by AddCreatureSummon(), GetTargets(), and RemoveCreatureSummon().

go

GameObject* SmartScript::go

private

Referenced by GetBaseObject(), GetScript(), GetTargets(), InstallTemplate(), IsSmartGO(), OnInitialize(), ProcessAction(), ResetBaseObject(), and SmartScript().

goOrigGUID

ObjectGuid SmartScript::goOrigGUID

private

Referenced by ResetBaseObject().

isProcessingTimedActionList

bool SmartScript::isProcessingTimedActionList

private

Referenced by OnUpdate(), SetScript9(), and SmartScript().

mActualCombatDist

uint32 SmartScript::mActualCombatDist

private

Referenced by GetActualCombatDist(), RestoreMaxCombatDist(), SetActualCombatDist(), and SmartScript().

mCounterList

CounterMap SmartScript::mCounterList

Referenced by GetCounterValue(), OnReset(), and StoreCounter().

me

Creature* SmartScript::me

private

Referenced by DoFindClosestFriendlyInRange(), DoFindFriendlyCC(), DoFindFriendlyMissingBuff(), DoSelectLowestHpFriendly(), DoSelectLowestHpPercentFriendly(), GetBaseObject(), GetScript(), GetTargets(), InstallTemplate(), IsSmart(), OnInitialize(), OnMoveInLineOfSight(), OnUpdate(), ProcessAction(), ProcessEvent(), ProcessEventsFor(), ProcessTimedAction(), ResetBaseObject(), SmartScript(), and UpdateTimer().

meOrigGUID

ObjectGuid SmartScript::meOrigGUID

private

Referenced by ResetBaseObject().

mEventPhase

uint32 SmartScript::mEventPhase

private

Referenced by DecPhase(), IncPhase(), IsInPhase(), SetPhase(), and SmartScript().

mEvents

SmartAIEventList SmartScript::mEvents

private

Referenced by FillScript(), FindLinkedEvent(), InstallEvents(), OnInitialize(), OnReset(), OnUpdate(), and ProcessEventsFor().

mInstallEvents

SmartAIEventList SmartScript::mInstallEvents

private

Referenced by AddEvent(), and InstallEvents().

mLastInvoker

ObjectGuid SmartScript::mLastInvoker

Referenced by GetLastInvoker(), OnReset(), ProcessAction(), SmartAI::SetScript9(), and SmartGameObjectAI::SetScript9().

mLastTextID

uint32 SmartScript::mLastTextID

private

Referenced by OnUpdate(), ProcessAction(), and SmartScript().

mMaxCombatDist

uint32 SmartScript::mMaxCombatDist

private

Referenced by GetMaxCombatDist(), OnInitialize(), RestoreMaxCombatDist(), and SmartScript().

mPathId

uint32 SmartScript::mPathId

private

Referenced by GetPathId(), SetPathId(), and SmartScript().

mRemIDs

std::list<uint32> SmartScript::mRemIDs

private

Referenced by OnUpdate().

mScriptType

SmartScriptType SmartScript::mScriptType

private

Referenced by GetScript(), OnInitialize(), OnUpdate(), and SmartScript().

mStoredDecimals

std::unordered_map<int32, int32> SmartScript::mStoredDecimals

private

mStoredEvents

SmartAIEventStoredList SmartScript::mStoredEvents

private

Referenced by OnUpdate(), and RemoveStoredEvent().

mTalkerEntry

uint32 SmartScript::mTalkerEntry

private

Referenced by OnUpdate(), ProcessAction(), and SmartScript().

mTemplate

SMARTAI_TEMPLATE SmartScript::mTemplate

private

Referenced by InstallTemplate(), and SmartScript().

mTextTimer

uint32 SmartScript::mTextTimer

private

Referenced by OnUpdate(), ProcessAction(), and SmartScript().

mTimedActionList

SmartAIEventList SmartScript::mTimedActionList

private

Referenced by OnUpdate(), SetScript9(), and UpdateTimer().

mUseTextTimer

bool SmartScript::mUseTextTimer

private

Referenced by OnUpdate(), ProcessAction(), and SmartScript().

smartCasterActualDist

uint32 SmartScript::smartCasterActualDist

private

Referenced by GetCasterActualDist(), RestoreCasterMaxDist(), SetCasterActualDist(), and SmartScript().

smartCasterMaxDist

uint32 SmartScript::smartCasterMaxDist

private

Referenced by GetCasterMaxDist(), OnInitialize(), RestoreCasterMaxDist(), and SmartScript().

smartCasterPowerType

Powers SmartScript::smartCasterPowerType

private

Referenced by GetCasterPowerType(), OnInitialize(), and SmartScript().

trigger

AreaTrigger const* SmartScript::trigger

private

Referenced by GetScript(), OnInitialize(), ProcessAction(), and SmartScript().