Fix ship path finding for long distances

Flamefire · Flamefire · commit 4149525e6554 · 2026-05-03T20:45:42.000+02:00
Do not try to limit pathfinding for ships.
Instead store the most common routes: Those between harbors in a small, fast lookup table.
For other routes, e.g. from shipyards or lost ships, use a LRU cache and fall back to unlimited search.
diff --git a/libs/s25main/Pathfinding.cpp b/libs/s25main/Pathfinding.cpp
@@ -4,12 +4,14 @@
 
 #include "GamePlayer.h"
 #include "helpers/EnumRange.h"
+#include "helpers/IdRange.h"
 #include "pathfinding/FreePathFinder.h"
 #include "pathfinding/FreePathFinderImpl.h"
 #include "pathfinding/PathConditionHuman.h"
 #include "pathfinding/PathConditionShip.h"
 #include "pathfinding/PathConditionTrade.h"
 #include "pathfinding/RoadPathFinder.h"
+#include "pathfinding/ShipPathData.h"
 #include "world/GameWorld.h"
 #include "gameTypes/ShipDirection.h"
 #include "gameData/GameConsts.h"
@@ -51,11 +53,10 @@ RoadPathDirection GameWorld::FindPathForWareOnRoads(const noRoadNode& start, con
 }
 
 bool GameWorldBase::FindShipPathToHarbor(const MapPoint start, HarborId harborId, SeaId seaId,
-                                         std::vector<Direction>* route, unsigned* length)
+                                         std::vector<Direction>* route, unsigned* length) const
 {
-    // Find the distance to the furthest harbor from the target harbor and take that as maximum
-    unsigned maxDistance = 0;
     const MapPoint coastalPoint = GetCoastalPoint(harborId, seaId);
+    RTTR_Assert(coastalPoint.isValid());
 
     // already arrived?
     if(start == coastalPoint)
@@ -66,23 +67,52 @@ bool GameWorldBase::FindShipPathToHarbor(const MapPoint start, HarborId harborId
             route->clear();
         return true;
     }
+    auto& shipPathData = GetShipPathData();
+    // If we start from a harbor we can get the route directly w/o the costly pathfinding
+    for(const auto startHbId : helpers::idRange<HarborId>(GetNumHarborPoints()))
+    {
+        if(GetCoastalPoint(startHbId, seaId) == start)
+        {
+            auto hbRoute = shipPathData.getHarborConnection(startHbId, harborId, seaId);
+            if(length)
+                *length = hbRoute.size();
+            if(route)
+                *route = std::move(hbRoute);
+        }
+    }
 
-    for(const auto dir : helpers::EnumRange<ShipDirection>{})
+    // Try cache first
+    bool reversed = false;
+    if(const auto* cachedPath = shipPathData.findCachedPath(start, coastalPoint, reversed))
     {
-        const std::vector<HarborPos::Neighbor>& neighbors = GetHarborNeighbors(harborId, dir);
-        for(const HarborPos::Neighbor& neighbor : neighbors)
+        if(route)
         {
-            if(IsHarborAtSea(neighbor.id, seaId) && neighbor.distance > maxDistance)
-                maxDistance = neighbor.distance;
+            *route = *cachedPath;
+            if(reversed)
+            {
+                std::reverse(route->begin(), route->end());
+                for(auto& d : *route)
+                    d = d + 3u; // reverse direction
+            }
         }
+        if(length)
+            *length = cachedPath->size();
+        return true;
     }
-    // Add a few fields reserve
-    maxDistance += 6;
-    return FindShipPath(start, coastalPoint, maxDistance, route, length);
+
+    // Not in cache -> compute full path and add
+    std::vector<Direction> newRoute;
+    if(!FindShipPath(start, coastalPoint, std::numeric_limits<unsigned>::max(), &newRoute, length))
+        return false;
+    shipPathData.addToCache(start, coastalPoint, newRoute);
+    if(route)
+        *route = std::move(newRoute);
+
+    return true;
 }
 
 bool GameWorldBase::FindShipPath(const MapPoint start, const MapPoint dest, unsigned maxDistance,
-                                 std::vector<Direction>* route, unsigned* length)
+                                 std::vector<Direction>* route, unsigned* length) const
 {
     return GetFreePathFinder().FindPath(start, dest, true, maxDistance, route, length, nullptr,
                                         PathConditionShip(*this));
diff --git a/libs/s25main/nodeObjs/noShip.cpp b/libs/s25main/nodeObjs/noShip.cpp
@@ -22,6 +22,7 @@
 #include "notifications/ShipNote.h"
 #include "ogl/glArchivItem_Bitmap.h"
 #include "ogl/glArchivItem_Bitmap_Player.h"
+#include "pathfinding/ShipPathData.h"
 #include "postSystem/ShipPostMsg.h"
 #include "random/Random.h"
 #include "world/GameWorld.h"
@@ -952,7 +953,6 @@ void noShip::AbortSeaAttack()
     }
 }
 
