Add limited extra harbor spots addon

libs/s25main/GlobalGameSettings.cpp

@@ -105,6 +105,7 @@ void GlobalGameSettings::registerAllAddons()
         AddonLeather,
         AddonNoArmorDefault,
         AddonArmorCapturedBld,
+        AddonAdditionalHarborSpots,
         AddonForesterFarmFieldAvoidance,
         AddonForesterReachRadius,
         AddonWoodcutterReachRadius,

libs/s25main/addons/AddonAdditionalHarborSpots.h

@@ -0,0 +1,18 @@
+// Copyright (C) 2005 - 2026 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "AddonBool.h"
+#include "mygettext/mygettext.h"
+
+class AddonAdditionalHarborSpots : public AddonBool
+{
+public:
+    AddonAdditionalHarborSpots()
+        : AddonBool(AddonId::ADDITIONAL_HARBOR_SPOTS, AddonGroup::GamePlay, _("Dangerous: Add extra harbor spots"),
+                    _("Advanced option. Converts a small set of suitable coastal castle sites to harbor spots. "
+                      "Caution: May alter intended map seafaring design."))
+    {}
+};

libs/s25main/addons/Addons.h

@@ -61,6 +61,7 @@
 
 #include "addons/AddonAutoFlags.h"
 
+#include "addons/AddonAdditionalHarborSpots.h"
 #include "addons/AddonArmorCapturedBld.h"
 #include "addons/AddonForesterFarmFieldAvoidance.h"
 #include "addons/AddonLeather.h"

libs/s25main/addons/const_addons.h

@@ -77,7 +77,7 @@ ENUM_WITH_STRING(AddonId, LIMIT_CATAPULTS = 0x00000000, INEXHAUSTIBLE_MINES = 0x
                  AUTOFLAGS = 0x00F00000,
 
                  WINE = 0x01000000, LEATHER = 0x01000001, NO_ARMOR_DEFAULT = 0x01000002,
-                 ARMOR_CAPTURED_BLD = 0x01000003,
+                 ARMOR_CAPTURED_BLD = 0x01000003, ADDITIONAL_HARBOR_SPOTS = 0x01000004,
 
                  FORESTER_FARM_FIELD_AVOIDANCE = 0x01100000,
 

libs/s25main/world/BQCalculator.h

@@ -5,7 +5,9 @@
 #pragma once
 
 #include "World.h"
+#include "commonDefines.h" // absDiff
 #include "helpers/containerUtils.h"
+#include "nodeObjs/noBase.h" // noBase (used via World::GetNO) and BlockingManner
 #include "gameData/TerrainDesc.h"
 
 struct BQCalculator

libs/s25main/world/MapLoader.cpp

@@ -19,6 +19,7 @@
 #include "lua/GameDataLoader.h"
 #include "pathfinding/PathConditionShip.h"
 #include "random/Random.h"
+#include "world/BQCalculator.h"
 #include "world/World.h"
 #include "nodeObjs/noAnimal.h"
 #include "nodeObjs/noEnvObject.h"
@@ -35,6 +36,7 @@
 #include "s25util/Log.h"
 #include <boost/filesystem/operations.hpp>
 #include <algorithm>
+#include <limits>
 #include <map>
 #include <queue>
 
@@ -57,7 +59,8 @@ bool MapLoader::Load(const libsiedler2::ArchivItem_Map& map, Exploration explora
         return false;
     PlaceObjects(map);
     PlaceAnimals(map);
-    if(!InitSeasAndHarbors(world_))
+    if(!InitSeasAndHarbors(world_, std::vector<MapPoint>(),
+                           world_.GetGGS().isEnabled(AddonId::ADDITIONAL_HARBOR_SPOTS)))
         return false;
 
     /// Schatten
@@ -523,7 +526,78 @@ bool MapLoader::PlaceHQs(GameWorldBase& world, const std::vector<MapPoint>& hqPo
     return true;
 }
 
-bool MapLoader::InitSeasAndHarbors(World& world, const std::vector<MapPoint>& additionalHarbors)
+namespace {
+bool hasEligibleHarborCoast(const World& world, const MapPoint pt)
+{
+    for(const auto dir : helpers::EnumRange<Direction>{})
+    {
+        // Skip the NW point because a harbor north of an island often has no usable path from that coastal point.
+        if(dir != Direction::NorthWest && world.GetSeaFromCoastalPoint(world.GetNeighbour(pt, dir)))
+            return true;
+    }
+    return false;
+}
+
+unsigned getMinimumHarborDistance(const World& world, const MapPoint pt, const std::vector<MapPoint>& harborPositions)
+{
+    unsigned minDistance = std::numeric_limits<unsigned>::max();
+    for(const MapPoint harborPt : harborPositions)
+        minDistance = std::min(minDistance, world.CalcDistance(pt, harborPt));
+    return minDistance;
+}
+
+std::vector<MapPoint> selectAdditionalHarborSpots(const World& world)
+{
+    std::vector<MapPoint> harborPositions;
+    harborPositions.reserve(world.GetNumHarborPoints() + MapLoader::MAX_GENERATED_HARBOR_SPOTS);
+    for(const auto harborId : helpers::idRange<HarborId>(world.GetNumHarborPoints()))
+        harborPositions.push_back(world.GetHarborPoint(harborId));
+
+    std::vector<MapPoint> candidates;
+    BQCalculator calcBQ(world);
+    RTTR_FOREACH_PT(MapPoint, world.GetSize())
+    {
+        if(helpers::contains(harborPositions, pt))
+            continue;
+        if(calcBQ(pt, [](const MapPoint&) { return false; }) != BuildingQuality::Castle)
+            continue;
+        if(!hasEligibleHarborCoast(world, pt))
+            continue;
+        if(helpers::contains_if(harborPositions, [&](const MapPoint harborPt) {
+               return world.CalcDistance(pt, harborPt) < MapLoader::MIN_GENERATED_HARBOR_DISTANCE;
+           }))
+            continue;
+
+        candidates.push_back(pt);
+    }
+
+    std::vector<MapPoint> generatedHarbors;
+    while(generatedHarbors.size() < MapLoader::MAX_GENERATED_HARBOR_SPOTS)
+    {
+        MapPoint bestCandidate = MapPoint::Invalid();
+        unsigned bestDistance = 0;
+        for(const MapPoint candidate : candidates)
+        {
+            const unsigned distance = getMinimumHarborDistance(world, candidate, harborPositions);
+            if(distance > bestDistance)
+            {
+                bestDistance = distance;
+                bestCandidate = candidate;
+            }
+        }
+
+        if(bestDistance < MapLoader::MIN_GENERATED_HARBOR_DISTANCE)
+            break;
+
+        generatedHarbors.push_back(bestCandidate);
+        harborPositions.push_back(bestCandidate);
+    }
+    return generatedHarbors;
+}
+} // namespace
+
+bool MapLoader::InitSeasAndHarbors(World& world, const std::vector<MapPoint>& additionalHarbors,
+                                   const bool generateHarborSpots)
 {
     for(MapPoint pt : additionalHarbors)
         world.harborData.push_back(HarborPos(pt));
@@ -549,6 +623,12 @@ bool MapLoader::InitSeasAndHarbors(World& world, const std::vector<MapPoint>& ad
         }
     }
 
+    if(generateHarborSpots)
+    {
+        for(MapPoint pt : selectAdditionalHarborSpots(world))
+            world.harborData.push_back(HarborPos(pt));
+    }
+
     /// Determine seas adjacent to the harbor places
     HarborId curHarborId(1);
     for(auto it = world.harborData.begin(); it != world.harborData.end();)

libs/s25main/world/MapLoader.h

@@ -40,6 +40,9 @@ class MapLoader
     static void CalcHarborPosNeighbors(World& world);
 
 public:
+    static constexpr unsigned MAX_GENERATED_HARBOR_SPOTS = 4;
+    static constexpr unsigned MIN_GENERATED_HARBOR_DISTANCE = 12;
+
     /// Construct a loader for the given world.
     explicit MapLoader(GameWorldBase& world);
     /// Load the map from the given archive, resetting previous state. Return false on error
@@ -61,7 +64,8 @@ class MapLoader
     static void InitShadows(World& world);
     static void SetMapExplored(World& world);
     static bool InitSeasAndHarbors(World& world,
-                                   const std::vector<MapPoint>& additionalHarbors = std::vector<MapPoint>());
+                                   const std::vector<MapPoint>& additionalHarbors = std::vector<MapPoint>(),
+                                   bool generateHarborSpots = false);
     /// Place the HQs on a loaded map and add starting wares if desired.
     /// Return false if there was an error.
     static bool PlaceHQs(GameWorldBase& world, const std::vector<MapPoint>& hqPositions, bool addStartWares = true);