Merge branch 'master' into fixShipConnections

Flamefire · web-flow · commit 5d7afa219d95 · 2026-05-17T10:03:49.000+02:00
diff --git a/libs/s25main/GlobalGameSettings.cpp b/libs/s25main/GlobalGameSettings.cpp
@@ -104,7 +104,8 @@ void GlobalGameSettings::registerAllAddons()
         AddonWine,
         AddonLeather,
         AddonNoArmorDefault,
-        AddonArmorCapturedBld
+        AddonArmorCapturedBld,
+        AddonForesterFarmFieldAvoidance
     >;
     // clang-format on
     using namespace boost::mp11;
diff --git a/libs/s25main/addons/AddonForesterFarmFieldAvoidance.h b/libs/s25main/addons/AddonForesterFarmFieldAvoidance.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 AddonForesterFarmFieldAvoidance : public AddonBool
+{
+public:
+    AddonForesterFarmFieldAvoidance()
+        : AddonBool(AddonId::FORESTER_FARM_FIELD_AVOIDANCE, AddonGroup::GamePlay | AddonGroup::Economy,
+                    _("Foresters avoid farm field spots"),
+                    _("Prevents foresters from planting trees on spots that own farms could use for new fields."))
+    {}
+};
diff --git a/libs/s25main/addons/Addons.h b/libs/s25main/addons/Addons.h
@@ -62,6 +62,7 @@
 #include "addons/AddonAutoFlags.h"
 
 #include "addons/AddonArmorCapturedBld.h"
+#include "addons/AddonForesterFarmFieldAvoidance.h"
 #include "addons/AddonLeather.h"
 #include "addons/AddonNoArmorDefault.h"
 #include "addons/AddonWine.h"
diff --git a/libs/s25main/addons/const_addons.h b/libs/s25main/addons/const_addons.h
@@ -26,6 +26,7 @@
 // 00E Jonathan
 // 00F Jarno
 // 010 aztimh
+// 011 DevOpsOfChaos
 
 // Do not forget to add your Addon to GlobalGameSettings::registerAllAddons @ GlobalGameSettings.cpp!
 // Never use a number twice!
@@ -75,7 +76,9 @@ 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,
+
+                 FORESTER_FARM_FIELD_AVOIDANCE = 0x01100000)
 //-V:AddonId:801
 
 enum class AddonGroup : unsigned
diff --git a/libs/s25main/buildings/nobMilitary.cpp b/libs/s25main/buildings/nobMilitary.cpp
@@ -508,6 +508,20 @@ void nobMilitary::RegulateTroops()
 
     is_regulating_troops = true;
 
+    GamePlayer& owner = world->GetPlayer(player);
+    std::array<int, NUM_SOLDIER_RANKS> hasReturnWarehouseByRank;
+    hasReturnWarehouseByRank.fill(-1);
+    auto canReturnHome = [&](const nofPassiveSoldier& soldier) {
+        const unsigned rank = soldier.GetRank();
+        int& hasReturnWarehouse = hasReturnWarehouseByRank[rank];
+        if(hasReturnWarehouse < 0)
+        {
+            hasReturnWarehouse =
+              owner.FindWarehouse(*this, FW::AcceptsFigure(soldier.GetJobType()), true, false) ? 1 : 0;
+        }
+        return hasReturnWarehouse != 0;
+    };
+
     // This only has an effect if the military control addon is in use and the troop limits have been lowered.
     std::array<unsigned, NUM_SOLDIER_RANKS> counts = GetTotalSoldiersByRank();
     std::array<unsigned, NUM_SOLDIER_RANKS> lack;
