RandomMovementGenerator< T > Class Template Reference

#include "RandomMovementGenerator.h"

Inheritance diagram for RandomMovementGenerator< T >:

Public Member Functions
	RandomMovementGenerator (float wanderDistance=0.0f)
	~RandomMovementGenerator ()
void	_setRandomLocation (T *)
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
bool	DoUpdate (T *, const uint32)
bool	GetResetPosition (float &x, float &y, float &z)
MovementGeneratorType	GetMovementGeneratorType ()
void	_setRandomLocation (Creature *creature)
void	DoInitialize (Creature *creature)
void	DoReset (Creature *creature)
void	DoFinalize (Creature *creature)
bool	DoUpdate (Creature *creature, const uint32 diff)
bool	GetResetPosition (float &x, float &y, float &z)
Public Member Functions inherited from MovementGeneratorMedium< T, RandomMovementGenerator< 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 uint32	GetSplineId () const
virtual void	unitSpeedChanged ()
virtual void	Pause (uint32)
virtual void	Resume (uint32)

Private Attributes
TimeTrackerSmall	_nextMoveTime
uint8	_moveCount
float	_wanderDistance
std::unique_ptr< PathGenerator >	_pathGenerator
std::vector< G3D::Vector3 >	_destinationPoints
std::vector< uint8 >	_validPointsVector [RANDOM_POINTS_NUMBER+1]
uint8	_currentPoint
std::map< uint16, Movement::PointsArray >	_preComputedPaths
Position	_initialPosition
Position	_currDestPosition

Detailed Description

template<class T>
class RandomMovementGenerator< T >

Constructor & Destructor Documentation

RandomMovementGenerator()

template<class T >

RandomMovementGenerator< T >::RandomMovementGenerator ( float  wanderDistance = 0.0f )

inline

                                                         : _nextMoveTime(0), _moveCount(0), _wanderDistance(wanderDistance), _pathGenerator(nullptr), _currentPoint(RANDOM_POINTS_NUMBER)
    {
        _initialPosition.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
        _destinationPoints.reserve(RANDOM_POINTS_NUMBER);
 
        for (uint8 i = 0; i < RANDOM_POINTS_NUMBER; ++i)
        {
            _validPointsVector[i].reserve(RANDOM_LINKS_COUNT);
            for (uint8 j = 0; j < RANDOM_LINKS_COUNT; ++j)
                _validPointsVector[i].push_back((i + j + RANDOM_POINTS_NUMBER / 2 - RANDOM_LINKS_COUNT / 2) % RANDOM_POINTS_NUMBER);
        }
 
        _validPointsVector[RANDOM_POINTS_NUMBER].reserve(RANDOM_POINTS_NUMBER);
        for (uint8 i = 0; i < RANDOM_POINTS_NUMBER; ++i)
            _validPointsVector[RANDOM_POINTS_NUMBER].push_back(i);
    }

References RandomMovementGenerator< T >::_destinationPoints, RandomMovementGenerator< T >::_initialPosition, RandomMovementGenerator< T >::_validPointsVector, RANDOM_LINKS_COUNT, RANDOM_POINTS_NUMBER, and Position::Relocate().

~RandomMovementGenerator()

template<class T >

template RandomMovementGenerator< T >::~RandomMovementGenerator

(

)

{ }

Member Function Documentation

_setRandomLocation() [1/2]

void RandomMovementGenerator< Creature >::_setRandomLocation

(

Creature *

creature

)

