自学教程：C++ BuildShortcut函数代码示例

bool PathFinder::calculate(float destX, float destY, float destZ, bool forceDest){    Vector3 oldDest = getEndPosition();    Vector3 dest(destX, destY, destZ);    setEndPosition(dest);    float x, y, z;    m_sourceUnit->GetPosition(x, y, z);    Vector3 start(x, y, z);    setStartPosition(start);    m_forceDestination = forceDest;    DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathFinder::calculate() for %u /n", m_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_STAT_IGNORE_PATHFINDING) ||        !HaveTile(start) || !HaveTile(dest))    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    updateFilter();    BuildPolyPath(start, dest);    return true;}

			void GuiToolstripCommand::UpdateShortcutOwner()			{				GuiControlHost* host = nullptr;				if (auto control = dynamic_cast<GuiControl*>(attachedRootObject))				{					host = control->GetRelatedControlHost();				}				else if (auto composition = dynamic_cast<GuiGraphicsComposition*>(attachedRootObject))				{					host = composition->GetRelatedControlHost();				}				if (shortcutOwner != host)				{					if (shortcutOwner)					{						ReplaceShortcut(nullptr, nullptr);						shortcutOwner = nullptr;					}					shortcutOwner = host;					if (shortcutBuilder && !shortcutKeyItem)					{						BuildShortcut(shortcutBuilder->text);					}				}			}

bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool forceDest){    float x, y, z;    _sourceUnit->GetPosition(x, y, z);    if (!Trinity::IsValidMapCoord(destX, destY, destZ) || !Trinity::IsValidMapCoord(x, y, z))        return false;    Vector3 dest(destX, destY, destZ);    SetEndPosition(dest);    Vector3 start(x, y, z);    SetStartPosition(start);    _forceDestination = forceDest;    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 (!_navMesh || !_navMeshQuery || _sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING) ||            !HaveTile(start) || !HaveTile(dest))    {        BuildShortcut();        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    UpdateFilter();    BuildPolyPath(start, dest);    return true;}

////////////////// PathInfo //////////////////PathInfo::PathInfo(const Unit* owner, const float destX, const float destY, const float destZ, bool useStraightPath) :    m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(useStraightPath),    m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL){    PathNode endPoint(destX, destY, destZ);    setEndPosition(endPoint);    float x,y,z;    m_sourceUnit->GetPosition(x, y, z);    PathNode startPoint(x, y, z);    setStartPosition(startPoint);    PATH_DEBUG("++ PathInfo::PathInfo for %u /n", m_sourceUnit->GetGUID());    uint32 mapId = m_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());    }    createFilter();    if (m_navMesh && m_navMeshQuery && !m_sourceUnit->hasUnitState(UNIT_STAT_IGNORE_PATHFINDING) && !(m_sourceUnit->GetTypeId() == TYPEID_UNIT ? ((Creature*)m_sourceUnit)->IsWorldBoss() : false))    {        BuildPolyPath(startPoint, endPoint);    }    else    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }}

