Modding: "Costs [amount] [stockpiledResource]" accepts game speed modifier

Author: yairm210

core/src/com/unciv/logic/city/CityConstructions.kt

@@ -373,15 +373,12 @@ class CityConstructions : IsPartOfGameInfoSerialization {
             val construction = getConstruction(constructionName)
             // First construction will be built next turn, we need to make sure it has the correct resources
             if (constructionQueue.isEmpty() && getWorkDone(constructionName) == 0) {
-                val costUniques = construction.getMatchingUniquesNotConflicting(UniqueType.CostsResources, 
-                    city.state
-                )
+                val stockpileCosts = construction.getStockpiledResourceRequirements(city.state)
                 val civResources = city.civ.getCivResourcesByName()
 
-                if (costUniques.any {
-                            val resourceName = it.params[1]
+                if (stockpileCosts.any { (resourceName, amount) ->
                             civResources[resourceName] == null
-                                    || it.params[0].toInt() > civResources[resourceName]!! })
+                                    || amount > civResources[resourceName]!! })
                     continue // Removes this construction from the queue
             }
             if (construction.isBuildable(this))
@@ -431,11 +428,7 @@ class CityConstructions : IsPartOfGameInfoSerialization {
     }
 
     private fun constructionBegun(construction: IConstruction) {
-        val costUniques = construction.getMatchingUniquesNotConflicting(UniqueType.CostsResources, city.state)
-
-        for (unique in costUniques) {
-            val amount = unique.params[0].toInt()
-            val resourceName = unique.params[1]
+        for ((resourceName, amount) in construction.getStockpiledResourceRequirements(city.state)) {
             val resource = city.civ.gameInfo.ruleset.tileResources[resourceName] ?: continue
             city.gainStockpiledResource(resource, -amount)
         }
@@ -735,11 +728,7 @@ class CityConstructions : IsPartOfGameInfoSerialization {
 
             // Consume stockpiled resources - usually consumed when construction starts, but not when bought
             if (getWorkDone(construction.name) == 0){ // we didn't pay the resources when we started building
-                val costUniques = construction.getMatchingUniques(UniqueType.CostsResources, conditionalState)
-
-                for (unique in costUniques) {
-                    val amount = unique.params[0].toInt()
-                    val resourceName = unique.params[1]
+                for ((resourceName, amount) in construction.getStockpiledResourceRequirements(conditionalState)) {
                     val resource = city.civ.gameInfo.ruleset.tileResources[resourceName] ?: continue
                     city.gainStockpiledResource(resource, -amount)
                 }

core/src/com/unciv/logic/map/tile/TileImprovementFunctions.kt

@@ -78,7 +78,8 @@ class TileImprovementFunctions(val tile: Tile) {
             yield(ImprovementBuildingProblem.MissingResources)
 
         if (improvement.getMatchingUniques(UniqueType.CostsResources)
-                    .any { civInfo.getResourceAmount(it.params[1]) < it.params[0].toInt() })
+                    .any { civInfo.getResourceAmount(it.params[1]) < it.params[0].toInt() * 
+                            (if (it.isModifiedByGameSpeed()) civInfo.gameInfo.speed.modifier else 1f) })
             yield(ImprovementBuildingProblem.MissingResources)
 
         val knownFeatureRemovals = tile.ruleset.nonRoadTileRemovals
@@ -258,7 +259,9 @@ class TileImprovementFunctions(val tile: Tile) {
 
         for (unique in improvement.getMatchingUniques(UniqueType.CostsResources, stateForConditionals)) {
             val resource = tile.ruleset.tileResources[unique.params[1]] ?: continue
-            civ.gainStockpiledResource(resource, -unique.params[0].toInt())
+            var amount = unique.params[0].toInt()
+            if (unique.isModifiedByGameSpeed()) amount = (amount * civ.gameInfo.speed.modifier).toInt()
+            civ.gainStockpiledResource(resource, -amount)
         }
 
         for (unique in improvement.uniqueObjects.filter { !it.hasTriggerConditional()

core/src/com/unciv/models/ruleset/Building.kt

@@ -394,9 +394,7 @@ class Building : RulesetStatsObject(), INonPerpetualConstruction {
 
         // If we've already paid the unit costs, we don't need to pay it again
         if (cityConstructions.getWorkDone(name) == 0)
-            for (unique in getMatchingUniques(UniqueType.CostsResources, stateForConditionals)) {
-                val amount = unique.params[0].toInt()
-                val resourceName = unique.params[1]
+            for ((resourceName, amount) in getStockpiledResourceRequirements(stateForConditionals)) {
                 val availableResources = cityConstructions.city.getAvailableResourceAmount(resourceName)
                 if (availableResources < amount)
                     yield(RejectionReasonType.ConsumesResources.toInstance(resourceName.getNeedMoreAmountString(amount - availableResources)))

core/src/com/unciv/models/ruleset/IConstruction.kt

@@ -19,12 +19,14 @@ import kotlin.math.roundToInt
 interface IConstruction : INamed {
     fun isBuildable(cityConstructions: CityConstructions): Boolean
     fun shouldBeDisplayed(cityConstructions: CityConstructions): Boolean
+    /** We can't call this getMatchingUniques because then it would conflict with IHasUniques */
+    fun getMatchingUniquesNotConflicting(uniqueType: UniqueType, stateForConditionals: StateForConditionals) = sequenceOf<Unique>()
+    
     /** Gets *per turn* resource requirements - does not include immediate costs for stockpiled resources.
      * Uses [state] to determine which civ or city this is built for*/
     fun getResourceRequirementsPerTurn(state: StateForConditionals? = null): Counter<String>
     fun requiredResources(state: StateForConditionals = StateForConditionals.EmptyState): Set<String>
-    /** We can't call this getMatchingUniques because then it would conflict with IHasUniques */
-    fun getMatchingUniquesNotConflicting(uniqueType: UniqueType, stateForConditionals: StateForConditionals) = sequenceOf<Unique>()
+    fun getStockpiledResourceRequirements(state: StateForConditionals): Counter<String>
 }
 
 interface INonPerpetualConstruction : IConstruction, INamed, IHasUniques {
@@ -117,6 +119,16 @@ interface INonPerpetualConstruction : IConstruction, INamed, IHasUniques {
         return getResourceRequirementsPerTurn(state).keys +
                 getMatchingUniques(UniqueType.CostsResources, state).map { it.params[1] }
     }
+    
+    override fun getStockpiledResourceRequirements(state: StateForConditionals): Counter<String> {
+        val counter = Counter<String>()
+        for (unique in getMatchingUniquesNotConflicting(UniqueType.CostsResources, state)){
+            var amount = unique.params[0].toInt()
+            if (unique.isModifiedByGameSpeed()) amount = (amount * state.gameInfo!!.speed.modifier).toInt()
+            counter.add(unique.params[1], amount)
+        }
+        return counter
+    }
 }
 
 enum class PurchaseReason(val purchasable: Boolean) {
@@ -270,6 +282,7 @@ open class PerpetualConstruction(override var name: String, val description: Str
 
     override fun shouldBeDisplayed(cityConstructions: CityConstructions) = isBuildable(cityConstructions)
     open fun getProductionTooltip(city: City, withIcon: Boolean = false) : String = ""
+    override fun getStockpiledResourceRequirements(state: StateForConditionals) = Counter.ZERO
 
     companion object {
         val science = PerpetualStatConversion(Stat.Science)

core/src/com/unciv/models/ruleset/unique/UniqueType.kt

@@ -208,7 +208,8 @@ enum class UniqueType(
     /** @see UnitActionStockpileCost */
     CostsResources("Costs [amount] [stockpiledResource]", UniqueTarget.Improvement, UniqueTarget.Building, UniqueTarget.Unit,
         docDescription = "These resources are removed *when work begins* on the construction. " +
-                "Do not confuse with \"costs [amount] [stockpiledResource]\" (lowercase 'c'), the Unit Action Modifier."),
+                "Do not confuse with \"costs [amount] [stockpiledResource]\" (lowercase 'c'), the Unit Action Modifier.",
+        flags = setOf(UniqueFlag.AcceptsSpeedModifier)),
     // Todo: Get rid of forced sign (+[relativeAmount]) and unify these two, e.g.: "[relativeAmount]% [resource/resourceType] production"
     // Note that the parameter type 'resourceType' (strategic, luxury, bonus) currently doesn't exist and should then be added as well
     StrategicResourcesIncrease("Quantity of strategic resources produced by the empire +[relativeAmount]%", UniqueTarget.Global),  // used by Policies

core/src/com/unciv/models/ruleset/unit/BaseUnit.kt

@@ -267,9 +267,7 @@ class BaseUnit : RulesetObject(), INonPerpetualConstruction {
 
             // If we've already paid the unit costs, we don't need to pay it again
             if (city == null || city.cityConstructions.getWorkDone(name) == 0)
-                for (unique in getMatchingUniques(UniqueType.CostsResources, stateForConditionals)) {
-                    val amount = unique.params[0].toInt()
-                    val resourceName = unique.params[1]
+                for ((resourceName, amount) in getStockpiledResourceRequirements(stateForConditionals)) {
                     val availableResources = city?.getAvailableResourceAmount(resourceName) ?: civ.getResourceAmount(resourceName)
                     if (availableResources < amount)
                         yield(RejectionReasonType.ConsumesResources.toInstance(resourceName.getNeedMoreAmountString(amount - availableResources)))

core/src/com/unciv/ui/screens/cityscreen/CityConstructionsTable.kt

@@ -533,12 +533,12 @@ class CityConstructionsTable(private val cityScreen: CityScreen) {
                 resourceTable.add(ImageGetter.getResourcePortrait(resource, 15f)).padBottom(1f)
             }
         }
-        for (unique in constructionButtonDTO.construction
-            .getMatchingUniquesNotConflicting(UniqueType.CostsResources, cityScreen.city.state)) {
+        for ((resourceName, amount) in constructionButtonDTO.construction
+            .getStockpiledResourceRequirements(cityScreen.city.state)) {
             val color = if (constructionButtonDTO.rejectionReason?.type == RejectionReasonType.ConsumesResources)
                 Color.RED else Color.WHITE
-            resourceTable.add(ColorMarkupLabel(unique.params[0], color)).expandX().left().padLeft(5f)
-            resourceTable.add(ImageGetter.getResourcePortrait(unique.params[1], 15f)).padBottom(1f)
+            resourceTable.add(ColorMarkupLabel(amount.toString(), color)).expandX().left().padLeft(5f)
+            resourceTable.add(ImageGetter.getResourcePortrait(resourceName, 15f)).padBottom(1f)
         }
         constructionTable.add(resourceTable).expandX().left()