{
    if (!creature)
        return;
 
    if (creature->_moveState != MAP_OBJECT_CELL_MOVE_NONE)
        return;
 
    if (_validPointsVector[_currentPoint].empty())
    {
        if (_currentPoint == RANDOM_POINTS_NUMBER) // cant go anywhere from initial position, lets stay
            return;
        // go back to initial position and will never return to this point
        _currentPoint = RANDOM_POINTS_NUMBER;
        _currDestPosition.Relocate(_initialPosition);
        creature->AddUnitState(UNIT_STATE_ROAMING_MOVE);
        Movement::MoveSplineInit init(creature);
        init.MoveTo(_currDestPosition.GetPositionX(), _currDestPosition.GetPositionY(), _currDestPosition.GetPositionZ());
 
        bool walk = true;
        switch (creature->GetMovementTemplate().GetRandom())
        {
            case CreatureRandomMovementType::CanRun:
                walk = creature->IsWalking();
                break;
            case CreatureRandomMovementType::AlwaysRun:
                walk = false;
                break;
            default:
                break;
        }
 
        init.SetWalk(walk);
        init.Launch();
        if (creature->GetFormation() && creature->GetFormation()->GetLeader() == creature)
            creature->GetFormation()->LeaderMoveTo(_currDestPosition.GetPositionX(), _currDestPosition.GetPositionY(), _currDestPosition.GetPositionZ(), 0);
        return;
    }
 
    uint8 random = urand(0, _validPointsVector[_currentPoint].size() - 1);
    std::vector<uint8>::iterator randomIter = _validPointsVector[_currentPoint].begin() + random;
    uint8 newPoint = *randomIter;
    uint16 pathIdx = uint16(_currentPoint * RANDOM_POINTS_NUMBER + newPoint);
 
    // cant go anywhere from new point, so dont go there to not be stuck
    if (_validPointsVector[newPoint].empty())
    {
        _validPointsVector[_currentPoint].erase(randomIter);
        return;
    }
 
    Movement::PointsArray& finalPath = _preComputedPaths[pathIdx];
    if (finalPath.empty())
    {
        Map* map = creature->GetMap();
        float x = _destinationPoints[newPoint].x, y = _destinationPoints[newPoint].y, z = _destinationPoints[newPoint].z;
        // invalid coordinates
        if (!Acore::IsValidMapCoord(x, y))
        {
            _validPointsVector[_currentPoint].erase(randomIter);
            _preComputedPaths.erase(pathIdx);
            return;
        }
 
        float ground = INVALID_HEIGHT;
        float levelZ = creature->GetMapWaterOrGroundLevel(x, y, z, &ground);
        float newZ = INVALID_HEIGHT;
 
        // flying creature
        if (creature->CanFly())
            newZ = std::max<float>(levelZ, z + rand_norm() * _wanderDistance / 2.0f);
        // point underwater
        else if (ground < levelZ)
        {
            if (!creature->CanEnterWater())
            {
                _validPointsVector[_currentPoint].erase(randomIter);
                _preComputedPaths.erase(pathIdx);
                return;
            }
            else
            {
                if (levelZ > INVALID_HEIGHT)
                    newZ = std::min<float>(levelZ - 2.0f, z + rand_norm() * _wanderDistance / 2.0f);
                newZ = std::max<float>(ground, newZ);
            }
        }
        // point on ground
        else
        {
            if (levelZ <= INVALID_HEIGHT || !creature->CanWalk())
            {
                _validPointsVector[_currentPoint].erase(randomIter);
                _preComputedPaths.erase(pathIdx);
                return;
            }
        }
 
        creature->UpdateAllowedPositionZ(x, y, newZ);
 
        if (newZ > INVALID_HEIGHT)
        {
            // flying / swiming creature - dest not in los
            if (!creature->IsWithinLOS(x, y, newZ))
            {
                _validPointsVector[_currentPoint].erase(randomIter);
                _preComputedPaths.erase(pathIdx);
                return;
            }
 
            finalPath.push_back(G3D::Vector3(creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ()));
            finalPath.push_back(G3D::Vector3(x, y, newZ));
        }
        else // ground
        {
            if (!_pathGenerator)
                _pathGenerator = std::make_unique<PathGenerator>(creature);
            else
                _pathGenerator->Clear();
 
            bool result = _pathGenerator->CalculatePath(x, y, levelZ, false);
            if (result && !(_pathGenerator->GetPathType() & PATHFIND_NOPATH))
            {
                // generated path is too long
                float pathLen = _pathGenerator->getPathLength();
                if (pathLen * pathLen > creature->GetExactDistSq(x, y, levelZ) * MAX_PATH_LENGHT_FACTOR * MAX_PATH_LENGHT_FACTOR)
                {
                    _validPointsVector[_currentPoint].erase(randomIter);
                    _preComputedPaths.erase(pathIdx);
                    return;
                }
 
                finalPath = _pathGenerator->GetPath();
                Movement::PointsArray::iterator itr = finalPath.begin();
                Movement::PointsArray::iterator itrNext = finalPath.begin() + 1;
                float zDiff, distDiff;
 
                for (; itrNext != finalPath.end(); ++itr, ++itrNext)
                {
                    distDiff = std::sqrt(((*itr).x - (*itrNext).x) * ((*itr).x - (*itrNext).x) + ((*itr).y - (*itrNext).y) * ((*itr).y - (*itrNext).y));
                    zDiff = std::fabs((*itr).z - (*itrNext).z);
 
                    // Xinef: tree climbing, cut as much as we can
                    if (zDiff > 2.0f ||
                            (G3D::fuzzyNe(zDiff, 0.0f) && distDiff / zDiff < 2.15f)) // ~25˚
                    {
                        _validPointsVector[_currentPoint].erase(randomIter);
                        _preComputedPaths.erase(pathIdx);
                        return;
                    }
 
                    if (!map->isInLineOfSight((*itr).x, (*itr).y, (*itr).z + 2.f, (*itrNext).x, (*itrNext).y, (*itrNext).z + 2.f, creature->GetPhaseMask(),
                        LINEOFSIGHT_ALL_CHECKS, VMAP::ModelIgnoreFlags::Nothing))
                    {
                        _validPointsVector[_currentPoint].erase(randomIter);
                        _preComputedPaths.erase(pathIdx);
                        return;
                    }
                }
 
                // no valid path
                if (finalPath.size() < 2)
                {
                    _validPointsVector[_currentPoint].erase(randomIter);
                    _preComputedPaths.erase(pathIdx);
                    return;
                }
            }
            else
            {
                _validPointsVector[_currentPoint].erase(randomIter);
                _preComputedPaths.erase(pathIdx);
                return;
            }
        }
    }
 
    _currentPoint = newPoint;
    G3D::Vector3& finalPoint = finalPath[finalPath.size() - 1];
    _currDestPosition.Relocate(finalPoint.x, finalPoint.y, finalPoint.z);
 
    creature->AddUnitState(UNIT_STATE_ROAMING_MOVE);
    bool walk = true;
    switch (creature->GetMovementTemplate().GetRandom())
    {
    case CreatureRandomMovementType::CanRun:
        walk = creature->IsWalking();
        break;
    case CreatureRandomMovementType::AlwaysRun:
        walk = false;
        break;
    default:
        break;
    }
 
    Movement::MoveSplineInit init(creature);
    init.MovebyPath(finalPath);
    init.SetWalk(walk);
    init.Launch();
 
    ++_moveCount;
    if (roll_chance_i((int32) _moveCount * 25 + 10))
    {
        _moveCount = 0;
        _nextMoveTime.Reset(urand(4000, 8000));
    }
    if (sWorld->getBoolConfig(CONFIG_DONT_CACHE_RANDOM_MOVEMENT_PATHS))
        _preComputedPaths.erase(pathIdx);
 
    //Call for creature group update
    if (creature->GetFormation() && creature->GetFormation()->GetLeader() == creature)
        creature->GetFormation()->LeaderMoveTo(finalPoint.x, finalPoint.y, finalPoint.z, 0);
}