void PathInfo::BuildPointPath(float *startPoint, float *endPoint){    // get the actual reachable point on last poly in path    float closestPoint[VERTEX_SIZE];    if ((m_type & PATHFIND_INCOMPLETE)            && DT_SUCCESS == m_navMeshQuery->closestPointOnPoly(m_pathPolyRefs[m_polyLength-1], endPoint, closestPoint))    {        dtVcopy(endPoint, closestPoint);        setActualEndPosition(PathNode(endPoint[2],endPoint[0],endPoint[1]));    }    float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE];    uint32 pointCount = 0;    dtStatus dtResult = DT_FAILURE;    if (m_useStraightPath)    {        dtResult = m_navMeshQuery->findStraightPath(                       startPoint,         // start position                       endPoint,           // end position                       m_pathPolyRefs,     // current path                       m_polyLength,       // lenth of current path                       pathPoints,         // [out] path corner points                       NULL,               // [out] flags                       NULL,               // [out] shortened path                       (int*)&pointCount,                       MAX_POINT_PATH_LENGTH);   // maximum number of points/polygons to use    }    else    {        dtResult = findSmoothPath(                       startPoint,         // start position                       endPoint,           // end position                       m_pathPolyRefs,     // current path                       m_polyLength,       // length of current path                       pathPoints,         // [out] path corner points                       (int*)&pointCount,                       MAX_POINT_PATH_LENGTH);    // maximum number of points    }    if (pointCount < 2 || dtResult != DT_SUCCESS)    {        // only happens if pass bad data to findStraightPath or navmesh is broken        // single point paths can be generated here        // TODO : check the exact cases        PATH_DEBUG("++ PathInfo::BuildPointPath FAILED! path sized %d returned/n", pointCount);        BuildShortcut();        m_type = PATHFIND_NOPATH;        return;    }    m_pathPoints.resize(pointCount);    for (uint32 i = 0; i < pointCount; ++i)        m_pathPoints.set(i, PathNode(pathPoints[i*VERTEX_SIZE+2], pathPoints[i*VERTEX_SIZE], pathPoints[i*VERTEX_SIZE+1]));    // first point is always our current location - we need the next one    setNextPosition(m_pathPoints[1]);    PATH_DEBUG("++ PathInfo::BuildPointPath path type %d size %d poly-size %d/n", m_type, pointCount, m_polyLength);}

bool PathInfo::Update(const float destX, const float destY, const float destZ, bool useStraightPath){    PathNode newDest(destX, destY, m_sourceUnit->GetMap()->GetHeight(destX,destY,destZ,100.0f));    PathNode oldDest = getEndPosition();    setEndPosition(newDest);    float x, y, z;    m_sourceUnit->GetPosition(x, y, z);    PathNode newStart(x, y, m_sourceUnit->GetMap()->GetHeight(x,y,z,100.0f));    PathNode oldStart = getStartPosition();    setStartPosition(newStart);    m_useStraightPath = useStraightPath;    PATH_DEBUG("++ PathInfo::Update() for %u /n", m_sourceUnit->GetGUID());    // make sure navMesh works - we can run on map w/o mmap    if (!m_navMesh || !m_navMeshQuery)    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    float dist = m_sourceUnit->GetObjectBoundingRadius();    bool oldDestInRange = inRange(oldDest, newDest, dist, dist);    // this can happen only if caller did a bad job calculating the need for path update    if (oldDestInRange && inRange(newStart, oldStart, dist, dist))    {        setEndPosition(oldDest);        setStartPosition(oldStart);        return false;    }    // check if destination moved - if not we can optimize something here    // we are following old, precalculated path?    if (oldDestInRange && m_pathPoints.size() > 2)    {        // our target is not moving - we just coming closer        // we are moving on precalculated path - enjoy the ride        PATH_DEBUG("++ PathInfo::Update:: precalculated path/n");        m_pathPoints.crop(1, 0);        setNextPosition(m_pathPoints[1]);        return false;    }    else    {        // target moved, so we need to update the poly path        BuildPolyPath(newStart, newDest);        return true;    }}

bool PathFinderMovementGenerator::calculate(float destX, float destY, float destZ, bool forceDest){    if (!SkyFire::IsValidMapCoord(destX, destY, destZ) ||        !SkyFire::IsValidMapCoord(m_sourceUnit->GetPositionX(), m_sourceUnit->GetPositionY(), m_sourceUnit->GetPositionZ()))        return false;    Vector3 oldDest = getEndPosition();    Vector3 dest(destX, destY, destZ);    setEndPosition(dest);    float x, y, z;    m_sourceUnit->GetPosition(x, y, z);    Vector3 start(x, y, z);    setStartPosition(start);    m_forceDestination = forceDest;    sLog->outDebug(LOG_FILTER_MAPS, "++ PathFinderMovementGenerator::calculate() for %u /n", m_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) ||        !HaveTile(start) || !HaveTile(dest))    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    updateFilter();    // check if destination moved - if not we can optimize something here    // we are following old, precalculated path?    float dist = m_sourceUnit->GetObjectSize();    if (inRange(oldDest, dest, dist, dist) && m_pathPoints.size() > 2)    {        // our target is not moving - we just coming closer        // we are moving on precalculated path - enjoy the ride        sLog->outStaticDebug("++ PathFinderMovementGenerator::calculate:: precalculated path/n");        m_pathPoints.erase(m_pathPoints.begin());        return false;    }    else    {        // target moved, so we need to update the poly path        m_navMeshLock->acquire_read();        BuildPolyPath(start, dest);        m_navMeshLock->release();        return true;    }}

bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool forceDest){    float 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 dest(destX, destY, destZ);    SetEndPosition(dest);    Vector3 start(x, y, z);    SetStartPosition(start);    _forceDestination = forceDest;    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 (!_navMesh || !_navMeshQuery || _sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING) ||        !HaveTile(start) || !HaveTile(dest))    {        BuildShortcut();        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    UpdateFilter();    // check if destination moved - if not we can optimize something here    // we are following old, precalculated path?    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");        _pathPoints.erase(_pathPoints.begin());        return false;    }    else    {        // target moved, so we need to update the poly path        BuildPolyPath(start, dest);        return true;    }}

bool PathInfo::Update(const float destX, const float destY, const float destZ,                      bool useStraightPath, bool forceDest){    PathNode newDest(destX, destY, destZ);    PathNode oldDest = getEndPosition();    setEndPosition(newDest);    float x, y, z;    m_sourceUnit->GetPosition(x, y, z);    PathNode newStart(x, y, z);    PathNode oldStart = getStartPosition();    setStartPosition(newStart);    m_useStraightPath = useStraightPath;    m_forceDestination = forceDest;    DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathInfo::Update() for %u /n", m_sourceUnit->GetGUID());    // make sure navMesh works - we can run on map w/o mmap    if (!m_navMesh || !m_navMeshQuery || !HaveTiles(newDest) ||            m_sourceUnit->hasUnitState(UNIT_STAT_IGNORE_PATHFINDING))    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    updateFilter();    // check if destination moved - if not we can optimize something here    // we are following old, precalculated path?    float dist = m_sourceUnit->GetObjectBoundingRadius();    if (inRange(oldDest, newDest, dist, dist) && m_pathPoints.size() > 2)    {        // our target is not moving - we just coming closer        // we are moving on precalculated path - enjoy the ride        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathInfo::Update:: precalculated path/n");        m_pathPoints.crop(1, 0);        setNextPosition(m_pathPoints[1]);        return false;    }    else    {        // target moved, so we need to update the poly path        BuildPolyPath(newStart, newDest);        return true;    }}

bool PathFinder::calculate(float destX, float destY, float destZ, bool forceDest){    Vector3 oldDest = getEndPosition();    Vector3 dest(destX, destY, destZ);    setEndPosition(dest);    float x, y, z;    m_sourceUnit->GetPosition(x, y, z);    Vector3 start(x, y, z);    setStartPosition(start);    m_forceDestination = forceDest;    DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathFinder::calculate() for %u /n", m_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_STAT_IGNORE_PATHFINDING) ||        !HaveTile(start) || !HaveTile(dest))    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    updateFilter();    // check if destination moved - if not we can optimize something here    // we are following old, precalculated path?    float dist = m_sourceUnit->GetObjectBoundingRadius();    if (inRange(oldDest, dest, dist, dist) && m_pathPoints.size() > 2)    {        // our target is not moving - we just coming closer        // we are moving on precalculated path - enjoy the ride        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathFinder::calculate:: precalculated path/n");        m_pathPoints.erase(m_pathPoints.begin());        return false;    }    else    {        // target moved, so we need to update the poly path        ReadGuard Guard(MMAP::MMapFactory::createOrGetMMapManager()->GetLock(m_sourceUnit->GetMapId()));        BuildPolyPath(start, dest);        return true;    }}

bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool /*forceDest*/){    float x, y, z;    _sourceUnit->GetPosition(x, y, z);    if (!Trinity::IsValidMapCoord(destX, destY, destZ) || !Trinity::IsValidMapCoord(x, y, z))        return false;    G3D::Vector3 dest(destX, destY, destZ);    SetEndPosition(dest);    SetActualEndPosition(GetEndPosition());    G3D::Vector3 start(x, y, z);    SetStartPosition(start);    TC_LOG_DEBUG("maps", "++ PathGenerator::CalculatePath() for %u/n", _sourceUnit->GetGUIDLow());    BuildShortcut();    _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    return true;}

bool PathInfo::Update(float destX, float destY, float destZ, bool forceDest){    float x, y, z;    m_sourceUnit->GetPosition(x, y, z);    if (!Oregon::IsValidMapCoord(destX, destY, destZ) || !Oregon::IsValidMapCoord(x, y, z))    {        sLog.outMMap("PathInfo::Update() called with invalid map coords, destX: %f destY: %f destZ: %f x: %f y: %f z: %f for creature %u", destX, destY, destZ, x, y, z, m_sourceUnit->GetGUIDLow());        m_type = PATHFIND_NOPATH;        return false;    }    Vector3 oldDest = getEndPosition();    Vector3 newDest(destX, destY, destZ);    setEndPosition(newDest);    Vector3 newStart(x, y, z);    setStartPosition(newStart);    m_forceDestination = forceDest;    sLog.outMMap("PathInfo::Update() for %u /n", m_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) ||        !HaveTile(newStart) || !HaveTile(newDest))    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    updateFilter();    BuildPolyPath(newStart, newDest);    return true;}

