From 6eeb630b6c05422d77000fa53cf8538d04031a83 Mon Sep 17 00:00:00 2001 From: Yair Morgenstern Date: Wed, 28 Jun 2023 23:38:01 +0300 Subject: [PATCH] chore: 'cityInfo' purge (changed to 'city' everywhere) --- core/src/com/unciv/logic/GameInfo.kt | 24 +-- .../automation/city/ConstructionAutomation.kt | 56 +++--- core/src/com/unciv/logic/city/City.kt | 10 +- ...tFunctions.kt => CityConquestFunctions.kt} | 2 +- .../city/managers/CityPopulationManager.kt | 2 +- .../unciv/logic/civilization/Civilization.kt | 10 +- .../civilization/managers/PolicyManager.kt | 6 +- .../unciv/logic/map/tile/TileStatFunctions.kt | 4 - core/src/com/unciv/models/ruleset/Building.kt | 16 +- .../ruleset/unique/UniqueParameterType.kt | 2 +- .../unciv/ui/screens/cityscreen/CityScreen.kt | 28 ++- .../ui/screens/cityscreen/CityStatsTable.kt | 76 ++++----- .../cityscreen/SpecialistAllocationTable.kt | 42 ++--- .../screens/overviewscreen/CityOverviewTab.kt | 76 ++++----- .../com/unciv/uniques/GlobalUniquesTests.kt | 160 +++++++++--------- tests/src/com/unciv/uniques/TestGame.kt | 12 +- .../src/com/unciv/uniques/TileUniquesTests.kt | 6 +- 17 files changed, 263 insertions(+), 269 deletions(-) rename core/src/com/unciv/logic/city/managers/{CityInfoConquestFunctions.kt => CityConquestFunctions.kt} (99%) diff --git a/core/src/com/unciv/logic/GameInfo.kt b/core/src/com/unciv/logic/GameInfo.kt index a976a6674a..71035b8ece 100644 --- a/core/src/com/unciv/logic/GameInfo.kt +++ b/core/src/com/unciv/logic/GameInfo.kt @@ -7,8 +7,8 @@ import com.unciv.json.json import com.unciv.logic.BackwardCompatibility.convertEncampmentData import com.unciv.logic.BackwardCompatibility.convertFortify import com.unciv.logic.BackwardCompatibility.guaranteeUnitPromotions -import com.unciv.logic.BackwardCompatibility.migrateToTileHistory import com.unciv.logic.BackwardCompatibility.migrateGreatPersonPools +import com.unciv.logic.BackwardCompatibility.migrateToTileHistory import com.unciv.logic.BackwardCompatibility.removeMissingModReferences import com.unciv.logic.GameInfo.Companion.CURRENT_COMPATIBILITY_NUMBER import com.unciv.logic.GameInfo.Companion.FIRST_WITHOUT @@ -534,7 +534,7 @@ class GameInfo : IsPartOfGameInfoSerialization, HasGameInfoSerializationVersion } // All cross-game data which needs to be altered (e.g. when removing or changing a name of a building/tech) - // will be done here, and not in CivInfo.setTransients or CityInfo + // will be done here, and not in Civilization.setTransients or City fun setTransients() { tileMap.gameInfo = this @@ -636,27 +636,27 @@ class GameInfo : IsPartOfGameInfoSerialization, HasGameInfoSerializationVersion civInfo.cache.updateCitiesConnectedToCapital(true) // We need to determine the GLOBAL happiness state in order to determine the city stats - for (cityInfo in civInfo.cities) { - cityInfo.cityStats.updateTileStats() // Some nat wonders can give happiness! - cityInfo.cityStats.updateCityHappiness( - cityInfo.cityConstructions.getStats() + for (city in civInfo.cities) { + city.cityStats.updateTileStats() // Some nat wonders can give happiness! + city.cityStats.updateCityHappiness( + city.cityConstructions.getStats() ) } - for (cityInfo in civInfo.cities) { + for (city in civInfo.cities) { /** We remove constructions from the queue that aren't defined in the ruleset. * This can lead to situations where the city is puppeted and had its construction removed, and there's no way to user-set it * So for cities like those, we'll auto-set the construction * Also set construction for human players who have automate production turned on */ - if (cityInfo.cityConstructions.constructionQueue.isEmpty()) - cityInfo.cityConstructions.chooseNextConstruction() + if (city.cityConstructions.constructionQueue.isEmpty()) + city.cityConstructions.chooseNextConstruction() // We also remove resources that the city may be demanding but are no longer in the ruleset - if (!ruleset.tileResources.containsKey(cityInfo.demandedResource)) - cityInfo.demandedResource = "" + if (!ruleset.tileResources.containsKey(city.demandedResource)) + city.demandedResource = "" - cityInfo.cityStats.update() + city.cityStats.update() } } } diff --git a/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt b/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt index 5812ed725c..2c0294209b 100644 --- a/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt +++ b/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt @@ -21,19 +21,19 @@ import kotlin.math.sqrt class ConstructionAutomation(val cityConstructions: CityConstructions){ - private val cityInfo = cityConstructions.city - private val civInfo = cityInfo.civ + private val city = cityConstructions.city + private val civInfo = city.civ private val buildableBuildings = hashMapOf() private val buildableUnits = hashMapOf() - private val buildings = cityInfo.getRuleset().buildings.values.asSequence() + private val buildings = city.getRuleset().buildings.values.asSequence() private val nonWonders = buildings.filterNot { it.isAnyWonder() } .filterNot { buildableBuildings[it.name] == false } // if we already know that this building can't be built here then don't even consider it - private val statBuildings = nonWonders.filter { !it.isEmpty() && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) } + private val statBuildings = nonWonders.filter { !it.isEmpty() && Automation.allowAutomatedConstruction(civInfo, city, it) } private val wonders = buildings.filter { it.isAnyWonder() } - private val units = cityInfo.getRuleset().units.values.asSequence() + private val units = city.getRuleset().units.values.asSequence() .filterNot { buildableUnits[it.name] == false } // if we already know that this unit can't be built here then don't even consider it private val civUnits = civInfo.units.getCivUnits() @@ -53,7 +53,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ private val averageProduction = civInfo.cities.map { it.cityStats.currentCityStats.production }.average() - private val cityIsOverAverageProduction = cityInfo.cityStats.currentCityStats.production >= averageProduction + private val cityIsOverAverageProduction = city.cityStats.currentCityStats.production >= averageProduction private val relativeCostEffectiveness = ArrayList() @@ -87,7 +87,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ addCultureBuildingChoice() addOtherBuildingChoice() - if (!cityInfo.isPuppet) { + if (!city.isPuppet) { addSpaceshipPartChoice() addWondersChoice() addWorkerChoice() @@ -95,7 +95,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ addMilitaryUnitChoice() } - val production = cityInfo.cityStats.currentCityStats.production + val production = city.cityStats.currentCityStats.production val chosenConstruction: String = if (relativeCostEffectiveness.isEmpty()) { // choose one of the special constructions instead @@ -115,7 +115,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ civInfo.addNotification( "Work has started on [$chosenConstruction]", - CityAction(cityInfo.location), + CityAction(city.location), NotificationCategory.Production, NotificationIcon.Construction ) @@ -127,7 +127,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ if (!isAtWar && (civInfo.stats.statsForNextTurn.gold < 0 || militaryUnits > max(5, cities * 2))) return if (civInfo.gold < -50) return - val militaryUnit = Automation.chooseMilitaryUnit(cityInfo, units) ?: return + val militaryUnit = Automation.chooseMilitaryUnit(city, units) ?: return val unitsToCitiesRatio = cities.toFloat() / (militaryUnits + 1) // most buildings and civ units contribute the the civ's growth, military units are anti-growth var modifier = sqrt(unitsToCitiesRatio) / 2 @@ -136,9 +136,9 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ if (Automation.afraidOfBarbarians(civInfo)) modifier = 2f // military units are pro-growth if pressured by barbs if (!cityIsOverAverageProduction) modifier /= 5 // higher production cities will deal with this - val civilianUnit = cityInfo.getCenterTile().civilianUnit + val civilianUnit = city.getCenterTile().civilianUnit if (civilianUnit != null && civilianUnit.hasUnique(UniqueType.FoundCity) - && cityInfo.getCenterTile().getTilesInDistance(5).none { it.militaryUnit?.civ == civInfo }) + && city.getCenterTile().getTilesInDistance(5).none { it.militaryUnit?.civ == civInfo }) modifier = 5f // there's a settler just sitting here, doing nothing - BAD if (civInfo.playerType == PlayerType.Human) modifier /= 2 // Players prefer to make their own unit choices usually @@ -149,16 +149,16 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ val buildableWorkboatUnits = units .filter { it.hasUnique(UniqueType.CreateWaterImprovements) - && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) + && Automation.allowAutomatedConstruction(civInfo, city, it) }.filterBuildable() val alreadyHasWorkBoat = buildableWorkboatUnits.any() - && !cityInfo.getTiles().any { + && !city.getTiles().any { it.civilianUnit?.hasUnique(UniqueType.CreateWaterImprovements) == true } if (!alreadyHasWorkBoat) return - val bfs = BFS(cityInfo.getCenterTile()) { + val bfs = BFS(city.getCenterTile()) { (it.isWater || it.isCityCenter()) && (it.getOwner() == null || it.isFriendlyTerritory(civInfo)) } repeat(20) { bfs.nextStep() } @@ -182,7 +182,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ val workerEquivalents = units .filter { it.hasUnique(UniqueType.BuildImprovements) - && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) + && Automation.allowAutomatedConstruction(civInfo, city, it) }.filterBuildable() if (workerEquivalents.none()) return // for mods with no worker units @@ -203,7 +203,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ .minByOrNull { it.cost } if (cultureBuilding != null) { var modifier = 0.5f - if (cityInfo.cityStats.currentCityStats.culture == 0f) // It won't grow if we don't help it + if (city.cityStats.currentCityStats.culture == 0f) // It won't grow if we don't help it modifier = 0.8f if (civInfo.wantsToFocusOn(Victory.Focus.Culture)) modifier = 1.6f addChoice(relativeCostEffectiveness, cultureBuilding.name, modifier) @@ -221,7 +221,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ private fun addOtherBuildingChoice() { val otherBuilding = nonWonders - .filter { Automation.allowAutomatedConstruction(civInfo, cityInfo, it) } + .filter { Automation.allowAutomatedConstruction(civInfo, city, it) } .filterBuildable() .minByOrNull { it.cost } if (otherBuilding != null) { @@ -233,7 +233,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ private fun getWonderPriority(wonder: Building): Float { // Only start building if we are the city that would complete it the soonest if (wonder.hasUnique(UniqueType.TriggersCulturalVictory) - && cityInfo == civInfo.cities.minByOrNull { + && city == civInfo.cities.minByOrNull { it.cityConstructions.turnsToConstruction(wonder.name) }!! ) { @@ -263,7 +263,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ if (!wonders.any()) return val highestPriorityWonder = wonders - .filter { Automation.allowAutomatedConstruction(civInfo, cityInfo, it) } + .filter { Automation.allowAutomatedConstruction(civInfo, city, it) } .filterBuildable() .maxByOrNull { getWonderPriority(it as Building) } ?: return @@ -279,7 +279,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ private fun addUnitTrainingBuildingChoice() { val unitTrainingBuilding = nonWonders .filter { it.hasUnique(UniqueType.UnitStartingExperience) - && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) + && Automation.allowAutomatedConstruction(civInfo, city, it) } .filterBuildable() .minByOrNull { it.cost } @@ -295,7 +295,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ private fun addDefenceBuildingChoice() { val defensiveBuilding = nonWonders .filter { it.cityStrength > 0 - && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) + && Automation.allowAutomatedConstruction(civInfo, city, it) } .filterBuildable() .minByOrNull { it.cost } @@ -306,7 +306,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ // If this city is the closest city to another civ, that makes it a likely candidate for attack if (civInfo.getKnownCivs() .mapNotNull { NextTurnAutomation.getClosestCities(civInfo, it) } - .any { it.city1 == cityInfo }) + .any { it.city1 == city }) modifier *= 1.5f addChoice(relativeCostEffectiveness, defensiveBuilding.name, modifier) @@ -316,7 +316,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ private fun addHappinessBuildingChoice() { val happinessBuilding = nonWonders .filter { it.isStatRelated(Stat.Happiness) - && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) } + && Automation.allowAutomatedConstruction(civInfo, city, it) } .filterBuildable() .minByOrNull { it.cost } if (happinessBuilding != null) { @@ -333,7 +333,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ if (allTechsAreResearched) return val scienceBuilding = statBuildings .filter { it.isStatRelated(Stat.Science) - && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) } + && Automation.allowAutomatedConstruction(civInfo, city, it) } .filterBuildable() .minByOrNull { it.cost } if (scienceBuilding != null) { @@ -365,16 +365,16 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ } private fun addFoodBuildingChoice() { - val conditionalState = StateForConditionals(civInfo, cityInfo) + val conditionalState = StateForConditionals(civInfo, city) val foodBuilding = nonWonders .filter { (it.isStatRelated(Stat.Food) || it.hasUnique(UniqueType.CarryOverFood, conditionalState) - ) && Automation.allowAutomatedConstruction(civInfo, cityInfo, it) + ) && Automation.allowAutomatedConstruction(civInfo, city, it) }.filterBuildable().minByOrNull { it.cost } if (foodBuilding != null) { var modifier = 1f - if (cityInfo.population.population < 5) modifier = 1.3f + if (city.population.population < 5) modifier = 1.3f addChoice(relativeCostEffectiveness, foodBuilding.name, modifier) } } diff --git a/core/src/com/unciv/logic/city/City.kt b/core/src/com/unciv/logic/city/City.kt index ff320a173f..1ad1297f55 100644 --- a/core/src/com/unciv/logic/city/City.kt +++ b/core/src/com/unciv/logic/city/City.kt @@ -3,9 +3,9 @@ package com.unciv.logic.city import com.badlogic.gdx.math.Vector2 import com.unciv.GUI import com.unciv.logic.IsPartOfGameInfoSerialization +import com.unciv.logic.city.managers.CityConquestFunctions import com.unciv.logic.city.managers.CityEspionageManager import com.unciv.logic.city.managers.CityExpansionManager -import com.unciv.logic.city.managers.CityInfoConquestFunctions import com.unciv.logic.city.managers.CityPopulationManager import com.unciv.logic.city.managers.CityReligionManager import com.unciv.logic.city.managers.SpyFleeReason @@ -486,18 +486,18 @@ class City : IsPartOfGameInfoSerialization { civ.gameInfo.cityDistances.setDirty() } - fun annexCity() = CityInfoConquestFunctions(this).annexCity() + fun annexCity() = CityConquestFunctions(this).annexCity() /** This happens when we either puppet OR annex, basically whenever we conquer a city and don't liberate it */ fun puppetCity(conqueringCiv: Civilization) = - CityInfoConquestFunctions(this).puppetCity(conqueringCiv) + CityConquestFunctions(this).puppetCity(conqueringCiv) /* Liberating is returning a city to its founder - makes you LOSE warmongering points **/ fun liberateCity(conqueringCiv: Civilization) = - CityInfoConquestFunctions(this).liberateCity(conqueringCiv) + CityConquestFunctions(this).liberateCity(conqueringCiv) fun moveToCiv(newCivInfo: Civilization) = - CityInfoConquestFunctions(this).moveToCiv(newCivInfo) + CityConquestFunctions(this).moveToCiv(newCivInfo) internal fun tryUpdateRoadStatus() { if (getCenterTile().roadStatus == RoadStatus.None) { diff --git a/core/src/com/unciv/logic/city/managers/CityInfoConquestFunctions.kt b/core/src/com/unciv/logic/city/managers/CityConquestFunctions.kt similarity index 99% rename from core/src/com/unciv/logic/city/managers/CityInfoConquestFunctions.kt rename to core/src/com/unciv/logic/city/managers/CityConquestFunctions.kt index 40482cf3c7..893c82d478 100644 --- a/core/src/com/unciv/logic/city/managers/CityInfoConquestFunctions.kt +++ b/core/src/com/unciv/logic/city/managers/CityConquestFunctions.kt @@ -21,7 +21,7 @@ import kotlin.math.roundToInt import kotlin.random.Random /** Helper class for containing 200 lines of "how to move cities between civs" */ -class CityInfoConquestFunctions(val city: City){ +class CityConquestFunctions(val city: City){ private val tileBasedRandom = Random(city.getCenterTile().position.toString().hashCode()) private fun getGoldForCapturingCity(conqueringCiv: Civilization): Int { diff --git a/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt b/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt index 8de6e53404..06183c611a 100644 --- a/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt +++ b/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt @@ -243,7 +243,7 @@ class CityPopulationManager : IsPartOfGameInfoSerialization { worstAutoJob != null -> specialistAllocations.add(worstAutoJob, -1) worstWorkedTile != null -> stopWorkingTile(worstWorkedTile.position) else -> { - // It happens when "cityInfo.manualSpecialists == true" + // It happens when "city.manualSpecialists == true" // and population goes below the number of specialists, e.g. city is razing. // Let's give a chance to do the work automatically at least. val worstJob = specialistAllocations.keys.minByOrNull { diff --git a/core/src/com/unciv/logic/civilization/Civilization.kt b/core/src/com/unciv/logic/civilization/Civilization.kt index d3f9ce6707..e673544a29 100644 --- a/core/src/com/unciv/logic/civilization/Civilization.kt +++ b/core/src/com/unciv/logic/civilization/Civilization.kt @@ -657,15 +657,15 @@ class Civilization : IsPartOfGameInfoSerialization { diplomacyManager.updateHasOpenBorders() } - for (cityInfo in cities) { - cityInfo.setTransients(this) // must be before the city's setTransients because it depends on the tilemap, that comes from the currentPlayerCivInfo + for (city in cities) { + city.setTransients(this) // must be before the city's setTransients because it depends on the tilemap, that comes from the currentPlayerCivInfo } // Now that all tile transients have been updated, clean "worked" tiles that are not under the Civ's control - for (cityInfo in cities) - for (workedTile in cityInfo.workedTiles.toList()) + for (city in cities) + for (workedTile in city.workedTiles.toList()) if (gameInfo.tileMap[workedTile].getOwner() != this) - cityInfo.workedTiles.remove(workedTile) + city.workedTiles.remove(workedTile) passThroughImpassableUnlocked = passableImpassables.isNotEmpty() // Cache whether this civ gets nonstandard terrain damage for performance reasons. diff --git a/core/src/com/unciv/logic/civilization/managers/PolicyManager.kt b/core/src/com/unciv/logic/civilization/managers/PolicyManager.kt index ceb47e9a00..656be1e86e 100644 --- a/core/src/com/unciv/logic/civilization/managers/PolicyManager.kt +++ b/core/src/com/unciv/logic/civilization/managers/PolicyManager.kt @@ -214,9 +214,9 @@ class PolicyManager : IsPartOfGameInfoSerialization { civInfo.cache.updateCivResources() // This ALSO has the side-effect of updating the CivInfo statForNextTurn so we don't need to call it explicitly - for (cityInfo in civInfo.cities) { - cityInfo.cityStats.update() - cityInfo.reassignPopulationDeferred() + for (city in civInfo.cities) { + city.cityStats.update() + city.reassignPopulationDeferred() } if (!canAdoptPolicy()) shouldOpenPolicyPicker = false diff --git a/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt b/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt index 48fa278509..5dfb799ecd 100644 --- a/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt +++ b/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt @@ -286,10 +286,6 @@ class TileStatFunctions(val tile: Tile) { val stats = Stats() val conditionalState = StateForConditionals(civInfo = observingCiv, city = city, tile = tile) - // I would love to make an interface 'canCallMatchingUniques' - // from which both cityInfo and CivilizationInfo derive, so I don't have to duplicate all this code - // But something something too much for this PR. - if (city != null) { // As above, since the conditional is tile-dependant, // we save uniques in the cache without conditional filtering, and use only filtered ones diff --git a/core/src/com/unciv/models/ruleset/Building.kt b/core/src/com/unciv/models/ruleset/Building.kt index 97abf29242..b8a0289d3f 100644 --- a/core/src/com/unciv/models/ruleset/Building.kt +++ b/core/src/com/unciv/models/ruleset/Building.kt @@ -108,7 +108,7 @@ class Building : RulesetStatsObject(), INonPerpetualConstruction { && filterUniques?.invoke(it) ?: true } - /** used in CityScreen (CityInfoTable and ConstructionInfoTable) */ + /** used in CityScreen (ConstructionInfoTable) */ fun getDescription(city: City, showAdditionalInfo: Boolean): String { val stats = getStats(city) val translatedLines = ArrayList() // Some translations require special handling @@ -644,8 +644,8 @@ class Building : RulesetStatsObject(), INonPerpetualConstruction { getRejectionReasons(cityConstructions).none() override fun postBuildEvent(cityConstructions: CityConstructions, boughtWith: Stat?): Boolean { - val cityInfo = cityConstructions.city - val civInfo = cityInfo.civ + val city = cityConstructions.city + val civInfo = city.civ if (civInfo.gameInfo.spaceResources.contains(name)) { civInfo.victoryManager.currentsSpaceshipParts.add(name, 1) @@ -673,15 +673,15 @@ class Building : RulesetStatsObject(), INonPerpetualConstruction { UniqueTriggerActivation.triggerCivwideUnique(unique, civInfo, cityConstructions.city, triggerNotificationText = triggerNotificationText) - for (unique in civInfo.getTriggeredUniques(UniqueType.TriggerUponConstructingBuilding, StateForConditionals(civInfo, cityInfo))) + for (unique in civInfo.getTriggeredUniques(UniqueType.TriggerUponConstructingBuilding, StateForConditionals(civInfo, city))) if (unique.conditionals.any {it.type == UniqueType.TriggerUponConstructingBuilding && matchesFilter(it.params[0])}) - UniqueTriggerActivation.triggerCivwideUnique(unique, cityInfo.civ, cityInfo, triggerNotificationText = triggerNotificationText) + UniqueTriggerActivation.triggerCivwideUnique(unique, city.civ, city, triggerNotificationText = triggerNotificationText) - for (unique in civInfo.getTriggeredUniques(UniqueType.TriggerUponConstructingBuildingCityFilter, StateForConditionals(cityInfo.civ, cityInfo))) + for (unique in civInfo.getTriggeredUniques(UniqueType.TriggerUponConstructingBuildingCityFilter, StateForConditionals(city.civ, city))) if (unique.conditionals.any {it.type == UniqueType.TriggerUponConstructingBuildingCityFilter && matchesFilter(it.params[0]) - && cityInfo.matchesFilter(it.params[1])}) - UniqueTriggerActivation.triggerCivwideUnique(unique, cityInfo.civ, cityInfo, triggerNotificationText = triggerNotificationText) + && city.matchesFilter(it.params[1])}) + UniqueTriggerActivation.triggerCivwideUnique(unique, city.civ, city, triggerNotificationText = triggerNotificationText) if (hasUnique(UniqueType.EnemyUnitsSpendExtraMovement)) civInfo.cache.updateHasActiveEnemyMovementPenalty() diff --git a/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt b/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt index 8fdccf275b..ba7a6c85a2 100644 --- a/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt +++ b/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt @@ -190,7 +190,7 @@ enum class UniqueParameterType( } }, - /** Implemented by [CityInfo.matchesFilter][com.unciv.logic.city.City.matchesFilter] */ + /** Implemented by [City.matchesFilter][com.unciv.logic.city.City.matchesFilter] */ CityFilter("cityFilter", "in all cities", null, "City filters") { private val cityFilterStrings = setOf( "in this city", diff --git a/core/src/com/unciv/ui/screens/cityscreen/CityScreen.kt b/core/src/com/unciv/ui/screens/cityscreen/CityScreen.kt index 321e780a32..71710566cd 100644 --- a/core/src/com/unciv/ui/screens/cityscreen/CityScreen.kt +++ b/core/src/com/unciv/ui/screens/cityscreen/CityScreen.kt @@ -21,16 +21,16 @@ import com.unciv.models.stats.Stat import com.unciv.models.translations.tr import com.unciv.ui.audio.CityAmbiencePlayer import com.unciv.ui.audio.SoundPlayer -import com.unciv.ui.components.input.KeyCharAndCode import com.unciv.ui.components.extensions.colorFromRGB import com.unciv.ui.components.extensions.disable +import com.unciv.ui.components.extensions.packIfNeeded +import com.unciv.ui.components.extensions.toTextButton +import com.unciv.ui.components.input.KeyCharAndCode +import com.unciv.ui.components.input.KeyShortcutDispatcherVeto import com.unciv.ui.components.input.keyShortcuts import com.unciv.ui.components.input.onActivation import com.unciv.ui.components.input.onClick import com.unciv.ui.components.input.onDoubleClick -import com.unciv.ui.components.extensions.packIfNeeded -import com.unciv.ui.components.extensions.toTextButton -import com.unciv.ui.components.input.KeyShortcutDispatcherVeto import com.unciv.ui.components.tilegroups.CityTileGroup import com.unciv.ui.components.tilegroups.CityTileState import com.unciv.ui.components.tilegroups.TileGroupMap @@ -38,9 +38,9 @@ import com.unciv.ui.components.tilegroups.TileSetStrings import com.unciv.ui.images.ImageGetter import com.unciv.ui.popups.ConfirmPopup import com.unciv.ui.popups.ToastPopup +import com.unciv.ui.popups.closeAllPopups import com.unciv.ui.screens.basescreen.BaseScreen import com.unciv.ui.screens.basescreen.RecreateOnResize -import com.unciv.ui.popups.closeAllPopups import com.unciv.ui.screens.worldscreen.WorldScreen class CityScreen( @@ -306,24 +306,22 @@ class CityScreen( } private fun addTiles() { - val cityInfo = city - val tileSetStrings = TileSetStrings() - val cityTileGroups = cityInfo.getCenterTile().getTilesInDistance(5) - .filter { cityInfo.civ.hasExplored(it) } - .map { CityTileGroup(cityInfo, it, tileSetStrings) } + val cityTileGroups = city.getCenterTile().getTilesInDistance(5) + .filter { city.civ.hasExplored(it) } + .map { CityTileGroup(city, it, tileSetStrings) } for (tileGroup in cityTileGroups) { - tileGroup.onClick { tileGroupOnClick(tileGroup, cityInfo) } - tileGroup.layerMisc.onClick { tileWorkedIconOnClick(tileGroup, cityInfo) } - tileGroup.layerMisc.onDoubleClick { tileWorkedIconDoubleClick(tileGroup, cityInfo) } + tileGroup.onClick { tileGroupOnClick(tileGroup, city) } + tileGroup.layerMisc.onClick { tileWorkedIconOnClick(tileGroup, city) } + tileGroup.layerMisc.onDoubleClick { tileWorkedIconDoubleClick(tileGroup, city) } tileGroups.add(tileGroup) } val tilesToUnwrap = mutableSetOf() for (tileGroup in tileGroups) { - val xDifference = cityInfo.getCenterTile().position.x - tileGroup.tile.position.x - val yDifference = cityInfo.getCenterTile().position.y - tileGroup.tile.position.y + val xDifference = city.getCenterTile().position.x - tileGroup.tile.position.x + val yDifference = city.getCenterTile().position.y - tileGroup.tile.position.y //if difference is bigger than 5 the tileGroup we are looking for is on the other side of the map if (xDifference > 5 || xDifference < -5 || yDifference > 5 || yDifference < -5) { //so we want to unwrap its position diff --git a/core/src/com/unciv/ui/screens/cityscreen/CityStatsTable.kt b/core/src/com/unciv/ui/screens/cityscreen/CityStatsTable.kt index 9f0b078f26..19f2f00823 100644 --- a/core/src/com/unciv/ui/screens/cityscreen/CityStatsTable.kt +++ b/core/src/com/unciv/ui/screens/cityscreen/CityStatsTable.kt @@ -20,12 +20,12 @@ import com.unciv.ui.components.Fonts import com.unciv.ui.components.extensions.addSeparator import com.unciv.ui.components.extensions.center import com.unciv.ui.components.extensions.colorFromRGB -import com.unciv.ui.components.input.onActivation -import com.unciv.ui.components.input.onClick import com.unciv.ui.components.extensions.surroundWithCircle import com.unciv.ui.components.extensions.toGroup import com.unciv.ui.components.extensions.toLabel import com.unciv.ui.components.extensions.toTextButton +import com.unciv.ui.components.input.onActivation +import com.unciv.ui.components.input.onClick import com.unciv.ui.images.ImageGetter import com.unciv.ui.screens.basescreen.BaseScreen import com.unciv.ui.screens.civilopediascreen.CivilopediaScreen @@ -38,7 +38,7 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { private val upperTable = Table() // fixed position table private val lowerTable = Table() // table that will be in the ScrollPane private val lowerPane: ScrollPane - private val cityInfo = cityScreen.city + private val city = cityScreen.city private val lowerCell: Cell private val detailedStatsButton = "Stats".toTextButton().apply { @@ -78,28 +78,28 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { val miniStatsTable = Table() val selected = BaseScreen.skin.getColor("selection") - for ((stat, amount) in cityInfo.cityStats.currentCityStats) { - if (stat == Stat.Faith && !cityInfo.civ.gameInfo.isReligionEnabled()) continue + for ((stat, amount) in city.cityStats.currentCityStats) { + if (stat == Stat.Faith && !city.civ.gameInfo.isReligionEnabled()) continue val icon = Table() - if (cityInfo.cityAIFocus.stat == stat) { + if (city.cityAIFocus.stat == stat) { icon.add(ImageGetter.getStatIcon(stat.name).surroundWithCircle(27f, false, color = selected)) if (cityScreen.canCityBeChanged()) { icon.onClick { - cityInfo.cityAIFocus = CityFocus.NoFocus - cityInfo.reassignPopulation(); cityScreen.update() + city.cityAIFocus = CityFocus.NoFocus + city.reassignPopulation(); cityScreen.update() } } } else { icon.add(ImageGetter.getStatIcon(stat.name).surroundWithCircle(27f, false, color = Color.CLEAR)) if (cityScreen.canCityBeChanged()) { icon.onClick { - cityInfo.cityAIFocus = cityInfo.cityAIFocus.safeValueOf(stat) - cityInfo.reassignPopulation(); cityScreen.update() + city.cityAIFocus = city.cityAIFocus.safeValueOf(stat) + city.reassignPopulation(); cityScreen.update() } } } miniStatsTable.add(icon).size(27f).padRight(3f) - val valueToDisplay = if (stat == Stat.Happiness) cityInfo.cityStats.happinessList.values.sum() else amount + val valueToDisplay = if (stat == Stat.Happiness) city.cityStats.happinessList.values.sum() else amount miniStatsTable.add(round(valueToDisplay).toInt().toLabel()).padRight(5f) } upperTable.add(miniStatsTable) @@ -110,11 +110,11 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { // begin lowerTable addCitizenManagement() - addGreatPersonPointInfo(cityInfo) - if (!cityInfo.population.getMaxSpecialists().isEmpty()) { + addGreatPersonPointInfo(city) + if (!city.population.getMaxSpecialists().isEmpty()) { addSpecialistInfo() } - if (cityInfo.religion.getNumberOfFollowers().isNotEmpty() && cityInfo.civ.gameInfo.isReligionEnabled()) + if (city.religion.getNumberOfFollowers().isNotEmpty() && city.civ.gameInfo.isReligionEnabled()) addReligionInfo() addBuildingsInfo() @@ -140,32 +140,32 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { private fun addText() { val unassignedPopString = "{Unassigned population}: ".tr() + - cityInfo.population.getFreePopulation().toString() + "/" + cityInfo.population.population + city.population.getFreePopulation().toString() + "/" + city.population.population val unassignedPopLabel = unassignedPopString.toLabel() if (cityScreen.canChangeState) - unassignedPopLabel.onClick { cityInfo.reassignPopulation(); cityScreen.update() } + unassignedPopLabel.onClick { city.reassignPopulation(); cityScreen.update() } var turnsToExpansionString = - if (cityInfo.cityStats.currentCityStats.culture > 0 && cityInfo.expansion.getChoosableTiles().any()) { - val remainingCulture = cityInfo.expansion.getCultureToNextTile() - cityInfo.expansion.cultureStored - var turnsToExpansion = ceil(remainingCulture / cityInfo.cityStats.currentCityStats.culture).toInt() + if (city.cityStats.currentCityStats.culture > 0 && city.expansion.getChoosableTiles().any()) { + val remainingCulture = city.expansion.getCultureToNextTile() - city.expansion.cultureStored + var turnsToExpansion = ceil(remainingCulture / city.cityStats.currentCityStats.culture).toInt() if (turnsToExpansion < 1) turnsToExpansion = 1 "[$turnsToExpansion] turns to expansion".tr() } else "Stopped expansion".tr() - if (cityInfo.expansion.getChoosableTiles().any()) + if (city.expansion.getChoosableTiles().any()) turnsToExpansionString += - " (${cityInfo.expansion.cultureStored}${Fonts.culture}/${cityInfo.expansion.getCultureToNextTile()}${Fonts.culture})" + " (${city.expansion.cultureStored}${Fonts.culture}/${city.expansion.getCultureToNextTile()}${Fonts.culture})" var turnsToPopString = when { - cityInfo.isStarving() -> "[${cityInfo.population.getNumTurnsToStarvation()}] turns to lose population" - cityInfo.getRuleset().units[cityInfo.cityConstructions.currentConstructionFromQueue] + city.isStarving() -> "[${city.population.getNumTurnsToStarvation()}] turns to lose population" + city.getRuleset().units[city.cityConstructions.currentConstructionFromQueue] .let { it != null && it.hasUnique(UniqueType.ConvertFoodToProductionWhenConstructed) } -> "Food converts to production" - cityInfo.isGrowing() -> "[${cityInfo.population.getNumTurnsToNewPopulation()}] turns to new population" + city.isGrowing() -> "[${city.population.getNumTurnsToNewPopulation()}] turns to new population" else -> "Stopped population growth" }.tr() - turnsToPopString += " (${cityInfo.population.foodStored}${Fonts.food}/${cityInfo.population.getFoodToNextPopulation()}${Fonts.food})" + turnsToPopString += " (${city.population.foodStored}${Fonts.food}/${city.population.getFoodToNextPopulation()}${Fonts.food})" upperTable.add(unassignedPopLabel).row() upperTable.add(turnsToExpansionString.toLabel()).row() @@ -173,24 +173,24 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { val tableWithIcons = Table() tableWithIcons.defaults().pad(2f) - if (cityInfo.isInResistance()) { + if (city.isInResistance()) { tableWithIcons.add(ImageGetter.getImage("StatIcons/Resistance")).size(20f) - tableWithIcons.add("In resistance for another [${cityInfo.getFlag(CityFlags.Resistance)}] turns".toLabel()).row() + tableWithIcons.add("In resistance for another [${city.getFlag(CityFlags.Resistance)}] turns".toLabel()).row() } val (wltkIcon: Actor?, wltkLabel: Label?) = when { - cityInfo.isWeLoveTheKingDayActive() -> + city.isWeLoveTheKingDayActive() -> ImageGetter.getStatIcon("Food") to - "We Love The King Day for another [${cityInfo.getFlag(CityFlags.WeLoveTheKing)}] turns".toLabel(Color.LIME) - cityInfo.demandedResource.isNotEmpty() -> - ImageGetter.getResourcePortrait(cityInfo.demandedResource, 20f) to - "Demanding [${cityInfo.demandedResource}]".toLabel(Color.CORAL, hideIcons = true) + "We Love The King Day for another [${city.getFlag(CityFlags.WeLoveTheKing)}] turns".toLabel(Color.LIME) + city.demandedResource.isNotEmpty() -> + ImageGetter.getResourcePortrait(city.demandedResource, 20f) to + "Demanding [${city.demandedResource}]".toLabel(Color.CORAL, hideIcons = true) else -> null to null } if (wltkLabel != null) { tableWithIcons.add(wltkIcon!!).size(20f).padRight(5f) wltkLabel.onClick { - UncivGame.Current.pushScreen(CivilopediaScreen(cityInfo.getRuleset(), link = "We Love The King Day")) + UncivGame.Current.pushScreen(CivilopediaScreen(city.getRuleset(), link = "We Love The King Day")) } tableWithIcons.add(wltkLabel).row() } @@ -209,7 +209,7 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { } private fun addReligionInfo() { - val expanderTab = CityReligionInfoTable(cityInfo.religion).asExpander { onContentResize() } + val expanderTab = CityReligionInfoTable(city.religion).asExpander { onContentResize() } lowerTable.add(expanderTab).growX().row() } @@ -218,7 +218,7 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { val specialistBuildings = mutableListOf() val otherBuildings = mutableListOf() - for (building in cityInfo.cityConstructions.getBuiltBuildings()) { + for (building in city.cityConstructions.getBuiltBuildings()) { when { building.isAnyWonder() -> wonders.add(building) !building.newSpecialists().isEmpty() -> specialistBuildings.add(building) @@ -276,16 +276,16 @@ class CityStatsTable(private val cityScreen: CityScreen): Table() { info.add(displayName.toLabel(fontSize = Constants.defaultFontSize, hideIcons = true)).padBottom(5f).right().row() - val stats = building.getStats(cityInfo).joinToString(separator = " ") { + val stats = building.getStats(city).joinToString(separator = " ") { "" + it.value.toInt() + it.key.character } statsAndSpecialists.add(stats.toLabel(fontSize = Constants.defaultFontSize)).right() - val assignedSpec = cityInfo.population.getNewSpecialists().clone() + val assignedSpec = city.population.getNewSpecialists().clone() val specialistIcons = Table() for ((specialistName, amount) in building.newSpecialists()) { - val specialist = cityInfo.getRuleset().specialists[specialistName] + val specialist = city.getRuleset().specialists[specialistName] ?: continue // probably a mod that doesn't have the specialist defined yet repeat(amount) { if (assignedSpec[specialistName] > 0) { diff --git a/core/src/com/unciv/ui/screens/cityscreen/SpecialistAllocationTable.kt b/core/src/com/unciv/ui/screens/cityscreen/SpecialistAllocationTable.kt index 49eec80536..ca446d6925 100644 --- a/core/src/com/unciv/ui/screens/cityscreen/SpecialistAllocationTable.kt +++ b/core/src/com/unciv/ui/screens/cityscreen/SpecialistAllocationTable.kt @@ -9,15 +9,15 @@ import com.unciv.ui.components.ExpanderTab import com.unciv.ui.components.extensions.addBorder import com.unciv.ui.components.extensions.addSeparatorVertical import com.unciv.ui.components.extensions.darken -import com.unciv.ui.components.input.onClick import com.unciv.ui.components.extensions.surroundWithCircle import com.unciv.ui.components.extensions.toGroup import com.unciv.ui.components.extensions.toLabel +import com.unciv.ui.components.input.onClick import com.unciv.ui.images.ImageGetter import com.unciv.ui.screens.basescreen.BaseScreen class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(BaseScreen.skin) { - val cityInfo = cityScreen.city + val city = cityScreen.city fun update() { clear() @@ -25,25 +25,25 @@ class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(Base // Color of "color" coming from Skin.json that's loaded into BaseScreen // 5 columns: unassignButton, AllocationTable, assignButton, SeparatorVertical, SpecialistsStatsTabe if (cityScreen.canCityBeChanged()) { - if (cityInfo.manualSpecialists) { + if (city.manualSpecialists) { val manualSpecialists = "Manual Specialists".toLabel() .addBorder(5f, BaseScreen.skin.getColor("color")) manualSpecialists.onClick { - cityInfo.manualSpecialists = false - cityInfo.reassignPopulation(); cityScreen.update() + city.manualSpecialists = false + city.reassignPopulation(); cityScreen.update() } add(manualSpecialists).colspan(5).row() } else { val autoSpecialists = "Auto Specialists".toLabel() .addBorder(5f, BaseScreen.skin.getColor("color")) - autoSpecialists.onClick { cityInfo.manualSpecialists = true; update() } + autoSpecialists.onClick { city.manualSpecialists = true; update() } add(autoSpecialists).colspan(5).row() } } - for ((specialistName, maxSpecialists) in cityInfo.population.getMaxSpecialists()) { - if (!cityInfo.getRuleset().specialists.containsKey(specialistName)) // specialist doesn't exist in this ruleset, probably a mod + for ((specialistName, maxSpecialists) in city.population.getMaxSpecialists()) { + if (!city.getRuleset().specialists.containsKey(specialistName)) // specialist doesn't exist in this ruleset, probably a mod continue - val newSpecialists = cityInfo.population.getNewSpecialists() + val newSpecialists = city.population.getNewSpecialists() val assignedSpecialists = newSpecialists[specialistName] if (cityScreen.canChangeState) add(getUnassignButton(assignedSpecialists, specialistName)) @@ -59,7 +59,7 @@ class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(Base private fun getAllocationTable(assignedSpecialists: Int, maxSpecialists: Int, specialistName: String): Table { val specialistIconTable = Table() - val specialistObject = cityInfo.getRuleset().specialists[specialistName]!! + val specialistObject = city.getRuleset().specialists[specialistName]!! for (i in 1..maxSpecialists) { val color = if (i <= assignedSpecialists) specialistObject.colorObject else Color.GRAY // unassigned @@ -72,17 +72,17 @@ class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(Base private fun getAssignButton(assignedSpecialists: Int, maxSpecialists: Int, specialistName: String): Actor { - if (assignedSpecialists >= maxSpecialists || cityInfo.isPuppet) return Table() + if (assignedSpecialists >= maxSpecialists || city.isPuppet) return Table() val assignButton = "+".toLabel(Color.BLACK, Constants.headingFontSize) .apply { this.setAlignment(Align.center) } .surroundWithCircle(30f).apply { circle.color = Color.GREEN.darken(0.2f) } assignButton.onClick { - cityInfo.population.specialistAllocations.add(specialistName, 1) - cityInfo.manualSpecialists = true - cityInfo.cityStats.update() + city.population.specialistAllocations.add(specialistName, 1) + city.manualSpecialists = true + city.cityStats.update() cityScreen.update() } - if (cityInfo.population.getFreePopulation() == 0 || !cityScreen.canChangeState) + if (city.population.getFreePopulation() == 0 || !cityScreen.canChangeState) assignButton.clear() return assignButton } @@ -92,13 +92,13 @@ class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(Base .apply { this.setAlignment(Align.center) } .surroundWithCircle(30f).apply { circle.color = Color.RED.darken(0.1f) } unassignButton.onClick { - cityInfo.population.specialistAllocations.add(specialistName, -1) - cityInfo.manualSpecialists = true - cityInfo.cityStats.update() + city.population.specialistAllocations.add(specialistName, -1) + city.manualSpecialists = true + city.cityStats.update() cityScreen.update() } - if (assignedSpecialists <= 0 || cityInfo.isPuppet) unassignButton.isVisible = false + if (assignedSpecialists <= 0 || city.isPuppet) unassignButton.isVisible = false if (!cityScreen.canChangeState) unassignButton.clear() return unassignButton } @@ -106,7 +106,7 @@ class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(Base private fun getSpecialistStatsTable(specialistName: String): Table { val specialistStatTable = Table().apply { defaults().padBottom(5f).padTop(5f) } - val specialistStats = cityInfo.cityStats.getStatsOfSpecialist(specialistName) + val specialistStats = city.cityStats.getStatsOfSpecialist(specialistName) var itemsInRow = 0 fun incrementItemsInRow(){ itemsInRow++ @@ -123,7 +123,7 @@ class SpecialistAllocationTable(private val cityScreen: CityScreen) : Table(Base incrementItemsInRow() } - val specialist = cityInfo.getRuleset().specialists[specialistName]!! + val specialist = city.getRuleset().specialists[specialistName]!! for (s in specialist.greatPersonPoints) { specialistStatTable.add(s.value.toLabel()) diff --git a/core/src/com/unciv/ui/screens/overviewscreen/CityOverviewTab.kt b/core/src/com/unciv/ui/screens/overviewscreen/CityOverviewTab.kt index db0a08fe14..278016b5d5 100644 --- a/core/src/com/unciv/ui/screens/overviewscreen/CityOverviewTab.kt +++ b/core/src/com/unciv/ui/screens/overviewscreen/CityOverviewTab.kt @@ -17,11 +17,11 @@ import com.unciv.models.translations.tr import com.unciv.ui.components.UncivTooltip.Companion.addTooltip import com.unciv.ui.components.extensions.addSeparator import com.unciv.ui.components.extensions.center -import com.unciv.ui.components.input.onClick import com.unciv.ui.components.extensions.pad import com.unciv.ui.components.extensions.surroundWithCircle import com.unciv.ui.components.extensions.toLabel import com.unciv.ui.components.extensions.toTextButton +import com.unciv.ui.components.input.onClick import com.unciv.ui.images.ImageGetter import com.unciv.ui.screens.cityscreen.CityScreen import kotlin.math.roundToInt @@ -82,30 +82,30 @@ class CityOverviewTab( private val columnsNames = arrayListOf("Population", "Food", "Gold", "Science", "Production", "Culture", "Happiness") .apply { if (gameInfo.isReligionEnabled()) add("Faith") } - private val cityInfoTableHeader = Table(skin) - private val cityInfoTableDetails = Table(skin) - private val cityInfoTableTotal = Table(skin) + private val headerTable = Table(skin) + private val detailsTable = Table(skin) + private val totalTable = Table(skin) private val collator = UncivGame.Current.settings.getCollatorFromLocale() override fun getFixedContent() = Table().apply { add("Cities".toLabel(fontSize = Constants.headingFontSize)).padTop(10f).row() - add(cityInfoTableHeader).padBottom(paddingVert).row() + add(headerTable).padBottom(paddingVert).row() addSeparator(Color.GRAY) } init { - cityInfoTableHeader.defaults().pad(paddingVert, paddingHorz).minWidth(iconSize) - cityInfoTableDetails.defaults().pad(paddingVert, paddingHorz).minWidth(iconSize) - cityInfoTableTotal.defaults().pad(paddingVert, paddingHorz).minWidth(iconSize) + headerTable.defaults().pad(paddingVert, paddingHorz).minWidth(iconSize) + detailsTable.defaults().pad(paddingVert, paddingHorz).minWidth(iconSize) + totalTable.defaults().pad(paddingVert, paddingHorz).minWidth(iconSize) updateTotal() update() top() - add(cityInfoTableDetails).row() + add(detailsTable).row() addSeparator(Color.GRAY).pad(paddingVert, 0f) - add(cityInfoTableTotal) + add(totalTable) } private fun toggleSort(sortBy: String) { @@ -141,7 +141,7 @@ class CityOverviewTab( private fun update() { updateHeader() updateCities() - equalizeColumns(cityInfoTableDetails, cityInfoTableHeader, cityInfoTableTotal) + equalizeColumns(detailsTable, headerTable, totalTable) layout() } @@ -170,23 +170,23 @@ class CityOverviewTab( icon.addActor(label) } icon.addActor(image) - return cityInfoTableHeader.add(icon).size(iconSize) + return headerTable.add(icon).size(iconSize) } - cityInfoTableHeader.clear() + headerTable.clear() addSortIcon(CITY, citySortIcon).left() - cityInfoTableHeader.add() // construction _icon_ column + headerTable.add() // construction _icon_ column addSortIcon(CONSTRUCTION, constructionSortIcon).left() for (name in columnsNames) { addSortIcon(name) } addSortIcon(WLTK, wltkSortIcon) addSortIcon(GARRISON, garrisonSortIcon) - cityInfoTableHeader.pack() + headerTable.pack() } private fun updateCities() { - cityInfoTableDetails.clear() + detailsTable.clear() if (viewingPlayer.cities.isEmpty()) return val sorter = getComparator() @@ -200,25 +200,25 @@ class CityOverviewTab( button.onClick { overviewScreen.game.pushScreen(CityScreen(city)) } - cityInfoTableDetails.add(button).left().fillX() + detailsTable.add(button).left().fillX() val construction = city.cityConstructions.currentConstructionFromQueue if (construction.isNotEmpty()) { - cityInfoTableDetails.add(ImageGetter.getConstructionPortrait(construction, iconSize *0.8f)).padRight( + detailsTable.add(ImageGetter.getConstructionPortrait(construction, iconSize *0.8f)).padRight( paddingHorz ) } else { - cityInfoTableDetails.add() + detailsTable.add() } - val cell = cityInfoTableDetails.add(city.cityConstructions.getCityProductionTextForCityButton().toLabel()).left().expandX() + val cell = detailsTable.add(city.cityConstructions.getCityProductionTextForCityButton().toLabel()).left().expandX() constructionCells.add(cell) - cityInfoTableDetails.add(city.population.population.toCenteredLabel()) + detailsTable.add(city.population.population.toCenteredLabel()) for (column in columnsNames) { val stat = Stat.safeValueOf(column) ?: continue - cityInfoTableDetails.add(city.getStat(stat).toCenteredLabel()) + detailsTable.add(city.getStat(stat).toCenteredLabel()) } when { @@ -226,7 +226,7 @@ class CityOverviewTab( val image = ImageGetter.getImage("OtherIcons/WLTK 1").surroundWithCircle( iconSize, color = Color.CLEAR) image.addTooltip("[${city.getFlag(CityFlags.WeLoveTheKing)}] turns", 18f, tipAlign = Align.topLeft) - cityInfoTableDetails.add(image) + detailsTable.add(image) } city.demandedResource.isNotEmpty() -> { val image = ImageGetter.getResourcePortrait(city.demandedResource, iconSize *0.7f).apply { @@ -235,14 +235,14 @@ class CityOverviewTab( gameInfo.getExploredResourcesNotification(viewingPlayer, city.demandedResource) ) } } - cityInfoTableDetails.add(image) + detailsTable.add(image) } - else -> cityInfoTableDetails.add() + else -> detailsTable.add() } val garrisonUnit = city.getGarrison() if (garrisonUnit == null) { - cityInfoTableDetails.add() + detailsTable.add() } else { val garrisonUnitName = garrisonUnit.displayName() val garrisonUnitIcon = ImageGetter.getConstructionPortrait(garrisonUnit.baseUnit.getIconName(), iconSize * 0.7f) @@ -250,9 +250,9 @@ class CityOverviewTab( garrisonUnitIcon.onClick { overviewScreen.select(EmpireOverviewCategories.Units, UnitOverviewTab.getUnitIdentifier(garrisonUnit) ) } - cityInfoTableDetails.add(garrisonUnitIcon) + detailsTable.add(garrisonUnitIcon) } - cityInfoTableDetails.row() + detailsTable.row() } // row heights may diverge - fix it by setting minHeight to @@ -260,21 +260,21 @@ class CityOverviewTab( val largestLabelHeight = constructionCells.maxByOrNull{ it.prefHeight }!!.prefHeight for (cell in constructionCells) cell.minHeight(largestLabelHeight) - cityInfoTableDetails.pack() + detailsTable.pack() } private fun updateTotal() { - cityInfoTableTotal.add("Total".toLabel()).left() - cityInfoTableTotal.add() // construction icon column - cityInfoTableTotal.add().expandX() // construction label column - cityInfoTableTotal.add(viewingPlayer.cities.sumOf { it.population.population }.toCenteredLabel()) + totalTable.add("Total".toLabel()).left() + totalTable.add() // construction icon column + totalTable.add().expandX() // construction label column + totalTable.add(viewingPlayer.cities.sumOf { it.population.population }.toCenteredLabel()) for (column in columnsNames.filter { it.isStat() }) { val stat = Stat.valueOf(column) - if (stat == Stat.Food || stat == Stat.Production) cityInfoTableTotal.add() // an intended empty space - else cityInfoTableTotal.add(viewingPlayer.cities.sumOf { it.getStat(stat) }.toCenteredLabel()) + if (stat == Stat.Food || stat == Stat.Production) totalTable.add() // an intended empty space + else totalTable.add(viewingPlayer.cities.sumOf { it.getStat(stat) }.toCenteredLabel()) } - cityInfoTableTotal.add(viewingPlayer.cities.count { it.isWeLoveTheKingDayActive() }.toCenteredLabel()) - cityInfoTableTotal.add(viewingPlayer.cities.count { it.isGarrisoned() }.toCenteredLabel()) - cityInfoTableTotal.pack() + totalTable.add(viewingPlayer.cities.count { it.isWeLoveTheKingDayActive() }.toCenteredLabel()) + totalTable.add(viewingPlayer.cities.count { it.isGarrisoned() }.toCenteredLabel()) + totalTable.pack() } } diff --git a/tests/src/com/unciv/uniques/GlobalUniquesTests.kt b/tests/src/com/unciv/uniques/GlobalUniquesTests.kt index 58dcb89694..9dc9497412 100644 --- a/tests/src/com/unciv/uniques/GlobalUniquesTests.kt +++ b/tests/src/com/unciv/uniques/GlobalUniquesTests.kt @@ -30,12 +30,12 @@ class GlobalUniquesTests { fun statsOnBuilding() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val buildingName = game.createBuilding("[+1 Food]").name - cityInfo.cityConstructions.addBuilding(buildingName) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.equals(Stats(food=1f))) + city.cityConstructions.addBuilding(buildingName) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.equals(Stats(food=1f))) } @@ -58,70 +58,70 @@ class GlobalUniquesTests { fun statsPerCity() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val buildingName = game.createBuilding("[+1 Production] [in this city]").name - cityInfo.cityConstructions.addBuilding(buildingName) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.equals(Stats(production=1f))) + city.cityConstructions.addBuilding(buildingName) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.equals(Stats(production=1f))) } @Test fun statsPerSpecialist() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true, initialPopulation = 2) + val city = game.addCity(civInfo, tile, true, initialPopulation = 2) val building = game.createBuilding("[+3 Gold] from every specialist [in this city]") val specialistName = game.createSpecialist() building.specialistSlots.add(specialistName, 2) - cityInfo.population.specialistAllocations[specialistName] = 2 + city.population.specialistAllocations[specialistName] = 2 - cityInfo.cityConstructions.addBuilding(building.name) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Specialists"]!!.equals(Stats(gold=6f))) + city.cityConstructions.addBuilding(building.name) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Specialists"]!!.equals(Stats(gold=6f))) } @Test fun statsPerPopulation() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true, initialPopulation = 4) + val city = game.addCity(civInfo, tile, true, initialPopulation = 4) val building = game.createBuilding("[+3 Gold] per [2] population [in this city]") - cityInfo.cityConstructions.addBuilding(building.name) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.gold == 6f) + city.cityConstructions.addBuilding(building.name) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.gold == 6f) } @Test fun statsPerXPopulation() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true, initialPopulation = 2) + val city = game.addCity(civInfo, tile, true, initialPopulation = 2) val building = game.createBuilding("[+3 Gold] ") - cityInfo.cityConstructions.addBuilding(building.name) + city.cityConstructions.addBuilding(building.name) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.gold == 0f) - cityInfo.population.setPopulation(5) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.gold == 3f) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.gold == 0f) + city.population.setPopulation(5) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.gold == 3f) } @Test fun statsFromCitiesOnSpecificTiles() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val building = game.createBuilding("[+3 Gold] in cities on [${Constants.desert}] tiles") - cityInfo.cityConstructions.addBuilding(building.name) + city.cityConstructions.addBuilding(building.name) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.gold == 3f) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.gold == 3f) tile.baseTerrain = Constants.grassland - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.gold == 0f) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.gold == 0f) } @Test @@ -129,12 +129,12 @@ class GlobalUniquesTests { game.makeHexagonalMap(2) val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val building = game.createBuilding("[+4 Gold] from [${Constants.grassland}] tiles [in all cities]") - cityInfo.cityConstructions.addBuilding(building.name) + city.cityConstructions.addBuilding(building.name) val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) - Assert.assertTrue(tile2.stats.getTileStats(cityInfo, civInfo).gold == 4f) + Assert.assertTrue(tile2.stats.getTileStats(city, civInfo).gold == 4f) } @Test @@ -142,17 +142,17 @@ class GlobalUniquesTests { game.makeHexagonalMap(3) val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val building = game.createBuilding("[+4 Gold] from [${Constants.grassland}] tiles without [${Constants.forest}] [in this city]") - cityInfo.cityConstructions.addBuilding(building.name) + city.cityConstructions.addBuilding(building.name) val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) - game.addTileToCity(cityInfo, tile2) - Assert.assertTrue(tile2.stats.getTileStats(cityInfo, civInfo).gold == 4f) + game.addTileToCity(city, tile2) + Assert.assertTrue(tile2.stats.getTileStats(city, civInfo).gold == 4f) val tile3 = game.setTileFeatures(Vector2(0f, 2f), Constants.grassland, listOf(Constants.forest)) - game.addTileToCity(cityInfo, tile3) - Assert.assertFalse(tile3.stats.getTileStats(cityInfo, civInfo).gold == 4f) + game.addTileToCity(city, tile3) + Assert.assertFalse(tile3.stats.getTileStats(city, civInfo).gold == 4f) } @Test @@ -160,32 +160,32 @@ class GlobalUniquesTests { game.makeHexagonalMap(1) val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true, initialPopulation = 2) + val city = game.addCity(civInfo, tile, true, initialPopulation = 2) val specialist = game.createSpecialist() val building = game.createBuilding("[+3 Faith] from every [${specialist}]") - cityInfo.cityConstructions.addBuilding(building.name) - cityInfo.population.specialistAllocations[specialist] = 2 + city.cityConstructions.addBuilding(building.name) + city.population.specialistAllocations[specialist] = 2 - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Specialists"]!!.faith == 6f) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Specialists"]!!.faith == 6f) - cityInfo.cityConstructions.removeBuilding(building.name) + city.cityConstructions.removeBuilding(building.name) val building2 = game.createBuilding("[+3 Faith] from every [${Constants.grassland}]") - cityInfo.cityConstructions.addBuilding(building2.name) + city.cityConstructions.addBuilding(building2.name) val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) - Assert.assertTrue(tile2.stats.getTileStats(cityInfo, civInfo).faith == 3f) + Assert.assertTrue(tile2.stats.getTileStats(city, civInfo).faith == 3f) - cityInfo.cityConstructions.removeBuilding(building2.name) + city.cityConstructions.removeBuilding(building2.name) val emptyBuilding = game.createBuilding() val building3 = game.createBuilding("[+3 Faith] from every [${emptyBuilding.name}]") - cityInfo.cityConstructions.addBuilding(emptyBuilding.name) - cityInfo.cityConstructions.addBuilding(building3.name) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.faith == 3f) + city.cityConstructions.addBuilding(emptyBuilding.name) + city.cityConstructions.addBuilding(building3.name) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.faith == 3f) } @Test @@ -533,24 +533,24 @@ class GlobalUniquesTests { fun growthPercentBonusTest() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val building = game.createBuilding("[+100]% growth [in all cities]") - cityInfo.cityConstructions.addBuilding(building.name) + city.cityConstructions.addBuilding(building.name) - cityInfo.cityStats.update() - Assert.assertTrue(cityInfo.cityStats.finalStatList["[Buildings] ([Growth])"]!!.equals(Stats(food=2f))) + city.cityStats.update() + Assert.assertTrue(city.cityStats.finalStatList["[Buildings] ([Growth])"]!!.equals(Stats(food=2f))) } @Test fun carryOverFoodTest() { val civInfo = game.addCiv("[50]% Food is carried over after population increases [in all cities]") val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) - val foodNecessary = cityInfo.population.getFoodToNextPopulation() - cityInfo.population.nextTurn(foodNecessary) + val foodNecessary = city.population.getFoodToNextPopulation() + city.population.nextTurn(foodNecessary) - Assert.assertTrue(cityInfo.population.foodStored == (foodNecessary * 0.5f).toInt()) + Assert.assertTrue(city.population.foodStored == (foodNecessary * 0.5f).toInt()) } @@ -558,16 +558,16 @@ class GlobalUniquesTests { fun foodConsumptionBySpecialistsTest() { val civInfo = game.addCiv("[-50]% Food consumption by specialists [in all cities]") val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true, initialPopulation = 1) + val city = game.addCity(civInfo, tile, true, initialPopulation = 1) val building = game.createBuilding() val specialistName = game.createSpecialist() building.specialistSlots.add(specialistName, 1) - cityInfo.population.specialistAllocations[specialistName] = 1 + city.population.specialistAllocations[specialistName] = 1 - cityInfo.cityStats.update() - print(cityInfo.cityStats.finalStatList) - Assert.assertTrue(cityInfo.cityStats.finalStatList["Population"]!!.food == -1f) + city.cityStats.update() + print(city.cityStats.finalStatList) + Assert.assertTrue(city.cityStats.finalStatList["Population"]!!.food == -1f) } // endregion growth @@ -578,38 +578,38 @@ class GlobalUniquesTests { fun unhappinessFromCitiesPercentageTest() { val civInfo = game.addCiv("[+100]% unhappiness from the number of cities") val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) - cityInfo.cityStats.update() + city.cityStats.update() // Because of some weird design choices, -3.6 is correct, though I would expect it to be -6 instead. // As I'm not certain enough in my feeling that it should be -6, I'm changing the test to fit the code instead of the other way around. // I've also written some text about this in CityStats.updateCityHappiness(). ~xlenstra - println(cityInfo.cityStats.happinessList) - Assert.assertTrue(abs(cityInfo.cityStats.happinessList["Cities"]!! - -3.6f) < epsilon) // Float rounding errors + println(city.cityStats.happinessList) + Assert.assertTrue(abs(city.cityStats.happinessList["Cities"]!! - -3.6f) < epsilon) // Float rounding errors } @Test fun unhappinessFromPopulationTypePercentageChangeTest() { val civInfo = game.addCiv("[-50]% Unhappiness from [Population] [in all cities]") val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true, initialPopulation = 4) + val city = game.addCity(civInfo, tile, true, initialPopulation = 4) - cityInfo.cityStats.update() + city.cityStats.update() // This test suffers from the same problems as `unhappinessFromCitiesPercentageTest()`. // This should be -2, I believe, as every pop should add -1 happiness and 4 pop with -50% unhappiness = -2 unhappiness. - println(cityInfo.cityStats.happinessList) - Assert.assertTrue(abs(cityInfo.cityStats.happinessList["Population"]!! - -1.2f) < epsilon) + println(city.cityStats.happinessList) + Assert.assertTrue(abs(city.cityStats.happinessList["Population"]!! - -1.2f) < epsilon) val building = game.createBuilding("[-50]% Unhappiness from [Specialists] [in all cities]") val specialist = game.createSpecialist() building.specialistSlots[specialist] = 2 - cityInfo.population.specialistAllocations[specialist] = 2 - cityInfo.cityConstructions.addBuilding(building.name) + city.population.specialistAllocations[specialist] = 2 + city.cityConstructions.addBuilding(building.name) - cityInfo.cityStats.update() - println(cityInfo.cityStats.happinessList) + city.cityStats.update() + println(city.cityStats.happinessList) // This test suffers from the same problems as above. It should be -1, I believe. - Assert.assertTrue(abs(cityInfo.cityStats.happinessList["Population"]!! - -0.6f) < epsilon) + Assert.assertTrue(abs(city.cityStats.happinessList["Population"]!! - -0.6f) < epsilon) } @@ -621,10 +621,10 @@ class GlobalUniquesTests { fun statsSpendingGreatPeople() { val civInfo = game.addCiv() val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert) - val cityInfo = game.addCity(civInfo, tile, true) + val city = game.addCity(civInfo, tile, true) val unit = game.addUnit("Great Engineer", civInfo, tile) val building = game.createBuilding("[+250 Gold] whenever a Great Person is expended") - cityInfo.cityConstructions.addBuilding(building.name) + city.cityConstructions.addBuilding(building.name) civInfo.addGold(-civInfo.gold) // reset gold just to be sure diff --git a/tests/src/com/unciv/uniques/TestGame.kt b/tests/src/com/unciv/uniques/TestGame.kt index 06a1a19dde..432cddf609 100644 --- a/tests/src/com/unciv/uniques/TestGame.kt +++ b/tests/src/com/unciv/uniques/TestGame.kt @@ -9,9 +9,9 @@ import com.unciv.logic.city.managers.CityFounder import com.unciv.logic.civilization.Civilization import com.unciv.logic.civilization.PlayerType import com.unciv.logic.map.MapSizeNew +import com.unciv.logic.map.TileMap import com.unciv.logic.map.mapunit.MapUnit import com.unciv.logic.map.tile.Tile -import com.unciv.logic.map.TileMap import com.unciv.models.Religion import com.unciv.models.metadata.BaseRuleset import com.unciv.models.metadata.GameSettings @@ -135,17 +135,17 @@ class TestGame { replacePalace: Boolean = false, initialPopulation: Int = 0 ): City { - val cityInfo = CityFounder().foundCity(civInfo, tile.position) + val city = CityFounder().foundCity(civInfo, tile.position) if (initialPopulation != 1) - cityInfo.population.addPopulation(initialPopulation - 1) // With defaults this will remove population + city.population.addPopulation(initialPopulation - 1) // With defaults this will remove population if (replacePalace && civInfo.cities.size == 1) { // Add a capital indicator without any other stats val palaceWithoutStats = createBuilding(UniqueType.IndicatesCapital.text) - cityInfo.cityConstructions.removeBuilding("Palace") - cityInfo.cityConstructions.addBuilding(palaceWithoutStats.name) + city.cityConstructions.removeBuilding("Palace") + city.cityConstructions.addBuilding(palaceWithoutStats.name) } - return cityInfo + return city } fun addTileToCity(city: City, tile: Tile) { diff --git a/tests/src/com/unciv/uniques/TileUniquesTests.kt b/tests/src/com/unciv/uniques/TileUniquesTests.kt index be26fc0c46..fe5474a38c 100644 --- a/tests/src/com/unciv/uniques/TileUniquesTests.kt +++ b/tests/src/com/unciv/uniques/TileUniquesTests.kt @@ -25,8 +25,8 @@ class TileUniquesTests { val tile = game.setTileFeatures(Vector2(0f, 0f), Constants.grassland) val cityTile = game.setTileFeatures(Vector2(2f,0f), Constants.grassland) - val cityInfo = game.addCity(civInfo, cityTile, true) - cityInfo.population.foodStored = 0 // just to be sure + val city = game.addCity(civInfo, cityTile, true) + city.population.foodStored = 0 // just to be sure civInfo.addGold(-civInfo.gold) // reset gold just to be sure val testImprovement = game.createTileImprovement("Pillaging this improvement yields [+20 Gold, +11 Food]") @@ -37,6 +37,6 @@ class TileUniquesTests { val pillageAction = UnitActionsPillage.getPillageAction(unit) pillageAction?.action?.invoke() Assert.assertTrue("Pillaging should transfer gold to the civ", civInfo.gold == 20) - Assert.assertTrue("Pillaging should transfer food to the nearest city", cityInfo.population.foodStored == 11) + Assert.assertTrue("Pillaging should transfer food to the nearest city", city.population.foodStored == 11) } }