-/// Fängt an zu einem Hafen zu fahren (berechnet Route usw.)
 void noShip::StartDrivingToHarborPlace()
 {
     if(!goalHarbor)
@@ -967,28 +967,28 @@ void noShip::StartDrivingToHarborPlace()
         route_.clear();
     else
     {
-        bool routeFound;
-        // Use upper bound to distance by checking the distance between the harbors if we still have and are at the home
-        // harbor
+        // if we still have and are at the home harbor get route directly
         if(homeHarbor && pos == world->GetCoastalPoint(homeHarbor, seaId_))
         {
-            // Use the maximum distance between the harbors plus 6 fields
-            unsigned maxDistance = world->GetMinHarborDistance(homeHarbor, goalHarbor) + 6;
-            routeFound = world->FindShipPath(pos, coastalPos, maxDistance, &route_, nullptr);
+            route_ = world->GetShipPathData().getHarborConnection(homeHarbor, goalHarbor, seaId_);
+            RTTR_Assert(!route_.empty());
         } else
-            routeFound = world->FindShipPathToHarbor(pos, goalHarbor, seaId_, &route_, nullptr);
-        if(!routeFound)
         {
-            // todo
-            RTTR_Assert(false);
-            LOG.write("WARNING: Bug detected (GF: %u). Please report this with the savegame and "
-                      "replay.\nnoShip::StartDrivingToHarborPlace: Schiff hat keinen Weg gefunden!\nplayer %i state %i "
-                      "pos %u,%u goal "
-                      "coastal %u,%u goal-id %i goalpos %u,%u \n")
-              % GetEvMgr().GetCurrentGF() % unsigned(ownerId_) % unsigned(state) % pos.x % pos.y % coastalPos.x
-              % coastalPos.y % goalHarbor % world->GetHarborPoint(goalHarbor).x % world->GetHarborPoint(goalHarbor).y;
-            goalHarbor.reset();
-            return;
+            if(!world->FindShipPathToHarbor(pos, goalHarbor, seaId_, &route_, nullptr))
+            {
+                // todo
+                RTTR_Assert(false);
+                LOG.write(
+                  "WARNING: Bug detected (GF: %u). Please report this with the savegame and "
+                  "replay.\nnoShip::StartDrivingToHarborPlace: Schiff hat keinen Weg gefunden!\nplayer %i state %i "
+                  "pos %u,%u goal "
+                  "coastal %u,%u goal-id %i goalpos %u,%u \n")
+                  % GetEvMgr().GetCurrentGF() % unsigned(ownerId_) % unsigned(state) % pos.x % pos.y % coastalPos.x
+                  % coastalPos.y % goalHarbor % world->GetHarborPoint(goalHarbor).x
+                  % world->GetHarborPoint(goalHarbor).y;
+                goalHarbor.reset();
+                return;
+            }
         }
     }
     curRouteIdx = 0;
diff --git a/libs/s25main/pathfinding/ShipPathData.cpp b/libs/s25main/pathfinding/ShipPathData.cpp
@@ -0,0 +1,92 @@
+// Copyright (C) 2005 - 2026 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "ShipPathData.h"
+#include "EventManager.h"
+#include "helpers/IdRange.h"
+#include "helpers/containerUtils.h"
+#include "pathfinding/FreePathFinder.h"
+#include "pathfinding/PathConditionShip.h"
+#include "world/GameWorldBase.h"
+#include <algorithm>
+#include <set>
+
+struct ShipPathData::HarborConnection::Matcher
+{
+    HarborId harbor;
+    SeaId sea;
+    bool operator()(const ShipPathData::HarborConnection& con) { return con.destHarbor == harbor && con.sea == sea; }
+};
+
+std::vector<Direction> ShipPathData::getHarborConnection(HarborId startHarbor, HarborId destHarbor, SeaId seaId)
+{
+    if(harborConnections_.empty())
+        initHarborConnections();
+    const auto it = helpers::find_if(harborConnections_[startHarbor], HarborConnection::Matcher{destHarbor, seaId});
+    RTTR_Assert(it != harborConnections_[startHarbor].end());
+    return it->route;
+}
+
+const std::vector<Direction>* ShipPathData::findCachedPath(MapPoint start, MapPoint dest, bool& reversed) const
+{
+    for(unsigned i = 0; i < cachedPaths_.size(); ++i)
+    {
+        const PathEntry& e = cachedPaths_[i];
+        const_cast<PathEntry&>(e).lastUse = world_.GetEvMgr().GetCurrentGF();
+        if(e.start == start && e.dest == dest)
+        {
+            reversed = false;
+            return &e.route;
+        }
+        if(e.start == dest && e.dest == start)
+        {
+            reversed = true;
+            return &e.route;
+        }
+    }
+    return nullptr;
+}
+
+void ShipPathData::addToCache(MapPoint start, MapPoint dest, std::vector<Direction> route)
+{
+    PathEntry entry{start, dest, world_.GetEvMgr().GetCurrentGF(), std::move(route)};
+    if(cachedPaths_.size() < cachedPaths_.max_size())
+        cachedPaths_.emplace_back(std::move(entry));
+    else
+    {
+        const auto itOldest =
+          std::min_element(cachedPaths_.begin(), cachedPaths_.end(),
+                           [](const PathEntry& a, const PathEntry& b) { return a.lastUse < b.lastUse; });
+        *itOldest = std::move(entry);
+    }
+}
+
+void ShipPathData::initHarborConnections()
+{
+    harborConnections_.resize(world_.GetNumHarborPoints());
+    for(const auto startHbId : helpers::idRange<HarborId>(world_.GetNumHarborPoints()))
+    {
+        auto& curConnections = harborConnections_[startHbId];
+        std::vector<HarborPos::Neighbor> neighbors;
+        for(const auto dir : helpers::EnumRange<ShipDirection>{})
+        {
+            const auto& curNbs = world_.GetHarborNeighbors(startHbId, dir);
+            neighbors.insert(neighbors.end(), curNbs.begin(), curNbs.end());
+        }
+        for(const auto& nb : neighbors)
+        {
+            RTTR_Assert(startHbId != nb.id);
+            RTTR_Assert(nb.sea);
+            // Connections are unique
+            RTTR_Assert(!helpers::contains_if(curConnections, HarborConnection::Matcher{nb.id, nb.sea}));
+            curConnections.push_back(HarborConnection{nb.id, nb.sea});
+            unsigned len;
+            const bool found =
+              world_.FindShipPath(world_.GetCoastalPoint(startHbId, nb.sea), world_.GetCoastalPoint(nb.id, nb.sea),
+                                  nb.distance, &curConnections.back().route, &len);
+            RTTR_Assert(found);
+            RTTR_Assert(len == nb.distance);
+        }
+    }
+}
diff --git a/libs/s25main/pathfinding/ShipPathData.h b/libs/s25main/pathfinding/ShipPathData.h
@@ -0,0 +1,58 @@
+// Copyright (C) 2005 - 2026 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <boost/container/small_vector.hpp>
+#include <boost/container/static_vector.hpp>
+#include <gameTypes/Direction.h>
+#include <gameTypes/MapCoordinates.h>
+#include <gameTypes/MapTypes.h>
+#include <helpers/StrongIdVector.h>
+#include <vector>
+
+class GameWorldBase;
+
+/// Implements data for finding ship paths.
+/// Assumes seas and land don't change so paths can be heavily cached.
+/// Most paths are between harbor points and can be queried directly, for others a LRU cache is provided
+class ShipPathData
+{
+public:
+    ShipPathData(const GameWorldBase& world) : world_(world) {}
+    /// Get route from start to destination harbor on the given sea.
+    /// Assumes it exists, i.e. they both have a coast at that sea.
+    std::vector<Direction> getHarborConnection(HarborId startHarbor, HarborId destHarbor, SeaId seaId);
+    /// Find a route in the cache
+    /// Return reference to it if found, else nullptr.
+    /// Sets `reversed` to true if start and dest of the route are swapped
+    const std::vector<Direction>* findCachedPath(MapPoint start, MapPoint dest, bool& reversed) const;
+    void addToCache(MapPoint start, MapPoint dest, std::vector<Direction> route);
+
+private:
+    const GameWorldBase& world_;
+    struct HarborConnection
+    {
+        HarborId destHarbor;
+        SeaId sea;
+        std::vector<Direction> route;
+        struct Matcher;
+    };
+
+    /// Connections from a harbor to others.
+    /// Usually only a small number of harbors are reachable, so inline some.
+    using HarborConnectionVector = boost::container::small_vector<HarborConnection, 8>;
+    helpers::StrongIdVector<HarborConnectionVector, HarborId> harborConnections_;
+
+    struct PathEntry
+    {
+        MapPoint start;
+        MapPoint dest;
+        unsigned lastUse;
+        std::vector<Direction> route;
+    };
+    // LRU cache for arbitrary ship paths (start,dest).
+    boost::container::static_vector<PathEntry, 16> cachedPaths_;
+
+    void initHarborConnections();
+};
diff --git a/libs/s25main/world/GameWorldBase.cpp b/libs/s25main/world/GameWorldBase.cpp
@@ -22,6 +22,7 @@
 #include "notifications/PlayerNodeNote.h"
 #include "pathfinding/FreePathFinder.h"
 #include "pathfinding/RoadPathFinder.h"
+#include "pathfinding/ShipPathData.h"
 #include "nodeObjs/noFlag.h"
 #include "gameData/BuildingProperties.h"
 #include "gameData/GameConsts.h"
@@ -81,6 +82,13 @@ bool GameWorldBase::IsSinglePlayer() const
     return true;
 }
 