////////////////// PathInfo //////////////////PathInfo::PathInfo(const Unit* owner, const float destX, const float destY, const float destZ, bool useStraightPath) : m_pathPolyRefs(NULL),    m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(useStraightPath), m_sourceUnit(owner),    m_navMesh(NULL), m_navMeshQuery(NULL){    PathNode endPoint(destX, destY, destZ);    setEndPosition(endPoint);    float x,y,z;    m_sourceUnit->GetPosition(x, y, z);    PathNode startPoint(x, y, z);    setStartPosition(startPoint);    PATH_DEBUG("++ PathInfo::PathInfo for %u /n", m_sourceUnit->GetGUID());    const Map* map = m_sourceUnit->GetMap();    if (map->IsPathfindingEnabled())        m_navMesh = map->GetNavMesh();    if (m_navMesh)    {        m_navMeshQuery = dtAllocNavMeshQuery();        ASSERT(m_navMeshQuery);        if(DT_SUCCESS != m_navMeshQuery->init(m_navMesh, MESH_MAX_NODES))        {            sLog->outError("%u's PathInfo navMeshQuery failed to init", m_sourceUnit->GetGUID());            return;        }        BuildPolyPath(startPoint, endPoint);    }    else    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }}

////////////////// PathInfo //////////////////PathInfo::PathInfo(const Unit* owner, float destX, float destY, float destZ, bool forceDest) :    m_polyLength(0), m_type(PATHFIND_BLANK),    m_forceDestination(forceDest), m_pointPathLimit(MAX_POINT_PATH_LENGTH),    m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL){    PathNode endPoint(destX, destY, destZ);    setEndPosition(endPoint);    float x,y,z;    m_sourceUnit->GetPosition(x, y, z);    PathNode startPoint(x, y, z);    setStartPosition(startPoint);    //DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathInfo::PathInfo for %u /n", m_sourceUnit->GetGUIDLow());    uint32 mapId = m_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());    }    createFilter();    if (m_navMesh && m_navMeshQuery && HaveTile(endPoint) &&            !m_sourceUnit->hasUnitState(UNIT_STAT_IGNORE_PATHFINDING))    {        BuildPolyPath(startPoint, endPoint);    }    else    {        BuildShortcut();        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }}

