Add leather addon

libs/common/include/commonDefines.h

@@ -32,6 +32,13 @@ inline T checkedCast(T_Src* src)
     return static_cast<T>(src);
 }
 
+template<typename T, typename T_Src>
+inline T& checkedCast(T_Src& src)
+{
+    RTTR_Assert(dynamic_cast<T*>(&src));
+    return static_cast<T&>(src);
+}
+
 // Fwd decl
 namespace boost {
 namespace filesystem {

libs/s25main/AddonHelperFunctions.cpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "AddonHelperFunctions.h"
+#include "GlobalGameSettings.h"
+#include "world/GameWorld.h"
+#include <LeatherLoader.h>
+#include <WineLoader.h>
+#include <addons/Addon.h>
+
+auto isUnusedBuilding(GamePlayer const& player) -> std::function<bool(BuildingType const& type)>
+{
+    return [&player = player](BuildingType const& bld) {
+        if(!wineaddon::isAddonActive(player.GetGameWorld()) && wineaddon::isWineAddonBuildingType(bld))
+            return true;
+        if(!player.GetGameWorld().GetGGS().isEnabled(AddonId::CHARBURNER) && bld == BuildingType::Charburner)
+            return true;
+        if(!leatheraddon::isAddonActive(player.GetGameWorld()) && leatheraddon::isLeatherAddonBuildingType(bld))
+            return true;
+        return false;
+    };
+}
+
+auto isUnusedWare(GamePlayer const& player) -> std::function<bool(GoodType const& type)>
+{
+    return [&player = player](GoodType const& type) {
+        if(!wineaddon::isAddonActive(player.GetGameWorld()) && wineaddon::isWineAddonGoodType(type))
+            return true;
+        if(!leatheraddon::isAddonActive(player.GetGameWorld()) && leatheraddon::isLeatherAddonGoodType(type))
+            return true;
+        return false;
+    };
+}
+
+auto isUnusedJob(GamePlayer const& player) -> std::function<bool(Job const& job)>
+{
+    return [&](Job const& job) {
+        if(!wineaddon::isAddonActive(player.GetGameWorld()) && wineaddon::isWineAddonJobType(job))
+            return true;
+        if(!player.GetGameWorld().GetGGS().isEnabled(AddonId::CHARBURNER) && job == Job::CharBurner)
+            return true;
+        if(!leatheraddon::isAddonActive(player.GetGameWorld()) && leatheraddon::isLeatherAddonJobType(job))
+            return true;
+        return false;
+    };
+}

libs/s25main/AddonHelperFunctions.h

@@ -0,0 +1,11 @@
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "GamePlayer.h"
+
+auto isUnusedBuilding(GamePlayer const& player) -> std::function<bool(BuildingType const& type)>;
+auto isUnusedWare(GamePlayer const& player) -> std::function<bool(GoodType const& type)>;
+auto isUnusedJob(GamePlayer const& player) -> std::function<bool(Job const& job)>;

libs/s25main/BuildingRegister.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "BuildingRegister.h"
+#include "LeatherLoader.h"
 #include "SerializedGameData.h"
 #include "WineLoader.h"
 #include "buildings/noBuildingSite.h"
@@ -41,6 +42,9 @@ void BuildingRegister::Deserialize(SerializedGameData& sgd)
             if(sgd.GetGameDataVersion() < 11 && wineaddon::isWineAddonBuildingType(bld))
                 continue;
 
+            if(sgd.GetGameDataVersion() < 12 && leatheraddon::isLeatherAddonBuildingType(bld))
+                continue;
+
             if(BuildingProperties::IsUsual(bld))
                 sgd.PopObjectContainer(buildings[bld], GO_Type::NobUsual);
         }

libs/s25main/GameCommand.cpp

@@ -13,7 +13,9 @@ namespace gc {
 unsigned Deserializer::getCurrentVersion()
 {
     // 1: Add wine addon --> 3 new values in distribution
-    return 1;
+    // 2: Add leather addon --> 3 new values in distribution, 1 new value in transport order and transport order default
+    // values changed, 3 new values in custom build order, 3 new jobs/wares in setAllInventory settings
+    return 2;
 }
 
 GameCommandPtr GameCommand::Deserialize(Deserializer& ser)
@@ -37,6 +39,7 @@ GameCommandPtr GameCommand::Deserialize(Deserializer& ser)
         case GCType::Attack: gc = new Attack(ser); break;
         case GCType::SeaAttack: gc = new SeaAttack(ser); break;
         case GCType::SetCoinsAllowed: gc = new SetCoinsAllowed(ser); break;
+        case GCType::SetArmorAllowed: gc = new SetArmorAllowed(ser); break;
         case GCType::SetProductionEnabled: gc = new SetProductionEnabled(ser); break;
         case GCType::SetInventorySetting: gc = new SetInventorySetting(ser); break;
         case GCType::SetAllInventorySettings: gc = new SetAllInventorySettings(ser); break;

libs/s25main/GameCommand.h

@@ -62,10 +62,11 @@ enum class GCType : uint8_t
     SetTroopLimit,
     NotifyAlliesOfLocation,
     SetTempleProductionMode,
+    SetArmorAllowed,
 };
 constexpr auto maxEnumValue(GCType)
 {
-    return GCType::SetTempleProductionMode;
+    return GCType::SetArmorAllowed;
 }
 
 class GameCommand

libs/s25main/GameCommands.cpp

@@ -4,6 +4,7 @@
 
 #include "GameCommands.h"
 #include "GamePlayer.h"
+#include "LeatherLoader.h"
 #include "WineLoader.h"
 #include "buildings/nobBaseWarehouse.h"
 #include "buildings/nobHarborBuilding.h"
@@ -16,6 +17,7 @@
 #include "world/GameWorld.h"
 #include "nodeObjs/noFlag.h"
 #include "nodeObjs/noShip.h"
+#include "gameData/SettingTypeConv.h"
 #include <algorithm>
 #include <stdexcept>
 
@@ -90,19 +92,43 @@ void UpgradeRoad::Execute(GameWorld& world, uint8_t playerId)
 
 ChangeDistribution::ChangeDistribution(Deserializer& ser) : GameCommand(GCType::ChangeDistribution)
 {
-    if(ser.getDataVersion() >= 1)
+    if(ser.getDataVersion() >= 2)
         helpers::popContainer(ser, data);
     else
     {
-        std::array<Distributions::value_type,
-                   std::tuple_size_v<Distributions> - 3> tmpData; // 3 entries for wine addon
-        helpers::popContainer(ser, tmpData);
+        const unsigned wineAddonAdditionalDistributions = 3;
+        const unsigned leatherAddonAdditionalDistributions = 3;
+
+        auto const numNotSavedDistributions =
+          leatherAddonAdditionalDistributions + (ser.getDataVersion() < 1 ? wineAddonAdditionalDistributions : 0);
+
+        std::vector<Distributions::value_type> tmpData(std::tuple_size_v<Distributions> - numNotSavedDistributions);
+
+        auto getSkipBuildingAndDefault = [&](DistributionMapping const& mapping) {
+            // Skipped and standard distribution in skipped case
+            std::tuple<bool, unsigned int> result = {false, 0};
+            if(ser.getDataVersion() < 1)
+            {
+                // skip over wine buildings
+                std::get<0>(result) |= wineaddon::isWineAddonBuildingType(std::get<BuildingType>(mapping));
+            }
+
+            // skip over leather addon buildings and leather addon wares only
+            std::get<0>(result) |= leatheraddon::isLeatherAddonBuildingType(std::get<BuildingType>(mapping));
+
+            if(std::get<BuildingType>(mapping) == BuildingType::Slaughterhouse
+               && (std::get<GoodType>(mapping) == GoodType::Ham))
+                result = {true, 8};
+            return result;
+        };
+
+        helpers::popContainer(ser, tmpData, true);
         size_t srcIdx = 0, tgtIdx = 0;
         for(const auto& mapping : distributionMap)
         {
-            // skip over wine buildings in tmpData
-            const auto setting =
-              wineaddon::isWineAddonBuildingType(std::get<BuildingType>(mapping)) ? 0 : tmpData[srcIdx++];
+            // skip over not stored buildings in tmpData
+            const auto [skipped, defaultValue] = getSkipBuildingAndDefault(mapping);
+            const auto setting = skipped ? defaultValue : tmpData[srcIdx++];
             data[tgtIdx++] = setting;
         }
     }
@@ -113,6 +139,32 @@ void ChangeDistribution::Execute(GameWorld& world, uint8_t playerId)
     world.GetPlayer(playerId).ChangeDistribution(data);
 }
 
+ChangeBuildOrder::ChangeBuildOrder(Deserializer& ser)
+    : GameCommand(GCType::ChangeBuildOrder), useCustomBuildOrder(ser.PopBool())
+{
+    if(ser.getDataVersion() >= 2)
+    {
+        for(BuildingType& i : data)
+            i = helpers::popEnum<BuildingType>(ser);
+    } else
+    {
+        auto countOfNotAvailableBuildingsInSaveGame = ser.getDataVersion() < 1 ? 6 : 3;
+        std::vector<BuildingType> buildOrder(data.size() - countOfNotAvailableBuildingsInSaveGame);
+
+        if(ser.getDataVersion() < 1)
+            buildOrder.insert(buildOrder.end(), {BuildingType::Vineyard, BuildingType::Winery, BuildingType::Temple});
+
+        if(ser.getDataVersion() < 2)
+            buildOrder.insert(buildOrder.end(),
+                              {BuildingType::Skinner, BuildingType::Tannery, BuildingType::LeatherWorks});
+
+        std::generate(buildOrder.begin(), buildOrder.end() - countOfNotAvailableBuildingsInSaveGame,
+                      [&]() { return helpers::popEnum<BuildingType>(ser); });
+
+        std::copy(buildOrder.begin(), buildOrder.end(), data.begin());
+    }
+}
+
 void ChangeBuildOrder::Execute(GameWorld& world, uint8_t playerId)
 {
     world.GetPlayer(playerId).ChangeBuildOrder(useCustomBuildOrder, data);
@@ -128,6 +180,27 @@ void DestroyBuilding::Execute(GameWorld& world, uint8_t playerId)
     world.DestroyBuilding(pt_, playerId);
 }
 
+ChangeTransport::ChangeTransport(Deserializer& ser) : GameCommand(GCType::ChangeTransport)
+{
+    if(ser.getDataVersion() >= 2)
+        helpers::popContainer(ser, data);
+    else
+    {
+        const unsigned leatherAddonAdditionalTransportOrders = 1;
+        std::vector<TransportOrders::value_type> tmpData(std::tuple_size<TransportOrders>::value
+                                                         - leatherAddonAdditionalTransportOrders);
+
+        helpers::popContainer(ser, tmpData, true);
+        std::copy(tmpData.begin(), tmpData.end(), data.begin());
+        // all transport prios greater equal 7 are increased by one because the new leatherwork
+        // uses prio 7
+        std::transform(data.begin(), data.end() - leatherAddonAdditionalTransportOrders, data.begin(),
+                       [](uint8_t& prio) { return prio < 7 ? prio : prio + 1; });
+        data[std::tuple_size<TransportOrders>::value - leatherAddonAdditionalTransportOrders] =
+          STD_TRANSPORT_PRIO[GoodType::Leather];
+    }
+}
+
 void ChangeTransport::Execute(GameWorld& world, uint8_t playerId)
 {
     world.GetPlayer(playerId).ConvertTransportData(data);
@@ -172,6 +245,13 @@ void SetCoinsAllowed::Execute(GameWorld& world, uint8_t playerId)
         bld->SetCoinsAllowed(enabled);
 }
 
+void SetArmorAllowed::Execute(GameWorld& world, uint8_t playerId)
+{
+    auto* const bld = world.GetSpecObj<nobMilitary>(pt_);
+    if(bld && bld->GetPlayer() == playerId)
+        bld->SetArmorAllowed(enabled);
+}
+
 void SetTroopLimit::Execute(GameWorld& world, uint8_t playerId)
 {
     auto* const bld = world.GetSpecObj<nobMilitary>(pt_);
@@ -193,6 +273,51 @@ void SetInventorySetting::Execute(GameWorld& world, uint8_t playerId)
         bld->SetInventorySetting(what, state);
 }
 
+SetAllInventorySettings::SetAllInventorySettings(Deserializer& ser)
+    : Coords(GCType::SetAllInventorySettings, ser), isJob(ser.PopBool())
+{
+    const uint32_t numStates = (isJob ? helpers::NumEnumValues_v<Job> : helpers::NumEnumValues_v<GoodType>);
+    if(ser.getDataVersion() >= 2)
+    {
+        for(unsigned i = 0; i < numStates; i++)
+            states.push_back(InventorySetting(ser.PopUnsignedChar()));
+    } else
+    {
+        states.resize(numStates);
+        if(isJob)
+        {
+            auto isJobSkipped = [&](Job const& job) {
+                return (ser.getDataVersion() < 1 && wineaddon::isWineAddonJobType(job))
+                       || leatheraddon::isLeatherAddonJobType(job);
+            };
+
+            size_t tgtIdx = 0;
+            for(const auto i : helpers::enumRange<Job>())
+            {
+                // skip over not stored jobs
+                if(!isJobSkipped(i))
+                    states[tgtIdx] = InventorySetting(ser.PopUnsignedChar());
+                tgtIdx++;
+            }
+        } else
+        {
+            auto isWareSkipped = [&](GoodType const& ware) {
+                return (ser.getDataVersion() < 1 && wineaddon::isWineAddonGoodType(ware))
+                       || leatheraddon::isLeatherAddonGoodType(ware);
+            };
+
+            size_t tgtIdx = 0;
+            for(const auto i : helpers::enumRange<GoodType>())
+            {
+                // skip over not stored wares
+                if(!isWareSkipped(i))
+                    states[tgtIdx] = InventorySetting(ser.PopUnsignedChar());
+                tgtIdx++;
+            }
+        }
+    }
+}
+
 void SetAllInventorySettings::Execute(GameWorld& world, uint8_t playerId)
 {
     auto* const bld = world.GetSpecObj<nobBaseWarehouse>(pt_);

libs/s25main/GameCommands.h

@@ -159,11 +159,7 @@ class ChangeBuildOrder : public GameCommand
     ChangeBuildOrder(const bool useCustomBuildOrder, const BuildOrders& data)
         : GameCommand(GCType::ChangeBuildOrder), useCustomBuildOrder(useCustomBuildOrder), data(data)
     {}
-    ChangeBuildOrder(Serializer& ser) : GameCommand(GCType::ChangeBuildOrder), useCustomBuildOrder(ser.PopBool())
-    {
-        for(BuildingType& i : data)
-            i = helpers::popEnum<BuildingType>(ser);
-    }
+    ChangeBuildOrder(Deserializer& ser);
 
 public:
     void Serialize(Serializer& ser) const override
@@ -248,7 +244,7 @@ class ChangeTransport : public GameCommand
 
 protected:
     ChangeTransport(const TransportOrders& data) : GameCommand(GCType::ChangeTransport), data(data) {}
-    ChangeTransport(Serializer& ser) : GameCommand(GCType::ChangeTransport) { helpers::popContainer(ser, data); }
+    ChangeTransport(Deserializer& ser);
 
 public:
     void Serialize(Serializer& ser) const override
@@ -405,6 +401,25 @@ class SetCoinsAllowed : public Coords
     void Execute(GameWorld& world, uint8_t playerId) override;
 };
 
+/// Allow/stop armor delivery to building
+class SetArmorAllowed : public Coords
+{
+    GC_FRIEND_DECL;
+    const bool enabled;
+
+protected:
+    SetArmorAllowed(const MapPoint pt, bool enabled) : Coords(GCType::SetArmorAllowed, pt), enabled(enabled) {}
+    SetArmorAllowed(Serializer& ser) : Coords(GCType::SetArmorAllowed, ser), enabled(ser.PopBool()) {}
+
+public:
+    void Serialize(Serializer& ser) const override
+    {
+        Coords::Serialize(ser);
+        ser.PushBool(enabled);
+    }
+    void Execute(GameWorld& world, uint8_t playerId) override;
+};
+
 /// Produktivität in einem Gebäude deaktivieren/aktivieren
 class SetProductionEnabled : public Coords
 {
@@ -484,13 +499,7 @@ class SetAllInventorySettings : public Coords
     SetAllInventorySettings(const MapPoint pt, bool isJob, std::vector<InventorySetting> states)
         : Coords(GCType::SetAllInventorySettings, pt), isJob(isJob), states(std::move(states))
     {}
-    SetAllInventorySettings(Serializer& ser) : Coords(GCType::SetAllInventorySettings, ser), isJob(ser.PopBool())
-    {
-        const uint32_t numStates = (isJob ? helpers::NumEnumValues_v<Job> : helpers::NumEnumValues_v<GoodType>);
-        states.reserve(numStates);
-        for(unsigned i = 0; i < numStates; i++)
-            states.push_back(InventorySetting(ser.PopUnsignedChar()));
-    }
+    SetAllInventorySettings(Deserializer& ser);
 
 public:
     void Serialize(Serializer& ser) const override