+ShipPathData& GameWorldBase::GetShipPathData() const
+{
+    if(!shipPathData)
+        shipPathData = std::make_unique<ShipPathData>(*this);
+    return *shipPathData;
+}
+
 bool GameWorldBase::IsRoadAvailable(const bool boat_road, const MapPoint pt) const
 {
     // Hindernisse
diff --git a/libs/s25main/world/GameWorldBase.h b/libs/s25main/world/GameWorldBase.h
@@ -16,6 +16,7 @@
 #include <set>
 #include <vector>
 
+class ShipPathData;
 class EventManager;
 class FreePathFinder;
 class GameInterface;
@@ -51,6 +52,7 @@ class GameWorldBase : public World
 {
     std::unique_ptr<RoadPathFinder> roadPathFinder;
     std::unique_ptr<FreePathFinder> freePathFinder;
+    mutable std::unique_ptr<ShipPathData> shipPathData;
     PostManager postManager;
     mutable NotificationManager notifications;
 
@@ -114,12 +116,13 @@ class GameWorldBase : public World
     /// Find path for ships to a specific harbor and see. Return true on success
     /// If starting point equals the coastal point of target harbor, set length 0, clear route and return true.
     bool FindShipPathToHarbor(MapPoint start, HarborId harborId, SeaId seaId, std::vector<Direction>* route,
-                              unsigned* length);
+                              unsigned* length) const;
     /// Find path for ships with a limited distance. Return true on success
     bool FindShipPath(MapPoint start, MapPoint dest, unsigned maxDistance, std::vector<Direction>* route,
-                      unsigned* length);
+                      unsigned* length) const;
     RoadPathFinder& GetRoadPathFinder() const { return *roadPathFinder; }
     FreePathFinder& GetFreePathFinder() const { return *freePathFinder; }
+    ShipPathData& GetShipPathData() const;
 
     /// Return flag that is on road at given point. dir will be set to the direction of the road from the returned flag
     /// prevDir (if set) will be skipped when searching for the road points