bool PathGenerator::CalculatePath(float destX, float destY, float destZ, bool forceDest, bool straightLine){    float x, y, z;    _sourceUnit->GetPosition(x, y, z);    if (!Trinity::IsValidMapCoord(destX, destY, destZ) || !Trinity::IsValidMapCoord(x, y, z))        return false;    TC_METRIC_EVENT("mmap_events", "CalculatePath", "");    G3D::Vector3 dest(destX, destY, destZ);    SetEndPosition(dest);    G3D::Vector3 start(x, y, z);    SetStartPosition(start);    _forceDestination = forceDest;    _straightLine = straightLine;    TC_LOG_DEBUG("maps", "++ PathGenerator::CalculatePath() for %s", _sourceUnit->GetGUID().ToString().c_str());    // 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 (!_navMesh || !_navMeshQuery || _sourceUnit->HasUnitState(UNIT_STATE_IGNORE_PATHFINDING) ||        !HaveTile(start) || !HaveTile(dest))    {        BuildShortcut();        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);        return true;    }    UpdateFilter();    BuildPolyPath(start, dest);    return true;}

void PathInfo::BuildPolyPath(PathNode startPos, PathNode endPos){    // *** getting start/end poly logic ***    float distToStartPoly, distToEndPoly;    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);    // we have a hole in our mesh    // make shortcut path and mark it as NOPATH ( with flying exception )    // its up to caller how he will use this info    if (startPoly == INVALID_POLYREF || endPoly == INVALID_POLYREF)    {        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ BuildPolyPath :: (startPoly == 0 || endPoly == 0)/n");        BuildShortcut();        m_type = (m_sourceUnit->GetTypeId() == TYPEID_UNIT && ((Creature*)m_sourceUnit)->CanFly())                    ? PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH) : PATHFIND_NOPATH;        return;    }    // we may need a better number here    bool farFromPoly = (distToStartPoly > 7.0f || distToEndPoly > 7.0f);    if (farFromPoly)    {        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ BuildPolyPath :: farFromPoly distToStartPoly=%.3f distToEndPoly=%.3f/n", distToStartPoly, distToEndPoly);        bool buildShotrcut = false;        if (m_sourceUnit->GetTypeId() == TYPEID_UNIT)        {            Creature* owner = (Creature*)m_sourceUnit;            PathNode p = (distToStartPoly > 7.0f) ? startPos : endPos;            if (m_sourceUnit->GetTerrain()->IsUnderWater(p.x, p.y, p.z))            {                DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ BuildPolyPath :: underWater case/n");                if (owner->CanSwim())                    buildShotrcut = true;            }            else            {                DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ BuildPolyPath :: flying case/n");                if (owner->CanFly())                    buildShotrcut = true;            }        }        if (buildShotrcut)        {            BuildShortcut();            m_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))            {                dtVcopy(endPoint, closestPoint);                setActualEndPosition(PathNode(endPoint[2],endPoint[0],endPoint[1]));            }            m_type = PATHFIND_INCOMPLETE;        }    }    // *** poly path generating logic ***    // start and end are on same polygon    // just need to move in straight line    if (startPoly == endPoly)    {        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ BuildPolyPath :: (startPoly == endPoly)/n");        BuildShortcut();        m_pathPolyRefs[0] = startPoly;        m_polyLength = 1;        m_type = farFromPoly ? PATHFIND_INCOMPLETE : PATHFIND_NORMAL;        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ BuildPolyPath :: path type %d/n", m_type);        return;    }    // look for startPoly/endPoly in current path    // TODO: we can merge it with getPathPolyByPosition() loop    bool startPolyFound = false;    bool endPolyFound = false;    uint32 pathStartIndex, pathEndIndex;    if (m_polyLength)    {        for (pathStartIndex = 0; pathStartIndex < m_polyLength; ++pathStartIndex)        {            // here to carch few bugs            MANGOS_ASSERT(m_pathPolyRefs[pathStartIndex] != INVALID_POLYREF);//.........这里部分代码省略.........

void PathFinder::BuildPointPath(const float *startPoint, const float *endPoint){    float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE];    uint32 pointCount = 0;    dtStatus dtResult = DT_FAILURE;    if(m_useStraightPath)    {        dtResult = m_navMeshQuery->findStraightPath(                startPoint,         // start position                endPoint,           // end position                m_pathPolyRefs,     // current path                m_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    }    else    {        dtResult = findSmoothPath(                startPoint,         // start position                endPoint,           // end position                m_pathPolyRefs,     // current path                m_polyLength,       // length of current path                pathPoints,         // [out] path corner points                (int*)&pointCount,                m_pointPathLimit);    // maximum number of points    }    if(pointCount < 2 || dtResult != DT_SUCCESS)    {        // only happens if pass bad data to findStraightPath or navmesh is broken        // single point paths can be generated here        // TODO : check the exact cases        sLog->outDebug(LOG_FILTER_PATHFINDING, "++ PathFinder::BuildPointPath FAILED! path sized %d returned/n", pointCount);        BuildShortcut();        m_type = PATHFIND_NOPATH;        return;    }    m_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]);    // first point is always our current location - we need the next one    setActualEndPosition(m_pathPoints[pointCount-1]);    // force the given destination, if needed    if(m_forceDestination &&        (!(m_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()))        {            setActualEndPosition(getEndPosition());            m_pathPoints[m_pathPoints.size()-1] = getEndPosition();        }        else        {            setActualEndPosition(getEndPosition());            BuildShortcut();        }        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }    sLog->outDebug(LOG_FILTER_PATHFINDING, "++ PathFinder::BuildPointPath path type %d size %d poly-size %d/n", m_type, pointCount, m_polyLength);}

			void GuiToolstripCommand::SetShortcutBuilder(const WString& value)			{				BuildShortcut(value);			}

void PathFinderMovementGenerator::BuildPointPath(const float *startPoint, const float *endPoint){    float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE];    uint32 pointCount = 0;    dtStatus dtResult = DT_FAILURE;    if (m_useStraightPath)    {        dtResult = m_navMeshQuery->findStraightPath(                startPoint,         // start position                endPoint,           // end position                m_pathPolyRefs,     // current path                m_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    }    else    {        dtResult = findSmoothPath(                startPoint,         // start position                endPoint,           // end position                m_pathPolyRefs,     // current path                m_polyLength,       // length of current path                pathPoints,         // [out] path corner points                (int*)&pointCount,                m_pointPathLimit);    // maximum number of points    }    if (pointCount < 2 || dtResult != DT_SUCCESS)    {        // only happens if pass bad data to findStraightPath or navmesh is broken        // single point paths can be generated here        // TODO : check the exact cases        sLog->outDebug(LOG_FILTER_MAPS, "++ PathFinderMovementGenerator::BuildPointPath FAILED! path sized %d returned/n", pointCount);        BuildShortcut();        m_type = PATHFIND_NOPATH;        return;    }    else if (pointCount == m_pointPathLimit)    {        sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath FAILED! path sized %d returned, lower than limit set to %d/n", pointCount, m_pointPathLimit);        BuildShortcut();        m_type = PATHFIND_SHORT;        return;    }    m_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]);    // first point is always our current location - we need the next one    setActualEndPosition(m_pathPoints[pointCount-1]);    // force the given destination, if needed    if(m_forceDestination &&        (!(m_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()))        {            setActualEndPosition(getEndPosition());            m_pathPoints[m_pathPoints.size()-1] = getEndPosition();        }        else        {            setActualEndPosition(getEndPosition());            BuildShortcut();        }        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }	// Custom point for bugged zone - start    float startEndDist = dist3DSqr(getStartPosition(), getEndPosition());       // Blade's Edge Arena (mapid)	if (m_sourceUnit->GetMapId() == 562)    {    	// Start & End Position		// NAPOLOVINA RABOTESHT PILLAR		if (startEndDist < 3000.0f && startPoint[1] >= 9.000000f && startPoint[2] <= 6234.335938f && startPoint[2] >= 6224.140430f && startPoint[0] >= 244.160000f && startPoint[0] <= 255.118940f) // southeast pillar	    {			clear();            m_pathPoints.resize(4);			m_pathPoints[0] = getStartPosition();			m_pathPoints[1] = Vector3(6231.038574f, 252.630981f, 11.300000f);			m_pathPoints[2] = Vector3(6234.254395f, 256.513702f, 11.280000f);			m_pathPoints[3] = getEndPosition();		}		// Problemna chast:		else if (startEndDist < 3000.0f && endPoint[1] >= 9.000000f && endPoint[2] <= 6234.335938f && endPoint[2] >= 6224.140430f && endPoint[0] >= 244.160000f && endPoint[0] <= 255.118940f) // southeast pillar		{			clear();            m_pathPoints.resize(4);		    m_pathPoints[0] = getStartPosition();			m_pathPoints[1] = Vector3(6234.254395f, 256.513702f, 11.280000f);			m_pathPoints[2] = Vector3(6231.038574f, 252.630981f, 11.300000f);//.........这里部分代码省略.........

void PathGenerator::BuildPointPath(const float *startPoint, const float *endPoint){    float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE];    uint32 pointCount = 0;    dtStatus dtResult = DT_FAILURE;    if (_straightLine)    {        // if the path is a straight line then start and end position are enough        dtResult = DT_SUCCESS;        pointCount = 2;        memcpy(&pathPoints[0], startPoint, sizeof(float)* 3);        memcpy(&pathPoints[3], endPoint, sizeof(float)* 3);    }    else if (_useStraightPath)    {        dtResult = _navMeshQuery->findStraightPath(                startPoint,         // start position                endPoint,           // end position                _pathPolyRefs,     // current path                _polyLength,       // lenth of current path                pathPoints,         // [out] path corner points                NULL,               // [out] flags                NULL,               // [out] shortened path                (int*)&pointCount,                _pointPathLimit);   // maximum number of points/polygons to use    }    else    {        dtResult = FindSmoothPath(                startPoint,         // start position                endPoint,           // end position                _pathPolyRefs,     // current path                _polyLength,       // length of current path                pathPoints,         // [out] path corner points                (int*)&pointCount,                _pointPathLimit);    // maximum number of points    }    if (pointCount < 2 || dtStatusFailed(dtResult))    {        // only happens if pass bad data to findStraightPath or navmesh is broken        // single point paths can be generated here        /// @todo check the exact cases        TC_LOG_DEBUG("maps", "++ PathGenerator::BuildPointPath FAILED! path sized %d returned/n", pointCount);        BuildShortcut();        _type = PATHFIND_NOPATH;        return;    }    else if (pointCount == _pointPathLimit)    {        TC_LOG_DEBUG("maps", "++ PathGenerator::BuildPointPath FAILED! path sized %d returned, lower than limit set to %d/n", pointCount, _pointPathLimit);        BuildShortcut();        _type = PATHFIND_SHORT;        return;    }    _pathPoints.resize(pointCount);    for (uint32 i = 0; i < pointCount; ++i)        _pathPoints[i] = G3D::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(_pathPoints[pointCount-1]);    // force the given destination, if needed    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()))        {            SetActualEndPosition(GetEndPosition());            _pathPoints[_pathPoints.size()-1] = GetEndPosition();        }        else        {            SetActualEndPosition(GetEndPosition());            BuildShortcut();        }        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }    TC_LOG_DEBUG("maps", "++ PathGenerator::BuildPointPath path type %d size %d poly-size %d/n", _type, pointCount, _polyLength);}

void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 const& endPos){    // *** getting start/end poly logic ***    float distToStartPoly, distToEndPoly;    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);    // we have a hole in our mesh    // make shortcut path and mark it as NOPATH ( with flying and swimming exception )    // its up to caller how he will use this info    if (startPoly == INVALID_POLYREF || endPoly == INVALID_POLYREF)    {        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (startPoly == 0 || endPoly == 0)/n");        BuildShortcut();        bool path = _sourceUnit->GetTypeId() == TYPEID_UNIT && _sourceUnit->ToCreature()->CanFly();        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 < _pathPoints.size(); ++i)            {                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)                {                    waterPath = false;                    break;                }            }        }        _type = (path || waterPath) ? PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH) : PATHFIND_NOPATH;        return;    }    // we may need a better number here    bool farFromPoly = (distToStartPoly > 7.0f || distToEndPoly > 7.0f);    if (farFromPoly)    {        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: farFromPoly distToStartPoly=%.3f distToEndPoly=%.3f/n", distToStartPoly, distToEndPoly);        bool buildShotrcut = false;        if (_sourceUnit->GetTypeId() == TYPEID_UNIT)        {            Creature* owner = (Creature*)_sourceUnit;            G3D::Vector3 const& p = (distToStartPoly > 7.0f) ? startPos : endPos;            if (_sourceUnit->GetBaseMap()->IsUnderWater(p.x, p.y, p.z))            {                TC_LOG_DEBUG("maps", "++ BuildPolyPath :: underWater case/n");                if (owner->CanSwim())                    buildShotrcut = true;            }            else            {                TC_LOG_DEBUG("maps", "++ BuildPolyPath :: flying case/n");                if (owner->CanFly())                    buildShotrcut = true;            }        }        if (buildShotrcut)        {            BuildShortcut();            _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);            return;        }        else        {            float closestPoint[VERTEX_SIZE];            // we may want to use closestPointOnPolyBoundary instead            if (dtStatusSucceed(_navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint, NULL)))            {                dtVcopy(endPoint, closestPoint);                SetActualEndPosition(G3D::Vector3(endPoint[2], endPoint[0], endPoint[1]));            }            _type = PATHFIND_INCOMPLETE;        }    }    // *** poly path generating logic ***    // start and end are on same polygon    // just need to move in straight line    if (startPoly == endPoly)    {        TC_LOG_DEBUG("maps", "++ BuildPolyPath :: (startPoly == endPoly)/n");        BuildShortcut();        _pathPolyRefs[0] = startPoly;        _polyLength = 1;        _type = farFromPoly ? PATHFIND_INCOMPLETE : PATHFIND_NORMAL;//.........这里部分代码省略.........

void PathFinder::BuildPointPath(const float* startPoint, const float* endPoint){    float pathPoints[MAX_POINT_PATH_LENGTH * VERTEX_SIZE];    uint32 pointCount = 0;    dtStatus dtResult = DT_FAILURE;    if (m_useStraightPath)    {        dtResult = m_navMeshQuery->findStraightPath(                startPoint,         // start position                endPoint,           // end position                m_pathPolyRefs,     // current path                m_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    }    else    {        dtResult = findSmoothPath(                startPoint,         // start position                endPoint,           // end position                m_pathPolyRefs,     // current path                m_polyLength,       // length of current path                pathPoints,         // [out] path corner points                (int*)&pointCount,                m_pointPathLimit);    // maximum number of points    }    if (pointCount < 2 || dtStatusFailed(dtResult))    {        // only happens if pass bad data to findStraightPath or navmesh is broken        // single point paths can be generated here        // TODO : check the exact cases        DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathFinder::BuildPointPath FAILED! path sized %d returned/n", pointCount);        BuildShortcut();        m_type = PATHFIND_NOPATH;        return;    }    uint32 tempPointCounter = 2;    uint8  cutLimit         = 0;    PointsArray    tempPathPoints;    tempPathPoints.resize(pointCount);    for (uint32 i = 0; i < pointCount; ++i)        tempPathPoints[i] = Vector3(pathPoints[i*VERTEX_SIZE+2], pathPoints[i*VERTEX_SIZE], pathPoints[i*VERTEX_SIZE+1]);    // Optimize points    for (uint32 i = 1; i < pointCount - 1; ++i)    {        G3D::Vector3 p  = tempPathPoints[i];     // Point                G3D::Vector3 p1 = tempPathPoints[i - 1]; // PrevPoint        G3D::Vector3 p2 = tempPathPoints[i + 1]; // NextPoint        float line = (p1.y - p2.y) * p.x + (p2.x - p1.x) * p.y + (p1.x * p2.y - p2.x * p1.y);        if (fabs(line) < LINE_FAULT && cutLimit < SKIP_POINT_LIMIT)        {            tempPathPoints[i] = Vector3(0, 0, 0);            ++cutLimit;        }        else        {            ++tempPointCounter;            cutLimit = 0;        }    }    m_pathPoints.resize(tempPointCounter);    uint32 b = 0;    for (uint32 i = 0; i < pointCount; ++i)    {        if (tempPathPoints[i] != Vector3(0, 0, 0))        {            m_pathPoints[b] = tempPathPoints[i];            ++b;        }    }    pointCount = tempPointCounter;    // first point is always our current location - we need the next one    setActualEndPosition(m_pathPoints[pointCount - 1]);    // force the given destination, if needed    if (m_forceDestination &&        (!(m_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()))        {            setActualEndPosition(getEndPosition());            m_pathPoints[m_pathPoints.size()-1] = getEndPosition();        }        else//.........这里部分代码省略.........

void PathGenerator::BuildPointPath(const float *startPoint, const float *endPoint){    float pathPoints[MAX_POINT_PATH_LENGTH*VERTEX_SIZE];    uint32 pointCount = 0;    dtStatus dtResult = DT_FAILURE;    if (_useStraightPath)    {        dtResult = _navMeshQuery->findStraightPath(                startPoint,         // start position                endPoint,           // end position                _pathPolyRefs,     // current path                _polyLength,       // lenth of current path                pathPoints,         // [out] path corner points                NULL,               // [out] flags                NULL,               // [out] shortened path                (int*)&pointCount,                _pointPathLimit);   // maximum number of points/polygons to use    }    else    {        dtResult = FindSmoothPath(                startPoint,         // start position                endPoint,           // end position                _pathPolyRefs,     // current path                _polyLength,       // length of current path                pathPoints,         // [out] path corner points                (int*)&pointCount,                _pointPathLimit);    // maximum number of points    }    if (pointCount < 2 || dtResult != DT_SUCCESS)    {        // only happens if pass bad data to findStraightPath or navmesh is broken        // single point paths can be generated here        // TODO : check the exact cases        sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath FAILED! path sized %d returned/n", pointCount);        BuildShortcut();        _type = PATHFIND_NOPATH;        return;    }    else if (pointCount == _pointPathLimit)    {        sLog->outDebug(LOG_FILTER_MAPS, "++ PathGenerator::BuildPointPath FAILED! path sized %d returned, lower than limit set to %d/n", pointCount, _pointPathLimit);        BuildShortcut();        _type = PATHFIND_SHORT;        return;    }    _pathPoints.resize(pointCount);    for (uint32 i = 0; i < pointCount; ++i)        _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(_pathPoints[pointCount-1]);    // force the given destination, if needed    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()))        {            SetActualEndPosition(GetEndPosition());            _pathPoints[_pathPoints.size()-1] = GetEndPosition();        }        else        {            SetActualEndPosition(GetEndPosition());            BuildShortcut();        }        _type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);    }    //Custom Point for Bugged Zone (By saqi)      float startEndDist = Dist3DSqr(GetStartPosition(), GetEndPosition());           //Blade edge arena (mapid)        if (_sourceUnit->GetMapId() == 562)        {             //Your Position & Target Position            if (startEndDist < 2500.0f && endPoint[2] <= 6230.803223f && startPoint[2] >= 6230.803223f && endPoint[1] >= 11.000000 && startPoint[1] >= 11.000000f && endPoint[0] >= 247.547917f && endPoint[0] <= 252.298940f)      // southeast pillar            {              //  Path X,y,z                _pathPoints.resize(4);                _pathPoints[0] = GetStartPosition();                _pathPoints[1] = Vector3(6234.506836f, 256.696106f, 11.400018f);                _pathPoints[2] = Vector3(6231.472656f, 252.849335f, 11.400018f);                _pathPoints[3] = GetEndPosition();            }            else if (startEndDist < 2500.0f && endPoint[2] >= 6246.201660f && startPoint[2] <= 6246.201660f && endPoint[1] >= 11.000000f && startPoint[1] >= 11.000000f && endPoint[0] >= 217.677917f && endPoint[0] <= 276.888794f) // northwest pillar            {                //  Path X,y,z                _pathPoints.resize(4);                _pathPoints[0] = GetStartPosition();                _pathPoints[1] = Vector3(6242.146484f, 267.531030f, 11.400000f);                _pathPoints[2] = Vector3(6246.985352f, 271.076599f, 11.400000f);                _pathPoints[3] = GetEndPosition();//.........这里部分代码省略.........