diff options
Diffstat (limited to 'src')
9 files changed, 211 insertions, 215 deletions
diff --git a/src/server/game/Movement/MotionMaster.cpp b/src/server/game/Movement/MotionMaster.cpp index bf938c3af6c..34be779a8b7 100644 --- a/src/server/game/Movement/MotionMaster.cpp +++ b/src/server/game/Movement/MotionMaster.cpp @@ -425,12 +425,12 @@ void MotionMaster::MoveCharge(float x, float y, float z, float speed, uint32 id, void MotionMaster::MoveCharge(PathGenerator path, float speed, uint32 id) { - Vector3 dest = path.getActualEndPosition(); + Vector3 dest = path.GetActualEndPosition(); MoveCharge(dest.x, dest.y, dest.z); Movement::MoveSplineInit init(_owner); - init.MovebyPath(path.getPath()); + init.MovebyPath(path.GetPath()); init.SetVelocity(speed); init.Launch(); } diff --git a/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp index f1d1d8cf04a..32c6ec3858d 100755 --- a/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/ConfusedMovementGenerator.cpp @@ -77,16 +77,16 @@ bool ConfusedMovementGenerator<T>::Update(T* unit, const uint32& diff) unit->UpdateAllowedPositionZ(x, y, z); PathGenerator path(unit); - path.setPathLengthLimit(30.0f); + path.SetPathLengthLimit(30.0f); path.CalculatePath(x, y, z); - if (path.getPathType() & PATHFIND_NOPATH) + if (path.GetPathType() & PATHFIND_NOPATH) { i_nextMoveTime.Reset(urand(800, 1000)); return true; } Movement::MoveSplineInit init(unit); - init.MovebyPath(path.getPath()); + init.MovebyPath(path.GetPath()); init.SetWalk(true); init.Launch(); } diff --git a/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp index acb1a57a9ba..8f4d78b34b1 100755 --- a/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp @@ -44,16 +44,16 @@ void FleeingMovementGenerator<T>::_setTargetLocation(T* owner) owner->AddUnitState(UNIT_STATE_FLEEING_MOVE); PathGenerator path(owner); - path.setPathLengthLimit(30.0f); + path.SetPathLengthLimit(30.0f); path.CalculatePath(x, y, z); - if (path.getPathType() & PATHFIND_NOPATH) + if (path.GetPathType() & PATHFIND_NOPATH) { i_nextCheckTime.Reset(urand(1000, 1500)); return; } Movement::MoveSplineInit init(owner); - init.MovebyPath(path.getPath()); + init.MovebyPath(path.GetPath()); init.SetWalk(false); int32 traveltime = init.Launch(); i_nextCheckTime.Reset(traveltime + urand(800, 1500)); diff --git a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp index 9784c19b4fd..4a8d15b8079 100755 --- a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp @@ -70,7 +70,7 @@ void TargetedMovementGeneratorMedium<T,D>::_setTargetLocation(T* owner) bool forceDest = (owner->GetTypeId() == TYPEID_UNIT && owner->ToCreature()->isPet() && owner->HasUnitState(UNIT_STATE_FOLLOW)); i_path->CalculatePath(x, y, z, forceDest); - if (i_path->getPathType() & PATHFIND_NOPATH) + if (i_path->GetPathType() & PATHFIND_NOPATH) return; D::_addUnitStateMove(owner); @@ -79,7 +79,7 @@ void TargetedMovementGeneratorMedium<T,D>::_setTargetLocation(T* owner) owner->AddUnitState(UNIT_STATE_CHASE); Movement::MoveSplineInit init(owner); - init.MovebyPath(i_path->getPath()); + init.MovebyPath(i_path->GetPath()); init.SetWalk(((D*)this)->EnableWalking()); init.Launch(); } diff --git a/src/server/game/Movement/PathGenerator.cpp b/src/server/game/Movement/PathGenerator.cpp index 00aa8043312..165cc282e3a 100644 --- a/src/server/game/Movement/PathGenerator.cpp +++ b/src/server/game/Movement/PathGenerator.cpp @@ -28,69 +28,69 @@ ////////////////// PathGenerator ////////////////// PathGenerator::PathGenerator(const Unit* owner) : - m_polyLength(0), m_type(PATHFIND_BLANK), - m_useStraightPath(false), m_forceDestination(false), m_pointPathLimit(MAX_POINT_PATH_LENGTH), - m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL), m_endPosition(Vector3::zero()) + _polyLength(0), _type(PATHFIND_BLANK), + _useStraightPath(false), _forceDestination(false), _pointPathLimit(MAX_POINT_PATH_LENGTH), + _sourceUnit(owner), _navMesh(NULL), _navMeshQuery(NULL), _endPosition(Vector3::zero()) { - sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::PathGenerator for %u \n", m_sourceUnit->GetGUIDLow()); + sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::PathGenerator for %u \n", _sourceUnit->GetGUIDLow()); - uint32 mapId = m_sourceUnit->GetMapId(); + uint32 mapId = _sourceUnit->GetMapId(); if (MMAP::MMapFactory::IsPathfindingEnabled(mapId)) { MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager(); - m_navMesh = mmap->GetNavMesh(mapId); - m_navMeshQuery = mmap->GetNavMeshQuery(mapId, m_sourceUnit->GetInstanceId()); + _navMesh = mmap->GetNavMesh(mapId); + _navMeshQuery = mmap->GetNavMeshQuery(mapId, _sourceUnit->GetInstanceId()); } - createFilter(); + CreateFilter(); } PathGenerator::~PathGenerator() { - sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::~PathGenerator() for %u \n", m_sourceUnit->GetGUIDLow()); + sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::~PathGenerator() for %u \n", _sourceUnit->GetGUIDLow()); } bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool forceDest) { float x, y, z; - m_sourceUnit->GetPosition(x, y, z); + _sourceUnit->GetPosition(x, y, z); if (!Trinity::IsValidMapCoord(destX, destY, destZ) || !Trinity::IsValidMapCoord(x, y, z)) return false; - Vector3 oldDest = getEndPosition(); + Vector3 oldDest = GetEndPosition(); Vector3 dest(destX, destY, destZ); - setEndPosition(dest); + SetEndPosition(dest); Vector3 start(x, y, z); - setStartPosition(start); + SetStartPosition(start); - m_forceDestination = forceDest; + _forceDestination = forceDest; - sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::CalculatePath() for %u \n", m_sourceUnit->GetGUIDLow()); + sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::CalculatePath() for %u \n", _sourceUnit->GetGUIDLow()); // make sure navMesh works - we can run on map w/o mmap // check if the start and end point have a .mmtile loaded (can we pass via not loaded tile on the way?) - if (!m_navMesh || !m_navMeshQuery || m_sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING) || + if (!_navMesh || !_navMeshQuery || _sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING) || !HaveTile(start) || !HaveTile(dest)) { BuildShortcut(); - m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); + _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); return true; } - updateFilter(); + UpdateFilter(); // check if destination moved - if not we can optimize something here // we are following old, precalculated path? - float dist = m_sourceUnit->GetObjectSize(); - if (oldDest != Vector3::zero() && inRange(oldDest, dest, dist, dist) && m_pathPoints.size() > 2) + float dist = _sourceUnit->GetObjectSize(); + if (oldDest != Vector3::zero() && InRange(oldDest, dest, dist, dist) && _pathPoints.size() > 2) { // our target is not moving - we just coming closer // we are moving on precalculated path - enjoy the ride sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::CalculatePath:: precalculated path\n"); - m_pathPoints.erase(m_pathPoints.begin()); + _pathPoints.erase(_pathPoints.begin()); return false; } else @@ -101,7 +101,7 @@ bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool fo } } -dtPolyRef PathGenerator::getPathPolyByPosition(const dtPolyRef *polyPath, uint32 polyPathSize, const float* point, float *distance) const +dtPolyRef PathGenerator::GetPathPolyByPosition(dtPolyRef const* polyPath, uint32 polyPathSize, float const* point, float* distance) const { if (!polyPath || !polyPathSize) return INVALID_POLYREF; @@ -113,7 +113,7 @@ dtPolyRef PathGenerator::getPathPolyByPosition(const dtPolyRef *polyPath, uint32 for (uint32 i = 0; i < polyPathSize; ++i) { float closestPoint[VERTEX_SIZE]; - if (DT_SUCCESS != m_navMeshQuery->closestPointOnPoly(polyPath[i], point, closestPoint)) + if (DT_SUCCESS != _navMeshQuery->closestPointOnPoly(polyPath[i], point, closestPoint)) continue; float d = dtVdist2DSqr(point, closestPoint); @@ -134,12 +134,12 @@ dtPolyRef PathGenerator::getPathPolyByPosition(const dtPolyRef *polyPath, uint32 return (minDist2d < 3.0f) ? nearestPoly : INVALID_POLYREF; } -dtPolyRef PathGenerator::getPolyByLocation(const float* point, float *distance) const +dtPolyRef PathGenerator::GetPolyByLocation(float const* point, float* distance) const { // first we check the current path // if the current path doesn't contain the current poly, // we need to use the expensive navMesh.findNearestPoly - dtPolyRef polyRef = getPathPolyByPosition(m_pathPolyRefs, m_polyLength, point, distance); + dtPolyRef polyRef = GetPathPolyByPosition(_pathPolyRefs, _polyLength, point, distance); if (polyRef != INVALID_POLYREF) return polyRef; @@ -148,7 +148,7 @@ dtPolyRef PathGenerator::getPolyByLocation(const float* point, float *distance) // first try with low search box float extents[VERTEX_SIZE] = {3.0f, 5.0f, 3.0f}; // bounds of poly search area float closestPoint[VERTEX_SIZE] = {0.0f, 0.0f, 0.0f}; - dtStatus result = m_navMeshQuery->findNearestPoly(point, extents, &m_filter, &polyRef, closestPoint); + dtStatus result = _navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint); if (DT_SUCCESS == result && polyRef != INVALID_POLYREF) { *distance = dtVdist(closestPoint, point); @@ -158,7 +158,7 @@ dtPolyRef PathGenerator::getPolyByLocation(const float* point, float *distance) // still nothing .. // try with bigger search box extents[1] = 200.0f; - result = m_navMeshQuery->findNearestPoly(point, extents, &m_filter, &polyRef, closestPoint); + result = _navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint); if (DT_SUCCESS == result && polyRef != INVALID_POLYREF) { *distance = dtVdist(closestPoint, point); @@ -168,7 +168,7 @@ dtPolyRef PathGenerator::getPolyByLocation(const float* point, float *distance) return INVALID_POLYREF; } -void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos) +void PathGenerator::BuildPolyPath(Vector3 const& startPos, Vector3 const& endPos) { // *** getting start/end poly logic *** @@ -176,8 +176,8 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos float startPoint[VERTEX_SIZE] = {startPos.y, startPos.z, startPos.x}; float endPoint[VERTEX_SIZE] = {endPos.y, endPos.z, endPos.x}; - dtPolyRef startPoly = getPolyByLocation(startPoint, &distToStartPoly); - dtPolyRef endPoly = getPolyByLocation(endPoint, &distToEndPoly); + dtPolyRef startPoly = GetPolyByLocation(startPoint, &distToStartPoly); + dtPolyRef endPoly = GetPolyByLocation(endPoint, &distToEndPoly); // we have a hole in our mesh // make shortcut path and mark it as NOPATH ( with flying and swimming exception ) @@ -186,15 +186,15 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos { sLog->outDebug(LOG_FILTER_MAPS, "++ BuildPolyPath :: (startPoly == 0 || endPoly == 0)\n"); BuildShortcut(); - bool path = m_sourceUnit->GetTypeId() == TYPEID_UNIT && m_sourceUnit->ToCreature()->CanFly(); + bool path = _sourceUnit->GetTypeId() == TYPEID_UNIT && _sourceUnit->ToCreature()->CanFly(); - bool waterPath = m_sourceUnit->GetTypeId() == TYPEID_UNIT && m_sourceUnit->ToCreature()->canSwim(); + bool waterPath = _sourceUnit->GetTypeId() == TYPEID_UNIT && _sourceUnit->ToCreature()->canSwim(); if (waterPath) { // Check both start and end points, if they're both in water, then we can *safely* let the creature move - for (uint32 i = 0; i < m_pathPoints.size(); ++i) + for (uint32 i = 0; i < _pathPoints.size(); ++i) { - ZLiquidStatus status = m_sourceUnit->GetBaseMap()->getLiquidStatus(m_pathPoints[i].x, m_pathPoints[i].y, m_pathPoints[i].z, MAP_ALL_LIQUIDS, NULL); + ZLiquidStatus status = _sourceUnit->GetBaseMap()->getLiquidStatus(_pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z, MAP_ALL_LIQUIDS, NULL); // One of the points is not in the water, cancel movement. if (status == LIQUID_MAP_NO_WATER) { @@ -204,7 +204,7 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos } } - m_type = (path || waterPath) ? PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH) : PATHFIND_NOPATH; + _type = (path || waterPath) ? PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH) : PATHFIND_NOPATH; return; } @@ -215,12 +215,12 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos sLog->outDebug(LOG_FILTER_MAPS, "++ BuildPolyPath :: farFromPoly distToStartPoly=%.3f distToEndPoly=%.3f\n", distToStartPoly, distToEndPoly); bool buildShotrcut = false; - if (m_sourceUnit->GetTypeId() == TYPEID_UNIT) + if (_sourceUnit->GetTypeId() == TYPEID_UNIT) { - Creature* owner = (Creature*)m_sourceUnit; + Creature* owner = (Creature*)_sourceUnit; Vector3 p = (distToStartPoly > 7.0f) ? startPos : endPos; - if (m_sourceUnit->GetBaseMap()->IsUnderWater(p.x, p.y, p.z)) + if (_sourceUnit->GetBaseMap()->IsUnderWater(p.x, p.y, p.z)) { sLog->outDebug(LOG_FILTER_MAPS, "++ BuildPolyPath :: underWater case\n"); if (owner->canSwim()) @@ -237,20 +237,20 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos if (buildShotrcut) { BuildShortcut(); - m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); + _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); return; } else { float closestPoint[VERTEX_SIZE]; // we may want to use closestPointOnPolyBoundary instead - if (DT_SUCCESS == m_navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint)) + if (DT_SUCCESS == _navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint)) { dtVcopy(endPoint, closestPoint); - setActualEndPosition(Vector3(endPoint[2],endPoint[0],endPoint[1])); + SetActualEndPosition(Vector3(endPoint[2], endPoint[0], endPoint[1])); } - m_type = PATHFIND_INCOMPLETE; + _type = PATHFIND_INCOMPLETE; } } @@ -264,11 +264,11 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos BuildShortcut(); - m_pathPolyRefs[0] = startPoly; - m_polyLength = 1; + _pathPolyRefs[0] = startPoly; + _polyLength = 1; - m_type = farFromPoly ? PATHFIND_INCOMPLETE : PATHFIND_NORMAL; - sLog->outDebug(LOG_FILTER_MAPS, "++ BuildPolyPath :: path type %d\n", m_type); + _type = farFromPoly ? PATHFIND_INCOMPLETE : PATHFIND_NORMAL; + sLog->outDebug(LOG_FILTER_MAPS, "++ BuildPolyPath :: path type %d\n", _type); return; } @@ -279,22 +279,22 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos uint32 pathStartIndex = 0; uint32 pathEndIndex = 0; - if (m_polyLength) + if (_polyLength) { - for (; pathStartIndex < m_polyLength; ++pathStartIndex) + for (; pathStartIndex < _polyLength; ++pathStartIndex) { // here to carch few bugs - ASSERT(m_pathPolyRefs[pathStartIndex] != INVALID_POLYREF); + ASSERT(_pathPolyRefs[pathStartIndex] != INVALID_POLYREF); - if (m_pathPolyRefs[pathStartIndex] == startPoly) + if (_pathPolyRefs[pathStartIndex] == startPoly) { startPolyFound = true; break; } } - for (pathEndIndex = m_polyLength-1; pathEndIndex > pathStartIndex; --pathEndIndex) - if (m_pathPolyRefs[pathEndIndex] == endPoly) + for (pathEndIndex = _polyLength-1; pathEndIndex > pathStartIndex; --pathEndIndex) + if (_pathPolyRefs[pathEndIndex] == endPoly) { endPolyFound = true; break; @@ -309,8 +309,8 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos // our path is a simple subpath case, we have all the data we need // just "cut" it out - m_polyLength = pathEndIndex - pathStartIndex + 1; - memmove(m_pathPolyRefs, m_pathPolyRefs+pathStartIndex, m_polyLength*sizeof(dtPolyRef)); + _polyLength = pathEndIndex - pathStartIndex + 1; + memmove(_pathPolyRefs, _pathPolyRefs + pathStartIndex, _polyLength * sizeof(dtPolyRef)); } else if (startPolyFound && !endPolyFound) { @@ -319,7 +319,7 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos // we are moving on the old path but target moved out // so we have atleast part of poly-path ready - m_polyLength -= pathStartIndex; + _polyLength -= pathStartIndex; // try to adjust the suffix of the path instead of recalculating entire length // at given interval the target cannot get too far from its last location @@ -328,37 +328,37 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos // take ~80% of the original length // TODO : play with the values here - uint32 prefixPolyLength = uint32(m_polyLength*0.8f + 0.5f); - memmove(m_pathPolyRefs, m_pathPolyRefs+pathStartIndex, prefixPolyLength*sizeof(dtPolyRef)); + uint32 prefixPolyLength = uint32(_polyLength * 0.8f + 0.5f); + memmove(_pathPolyRefs, _pathPolyRefs+pathStartIndex, prefixPolyLength * sizeof(dtPolyRef)); - dtPolyRef suffixStartPoly = m_pathPolyRefs[prefixPolyLength-1]; + dtPolyRef suffixStartPoly = _pathPolyRefs[prefixPolyLength-1]; // we need any point on our suffix start poly to generate poly-path, so we need last poly in prefix data float suffixEndPoint[VERTEX_SIZE]; - if (DT_SUCCESS != m_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)) + if (DT_SUCCESS != _navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)) { // we can hit offmesh connection as last poly - closestPointOnPoly() don't like that // try to recover by using prev polyref --prefixPolyLength; - suffixStartPoly = m_pathPolyRefs[prefixPolyLength-1]; - if (DT_SUCCESS != m_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)) + suffixStartPoly = _pathPolyRefs[prefixPolyLength-1]; + if (DT_SUCCESS != _navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)) { // suffixStartPoly is still invalid, error state BuildShortcut(); - m_type = PATHFIND_NOPATH; + _type = PATHFIND_NOPATH; return; } } // generate suffix uint32 suffixPolyLength = 0; - dtStatus dtResult = m_navMeshQuery->findPath( + dtStatus dtResult = _navMeshQuery->findPath( suffixStartPoly, // start polygon endPoly, // end polygon suffixEndPoint, // start position endPoint, // end position - &m_filter, // polygon search filter - m_pathPolyRefs + prefixPolyLength - 1, // [out] path + &_filter, // polygon search filter + _pathPolyRefs + prefixPolyLength - 1, // [out] path (int*)&suffixPolyLength, MAX_PATH_LENGTH-prefixPolyLength); // max number of polygons in output path @@ -367,13 +367,13 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos // this is probably an error state, but we'll leave it // and hopefully recover on the next Update // we still need to copy our preffix - sLog->outError(LOG_FILTER_MAPS, "%u's Path Build failed: 0 length path", m_sourceUnit->GetGUIDLow()); + sLog->outError(LOG_FILTER_MAPS, "%u's Path Build failed: 0 length path", _sourceUnit->GetGUIDLow()); } - sLog->outDebug(LOG_FILTER_MAPS, "++ m_polyLength=%u prefixPolyLength=%u suffixPolyLength=%u \n",m_polyLength, prefixPolyLength, suffixPolyLength); + sLog->outDebug(LOG_FILTER_MAPS, "++ m_polyLength=%u prefixPolyLength=%u suffixPolyLength=%u \n", _polyLength, prefixPolyLength, suffixPolyLength); // new path = prefix + suffix - overlap - m_polyLength = prefixPolyLength + suffixPolyLength - 1; + _polyLength = prefixPolyLength + suffixPolyLength - 1; } else { @@ -384,33 +384,33 @@ void PathGenerator::BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos // just generate new path // free and invalidate old path data - clear(); + Clear(); - dtStatus dtResult = m_navMeshQuery->findPath( + dtStatus dtResult = _navMeshQuery->findPath( startPoly, // start polygon endPoly, // end polygon startPoint, // start position endPoint, // end position - &m_filter, // polygon search filter - m_pathPolyRefs, // [out] path - (int*)&m_polyLength, + &_filter, // polygon search filter + _pathPolyRefs, // [out] path + (int*)&_polyLength, MAX_PATH_LENGTH); // max number of polygons in output path - if (!m_polyLength || dtResult != DT_SUCCESS) + if (!_polyLength || dtResult != DT_SUCCESS) { // only happens if we passed bad data to findPath(), or navmesh is messed up - sLog->outError(LOG_FILTER_MAPS, "%u's Path Build failed: 0 length path", m_sourceUnit->GetGUIDLow()); + sLog->outError(LOG_FILTER_MAPS, "%u's Path Build failed: 0 length path", _sourceUnit->GetGUIDLow()); BuildShortcut(); - m_type = PATHFIND_NOPATH; + _type = PATHFIND_NOPATH; return; } } // by now we know what type of path we can get - if (m_pathPolyRefs[m_polyLength - 1] == endPoly && !(m_type & PATHFIND_INCOMPLETE)) - m_type = PATHFIND_NORMAL; + if (_pathPolyRefs[_polyLength - 1] == endPoly && !(_type & PATHFIND_INCOMPLETE)) + _type = PATHFIND_NORMAL; else - m_type = PATHFIND_INCOMPLETE; + _type = PATHFIND_INCOMPLETE; // generate the point-path out of our up-to-date poly-path BuildPointPath(startPoint, endPoint); @@ -421,29 +421,29 @@ void PathGenerator::BuildPointPath(const float *startPoint, const float *endPoin float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE]; uint32 pointCount = 0; dtStatus dtResult = DT_FAILURE; - if (m_useStraightPath) + if (_useStraightPath) { - dtResult = m_navMeshQuery->findStraightPath( + dtResult = _navMeshQuery->findStraightPath( startPoint, // start position endPoint, // end position - m_pathPolyRefs, // current path - m_polyLength, // lenth of current path + _pathPolyRefs, // current path + _polyLength, // lenth of current path pathPoints, // [out] path corner points NULL, // [out] flags NULL, // [out] shortened path (int*)&pointCount, - m_pointPathLimit); // maximum number of points/polygons to use + _pointPathLimit); // maximum number of points/polygons to use } else { - dtResult = findSmoothPath( + dtResult = FindSmoothPath( startPoint, // start position endPoint, // end position - m_pathPolyRefs, // current path - m_polyLength, // length of current path + _pathPolyRefs, // current path + _polyLength, // length of current path pathPoints, // [out] path corner points (int*)&pointCount, - m_pointPathLimit); // maximum number of points + _pointPathLimit); // maximum number of points } if (pointCount < 2 || dtResult != DT_SUCCESS) @@ -453,81 +453,80 @@ void PathGenerator::BuildPointPath(const float *startPoint, const float *endPoin // TODO : check the exact cases sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath FAILED! path sized %d returned\n", pointCount); BuildShortcut(); - m_type = PATHFIND_NOPATH; + _type = PATHFIND_NOPATH; return; } - else if (pointCount == m_pointPathLimit) + else if (pointCount == _pointPathLimit) { - sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath FAILED! path sized %d returned, lower than limit set to %d\n", pointCount, m_pointPathLimit); + sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath FAILED! path sized %d returned, lower than limit set to %d\n", pointCount, _pointPathLimit); BuildShortcut(); - m_type = PATHFIND_SHORT; + _type = PATHFIND_SHORT; return; } - m_pathPoints.resize(pointCount); + _pathPoints.resize(pointCount); for (uint32 i = 0; i < pointCount; ++i) - m_pathPoints[i] = Vector3(pathPoints[i*VERTEX_SIZE+2], pathPoints[i*VERTEX_SIZE], pathPoints[i*VERTEX_SIZE+1]); + _pathPoints[i] = Vector3(pathPoints[i*VERTEX_SIZE+2], pathPoints[i*VERTEX_SIZE], pathPoints[i*VERTEX_SIZE+1]); NormalizePath(); // first point is always our current location - we need the next one - setActualEndPosition(m_pathPoints[pointCount-1]); + SetActualEndPosition(_pathPoints[pointCount-1]); // force the given destination, if needed - if(m_forceDestination && - (!(m_type & PATHFIND_NORMAL) || !inRange(getEndPosition(), getActualEndPosition(), 1.0f, 1.0f))) + if (_forceDestination && + (!(_type & PATHFIND_NORMAL) || !InRange(GetEndPosition(), GetActualEndPosition(), 1.0f, 1.0f))) { // we may want to keep partial subpath - if(dist3DSqr(getActualEndPosition(), getEndPosition()) < - 0.3f * dist3DSqr(getStartPosition(), getEndPosition())) + if (Dist3DSqr(GetActualEndPosition(), GetEndPosition()) < 0.3f * Dist3DSqr(GetStartPosition(), GetEndPosition())) { - setActualEndPosition(getEndPosition()); - m_pathPoints[m_pathPoints.size()-1] = getEndPosition(); + SetActualEndPosition(GetEndPosition()); + _pathPoints[_pathPoints.size()-1] = GetEndPosition(); } else { - setActualEndPosition(getEndPosition()); + SetActualEndPosition(GetEndPosition()); BuildShortcut(); } - m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); + _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); } - sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath path type %d size %d poly-size %d\n", m_type, pointCount, m_polyLength); + sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath path type %d size %d poly-size %d\n", _type, pointCount, _polyLength); } void PathGenerator::NormalizePath() { - for (uint32 i = 0; i < m_pathPoints.size(); ++i) - m_sourceUnit->UpdateAllowedPositionZ(m_pathPoints[i].x, m_pathPoints[i].y, m_pathPoints[i].z); + for (uint32 i = 0; i < _pathPoints.size(); ++i) + _sourceUnit->UpdateAllowedPositionZ(_pathPoints[i].x, _pathPoints[i].y, _pathPoints[i].z); } void PathGenerator::BuildShortcut() { sLog->outDebug(LOG_FILTER_MAPS, "++ BuildShortcut :: making shortcut\n"); - clear(); + Clear(); // make two point path, our curr pos is the start, and dest is the end - m_pathPoints.resize(2); + _pathPoints.resize(2); // set start and a default next position - m_pathPoints[0] = getStartPosition(); - m_pathPoints[1] = getActualEndPosition(); + _pathPoints[0] = GetStartPosition(); + _pathPoints[1] = GetActualEndPosition(); NormalizePath(); - m_type = PATHFIND_SHORTCUT; + _type = PATHFIND_SHORTCUT; } -void PathGenerator::createFilter() +void PathGenerator::CreateFilter() { uint16 includeFlags = 0; uint16 excludeFlags = 0; - if (m_sourceUnit->GetTypeId() == TYPEID_UNIT) + if (_sourceUnit->GetTypeId() == TYPEID_UNIT) { - Creature* creature = (Creature*)m_sourceUnit; + Creature* creature = (Creature*)_sourceUnit; if (creature->canWalk()) includeFlags |= NAV_GROUND; // walk @@ -535,37 +534,37 @@ void PathGenerator::createFilter() if (creature->canSwim()) includeFlags |= (NAV_WATER | NAV_MAGMA | NAV_SLIME); // swim } - else if (m_sourceUnit->GetTypeId() == TYPEID_PLAYER) + else if (_sourceUnit->GetTypeId() == TYPEID_PLAYER) { // perfect support not possible, just stay 'safe' includeFlags |= (NAV_GROUND | NAV_WATER); } - m_filter.setIncludeFlags(includeFlags); - m_filter.setExcludeFlags(excludeFlags); + _filter.setIncludeFlags(includeFlags); + _filter.setExcludeFlags(excludeFlags); - updateFilter(); + UpdateFilter(); } -void PathGenerator::updateFilter() +void PathGenerator::UpdateFilter() { // allow creatures to cheat and use different movement types if they are moved // forcefully into terrain they can't normally move in - if (m_sourceUnit->IsInWater() || m_sourceUnit->IsUnderWater()) + if (_sourceUnit->IsInWater() || _sourceUnit->IsUnderWater()) { - uint16 includedFlags = m_filter.getIncludeFlags(); - includedFlags |= getNavTerrain(m_sourceUnit->GetPositionX(), - m_sourceUnit->GetPositionY(), - m_sourceUnit->GetPositionZ()); + uint16 includedFlags = _filter.getIncludeFlags(); + includedFlags |= GetNavTerrain(_sourceUnit->GetPositionX(), + _sourceUnit->GetPositionY(), + _sourceUnit->GetPositionZ()); - m_filter.setIncludeFlags(includedFlags); + _filter.setIncludeFlags(includedFlags); } } -NavTerrain PathGenerator::getNavTerrain(float x, float y, float z) +NavTerrain PathGenerator::GetNavTerrain(float x, float y, float z) { LiquidData data; - m_sourceUnit->GetBaseMap()->getLiquidStatus(x, y, z, MAP_ALL_LIQUIDS, &data); + _sourceUnit->GetBaseMap()->getLiquidStatus(x, y, z, MAP_ALL_LIQUIDS, &data); switch (data.type_flags) { @@ -581,16 +580,16 @@ NavTerrain PathGenerator::getNavTerrain(float x, float y, float z) } } -bool PathGenerator::HaveTile(const Vector3 &p) const +bool PathGenerator::HaveTile(Vector3 const& p) const { int tx, ty; float point[VERTEX_SIZE] = {p.y, p.z, p.x}; - m_navMesh->calcTileLoc(point, &tx, &ty); - return (m_navMesh->getTileAt(tx, ty) != NULL); + _navMesh->calcTileLoc(point, &tx, &ty); + return (_navMesh->getTileAt(tx, ty) != NULL); } -uint32 PathGenerator::fixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, dtPolyRef const* visited, uint32 nvisited) +uint32 PathGenerator::FixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, dtPolyRef const* visited, uint32 nvisited) { int32 furthestPath = -1; int32 furthestVisited = -1; @@ -635,8 +634,8 @@ uint32 PathGenerator::fixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPat return req+size; } -bool PathGenerator::getSteerTarget(const float* startPos, const float* endPos, - float minTargetDist, const dtPolyRef* path, uint32 pathSize, +bool PathGenerator::GetSteerTarget(float const* startPos, float const* endPos, + float minTargetDist, dtPolyRef const* path, uint32 pathSize, float* steerPos, unsigned char& steerPosFlag, dtPolyRef& steerPosRef) { // Find steer target. @@ -645,7 +644,7 @@ bool PathGenerator::getSteerTarget(const float* startPos, const float* endPos, unsigned char steerPathFlags[MAX_STEER_POINTS]; dtPolyRef steerPathPolys[MAX_STEER_POINTS]; uint32 nsteerPath = 0; - dtStatus dtResult = m_navMeshQuery->findStraightPath(startPos, endPos, path, pathSize, + dtStatus dtResult = _navMeshQuery->findStraightPath(startPos, endPos, path, pathSize, steerPath, steerPathFlags, steerPathPolys, (int*)&nsteerPath, MAX_STEER_POINTS); if (!nsteerPath || DT_SUCCESS != dtResult) return false; @@ -656,7 +655,7 @@ bool PathGenerator::getSteerTarget(const float* startPos, const float* endPos, { // Stop at Off-Mesh link or when point is further than slop away. if ((steerPathFlags[ns] & DT_STRAIGHTPATH_OFFMESH_CONNECTION) || - !inRangeYZX(&steerPath[ns*VERTEX_SIZE], startPos, minTargetDist, 1000.0f)) + !InRangeYZX(&steerPath[ns*VERTEX_SIZE], startPos, minTargetDist, 1000.0f)) break; ns++; } @@ -672,8 +671,8 @@ bool PathGenerator::getSteerTarget(const float* startPos, const float* endPos, return true; } -dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPos, - const dtPolyRef* polyPath, uint32 polyPathSize, +dtStatus PathGenerator::FindSmoothPath(float const* startPos, float const* endPos, + dtPolyRef const* polyPath, uint32 polyPathSize, float* smoothPath, int* smoothPathSize, uint32 maxSmoothPathSize) { *smoothPathSize = 0; @@ -684,10 +683,10 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo uint32 npolys = polyPathSize; float iterPos[VERTEX_SIZE], targetPos[VERTEX_SIZE]; - if (DT_SUCCESS != m_navMeshQuery->closestPointOnPolyBoundary(polys[0], startPos, iterPos)) + if (DT_SUCCESS != _navMeshQuery->closestPointOnPolyBoundary(polys[0], startPos, iterPos)) return DT_FAILURE; - if (DT_SUCCESS != m_navMeshQuery->closestPointOnPolyBoundary(polys[npolys-1], endPos, targetPos)) + if (DT_SUCCESS != _navMeshQuery->closestPointOnPolyBoundary(polys[npolys-1], endPos, targetPos)) return DT_FAILURE; dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos); @@ -702,7 +701,7 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo unsigned char steerPosFlag; dtPolyRef steerPosRef = INVALID_POLYREF; - if (!getSteerTarget(iterPos, targetPos, SMOOTH_PATH_SLOP, polys, npolys, steerPos, steerPosFlag, steerPosRef)) + if (!GetSteerTarget(iterPos, targetPos, SMOOTH_PATH_SLOP, polys, npolys, steerPos, steerPosFlag, steerPosRef)) break; bool endOfPath = (steerPosFlag & DT_STRAIGHTPATH_END); @@ -727,15 +726,15 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo dtPolyRef visited[MAX_VISIT_POLY]; uint32 nvisited = 0; - m_navMeshQuery->moveAlongSurface(polys[0], iterPos, moveTgt, &m_filter, result, visited, (int*)&nvisited, MAX_VISIT_POLY); - npolys = fixupCorridor(polys, npolys, MAX_PATH_LENGTH, visited, nvisited); + _navMeshQuery->moveAlongSurface(polys[0], iterPos, moveTgt, &_filter, result, visited, (int*)&nvisited, MAX_VISIT_POLY); + npolys = FixupCorridor(polys, npolys, MAX_PATH_LENGTH, visited, nvisited); - m_navMeshQuery->getPolyHeight(polys[0], result, &result[1]); + _navMeshQuery->getPolyHeight(polys[0], result, &result[1]); result[1] += 0.5f; dtVcopy(iterPos, result); // Handle end of path and off-mesh links when close enough. - if (endOfPath && inRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 1.0f)) + if (endOfPath && InRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 1.0f)) { // Reached end of path. dtVcopy(iterPos, targetPos); @@ -746,7 +745,7 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo } break; } - else if (offMeshConnection && inRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 1.0f)) + else if (offMeshConnection && InRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 1.0f)) { // Advance the path up to and over the off-mesh connection. dtPolyRef prevRef = INVALID_POLYREF; @@ -766,7 +765,7 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo // Handle the connection. float startPos[VERTEX_SIZE], endPos[VERTEX_SIZE]; - if (DT_SUCCESS == m_navMesh->getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startPos, endPos)) + if (DT_SUCCESS == _navMesh->getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startPos, endPos)) { if (nsmoothPath < maxSmoothPathSize) { @@ -775,7 +774,7 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo } // Move position at the other side of the off-mesh link. dtVcopy(iterPos, endPos); - m_navMeshQuery->getPolyHeight(polys[0], iterPos, &iterPos[1]); + _navMeshQuery->getPolyHeight(polys[0], iterPos, &iterPos[1]); iterPos[1] += 0.5f; } } @@ -794,21 +793,21 @@ dtStatus PathGenerator::findSmoothPath(const float* startPos, const float* endPo return nsmoothPath < MAX_POINT_PATH_LENGTH ? DT_SUCCESS : DT_FAILURE; } -bool PathGenerator::inRangeYZX(const float* v1, const float* v2, float r, float h) const +bool PathGenerator::InRangeYZX(const float* v1, const float* v2, float r, float h) const { const float dx = v2[0] - v1[0]; const float dy = v2[1] - v1[1]; // elevation const float dz = v2[2] - v1[2]; - return (dx*dx + dz*dz) < r*r && fabsf(dy) < h; + return (dx * dx + dz * dz) < r * r && fabsf(dy) < h; } -bool PathGenerator::inRange(const Vector3 &p1, const Vector3 &p2, float r, float h) const +bool PathGenerator::InRange(Vector3 const& p1, Vector3 const& p2, float r, float h) const { - Vector3 d = p1-p2; - return (d.x*d.x + d.y*d.y) < r*r && fabsf(d.z) < h; + Vector3 d = p1 - p2; + return (d.x * d.x + d.y * d.y) < r * r && fabsf(d.z) < h; } -float PathGenerator::dist3DSqr(const Vector3 &p1, const Vector3 &p2) const +float PathGenerator::Dist3DSqr(Vector3 const& p1, Vector3 const& p2) const { - return (p1-p2).squaredLength(); + return (p1 - p2).squaredLength(); } diff --git a/src/server/game/Movement/PathGenerator.h b/src/server/game/Movement/PathGenerator.h index ac163f43be5..a20f900b584 100644 --- a/src/server/game/Movement/PathGenerator.h +++ b/src/server/game/Movement/PathGenerator.h @@ -16,8 +16,8 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#ifndef _PATH_INFO_H -#define _PATH_INFO_H +#ifndef _PATH_GENERATOR_H +#define _PATH_GENERATOR_H #include "SharedDefines.h" #include "DetourNavMesh.h" @@ -63,75 +63,72 @@ class PathGenerator bool CalculatePath(float destX, float destY, float destZ, bool forceDest = false); // option setters - use optional - void SetUseStraightPath(bool useStraightPath) { m_useStraightPath = useStraightPath; }; - void setPathLengthLimit(float distance) { m_pointPathLimit = std::min<uint32>(uint32(distance/SMOOTH_PATH_STEP_SIZE), MAX_POINT_PATH_LENGTH); }; + void SetUseStraightPath(bool useStraightPath) { _useStraightPath = useStraightPath; }; + void SetPathLengthLimit(float distance) { _pointPathLimit = std::min<uint32>(uint32(distance/SMOOTH_PATH_STEP_SIZE), MAX_POINT_PATH_LENGTH); }; // result getters - Vector3 getStartPosition() const { return m_startPosition; } - Vector3 getEndPosition() const { return m_endPosition; } - Vector3 getActualEndPosition() const { return m_actualEndPosition; } + Vector3 const& GetStartPosition() const { return _startPosition; } + Vector3 const& GetEndPosition() const { return _endPosition; } + Vector3 const& GetActualEndPosition() const { return _actualEndPosition; } - PointsArray& getPath() { return m_pathPoints; } - PathType getPathType() const { return m_type; } + PointsArray& GetPath() { return _pathPoints; } + PathType GetPathType() const { return _type; } private: - dtPolyRef m_pathPolyRefs[MAX_PATH_LENGTH]; // array of detour polygon references - uint32 m_polyLength; // number of polygons in the path + dtPolyRef _pathPolyRefs[MAX_PATH_LENGTH]; // array of detour polygon references + uint32 _polyLength; // number of polygons in the path - PointsArray m_pathPoints; // our actual (x,y,z) path to the target - PathType m_type; // tells what kind of path this is + PointsArray _pathPoints; // our actual (x,y,z) path to the target + PathType _type; // tells what kind of path this is - bool m_useStraightPath; // type of path will be generated - bool m_forceDestination; // when set, we will always arrive at given point - uint32 m_pointPathLimit; // limit point path size; min(this, MAX_POINT_PATH_LENGTH) + bool _useStraightPath; // type of path will be generated + bool _forceDestination; // when set, we will always arrive at given point + uint32 _pointPathLimit; // limit point path size; min(this, MAX_POINT_PATH_LENGTH) - Vector3 m_startPosition; // {x, y, z} of current location - Vector3 m_endPosition; // {x, y, z} of the destination - Vector3 m_actualEndPosition;// {x, y, z} of the closest possible point to given destination + Vector3 _startPosition; // {x, y, z} of current location + Vector3 _endPosition; // {x, y, z} of the destination + Vector3 _actualEndPosition;// {x, y, z} of the closest possible point to given destination - const Unit* const m_sourceUnit; // the unit that is moving - const dtNavMesh* m_navMesh; // the nav mesh - const dtNavMeshQuery* m_navMeshQuery; // the nav mesh query used to find the path + Unit const* const _sourceUnit; // the unit that is moving + dtNavMesh const* _navMesh; // the nav mesh + dtNavMeshQuery const* _navMeshQuery; // the nav mesh query used to find the path - dtQueryFilter m_filter; // use single filter for all movements, update it when needed + dtQueryFilter _filter; // use single filter for all movements, update it when needed - void setStartPosition(Vector3 point) { m_startPosition = point; } - void setEndPosition(Vector3 point) { m_actualEndPosition = point; m_endPosition = point; } - void setActualEndPosition(Vector3 point) { m_actualEndPosition = point; } - + void SetStartPosition(Vector3 Point) { _startPosition = Point; } + void SetEndPosition(Vector3 Point) { _actualEndPosition = Point; _endPosition = Point; } + void SetActualEndPosition(Vector3 Point) { _actualEndPosition = Point; } void NormalizePath(); - void clear() + void Clear() { - m_polyLength = 0; - m_pathPoints.clear(); + _polyLength = 0; + _pathPoints.clear(); } - bool inRange(const Vector3 &p1, const Vector3 &p2, float r, float h) const; - float dist3DSqr(const Vector3 &p1, const Vector3 &p2) const; - bool inRangeYZX(const float* v1, const float* v2, float r, float h) const; + bool InRange(Vector3 const& p1, Vector3 const& p2, float r, float h) const; + float Dist3DSqr(Vector3 const& p1, Vector3 const& p2) const; + bool InRangeYZX(float const* v1, float const* v2, float r, float h) const; - dtPolyRef getPathPolyByPosition(const dtPolyRef *polyPath, uint32 polyPathSize, const float* point, float *distance = NULL) const; - dtPolyRef getPolyByLocation(const float* point, float *distance) const; - bool HaveTile(const Vector3 &p) const; + dtPolyRef GetPathPolyByPosition(dtPolyRef const* polyPath, uint32 polyPathSize, float const* Point, float* Distance = NULL) const; + dtPolyRef GetPolyByLocation(float const* Point, float* Distance) const; + bool HaveTile(Vector3 const& p) const; - void BuildPolyPath(const Vector3 &startPos, const Vector3 &endPos); - void BuildPointPath(const float *startPoint, const float *endPoint); + void BuildPolyPath(Vector3 const& startPos, Vector3 const& endPos); + void BuildPointPath(float const* startPoint, float const* endPoint); void BuildShortcut(); - NavTerrain getNavTerrain(float x, float y, float z); - void createFilter(); - void updateFilter(); + NavTerrain GetNavTerrain(float x, float y, float z); + void CreateFilter(); + void UpdateFilter(); // smooth path aux functions - uint32 fixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, - const dtPolyRef* visited, uint32 nvisited); - bool getSteerTarget(const float* startPos, const float* endPos, float minTargetDist, - const dtPolyRef* path, uint32 pathSize, float* steerPos, + uint32 FixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, dtPolyRef const* visited, uint32 nvisited); + bool GetSteerTarget(float const* startPos, float const* endPos, float minTargetDist, dtPolyRef const* path, uint32 pathSize, float* steerPos, unsigned char& steerPosFlag, dtPolyRef& steerPosRef); - dtStatus findSmoothPath(const float* startPos, const float* endPos, - const dtPolyRef* polyPath, uint32 polyPathSize, + dtStatus FindSmoothPath(float const* startPos, float const* endPos, + dtPolyRef const* polyPath, uint32 polyPathSize, float* smoothPath, int* smoothPathSize, uint32 smoothPathMaxSize); }; diff --git a/src/server/game/Movement/Spline/MoveSplineInit.cpp b/src/server/game/Movement/Spline/MoveSplineInit.cpp index 8167ff36de2..2796e208e34 100644 --- a/src/server/game/Movement/Spline/MoveSplineInit.cpp +++ b/src/server/game/Movement/Spline/MoveSplineInit.cpp @@ -154,7 +154,7 @@ namespace Movement { PathGenerator path(unit); path.CalculatePath(dest.x, dest.y, dest.z, forceDestination); - MovebyPath(path.getPath()); + MovebyPath(path.GetPath()); } else { diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp index 081056c1c79..0cbae416271 100755 --- a/src/server/game/Spells/Spell.cpp +++ b/src/server/game/Spells/Spell.cpp @@ -5157,10 +5157,10 @@ SpellCastResult Spell::CheckCast(bool strict) target->GetContactPoint(m_caster, pos.m_positionX, pos.m_positionY, pos.m_positionZ); target->GetFirstCollisionPosition(pos, CONTACT_DISTANCE, target->GetRelativeAngle(m_caster)); - m_preGeneratedPath.setPathLengthLimit(m_spellInfo->GetMaxRange(true) * 1.5f); + m_preGeneratedPath.SetPathLengthLimit(m_spellInfo->GetMaxRange(true) * 1.5f); m_preGeneratedPath.CalculatePath(pos.m_positionX, pos.m_positionY, pos.m_positionZ + target->GetObjectSize()); - if (m_preGeneratedPath.getPathType() & PATHFIND_SHORT) + if (m_preGeneratedPath.GetPathType() & PATHFIND_SHORT) return SPELL_FAILED_OUT_OF_RANGE; break; diff --git a/src/server/game/Spells/SpellEffects.cpp b/src/server/game/Spells/SpellEffects.cpp index 1aa2ca0176b..d3b21395725 100755 --- a/src/server/game/Spells/SpellEffects.cpp +++ b/src/server/game/Spells/SpellEffects.cpp @@ -5139,7 +5139,7 @@ void Spell::EffectCharge(SpellEffIndex /*effIndex*/) if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET) { - if (m_preGeneratedPath.getPathType() & PATHFIND_NOPATH) + if (m_preGeneratedPath.GetPathType() & PATHFIND_NOPATH) { Position pos; unitTarget->GetContactPoint(m_caster, pos.m_positionX, pos.m_positionY, pos.m_positionZ); |