Spike/addons/settlers iv mining

libs/s25main/GlobalGameSettings.cpp

@@ -88,6 +88,10 @@ void GlobalGameSettings::registerAllAddons()
         AddonMilitaryAid,
         AddonMilitaryControl,
         AddonMilitaryHitpoints,
+        AddonMiningOverhaulCoal,
+        AddonMiningOverhaulGold,
+        AddonMiningOverhaulGranite,
+        AddonMiningOverhaulIron,
         AddonMoreAnimals,
         AddonNoAlliedPush,
         AddonNoCoinsDefault,

libs/s25main/addons/AddonMiningOverhaul.h

@@ -0,0 +1,52 @@
+// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "AddonList.h"
+#include "mygettext/mygettext.h"
+
+class AddonMiningOverhaulBase : public AddonList
+{
+protected:
+    AddonMiningOverhaulBase(AddonId addonId, const std::string& addonName)
+        : AddonList(addonId, AddonGroup::Economy, addonName,
+                    _("This addon lets you control mining behavior.\n\n"
+                      "No change: Original behavior\n"
+                      "Settlers IV: Mines never deplete. Range is decreased to 1. Chance for production depends on "
+                      "resource amount in range.\n"
+                      "Inexhaustible: Mines never deplete\n"
+                      "Everywhere: Mines never deplete, can mine everywhere"),
+                    {
+                      _("No change"),
+                      _("Settlers IV"),
+                      _("Inexhaustible"),
+                      _("Everywhere"),
+                    })
+    {}
+};
+
+class AddonMiningOverhaulCoal : public AddonMiningOverhaulBase
+{
+public:
+    AddonMiningOverhaulCoal() : AddonMiningOverhaulBase(AddonId::MINING_OVERHAUL_COAL, _("Mining overhaul: Coal")) {}
+};
+
+class AddonMiningOverhaulGold : public AddonMiningOverhaulBase
+{
+public:
+    AddonMiningOverhaulGold() : AddonMiningOverhaulBase(AddonId::MINING_OVERHAUL_GOLD, _("Mining overhaul: Gold")) {}
+};
+
+class AddonMiningOverhaulGranite : public AddonMiningOverhaulBase
+{
+public:
+    AddonMiningOverhaulGranite() : AddonMiningOverhaulBase(AddonId::MINING_OVERHAUL_GRANITE, _("Mining overhaul: Granite")) {}
+};
+
+class AddonMiningOverhaulIron : public AddonMiningOverhaulBase
+{
+public:
+    AddonMiningOverhaulIron() : AddonMiningOverhaulBase(AddonId::MINING_OVERHAUL_IRON, _("Mining overhaul: Iron")) {}
+};

libs/s25main/addons/Addons.h

@@ -34,11 +34,13 @@
 #include "addons/AddonToolOrdering.h"
 
 #include "addons/AddonInexhaustibleFish.h"
-#include "addons/AddonInexhaustibleGraniteMines.h"
 #include "addons/AddonMaxRank.h"
 #include "addons/AddonMilitaryAid.h"
 #include "addons/AddonSeaAttack.h"
 
+#include "addons/AddonInexhaustibleGraniteMines.h"
+#include "addons/AddonMiningOverhaul.h"
+
 #include "addons/AddonBattlefieldPromotion.h"
 #include "addons/AddonBurnDuration.h"
 #include "addons/AddonHalfCostMilEquip.h"

libs/s25main/addons/const_addons.h

