Make tileInfo.terrainFeatures immutable (#6180)

* Step 1 of saving terrain features as a transient - move all terrainFeature changes to new 'addTerrainFeature' and 'removeTerrainFeature' functions
This also included slight rewriting of functions for clarity, but NO functional changes.
Even though there's some logic that I would definitely change, this PR isn't the place for that.

* Fixed tests

core/src/com/unciv/logic/battle/Battle.kt

@@ -712,14 +712,14 @@ object Battle {
         }
         tile.roadStatus = RoadStatus.None
         if (tile.isLand && !tile.isImpassible() && !tile.terrainFeatures.contains("Fallout")) {
-            if (tile.terrainFeatures.any { attacker.getCivInfo().gameInfo.ruleSet.terrains[it]!!.hasUnique(UniqueType.ResistsNukes) }) {
+            val ruleset = tile.ruleset
-                if (Random().nextFloat() < 0.25f) {
+            val destructionChance = if (tile.hasUnique(UniqueType.ResistsNukes)) 0.25f
-                    tile.terrainFeatures.removeAll { attacker.getCivInfo().gameInfo.ruleSet.terrains[it]!!.hasUnique(UniqueType.DestroyableByNukes) }
+            else 0.5f
-                    tile.terrainFeatures.add("Fallout")
+            if (Random().nextFloat() < destructionChance) {
-                }
+                for (terrainFeature in tile.terrainFeatures)
-            } else if (Random().nextFloat() < 0.5f) {
+                    if (ruleset.terrains[terrainFeature]!!.hasUnique(UniqueType.DestroyableByNukes))
-                tile.terrainFeatures.removeAll { attacker.getCivInfo().gameInfo.ruleSet.terrains[it]!!.hasUnique(UniqueType.DestroyableByNukes) }
+                        tile.removeTerrainFeature(terrainFeature)
-                tile.terrainFeatures.add("Fallout")
+                tile.addTerrainFeature("Fallout")
             }
         }
     }

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

@@ -124,7 +124,7 @@ class CityInfo {
                 "Remove $it"
             )
         })
-            tile.terrainFeatures.remove(terrainFeature)
+            tile.removeTerrainFeature(terrainFeature)
 
         tile.improvement = null
         tile.improvementInProgress = null

core/src/com/unciv/logic/map/MapUnit.kt

@@ -651,7 +651,7 @@ class MapUnit {
                     if (removedFeatureObject != null && removedFeatureObject.hasUnique(UniqueType.ProductionBonusWhenRemoved)) {
                         tryProvideProductionToClosestCity(removedFeatureName)
                     }
-                    tile.terrainFeatures.remove(removedFeatureName)
+                    tile.removeTerrainFeature(removedFeatureName)
                 }
             }
             tile.improvementInProgress == RoadStatus.Road.name -> tile.roadStatus = RoadStatus.Road

core/src/com/unciv/logic/map/TileInfo.kt

