ConfusedMovementGenerator< T > Class Template Reference

#include "ConfusedMovementGenerator.h"

Inheritance diagram for ConfusedMovementGenerator< T >:

Public Member Functions
	ConfusedMovementGenerator ()
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
bool	DoUpdate (T *, uint32)
MovementGeneratorType	GetMovementGeneratorType ()
void	DoFinalize (Player *unit)
void	DoFinalize (Creature *unit)
Public Member Functions inherited from MovementGeneratorMedium< T, ConfusedMovementGenerator< 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	_InitSpecific (T *, bool &, bool &)
void	_InitSpecific (Creature *creature, bool &is_water_ok, bool &is_land_ok)
void	_InitSpecific (Player *, bool &is_water_ok, bool &is_land_ok)

Private Attributes
TimeTracker	i_nextMoveTime
float	i_waypoints [MAX_CONF_WAYPOINTS+1][3]
uint32	i_nextMove

Detailed Description

template<class T>
class ConfusedMovementGenerator< T >

Constructor & Destructor Documentation

ConfusedMovementGenerator()

template<class T >

ConfusedMovementGenerator< T >::ConfusedMovementGenerator ( )

inlineexplicit

: i_nextMoveTime(1) {}

Member Function Documentation

_InitSpecific() [1/3]

void ConfusedMovementGenerator< Creature >::_InitSpecific ( Creature *  creature, bool &  is_water_ok, bool &  is_land_ok  )

private

{
    is_water_ok = creature->CanEnterWater();
    is_land_ok  = creature->CanWalk();
}

References Creature::CanEnterWater(), and Creature::CanWalk().

_InitSpecific() [2/3]

void ConfusedMovementGenerator< Player >::_InitSpecific ( Player *  , bool &  is_water_ok, bool &  is_land_ok  )

private

{
    is_water_ok = true;
    is_land_ok  = true;
}

_InitSpecific() [3/3]

template<class T >

void ConfusedMovementGenerator< T >::_InitSpecific ( T *  , bool &  , bool &    )

private

DoFinalize() [1/3]

void ConfusedMovementGenerator< Creature >::DoFinalize

(

Creature *

unit

)

{
    unit->RemoveUnitFlag(UNIT_FLAG_CONFUSED);
    unit->ClearUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_CONFUSED_MOVE);
    if (unit->GetVictim())
        unit->SetTarget(unit->GetVictim()->GetGUID());
}

References Unit::ClearUnitState(), Object::GetGUID(), Unit::GetVictim(), Unit::RemoveUnitFlag(), Creature::SetTarget(), UNIT_FLAG_CONFUSED, UNIT_STATE_CONFUSED, and UNIT_STATE_CONFUSED_MOVE.

DoFinalize() [2/3]

void ConfusedMovementGenerator< Player >::DoFinalize

(

Player *

unit

)

{
    unit->RemoveUnitFlag(UNIT_FLAG_CONFUSED);
    unit->ClearUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_CONFUSED_MOVE);
    unit->StopMoving();
}

References Unit::ClearUnitState(), Unit::RemoveUnitFlag(), Unit::StopMoving(), UNIT_FLAG_CONFUSED, UNIT_STATE_CONFUSED, and UNIT_STATE_CONFUSED_MOVE.

DoFinalize() [3/3]

template<class T >

void ConfusedMovementGenerator< T >::DoFinalize

(

T *

)

DoInitialize()

template<class T >

template void ConfusedMovementGenerator< T >::DoInitialize

(

T *

)

Cannot use coordinates outside our InhabitType. Use the current or previous position.

Trying to access path outside line of sight. Skip this by using the current or previous position.

Positions are fine - apply them to this waypoint