@@ -55,6 +55,9 @@ ENUM_WITH_STRING(AddonId, LIMIT_CATAPULTS = 0x00000000, INEXHAUSTIBLE_MINES = 0x
 
                  INEXHAUSTIBLE_GRANITEMINES = 0x00800000,
 
+                 MINING_OVERHAUL_COAL = 0x00800001, MINING_OVERHAUL_GOLD = 0x00800002, 
+                 MINING_OVERHAUL_GRANITE = 0x00800003, MINING_OVERHAUL_IRON = 0x00800004,
+
                  MAX_RANK = 0x00900000, SEA_ATTACK = 0x00900001, INEXHAUSTIBLE_FISH = 0x00900002,
                  MORE_ANIMALS = 0x00900003, BURN_DURATION = 0x00900004, NO_ALLIED_PUSH = 0x00900005,
                  BATTLEFIELD_PROMOTION = 0x00900006, HALF_COST_MIL_EQUIP = 0x00900007, MILITARY_CONTROL = 0x00900008,

libs/s25main/ai/aijh/AIPlayerJH.cpp

@@ -977,13 +977,8 @@ MapPoint AIPlayerJH::FindPositionForBuildingAround(BuildingType type, const MapP
             foundPos = FindBestPosition(around, AIResource::Ironore, BuildingQuality::Mine, searchRadius);
             break;
         case BuildingType::GraniteMine:
-            if(!ggs.isEnabled(
-                 AddonId::INEXHAUSTIBLE_GRANITEMINES)) // inexhaustible granite mines do not require granite
-                foundPos = FindBestPosition(around, AIResource::Granite, BuildingQuality::Mine, searchRadius);
-            else
-                foundPos = SimpleFindPosition(around, BuildingQuality::Mine, searchRadius);
+            foundPos = FindBestPosition(around, AIResource::Granite, BuildingQuality::Mine, searchRadius);
             break;
-
         case BuildingType::Fishery:
             foundPos = FindBestPosition(around, AIResource::Fish, BUILDING_SIZE[type], searchRadius);
             if(foundPos.isValid() && !ValidFishInRange(foundPos))

libs/s25main/buildings/nobUsual.h

@@ -57,6 +57,9 @@ class nobUsual : public noBuilding
     /// Wird gerade gearbeitet oder nicht?
     bool is_working;
 
+    /// is this an empty cycle? (use wares but produce nothing)
+    bool is_emptyCycle;
+
     ~nobUsual() override;
 
     void Serialize(SerializedGameData& sgd) const override;

libs/s25main/figures/nofMiner.cpp

@@ -11,6 +11,7 @@
 #include "network/GameClient.h"
 #include "ogl/glArchivItem_Bitmap_Player.h"
 #include "world/GameWorld.h"
+#include <random/Random.h>
 
 nofMiner::nofMiner(const MapPoint pos, const unsigned char player, nobUsual* workplace)
     : nofWorkman(Job::Miner, pos, player, workplace)
@@ -71,20 +72,101 @@ helpers::OptionalEnum<GoodType> nofMiner::ProduceWare()
 
 bool nofMiner::AreWaresAvailable() const
 {
+    // FindPointWithResource triggeres outofresource message
+    if(GetAddonSetting() == 3)
+        return true;
+
     return nofWorkman::AreWaresAvailable() && FindPointWithResource(GetRequiredResType()).isValid();
 }
 
-bool nofMiner::StartWorking()
+unsigned int nofMiner::GetAddonSetting() const 
 {
-    MapPoint resPt = FindPointWithResource(GetRequiredResType());
-    if(!resPt.isValid())
-        return false;
     const GlobalGameSettings& settings = world->GetGGS();
-    bool inexhaustibleRes = settings.isEnabled(AddonId::INEXHAUSTIBLE_MINES)
-                            || (workplace->GetBuildingType() == BuildingType::GraniteMine
-                                && settings.isEnabled(AddonId::INEXHAUSTIBLE_GRANITEMINES));
-    if(!inexhaustibleRes)
-        world->ReduceResource(resPt);
+
+    switch(workplace->GetBuildingType())
+    {
+        case BuildingType::GoldMine: return settings.getSelection(AddonId::MINING_OVERHAUL_GOLD);
+        case BuildingType::IronMine: return settings.getSelection(AddonId::MINING_OVERHAUL_IRON);
+        case BuildingType::CoalMine: return settings.getSelection(AddonId::MINING_OVERHAUL_COAL);
+        case BuildingType::GraniteMine: return settings.getSelection(AddonId::MINING_OVERHAUL_GRANITE);
+        default: return 0;
+    }
+}
+
+bool nofMiner::StartWorking()
+{
+    workplace->is_emptyCycle = false;
+
+    // needs to have at least one resource spot
+    // 0 = is exhaustible
+    // 1 = settlers IV like
+    // 2 = inexhaustible
+    // 3 = everywhere
+    unsigned int addonSettings = GetAddonSetting();
+
+    switch (addonSettings)
+    {
+        case 1: // settlers IV style
+        {
+            int sumResAmount = 0;
+            MapPoint useResPt;
+
+            std::vector<MapPoint> resPts = FindAllPointsWithResource(GetRequiredResType());
+
+            // iterate over all points
+            for each(MapPoint curPt in resPts)
+            {
+                // calculate the absolute amount of resource beneath
+                uint8_t resAmount = world->GetNode(curPt).resources.getAmount();
+                sumResAmount += resAmount;
+
+                // if there is one with more than 1 quantity, keep it (for reducing)
+                if(resAmount > 1 && !useResPt.isValid())
+                    useResPt = curPt;
+            }
+
+            // no resources left (mine was built on invalid spot)
+            if(sumResAmount == 0)
+                return false;
+
+            // 19 = amount of nodes a mine can reach
+            // 7  = maximum resource amount a node possibly has
+            if(RANDOM.Rand(RANDOM_CONTEXT(), 19 * 7) > sumResAmount)
+            {
+                // failed, use food and start working - but produce nothing
+                workplace->is_emptyCycle = true;
+                //ProduceWare = boost::none;
+            } else
+            {
+                // if success, use 1 quantity if any
+                if(!useResPt.isValid())
+                    world->ReduceResource(useResPt);
+            }
+        }
+        break;
+        case 2: // inexhaustible
+        {
+            MapPoint resPt = FindPointWithResource(GetRequiredResType());
+            if(!resPt.isValid())
+                return false;
+        }
+        break;
+        case 3: // inexhaustible, everywhere
+        {
+        }
+        break;
+        case 0: // original behavior
+        default:
+        {
+            MapPoint resPt = FindPointWithResource(GetRequiredResType());
+            if(!resPt.isValid())
+                return false;
+
+            world->ReduceResource(resPt);
+        }
+        break;
+    }
+
     return nofWorkman::StartWorking();
 }
 

libs/s25main/figures/nofMiner.h

@@ -9,7 +9,7 @@
 class SerializedGameData;
 class nobUsual;
 
-/// Klasse für den Schreiner
+/// Klasse für den Miner
 class nofMiner : public nofWorkman
 {
 protected:
@@ -23,6 +23,7 @@ class nofMiner : public nofWorkman
     bool AreWaresAvailable() const override;
     bool StartWorking() override;
     ResourceType GetRequiredResType() const;
+    unsigned int GetAddonSetting() const;
 
 public:
     nofMiner(MapPoint pos, unsigned char player, nobUsual* workplace);

libs/s25main/figures/nofWorkman.cpp

@@ -55,7 +55,7 @@ void nofWorkman::HandleStateWaiting2()
 {
     current_ev = nullptr;
     // Ware erzeugen... (noch nicht "richtig"!, sondern nur viruell erstmal)
-    if(!(ware = ProduceWare()).has_value())
+    if(!(ware = ProduceWare()).has_value() || workplace->is_emptyCycle)
     {
         // Soll keine erzeugt werden --> wieder anfangen zu arbeiten
         TryToWork();
@@ -110,3 +110,13 @@ MapPoint nofWorkman::FindPointWithResource(ResourceType type) const
 
     return MapPoint::Invalid();
 }
+
+std::vector<MapPoint> nofWorkman::FindAllPointsWithResource(ResourceType type) const
+{
+    // int maxResults = (int)((MINER_RADIUS * MINER_RADIUS + MINER_RADIUS) * 3u + 1u);
+
+    const std::vector<MapPoint> pts =
+      world->GetMatchingPointsInRadius<19>(pos, MINER_RADIUS, NodeHasResource(*world, type), true);
+
+    return pts;
+}

libs/s25main/figures/nofWorkman.h

@@ -8,6 +8,7 @@
 #include "nofBuildingWorker.h"
 #include "gameTypes/GoodTypes.h"
 #include "gameTypes/Resource.h"
+#include <vector>
 class SerializedGameData;
 class nobBaseWarehouse;
 class nobUsual;
@@ -38,6 +39,8 @@ class nofWorkman : public nofBuildingWorker
 
     /// Looks for a point with a given resource on the node
     MapPoint FindPointWithResource(ResourceType type) const;
+    /// Looks for all points with a given resource on the node
+    std::vector<MapPoint> FindAllPointsWithResource(ResourceType type) const;
 
 public:
     /// Going to workplace