mirrors/Unciv
1
0
Fork 0
mirror of https://github.com/yairm210/Unciv.git synced 2025-08-04 09:09:21 +07:00
Code Issues Packages Projects Releases Wiki Activity

Added more unit tests for uniques (#6841)

Browse Source
This commit is contained in:
Xander Lenstra
2022-05-17 15:42:27 +02:00
committed by GitHub
parent 88585bcf7d
commit 7b3a4c741f
6 changed files with 185 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3,10 +3,10 @@ package com.unciv.uniques
import com.badlogic.gdx.math.Vector2
import com.unciv.Constants
import com.unciv.models.ruleset.unique.UniqueType
import com.unciv.logic.map.RoadStatus
import com.unciv.models.ruleset.BeliefType
import com.unciv.models.stats.Stats
import com.unciv.testing.GdxTestRunner
import com.unciv.ui.worldscreen.unit.UnitActions
import org.junit.Assert
import org.junit.Before
import org.junit.Test
@ -21,13 +21,13 @@ class GlobalUniquesTests {
fun initTheWorld() {
game = TestGame()
}
// region stat uniques
@Test
/** tests [UniqueType.Stats] */
fun stats() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val buildingName = game.createBuildingWithUnique("[+1 Food]").name
@ -39,7 +39,7 @@ class GlobalUniquesTests {
@Test
fun statsPerCity() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val buildingName = game.createBuildingWithUnique("[+1 Production] [in this city]").name
@ -51,7 +51,7 @@ class GlobalUniquesTests {
@Test
fun statsPerSpecialist() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val building = game.createBuildingWithUnique("[+3 Gold] from every specialist [in this city]")
val specialistName = game.addEmptySpecialist()
@ -67,7 +67,7 @@ class GlobalUniquesTests {
@Test
fun statsPerPopulation() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val building = game.createBuildingWithUnique("[+3 Gold] per [2] population [in this city]")
cityInfo.population.addPopulation(4)
@ -80,7 +80,7 @@ class GlobalUniquesTests {
@Test
fun statsPerXPopulation() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val building = game.createBuildingWithUnique("[+3 Gold] in cities with [3] or more population")
@ -97,7 +97,7 @@ class GlobalUniquesTests {
@Test
fun statsFromCitiesOnSpecificTiles() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val building = game.createBuildingWithUnique("[+3 Gold] in cities on [${Constants.desert}] tiles")
cityInfo.cityConstructions.addBuilding(building.name)
@ -112,48 +112,54 @@ class GlobalUniquesTests {
@Test
fun statsSpendingGreatPeople() {
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val unit = game.addUnit("Great Prophet", civInfo, tile)
val unit = game.addUnit("Great Engineer", civInfo, tile)
val building = game.createBuildingWithUnique("[+250 Gold] whenever a Great Person is expended")
cityInfo.cityConstructions.addBuilding(building.name)
civInfo.addGold(-civInfo.gold)
UnitActions.getFoundReligionAction(unit)()
civInfo.addGold(-civInfo.gold) // reset gold just to be sure
unit.consume()
Assert.assertTrue(civInfo.gold == 250)
}
@Test
fun statsFromTiles() {
game.makeHexagonalMap(2)
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val building = game.createBuildingWithUnique("[+4 Gold] from [${Constants.grassland}] tiles [in all cities]")
cityInfo.cityConstructions.addBuilding(building.name)
val tile2 = game.addTile(Constants.grassland, Vector2(0f,1f))
val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland)
Assert.assertTrue(tile2.getTileStats(cityInfo, civInfo).gold == 4f)
}
@Test
fun statsFromTilesWithout() {
game.makeHexagonalMap(3)
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val building = game.createBuildingWithUnique("[+4 Gold] from [${Constants.grassland}] tiles without [${Constants.forest}] [in all cities]")
val building = game.createBuildingWithUnique("[+4 Gold] from [${Constants.grassland}] tiles without [${Constants.forest}] [in this city]")
cityInfo.cityConstructions.addBuilding(building.name)
val tile2 = game.addTile(Constants.grassland, Vector2(0f,1f))
val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland)
game.addTileToCity(cityInfo, tile2)
Assert.assertTrue(tile2.getTileStats(cityInfo, civInfo).gold == 4f)
val tile3 = game.addTile(Constants.grassland, Vector2(0f, 2f), listOf(Constants.forest))
val tile3 = game.setTileFeatures(Vector2(0f, 2f), Constants.grassland, listOf(Constants.forest))
game.addTileToCity(cityInfo, tile3)
Assert.assertFalse(tile3.getTileStats(cityInfo, civInfo).gold == 4f)
}
@Test
fun statsFromObject() {
game.makeHexagonalMap(1)
val civInfo = game.addCiv()
val tile = game.addTile(Constants.desert)
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val cityInfo = game.addCity(civInfo, tile, true)
val specialist = game.addEmptySpecialist()
val building = game.createBuildingWithUnique("[+3 Faith] from every [${specialist}]")
@ -168,8 +174,8 @@ class GlobalUniquesTests {
cityInfo.cityConstructions.removeBuilding(building.name)
val building2 = game.createBuildingWithUnique("[+3 Faith] from every [${Constants.grassland}]")
cityInfo.cityConstructions.addBuilding(building2.name)
val tile2 = game.addTile(Constants.grassland, Vector2(1f, 0f))
val tile2 = game.setTileFeatures(Vector2(0f,1f), Constants.grassland)
Assert.assertTrue(tile2.getTileStats(cityInfo, civInfo).faith == 3f)
cityInfo.cityConstructions.removeBuilding(building2.name)
@ -182,4 +188,84 @@ class GlobalUniquesTests {
cityInfo.cityStats.update()
Assert.assertTrue(cityInfo.cityStats.finalStatList["Buildings"]!!.faith == 3f)
}
@Test
fun statsFromTradeRoute() {
game.makeHexagonalMap(3)
val civInfo = game.addCiv(uniques = listOf("[+30 Science] from each Trade Route"))
civInfo.tech.addTechnology("The Wheel") // Required to form trade routes
val tile = game.setTileFeatures(Vector2(0f,0f), Constants.desert)
val tile2 = game.setTileFeatures(Vector2(0f,2f), Constants.desert)
tile.roadStatus = RoadStatus.Road
tile2.roadStatus = RoadStatus.Road
val cityInfo = game.addCity(civInfo, tile)
val city2 = game.addCity(civInfo, tile2)
val inBetweenTile = game.setTileFeatures(Vector2(0f, 1f), Constants.desert)
inBetweenTile.roadStatus = RoadStatus.Road
civInfo.transients().updateCitiesConnectedToCapital()
city2.cityStats.update()
println(city2.isConnectedToCapital())
println(city2.cityStats.finalStatList)
Assert.assertTrue(city2.cityStats.finalStatList["Trade routes"]!!.science == 30f)
}
@Test
fun statsFromGlobalCitiesFollowingReligion() {
val civ1 = game.addCiv()
val religion = game.addReligion(civ1)
val belief = game.addBelief(BeliefType.Founder, "[+30 Science] for each global city following this religion")
religion.founderBeliefs.add(belief.name)
val civ2 = game.addCiv()
val tile = game.getTile(Vector2(0f,0f))
val cityOfCiv2 = game.addCity(civ2, tile)
cityOfCiv2.population.setPopulation(1) // Need someone to be converted
cityOfCiv2.religion.addPressure(religion.name, 1000)
Assert.assertTrue(cityOfCiv2.religion.getMajorityReligionName() == religion.name)
civ1.updateStatsForNextTurn()
Assert.assertTrue(civ1.statsForNextTurn.science == 30f)
}
@Test
fun statsFromGlobalFollowers() {
val civ1 = game.addCiv()
val religion = game.addReligion(civ1)
val belief = game.addBelief(BeliefType.Founder, "[+30 Science] from every [3] global followers [in all cities]")
religion.founderBeliefs.add(belief.name)
val civ2 = game.addCiv()
val tile = game.getTile(Vector2(0f,0f))
val cityOfCiv2 = game.addCity(civ2, tile)
cityOfCiv2.population.setPopulation(9) // Need people to be converted
cityOfCiv2.religion.addPressure(religion.name, 1000000000) // To completely overwhelm the default atheism in a city
civ1.updateStatsForNextTurn()
println(civ1.statsForNextTurn.science)
Assert.assertTrue(civ1.statsForNextTurn.science == 90f)
}
// endregion
// region stat percentage bonus providing uniques
@Test
fun statPercentBonus() {
val civ = game.addCiv()
val tile = game.getTile(Vector2(0f, 0f))
val city = game.addCity(civ, tile, true)
val building = game.createBuildingWithUniques(arrayListOf("[+10 Science]", "[+200]% [Science]"))
city.cityConstructions.addBuilding(building.name)
city.cityStats.update()
println(city.cityStats.finalStatList)
Assert.assertTrue(city.cityStats.finalStatList["Buildings"]!!.science == 30f)
}
// endregion
}

81
tests/src/com/unciv/uniques/TestGame.kt
View File

@ -1,26 +1,34 @@
package com.unciv.uniques
import com.badlogic.gdx.math.Vector2
import com.unciv.Constants
import com.unciv.UncivGame
import com.unciv.logic.GameInfo
import com.unciv.logic.city.CityInfo
import com.unciv.logic.civilization.CityStateType
import com.unciv.logic.civilization.CivilizationInfo
import com.unciv.logic.civilization.PlayerType
import com.unciv.logic.map.MapSizeNew
import com.unciv.logic.map.MapUnit
import com.unciv.logic.map.TileInfo
import com.unciv.logic.map.TileMap
import com.unciv.models.Religion
import com.unciv.models.metadata.BaseRuleset
import com.unciv.models.metadata.GameSettings
import com.unciv.models.ruleset.*
import com.unciv.models.ruleset.unique.UniqueType
import com.unciv.ui.utils.withItem
import kotlin.math.abs
import kotlin.math.max
class TestGame {
private var objectsCreated = 0
val ruleset: Ruleset
val gameInfo = GameInfo()
val tileMap = TileMap()
/** [tileMap] has a default size of 1 tile, use [makeHexagonalMap] or [makeRectangularMap] to change that */
val tileMap
get() = gameInfo.tileMap
init {
// Set UncivGame.Current so that debug variables are initialized
@ -35,29 +43,50 @@ class TestGame {
gameInfo.difficultyObject = ruleset.difficulties["Prince"]!!
// Create a tilemap, needed for city centers
gameInfo.tileMap = tileMap
gameInfo.tileMap = TileMap(1, ruleset, false)
tileMap.mapParameters.mapSize = MapSizeNew(0, 0)
tileMap.ruleset = ruleset
}
fun addTile(terrain: String, position: Vector2 = Vector2.Zero, features: List<String> = listOf()): TileInfo {
val tile = TileInfo()
tile.ruleset = ruleset
/** Makes a new rectangular tileMap and sets it in gameInfo. Removes all existing tiles. All new tiles have terrain [baseTerrain] */
fun makeRectangularMap(newHeight: Int, newWidth: Int, baseTerrain: String = Constants.desert) {
val newTileMap = TileMap(newWidth, newHeight, ruleset, tileMap.mapParameters.worldWrap)
newTileMap.mapParameters.mapSize = MapSizeNew(newWidth, newHeight)
for (row in tileMap.tileMatrix)
for (tile in row)
if (tile != null)
tile.baseTerrain = baseTerrain
gameInfo.tileMap = newTileMap
}
/** Makes a new hexagonal tileMap and sets it in gameInfo. Removes all existing tiles. All new tiles have terrain [baseTerrain] */
fun makeHexagonalMap(newRadius: Int, baseTerrain: String = Constants.desert) {
val newTileMap = TileMap(newRadius, ruleset, tileMap.mapParameters.worldWrap)
newTileMap.mapParameters.mapSize = MapSizeNew(newRadius)
for (row in tileMap.tileMatrix)
for (tile in row)
if (tile != null)
tile.baseTerrain = baseTerrain
gameInfo.tileMap = newTileMap
}
fun getTile(position: Vector2) = tileMap[position]
/** Sets the [terrain] and [features] of the tile at [position], and then returns it */
fun setTileFeatures(position: Vector2, terrain: String = Constants.desert, features: List<String> = listOf()): TileInfo {
val tile = tileMap[position]
tile.baseTerrain = terrain
for (feature in features) {
tile.addTerrainFeature(feature)
}
tile.tileMap = tileMap
tile.position = position
tile.setTransients()
while (tileMap.tileMatrix.size < position.x + 1)
tileMap.tileMatrix.add(ArrayList())
while (tileMap.tileMatrix[position.x.toInt()].size < position.y + 1)
tileMap.tileMatrix[position.x.toInt()].add(null)
tileMap.tileMatrix[position.x.toInt()][position.y.toInt()] = tile
return tile
}
}
fun addCiv(uniques: List<String> = emptyList(), isPlayer: Boolean = false, cityState: CityStateType? = null): CivilizationInfo {
val nationName = "Nation-${objectsCreated++}"
ruleset.nations[nationName] = Nation().apply {
name = nationName
@ -92,6 +121,10 @@ class TestGame {
}
return cityInfo
}
fun addTileToCity(city: CityInfo, tile: TileInfo) {
city.tiles.add(tile.position)
}
fun addUnit(name: String, civInfo: CivilizationInfo, tile: TileInfo): MapUnit {
val baseUnit = ruleset.units[name]!!
@ -119,4 +152,20 @@ class TestGame {
return building
}
fun addReligion(foundingCiv: CivilizationInfo): Religion {
gameInfo.gameParameters.religionEnabled = true
val religion = Religion("Religion-${objectsCreated++}", gameInfo, foundingCiv.civName)
foundingCiv.religionManager.religion = religion
gameInfo.religions[religion.name] = religion
return religion
}
fun addBelief(type: BeliefType = BeliefType.Any, vararg uniques: String): Belief {
val belief = Belief()
belief.name = "Belief-${objectsCreated++}"
belief.type = type
belief.uniques = arrayListOf<String>(*uniques)
ruleset.beliefs[belief.name] = belief
return belief
}
}

5
tests/src/com/unciv/uniques/UnitUniquesTests.kt
View File

@ -25,8 +25,9 @@ class UnitUniquesTests {
@Test
fun `Sweden can gift Great Persons to City States`() {
// when
game.makeHexagonalMap(1)
val cityState = game.addCiv(cityState = CityStateType.Cultured)
val cityStateCapitalTile = game.addTile(Constants.grassland, Vector2(0f, 0f))
val cityStateCapitalTile = game.getTile(Vector2(0f, 0f))
val cityStateCapital = game.addCity(cityState, cityStateCapitalTile)
val mainCiv = game.addCiv(
@ -35,7 +36,7 @@ class UnitUniquesTests {
)
game.gameInfo.currentPlayerCiv = mainCiv
val unitTile = game.addTile(Constants.grassland, Vector2(1f, 0f))
val unitTile = game.getTile(Vector2(1f, 0f))
cityStateCapital.expansion.takeOwnership(unitTile)
val greatPerson = game.addUnit("Great Scientist", mainCiv, unitTile)