#include <ConfusedMovementGenerator.h>

Public Member Functions
	ConfusedMovementGenerator ()

void	DoInitialize (T *)

void	DoFinalize (T *)

void	DoReset (T *)

bool	DoUpdate (T *, uint32)

MovementGeneratorType	GetMovementGeneratorType () const override

template<>
void	DoFinalize (Player *unit)

template<>
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	unitSpeedChanged ()

virtual bool	GetResetPosition (Unit *, float &, float &, float &)

Private Attributes
TimeTracker	i_nextMoveTime

float	i_x

float	i_y

float	i_z

Constructor & Destructor Documentation

template<class T >

ConfusedMovementGenerator< T >::ConfusedMovementGenerator ( )

inlineexplicit

29 : i_nextMoveTime(0), i_x(0), i_y(0), i_z(0) { }

ConfusedMovementGenerator::i_x

float i_x

Definition: ConfusedMovementGenerator.h:39

ConfusedMovementGenerator::i_z

float i_z

Definition: ConfusedMovementGenerator.h:39

ConfusedMovementGenerator::i_nextMoveTime

TimeTracker i_nextMoveTime

Definition: ConfusedMovementGenerator.h:38

ConfusedMovementGenerator::i_y

float i_y

Definition: ConfusedMovementGenerator.h:39

Member Function Documentation

template<class T >

void ConfusedMovementGenerator< T >::DoFinalize ( T * )

template<>

void ConfusedMovementGenerator< Player >::DoFinalize ( Player * unit )

 {
  unit->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_CONFUSED);
  unit->ClearUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_CONFUSED_MOVE);
  unit->StopMoving();
 }

template<>

void ConfusedMovementGenerator< Creature >::DoFinalize ( Creature * unit )

 {
  unit->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_CONFUSED);
  unit->ClearUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_CONFUSED_MOVE);
  if (unit->GetVictim())
  unit->SetTarget(unit->EnsureVictim()->GetGUID());
 }

Here is the call graph for this function:

template<class T >

template void ConfusedMovementGenerator< T >::DoInitialize ( T * )

 {
  unit->AddUnitState(UNIT_STATE_CONFUSED);
  unit->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_CONFUSED);
  unit->GetPosition(i_x, i_y, i_z);
 
  if (!unit->IsAlive() || unit->IsStopped())
  return;
 
  unit->StopMoving();
  unit->AddUnitState(UNIT_STATE_CONFUSED_MOVE);
 }

template<class T >

template void ConfusedMovementGenerator< T >::DoReset ( T * )

 {
  i_nextMoveTime.Reset(0);
 
  if (!unit->IsAlive() || unit->IsStopped())
  return;
 
  unit->StopMoving();
  unit->AddUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_CONFUSED_MOVE);
 }

template<class T >

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

 {
  if (unit->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED | UNIT_STATE_DISTRACTED))
  return true;
 
  if (i_nextMoveTime.Passed())
  {
  // currently moving, update location
  unit->AddUnitState(UNIT_STATE_CONFUSED_MOVE);
 
  if (unit->movespline->Finalized())
  i_nextMoveTime.Reset(urand(800, 1500));
  }
  else
  {
  // waiting for next move
  i_nextMoveTime.Update(diff);
  if (i_nextMoveTime.Passed())
  {
  // start moving
  unit->AddUnitState(UNIT_STATE_CONFUSED_MOVE);
 
  float dest = 4.0f * (float)rand_norm() - 2.0f;
 
  Position pos;
  pos.Relocate(i_x, i_y, i_z);
  unit->MovePositionToFirstCollision(pos, dest, 0.0f);
 
  PathGenerator path(unit);
  path.SetPathLengthLimit(30.0f);
  bool result = path.CalculatePath(pos.m_positionX, pos.m_positionY, pos.m_positionZ);
  if (!result || (path.GetPathType() & PATHFIND_NOPATH))
  {
  i_nextMoveTime.Reset(100);
  return true;
  }
 
  Movement::MoveSplineInit init(unit);
  init.MovebyPath(path.GetPath());
  init.SetWalk(true);
  init.Launch();
  }
  }
 
  return true;
 }