References MovableMapObject::_moveState, Unit::AddUnitState(), AlwaysRun, Creature::CanEnterWater(), Creature::CanFly(), CanRun, CanWalk, CONFIG_DONT_CACHE_RANDOM_MOVEMENT_PATHS, Position::GetExactDistSq(), Creature::GetFormation(), CreatureGroup::GetLeader(), WorldObject::GetMap(), WorldObject::GetMapWaterOrGroundLevel(), Creature::GetMovementTemplate(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), CreatureMovementData::GetRandom(), INVALID_HEIGHT, Map::isInLineOfSight(), Acore::IsValidMapCoord(), Unit::IsWalking(), WorldObject::IsWithinLOS(), Movement::MoveSplineInit::Launch(), CreatureGroup::LeaderMoveTo(), LINEOFSIGHT_ALL_CHECKS, MAP_OBJECT_CELL_MOVE_NONE, MAX_PATH_LENGHT_FACTOR, Movement::MoveSplineInit::MovebyPath(), Movement::MoveSplineInit::MoveTo(), VMAP::Nothing, PATHFIND_NOPATH, rand_norm(), RANDOM_POINTS_NUMBER, roll_chance_i(), Movement::MoveSplineInit::SetWalk(), sWorld, UNIT_STATE_ROAMING_MOVE, WorldObject::UpdateAllowedPositionZ(), and urand().

