FleeingMovementGenerator< T > Class Template Reference

#include "FleeingMovementGenerator.h"

Inheritance diagram for FleeingMovementGenerator< T >:

Public Member Functions
	FleeingMovementGenerator (ObjectGuid fleeTargetGUID)
MovementGeneratorType	GetMovementGeneratorType () override
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
bool	DoUpdate (T *, uint32)
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	Initialize (Unit *)=0
virtual void	Finalize (Unit *)=0
virtual void	Reset (Unit *)=0
virtual bool	Update (Unit *, uint32 time_diff)=0
virtual MovementGeneratorType	GetMovementGeneratorType ()=0
virtual uint32	GetSplineId () const
virtual void	unitSpeedChanged ()
virtual void	Pause (uint32)
virtual void	Resume (uint32)
virtual bool	GetResetPosition (float &, float &, float &)

Private Member Functions
void	SetTargetLocation (T *)
void	GetPoint (T *, Position &position)

Private Attributes
std::unique_ptr< PathGenerator >	_path
ObjectGuid	_fleeTargetGUID
TimeTracker	_timer
bool	_interrupt
uint8	_shortPathsCount

Detailed Description

template<class T>
class FleeingMovementGenerator< T >

Constructor & Destructor Documentation

FleeingMovementGenerator()

template<class T >

FleeingMovementGenerator< T >::FleeingMovementGenerator ( ObjectGuid  fleeTargetGUID )

inlineexplicit

: _path(nullptr), _fleeTargetGUID(fleeTargetGUID), _timer(0), _interrupt(false), _shortPathsCount(0) { }

Member Function Documentation

DoFinalize() [1/2]

void FleeingMovementGenerator< Player >::DoFinalize

(

Player *

owner

)

{
    owner->RemoveUnitFlag(UNIT_FLAG_FLEEING);
    owner->ClearUnitState(UNIT_STATE_FLEEING);
    owner->StopMoving();
}

References Unit::ClearUnitState(), Unit::RemoveUnitFlag(), Unit::StopMoving(), UNIT_FLAG_FLEEING, and UNIT_STATE_FLEEING.

DoFinalize() [2/2]

template<class T >

void FleeingMovementGenerator< T >::DoFinalize

(

T *

)

{
}

DoInitialize()

template<class T >

template void FleeingMovementGenerator< T >::DoInitialize

(

T *

)

{
    if (!owner)
    {
        return;
    }
 
    owner->StopMoving();
    _path = nullptr;
    owner->SetUnitFlag(UNIT_FLAG_FLEEING);
    owner->AddUnitState(UNIT_STATE_FLEEING);
    SetTargetLocation(owner);
}

DoReset()

template<class T >

template void FleeingMovementGenerator< T >::DoReset

(

T *

)

{
    DoInitialize(owner);
}

DoUpdate()

template<class T >

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

{
    if (!owner || !owner->IsAlive())
    {
        return false;
    }
 
    if (owner->HasUnitState(UNIT_STATE_NOT_MOVE) || owner->IsMovementPreventedByCasting())
    {
        _path = nullptr;
        _interrupt = true;
        owner->StopMoving();
        return true;
    }
    else
        _interrupt = false;
 
    _timer.Update(diff);
    if (!_interrupt && _timer.Passed() && owner->movespline->Finalized())
    {
        SetTargetLocation(owner);
    }
 
    return true;
}

References UNIT_STATE_NOT_MOVE.

GetMovementGeneratorType()

template<class T >

MovementGeneratorType FleeingMovementGenerator< T >::GetMovementGeneratorType ( )

inlineoverridevirtual

Implements MovementGenerator.

{ return FLEEING_MOTION_TYPE; }

References FLEEING_MOTION_TYPE.

GetPoint()

template<class T >

template void FleeingMovementGenerator< T >::GetPoint ( T *  , Position &  position  )

private