@@ -65,7 +65,7 @@ open class TileInfo {
 
     var position: Vector2 = Vector2.Zero
     lateinit var baseTerrain: String
-    val terrainFeatures: ArrayList<String> = ArrayList()
+    var terrainFeatures: List<String> = listOf()
 
 
     var naturalWonder: String? = null
@@ -97,7 +97,7 @@ open class TileInfo {
         for (airUnit in airUnits) toReturn.airUnits.add(airUnit.clone())
         toReturn.position = position.cpy()
         toReturn.baseTerrain = baseTerrain
-        toReturn.terrainFeatures.addAll(terrainFeatures)
+        toReturn.terrainFeatures = terrainFeatures // immutable lists can be directly passed around
         toReturn.naturalWonder = naturalWonder
         toReturn.resource = resource
         toReturn.resourceAmount = resourceAmount
@@ -227,7 +227,7 @@ open class TileInfo {
         return civInfo.isAtWarWith(tileOwner)
     }
 
-    fun getTerrainFeatures(): List<Terrain> = terrainFeatures.mapNotNull { ruleset.terrains[it] }
+    fun getTerrainFeaturesObjects(): List<Terrain> = terrainFeatures.mapNotNull { ruleset.terrains[it] }
     fun getAllTerrains(): Sequence<Terrain> = sequence {
         yield(baseTerrainObject)
         if (naturalWonder != null) yield(getNaturalWonder())
@@ -259,7 +259,7 @@ open class TileInfo {
     fun getTileStats(city: CityInfo?, observingCiv: CivilizationInfo?): Stats {
         var stats = getBaseTerrain().cloneStats()
 
-        for (terrainFeatureBase in getTerrainFeatures()) {
+        for (terrainFeatureBase in getTerrainFeaturesObjects()) {
             when {
                 terrainFeatureBase.hasUnique(UniqueType.NullifyYields) ->
                     return terrainFeatureBase.cloneStats()
@@ -355,7 +355,7 @@ open class TileInfo {
     private fun getTileStartYield(isCenter: Boolean): Float {
         var stats = getBaseTerrain().cloneStats()
 
-        for (terrainFeatureBase in getTerrainFeatures()) {
+        for (terrainFeatureBase in getTerrainFeaturesObjects()) {
             if (terrainFeatureBase.overrideStats)
                 stats = terrainFeatureBase.cloneStats()
             else
@@ -848,6 +848,14 @@ open class TileInfo {
         }
     }
     
+    fun addTerrainFeature(terrainFeature:String) {
+        terrainFeatures = ArrayList(terrainFeatures).apply { add(terrainFeature) }
+    }
+    
+    fun removeTerrainFeature(terrainFeature: String) {
+        terrainFeatures = ArrayList(terrainFeatures).apply { remove(terrainFeature) }
+    }
+
 
     /** If the unit isn't in the ruleset we can't even know what type of unit this is! So check each place
      * This works with no transients so can be called from gameInfo.setTransients with no fear
@@ -875,7 +883,7 @@ open class TileInfo {
         if (naturalWonder != null) {
             val naturalWonder = ruleset.terrains[naturalWonder]!!
             baseTerrain = naturalWonder.turnsInto!!
-            terrainFeatures.clear()
+            terrainFeatures = listOf()
             resource = null
             improvement = null
         }
@@ -883,12 +891,12 @@ open class TileInfo {
         for (terrainFeature in terrainFeatures.toList()) {
             val terrainFeatureObject = ruleset.terrains[terrainFeature]
             if (terrainFeatureObject == null) {
-                terrainFeatures.remove(terrainFeature)
+                removeTerrainFeature(terrainFeature)
                 continue
             }
 
             if (terrainFeatureObject.occursOn.isNotEmpty() && !terrainFeatureObject.occursOn.contains(baseTerrain))
-                terrainFeatures.remove(terrainFeature)
+                removeTerrainFeature(terrainFeature)
         }
 
 
@@ -928,9 +936,10 @@ open class TileInfo {
             baseTerrain = mostCommonBaseTerrain?.key ?: Constants.grassland
             //We have to add hill as first terrain feature
             val copy = terrainFeatures.toTypedArray()
-            terrainFeatures.clear()
+            val newTerrainFeatures = ArrayList<String>()
-            terrainFeatures.add(Constants.hill)
+            newTerrainFeatures.add(Constants.hill)
-            terrainFeatures.addAll(copy)
+            newTerrainFeatures.addAll(copy)
+            terrainFeatures = newTerrainFeatures
         }
     }
 

core/src/com/unciv/logic/map/TileMap.kt

@@ -447,7 +447,7 @@ class TileMap {
     fun removeMissingTerrainModReferences(ruleSet: Ruleset) {
         for (tile in this.values) {
             for (terrainFeature in tile.terrainFeatures.filter { !ruleSet.terrains.containsKey(it) })
-                tile.terrainFeatures.remove(terrainFeature)
+                tile.removeTerrainFeature(terrainFeature)
             if (tile.resource != null && !ruleSet.tileResources.containsKey(tile.resource!!))
                 tile.resource = null
             if (tile.improvement != null && !ruleSet.tileImprovements.containsKey(tile.improvement!!))

core/src/com/unciv/logic/map/mapgenerator/MapGenerator.kt

@@ -133,7 +133,7 @@ class MapGenerator(val ruleset: Ruleset) {
             if (!terrain.occursOn.contains(tile.getLastTerrain().name)) continue
 
             if (terrain.type == TerrainType.TerrainFeature)
-                tile.terrainFeatures.add(terrain.name)
+                tile.addTerrainFeature(terrain.name)
             else tile.baseTerrain = terrain.name
             tile.setTerrainTransients()
         }
@@ -286,7 +286,7 @@ class MapGenerator(val ruleset: Ruleset) {
 
             when {
                 elevation <= 0.5 -> tile.baseTerrain = flat
-                elevation <= 0.7 && hill != null -> tile.terrainFeatures.add(hill)
+                elevation <= 0.7 && hill != null -> tile.addTerrainFeature(hill)
                 elevation <= 0.7 && hill == null -> tile.baseTerrain = flat // otherwise would be hills become mountains
                 elevation <= 1.0 && mountain != null -> tile.baseTerrain = mountain
             }
@@ -313,29 +313,33 @@ class MapGenerator(val ruleset: Ruleset) {
 
                 if (adjacentMountains == 0 && tile.baseTerrain == mountain) {
                     if (randomness.RNG.nextInt(until = 4) == 0)
-                        tile.terrainFeatures.add(Constants.lowering)
+                        tile.addTerrainFeature(Constants.lowering)
                 } else if (adjacentMountains == 1) {
                     if (randomness.RNG.nextInt(until = 10) == 0)
-                        tile.terrainFeatures.add(Constants.rising)
+                        tile.addTerrainFeature(Constants.rising)
                 } else if (adjacentImpassible == 3) {
                     if (randomness.RNG.nextInt(until = 2) == 0)
-                        tile.terrainFeatures.add(Constants.lowering)
+                        tile.addTerrainFeature(Constants.lowering)
                 } else if (adjacentImpassible > 3) {
-                    tile.terrainFeatures.add(Constants.lowering)
+                    tile.addTerrainFeature(Constants.lowering)
                 }
             }
 
             for (tile in tileMap.values.filter { !it.isWater }) {
-                if (tile.terrainFeatures.remove(Constants.rising) && totalMountains < targetMountains) {
+                if (tile.terrainFeatures.contains(Constants.rising)) {
+                    tile.removeTerrainFeature(Constants.rising)
+                    if (totalMountains >= targetMountains) continue
                     if (hill != null)
-                        tile.terrainFeatures.remove(hill)
+                        tile.removeTerrainFeature(hill)
                     tile.baseTerrain = mountain
                     totalMountains++
                 }
-                if (tile.terrainFeatures.remove(Constants.lowering) && totalMountains > targetMountains * 0.5f) {
+                if (tile.terrainFeatures.contains(Constants.lowering)) {
+                    tile.removeTerrainFeature(Constants.lowering)
+                    if (totalMountains <= targetMountains * 0.5f) continue
                     if (tile.baseTerrain == mountain) {
                         if (hill != null && !tile.terrainFeatures.contains(hill))
-                            tile.terrainFeatures.add(hill)
+                            tile.addTerrainFeature(hill)
                         totalMountains--
                     }
                     tile.baseTerrain = flat
@@ -357,25 +361,31 @@ class MapGenerator(val ruleset: Ruleset) {
                     tile.neighbors.count { it.terrainFeatures.contains(hill) }
 
                 if (adjacentHills <= 1 && adjacentMountains == 0 && randomness.RNG.nextInt(until = 2) == 0) {
-                    tile.terrainFeatures.add(Constants.lowering)
+                    tile.addTerrainFeature(Constants.lowering)
                 } else if (adjacentHills > 3 && adjacentMountains == 0 && randomness.RNG.nextInt(until = 2) == 0) {
-                    tile.terrainFeatures.add(Constants.lowering)
+                    tile.addTerrainFeature(Constants.lowering)
                 } else if (adjacentHills + adjacentMountains in 2..3 && randomness.RNG.nextInt(until = 2) == 0) {
-                    tile.terrainFeatures.add(Constants.rising)
+                    tile.addTerrainFeature(Constants.rising)
                 }
 
             }
 
             for (tile in tileMap.values.asSequence().filter { !it.isWater && (mountain == null || it.baseTerrain != mountain) }) {
-                if (tile.terrainFeatures.remove(Constants.rising) && (totalHills <= targetHills || i == 1) ) {
+                if (tile.terrainFeatures.contains(Constants.rising)) {
+                    tile.removeTerrainFeature(Constants.rising)
+                    if (totalHills > targetHills && i != 1) continue
                     if (!tile.terrainFeatures.contains(hill)) {
-                        tile.terrainFeatures.add(hill)
+                        tile.addTerrainFeature(hill)
                         totalHills++
                     }
                 }
-                if (tile.terrainFeatures.remove(Constants.lowering) && (totalHills >= targetHills * 0.9f || i == 1)) {
+                if (tile.terrainFeatures.contains(Constants.lowering)) {
-                    if (tile.terrainFeatures.remove(hill))
+                    tile.removeTerrainFeature(Constants.lowering)
+                    if (totalHills >= targetHills * 0.9f || i == 1) {
+                        if (tile.terrainFeatures.contains(hill))
+                            tile.removeTerrainFeature(hill)
                         totalHills--
+                    }
                 }
             }
         }
@@ -464,8 +474,10 @@ class MapGenerator(val ruleset: Ruleset) {
                 && it.getLastTerrain().name in candidateTerrains }) {
             val vegetation = (randomness.getPerlinNoise(tile, vegetationSeed, scale = 3.0, nOctaves = 1) + 1.0) / 2.0
 
-            if (vegetation <= tileMap.mapParameters.vegetationRichness)
+            if (vegetation <= tileMap.mapParameters.vegetationRichness) {
-                tile.terrainFeatures.add(Constants.vegetation.filter { ruleset.terrains[it]!!.occursOn.contains(tile.getLastTerrain().name) }.random(randomness.RNG))
+                val randomVegetation = Constants.vegetation.filter { ruleset.terrains[it]!!.occursOn.contains(tile.getLastTerrain().name) }.random(randomness.RNG)
+                tile.addTerrainFeature(randomVegetation)
+            }
         }
     }
     /**
@@ -480,7 +492,7 @@ class MapGenerator(val ruleset: Ruleset) {
                 val possibleFeatures = rareFeatures.filter { it.occursOn.contains(tile.baseTerrain)
                         && (!tile.isHill() || it.occursOn.contains(Constants.hill)) }
                 if (possibleFeatures.any())
-                    tile.terrainFeatures.add(possibleFeatures.random(randomness.RNG).name)
+                    tile.addTerrainFeature(possibleFeatures.random(randomness.RNG).name)
             }
         }
     }
@@ -501,7 +513,7 @@ class MapGenerator(val ruleset: Ruleset) {
             var temperature = ((latitudeTemperature + randomTemperature) / 2.0)
             temperature = abs(temperature).pow(1.0 - tileMap.mapParameters.temperatureExtremeness) * temperature.sign
             if (temperature < -0.8)
-                tile.terrainFeatures.add(Constants.ice)
+                tile.addTerrainFeature(Constants.ice)
         }
     }
 }

core/src/com/unciv/logic/map/mapgenerator/MapRegions.kt

@@ -476,7 +476,7 @@ class MapRegions (val ruleset: Ruleset){
         val panicPosition = region.rect.getPosition(Vector2())
         val panicTerrain = ruleset.terrains.values.first { it.type == TerrainType.Land }.name
         region.tileMap[panicPosition].baseTerrain = panicTerrain
-        region.tileMap[panicPosition].terrainFeatures.clear()
+        region.tileMap[panicPosition].terrainFeatures = listOf()
         setRegionStart(region, panicPosition)
     }
 
@@ -487,9 +487,9 @@ class MapRegions (val ruleset: Ruleset){
     private fun normalizeStart(startTile: TileInfo, tileMap: TileMap, minorCiv: Boolean) {
         // Remove ice-like features adjacent to start
         for (tile in startTile.neighbors) {
-            val lastTerrain = tile.getTerrainFeatures().lastOrNull { it.impassable }
+            val lastTerrain = tile.getTerrainFeaturesObjects().lastOrNull { it.impassable }
             if (lastTerrain != null) {
-                tile.terrainFeatures.remove(lastTerrain.name)
+                tile.removeTerrainFeature(lastTerrain.name)
             }
         }
 
@@ -509,7 +509,7 @@ class MapRegions (val ruleset: Ruleset){
             val hillEquivalent = ruleset.terrains.values
                     .firstOrNull { it.type == TerrainType.TerrainFeature && it.production >= 2 && !it.hasUnique(UniqueType.RareFeature) }?.name
             if (hillSpot != null && hillEquivalent != null) {
-                hillSpot.terrainFeatures.add(hillEquivalent)
+                hillSpot.addTerrainFeature(hillEquivalent)
             }
         }
 
@@ -608,7 +608,7 @@ class MapRegions (val ruleset: Ruleset){
 
         // Start with list of candidate plots sorted in ring order 1,2,3
         val candidatePlots = startTile.getTilesInDistanceRange(1..rangeForBonuses)
-                .filter { it.resource == null && oasisEquivalent !in it.getTerrainFeatures() }
+                .filter { it.resource == null && oasisEquivalent !in it.getTerrainFeaturesObjects() }
                 .shuffled().sortedBy { it.aerialDistanceTo(startTile) }.toMutableList()
 
         // Place food bonuses (and oases) as able
@@ -627,7 +627,7 @@ class MapRegions (val ruleset: Ruleset){
 
             if (validBonuses.isNotEmpty() || goodPlotForOasis) {
                 if (goodPlotForOasis) {
-                    plot.terrainFeatures.add(oasisEquivalent!!.name)
+                    plot.addTerrainFeature(oasisEquivalent!!.name)
                     canPlaceOasis = false
                 } else {
                     plot.setTileResource(validBonuses.random())
@@ -1345,10 +1345,7 @@ class MapRegions (val ruleset: Ruleset){
         for (terrain in ruleset.terrains.values.filter { it.type != TerrainType.Water }) {
             // Figure out if we generated a list for this terrain
             val list = ruleLists.filterKeys { it.text == getTerrainRule(terrain).text }.values.firstOrNull()
-            if (list == null) {
+                ?: continue // If not the terrain can be safely skipped
-                // If not the terrain can be safely skipped
-                continue
-            }
             totalPlaced += placeMajorDeposits(list, terrain, fallbackStrategic, 2, 2)
         }
 
@@ -1399,10 +1396,7 @@ class MapRegions (val ruleset: Ruleset){
         for (terrain in ruleset.terrains.values.filter { it.type == TerrainType.Water }) {
             // Figure out if we generated a list for this terrain
             val list = ruleLists.filterKeys { it.text == getTerrainRule(terrain).text }.values.firstOrNull()
-            if (list == null) {
+                ?: continue // If not the terrain can be safely skipped
-                // If not the terrain can be safely skipped
-                continue
-            }
             totalPlaced += placeMajorDeposits(list, terrain, fallbackStrategic, 4, 3)
         }
 
@@ -1664,8 +1658,8 @@ class MapRegions (val ruleset: Ruleset){
 
             // Check first available out of unbuildable features, then other features, then base terrain
             val terrainToCheck = if (tile.terrainFeatures.isEmpty()) tile.getBaseTerrain()
-            else tile.getTerrainFeatures().firstOrNull { it.unbuildable }
+            else tile.getTerrainFeaturesObjects().firstOrNull { it.unbuildable }
-                    ?: tile.getTerrainFeatures().first()
+                    ?: tile.getTerrainFeaturesObjects().first()
 
             // Add all applicable qualities
             for (unique in terrainToCheck.getMatchingUniques(UniqueType.HasQuality, StateForConditionals(region = region))) {
@@ -1771,7 +1765,7 @@ class Region (val tileMap: TileMap, val rect: Rectangle, val continentID: Int =
         terrainCounts.clear()
         for (tile in tiles) {
             val terrainsToCount = if (tile.getAllTerrains().any { it.hasUnique(UniqueType.IgnoreBaseTerrainForRegion) })
-                tile.getTerrainFeatures().map { it.name }.asSequence()
+                tile.getTerrainFeaturesObjects().map { it.name }.asSequence()
             else
                 tile.getAllTerrains().map { it.name }
             for (terrain in terrainsToCount) {

core/src/com/unciv/logic/map/mapgenerator/NaturalWonderGenerator.kt

@@ -167,7 +167,7 @@ class NaturalWonderGenerator(val ruleset: Ruleset, val randomness: MapGeneration
     }
 
     private fun clearTile(tile: TileInfo){
-        tile.terrainFeatures.clear()
+        tile.terrainFeatures = listOf()
         tile.resource = null
         tile.improvement = null
         tile.setTerrainTransients()

core/src/com/unciv/ui/civilopedia/CivilopediaCategories.kt

@@ -31,7 +31,7 @@ object CivilopediaImageGetters {
                 tileInfo.baseTerrain = terrain.turnsInto ?: Constants.grassland
             }
             TerrainType.TerrainFeature -> {
-                tileInfo.terrainFeatures.add(terrain.name)
+                tileInfo.addTerrainFeature(terrain.name)
                 tileInfo.baseTerrain =
                     if (terrain.occursOn.isEmpty() || terrain.occursOn.contains(Constants.grassland))
                         Constants.grassland

core/src/com/unciv/ui/mapeditor/MapEditorOptionsTable.kt

@@ -83,7 +83,7 @@ class MapEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(BaseScr
         terrainFeaturesTable.add(getHex(ImageGetter.getRedCross(50f, 0.6f)).apply {
             onClick {
                 tileAction = {
-                    it.terrainFeatures.clear()
+                    it.terrainFeatures = listOf()
                     it.naturalWonder = null
                     it.hasBottomRiver = false
                     it.hasBottomLeftRiver = false
@@ -305,7 +305,7 @@ class MapEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(BaseScr
                     tileInfo.baseTerrain =
                         if (terrainObject.occursOn.isNotEmpty()) terrainObject.occursOn.first()
                         else ruleset.terrains.values.first { it.type == TerrainType.Land }.name
-                    tileInfo.terrainFeatures.add(terrain)
+                    tileInfo.addTerrainFeature(terrain)
                 }
 
                 tileInfo.resource = resource.name
@@ -326,7 +326,7 @@ class MapEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(BaseScr
                     terrain.occursOn.isNotEmpty() -> terrain.occursOn.first()
                     else -> "Grassland"
                 }
-                tileInfo.terrainFeatures.add(terrain.name)
+                tileInfo.addTerrainFeature(terrain.name)
             } else tileInfo.baseTerrain = terrain.name
             val group = makeTileGroup(tileInfo)
 
@@ -336,7 +336,7 @@ class MapEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(BaseScr
                     when (terrain.type) {
                         TerrainType.TerrainFeature -> {
                             if (terrain.occursOn.contains(it.getLastTerrain().name))
-                                it.terrainFeatures.add(terrain.name)
+                                it.addTerrainFeature(terrain.name)
                         }
                         TerrainType.NaturalWonder -> it.naturalWonder = terrain.name
                         else -> it.baseTerrain = terrain.name

core/src/com/unciv/ui/worldscreen/unit/UnitActions.kt

@@ -626,7 +626,7 @@ object UnitActions {
                 action = {
                     val unitTile = unit.getTile()
                     for (terrainFeature in tile.terrainFeatures.filter { unitTile.ruleset.tileImprovements.containsKey("Remove $it") })
-                        unitTile.terrainFeatures.remove(terrainFeature)// remove forest/jungle/marsh
+                        unitTile.removeTerrainFeature(terrainFeature)// remove forest/jungle/marsh
                     unitTile.improvement = improvementName
                     unitTile.improvementInProgress = null
                     unitTile.turnsToImprovement = 0

tests/src/com/unciv/logic/map/TileImprovementConstructionTests.kt

@@ -134,7 +134,7 @@ class TileImprovementConstructionTests {
     @Test
     fun terraceFarmCanNOTBeBuiltOnBonus() {
         val tile = getTile()
-        tile.terrainFeatures.add("Hill")
+        tile.addTerrainFeature("Hill")
         tile.resource = "Sheep"
         tile.setTransients()
         civInfo.civName = "Inca"

tests/src/com/unciv/logic/map/TileMapTests.kt

@@ -87,8 +87,7 @@ class TileMapTests {
         tile1.baseTerrain = Constants.hill
         tile1.setTerrainTransients()
         tile2.baseTerrain = Constants.grassland
-        tile2.terrainFeatures.clear()
+        tile2.terrainFeatures = listOf(Constants.forest)
-        tile2.terrainFeatures.add(Constants.forest)
         tile2.setTerrainTransients()
         tile3.baseTerrain = Constants.coast
         tile3.setTerrainTransients()
@@ -115,8 +114,7 @@ class TileMapTests {
     @Test
     fun canSeeMountainFromForestOverHills() {
         tile1.baseTerrain = Constants.grassland
-        tile1.terrainFeatures.clear()
+        tile1.terrainFeatures = listOf(Constants.forest)
-        tile1.terrainFeatures.add(Constants.forest)
         tile1.setTerrainTransients()
         tile2.baseTerrain = Constants.hill
         tile2.setTerrainTransients()
@@ -133,8 +131,7 @@ class TileMapTests {
         tile1.baseTerrain = Constants.hill
         tile1.setTerrainTransients()
         tile2.baseTerrain = Constants.grassland
-        tile2.terrainFeatures.clear()
+        tile2.terrainFeatures = listOf(Constants.forest)
-        tile2.terrainFeatures.add(Constants.forest)
         tile2.setTerrainTransients()
         tile3.baseTerrain = Constants.hill
         tile3.setTerrainTransients()
@@ -175,12 +172,10 @@ class TileMapTests {
     @Test
     fun canNOTSeeOutThroughForest() {
         tile1.baseTerrain = Constants.grassland
-        tile1.terrainFeatures.clear()
+        tile1.terrainFeatures = listOf(Constants.forest)
-        tile1.terrainFeatures.add(Constants.forest)
         tile1.setTerrainTransients()
         tile2.baseTerrain = Constants.grassland
-        tile2.terrainFeatures.clear()
+        tile2.terrainFeatures = listOf(Constants.forest)
-        tile2.terrainFeatures.add(Constants.forest)
         tile2.setTerrainTransients()
         tile3.baseTerrain = Constants.grassland
         tile3.setTerrainTransients()
@@ -195,8 +190,7 @@ class TileMapTests {
         tile1.baseTerrain = Constants.coast
         tile1.setTerrainTransients()
         tile2.baseTerrain = Constants.grassland
-        tile2.terrainFeatures.clear()
+        tile2.terrainFeatures = listOf(Constants.jungle)
-        tile2.terrainFeatures.add(Constants.jungle)
         tile2.setTerrainTransients()
         tile3.baseTerrain = Constants.coast
         tile3.setTerrainTransients()

tests/src/com/unciv/logic/map/UnitMovementAlgorithmsTests.kt

@@ -54,7 +54,7 @@ class UnitMovementAlgorithmsTests {
     fun canPassThroughPassableTerrains() {
         for (terrain in ruleSet.terrains.values) {
             tile.baseTerrain = terrain.name
-            tile.terrainFeatures.clear()
+            tile.terrainFeatures = listOf()
             tile.setTransients()
 
             unit.baseUnit = BaseUnit().apply { unitType = "Sword"; ruleset = ruleSet }
@@ -112,8 +112,7 @@ class UnitMovementAlgorithmsTests {
     @Test
     fun canNOTEnterIce() {
         tile.baseTerrain = Constants.ocean
-        tile.terrainFeatures.clear()
+        tile.terrainFeatures = listOf(Constants.ice)
-        tile.terrainFeatures.add(Constants.ice)
         tile.setTransients()
 
         for (type in ruleSet.unitTypes) {

tests/src/com/unciv/uniques/GlobalUniquesTests.kt

@@ -54,7 +54,7 @@ class GlobalUniquesTests {
         tile.ruleset = ruleSet
         tile.baseTerrain = terrain
         for (feature in features) {
-            tile.terrainFeatures.add(feature)
+            tile.addTerrainFeature(feature)
         }
         tile.tileMap = tileMap
         tile.position = position