void PointMovementGenerator<T>::Initialize(T &unit)
{
unit.StopMoving();
Traveller<T> traveller(unit);
// OLD: knockback effect has UNIT_STAT_JUMPING set, so if here we disable sentmonstermove there will be creature position sync problem between client and server
// NEW: reactivated this check - UNIT_STAT_JUMPING is only used in MoveJump, which sends its own packet
//i_destinationHolder.SetDestination(traveller, i_x, i_y, i_z, !m_usePathfinding);
if (m_usePathfinding)
{
PathInfo path(&unit, i_x, i_y, i_z);
PointPath pointPath = path.getFullPath();
float speed = traveller.Speed() * 0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength() / speed);
if (unit.GetTypeId() != TYPEID_UNIT)
unit.SetUnitMovementFlags(SPLINEFLAG_WALKING);
unit.SendMonsterMoveByPath(pointPath, 1, pointPath.size(), traveltime);
PathNode p = pointPath[pointPath.size()-1];
i_destinationHolder.SetDestination(traveller, p.x, p.y, p.z, false);
}
else
i_destinationHolder.SetDestination(traveller, i_x, i_y, i_z, /*true*/ !unit.HasUnitState(UNIT_STAT_JUMPING));
}
void PointMovementGenerator<T>::Initialize(T& unit)
{
if (!unit.IsStopped())
unit.StopMoving();
unit.addUnitState(UNIT_STAT_ROAMING | UNIT_STAT_ROAMING_MOVE);
Traveller<T> traveller(unit);
if (m_usePathfinding)
{
PathInfo path(&unit, i_x, i_y, i_z);
PointPath pointPath = path.getFullPath();
float speed = traveller.Speed() * 0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength() / speed);
SplineFlags flags = (unit.GetTypeId() == TYPEID_UNIT) ? ((Creature*)&unit)->GetSplineFlags() : SPLINEFLAG_WALKMODE;
unit.SendMonsterMoveByPath(pointPath, 1, pointPath.size(), flags, traveltime);
PathNode p = pointPath[pointPath.size() - 1];
i_destinationHolder.SetDestination(traveller, p.x, p.y, p.z, false);
}
else
i_destinationHolder.SetDestination(traveller, i_x, i_y, i_z, true);
if (unit.GetTypeId() == TYPEID_UNIT && ((Creature*)&unit)->CanFly())
((Creature&)unit).AddSplineFlag(SPLINEFLAG_FLYING);
}
static bool HandleMmapPathCommand(ChatHandler* handler, const char* args)
{
if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
}
handler->PSendSysMessage("mmap path:");
// units
Player* player = handler->GetSession()->GetPlayer();
Unit* target = handler->getSelectedUnit();
if (!player || !target)
{
handler->PSendSysMessage("Invalid target/source selection.");
return true;
}
char* para = strtok((char*)args, " ");
bool useStraightPath = false;
if (para && strcmp(para, "true") == 0)
useStraightPath = true;
// unit locations
float x, y, z;
player->GetPosition(x, y, z);
// path
PathInfo path(target, x, y, z, useStraightPath);
PointPath pointPath = path.getFullPath();
handler->PSendSysMessage("%s's path to %s:", target->GetName(), player->GetName());
handler->PSendSysMessage("Building %s", useStraightPath ? "StraightPath" : "SmoothPath");
handler->PSendSysMessage("length %i type %u", pointPath.size(), path.getPathType());
PathNode start = path.getStartPosition();
PathNode next = path.getNextPosition();
PathNode end = path.getEndPosition();
PathNode actualEnd = path.getActualEndPosition();
handler->PSendSysMessage("start (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
handler->PSendSysMessage("next (%.3f, %.3f, %.3f)", next.x, next.y, next.z);
handler->PSendSysMessage("end (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
handler->PSendSysMessage("actual end (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
if (!player->isGameMaster())
handler->PSendSysMessage("Enable GM mode to see the path points.");
// this entry visible only to GM's with "gm on"
static const uint32 WAYPOINT_NPC_ENTRY = 1;
for (uint32 i = 0; i < pointPath.size(); ++i)
player->SummonCreature(WAYPOINT_NPC_ENTRY, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
return true;
}
void
HomeMovementGenerator<Creature>::_setTargetLocation(Creature & owner)
{
if (owner.hasUnitState(UNIT_STAT_NOT_MOVE))
return;
float x, y, z;
// 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.GetRespawnCoord(x, y, z);
CreatureTraveller traveller(owner);
i_destinationHolder.SetDestination(traveller, x, y, z, false);
PathInfo path(&owner, x, y, z);
PointPath pointPath = path.getFullPath();
float speed = traveller.Speed() * 0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength() / speed);
modifyTravelTime(traveltime);
owner.SendMonsterMoveByPath(pointPath, 1, pointPath.size(), owner.GetSplineFlags(), traveltime);
owner.clearUnitState(UNIT_STAT_ALL_STATE);
}
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);
i_destinationHolder.SetDestination(traveller, x, y, z, false);
PathInfo path(&owner, x, y, z, true);
PointPath pointPath = path.getFullPath();
float speed = traveller.Speed() * 0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength() / speed);
modifyTravelTime(traveltime);
owner.SendMonsterMoveByPath(pointPath, 1, pointPath.size(), traveltime);
owner.clearUnitState(UNIT_STAT_ALL_STATE);
}
void
WaypointMovementGenerator<Creature>::MoveToNextNode(CreatureTraveller &traveller)
{
Creature* owner = &(traveller.i_traveller);
PathInfo sub_path(owner, node->x, node->y, node->z);
PointPath pointPath = sub_path.getFullPath();
float speed = traveller.Speed()*0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength()/speed);
owner->SendMonsterMoveByPath(pointPath, 1, pointPath.size(), traveltime);
PathNode p = pointPath[pointPath.size()-1];
i_destinationHolder.SetDestination(traveller, p.x, p.y, p.z, false);
i_nextMoveTime.Reset(traveltime);
}
bool NavigationMesh::makeSpline(PointPath& path) {
if( path.size() < 2 )
return false;
PointPath::iterator p0, p1, p2, p3;
p0 = p1 = path.begin();
++p1;
Ogre::Vector3 pextra = *p0 - ((*p1 - *p0).normalise() * 0.5);
path.push_front(pextra);
p0 = p1 = path.end();
--p1;
--p0;
--p0;
pextra = *p1 + ((*p1 - *p0).normalise() * 0.5);
path.push_back(pextra);
int dotsPerUnit = 2;
p0 = path.begin();
p1 = p0;
++p1;
p2 = p1;
++p2;
p3 = p2;
++p3;
while( p3 != path.end() ){
int n = (*p1 - *p2).length() * dotsPerUnit;
Ogre::Real step = 1.0/n;
Ogre::Real s = step;
for(int i = 1; i < n; ++i) {
path.insert(p2, CatmullRollSpline(*p0, *p1, *p2, *p3, s));
s += step;
}
p0 = p1;
p1 = p2;
++p2;
++p3;
}
path.pop_front();
path.pop_back();
return true;
}
void WaypointMovementGenerator<Creature>::MoveToNextNode(CreatureTraveller &traveller)
{
Creature* owner = &(traveller.i_traveller);
const WaypointNode &node = i_path->at(i_currentNode);
PathInfo sub_path(owner, node.x, node.y, node.z);
PointPath pointPath = sub_path.getFullPath();
float speed = traveller.Speed()*0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength()/speed);
owner->SendMonsterMoveByPath(pointPath, 1, pointPath.size(), owner->GetSplineFlags(), traveltime);
if (owner->GetFormation() && (owner->GetFormation())->getLeader() == owner) //Formation movement
(owner->GetFormation())->LeaderMoveTo(node.x, node.y, node.z);
PathNode p = pointPath[pointPath.size()-1];
i_destinationHolder.SetDestination(traveller, p.x, p.y, p.z, false);
i_nextMoveTime.Reset(traveltime);
}
void PointMovementGenerator<T>::Initialize(T &unit)
{
unit.StopMoving();
Traveller<T> traveller(unit);
if (m_usePathfinding)
{
PathInfo path(&unit, i_x, i_y, i_z);
PointPath pointPath = path.getFullPath();
float speed = traveller.Speed() * 0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength() / speed);
if (unit.GetTypeId() != TYPEID_UNIT)
unit.SetUnitMovementFlags(SPLINEFLAG_WALKMODE);
unit.SendMonsterMoveByPath(pointPath, 1, pointPath.size(), traveltime);
PathNode p = pointPath[pointPath.size()-1];
i_destinationHolder.SetDestination(traveller, p.x, p.y, p.z, false);
}
else
i_destinationHolder.SetDestination(traveller, i_x, i_y, i_z, true);
}
bool TargetedMovementGenerator<T>::_setTargetLocation(T &owner)
{
if (!i_target.isValid() || !i_target->IsInWorld())
return false;
if (owner.hasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED))
return false;
float x, y, z;
Traveller<T> traveller(owner);
if (i_destinationHolder.HasDestination() && !m_pathPointsSent)
{
if (i_destinationHolder.HasArrived())
{
// prevent redundant micro-movement
if (!i_offset)
{
if (i_target->IsWithinMeleeRange(&owner))
return false;
}
else if (!i_angle && !owner.hasUnitState(UNIT_STAT_FOLLOW))
{
if (i_target->IsWithinDistInMap(&owner, i_offset))
return false;
}
else
{
if (i_target->IsWithinDistInMap(&owner, i_offset + 1.0f))
return false;
}
}
else
{
bool stop = false;
if (!i_offset)
{
if (i_target->IsWithinMeleeRange(&owner, 0.0f))
stop = true;
}
else if (!i_angle && !owner.hasUnitState(UNIT_STAT_FOLLOW))
{
if (i_target->IsWithinDist(&owner, i_offset * 0.8f))
stop = true;
}
if (stop)
{
owner.GetPosition(x, y, z);
if (owner.GetTypeId() == TYPEID_UNIT && (owner.HasUnitMovementFlag(MOVEFLAG_CAN_FLY) || owner.IsInWater() || i_target->IsInWater()))
z = i_target->GetPositionZ();
if(m_usePathfinding)
{
bool newPathCalculated = true;
if (!i_path)
i_path = new PathInfo(&owner, x, y, z);
else
newPathCalculated = i_path->Update(x, y, z);
// nothing we can do here ...
if(i_path->getPathType() & PATHFIND_NOPATH)
return true;
PointPath pointPath = i_path->getFullPath();
if (i_destinationHolder.HasArrived() && m_pathPointsSent)
--m_pathPointsSent;
i_path->getNextPosition(x, y, z);
i_destinationHolder.SetDestination(traveller, x, y, z, false);
// send the path if:
// we have brand new path
// we have visited almost all of the previously sent points
// movespeed has changed
// the owner is stopped (caused by some movement effects)
if (newPathCalculated || m_pathPointsSent < 2 || i_recalculateTravel || owner.IsStopped())
{
// send 10 nodes, or send all nodes if there are less than 10 left
m_pathPointsSent = std::min<uint32>(10, pointPath.size() - 1);
uint32 endIndex = m_pathPointsSent + 1;
// dist to next node + world-unit length of the path
x -= owner.GetPositionX();
y -= owner.GetPositionY();
z -= owner.GetPositionZ();
float dist = sqrt(x*x + y*y + z*z) + pointPath.GetTotalLength(1, endIndex);
// calculate travel time, set spline, then send path
uint32 traveltime = uint32(dist / (traveller.Speed()*0.001f));
owner.SendMonsterMoveByPath(pointPath, 1, endIndex, traveltime);
return false;
}
}
else
{
i_destinationHolder.SetDestination(traveller, x, y, z);
i_destinationHolder.StartTravel(traveller, false);
owner.StopMoving();
return false;
}
}
}
if (i_target->GetExactDistSq(i_targetX, i_targetY, i_targetZ) < 0.01f)
return false;
}
if (!i_offset)
{
// to nearest random contact position
i_target->GetRandomContactPoint(&owner, x, y, z, 0, MELEE_RANGE - 0.5f);
}
else if (!i_angle && !owner.hasUnitState(UNIT_STAT_FOLLOW))
{
// caster chase
i_target->GetContactPoint(&owner, x, y, z, i_offset * urand(80, 95) * 0.01f);
}
else
{
// to at i_offset distance from target and i_angle from target facing
i_target->GetClosePoint(x, y, z, owner.GetObjectSize(), i_offset,i_angle);
}
/*
We MUST not check the distance difference and avoid setting the new location for smaller distances.
By that we risk having far too many GetContactPoint() calls freezing the whole system.
In TargetedMovementGenerator<T>::Update() we check the distance to the target and at
some range we calculate a new position. The calculation takes some processor cycles due to vmaps.
If the distance to the target it too large to ignore,
but the distance to the new contact point is short enough to be ignored,
we will calculate a new contact point each update loop, but will never move to it.
The system will freeze.
ralf
//We don't update Mob Movement, if the difference between New destination and last destination is < BothObjectSize
float bothObjectSize = i_target->GetObjectSize() + owner.GetObjectSize() + CONTACT_DISTANCE;
if (i_destinationHolder.HasDestination() && i_destinationHolder.GetDestinationDiff(x,y,z) < bothObjectSize)
return;
*/
//i_destinationHolder.SetDestination(traveller, x, y, z);
if(m_usePathfinding)
{
bool forceDest = false;
// allow pets to cheat while generating paths as they should ALWAYS be able to reach thier target.
if (owner.GetTypeId() == TYPEID_UNIT
&& owner.ToCreature()
&& owner.ToCreature()->isPet())
forceDest = true;
bool newPathCalculated = true;
if (!i_path)
i_path = new PathInfo(&owner, x, y, z, forceDest);
else
newPathCalculated = i_path->Update(x, y, z, forceDest);
// nothing we can do here ...
if (i_path->getPathType() & PATHFIND_NOPATH)
return true;
if (i_destinationHolder.HasArrived() && m_pathPointsSent)
--m_pathPointsSent;
i_path->getNextPosition(x, y, z);
i_destinationHolder.SetDestination(traveller, x, y, z, false);
// send the path if:
// we have brand new path
// we have visited almost all of the previously sent points
// movespeed has changed
// the owner is stopped (caused by some movement effects)
if (newPathCalculated || m_pathPointsSent < 2 || i_recalculateTravel || owner.IsStopped())
{
PointPath pointPath = i_path->getFullPath();
// send 10 nodes, or send all nodes if there are less than 10 left
m_pathPointsSent = std::min<uint32>(10, pointPath.size() - 1);
uint32 endIndex = m_pathPointsSent + 1;
// dist to next node + world-unit length of the path
x -= owner.GetPositionX();
y -= owner.GetPositionY();
z -= owner.GetPositionZ();
float dist = sqrt(x*x + y*y + z*z) + pointPath.GetTotalLength(1, endIndex);
// calculate travel time, set spline, then send path
uint32 traveltime = uint32(dist / (traveller.Speed()*0.001f));
owner.SendMonsterMoveByPath(pointPath, 1, endIndex, traveltime);
}
owner.addUnitState(UNIT_STAT_CHASE);
}
else
{
i_destinationHolder.SetDestination(traveller, x, y, z);
owner.addUnitState(UNIT_STAT_CHASE);
i_destinationHolder.StartTravel(traveller);
}
}
bool ConfusedMovementGenerator<T>::Update(T &unit, const uint32 &diff)
{
if(!&unit)
return true;
// ignore in case other no reaction state
if (unit.hasUnitState(UNIT_STAT_CAN_NOT_REACT & ~UNIT_STAT_CONFUSED))
return true;
if (i_nextMoveTime.Passed())
{
// currently moving, update location
unit.addUnitState(UNIT_STAT_CONFUSED_MOVE);
Traveller<T> traveller(unit);
if (i_destinationHolder.UpdateTraveller(traveller, diff, false))
{
if (!IsActive(unit)) // force stop processing (movement can move out active zone with cleanup movegens list)
return true; // not expire now, but already lost
if (i_destinationHolder.HasArrived())
{
// arrived, stop and wait a bit
unit.StopMoving();
i_nextMoveTime.Reset(urand(800, 1500));
}
}
}
else
{
// waiting for next move
i_nextMoveTime.Update(diff);
if(i_nextMoveTime.Passed())
{
// start moving
unit.addUnitState(UNIT_STAT_CONFUSED_MOVE);
float x = i_x + 10.0f*(rand_norm_f() - 0.5f);
float y = i_y + 10.0f*(rand_norm_f() - 0.5f);
float z = i_z;
unit.UpdateAllowedPositionZ(x, y, z);
Traveller<T> traveller(unit);
PathInfo path(&unit, x, y, z);
if(!(path.getPathType() & PATHFIND_NORMAL))
{
i_nextMoveTime.Reset(urand(800, 1000));
return true;
}
PointPath pointPath = path.getFullPath();
float speed = traveller.Speed() * 0.001f; // in ms
uint32 traveltime = uint32(pointPath.GetTotalLength() / speed);
SplineFlags flags = (unit.GetTypeId() == TYPEID_UNIT) ? ((Creature*)&unit)->GetSplineFlags() : SPLINEFLAG_WALKMODE;
unit.SendMonsterMoveByPath(pointPath, 1, std::min<uint32>(pointPath.size(), 5), flags, traveltime);
PathNode p = pointPath[std::min<uint32>(pointPath.size()-1, 4)];
// we do not really need it with mmaps active
unit.UpdateAllowedPositionZ(p.x, p.y, p.z);
i_destinationHolder.SetDestination(traveller, p.x, p.y, p.z, false);
}
}
return true;
}
void TargetedMovementGeneratorMedium<T,D>::_setTargetLocation(T &owner)
{
if (!i_target.isValid() || !i_target->IsInWorld())
return;
if (owner.hasUnitState(UNIT_STAT_NOT_MOVE))
return;
float x, y, z;
// prevent redundant micro-movement for pets, other followers.
if (i_offset && i_target->IsWithinDistInMap(&owner,2*i_offset))
{
if (i_destinationHolder.HasDestination())
return;
owner.GetPosition(x, y, z);
}
else if (!i_offset)
{
// to nearest contact position
i_target->GetContactPoint( &owner, x, y, z );
}
else
{
// to at i_offset distance from target and i_angle from target facing
i_target->GetClosePoint(x, y, z, owner.GetObjectBoundingRadius(), i_offset, i_angle, &owner);
}
/*
We MUST not check the distance difference and avoid setting the new location for smaller distances.
By that we risk having far too many GetContactPoint() calls freezing the whole system.
In TargetedMovementGenerator<T>::Update() we check the distance to the target and at
some range we calculate a new position. The calculation takes some processor cycles due to vmaps.
If the distance to the target it too large to ignore,
but the distance to the new contact point is short enough to be ignored,
we will calculate a new contact point each update loop, but will never move to it.
The system will freeze.
ralf
//We don't update Mob Movement, if the difference between New destination and last destination is < BothObjectSize
float bothObjectSize = i_target->GetObjectBoundingRadius() + owner.GetObjectBoundingRadius() + CONTACT_DISTANCE;
if( i_destinationHolder.HasDestination() && i_destinationHolder.GetDestinationDiff(x,y,z) < bothObjectSize )
return;
*/
//ACE_High_Res_Timer timer = ACE_High_Res_Timer();
//ACE_hrtime_t elapsed;
//timer.start();
bool forceDest = false;
// allow pets following their master to cheat while generating paths
if(owner.GetTypeId() == TYPEID_UNIT && ((Creature*)&owner)->IsPet()
&& owner.hasUnitState(UNIT_STAT_FOLLOW))
forceDest = true;
bool newPathCalculated = true;
if(!i_path)
i_path = new PathInfo(&owner, x, y, z, false, forceDest);
else
newPathCalculated = i_path->Update(x, y, z, false, forceDest);
//timer.stop();
//timer.elapsed_microseconds(elapsed);
//sLog.outDebug("Path found in %llu microseconds", elapsed);
// nothing we can do here ...
if(i_path->getPathType() & PATHFIND_NOPATH)
return;
PointPath pointPath = i_path->getFullPath();
if (i_destinationHolder.HasArrived() && m_pathPointsSent)
--m_pathPointsSent;
Traveller<T> traveller(owner);
i_path->getNextPosition(x, y, z);
i_destinationHolder.SetDestination(traveller, x, y, z, false);
// send the path if:
// we have brand new path
// we have visited almost all of the previously sent points
// movespeed has changed
// the owner is stopped (caused by some movement effects)
if (newPathCalculated || m_pathPointsSent < 2 || i_recalculateTravel || owner.IsStopped())
{
// send 10 nodes, or send all nodes if there are less than 10 left
m_pathPointsSent = std::min<uint32>(10, pointPath.size() - 1);
uint32 endIndex = m_pathPointsSent + 1;
// dist to next node + world-unit length of the path
x -= owner.GetPositionX();
y -= owner.GetPositionY();
z -= owner.GetPositionZ();
float dist = sqrt(x*x + y*y + z*z) + pointPath.GetTotalLength(1, endIndex);
// calculate travel time, set spline, then send path
uint32 traveltime = uint32(dist / (traveller.Speed()*0.001f));
SplineFlags flags = (owner.GetTypeId() == TYPEID_UNIT) ? ((Creature*)&owner)->GetSplineFlags() : SPLINEFLAG_WALKMODE;
owner.SendMonsterMoveByPath(pointPath, 1, endIndex, flags, traveltime);
}
D::_addUnitStateMove(owner);
if (owner.GetTypeId() == TYPEID_UNIT && ((Creature*)&owner)->CanFly())
((Creature&)owner).AddSplineFlag(SPLINEFLAG_FLYING);
}
