src/Ai/Base/Actions/MovementActions.cpp

@@ -3221,26 +3221,34 @@ bool MovementAction::RefineWalkPoints(std::vector<G3D::Vector3>& walkPoints)
         WorldPosition aPos(mapId, a.x, a.y, a.z);
         WorldPosition bPos(mapId, b.x, b.y, b.z);
 
-        // Per-segment mmap query: routes around geometry the offline
-        // graph didn't account for, or returns empty if unreachable.
+        // Per-segment mmap query against the live navmesh. The
+        // travel-node graph stores offline-baked waypoints; if the
+        // straight line A->B crosses geometry the live navmesh has
+        // (mountain, ledge, model edit since offline gen), this
+        // returns either an mmap-routed path around it (NORMAL/
+        // INCOMPLETE) or empty (NOT_USING_PATH was rejected as
+        // "would walk through walls").
         std::vector<WorldPosition> segPath = bPos.getPathStepFrom(aPos, bot);
 
-        // Trust the raw waypoint pair when mmap can't validate it —
-        // navmesh gaps/tile-edge artifacts on short segments shouldn't
-        // kill an active plan. Travelnode waypoints are authoritative.
-        bool const trustRaw = segPath.empty() ||
-                              TravelPath::IsPathCheating(segPath, aPos.distance(bPos));
-
-        if (trustRaw)
+        if (segPath.empty())
         {
-            if (i == 0)
-                refined.emplace_back(a);
-            refined.emplace_back(b);
-            continue;
+            // Live mmap refuses A->B. Caller should abort the plan
+            // and let MoveFarTo's own probe re-derive a route.
+            return false;
         }
 
-        // Include the first segment's start; skip subsequent starts
-        // to avoid duplicating the prior segment's tail.
+        // Reject "pathfinder cheating" — same checks the offline gen
+        // applies to BuildPath. Catches cached segments where the
+        // live navmesh still produces a near-vertical hop or a
+        // 2-point straight line through geometry.
+        if (TravelPath::IsPathCheating(segPath, aPos.distance(bPos)))
+        {
+            return false;
+        }
+
+        // First segment: include its start point so the spline
+        // begins from the original A. Later segments: skip the first
+        // point — it duplicates the previous segment's tail.
         size_t startK = (i == 0) ? 0 : 1;
         for (size_t k = startK; k < segPath.size(); ++k)
             refined.emplace_back(segPath[k].GetPositionX(),

src/Ai/World/Rpg/Action/NewRpgBaseAction.cpp

@@ -163,12 +163,13 @@ bool NewRpgBaseAction::MoveFarTo(WorldPosition dest)
     //      waypoint spline at dest.
     bool tryNodes = (dis >= nodeFirstDis && sPlayerbotAIConfig.enableTravelNodes);
 
-    // Ride an active plan to completion as long as its destination
-    // still matches. Remaining distance can drop below nodeFirstDis
-    // mid-route (e.g. crossing a zone border near the target); killing
-    // the plan here would replace remaining waypoints with raw mmap
-    // and often produce a u-turn. Clear only on dest change.
-    if (botAI->rpgInfo.HasActiveTravelPlan())
+    // If a node plan is already active, ride it — but only if its
+    // destination still matches the requested dest. Otherwise the
+    // old plan (e.g. built toward a quest objective POI) would keep
+    // driving the bot after the caller switched targets (e.g. to a
+    // turn-in NPC). cmangos's ResolveMovePath dodges this by being
+    // stateless; we have a long-lived plan flag, so check explicitly.
+    if (tryNodes && botAI->rpgInfo.HasActiveTravelPlan())
     {
         if (botAI->rpgInfo.travelPlan.destination.distance(dest) > 10.0f)
             botAI->rpgInfo.ClearTravel();
@@ -191,6 +192,11 @@ bool NewRpgBaseAction::MoveFarTo(WorldPosition dest)
         }
         // Graph returned no plan — fall through to mmap probe.
     }
+    else if (botAI->rpgInfo.HasActiveTravelPlan())
+    {
+        // Move dropped below node-first threshold — drop any leftover plan.
+        botAI->rpgInfo.ClearTravel();
+    }
 
     // 40-step chained mmap probe — fallback when the node graph
     // returned no plan (or for short moves below nodeFirstDis).