{
    float casterDistance = 0.f;
    float casterAngle = 0.f;
    Unit* fleeTarget = nullptr;
    if (_shortPathsCount < 5)
        fleeTarget = ObjectAccessor::GetUnit(*owner, _fleeTargetGUID);
 
    if (fleeTarget)
    {
        casterDistance = fleeTarget->GetDistance(owner);
        if (casterDistance > 0.2f)
        {
            casterAngle = fleeTarget->GetAngle(owner);
        }
        else
        {
            casterAngle = frand(0.0f, 2.0f * float(M_PI));
        }
    }
    else
    {
        casterDistance = 0.0f;
        casterAngle = frand(0.0f, 2.0f * float(M_PI));
    }
 
    float distance = 0.f;
    float angle = 0.f;
    if (casterDistance < MIN_QUIET_DISTANCE)
    {
        distance = frand(0.4f, 1.3f) * (MIN_QUIET_DISTANCE - casterDistance);
        angle = casterAngle + frand(-float(M_PI) / 8.0f, float(M_PI) / 8.0f);
    }
    else if (casterDistance > MAX_QUIET_DISTANCE)
    {
        distance = frand(0.4f, 1.0f) * (MAX_QUIET_DISTANCE - MIN_QUIET_DISTANCE);
        angle = -casterAngle + frand(-float(M_PI) / 4.0f, float(M_PI) / 4.0f);
    }
    else    // we are inside quiet range
    {
        distance = frand(0.6f, 1.2f) * (MAX_QUIET_DISTANCE - MIN_QUIET_DISTANCE);
        angle = frand(0.0f, 2.0f * float(M_PI));
    }
 
    // In MovePositionToFirstCollision we have added owner's orientation
    // so now let's subtract it
    angle -= owner->GetOrientation();
 
    owner->MovePositionToFirstCollision(position, distance, angle);
}

References frand(), Position::GetAngle(), WorldObject::GetDistance(), ObjectAccessor::GetUnit(), MAX_QUIET_DISTANCE, and MIN_QUIET_DISTANCE.

SetTargetLocation()

template<class T >

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

private

{
    if (!owner)
    {
        return;
    }
 
    if (owner->HasUnitState(UNIT_STATE_NOT_MOVE) || owner->IsMovementPreventedByCasting())
    {
        _path = nullptr;
        _interrupt = true;
        owner->StopMoving();
        return;
    }
 
    owner->AddUnitState(UNIT_STATE_FLEEING_MOVE);
 
    Position destination = owner->GetPosition();
    GetPoint(owner, destination);
 
    // Add LOS check for target point
    if (!owner->IsWithinLOS(destination.GetPositionX(), destination.GetPositionY(), destination.GetPositionZ()))
    {
        _timer.Reset(200);
        return;
    }
 
    if (!_path)
    {
        _path = std::make_unique<PathGenerator>(owner);
    }
    else
    {
        _path->Clear();
    }
 
    _path->SetPathLengthLimit(30.0f);
    bool result = _path->CalculatePath(destination.GetPositionX(), destination.GetPositionY(), destination.GetPositionZ());
    if (!result || (_path->GetPathType() & PathType(PATHFIND_NOPATH | PATHFIND_SHORTCUT | PATHFIND_FARFROMPOLY)))
    {
        _timer.Reset(100);
        return;
    }
 
    // Same position - recheck
    if (_path->getPathLength() < MIN_PATH_LENGTH)
    {
        if (_fleeTargetGUID)
        {
            ++_shortPathsCount;
        }
 
        _timer.Reset(100);
        return;
    }
 
    _shortPathsCount = 0;
 
    Movement::MoveSplineInit init(owner);
    init.MovebyPath(_path->GetPath());
    init.SetWalk(false);
    int32 traveltime = init.Launch();
    _timer.Reset(traveltime + urand(800, 1500));
}

References Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Movement::MoveSplineInit::Launch(), MIN_PATH_LENGTH, Movement::MoveSplineInit::MovebyPath(), PATHFIND_FARFROMPOLY, PATHFIND_NOPATH, PATHFIND_SHORTCUT, Movement::MoveSplineInit::SetWalk(), UNIT_STATE_FLEEING_MOVE, UNIT_STATE_NOT_MOVE, and urand().

Member Data Documentation

_fleeTargetGUID

template<class T >

ObjectGuid FleeingMovementGenerator< T >::_fleeTargetGUID

private

_interrupt

template<class T >

bool FleeingMovementGenerator< T >::_interrupt

private

_path

template<class T >

std::unique_ptr<PathGenerator> FleeingMovementGenerator< T >::_path

private

_shortPathsCount

template<class T >

uint8 FleeingMovementGenerator< T >::_shortPathsCount

private

_timer

template<class T >

TimeTracker FleeingMovementGenerator< T >::_timer

private