Fix handling of harbors connected by multiple seas

Flamefire · Flamefire · commit c67fb2f1c32f · 2026-05-07T17:51:09.000+02:00
It could be possible that 2 harbors are at the same 2 seas.
The current harbor connections do not honor this and only store a single distance which would hence be wrong for one of those 2.
Store the seaId for each connection.
diff --git a/libs/s25main/Pathfinding.cpp b/libs/s25main/Pathfinding.cpp
@@ -90,7 +90,7 @@ bool GameWorldBase::FindShipPath(const MapPoint start, const MapPoint dest, unsi
 
 /// Prüft, ob eine Schiffsroute noch Gültigkeit hat
 bool GameWorld::CheckShipRoute(const MapPoint start, const std::vector<Direction>& route, const unsigned pos,
-                               MapPoint* dest)
+                               MapPoint* dest) const
 {
     return GetFreePathFinder().CheckRoute(start, route, pos, PathConditionShip(*this), dest);
 }
diff --git a/libs/s25main/SerializedGameData.cpp b/libs/s25main/SerializedGameData.cpp
@@ -108,7 +108,8 @@
 /// 12: leatheraddon added, three new building types and three new goods
 /// 13: SeaId & HarborId: World::harborData w/o dummy entry at 0
 /// 14: Remove "age" field in nobBaseMilitary
-static const unsigned currentGameDataVersion = 14;
+/// 15: Add sea to HarborPos::Neighbor
+static const unsigned currentGameDataVersion = 15;
 // clang-format on
 
 std::unique_ptr<GameObject> SerializedGameData::Create_GameObject(const GO_Type got, const unsigned obj_id)
diff --git a/libs/s25main/buildings/nobHarborBuilding.cpp b/libs/s25main/buildings/nobHarborBuilding.cpp
@@ -835,23 +835,27 @@ std::vector<nobHarborBuilding::ShipConnection> nobHarborBuilding::GetShipConnect
     if(world->GetGOT(pos) != GO_Type::NobHarborbuilding)
         return connections;
 
-    const auto sharesSeaWith = [&seaIds = this->seaIds, world = this->world](const nobHarborBuilding& harbor) {
+    const auto getSharedSea = [&seaIds = this->seaIds, world = this->world](const nobHarborBuilding& harbor) {
         for(SeaId seaId : seaIds)
         {
             if(seaId && world->IsHarborAtSea(harbor.GetHarborPosID(), seaId))
-                return true;
+                return seaId;
         }
-        return false;
+        return SeaId::invalidValue();
     };
     for(auto* harbor_building : world->GetPlayer(player).GetBuildingRegister().GetHarbors())
     {
-        if(harbor_building != this && sharesSeaWith(*harbor_building))
+        if(harbor_building == this)
+            continue;
+        SeaId seaId = getSharedSea(*harbor_building);
+        if(seaId)
         {
             ShipConnection sc;
             sc.dest = harbor_building;
             // Use twice the distance as cost (ship might need to arrive first) and a fixed value to represent
             // loading&unloading
-            sc.way_costs = 2 * world->CalcHarborDistance(GetHarborPosID(), harbor_building->GetHarborPosID()) + 10;
+            sc.way_costs =
+              2 * world->GetHarborDistance(GetHarborPosID(), harbor_building->GetHarborPosID(), seaId) + 10;
             connections.push_back(sc);
         }
     }
@@ -1166,10 +1170,10 @@ nobHarborBuilding::GetAttackerBuildingsForSeaAttack(const std::vector<HarborId>&
             continue;
 
         // Entfernung zwischen Hafen und möglichen Zielhafenpunkt ausrechnen
-        unsigned min_distance = 0xffffffff;
+        auto min_distance = std::numeric_limits<unsigned>::max();
         for(HarborId defender_harbor : defender_harbors)
         {
-            min_distance = std::min(min_distance, world->CalcHarborDistance(GetHarborPosID(), defender_harbor));
+            min_distance = std::min(min_distance, world->GetMinHarborDistance(GetHarborPosID(), defender_harbor));
         }
 
         // Gebäude suchen, vielleicht schon vorhanden?
@@ -1202,7 +1206,7 @@ void nobHarborBuilding::AddSeaAttacker(std::unique_ptr<nofAttacker> attacker)
       world->GetHarborPointsAroundMilitaryBuilding(attacker->GetAttackedGoal()->GetPos());
     for(HarborId harbor_point : harbor_points)
     {
-        unsigned tmp_distance = world->CalcHarborDistance(this->GetHarborPosID(), harbor_point);
+        unsigned tmp_distance = world->GetMinHarborDistance(this->GetHarborPosID(), harbor_point);
         if(tmp_distance < best_distance)
         {
             best_distance = tmp_distance;
diff --git a/libs/s25main/gameTypes/HarborPos.h b/libs/s25main/gameTypes/HarborPos.h
@@ -15,13 +15,19 @@ struct HarborPos
     struct Neighbor
     {
         HarborId id;
+        SeaId sea;
         unsigned distance;
 
-        Neighbor(HarborId id, unsigned distance) noexcept : id(id), distance(distance) {}
+        Neighbor(HarborId id, SeaId sea, unsigned distance) noexcept : id(id), sea(sea), distance(distance) {}
 
         bool operator<(const Neighbor& two) const noexcept
         {
-            return (distance < two.distance) || (distance == two.distance && id.value() < two.id.value());
+            if(distance == two.distance)
+            {
+                if(sea != two.sea)
+                    return sea.value() < two.sea.value();
+            }
+            return id.value() < two.id.value();
         }
     };
 
diff --git a/libs/s25main/nodeObjs/noShip.cpp b/libs/s25main/nodeObjs/noShip.cpp
@@ -973,7 +973,7 @@ void noShip::StartDrivingToHarborPlace()
         if(homeHarbor && pos == world->GetCoastalPoint(homeHarbor, seaId_))
         {
             // Use the maximum distance between the harbors plus 6 fields
-            unsigned maxDistance = world->CalcHarborDistance(homeHarbor, goalHarbor) + 6;
+            unsigned maxDistance = world->GetMinHarborDistance(homeHarbor, goalHarbor) + 6;
             routeFound = world->FindShipPath(pos, coastalPos, maxDistance, &route_, nullptr);
         } else
             routeFound = world->FindShipPathToHarbor(pos, goalHarbor, seaId_, &route_, nullptr);
diff --git a/libs/s25main/world/GameWorld.h b/libs/s25main/world/GameWorld.h
@@ -94,7 +94,7 @@ class GameWorld : public GameWorldBase
                                              unsigned* length = nullptr, MapPoint* firstPt = nullptr,
                                              unsigned max = std::numeric_limits<unsigned>::max());
     /// Prüft, ob eine Schiffsroute noch Gültigkeit hat
-    bool CheckShipRoute(MapPoint start, const std::vector<Direction>& route, unsigned pos, MapPoint* dest);
+    bool CheckShipRoute(MapPoint start, const std::vector<Direction>& route, unsigned pos, MapPoint* dest) const;
     /// Find a route for trade caravanes
     helpers::OptionalEnum<Direction> FindTradePath(MapPoint start, MapPoint dest, unsigned char player,
                                                    unsigned max_route = 0xffffffff, bool random_route = false,
diff --git a/libs/s25main/world/MapLoader.cpp b/libs/s25main/world/MapLoader.cpp
@@ -483,24 +483,6 @@ bool MapLoader::InitSeasAndHarbors(World& world, const std::vector<MapPoint>& ad
 
     // Calculate the neighbors and distances
     CalcHarborPosNeighbors(world);
-
-    // Validate
-    for(const auto startHbId : helpers::idRange<HarborId>(world.harborData.size()))
-    {
-        const HarborPos& startHbPos = world.harborData[startHbId];
-        for(const std::vector<HarborPos::Neighbor>& neighbors : startHbPos.neighbors)
-        {
-            for(const HarborPos::Neighbor& neighbor : neighbors)
-            {
-                if(world.CalcHarborDistance(neighbor.id, startHbId) != neighbor.distance)
-                {
-                    LOG.write("Bug: Harbor distance mismatch for harbors %1%->%2%: %3% != %4%\n") % startHbId
-                      % neighbor.id % world.CalcHarborDistance(neighbor.id, startHbId) % neighbor.distance;
-                    return false;
-                }
-            }
-        }
-    }
     return true;
 }
 
@@ -579,12 +561,12 @@ void MapLoader::CalcHarborPosNeighbors(World& world)
         for(const MapPoint& ownCoastPt : ownCoastalPoints)
         {
             // Special case: Get all harbors that share the coast point with us
-            SeaId seaId = world.GetSeaFromCoastalPoint(ownCoastPt);
+            const SeaId seaId = world.GetSeaFromCoastalPoint(ownCoastPt);
             auto const coastToHbs = coastToHarborPerSea[seaId].equal_range(world.GetIdx(ownCoastPt));
             for(auto it = coastToHbs.first; it != coastToHbs.second; ++it)
             {
                 ShipDirection shipDir = world.GetShipDir(ownCoastPt, ownCoastPt);
-                world.harborData[startHbId].neighbors[shipDir].push_back(HarborPos::Neighbor(it->second, 0));
+                world.harborData[startHbId].neighbors[shipDir].push_back(HarborPos::Neighbor(it->second, seaId, 0));
                 hbFound[it->second] = true;
             }
             todo_list.push(CalcHarborPosNeighborsNode(ownCoastPt, 0));
@@ -610,8 +592,9 @@ void MapLoader::CalcHarborPosNeighbors(World& world)
 
                 if(ptValue > 0) // found harbor(s)
                 {
-                    ShipDirection shipDir = world.GetShipDir(world.harborData[startHbId].pos, curPt);
-                    SeaId seaId = world.GetSeaFromCoastalPoint(curPt);
+                    const ShipDirection shipDir = world.GetShipDir(world.harborData[startHbId].pos, curPt);
+                    const SeaId seaId = world.GetSeaFromCoastalPoint(curPt);
+                    RTTR_Assert(seaId);
                     auto const coastToHbs = coastToHarborPerSea[seaId].equal_range(idx);
                     for(auto it = coastToHbs.first; it != coastToHbs.second; ++it)
                     {
@@ -621,11 +604,10 @@ void MapLoader::CalcHarborPosNeighbors(World& world)
 
                         hbFound[otherHbId] = true;
                         world.harborData[startHbId].neighbors[shipDir].push_back(
-                          HarborPos::Neighbor(otherHbId, curNode.distance + 1));
+                          HarborPos::Neighbor(otherHbId, seaId, curNode.distance + 1));
 
                         // Make this the only coastal point of this harbor for this sea
                         HarborPos& otherHb = world.harborData[otherHbId];
-                        RTTR_Assert(seaId);
                         for(const auto hbDir : helpers::EnumRange<Direction>{})
                         {
                             if(otherHb.seaIds[hbDir] == seaId && world.GetNeighbour(otherHb.pos, hbDir) != curPt)
diff --git a/libs/s25main/world/MapSerializer.cpp b/libs/s25main/world/MapSerializer.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2026 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,10 +7,12 @@
 #include "Game.h"
 #include "SerializedGameData.h"
 #include "buildings/noBuildingSite.h"
+#include "helpers/IdRange.h"
 #include "helpers/Range.h"
 #include "lua/GameDataLoader.h"
 #include "world/GameWorldBase.h"
 #include "s25util/warningSuppression.h"
+#include <boost/container/static_vector.hpp>
 #include <mygettext/mygettext.h>
 
 void MapSerializer::Serialize(const GameWorldBase& world, SerializedGameData& sgd)
@@ -49,6 +51,7 @@ void MapSerializer::Serialize(const GameWorldBase& world, SerializedGameData& sg
             for(const auto& c : curNeighbors)
             {
                 sgd.PushUnsignedInt(c.id.value());
+                sgd.PushUnsignedInt(c.sea.value());
                 sgd.PushUnsignedInt(c.distance);
             }
         }
@@ -147,8 +150,11 @@ void MapSerializer::Deserialize(GameWorldBase& world, SerializedGameData& sgd, G
             {
                 RTTR_UNUSED(j);
                 const auto id = HarborId(sgd.PopUnsignedInt());
+                SeaId sea;
+                if(sgd.GetGameDataVersion() >= 15)
+                    sea = SeaId(sgd.PopUnsignedInt());
                 const auto distance = sgd.PopUnsignedInt();
-                neighbor.emplace_back(id, distance);
+                neighbor.emplace_back(id, sea, distance);
             }
         }
     }
@@ -158,6 +164,56 @@ void MapSerializer::Deserialize(GameWorldBase& world, SerializedGameData& sgd, G
         if(!world.harborData.front().pos.isValid())
             world.harborData.erase(world.harborData.begin());
     }
+    if(sgd.GetGameDataVersion() < 15)
+    {
+        const auto getSeas = [&world](const HarborId& hbId) {
+            boost::container::static_vector<SeaId, helpers::NumEnumValues_v<Direction>> seas;
+            for(const auto sea : world.harborData[hbId].seaIds)
+            {
+                if(sea)
+                    seas.push_back(sea);
+            }
+            return seas;
+        };
+        // Determine seas for neighbors
+        for(const auto startHbId : helpers::idRange<HarborId>(world.GetNumHarborPoints()))
+        {
+            const auto mySeas = getSeas(startHbId);
+            for(auto& neighborsPerDir : world.harborData[startHbId].neighbors)
+            {
+                for(auto& neighbor : neighborsPerDir)
+                {
+                    // Easy case: Either harbor is only at a single sea, so that must be the one
+                    if(mySeas.size() == 1u)
+                    {
+                        neighbor.sea = mySeas.front();
+                        continue;
+                    }
+                    const auto otherSeas = getSeas(neighbor.id);
+                    if(otherSeas.size() == 1u)
+                    {
+                        neighbor.sea = otherSeas.front();
+                        continue;
+                    }
+                    // Find the sea where this distance matches
+                    for(const auto sea : mySeas)
+                    {
+                        if(!helpers::contains(otherSeas, sea))
+                            continue;
+                        unsigned len;
+                        if(world.FindShipPath(world.GetCoastalPoint(startHbId, sea),
+                                              world.GetCoastalPoint(neighbor.id, sea), neighbor.distance, nullptr, &len)
+                           && len == neighbor.distance)
+                        {
+                            neighbor.sea = sea;
+                            break;
+                        }
+                    }
+                    RTTR_Assert(neighbor.sea);
+                }
+            }
+        }
+    }
 
     sgd.PopObjectContainer(world.harbor_building_sites_from_sea, GO_Type::Buildingsite);
 
diff --git a/libs/s25main/world/World.cpp b/libs/s25main/world/World.cpp
@@ -412,19 +412,35 @@ const std::vector<HarborPos::Neighbor>& World::GetHarborNeighbors(const HarborId
     return harborData[harborId].neighbors[dir];
 }
 
-unsigned World::CalcHarborDistance(HarborId haborId1, HarborId harborId2) const
+unsigned World::GetMinHarborDistance(HarborId haborId1, HarborId harborId2) const
 {
     if(haborId1 == harborId2) // special case: distance to self
         return 0;
+    unsigned minDistance = std::numeric_limits<unsigned>::max();
     for(const auto dir : helpers::EnumRange<ShipDirection>{})
     {
         for(const HarborPos::Neighbor& n : harborData[haborId1].neighbors[dir])
         {
             if(n.id == harborId2)
-                return n.distance;
+                minDistance = std::min(minDistance, n.distance);
         }
     }
+    return minDistance;
+}
 
+unsigned World::GetHarborDistance(HarborId haborId1, HarborId harborId2, SeaId sea) const
+{
+    if(haborId1 == harborId2) // special case: distance to self
+        return 0;
+    for(const auto dir : helpers::EnumRange<ShipDirection>{})
+    {
+        for(const HarborPos::Neighbor& n : harborData[haborId1].neighbors[dir])
+        {
+            if(n.id == harborId2 && n.sea == sea)
+                return n.distance;
+        }
+    }
+    RTTR_Assert(!"Should only query actual neighbors");
     return std::numeric_limits<unsigned>::max();
 }
 
diff --git a/libs/s25main/world/World.h b/libs/s25main/world/World.h
@@ -192,8 +192,11 @@ class World : public MapBase
     /// Return the ID of the harbor point on that node or 0 if there is none
     HarborId GetHarborPointID(const MapPoint pt) const { return GetNode(pt).harborId; }
     const std::vector<HarborPos::Neighbor>& GetHarborNeighbors(HarborId harborId, const ShipDirection& dir) const;
-    /// Berechnet die Entfernung zwischen 2 Hafenpunkten
-    unsigned CalcHarborDistance(HarborId haborId1, HarborId harborId2) const;
+    /// Return the minimum distance between 2 harbors
+    /// Note: Harbors could be at 2 seas, so there might be multiple, different distances
+    unsigned GetMinHarborDistance(HarborId haborId1, HarborId harborId2) const;
+    /// Return distance between harbors at given sea
+    unsigned GetHarborDistance(HarborId haborId1, HarborId harborId2, SeaId sea) const;
     /// Return the sea id if this is a point at a coast to a sea where ships can go. Else returns 0
     SeaId GetSeaFromCoastalPoint(MapPoint pt) const;
 
diff --git a/tests/s25Main/integration/testSeafaring.cpp b/tests/s25Main/integration/testSeafaring.cpp
@@ -531,7 +531,7 @@ BOOST_FIXTURE_TEST_CASE(LongDistanceTravel, ShipReadyFixtureBig)
     // Go to opposite one
     const HarborId targetHbId(7);
     // Make sure that the other harbor is far away
-    BOOST_TEST_REQUIRE(world.CalcHarborDistance(harbor.GetHarborPosID(), targetHbId) > 600u);
+    BOOST_TEST_REQUIRE(world.GetMinHarborDistance(harbor.GetHarborPosID(), targetHbId) > 600u);
     // Add some scouts
     harbor.AddToInventory(PeopleCounts::make(Job::Scout, 20), true);
     // We want the ship to only scout unexplored harbors, so set all but one to visible
@@ -800,11 +800,11 @@ BOOST_FIXTURE_TEST_CASE(IncreasedPathLengthWhenHarborDestroyed, ShipReadyFixture
     unsigned len;
     BOOST_TEST_REQUIRE(
       world.FindShipPath(ship.GetPos(), world.GetCoastalPoint(hbIdRight, seaId), unsigned(-1), nullptr, &len));
-    const auto hbDistance = world.CalcHarborDistance(hbIdLeft, hbIdRight);
+    const auto hbDistance = world.GetMinHarborDistance(hbIdLeft, hbIdRight);
     // Reproducer requires the path to be longer than the direct distance and other connections
     BOOST_TEST_REQUIRE(len > hbDistance + extraDist);
-    BOOST_TEST_REQUIRE(hbDistance > world.CalcHarborDistance(hbIdRight, hbIdTop));
-    BOOST_TEST_REQUIRE(hbDistance > world.CalcHarborDistance(hbIdRight, hbIdBottom));
+    BOOST_TEST_REQUIRE(hbDistance > world.GetMinHarborDistance(hbIdRight, hbIdTop));
+    BOOST_TEST_REQUIRE(hbDistance > world.GetMinHarborDistance(hbIdRight, hbIdBottom));
     BuildingFactory::CreateBuilding(world, BuildingType::HarborBuilding, hbRightPos, curPlayer, Nation::Romans);
     BOOST_TEST_REQUIRE(ship.IsMoving());
     BOOST_TEST_REQUIRE(ship.GetHomeHarbor() == hbIdRight);
diff --git a/tests/s25Main/integration/testWorld.cpp b/tests/s25Main/integration/testWorld.cpp
@@ -241,7 +241,7 @@ BOOST_FIXTURE_TEST_CASE(CloseHarborSpots, WorldFixture<UninitializedWorldCreator
                 BOOST_TEST_REQUIRE(destPt.isValid());
                 std::vector<Direction> route;
                 BOOST_TEST_REQUIRE((startPt == destPt || world.FindShipPath(startPt, destPt, 10000, &route, nullptr)));
-                BOOST_TEST_REQUIRE(route.size() == world.CalcHarborDistance(startHb, targetHb));
+                BOOST_TEST_REQUIRE(route.size() == world.GetMinHarborDistance(startHb, targetHb));
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ bool GameWorldBase::FindShipPath(const MapPoint start, const MapPoint dest, unsi`
`90`	`90`
`91`	`91`	`/// Prüft, ob eine Schiffsroute noch Gültigkeit hat`
`92`	`92`	`bool GameWorld::CheckShipRoute(const MapPoint start, const std::vector<Direction>& route, const unsigned pos,`
`93`		`- MapPoint* dest)`
	`93`	`+ MapPoint* dest) const`
`94`	`94`	`{`
`95`	`95`	`return GetFreePathFinder().CheckRoute(start, route, pos, PathConditionShip(*this), dest);`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -835,23 +835,27 @@ std::vector<nobHarborBuilding::ShipConnection> nobHarborBuilding::GetShipConnect`
`835`	`835`	`if(world->GetGOT(pos) != GO_Type::NobHarborbuilding)`
`836`	`836`	`return connections;`
`837`	`837`
`838`		`- const auto sharesSeaWith = [&seaIds = this->seaIds, world = this->world](const nobHarborBuilding& harbor) {`
	`838`	`+ const auto getSharedSea = [&seaIds = this->seaIds, world = this->world](const nobHarborBuilding& harbor) {`
`839`	`839`	`for(SeaId seaId : seaIds)`
`840`	`840`	`{`
`841`	`841`	`if(seaId && world->IsHarborAtSea(harbor.GetHarborPosID(), seaId))`
`842`		`- return true;`
	`842`	`+ return seaId;`
`843`	`843`	`}`
`844`		`- return false;`
	`844`	`+ return SeaId::invalidValue();`
`845`	`845`	`};`
`846`	`846`	`for(auto* harbor_building : world->GetPlayer(player).GetBuildingRegister().GetHarbors())`
`847`	`847`	`{`
`848`		`- if(harbor_building != this && sharesSeaWith(*harbor_building))`
	`848`	`+ if(harbor_building == this)`
	`849`	`+ continue;`
	`850`	`+ SeaId seaId = getSharedSea(*harbor_building);`
	`851`	`+ if(seaId)`
`849`	`852`	`{`
`850`	`853`	`ShipConnection sc;`
`851`	`854`	`sc.dest = harbor_building;`
`852`	`855`	`// Use twice the distance as cost (ship might need to arrive first) and a fixed value to represent`
`853`	`856`	`// loading&unloading`
`854`		`- sc.way_costs = 2 * world->CalcHarborDistance(GetHarborPosID(), harbor_building->GetHarborPosID()) + 10;`
	`857`	`+ sc.way_costs =`
	`858`	`+ 2 * world->GetHarborDistance(GetHarborPosID(), harbor_building->GetHarborPosID(), seaId) + 10;`
`855`	`859`	`connections.push_back(sc);`
`856`	`860`	`}`
`857`	`861`	`}`
`@@ -1166,10 +1170,10 @@ nobHarborBuilding::GetAttackerBuildingsForSeaAttack(const std::vector<HarborId>&`
`1166`	`1170`	`continue;`
`1167`	`1171`
`1168`	`1172`	`// Entfernung zwischen Hafen und möglichen Zielhafenpunkt ausrechnen`
`1169`		`- unsigned min_distance = 0xffffffff;`
	`1173`	`+ auto min_distance = std::numeric_limits<unsigned>::max();`
`1170`	`1174`	`for(HarborId defender_harbor : defender_harbors)`
`1171`	`1175`	`{`
`1172`		`- min_distance = std::min(min_distance, world->CalcHarborDistance(GetHarborPosID(), defender_harbor));`
	`1176`	`+ min_distance = std::min(min_distance, world->GetMinHarborDistance(GetHarborPosID(), defender_harbor));`
`1173`	`1177`	`}`
`1174`	`1178`
`1175`	`1179`	`// Gebäude suchen, vielleicht schon vorhanden?`
`@@ -1202,7 +1206,7 @@ void nobHarborBuilding::AddSeaAttacker(std::unique_ptr<nofAttacker> attacker)`
`1202`	`1206`	`world->GetHarborPointsAroundMilitaryBuilding(attacker->GetAttackedGoal()->GetPos());`
`1203`	`1207`	`for(HarborId harbor_point : harbor_points)`
`1204`	`1208`	`{`
`1205`		`- unsigned tmp_distance = world->CalcHarborDistance(this->GetHarborPosID(), harbor_point);`
	`1209`	`+ unsigned tmp_distance = world->GetMinHarborDistance(this->GetHarborPosID(), harbor_point);`
`1206`	`1210`	`if(tmp_distance < best_distance)`
`1207`	`1211`	`{`
`1208`	`1212`	`best_distance = tmp_distance;`
Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,19 @@ struct HarborPos`
`15`	`15`	`struct Neighbor`
`16`	`16`	`{`
`17`	`17`	`HarborId id;`
	`18`	`+ SeaId sea;`
`18`	`19`	`unsigned distance;`
`19`	`20`
`20`		`- Neighbor(HarborId id, unsigned distance) noexcept : id(id), distance(distance) {}`
	`21`	`+ Neighbor(HarborId id, SeaId sea, unsigned distance) noexcept : id(id), sea(sea), distance(distance) {}`
`21`	`22`
`22`	`23`	`bool operator<(const Neighbor& two) const noexcept`
`23`	`24`	`{`
`24`		`- return (distance < two.distance) \|\| (distance == two.distance && id.value() < two.id.value());`
	`25`	`+ if(distance == two.distance)`
	`26`	`+ {`
	`27`	`+ if(sea != two.sea)`
	`28`	`+ return sea.value() < two.sea.value();`
	`29`	`+ }`
	`30`	`+ return id.value() < two.id.value();`
`25`	`31`	`}`
`26`	`32`	`};`
`27`	`33`
Original file line number	Diff line number	Diff line change
`@@ -973,7 +973,7 @@ void noShip::StartDrivingToHarborPlace()`
`973`	`973`	`if(homeHarbor && pos == world->GetCoastalPoint(homeHarbor, seaId_))`
`974`	`974`	`{`
`975`	`975`	`// Use the maximum distance between the harbors plus 6 fields`
`976`		`- unsigned maxDistance = world->CalcHarborDistance(homeHarbor, goalHarbor) + 6;`
	`976`	`+ unsigned maxDistance = world->GetMinHarborDistance(homeHarbor, goalHarbor) + 6;`
`977`	`977`	`routeFound = world->FindShipPath(pos, coastalPos, maxDistance, &route_, nullptr);`
`978`	`978`	`} else`
`979`	`979`	`routeFound = world->FindShipPathToHarbor(pos, goalHarbor, seaId_, &route_, nullptr);`
Original file line number	Diff line number	Diff line change
`@@ -412,19 +412,35 @@ const std::vector<HarborPos::Neighbor>& World::GetHarborNeighbors(const HarborId`
`412`	`412`	`return harborData[harborId].neighbors[dir];`
`413`	`413`	`}`
`414`	`414`
`415`		`-unsigned World::CalcHarborDistance(HarborId haborId1, HarborId harborId2) const`
	`415`	`+unsigned World::GetMinHarborDistance(HarborId haborId1, HarborId harborId2) const`
`416`	`416`	`{`
`417`	`417`	`if(haborId1 == harborId2) // special case: distance to self`
`418`	`418`	`return 0;`
	`419`	`+ unsigned minDistance = std::numeric_limits<unsigned>::max();`
`419`	`420`	`for(const auto dir : helpers::EnumRange<ShipDirection>{})`
`420`	`421`	`{`
`421`	`422`	`for(const HarborPos::Neighbor& n : harborData[haborId1].neighbors[dir])`
`422`	`423`	`{`
`423`	`424`	`if(n.id == harborId2)`
`424`		`- return n.distance;`
	`425`	`+ minDistance = std::min(minDistance, n.distance);`
`425`	`426`	`}`
`426`	`427`	`}`
	`428`	`+ return minDistance;`
	`429`	`+}`
`427`	`430`
	`431`	`+unsigned World::GetHarborDistance(HarborId haborId1, HarborId harborId2, SeaId sea) const`
	`432`	`+{`
	`433`	`+ if(haborId1 == harborId2) // special case: distance to self`
	`434`	`+ return 0;`
	`435`	`+ for(const auto dir : helpers::EnumRange<ShipDirection>{})`
	`436`	`+ {`
	`437`	`+ for(const HarborPos::Neighbor& n : harborData[haborId1].neighbors[dir])`
	`438`	`+ {`
	`439`	`+ if(n.id == harborId2 && n.sea == sea)`
	`440`	`+ return n.distance;`
	`441`	`+ }`
	`442`	`+ }`
	`443`	`+ RTTR_Assert(!"Should only query actual neighbors");`
`428`	`444`	`return std::numeric_limits<unsigned>::max();`
`429`	`445`	`}`
`430`	`446`