mirror of
https://github.com/yairm210/Unciv.git
synced 2025-07-06 00:09:23 +07:00
chore: Modernized TileImprovementConstructionTests
This commit is contained in:
Yair Morgenstern
@ -126,7 +126,8 @@ class TileInfoImprovementFunctions(val tile: Tile) {
|
||||
// Can't build if the improvement specifically prevents building on some present feature
|
||||
improvement.getMatchingUniques(UniqueType.CannotBuildOnTile, stateForConditionals).any {
|
||||
unique -> tile.matchesTerrainFilter(unique.params[0])
|
||||
} -> false
|
||||
} ->
|
||||
false
|
||||
|
||||
// Can't build if an improvement is only allowed to be built on specific tiles and this is not one of them
|
||||
// If multiple uniques of this type exists, we want all to match (e.g. Hill _and_ Forest would be meaningful)
|
||||
|
||||
@ -1,17 +1,12 @@
|
||||
// Taken from https://github.com/TomGrill/gdx-testing
|
||||
package com.unciv.logic.map
|
||||
|
||||
import com.badlogic.gdx.math.Vector2
|
||||
import com.unciv.logic.city.City
|
||||
import com.unciv.logic.civilization.Civilization
|
||||
import com.unciv.logic.map.tile.Tile
|
||||
import com.unciv.models.ruleset.Ruleset
|
||||
import com.unciv.models.ruleset.RulesetCache
|
||||
import com.unciv.models.ruleset.nation.Nation
|
||||
import com.unciv.models.ruleset.tile.TerrainType
|
||||
import com.unciv.models.ruleset.unique.StateForConditionals
|
||||
import com.unciv.models.ruleset.unique.UniqueType
|
||||
import com.unciv.testing.GdxTestRunner
|
||||
import com.unciv.uniques.TestGame
|
||||
import org.junit.Assert
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
@ -20,50 +15,46 @@ import org.junit.runner.RunWith
|
||||
@RunWith(GdxTestRunner::class)
|
||||
class TileImprovementConstructionTests {
|
||||
|
||||
private var civInfo = Civilization()
|
||||
private var city = City()
|
||||
private var ruleSet = Ruleset()
|
||||
private val tileMap = TileMap()
|
||||
private lateinit var civInfo: Civilization
|
||||
private lateinit var tileMap: TileMap
|
||||
|
||||
val testGame = TestGame()
|
||||
|
||||
private fun getTile() = Tile().apply {
|
||||
baseTerrain = "Plains"
|
||||
ruleset = ruleSet
|
||||
position = Vector2(1f, 1f) // so that it's not on the same position as the city
|
||||
setOwningCity(city)
|
||||
this@apply.tileMap = this@TileImprovementConstructionTests.tileMap
|
||||
}
|
||||
|
||||
@Before
|
||||
fun initTheWorld() {
|
||||
RulesetCache.loadRulesets(noMods = true)
|
||||
ruleSet = RulesetCache.getVanillaRuleset()
|
||||
civInfo.tech.researchedTechnologies.addAll(ruleSet.technologies.values)
|
||||
civInfo.tech.techsResearched.addAll(ruleSet.technologies.keys)
|
||||
civInfo.nation = Nation()
|
||||
city.civ = civInfo
|
||||
testGame.makeHexagonalMap(3)
|
||||
tileMap = testGame.tileMap
|
||||
civInfo = testGame.addCiv()
|
||||
civInfo.tech.researchedTechnologies.addAll(testGame.ruleset.technologies.values)
|
||||
civInfo.tech.techsResearched.addAll(testGame.ruleset.technologies.keys)
|
||||
testGame.addCity(civInfo, tileMap[0,0])
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
fun allTerrainSpecificImprovementsCanBeBuilt() {
|
||||
|
||||
for (improvement in ruleSet.tileImprovements.values) {
|
||||
for (improvement in testGame.ruleset.tileImprovements.values) {
|
||||
var terrain = improvement.terrainsCanBeBuiltOn.firstOrNull() ?: continue
|
||||
if (terrain == "Land") terrain = ruleSet.terrains.values.first { it.type == TerrainType.Land }.name
|
||||
if (terrain == "Water") terrain = ruleSet.terrains.values.first { it.type == TerrainType.Water }.name
|
||||
if (terrain == "Land") terrain = testGame.ruleset.terrains.values.first { it.type == TerrainType.Land }.name
|
||||
if (terrain == "Water") terrain = testGame.ruleset.terrains.values.first { it.type == TerrainType.Water }.name
|
||||
// If this improvement requires additional conditions to be true,
|
||||
// its too complex to handle all of them, so just skip it and hope its fine
|
||||
// I would like some comments on whether this approach is fine or if it's better if I handle every single unique here as well
|
||||
if (improvement.hasUnique(UniqueType.CanOnlyBeBuiltOnTile, StateForConditionals.IgnoreConditionals)) continue
|
||||
if (improvement.hasUnique(UniqueType.Unbuildable, StateForConditionals.IgnoreConditionals)) continue
|
||||
|
||||
val tile = getTile()
|
||||
val tile = tileMap[1,1]
|
||||
tile.baseTerrain = terrain
|
||||
tile.resource = null
|
||||
if (improvement.hasUnique(UniqueType.CanOnlyImproveResource, StateForConditionals.IgnoreConditionals)) {
|
||||
tile.resource = ruleSet.tileResources.values.firstOrNull { it.isImprovedBy(improvement.name) }?.name ?: continue
|
||||
tile.resource = testGame.ruleset.tileResources.values.firstOrNull { it.isImprovedBy(improvement.name) }?.name ?: continue
|
||||
}
|
||||
tile.setTransients()
|
||||
if (improvement.uniqueTo != null) civInfo.civName = improvement.uniqueTo!!
|
||||
|
||||
if (improvement.uniqueTo != null){
|
||||
civInfo.civName = improvement.uniqueTo!!
|
||||
}
|
||||
|
||||
val canBeBuilt = tile.improvementFunctions.canBuildImprovement(improvement, civInfo)
|
||||
Assert.assertTrue(improvement.name, canBeBuilt)
|
||||
@ -72,9 +63,10 @@ class TileImprovementConstructionTests {
|
||||
|
||||
@Test
|
||||
fun allResourceImprovementsCanBeBuilt() {
|
||||
for (improvement in ruleSet.tileImprovements.values) {
|
||||
val tile = getTile()
|
||||
tile.resource = ruleSet.tileResources.values
|
||||
|
||||
for (improvement in testGame.ruleset.tileImprovements.values) {
|
||||
val tile = tileMap[1,1]
|
||||
tile.resource = testGame.ruleset.tileResources.values
|
||||
.firstOrNull { it.isImprovedBy(improvement.name) }?.name
|
||||
if (tile.resource == null) continue
|
||||
// If this improvement requires additional conditions to be true,
|
||||
@ -89,31 +81,25 @@ class TileImprovementConstructionTests {
|
||||
|
||||
@Test
|
||||
fun coastalImprovementsCanBeBuilt() {
|
||||
val map = TileMap()
|
||||
val tile = getTile()
|
||||
tile.tileMap = map
|
||||
tile.setTransients()
|
||||
val coastTile = tileMap[1,2]
|
||||
coastTile.baseTerrain = "Coast"
|
||||
coastTile.setTransients()
|
||||
|
||||
val otherTile = tile.clone()
|
||||
otherTile.baseTerrain = "Coast"
|
||||
otherTile.position.y = 1f
|
||||
val coastalTile = tileMap[1,1]
|
||||
|
||||
map.tileMatrix.add(arrayListOf(tile, otherTile))
|
||||
|
||||
for (improvement in ruleSet.tileImprovements.values) {
|
||||
for (improvement in testGame.ruleset.tileImprovements.values) {
|
||||
if (!improvement.uniques.contains("Can only be built on [Coastal] tiles")) continue
|
||||
civInfo.civName = improvement.uniqueTo ?: "OtherCiv"
|
||||
val canBeBuilt = tile.improvementFunctions.canBuildImprovement(improvement, civInfo)
|
||||
val canBeBuilt = coastalTile.improvementFunctions.canBuildImprovement(improvement, civInfo)
|
||||
Assert.assertTrue(improvement.name, canBeBuilt)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun coastalImprovementsCanNOTBeBuiltInland() {
|
||||
val tile = getTile()
|
||||
tile.setTransients()
|
||||
val tile = tileMap[1,1]
|
||||
|
||||
for (improvement in ruleSet.tileImprovements.values) {
|
||||
for (improvement in testGame.ruleset.tileImprovements.values) {
|
||||
if (!improvement.uniques.contains("Can only be built on [Coastal] tiles")) continue
|
||||
civInfo.civName = improvement.uniqueTo ?: "OtherCiv"
|
||||
val canBeBuilt = tile.improvementFunctions.canBuildImprovement(improvement, civInfo)
|
||||
@ -123,11 +109,10 @@ class TileImprovementConstructionTests {
|
||||
|
||||
@Test
|
||||
fun uniqueToOtherImprovementsCanNOTBeBuilt() {
|
||||
for (improvement in ruleSet.tileImprovements.values) {
|
||||
for (improvement in testGame.ruleset.tileImprovements.values) {
|
||||
if (improvement.uniqueTo == null) continue
|
||||
civInfo.civName = "OtherCiv"
|
||||
val tile = getTile()
|
||||
tile.setTransients()
|
||||
val tile = tileMap[1,1]
|
||||
val canBeBuilt = tile.improvementFunctions.canBuildImprovement(improvement, civInfo)
|
||||
Assert.assertFalse(improvement.name, canBeBuilt)
|
||||
}
|
||||
@ -135,16 +120,14 @@ class TileImprovementConstructionTests {
|
||||
|
||||
@Test
|
||||
fun improvementsCanNOTBeBuiltOnWrongResource() {
|
||||
civInfo.civName = "OtherCiv"
|
||||
|
||||
for (resource in ruleSet.tileResources.values) {
|
||||
for (resource in testGame.ruleset.tileResources.values) {
|
||||
if (resource.getImprovements().isEmpty()) continue
|
||||
val improvement = ruleSet.tileImprovements[resource.getImprovements().first()]!!
|
||||
val improvement = testGame.ruleset.tileImprovements[resource.getImprovements().first()]!!
|
||||
if (!improvement.hasUnique(UniqueType.CanOnlyImproveResource)) continue
|
||||
val wrongResource = ruleSet.tileResources.values.firstOrNull {
|
||||
val wrongResource = testGame.ruleset.tileResources.values.firstOrNull {
|
||||
it != resource && !it.isImprovedBy(improvement.name)
|
||||
} ?: continue
|
||||
val tile = getTile()
|
||||
val tile = tileMap[1,1]
|
||||
tile.baseTerrain = "Plains"
|
||||
tile.resource = wrongResource.name
|
||||
tile.setTransients()
|
||||
@ -155,13 +138,13 @@ class TileImprovementConstructionTests {
|
||||
|
||||
@Test
|
||||
fun terraceFarmCanNOTBeBuiltOnBonus() {
|
||||
val tile = getTile()
|
||||
val tile = tileMap[1,1]
|
||||
tile.resource = "Sheep"
|
||||
tile.setTransients()
|
||||
tile.addTerrainFeature("Hill")
|
||||
civInfo.civName = "Inca"
|
||||
|
||||
for (improvement in ruleSet.tileImprovements.values) {
|
||||
for (improvement in testGame.ruleset.tileImprovements.values) {
|
||||
if (!improvement.uniques.contains("Cannot be built on [Bonus resource] tiles")) continue
|
||||
val canBeBuilt = tile.improvementFunctions.canBuildImprovement(improvement, civInfo)
|
||||
Assert.assertFalse(improvement.name, canBeBuilt)
|
||||
|
||||
@ -1,217 +0,0 @@
|
||||
package com.unciv.logic.map
|
||||
|
||||
import com.badlogic.gdx.math.Vector2
|
||||
import com.unciv.Constants
|
||||
import com.unciv.logic.map.tile.Tile
|
||||
import com.unciv.models.ruleset.Ruleset
|
||||
import com.unciv.models.ruleset.RulesetCache
|
||||
import com.unciv.testing.GdxTestRunner
|
||||
import org.junit.Assert
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
|
||||
@RunWith(GdxTestRunner::class)
|
||||
class TileMapTests {
|
||||
|
||||
private var map = TileMap()
|
||||
private var tile1 = Tile()
|
||||
private var tile2 = Tile()
|
||||
private var tile3 = Tile()
|
||||
private var ruleSet = Ruleset()
|
||||
|
||||
@Before
|
||||
fun initTheWorld() {
|
||||
RulesetCache.loadRulesets(noMods = true)
|
||||
ruleSet = RulesetCache.getVanillaRuleset()
|
||||
map = TileMap()
|
||||
|
||||
tile1.position = Vector2(0f, 0f)
|
||||
tile1.tileMap = map
|
||||
tile1.ruleset = ruleSet
|
||||
|
||||
tile2.position = Vector2(0f, 1f)
|
||||
tile2.tileMap = map
|
||||
tile2.ruleset = ruleSet
|
||||
|
||||
tile3.position = Vector2(0f, 2f)
|
||||
tile3.tileMap = map
|
||||
tile3.ruleset = ruleSet
|
||||
|
||||
map.tileMatrix.add(arrayListOf(tile1, tile2, tile3))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeOnFlatGround() {
|
||||
tile1.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.desert
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.snow
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeOnFlatWater() {
|
||||
tile1.baseTerrain = Constants.ocean
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.coast
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.ocean
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeFromHills() {
|
||||
tile1.baseTerrain = Constants.hill
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.grassland
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.coast
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeOverForestFromHills() {
|
||||
tile1.baseTerrain = Constants.hill
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.grassland
|
||||
tile2.setTerrainTransients()
|
||||
tile2.setTerrainFeatures(listOf(Constants.forest))
|
||||
tile3.baseTerrain = Constants.coast
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeMountainOverHills() {
|
||||
tile1.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.hill
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.mountain
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeMountainFromForestOverHills() {
|
||||
tile1.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainTransients()
|
||||
tile1.setTerrainFeatures(listOf(Constants.forest))
|
||||
tile2.baseTerrain = Constants.hill
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.mountain
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeHillsFromHills() {
|
||||
tile1.baseTerrain = Constants.hill
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainFeatures(listOf(Constants.forest))
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.hill
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canNOTSeeGrassOverHills() {
|
||||
tile1.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.hill
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.grassland
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertFalse(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canNOTSeeHillsOverHills() {
|
||||
tile1.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.hill
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.hill
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertFalse(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canNOTSeeOutThroughForest() {
|
||||
tile1.baseTerrain = Constants.grassland
|
||||
tile1.setTerrainTransients()
|
||||
tile1.setTerrainFeatures(listOf(Constants.forest))
|
||||
tile2.baseTerrain = Constants.grassland
|
||||
tile2.setTerrainTransients()
|
||||
tile2.setTerrainFeatures(listOf(Constants.forest))
|
||||
tile3.baseTerrain = Constants.grassland
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertFalse(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canNOTSeeWaterOverJungle() {
|
||||
tile1.baseTerrain = Constants.coast
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.grassland
|
||||
tile2.setTerrainTransients()
|
||||
tile2.setTerrainFeatures(listOf(Constants.forest))
|
||||
tile3.baseTerrain = Constants.coast
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertFalse(tile3 in visibleTiles)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun canSeeWaterOverFlatLand() {
|
||||
tile1.baseTerrain = Constants.coast
|
||||
tile1.setTerrainTransients()
|
||||
tile2.baseTerrain = Constants.grassland
|
||||
tile2.setTerrainTransients()
|
||||
tile3.baseTerrain = Constants.coast
|
||||
tile3.setTerrainTransients()
|
||||
|
||||
val visibleTiles = map.getViewableTiles(tile1.position,2)
|
||||
Assert.assertTrue(tile2 in visibleTiles)
|
||||
Assert.assertTrue(tile3 in visibleTiles)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user