FleeingMovementGenerator< T > Class Template Reference

#include <FleeingMovementGenerator.h>

Public Member Functions
	FleeingMovementGenerator (ObjectGuid fright)
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
bool	DoUpdate (T *, uint32)
MovementGeneratorType	GetMovementGeneratorType () const override
template<>
void	DoFinalize (Player *owner)
Public Member Functions inherited from MovementGeneratorMedium< T, FleeingMovementGenerator< T > >
void	Initialize (Unit *u) override
void	Finalize (Unit *u) override
void	Reset (Unit *u) override
bool	Update (Unit *u, uint32 time_diff) override
Public Member Functions inherited from MovementGenerator
virtual	~MovementGenerator ()
virtual void	unitSpeedChanged ()
virtual bool	GetResetPosition (Unit *, float &, float &, float &)

Private Member Functions
void	_setTargetLocation (T *)
void	_getPoint (T *, float &x, float &y, float &z)

Private Attributes
ObjectGuid	i_frightGUID
TimeTracker	i_nextCheckTime

Constructor & Destructor Documentation

template<class T>

FleeingMovementGenerator< T >::FleeingMovementGenerator ( ObjectGuid  fright )

inline

: i_frightGUID(fright), i_nextCheckTime(0) { }

Member Function Documentation

template<class T>

template void FleeingMovementGenerator< T >::_getPoint ( T *  , float &  x, float &  y, float &  z  )

private

{
 float dist_from_caster, angle_to_caster;
 if (Unit* fright = ObjectAccessor::GetUnit(*owner, i_frightGUID))
 {
 dist_from_caster = fright->GetDistance(owner);
 if (dist_from_caster > 0.2f)
 angle_to_caster = fright->GetAngle(owner);
 else
 angle_to_caster = frand(0, 2 * static_cast<float>(M_PI));
 }
 else
 {
 dist_from_caster = 0.0f;
 angle_to_caster = frand(0, 2 * static_cast<float>(M_PI));
 }

 float dist, angle;
 if (dist_from_caster < MIN_QUIET_DISTANCE)
 {
 dist = frand(0.4f, 1.3f)*(MIN_QUIET_DISTANCE - dist_from_caster);
 angle = angle_to_caster + frand(-static_cast<float>(M_PI)/8, static_cast<float>(M_PI)/8);
 }
 else if (dist_from_caster > MAX_QUIET_DISTANCE)
 {
 dist = frand(0.4f, 1.0f)*(MAX_QUIET_DISTANCE - MIN_QUIET_DISTANCE);
 angle = -angle_to_caster + frand(-static_cast<float>(M_PI)/4, static_cast<float>(M_PI)/4);
 }
 else // we are inside quiet range
 {
 dist = frand(0.6f, 1.2f)*(MAX_QUIET_DISTANCE - MIN_QUIET_DISTANCE);
 angle = frand(0, 2*static_cast<float>(M_PI));
 }

 Position pos = owner->GetFirstCollisionPosition(dist, angle);
 x = pos.m_positionX;
 y = pos.m_positionY;
 z = pos.m_positionZ;
}

Here is the call graph for this function:

template<class T>

template void FleeingMovementGenerator< T >::_setTargetLocation ( T *  )

private

{
 if (!owner)
 return;

 if (owner->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED))
 return;

 owner->AddUnitState(UNIT_STATE_FLEEING_MOVE);

 float x, y, z;
 _getPoint(owner, x, y, z);

 // Add LOS check for target point
 Position mypos = owner->GetPosition();
 bool isInLOS = VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(owner->GetMapId(),
 mypos.m_positionX,
 mypos.m_positionY,
 mypos.m_positionZ + 2.0f,
 x, y, z + 2.0f);
 if (!isInLOS)
 {
 i_nextCheckTime.Reset(200);
 return;
 }

 PathGenerator path(owner);
 path.SetPathLengthLimit(30.0f);
 bool result = path.CalculatePath(x, y, z);
 if (!result || (path.GetPathType() & PATHFIND_NOPATH))
 {
 i_nextCheckTime.Reset(100);
 return;
 }

 Movement::MoveSplineInit init(owner);
 init.MovebyPath(path.GetPath());
 init.SetWalk(false);
 int32 traveltime = init.Launch();
 i_nextCheckTime.Reset(traveltime + urand(800, 1500));
}

Here is the call graph for this function:

template<class T>

void FleeingMovementGenerator< T >::DoFinalize

(

T *

)

template<>

void FleeingMovementGenerator< Player >::DoFinalize

(

Player *

owner

)

{
 owner->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_FLEEING);
 owner->ClearUnitState(UNIT_STATE_FLEEING | UNIT_STATE_FLEEING_MOVE);
 owner->StopMoving();
}

template<class T>

template void FleeingMovementGenerator< T >::DoInitialize

(

T *

)

{
 if (!owner)
 return;

 owner->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_FLEEING);
 owner->AddUnitState(UNIT_STATE_FLEEING | UNIT_STATE_FLEEING_MOVE);
 _setTargetLocation(owner);
}

template<class T>

template void FleeingMovementGenerator< T >::DoReset

(

T *

)

{
 DoInitialize(owner);
}

template<class T>

template bool FleeingMovementGenerator< T >::DoUpdate	(	T *	,
		uint32
	)

{
 if (!owner || !owner->IsAlive())
 return false;

 if (owner->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED))
 {
 owner->ClearUnitState(UNIT_STATE_FLEEING_MOVE);
 return true;
 }

 i_nextCheckTime.Update(time_diff);
 if (i_nextCheckTime.Passed() && owner->movespline->Finalized())
 _setTargetLocation(owner);

 return true;
}

template<class T>

MovementGeneratorType FleeingMovementGenerator< T >::GetMovementGeneratorType ( ) const

inlineoverridevirtual

Implements MovementGenerator.

{ return FLEEING_MOTION_TYPE; }

Member Data Documentation

template<class T>

ObjectGuid FleeingMovementGenerator< T >::i_frightGUID

private

template<class T>

TimeTracker FleeingMovementGenerator< T >::i_nextCheckTime

private

---

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

• src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.h
• src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp