bool HomeMovementGenerator<Creature>::Update(Creature &owner, const uint32 time_diff)
{
CreatureTraveller traveller(owner);
i_destinationHolder.UpdateTraveller(traveller, time_diff);
if (time_diff > i_travel_timer)
{
owner.AddUnitMovementFlag(MOVEMENTFLAG_WALKING);
// restore orientation of not moving creature at returning to home
if (owner.GetDefaultMovementType() == IDLE_MOTION_TYPE)
{
//sLog->outDebug("Entering HomeMovement::GetDestination(z, y, z)");
owner.SetOrientation(ori);
WorldPacket packet;
owner.BuildHeartBeatMsg(&packet);
owner.SendMessageToSet(&packet, false);
}
owner.ClearUnitState(UNIT_STAT_EVADE);
owner.LoadCreaturesAddon(true);
owner.AI()->JustReachedHome();
return false;
}
i_travel_timer -= time_diff;
return true;
}
void Update(uint32 diff)
{
if (CageTimer)
{
if (CageTimer <= diff)
{
Creature *Magtheridon = instance->GetCreature(MagtheridonGUID);
if (Magtheridon && Magtheridon->isAlive())
{
Magtheridon->ClearUnitState(UNIT_STAT_STUNNED);
Magtheridon->AI()->AttackStart(Magtheridon->SelectNearestTarget(999));
}
CageTimer = 0;
} else CageTimer -= diff;
}
if (RespawnTimer)
{
if (RespawnTimer <= diff)
{
for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i)
{
if (Creature *Channeler = instance->GetCreature(*i))
{
if (Channeler->isAlive())
Channeler->AI()->EnterEvadeMode();
else
Channeler->Respawn();
}
}
RespawnTimer = 0;
} else RespawnTimer -= diff;
}
}
void FleeingMovementGenerator<Creature>::Finalize(Creature &owner)
{
owner.RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_FLEEING);
owner.ClearUnitState(UNIT_STATE_FLEEING|UNIT_STATE_FLEEING_MOVE);
if (owner.getVictim())
owner.SetTarget(owner.getVictim()->GetGUID());
}
bool WaypointMovementGenerator<Creature>::Update(Creature &creature, const uint32 &diff)
{
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (creature.HasUnitState(UNIT_STATE_NOT_MOVE))
{
creature.ClearUnitState(UNIT_STATE_ROAMING_MOVE);
return true;
}
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
return false;
if (Stopped())
{
if (CanMove(diff))
return StartMove(creature);
}
else
{
if (creature.IsStopped())
Stop(STOP_TIME_FOR_PLAYER);
else if (creature.movespline->Finalized())
{
OnArrived(creature);
return StartMove(creature);
}
}
return true;
}
void ConfusedMovementGenerator<Creature>::Finalize(Creature &unit)
{
unit.RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_CONFUSED);
unit.ClearUnitState(UNIT_STAT_CONFUSED|UNIT_STAT_CONFUSED_MOVE);
if (unit.getVictim())
unit.SetTarget(unit.getVictim()->GetGUID());
}
void EnterCombat(Unit* victim)
{
DoCastAOE(SPELL_ABILITATE_BALANCE_BAR);
if (instance)
{
instance->DoCastSpellOnPlayers(SPELL_ABILITATE_BALANCE_BAR);
instance->SetData(DATA_RHYOLITH_EVENT, IN_PROGRESS);
}
direction = 25;
phase1=true;
steertimer = 0;
me->SetReactState(REACT_PASSIVE);
me->SendMovementWalkMode();
moving = true;
me->SetSpeed(MOVE_WALK, 0.5f, true);
me->SetSpeed(MOVE_RUN, 0.5f, true);
me->SetWalk(true);
obsidian = me->AddAura(SPELL_OBSIDIAN_ARMOR, me);
if (obsidian)
obsidian->SetStackAmount(80);
DoZoneInCombat(me);
leftfoot = me->SummonCreature(LEFT_FOOT_RHYOLITH,
me->GetPositionX(),
me->GetPositionY(),
me->GetPositionZ() + 12.0f,
0,TEMPSUMMON_MANUAL_DESPAWN);
if (leftfoot)
{
leftfoot->EnterVehicle(me, 0);
leftfoot->ClearUnitState(UNIT_STATE_ONVEHICLE);
}
rightfoot = me->SummonCreature(RIGHT_FOOT_RHYOLITH,
me->GetPositionX(),
me->GetPositionY(),
me->GetPositionZ() + 12.0f,
0,TEMPSUMMON_MANUAL_DESPAWN);
if (rightfoot)
{
rightfoot->EnterVehicle(me, 1);
rightfoot->ClearUnitState(UNIT_STATE_ONVEHICLE);
}
events.ScheduleEvent(EVENT_UPDATE_PATH, 2000, 0, 0);
events.ScheduleEvent(EVENT_STOMP, 2000, 0, 0);
}
void HomeMovementGenerator<Creature>::Finalize(Creature& owner)
{
if (arrived)
{
owner.ClearUnitState(UNIT_STATE_EVADE);
owner.SetWalk(true);
owner.LoadCreaturesAddon(true);
owner.AI()->JustReachedHome();
}
}
bool
RandomMovementGenerator<Creature>::Update(Creature &creature, const uint32 diff)
{
if (creature.HasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED))
{
i_nextMoveTime.Update(i_nextMoveTime.GetExpiry()); // Expire the timer
creature.ClearUnitState(UNIT_STAT_ROAMING);
return true;
}
i_nextMoveTime.Update(diff);
if (i_destinationHolder.HasArrived() && !creature.IsStopped() && !creature.canFly())
creature.ClearUnitState(UNIT_STAT_ROAMING | UNIT_STAT_MOVE);
if (!i_destinationHolder.HasArrived() && creature.IsStopped())
creature.AddUnitState(UNIT_STAT_ROAMING);
CreatureTraveller traveller(creature);
if (i_destinationHolder.UpdateTraveller(traveller, diff, true))
{
if (i_nextMoveTime.Passed())
{
if (irand(0, RUNNING_CHANCE_RANDOMMV) > 0)
creature.AddUnitMovementFlag(MOVEMENTFLAG_WALKING);
_setRandomLocation(creature);
}
else if (creature.isPet() && creature.GetOwner() && !creature.IsWithinDist(creature.GetOwner(), PET_FOLLOW_DIST+2.5f))
{
creature.RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
_setRandomLocation(creature);
}
}
return true;
}
void HomeMovementGenerator<Creature>::_setTargetLocation(Creature & owner)
{
if (!&owner)
return;
if (owner.HasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED))
return;
float x, y, z;
owner.GetHomePosition(x, y, z, ori);
CreatureTraveller traveller(owner);
uint32 travel_time = i_destinationHolder.SetDestination(traveller, x, y, z);
modifyTravelTime(travel_time);
owner.ClearUnitState(uint32(UNIT_STAT_ALL_STATE & ~UNIT_STAT_EVADE));
}
bool RandomMovementGenerator<Creature>::Update(Creature &creature, const uint32 diff)
{
if (creature.HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED | UNIT_STATE_DISTRACTED))
{
i_nextMoveTime.Reset(0); // Expire the timer
creature.ClearUnitState(UNIT_STATE_ROAMING_MOVE);
return true;
}
if (creature.movespline->Finalized())
{
i_nextMoveTime.Update(diff);
if (i_nextMoveTime.Passed())
_setRandomLocation(creature);
}
return true;
}
void HomeMovementGenerator<Creature>::Finalize(Creature& owner)
{
if (arrived)
{
// Instant regen Health after EvadeMode
owner.SetFullHealth();
// Instant regen Mana after EvadeMode
if (owner.GetPowerType() == POWER_MANA)
owner.SetPower(POWER_MANA, owner.GetMaxPower(POWER_MANA));
// Instant Reset Rage after EvadeMode
if (owner.GetPowerType() == POWER_RAGE)
owner.SetPower(POWER_RAGE, 0);
owner.ClearUnitState(UNIT_STATE_EVADE);
owner.SetWalk(true);
owner.LoadCreaturesAddon(true);
owner.AI()->JustReachedHome();
}
}
void HomeMovementGenerator<Creature>::_setTargetLocation(Creature & owner)
{
if (owner.HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED | UNIT_STATE_DISTRACTED))
return;
Movement::MoveSplineInit init(owner);
float x, y, z, o;
// at apply we can select more nice return points base at current movegen
//if (owner.GetMotionMaster()->empty() || !owner.GetMotionMaster()->top()->GetResetPosition(owner, x, y, z))
//{
owner.GetHomePosition(x, y, z, o);
init.SetFacing(o);
//}
init.MoveTo(x, y, z, true);
init.SetWalk(false);
init.Launch();
arrived = false;
owner.ClearUnitState(UNIT_STATE_ALL_STATE & ~UNIT_STATE_EVADE);
}
void WaypointMovementGenerator<Creature>::OnArrived(Creature& creature)
{
if (!i_path || i_path->empty())
return;
if (m_isArrivalDone)
return;
creature.ClearUnitState(UNIT_STAT_ROAMING_MOVE);
m_isArrivalDone = true;
if (i_path->at(i_currentNode)->event_id && urand(0, 99) < i_path->at(i_currentNode)->event_chance)
{
sLog->outDebug(LOG_FILTER_MAPSCRIPTS, "Creature movement start script %u at point %u for %u.", i_path->at(i_currentNode)->event_id, i_currentNode, creature.GetGUID());
creature.GetMap()->ScriptsStart(sWaypointScripts, i_path->at(i_currentNode)->event_id, &creature, NULL/*, false*/);
}
// Inform script
MovementInform(creature);
Stop(i_path->at(i_currentNode)->delay);
}
void HomeMovementGenerator<Creature>::Finalize(Creature & owner)
{
owner.ClearUnitState(UNIT_STAT_EVADE);
}
void WaypointMovementGenerator<Creature>::Finalize(Creature &creature)
{
creature.ClearUnitState(UNIT_STATE_ROAMING|UNIT_STATE_ROAMING_MOVE);
creature.SetWalk(false);
}
bool
WaypointMovementGenerator<Creature>::Update(Creature &unit, const uint32 &diff)
{
if (!&unit)
return true;
if (!path_id)
return false;
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (unit.HasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED))
return true;
// Clear the generator if the path doesn't exist
if (!waypoints || !waypoints->size())
return false;
Traveller<Creature> traveller(unit);
i_nextMoveTime.Update(diff);
i_destinationHolder.UpdateTraveller(traveller, diff, true);
if (i_nextMoveTime.GetExpiry() < TIMEDIFF_NEXT_WP)
{
if (unit.IsStopped())
{
if (StopedByPlayer)
{
ASSERT(node);
InitTraveller(unit, *node);
i_destinationHolder.SetDestination(traveller, node->x, node->y, node->z);
i_nextMoveTime.Reset(i_destinationHolder.GetTotalTravelTime());
StopedByPlayer = false;
return true;
}
if (i_currentNode == waypoints->size() - 1) // If that's our last waypoint
{
if (repeating) // If the movement is repeating
i_currentNode = 0; // Start moving all over again
else
{
unit.SetHomePosition(node->x, node->y, node->z, unit.GetOrientation());
unit.GetMotionMaster()->Initialize();
return false; // Clear the waypoint movement
}
}
else
++i_currentNode;
node = waypoints->at(i_currentNode);
InitTraveller(unit, *node);
i_destinationHolder.SetDestination(traveller, node->x, node->y, node->z);
i_nextMoveTime.Reset(i_destinationHolder.GetTotalTravelTime());
//Call for creature group update
if (unit.GetFormation() && unit.GetFormation()->getLeader() == &unit)
unit.GetFormation()->LeaderMoveTo(node->x, node->y, node->z);
}
else
{
//Determine waittime
if (node->delay)
i_nextMoveTime.Reset(node->delay);
//note: disable "start" for mtmap
if (node->event_id && urand(0,99) < node->event_chance)
unit.GetMap()->ScriptsStart(sWaypointScripts, node->event_id, &unit, NULL/*, false*/);
i_destinationHolder.ResetTravelTime();
MovementInform(unit);
unit.UpdateWaypointID(i_currentNode);
unit.ClearUnitState(UNIT_STAT_ROAMING);
unit.Relocate(node->x, node->y, node->z);
}
}
else
{
if (unit.IsStopped() && !i_destinationHolder.HasArrived())
{
if (!StopedByPlayer)
{
i_destinationHolder.IncreaseTravelTime(STOP_TIME_FOR_PLAYER);
i_nextMoveTime.Reset(STOP_TIME_FOR_PLAYER);
StopedByPlayer = true;
}
}
}
return true;
}
void RandomMovementGenerator<Creature>::Interrupt(Creature &creature)
{
creature.ClearUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
creature.SetWalk(false);
}
void RandomMovementGenerator<Creature>::Finalize(Creature& creature)
{
creature.ClearUnitState(UNIT_STATE_ROAMING);
creature.SetWalk(!creature.HasUnitState(UNIT_STATE_RUNNING_STATE));
}