mirrors/Unciv
1
0
Fork 0
mirror of https://github.com/yairm210/Unciv.git synced 2025-03-13 11:30:31 +07:00
Code Issues Packages Projects Releases Wiki Activity

Make tileInfo.terrainFeatures immutable (#6180)

Browse Source 
* 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
This commit is contained in:
Yair Morgenstern 2022-02-19 19:28:05 +02:00 committed by GitHub
parent 6e92ea4d29
commit 22466a9d45
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 92 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
core/src/com/unciv/logic/battle/Battle.kt
View File

@ -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) }) {
if (Random().nextFloat() < 0.25f) {
tile.terrainFeatures.removeAll { attacker.getCivInfo().gameInfo.ruleSet.terrains[it]!!.hasUnique(UniqueType.DestroyableByNukes) }
tile.terrainFeatures.add("Fallout")
}
} else if (Random().nextFloat() < 0.5f) {
tile.terrainFeatures.removeAll { attacker.getCivInfo().gameInfo.ruleSet.terrains[it]!!.hasUnique(UniqueType.DestroyableByNukes) }
tile.terrainFeatures.add("Fallout")
val ruleset = tile.ruleset
val destructionChance = if (tile.hasUnique(UniqueType.ResistsNukes)) 0.25f
else 0.5f
if (Random().nextFloat() < destructionChance) {
for (terrainFeature in tile.terrainFeatures)
if (ruleset.terrains[terrainFeature]!!.hasUnique(UniqueType.DestroyableByNukes))
tile.removeTerrainFeature(terrainFeature)
tile.addTerrainFeature("Fallout")
}
}
}

2
core/src/com/unciv/logic/city/CityInfo.kt
View File

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

2
core/src/com/unciv/logic/map/MapUnit.kt
View File

@ -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

31
core/src/com/unciv/logic/map/TileInfo.kt
View File

@ -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()
terrainFeatures.add(Constants.hill)
terrainFeatures.addAll(copy)
val newTerrainFeatures = ArrayList<String>()
newTerrainFeatures.add(Constants.hill)
newTerrainFeatures.addAll(copy)
terrainFeatures = newTerrainFeatures
}
}

2
core/src/com/unciv/logic/map/TileMap.kt
View File

@ -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!!))

54
core/src/com/unciv/logic/map/mapgenerator/MapGenerator.kt
View File

@ -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.remove(hill))
if (tile.terrainFeatures.contains(Constants.lowering)) {
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)
tile.terrainFeatures.add(Constants.vegetation.filter { ruleset.terrains[it]!!.occursOn.contains(tile.getLastTerrain().name) }.random(randomness.RNG))
if (vegetation <= tileMap.mapParameters.vegetationRichness) {
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)
}
}
}

28
core/src/com/unciv/logic/map/mapgenerator/MapRegions.kt
View File

@ -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) {
// If not the terrain can be safely skipped
continue
}
?: continue // If not the terrain can be safely skipped
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) {
// If not the terrain can be safely skipped
continue
}
?: continue // If not the terrain can be safely skipped
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 }
?: tile.getTerrainFeatures().first()
else tile.getTerrainFeaturesObjects().firstOrNull { it.unbuildable }
?: 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) {

2
core/src/com/unciv/logic/map/mapgenerator/NaturalWonderGenerator.kt
View File

@ -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()

2
core/src/com/unciv/ui/civilopedia/CivilopediaCategories.kt
View File

@ -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

8
core/src/com/unciv/ui/mapeditor/MapEditorOptionsTable.kt
View File

@ -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

2
core/src/com/unciv/ui/worldscreen/unit/UnitActions.kt
View File

@ -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

2
tests/src/com/unciv/logic/map/TileImprovementConstructionTests.kt
View File

@ -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"

18
tests/src/com/unciv/logic/map/TileMapTests.kt
View File

@ -87,8 +87,7 @@ class TileMapTests {
tile1.baseTerrain = Constants.hill
tile1.setTerrainTransients()
tile2.baseTerrain = Constants.grassland
tile2.terrainFeatures.clear()
tile2.terrainFeatures.add(Constants.forest)
tile2.terrainFeatures = listOf(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.add(Constants.forest)
tile1.terrainFeatures = listOf(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.add(Constants.forest)
tile2.terrainFeatures = listOf(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.add(Constants.forest)
tile1.terrainFeatures = listOf(Constants.forest)
tile1.setTerrainTransients()
tile2.baseTerrain = Constants.grassland
tile2.terrainFeatures.clear()
tile2.terrainFeatures.add(Constants.forest)
tile2.terrainFeatures = listOf(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.add(Constants.jungle)
tile2.terrainFeatures = listOf(Constants.jungle)
tile2.setTerrainTransients()
tile3.baseTerrain = Constants.coast
tile3.setTerrainTransients()

5
tests/src/com/unciv/logic/map/UnitMovementAlgorithmsTests.kt
View File

@ -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.add(Constants.ice)
tile.terrainFeatures = listOf(Constants.ice)
tile.setTransients()
for (type in ruleSet.unitTypes) {

2
tests/src/com/unciv/uniques/GlobalUniquesTests.kt
View File

@ -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