_setRandomLocation() [2/2]

template<class T >

void RandomMovementGenerator< T >::_setRandomLocation

(

T *

)

DoFinalize() [1/2]

void RandomMovementGenerator< Creature >::DoFinalize

(

Creature *

creature

)

{
    creature->ClearUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
}

References Unit::ClearUnitState(), UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

DoFinalize() [2/2]

template<class T >

void RandomMovementGenerator< T >::DoFinalize

(

T *

)

DoInitialize() [1/2]

void RandomMovementGenerator< Creature >::DoInitialize

(

Creature *

creature

)

{
    if (!creature->IsAlive())
        return;
 
    if (!_wanderDistance)
        _wanderDistance = creature->GetWanderDistance();
 
    _nextMoveTime.Reset(creature->GetSpawnId() && creature->GetWanderDistance() == _wanderDistance ? urand(1, 5000) : 0);
    _wanderDistance = std::max((creature->GetWanderDistance() == _wanderDistance && creature->GetInstanceId() == 0) ? (creature->CanFly() ? MIN_WANDER_DISTANCE_AIR : MIN_WANDER_DISTANCE_GROUND) : 0.0f, _wanderDistance);
 
    if (G3D::fuzzyEq(_initialPosition.GetExactDist2d(0.0f, 0.0f), 0.0f))
    {
        _initialPosition.Relocate(creature);
        _destinationPoints.clear();
        for (uint8 i = 0; i < RANDOM_POINTS_NUMBER; ++i)
        {
            float angle = (M_PI * 2.0f / (float)RANDOM_POINTS_NUMBER) * i;
            float factor = 0.5f + rand_norm() * 0.5f;
            _destinationPoints.push_back(G3D::Vector3(_initialPosition.GetPositionX() + _wanderDistance * cos(angle)*factor, _initialPosition.GetPositionY() + _wanderDistance * std::sin(angle)*factor, _initialPosition.GetPositionZ()));
        }
    }
 
    creature->AddUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
}

References Unit::AddUnitState(), Creature::CanFly(), WorldObject::GetInstanceId(), Creature::GetSpawnId(), Creature::GetWanderDistance(), Unit::IsAlive(), MIN_WANDER_DISTANCE_AIR, MIN_WANDER_DISTANCE_GROUND, rand_norm(), RANDOM_POINTS_NUMBER, UNIT_STATE_ROAMING, UNIT_STATE_ROAMING_MOVE, and urand().

DoInitialize() [2/2]

template<class T >

void RandomMovementGenerator< T >::DoInitialize

(

T *

)

DoReset() [1/2]

void RandomMovementGenerator< Creature >::DoReset

(

Creature *

creature

)

{
    DoInitialize(creature);
}

DoReset() [2/2]

template<class T >

void RandomMovementGenerator< T >::DoReset

(

T *

)

DoUpdate() [1/2]

bool RandomMovementGenerator< Creature >::DoUpdate	(	Creature *	creature,
		const uint32	diff
	)