@@ -521,7 +535,7 @@ void nobMilitary::RegulateTroops()
             std::vector<nofPassiveSoldier*> notNeededSoldiers;
             for(auto it = ordered_troops.begin(); excess && it != ordered_troops.end();)
             {
-                if((*it)->GetRank() == rank)
+                if((*it)->GetRank() == rank && canReturnHome(**it))
                 {
                     notNeededSoldiers.push_back(*it);
                     it = ordered_troops.erase(it);
@@ -538,12 +552,11 @@ void nobMilitary::RegulateTroops()
             // This bit is for ordering troops later
             lack[rank] = troop_limits[rank] - counts[rank];
         }
-        if(excess > 0
-           && world->GetPlayer(player).FindWarehouse(*this, FW::AcceptsFigure(SOLDIER_JOBS[rank]), true, false))
+        if(excess > 0)
         {
             for(auto it = troops.begin(); excess && it != troops.end() && troops.size() > 1;)
             {
-                if((*it)->GetRank() == rank)
+                if((*it)->GetRank() == rank && canReturnHome(**it))
                 {
                     (*it)->LeaveBuilding();
                     AddLeavingFigure(std::move(*it));
@@ -565,22 +578,35 @@ void nobMilitary::RegulateTroops()
         // Zuerst die bestellten Soldaten wegschicken
         // Weak ones first
         std::vector<nofPassiveSoldier*> notNeededSoldiers;
-        GamePlayer& owner = world->GetPlayer(player);
         if(owner.GetMilitarySetting(1) > MILITARY_SETTINGS_SCALE[1] / 2)
         {
-            for(auto it = ordered_troops.begin(); diff && !ordered_troops.empty(); ++diff)
+            for(auto it = ordered_troops.begin(); diff && it != ordered_troops.end();)
             {
-                notNeededSoldiers.push_back(*it);
-                it = ordered_troops.erase(it);
+                if(canReturnHome(**it))
+                {
+                    notNeededSoldiers.push_back(*it);
+                    it = ordered_troops.erase(it);
+                    ++diff;
+                } else
+                {
+                    ++it;
+                }
             }
         }
         // Strong ones first
         else
         {
-            for(auto it = ordered_troops.rbegin(); diff && !ordered_troops.empty(); ++diff)
+            for(auto it = ordered_troops.rbegin(); diff && it != ordered_troops.rend();)
             {
-                notNeededSoldiers.push_back(*it);
-                it = helpers::erase_reverse(ordered_troops, it);
+                if(canReturnHome(**it))
+                {
+                    notNeededSoldiers.push_back(*it);
+                    it = helpers::erase_reverse(ordered_troops, it);
+                    ++diff;
+                } else
+                {
+                    ++it;
+                }
             }
         }
 
@@ -590,32 +616,41 @@ void nobMilitary::RegulateTroops()
             notNeededSoldier->NotNeeded();
         }
 
-        // Nur rausschicken, wenn es einen Weg zu einem Lagerhaus gibt!
-        if(owner.FindWarehouse(*this, FW::NoCondition(), true, false))
+        // Dann den Rest (einer muss immer noch drinbleiben!)
+        // erst die schwachen Soldaten raus
+        if(owner.GetMilitarySetting(1) > MILITARY_SETTINGS_SCALE[1] / 2)
         {
-            // Dann den Rest (einer muss immer noch drinbleiben!)
-            // erst die schwachen Soldaten raus
-            if(owner.GetMilitarySetting(1) > MILITARY_SETTINGS_SCALE[1] / 2)
+            for(auto it = troops.begin(); diff && it != troops.end() && troops.size() > 1;)
             {
-                for(auto it = troops.begin(); diff && troops.size() > 1; ++diff)
+                if(canReturnHome(**it))
                 {
                     (*it)->LeaveBuilding();
                     AddLeavingFigure(std::move(*it));
                     it = troops.erase(it);
+                    ++diff;
+                } else
+                {
+                    ++it;
                 }
             }
-            // erst die starken Soldaten raus
-            else
+        }
+        // erst die starken Soldaten raus
+        else
+        {
+            for(auto it = troops.rbegin(); diff && it != troops.rend() && troops.size() > 1;)
             {
-                for(auto it = troops.rbegin(); diff && troops.size() > 1; ++diff)
+                if(canReturnHome(**it))
                 {
                     (*it)->LeaveBuilding();
                     AddLeavingFigure(std::move(*it));
                     it = helpers::erase_reverse(troops, it);
+                    ++diff;
+                } else
+                {
+                    ++it;
                 }
             }
         }
-
     } else if(diff > 0)
     {
         // Zu wenig Truppen
diff --git a/libs/s25main/figures/nofFarmer.cpp b/libs/s25main/figures/nofFarmer.cpp
@@ -57,6 +57,36 @@ unsigned short nofFarmer::GetCarryID() const
     return 71;
 }
 
+nofFarmhand::PointQuality nofFarmer::GetNewFieldPointQuality(const GameWorld& world, const MapPoint pt)
+{
+    // Nicht auf Straßen bauen!
+    for(const auto dir : helpers::EnumRange<Direction>{})
+    {
+        if(world.GetPointRoad(pt, dir) != PointRoad::None)
+            return PointQuality::NotPossible;
+    }
+
+    // Terrain untersuchen
+    if(!world.IsOfTerrain(pt, [](const auto& desc) { return desc.IsVital(); }))
+        return PointQuality::NotPossible;
+
+    // Ist Platz frei?
+    NodalObjectType noType = world.GetNO(pt)->GetType();
+    if(noType != NodalObjectType::Environment && noType != NodalObjectType::Nothing)
+        return PointQuality::NotPossible;
+
+    for(const MapPoint nb : world.GetNeighbours(pt))
+    {
+        // Nicht direkt neben andere Getreidefelder und Gebäude setzen!
+        noType = world.GetNO(nb)->GetType();
+        if(noType == NodalObjectType::Grainfield || noType == NodalObjectType::Grapefield
+           || noType == NodalObjectType::Building || noType == NodalObjectType::Buildingsite)
+            return PointQuality::NotPossible;
+    }
+
+    return PointQuality::Class2;
+}
+
 /// Abgeleitete Klasse informieren, wenn sie anfängt zu arbeiten (Vorbereitungen)
 void nofFarmer::WorkStarted()
 {
@@ -123,34 +153,7 @@ nofFarmhand::PointQuality nofFarmer::GetPointQuality(const MapPoint pt, bool /*
     }
     // oder einen freien Platz, wo wir ein neues sähen können
     else
-    {
-        // Nicht auf Straßen bauen!
-        for(const auto dir : helpers::EnumRange<Direction>{})
-        {
-            if(world->GetPointRoad(pt, dir) != PointRoad::None)
-                return PointQuality::NotPossible;
-        }
-
-        // Terrain untersuchen
-        if(!world->IsOfTerrain(pt, [](const auto& desc) { return desc.IsVital(); }))
-            return PointQuality::NotPossible;
-
-        // Ist Platz frei?
-        NodalObjectType noType = world->GetNO(pt)->GetType();
-        if(noType != NodalObjectType::Environment && noType != NodalObjectType::Nothing)
-            return PointQuality::NotPossible;
-
-        for(const MapPoint nb : world->GetNeighbours(pt))
-        {
-            // Nicht direkt neben andere Getreidefelder und Gebäude setzen!
-            noType = world->GetNO(nb)->GetType();
-            if(noType == NodalObjectType::Grainfield || noType == NodalObjectType::Grapefield
-               || noType == NodalObjectType::Building || noType == NodalObjectType::Buildingsite)
-                return PointQuality::NotPossible;
-        }
-
-        return PointQuality::Class2;
-    }
+        return GetNewFieldPointQuality(*world, pt);
 }
 
 void nofFarmer::WorkAborted()
diff --git a/libs/s25main/figures/nofFarmer.h b/libs/s25main/figures/nofFarmer.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "nofFarmhand.h"
+class GameWorld;
 class SerializedGameData;
 class nobUsual;
 
@@ -34,6 +35,8 @@ class nofFarmer : public nofFarmhand
     nofFarmer(MapPoint pos, unsigned char player, nobUsual* workplace);
     nofFarmer(SerializedGameData& sgd, unsigned obj_id);
 
+    static nofFarmhand::PointQuality GetNewFieldPointQuality(const GameWorld& world, MapPoint pt);
+
     void Serialize(SerializedGameData& sgd) const override;
 
     GO_Type GetGOT() const final { return GO_Type::NofFarmer; }
diff --git a/libs/s25main/figures/nofFarmhand.cpp b/libs/s25main/figures/nofFarmhand.cpp
@@ -27,6 +27,23 @@ nofFarmhand::nofFarmhand(SerializedGameData& sgd, const unsigned obj_id)
     : nofBuildingWorker(sgd, obj_id), dest(sgd.PopMapPoint())
 {}
 
+unsigned nofFarmhand::GetWorkRadius(const Job job)
+{
+    switch(job)
+    {
+        case Job::Carpenter: return 0;
+        case Job::Hunter:
+        case Job::Farmer:
+        case Job::Winegrower: return 2;
+        case Job::CharBurner: return 3;
+        case Job::Woodcutter:
+        case Job::Forester: return 6;
+        case Job::Fisher: return 7;
+        case Job::Stonemason: return 8;
+        default: throw std::logic_error("Invalid job");
+    }
+}
+
 void nofFarmhand::WalkedDerived()
 {
     switch(state)
@@ -59,21 +76,7 @@ void nofFarmhand::HandleDerivedEvent(const unsigned /*id*/)
         {
             // Start working after the initial wait period
             // Work radius
-            const unsigned max_radius = [](Job job) {
-                switch(job)
-                {
-                    case Job::Carpenter: return 0;
-                    case Job::Hunter:
-                    case Job::Farmer:
-                    case Job::Winegrower: return 2;
-                    case Job::CharBurner: return 3;
-                    case Job::Woodcutter:
-                    case Job::Forester: return 6;
-                    case Job::Fisher: return 7;
-                    case Job::Stonemason: return 8;
-                    default: throw std::logic_error("Invalid job");
-                }
-            }(job_);
+            const unsigned max_radius = GetWorkRadius(job_);
             // Number of additional radii in which points should be found
             // I.e. 0 => Don't search for points further away than ones already found
             const unsigned additionalRadiiToFind = [](Job job) {
diff --git a/libs/s25main/figures/nofFarmhand.h b/libs/s25main/figures/nofFarmhand.h
@@ -54,6 +54,8 @@ class nofFarmhand : public nofBuildingWorker
     nofFarmhand(Job job, MapPoint pos, unsigned char player, nobUsual* workplace);
     nofFarmhand(SerializedGameData& sgd, unsigned obj_id);
 
+    static unsigned GetWorkRadius(Job job);
+
     void Serialize(SerializedGameData& sgd) const override;
 
     void HandleDerivedEvent(unsigned id) override;
diff --git a/libs/s25main/figures/nofForester.cpp b/libs/s25main/figures/nofForester.cpp
@@ -6,15 +6,38 @@
 
 #include "GameInterface.h"
 #include "GamePlayer.h"
+#include "GlobalGameSettings.h"
 #include "Loader.h"
 #include "SoundManager.h"
+#include "addons/const_addons.h"
+#include "buildings/noBaseBuilding.h"
 #include "network/GameClient.h"
+#include "nofFarmer.h"
 #include "ogl/glArchivItem_Bitmap_Player.h"
 #include "random/Random.h"
 #include "world/GameWorld.h"
 #include "nodeObjs/noTree.h"
 #include <boost/container/static_vector.hpp>
 
+namespace {
+bool IsPotentialNewFieldForOwnFarm(GameWorld& world, const MapPoint pt, const unsigned char player)
+{
+    if(nofFarmer::GetNewFieldPointQuality(world, pt) == nofFarmhand::PointQuality::NotPossible)
+        return false;
+
+    return world.CheckPointsInRadius(
+      pt, nofFarmhand::GetWorkRadius(Job::Farmer),
+      [&world, player](const MapPoint farmPt, unsigned) {
+          if(world.GetNO(farmPt)->GetType() != NodalObjectType::Building)
+              return false;
+
+          const auto* building = world.GetSpecObj<noBaseBuilding>(farmPt);
+          return building && building->GetPlayer() == player && building->GetBuildingType() == BuildingType::Farm;
+      },
+      false);
+}
+} // namespace
+
 nofForester::nofForester(const MapPoint pos, const unsigned char player, nobUsual* workplace)
     : nofFarmhand(Job::Forester, pos, player, workplace)
 {}
@@ -110,6 +133,10 @@ nofFarmhand::PointQuality nofForester::GetPointQuality(const MapPoint pt, bool /
             return PointQuality::NotPossible;
     }
 
+    if(world->GetGGS().isEnabled(AddonId::FORESTER_FARM_FIELD_AVOIDANCE)
+       && IsPotentialNewFieldForOwnFarm(*world, pt, player))
+        return PointQuality::NotPossible;
+
     // Terrain untersuchen
     if(world->IsOfTerrain(pt, [](const auto& desc) { return desc.IsVital(); }))
         return PointQuality::Class1;
diff --git a/tests/s25Main/integration/testAttacking.cpp b/tests/s25Main/integration/testAttacking.cpp
diff --git a/tests/s25Main/integration/testFarmer.cpp b/tests/s25Main/integration/testFarmer.cpp

Original file line number	Diff line number	Diff line change
`@@ -508,6 +508,20 @@ void nobMilitary::RegulateTroops()`
`508`	`508`
`509`	`509`	`is_regulating_troops = true;`
`510`	`510`
	`511`	`+ GamePlayer& owner = world->GetPlayer(player);`
	`512`	`+ std::array<int, NUM_SOLDIER_RANKS> hasReturnWarehouseByRank;`
	`513`	`+ hasReturnWarehouseByRank.fill(-1);`
	`514`	`+ auto canReturnHome = [&](const nofPassiveSoldier& soldier) {`
	`515`	`+ const unsigned rank = soldier.GetRank();`
	`516`	`+ int& hasReturnWarehouse = hasReturnWarehouseByRank[rank];`
	`517`	`+ if(hasReturnWarehouse < 0)`
	`518`	`+ {`
	`519`	`+ hasReturnWarehouse =`
	`520`	`+ owner.FindWarehouse(*this, FW::AcceptsFigure(soldier.GetJobType()), true, false) ? 1 : 0;`
	`521`	`+ }`
	`522`	`+ return hasReturnWarehouse != 0;`
	`523`	`+ };`
	`524`	`+`
`511`	`525`	`// This only has an effect if the military control addon is in use and the troop limits have been lowered.`
`512`	`526`	`std::array<unsigned, NUM_SOLDIER_RANKS> counts = GetTotalSoldiersByRank();`
`513`	`527`	`std::array<unsigned, NUM_SOLDIER_RANKS> lack;`
`@@ -521,7 +535,7 @@ void nobMilitary::RegulateTroops()`
`521`	`535`	`std::vector<nofPassiveSoldier*> notNeededSoldiers;`
`522`	`536`	`for(auto it = ordered_troops.begin(); excess && it != ordered_troops.end();)`
`523`	`537`	`{`
`524`		`- if((*it)->GetRank() == rank)`
	`538`	`+ if((it)->GetRank() == rank && canReturnHome(*it))`
`525`	`539`	`{`
`526`	`540`	`notNeededSoldiers.push_back(*it);`
`527`	`541`	`it = ordered_troops.erase(it);`
`@@ -538,12 +552,11 @@ void nobMilitary::RegulateTroops()`
`538`	`552`	`// This bit is for ordering troops later`
`539`	`553`	`lack[rank] = troop_limits[rank] - counts[rank];`
`540`	`554`	`}`
`541`		`- if(excess > 0`
`542`		`- && world->GetPlayer(player).FindWarehouse(*this, FW::AcceptsFigure(SOLDIER_JOBS[rank]), true, false))`
	`555`	`+ if(excess > 0)`
`543`	`556`	`{`
`544`	`557`	`for(auto it = troops.begin(); excess && it != troops.end() && troops.size() > 1;)`
`545`	`558`	`{`
`546`		`- if((*it)->GetRank() == rank)`
	`559`	`+ if((it)->GetRank() == rank && canReturnHome(*it))`
`547`	`560`	`{`
`548`	`561`	`(*it)->LeaveBuilding();`
`549`	`562`	`AddLeavingFigure(std::move(*it));`
`@@ -565,22 +578,35 @@ void nobMilitary::RegulateTroops()`
`565`	`578`	`// Zuerst die bestellten Soldaten wegschicken`
`566`	`579`	`// Weak ones first`
`567`	`580`	`std::vector<nofPassiveSoldier*> notNeededSoldiers;`
`568`		`- GamePlayer& owner = world->GetPlayer(player);`
`569`	`581`	`if(owner.GetMilitarySetting(1) > MILITARY_SETTINGS_SCALE[1] / 2)`
`570`	`582`	`{`
`571`		`- for(auto it = ordered_troops.begin(); diff && !ordered_troops.empty(); ++diff)`
	`583`	`+ for(auto it = ordered_troops.begin(); diff && it != ordered_troops.end();)`
`572`	`584`	`{`
`573`		`- notNeededSoldiers.push_back(*it);`
`574`		`- it = ordered_troops.erase(it);`
	`585`	`+ if(canReturnHome(**it))`
	`586`	`+ {`
	`587`	`+ notNeededSoldiers.push_back(*it);`
	`588`	`+ it = ordered_troops.erase(it);`
	`589`	`+ ++diff;`
	`590`	`+ } else`
	`591`	`+ {`
	`592`	`+ ++it;`
	`593`	`+ }`
`575`	`594`	`}`
`576`	`595`	`}`
`577`	`596`	`// Strong ones first`
`578`	`597`	`else`
`579`	`598`	`{`
`580`		`- for(auto it = ordered_troops.rbegin(); diff && !ordered_troops.empty(); ++diff)`
	`599`	`+ for(auto it = ordered_troops.rbegin(); diff && it != ordered_troops.rend();)`
`581`	`600`	`{`
`582`		`- notNeededSoldiers.push_back(*it);`
`583`		`- it = helpers::erase_reverse(ordered_troops, it);`
	`601`	`+ if(canReturnHome(**it))`
	`602`	`+ {`
	`603`	`+ notNeededSoldiers.push_back(*it);`
	`604`	`+ it = helpers::erase_reverse(ordered_troops, it);`
	`605`	`+ ++diff;`
	`606`	`+ } else`
	`607`	`+ {`
	`608`	`+ ++it;`
	`609`	`+ }`
`584`	`610`	`}`
`585`	`611`	`}`
`586`	`612`
`@@ -590,32 +616,41 @@ void nobMilitary::RegulateTroops()`
`590`	`616`	`notNeededSoldier->NotNeeded();`
`591`	`617`	`}`
`592`	`618`
`593`		`- // Nur rausschicken, wenn es einen Weg zu einem Lagerhaus gibt!`
`594`		`- if(owner.FindWarehouse(*this, FW::NoCondition(), true, false))`
	`619`	`+ // Dann den Rest (einer muss immer noch drinbleiben!)`
	`620`	`+ // erst die schwachen Soldaten raus`
	`621`	`+ if(owner.GetMilitarySetting(1) > MILITARY_SETTINGS_SCALE[1] / 2)`
`595`	`622`	`{`
`596`		`- // Dann den Rest (einer muss immer noch drinbleiben!)`
`597`		`- // erst die schwachen Soldaten raus`
`598`		`- if(owner.GetMilitarySetting(1) > MILITARY_SETTINGS_SCALE[1] / 2)`
	`623`	`+ for(auto it = troops.begin(); diff && it != troops.end() && troops.size() > 1;)`
`599`	`624`	`{`
`600`		`- for(auto it = troops.begin(); diff && troops.size() > 1; ++diff)`
	`625`	`+ if(canReturnHome(**it))`
`601`	`626`	`{`
`602`	`627`	`(*it)->LeaveBuilding();`
`603`	`628`	`AddLeavingFigure(std::move(*it));`
`604`	`629`	`it = troops.erase(it);`
	`630`	`+ ++diff;`
	`631`	`+ } else`
	`632`	`+ {`
	`633`	`+ ++it;`
`605`	`634`	`}`
`606`	`635`	`}`
`607`		`- // erst die starken Soldaten raus`
`608`		`- else`
	`636`	`+ }`
	`637`	`+ // erst die starken Soldaten raus`
	`638`	`+ else`
	`639`	`+ {`
	`640`	`+ for(auto it = troops.rbegin(); diff && it != troops.rend() && troops.size() > 1;)`
`609`	`641`	`{`
`610`		`- for(auto it = troops.rbegin(); diff && troops.size() > 1; ++diff)`
	`642`	`+ if(canReturnHome(**it))`
`611`	`643`	`{`
`612`	`644`	`(*it)->LeaveBuilding();`
`613`	`645`	`AddLeavingFigure(std::move(*it));`
`614`	`646`	`it = helpers::erase_reverse(troops, it);`
	`647`	`+ ++diff;`
	`648`	`+ } else`
	`649`	`+ {`
	`650`	`+ ++it;`
`615`	`651`	`}`
`616`	`652`	`}`
`617`	`653`	`}`
`618`		`-`
`619`	`654`	`} else if(diff > 0)`
`620`	`655`	`{`
`621`	`656`	`// Zu wenig Truppen`