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,57 @@
+// 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 <LeatherLoader.h>
+#include <WineLoader.h>
+#include <addons/Addon.h>
+
+std::function<bool(const BuildingType type)> makeIsUnusedBuilding(const GlobalGameSettings& ggs)
+{
+    const bool wineAddonActive = ggs.isEnabled(AddonId::WINE);
+    const bool charburnerAddonActive = ggs.isEnabled(AddonId::CHARBURNER);
+    const bool leatherAddonActive = ggs.isEnabled(AddonId::LEATHER);
+
+    return [wineAddonActive, charburnerAddonActive, leatherAddonActive](BuildingType const& bld) {
+        if(!wineAddonActive && wineaddon::isWineAddonBuildingType(bld))
+            return true;
+        if(!charburnerAddonActive && bld == BuildingType::Charburner)
+            return true;
+        if(!leatherAddonActive && leatheraddon::isLeatherAddonBuildingType(bld))
+            return true;
+        return false;
+    };
+}
+
+std::function<bool(const GoodType type)> makeIsUnusedWare(const GlobalGameSettings& ggs)
+{
+    const bool wineAddonActive = ggs.isEnabled(AddonId::WINE);
+    const bool leatherAddonActive = ggs.isEnabled(AddonId::LEATHER);
+
+    return [wineAddonActive, leatherAddonActive](GoodType const& type) {
+        if(!wineAddonActive && wineaddon::isWineAddonGoodType(type))
+            return true;
+        if(!leatherAddonActive && leatheraddon::isLeatherAddonGoodType(type))
+            return true;
+        return false;
+    };
+}
+
+std::function<bool(const Job job)> makeIsUnusedJob(const GlobalGameSettings& ggs)
+{
+    const bool wineAddonActive = ggs.isEnabled(AddonId::WINE);
+    const bool charburnerAddonActive = ggs.isEnabled(AddonId::CHARBURNER);
+    const bool leatherAddonActive = ggs.isEnabled(AddonId::LEATHER);
+
+    return [wineAddonActive, charburnerAddonActive, leatherAddonActive](Job const& job) {
+        if(!wineAddonActive && wineaddon::isWineAddonJobType(job))
+            return true;
+        if(!charburnerAddonActive && job == Job::CharBurner)
+            return true;
+        if(!leatherAddonActive && leatheraddon::isLeatherAddonJobType(job))
+            return true;
+        return false;
+    };
+}

libs/s25main/AddonHelperFunctions.h

@@ -0,0 +1,31 @@
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "gameTypes/BuildingType.h"
+#include "gameTypes/GoodTypes.h"
+#include "gameTypes/JobTypes.h"
+#include <functional>
+
+class GlobalGameSettings;
+
+std::function<bool(const BuildingType type)> makeIsUnusedBuilding(const GlobalGameSettings& ggs);
+std::function<bool(const GoodType type)> makeIsUnusedWare(const GlobalGameSettings& ggs);
+std::function<bool(const Job job)> makeIsUnusedJob(const GlobalGameSettings& ggs);
+
+// Only used for deserialization, can be removed when breaking compatibility (GetGameDataVersion)
+constexpr auto numLeatherAddonBuildings = 3u;
+constexpr auto numWineAddonBuildings = 3u;
+constexpr auto numWineAndLeatherAddonBuildings = numWineAddonBuildings + numLeatherAddonBuildings;
+
+constexpr auto numLeatherAddonGoods = 3u;
+constexpr auto numWineAddonGoods = 2u;
+constexpr auto numWineAndLeatherAddonGoods = numWineAddonGoods + numLeatherAddonGoods;
+
+constexpr auto numLeatherAddonJobs = 3u;
+constexpr auto numWineAddonJobs = 3u;
+constexpr auto numWineAndLeatherAddonJobs = numWineAddonJobs + numLeatherAddonJobs;
+
+constexpr uint8_t transportPrioOfLeatherworks = 7;

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

@@ -3,7 +3,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "GameCommands.h"
+#include "AddonHelperFunctions.h"
 #include "GamePlayer.h"
+#include "LeatherLoader.h"
 #include "WineLoader.h"
 #include "buildings/nobBaseWarehouse.h"
 #include "buildings/nobHarborBuilding.h"
@@ -16,6 +18,7 @@
 #include "world/GameWorld.h"
 #include "nodeObjs/noFlag.h"
 #include "nodeObjs/noShip.h"
+#include "gameData/SettingTypeConv.h"
 #include <algorithm>
 #include <stdexcept>
 
@@ -90,19 +93,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 +140,33 @@ 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 ? numWineAndLeatherAddonBuildings : numLeatherAddonBuildings;
+        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 +182,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 transportPrioOfLeatherworks are increased by one because the new
+        // leatherwork uses prio transportPrioOfLeatherworks
+        std::transform(data.begin(), data.end() - leatherAddonAdditionalTransportOrders, data.begin(),
+                       [](uint8_t& prio) { return prio < transportPrioOfLeatherworks ? 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 +247,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 +275,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_);