{
    if (creature->HasUnitState(UNIT_STATE_NOT_MOVE) || creature->IsMovementPreventedByCasting())
    {
        _nextMoveTime.Reset(0);  // Expire the timer
        creature->StopMoving();
        return true;
    }
 
    // xinef: if we got disable move flag, do not remove default generator - just prevent movement
    if (creature->HasUnitFlag(UNIT_FLAG_DISABLE_MOVE))
    {
        _nextMoveTime.Reset(0);  // Expire the timer
        creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
        return true;
    }
 
    if (creature->movespline->Finalized())
    {
        _nextMoveTime.Update(diff);
        if (_nextMoveTime.Passed())
            _setRandomLocation(creature);
    }
    return true;
}

References Unit::ClearUnitState(), Movement::MoveSpline::Finalized(), Unit::HasUnitFlag(), Unit::HasUnitState(), Creature::IsMovementPreventedByCasting(), Unit::movespline, Unit::StopMoving(), UNIT_FLAG_DISABLE_MOVE, UNIT_STATE_NOT_MOVE, and UNIT_STATE_ROAMING_MOVE.

DoUpdate() [2/2]

template<class T >

bool RandomMovementGenerator< T >::DoUpdate	(	T *	,
		const uint32
	)

GetMovementGeneratorType()

template<class T >

MovementGeneratorType RandomMovementGenerator< T >::GetMovementGeneratorType ( )

inlinevirtual

Implements MovementGenerator.

{ return RANDOM_MOTION_TYPE; }

References RANDOM_MOTION_TYPE.

GetResetPosition() [1/2]

bool RandomMovementGenerator< Creature >::GetResetPosition ( float &  x, float &  y, float &  z  )

virtual

Reimplemented from MovementGenerator.

{
    if (_currentPoint < RANDOM_POINTS_NUMBER)
        _currDestPosition.GetPosition(x, y, z);
    else if (G3D::fuzzyNe(_initialPosition.GetExactDist2d(0.0f, 0.0f), 0.0f)) // if initial position is not 0.0f, 0.0f
        _initialPosition.GetPosition(x, y, z);
    else
        return false;
    return true;
}

References RANDOM_POINTS_NUMBER.

GetResetPosition() [2/2]

template<class T >

bool RandomMovementGenerator< T >::GetResetPosition ( float &  x, float &  y, float &  z  )

virtual

Reimplemented from MovementGenerator.

Member Data Documentation

_currDestPosition

template<class T >

Position RandomMovementGenerator< T >::_currDestPosition

private

_currentPoint

template<class T >

uint8 RandomMovementGenerator< T >::_currentPoint

private

_destinationPoints

template<class T >

std::vector<G3D::Vector3> RandomMovementGenerator< T >::_destinationPoints

private

Referenced by RandomMovementGenerator< T >::RandomMovementGenerator().

_initialPosition

template<class T >

Position RandomMovementGenerator< T >::_initialPosition

private

Referenced by RandomMovementGenerator< T >::RandomMovementGenerator().

_moveCount

template<class T >

uint8 RandomMovementGenerator< T >::_moveCount

private

_nextMoveTime

template<class T >

TimeTrackerSmall RandomMovementGenerator< T >::_nextMoveTime

private

_pathGenerator

template<class T >

std::unique_ptr<PathGenerator> RandomMovementGenerator< T >::_pathGenerator

private

_preComputedPaths

template<class T >

std::map<uint16, Movement::PointsArray> RandomMovementGenerator< T >::_preComputedPaths

private

_validPointsVector

template<class T >

std::vector<uint8> RandomMovementGenerator< T >::_validPointsVector[RANDOM_POINTS_NUMBER+1]

private

Referenced by RandomMovementGenerator< T >::RandomMovementGenerator().

_wanderDistance

template<class T >

float RandomMovementGenerator< T >::_wanderDistance

private

---

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

• azerothcore-wotlk/src/server/game/Movement/MovementGenerators/RandomMovementGenerator.h
• azerothcore-wotlk/src/server/game/Movement/MovementGenerators/RandomMovementGenerator.cpp