{
    unit->StopMoving();
    float const wander_distance = 4;
    float x = unit->GetPositionX();
    float y = unit->GetPositionY();
    float z = unit->GetPositionZ();
 
    Map const* map = unit->GetMap();
 
    bool is_water_ok, is_land_ok;
    _InitSpecific(unit, is_water_ok, is_land_ok);
 
    for (uint8 idx = 0; idx < MAX_CONF_WAYPOINTS + 1; ++idx)
    {
        float wanderX = x + (wander_distance * (float)rand_norm() - wander_distance / 2);
        float wanderY = y + (wander_distance * (float)rand_norm() - wander_distance / 2);
 
        // prevent invalid coordinates generation
        Acore::NormalizeMapCoord(wanderX);
        Acore::NormalizeMapCoord(wanderY);
 
        float new_z = unit->GetMapHeight(wanderX, wanderY, z);
        if (new_z <= INVALID_HEIGHT || std::fabs(z - new_z) > 3.0f) // pussywizard
        {
            i_waypoints[idx][0] = idx > 0 ? i_waypoints[idx - 1][0] : x;
            i_waypoints[idx][1] = idx > 0 ? i_waypoints[idx - 1][1] : y;
            i_waypoints[idx][2] = idx > 0 ? i_waypoints[idx - 1][2] : z;
            continue;
        }
        else if (unit->IsWithinLOS(wanderX, wanderY, z))
        {
            bool is_water = map->IsInWater(unit->GetPhaseMask(), wanderX, wanderY, z, unit->GetCollisionHeight());
 
            if ((is_water && !is_water_ok) || (!is_water && !is_land_ok))
            {
                i_waypoints[idx][0] = idx > 0 ? i_waypoints[idx - 1][0] : x;
                i_waypoints[idx][1] = idx > 0 ? i_waypoints[idx - 1][1] : y;
                i_waypoints[idx][2] = idx > 0 ? i_waypoints[idx - 1][2] : z;
                continue;
            }
        }
        else
        {
            i_waypoints[idx][0] = idx > 0 ? i_waypoints[idx - 1][0] : x;
            i_waypoints[idx][1] = idx > 0 ? i_waypoints[idx - 1][1] : y;
            i_waypoints[idx][2] = idx > 0 ? i_waypoints[idx - 1][2] : z;
            continue;
        }
 
        //unit->UpdateAllowedPositionZ(wanderX, wanderY, z);
 
        i_waypoints[idx][0] = wanderX;
        i_waypoints[idx][1] = wanderY;
        i_waypoints[idx][2] = new_z;
    }
 
    // Xinef: Call movement immediately to broadcast movement packet
    // Xinef: Initial timer is set to 1 so update with 1
    i_nextMove = urand(1, MAX_CONF_WAYPOINTS);
    DoUpdate(unit, 1);
 
    unit->SetUnitFlag(UNIT_FLAG_CONFUSED);
    unit->AddUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_CONFUSED_MOVE);
}

References INVALID_HEIGHT, Map::IsInWater(), MAX_CONF_WAYPOINTS, Acore::NormalizeMapCoord(), rand_norm(), UNIT_FLAG_CONFUSED, UNIT_STATE_CONFUSED, UNIT_STATE_CONFUSED_MOVE, and urand().

DoReset()

template<class T >

template void ConfusedMovementGenerator< T >::DoReset

(

T *

)

{
    DoInitialize(unit);
}

DoUpdate()

template<class T >

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

{
    if (unit->HasUnitState(UNIT_STATE_NOT_MOVE) || unit->IsMovementPreventedByCasting())
    {
        unit->StopMoving();
        return true;
    }
 
    if (i_nextMoveTime.Passed())
    {
        // currently moving, update location
        unit->AddUnitState(UNIT_STATE_CONFUSED_MOVE);
 
        if (unit->movespline->Finalized())
        {
            i_nextMove = urand(1, MAX_CONF_WAYPOINTS);
            i_nextMoveTime.Reset(urand(600, 1200)); // Guessed
        }
    }
    else
    {
        // waiting for next move
        i_nextMoveTime.Update(diff);
        if (i_nextMoveTime.Passed())
        {
            // start moving
            unit->AddUnitState(UNIT_STATE_CONFUSED_MOVE);
 
            ASSERT(i_nextMove <= MAX_CONF_WAYPOINTS);
            float x = i_waypoints[i_nextMove][0];
            float y = i_waypoints[i_nextMove][1];
            float z = i_waypoints[i_nextMove][2];
            Movement::MoveSplineInit init(unit);
            init.MoveTo(x, y, z, true);
            init.Launch();
        }
    }
 
    return true;
}

References ASSERT, Movement::MoveSplineInit::Launch(), MAX_CONF_WAYPOINTS, Movement::MoveSplineInit::MoveTo(), UNIT_STATE_CONFUSED_MOVE, UNIT_STATE_NOT_MOVE, and urand().

GetMovementGeneratorType()

template<class T >

MovementGeneratorType ConfusedMovementGenerator< T >::GetMovementGeneratorType ( )

inlinevirtual

Implements MovementGenerator.

{ return CONFUSED_MOTION_TYPE; }

References CONFUSED_MOTION_TYPE.

Member Data Documentation

i_nextMove

template<class T >

uint32 ConfusedMovementGenerator< T >::i_nextMove

private

i_nextMoveTime

template<class T >

TimeTracker ConfusedMovementGenerator< T >::i_nextMoveTime

private

i_waypoints

template<class T >

float ConfusedMovementGenerator< T >::i_waypoints[MAX_CONF_WAYPOINTS+1][3]

private