From 801116551b0653c1b26a2f4ab06c2bac99548744 Mon Sep 17 00:00:00 2001 From: Yair Morgenstern Date: Thu, 19 Jan 2023 21:56:44 +0200 Subject: [PATCH] Chore: Moved tile stat functions to separate class --- core/src/com/unciv/logic/GameStarter.kt | 2 +- .../com/unciv/logic/automation/Automation.kt | 6 +- core/src/com/unciv/logic/city/CityStats.kt | 2 +- .../city/managers/CityPopulationManager.kt | 2 +- .../logic/map/mapgenerator/MapRegions.kt | 8 +- core/src/com/unciv/logic/map/tile/TileInfo.kt | 171 +---------------- .../unciv/logic/map/tile/TileStatFunctions.kt | 177 ++++++++++++++++++ .../ui/cityscreen/CityScreenTileTable.kt | 4 +- .../com/unciv/ui/cityscreen/CityTileGroup.kt | 2 +- .../unciv/ui/mapeditor/MapEditorViewTab.kt | 8 +- .../com/unciv/ui/tilegroups/TileGroupIcons.kt | 4 +- .../ui/worldscreen/bottombar/TileInfoTable.kt | 2 +- .../com/unciv/uniques/GlobalUniquesTests.kt | 12 +- 13 files changed, 207 insertions(+), 193 deletions(-) create mode 100644 core/src/com/unciv/logic/map/tile/TileStatFunctions.kt diff --git a/core/src/com/unciv/logic/GameStarter.kt b/core/src/com/unciv/logic/GameStarter.kt index 5025ac1130..a3bf012842 100644 --- a/core/src/com/unciv/logic/GameStarter.kt +++ b/core/src/com/unciv/logic/GameStarter.kt @@ -324,7 +324,7 @@ object GameStarter { val startScores = HashMap(tileMap.values.size) for (tile in tileMap.values) { - startScores[tile] = tile.getTileStartScore() + startScores[tile] = tile.stats.getTileStartScore() } val allCivs = gameInfo.civilizations.filter { !it.isBarbarian() } val landTilesInBigEnoughGroup = getCandidateLand(allCivs.size, tileMap, startScores) diff --git a/core/src/com/unciv/logic/automation/Automation.kt b/core/src/com/unciv/logic/automation/Automation.kt index de33805146..3bcfa64b40 100644 --- a/core/src/com/unciv/logic/automation/Automation.kt +++ b/core/src/com/unciv/logic/automation/Automation.kt @@ -22,7 +22,7 @@ import com.unciv.ui.victoryscreen.RankingType object Automation { fun rankTileForCityWork(tile: TileInfo, city: CityInfo, cityStats: Stats): Float { - val stats = tile.getTileStats(city, city.civInfo) + val stats = tile.stats.getTileStats(city, city.civInfo) return rankStatsForCityWork(stats, city, cityStats) } @@ -349,7 +349,7 @@ object Automation { if (tile == null) return 0f val tileOwner = tile.getOwner() if (tileOwner != null && tileOwner != civInfo) return 0f // Already belongs to another civilization, useless to us - val stats = tile.getTileStats(null, civInfo) + val stats = tile.stats.getTileStats(null, civInfo) var rank = rankStatsValue(stats, civInfo) if (tile.improvement == null) rank += 0.5f // improvement potential! if (tile.isPillaged()) rank += 0.6f @@ -400,7 +400,7 @@ object Automation { if (tile.naturalWonder != null) score -= 105 // Straight up take the sum of all yields - score -= tile.getTileStats(cityInfo, cityInfo.civInfo, localUniqueCache).values.sum().toInt() + score -= tile.stats.getTileStats(cityInfo, cityInfo.civInfo, localUniqueCache).values.sum().toInt() // Check if we get access to better tiles from this tile var adjacentNaturalWonder = false diff --git a/core/src/com/unciv/logic/city/CityStats.kt b/core/src/com/unciv/logic/city/CityStats.kt index 2698ba3e85..9d66835a1c 100644 --- a/core/src/com/unciv/logic/city/CityStats.kt +++ b/core/src/com/unciv/logic/city/CityStats.kt @@ -363,7 +363,7 @@ class CityStats(val cityInfo: CityInfo) { || it.terrainHasUnique(UniqueType.TileProvidesYieldWithoutPopulation)) } for (cell in workedTiles) { - val cellStats = cell.getTileStats(cityInfo, cityInfo.civInfo, localUniqueCache) + val cellStats = cell.stats.getTileStats(cityInfo, cityInfo.civInfo, localUniqueCache) stats.add(cellStats) } statsFromTiles = stats diff --git a/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt b/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt index 3759e1ab6f..3aa84280f3 100644 --- a/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt +++ b/core/src/com/unciv/logic/city/managers/CityPopulationManager.kt @@ -175,7 +175,7 @@ class CityPopulationManager : IsPartOfGameInfoSerialization { if (valueBestTile > valueBestSpecialist) { if (bestTile != null) { cityInfo.workedTiles = cityInfo.workedTiles.withItem(bestTile.position) - cityStats[Stat.Food] += bestTile.getTileStats(cityInfo, cityInfo.civInfo)[Stat.Food] + cityStats[Stat.Food] += bestTile.stats.getTileStats(cityInfo, cityInfo.civInfo)[Stat.Food] } } else if (bestJob != null) { specialistAllocations.add(bestJob, 1) diff --git a/core/src/com/unciv/logic/map/mapgenerator/MapRegions.kt b/core/src/com/unciv/logic/map/mapgenerator/MapRegions.kt index 6577dbebdb..df83172c6a 100644 --- a/core/src/com/unciv/logic/map/mapgenerator/MapRegions.kt +++ b/core/src/com/unciv/logic/map/mapgenerator/MapRegions.kt @@ -3,12 +3,12 @@ package com.unciv.logic.map.mapgenerator import com.badlogic.gdx.math.Rectangle import com.badlogic.gdx.math.Vector2 import com.unciv.Constants -import com.unciv.logic.map.HexMath import com.unciv.logic.civilization.CivilizationInfo +import com.unciv.logic.map.HexMath import com.unciv.logic.map.MapResources import com.unciv.logic.map.MapShape -import com.unciv.logic.map.tile.TileInfo import com.unciv.logic.map.TileMap +import com.unciv.logic.map.tile.TileInfo import com.unciv.models.metadata.GameParameters import com.unciv.models.ruleset.Ruleset import com.unciv.models.ruleset.tile.ResourceType @@ -265,7 +265,7 @@ class MapRegions (val ruleset: Ruleset){ // The rest are positive bias val positiveBiasCivs = civilizations.filterNot { it in coastBiasCivs || it in negativeBiasCivs || it in randomCivs } .sortedBy { ruleset.nations[it.civName]!!.startBias.size } // civs with only one desired region go first - val positiveBiasFallbackCivs = ArrayList() // Civs who couln't get their desired region at first pass + val positiveBiasFallbackCivs = ArrayList() // Civs who couldn't get their desired region at first pass val unpickedRegions = regions.toMutableList() // First assign coast bias civs @@ -711,7 +711,7 @@ class MapRegions (val ruleset: Ruleset){ } private fun getPotentialYield(tile: TileInfo, stat: Stat, unimproved: Boolean = false): Float { - val baseYield = tile.getTileStats(null)[stat] + val baseYield = tile.stats.getTileStats(null)[stat] if (unimproved) return baseYield val bestImprovementYield = tile.tileMap.ruleset!!.tileImprovements.values diff --git a/core/src/com/unciv/logic/map/tile/TileInfo.kt b/core/src/com/unciv/logic/map/tile/TileInfo.kt index d2a486bced..462960876b 100644 --- a/core/src/com/unciv/logic/map/tile/TileInfo.kt +++ b/core/src/com/unciv/logic/map/tile/TileInfo.kt @@ -17,17 +17,13 @@ import com.unciv.models.ruleset.tile.Terrain import com.unciv.models.ruleset.tile.TerrainType import com.unciv.models.ruleset.tile.TileImprovement import com.unciv.models.ruleset.tile.TileResource -import com.unciv.models.ruleset.unique.LocalUniqueCache import com.unciv.models.ruleset.unique.StateForConditionals import com.unciv.models.ruleset.unique.Unique import com.unciv.models.ruleset.unique.UniqueMap import com.unciv.models.ruleset.unique.UniqueType -import com.unciv.models.stats.Stat -import com.unciv.models.stats.Stats import com.unciv.models.translations.tr import com.unciv.ui.civilopedia.FormattedLine import com.unciv.ui.utils.Fonts -import com.unciv.ui.utils.extensions.toPercent import kotlin.math.abs import kotlin.math.min import kotlin.random.Random @@ -42,6 +38,9 @@ open class TileInfo : IsPartOfGameInfoSerialization { @Transient val improvementFunctions = TileInfoImprovementFunctions(this) + @Transient + val stats = TileStatFunctions(this) + @Transient private var isCityCenterInternal = false @@ -230,7 +229,7 @@ open class TileInfo : IsPartOfGameInfoSerialization { return tileResourceCache!! } - private fun getNaturalWonder(): Terrain = + internal fun getNaturalWonder(): Terrain = if (naturalWonder == null) throw Exception("No natural wonder exists for this tile!") else ruleset.terrains[naturalWonder!!]!! @@ -430,168 +429,6 @@ open class TileInfo : IsPartOfGameInfoSerialization { return workingCity != null && workingCity.lockedTiles.contains(position) } - fun getTileStats(observingCiv: CivilizationInfo?): Stats = getTileStats(getCity(), observingCiv) - - fun getTileStats(city: CityInfo?, observingCiv: CivilizationInfo?, - localUniqueCache: LocalUniqueCache = LocalUniqueCache(false) - ): Stats { - var stats = getBaseTerrain().cloneStats() - - val stateForConditionals = StateForConditionals(civInfo = observingCiv, cityInfo = city, tile = this) - - for (terrainFeatureBase in terrainFeatureObjects) { - when { - terrainFeatureBase.hasUnique(UniqueType.NullifyYields) -> - return terrainFeatureBase.cloneStats() - terrainFeatureBase.overrideStats -> stats = terrainFeatureBase.cloneStats() - else -> stats.add(terrainFeatureBase) - } - } - - if (naturalWonder != null) { - val wonderStats = getNaturalWonder().cloneStats() - - if (getNaturalWonder().overrideStats) - stats = wonderStats - else - stats.add(wonderStats) - } - - if (city != null) { - var tileUniques = city.getMatchingUniques(UniqueType.StatsFromTiles, StateForConditionals.IgnoreConditionals) - .filter { city.matchesFilter(it.params[2]) } - tileUniques += city.getMatchingUniques(UniqueType.StatsFromObject, StateForConditionals.IgnoreConditionals) - for (unique in localUniqueCache.get("StatsFromTilesAndObjects", tileUniques)) { - if (!unique.conditionalsApply(stateForConditionals)) continue - val tileType = unique.params[1] - if (!matchesTerrainFilter(tileType, observingCiv)) continue - stats.add(unique.stats) - } - - for (unique in localUniqueCache.get("StatsFromTilesWithout", - city.getMatchingUniques(UniqueType.StatsFromTilesWithout, StateForConditionals.IgnoreConditionals)) - ) { - if ( - unique.conditionalsApply(stateForConditionals) && - matchesTerrainFilter(unique.params[1]) && - !matchesTerrainFilter(unique.params[2]) && - city.matchesFilter(unique.params[3]) - ) - stats.add(unique.stats) - } - } - - if (isAdjacentToRiver()) stats.gold++ - - if (observingCiv != null) { - // resource base - if (hasViewableResource(observingCiv)) stats.add(tileResource) - - val improvement = getUnpillagedTileImprovement() - if (improvement != null) - stats.add(improvementFunctions.getImprovementStats(improvement, observingCiv, city, localUniqueCache)) - - if (stats.gold != 0f && observingCiv.goldenAges.isGoldenAge()) - stats.gold++ - } - if (isCityCenter()) { - if (stats.food < 2) stats.food = 2f - if (stats.production < 1) stats.production = 1f - } - - for ((stat, value) in stats) - if (value < 0f) stats[stat] = 0f - - for ((stat, value) in getTilePercentageStats(observingCiv, city)) { - stats[stat] *= value.toPercent() - } - - return stats - } - - // Only gets the tile percentage bonus, not the improvement percentage bonus - @Suppress("MemberVisibilityCanBePrivate") - fun getTilePercentageStats(observingCiv: CivilizationInfo?, city: CityInfo?): Stats { - val stats = Stats() - val stateForConditionals = StateForConditionals(civInfo = observingCiv, cityInfo = city, tile = this) - - if (city != null) { - for (unique in city.getMatchingUniques(UniqueType.StatPercentFromObject, stateForConditionals)) { - val tileFilter = unique.params[2] - if (matchesTerrainFilter(tileFilter, observingCiv)) - stats[Stat.valueOf(unique.params[1])] += unique.params[0].toFloat() - } - - for (unique in city.getMatchingUniques(UniqueType.AllStatsPercentFromObject, stateForConditionals)) { - val tileFilter = unique.params[1] - if (!matchesTerrainFilter(tileFilter, observingCiv)) continue - val statPercentage = unique.params[0].toFloat() - for (stat in Stat.values()) - stats[stat] += statPercentage - } - - } else if (observingCiv != null) { - for (unique in observingCiv.getMatchingUniques(UniqueType.StatPercentFromObject, stateForConditionals)) { - val tileFilter = unique.params[2] - if (matchesTerrainFilter(tileFilter, observingCiv)) - stats[Stat.valueOf(unique.params[1])] += unique.params[0].toFloat() - } - - for (unique in observingCiv.getMatchingUniques(UniqueType.AllStatsPercentFromObject, stateForConditionals)) { - val tileFilter = unique.params[1] - if (!matchesTerrainFilter(tileFilter, observingCiv)) continue - val statPercentage = unique.params[0].toFloat() - for (stat in Stat.values()) - stats[stat] += statPercentage - } - } - - return stats - } - - fun getTileStartScore(): Float { - var sum = 0f - for (tile in getTilesInDistance(2)) { - val tileYield = tile.getTileStartYield(tile == this) - sum += tileYield - if (tile in neighbors) - sum += tileYield - } - - if (isHill()) - sum -= 2f - if (isAdjacentToRiver()) - sum += 2f - if (neighbors.any { it.baseTerrain == Constants.mountain }) - sum += 2f - if (isCoastalTile()) - sum += 3f - if (!isCoastalTile() && neighbors.any { it.isCoastalTile() }) - sum -= 7f - - return sum - } - - private fun getTileStartYield(isCenter: Boolean): Float { - var stats = getBaseTerrain().cloneStats() - - for (terrainFeatureBase in terrainFeatureObjects) { - if (terrainFeatureBase.overrideStats) - stats = terrainFeatureBase.cloneStats() - else - stats.add(terrainFeatureBase) - } - if (resource != null) stats.add(tileResource) - - if (stats.production < 0) stats.production = 0f - if (isCenter) { - if (stats.food < 2) stats.food = 2f - if (stats.production < 1) stats.production = 1f - } - - return stats.food + stats.production + stats.gold - } - // For dividing the map into Regions to determine start locations fun getTileFertility(checkCoasts: Boolean): Int { var fertility = 0 diff --git a/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt b/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt new file mode 100644 index 0000000000..6ff692910b --- /dev/null +++ b/core/src/com/unciv/logic/map/tile/TileStatFunctions.kt @@ -0,0 +1,177 @@ +package com.unciv.logic.map.tile + +import com.unciv.Constants +import com.unciv.logic.city.CityInfo +import com.unciv.logic.civilization.CivilizationInfo +import com.unciv.models.ruleset.unique.LocalUniqueCache +import com.unciv.models.ruleset.unique.StateForConditionals +import com.unciv.models.ruleset.unique.UniqueType +import com.unciv.models.stats.Stat +import com.unciv.models.stats.Stats +import com.unciv.ui.utils.extensions.toPercent + +class TileStatFunctions(val tileInfo: TileInfo) { + + fun getTileStats(observingCiv: CivilizationInfo?): Stats = getTileStats(tileInfo.getCity(), observingCiv) + + fun getTileStats(city: CityInfo?, observingCiv: CivilizationInfo?, + localUniqueCache: LocalUniqueCache = LocalUniqueCache(false) + ): Stats { + var stats = tileInfo.getBaseTerrain().cloneStats() + + val stateForConditionals = StateForConditionals(civInfo = observingCiv, cityInfo = city, tile = tileInfo) + + for (terrainFeatureBase in tileInfo.terrainFeatureObjects) { + when { + terrainFeatureBase.hasUnique(UniqueType.NullifyYields) -> + return terrainFeatureBase.cloneStats() + terrainFeatureBase.overrideStats -> stats = terrainFeatureBase.cloneStats() + else -> stats.add(terrainFeatureBase) + } + } + + if (tileInfo.naturalWonder != null) { + val wonderStats = tileInfo.getNaturalWonder().cloneStats() + + if (tileInfo.getNaturalWonder().overrideStats) + stats = wonderStats + else + stats.add(wonderStats) + } + + if (city != null) { + var tileUniques = city.getMatchingUniques(UniqueType.StatsFromTiles, StateForConditionals.IgnoreConditionals) + .filter { city.matchesFilter(it.params[2]) } + tileUniques += city.getMatchingUniques(UniqueType.StatsFromObject, StateForConditionals.IgnoreConditionals) + for (unique in localUniqueCache.get("StatsFromTilesAndObjects", tileUniques)) { + if (!unique.conditionalsApply(stateForConditionals)) continue + val tileType = unique.params[1] + if (!tileInfo.matchesTerrainFilter(tileType, observingCiv)) continue + stats.add(unique.stats) + } + + for (unique in localUniqueCache.get("StatsFromTilesWithout", + city.getMatchingUniques(UniqueType.StatsFromTilesWithout, StateForConditionals.IgnoreConditionals)) + ) { + if ( + unique.conditionalsApply(stateForConditionals) && + tileInfo.matchesTerrainFilter(unique.params[1]) && + !tileInfo.matchesTerrainFilter(unique.params[2]) && + city.matchesFilter(unique.params[3]) + ) + stats.add(unique.stats) + } + } + + if (tileInfo.isAdjacentToRiver()) stats.gold++ + + if (observingCiv != null) { + // resource base + if (tileInfo.hasViewableResource(observingCiv)) stats.add(tileInfo.tileResource) + + val improvement = tileInfo.getUnpillagedTileImprovement() + if (improvement != null) + stats.add(tileInfo.improvementFunctions.getImprovementStats(improvement, observingCiv, city, localUniqueCache)) + + if (stats.gold != 0f && observingCiv.goldenAges.isGoldenAge()) + stats.gold++ + } + if (tileInfo.isCityCenter()) { + if (stats.food < 2) stats.food = 2f + if (stats.production < 1) stats.production = 1f + } + + for ((stat, value) in stats) + if (value < 0f) stats[stat] = 0f + + for ((stat, value) in getTilePercentageStats(observingCiv, city)) { + stats[stat] *= value.toPercent() + } + + return stats + } + + // Only gets the tile percentage bonus, not the improvement percentage bonus + @Suppress("MemberVisibilityCanBePrivate") + fun getTilePercentageStats(observingCiv: CivilizationInfo?, city: CityInfo?): Stats { + val stats = Stats() + val stateForConditionals = StateForConditionals(civInfo = observingCiv, cityInfo = city, tile = tileInfo) + + if (city != null) { + for (unique in city.getMatchingUniques(UniqueType.StatPercentFromObject, stateForConditionals)) { + val tileFilter = unique.params[2] + if (tileInfo.matchesTerrainFilter(tileFilter, observingCiv)) + stats[Stat.valueOf(unique.params[1])] += unique.params[0].toFloat() + } + + for (unique in city.getMatchingUniques(UniqueType.AllStatsPercentFromObject, stateForConditionals)) { + val tileFilter = unique.params[1] + if (!tileInfo.matchesTerrainFilter(tileFilter, observingCiv)) continue + val statPercentage = unique.params[0].toFloat() + for (stat in Stat.values()) + stats[stat] += statPercentage + } + + } else if (observingCiv != null) { + for (unique in observingCiv.getMatchingUniques(UniqueType.StatPercentFromObject, stateForConditionals)) { + val tileFilter = unique.params[2] + if (tileInfo.matchesTerrainFilter(tileFilter, observingCiv)) + stats[Stat.valueOf(unique.params[1])] += unique.params[0].toFloat() + } + + for (unique in observingCiv.getMatchingUniques(UniqueType.AllStatsPercentFromObject, stateForConditionals)) { + val tileFilter = unique.params[1] + if (!tileInfo.matchesTerrainFilter(tileFilter, observingCiv)) continue + val statPercentage = unique.params[0].toFloat() + for (stat in Stat.values()) + stats[stat] += statPercentage + } + } + + return stats + } + + fun getTileStartScore(): Float { + var sum = 0f + for (closeTile in tileInfo.getTilesInDistance(2)) { + val tileYield = closeTile.stats.getTileStartYield(closeTile == tileInfo) + sum += tileYield + if (closeTile in tileInfo.neighbors) + sum += tileYield + } + + if (tileInfo.isHill()) + sum -= 2f + if (tileInfo.isAdjacentToRiver()) + sum += 2f + if (tileInfo.neighbors.any { it.baseTerrain == Constants.mountain }) + sum += 2f + if (tileInfo.isCoastalTile()) + sum += 3f + if (!tileInfo.isCoastalTile() && tileInfo.neighbors.any { it.isCoastalTile() }) + sum -= 7f + + return sum + } + + private fun getTileStartYield(isCenter: Boolean): Float { + var stats = tileInfo.getBaseTerrain().cloneStats() + + for (terrainFeatureBase in tileInfo.terrainFeatureObjects) { + if (terrainFeatureBase.overrideStats) + stats = terrainFeatureBase.cloneStats() + else + stats.add(terrainFeatureBase) + } + if (tileInfo.resource != null) stats.add(tileInfo.tileResource) + + if (stats.production < 0) stats.production = 0f + if (isCenter) { + if (stats.food < 2) stats.food = 2f + if (stats.production < 1) stats.production = 1f + } + + return stats.food + stats.production + stats.gold + } + +} diff --git a/core/src/com/unciv/ui/cityscreen/CityScreenTileTable.kt b/core/src/com/unciv/ui/cityscreen/CityScreenTileTable.kt index 598091ab29..4e9093f222 100644 --- a/core/src/com/unciv/ui/cityscreen/CityScreenTileTable.kt +++ b/core/src/com/unciv/ui/cityscreen/CityScreenTileTable.kt @@ -49,7 +49,7 @@ class CityScreenTileTable(private val cityScreen: CityScreen): Table() { isVisible = true innerTable.clearChildren() - val stats = selectedTile.getTileStats(city, city.civInfo) + val stats = selectedTile.stats.getTileStats(city, city.civInfo) innerTable.pad(5f) innerTable.add( MarkupRenderer.render(selectedTile.toMarkup(city.civInfo), iconDisplay = IconDisplay.None) { @@ -110,7 +110,7 @@ class CityScreenTileTable(private val cityScreen: CityScreen): Table() { * Used from onClick and keyboard dispatch, thus only minimal parameters are passed, * and it needs to do all checks and the sound as appropriate. */ - fun askToBuyTile(selectedTile: TileInfo) { + private fun askToBuyTile(selectedTile: TileInfo) { // These checks are redundant for the onClick action, but not for the keyboard binding if (!isTilePurchaseShown(selectedTile)) return val goldCostOfTile = city.expansion.getGoldCostOfTile(selectedTile) diff --git a/core/src/com/unciv/ui/cityscreen/CityTileGroup.kt b/core/src/com/unciv/ui/cityscreen/CityTileGroup.kt index 18f362c10a..7435427378 100644 --- a/core/src/com/unciv/ui/cityscreen/CityTileGroup.kt +++ b/core/src/com/unciv/ui/cityscreen/CityTileGroup.kt @@ -78,7 +78,7 @@ class CityTileGroup(private val city: CityInfo, tileInfo: TileInfo, tileSetStrin } private fun updateYieldGroup() { - yieldGroup.setStats(tileInfo.getTileStats(city, city.civInfo)) + yieldGroup.setStats(tileInfo.stats.getTileStats(city, city.civInfo)) yieldGroup.setOrigin(Align.center) yieldGroup.setScale(0.7f) yieldGroup.toFront() diff --git a/core/src/com/unciv/ui/mapeditor/MapEditorViewTab.kt b/core/src/com/unciv/ui/mapeditor/MapEditorViewTab.kt index 767c816666..9cf6ab43e2 100644 --- a/core/src/com/unciv/ui/mapeditor/MapEditorViewTab.kt +++ b/core/src/com/unciv/ui/mapeditor/MapEditorViewTab.kt @@ -6,11 +6,11 @@ import com.badlogic.gdx.scenes.scene2d.ui.Table import com.unciv.UncivGame import com.unciv.logic.GameInfo import com.unciv.logic.civilization.CivilizationInfo -import com.unciv.logic.map.tile.TileInfo import com.unciv.logic.map.TileMap +import com.unciv.logic.map.tile.TileInfo import com.unciv.models.Counter -import com.unciv.models.ruleset.nation.Nation import com.unciv.models.ruleset.Ruleset +import com.unciv.models.ruleset.nation.Nation import com.unciv.models.stats.Stats import com.unciv.models.translations.tr import com.unciv.ui.civilopedia.CivilopediaScreen @@ -158,7 +158,7 @@ class MapEditorViewTab( editorScreen.tileClickHandler = null } - fun tileClickHandler(tile: TileInfo) { + private fun tileClickHandler(tile: TileInfo) { if (tileDataCell == null) return val lines = ArrayList() @@ -169,7 +169,7 @@ class MapEditorViewTab( lines.addAll(tile.toMarkup(null)) val stats = try { - tile.getTileStats(null, mockCiv) + tile.stats.getTileStats(null, mockCiv) } catch (ex: Exception) { // Maps aren't always fixed to remove dead references... like resource "Gold" if (ex.message != null) diff --git a/core/src/com/unciv/ui/tilegroups/TileGroupIcons.kt b/core/src/com/unciv/ui/tilegroups/TileGroupIcons.kt index 1378fff217..4d96cbcad8 100644 --- a/core/src/com/unciv/ui/tilegroups/TileGroupIcons.kt +++ b/core/src/com/unciv/ui/tilegroups/TileGroupIcons.kt @@ -23,7 +23,7 @@ class TileGroupIcons(val tileGroup: TileGroup) { var improvementIcon: Actor? = null var populationIcon: Image? = null //reuse for acquire icon - val startingLocationIcons = mutableListOf() + private val startingLocationIcons = mutableListOf() var civilianUnitIcon: UnitGroup? = null var militaryUnitIcon: UnitGroup? = null @@ -142,7 +142,7 @@ class TileGroupIcons(val tileGroup: TileGroup) { if (showTileYields) { // Setting up YieldGroup Icon - tileGroup.tileYieldGroup.setStats(tileGroup.tileInfo.getTileStats(viewingCiv)) + tileGroup.tileYieldGroup.setStats(tileGroup.tileInfo.stats.getTileStats(viewingCiv)) tileGroup.tileYieldGroup.setOrigin(Align.center) tileGroup.tileYieldGroup.setScale(0.7f) tileGroup.tileYieldGroup.toFront() diff --git a/core/src/com/unciv/ui/worldscreen/bottombar/TileInfoTable.kt b/core/src/com/unciv/ui/worldscreen/bottombar/TileInfoTable.kt index d5bd617c7b..c245a95075 100644 --- a/core/src/com/unciv/ui/worldscreen/bottombar/TileInfoTable.kt +++ b/core/src/com/unciv/ui/worldscreen/bottombar/TileInfoTable.kt @@ -45,7 +45,7 @@ class TileInfoTable(private val viewingCiv :CivilizationInfo) : Table(BaseScreen // padLeft = padRight + 5: for symmetry. An extra 5 for the distance yield number to // tile text comes from the pad up there in updateTileTable - for ((key, value) in tile.getTileStats(viewingCiv)) { + for ((key, value) in tile.stats.getTileStats(viewingCiv)) { table.add(ImageGetter.getStatIcon(key.name)) .size(20f).align(Align.right).padLeft(10f) table.add(value.toInt().toLabel()) diff --git a/tests/src/com/unciv/uniques/GlobalUniquesTests.kt b/tests/src/com/unciv/uniques/GlobalUniquesTests.kt index 8cd8307931..f05a70282a 100644 --- a/tests/src/com/unciv/uniques/GlobalUniquesTests.kt +++ b/tests/src/com/unciv/uniques/GlobalUniquesTests.kt @@ -133,7 +133,7 @@ class GlobalUniquesTests { cityInfo.cityConstructions.addBuilding(building.name) val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) - Assert.assertTrue(tile2.getTileStats(cityInfo, civInfo).gold == 4f) + Assert.assertTrue(tile2.stats.getTileStats(cityInfo, civInfo).gold == 4f) } @Test @@ -147,11 +147,11 @@ class GlobalUniquesTests { val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) game.addTileToCity(cityInfo, tile2) - Assert.assertTrue(tile2.getTileStats(cityInfo, civInfo).gold == 4f) + Assert.assertTrue(tile2.stats.getTileStats(cityInfo, civInfo).gold == 4f) val tile3 = game.setTileFeatures(Vector2(0f, 2f), Constants.grassland, listOf(Constants.forest)) game.addTileToCity(cityInfo, tile3) - Assert.assertFalse(tile3.getTileStats(cityInfo, civInfo).gold == 4f) + Assert.assertFalse(tile3.stats.getTileStats(cityInfo, civInfo).gold == 4f) } @Test @@ -174,7 +174,7 @@ class GlobalUniquesTests { cityInfo.cityConstructions.addBuilding(building2.name) val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) - Assert.assertTrue(tile2.getTileStats(cityInfo, civInfo).faith == 3f) + Assert.assertTrue(tile2.stats.getTileStats(cityInfo, civInfo).faith == 3f) cityInfo.cityConstructions.removeBuilding(building2.name) @@ -317,7 +317,7 @@ class GlobalUniquesTests { val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) tile2.changeImprovement("Farm") - Assert.assertTrue(tile2.getTileStats(city, civInfo).faith == 9f) + Assert.assertTrue(tile2.stats.getTileStats(city, civInfo).faith == 9f) city.cityConstructions.addBuilding(emptyBuilding.name) city.cityStats.update() @@ -342,7 +342,7 @@ class GlobalUniquesTests { val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland) tile2.changeImprovement("Farm") - Assert.assertTrue(tile2.getTileStats(city, civInfo).faith == 9f) + Assert.assertTrue(tile2.stats.getTileStats(city, civInfo).faith == 9f) city.cityConstructions.addBuilding(emptyBuilding.name) city.cityStats.update()