Modernize Connection Tests (#9831)

This commit is contained in:
SeventhM
2023-07-22 22:18:39 -07:00
committed by GitHub
parent 97b80973d1
commit eb17398d78

View File

@ -1,18 +1,8 @@
package com.unciv.logic.civilization
import com.badlogic.gdx.math.Vector2
import com.unciv.logic.GameInfo
import com.unciv.logic.city.City
import com.unciv.logic.civilization.diplomacy.DiplomacyManager
import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
import com.unciv.logic.civilization.transients.CapitalConnectionsFinder
import com.unciv.logic.map.TileMap
import com.unciv.logic.map.tile.RoadStatus
import com.unciv.models.ruleset.Ruleset
import com.unciv.models.ruleset.RulesetCache
import com.unciv.models.ruleset.nation.Nation
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
@ -33,134 +23,106 @@ import org.junit.runner.RunWith
@RunWith(GdxTestRunner::class)
class CapitalConnectionsFinderTests {
private var gameInfo = GameInfo()
private val testCivilizationNames = arrayListOf("America", "Germany", "Greece","Hanoi", "Genoa")
private var rules = Ruleset()
private fun ourCiv() = gameInfo.civilizations.first()
private var testGame = TestGame()
private lateinit var ourCiv: Civilization
@Before
fun setup() {
RulesetCache.loadRulesets(noMods = true)
rules = RulesetCache.getVanillaRuleset()
testGame.makeHexagonalMap(5)
ourCiv = testGame.addCiv()
gameInfo = GameInfo()
gameInfo.ruleset = rules
for (civName in testCivilizationNames)
gameInfo.civilizations.add(Civilization(civName).apply { playerType=PlayerType.Human })
gameInfo.tileMap = TileMap(4, rules)
// Initialize test civilizations so they pass certain criteria
gameInfo.civilizations.forEach {
it.gameInfo = gameInfo
it.nation = Nation()
it.nation.name = it.civName // for isBarbarian()
it.tech.techsResearched.add(rules.tileImprovements[RoadStatus.Road.name]!!.techRequired!!)
it.tech.techsResearched.add(rules.tileImprovements[RoadStatus.Railroad.name]!!.techRequired!!)
}
gameInfo.setTransients()
//Add techs to utilize roads
ourCiv.tech.addTechnology(testGame.ruleset.tileImprovements[RoadStatus.Road.name]?.techRequired!!)
ourCiv.tech.addTechnology(testGame.ruleset.tileImprovements[RoadStatus.Railroad.name]?.techRequired!!)
}
private fun createMedium(from:Int, to: Int, type: RoadStatus) {
for (i in from..to){
val tile = gameInfo.tileMap[0, i]
val tile = testGame.tileMap[0, i]
tile.roadStatus = type
}
}
private fun createCity(civInfo: Civilization, position: Vector2, name: String, capital: Boolean = false, hasHarbor: Boolean = false): City {
val city = City().apply {
location = position
this.name = name
setTransients(civInfo)
gameInfo.tileMap[location].setOwningCity(this)
}
if (capital)
city.cityConstructions.addBuilding(rules.buildings.values.first { it.hasUnique(UniqueType.IndicatesCapital) }.name)
if (hasHarbor)
city.cityConstructions.addBuilding(rules.buildings.values.first { it.hasUnique(UniqueType.ConnectTradeRoutes) }.name)
return city
}
private fun meetCivAndSetBorders(name: String, areBordersOpen: Boolean) {
ourCiv().diplomacy[name] = DiplomacyManager(ourCiv(), name)
.apply { diplomaticStatus = DiplomaticStatus.Peace }
ourCiv().diplomacy[name]!!.hasOpenBorders = areBordersOpen
private fun meetCivAndSetBorders(civ: Civilization, areBordersOpen: Boolean) {
ourCiv.getDiplomacyManager(civ).makePeace()
ourCiv.getDiplomacyManager(civ).hasOpenBorders = areBordersOpen
}
@Test
fun `Own cities are connected by road`() {
// Map: C-A N
// createLand(-2,2)
ourCiv().cities = listOf( createCity(ourCiv(), Vector2(0f, 0f), "Capital", true),
createCity(ourCiv(), Vector2(0f, -2f), "Connected"),
createCity(ourCiv(), Vector2(0f, 2f), "Not connected"))
val capital = testGame.addCity(ourCiv, testGame.tileMap[0, 0])
val connectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, -2])
val notConnectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, 2])
createMedium(-2, 0, RoadStatus.Road)
ourCiv.cache.updateCitiesConnectedToCapital()
val connectionsFinder = CapitalConnectionsFinder(ourCiv())
val res = connectionsFinder.find()
Assert.assertTrue(res.keys.any { it.name == "Connected" } && !res.keys.any { it.name == "Not connected" } )
Assert.assertTrue(connectedCity.isConnectedToCapital())
Assert.assertFalse(notConnectedCity.isConnectedToCapital())
}
@Test
fun `Own cities are connected by railroad`() {
// Map: N A=C
ourCiv().cities = listOf( createCity(ourCiv(), Vector2(0f, 0f), "Capital", true),
createCity(ourCiv(), Vector2(0f, 2f), "Connected"),
createCity(ourCiv(), Vector2(0f, -2f), "Not connected"))
val capital = testGame.addCity(ourCiv, testGame.tileMap[0, 0])
val connectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, 2])
val notConnectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, -2])
createMedium(0, 2, RoadStatus.Railroad)
val connectionsFinder = CapitalConnectionsFinder(ourCiv())
val res = connectionsFinder.find()
Assert.assertTrue(res.keys.any { it.name == "Connected" } && !res.keys.any { it.name == "Not connected" } )
ourCiv.cache.updateCitiesConnectedToCapital()
Assert.assertTrue(connectedCity.isConnectedToCapital())
Assert.assertFalse(notConnectedCity.isConnectedToCapital())
}
//
// @Test
// fun `Own cities are connected by road and harbor`() {
// // Map: N A-C C
// // ~~~~~~~
// createMedium(0,2, RoadStatus.Road)
// // createWater(-2,4)
// ourCiv().cities = listOf( createCity(ourCiv(), Vector2(0f, 0f), "Capital", true),
// createCity(ourCiv(), Vector2(0f, -2f), "Not connected"),
// createCity(ourCiv(), Vector2(0f, 2f), "Connected1", capital = false, hasHarbor = true),
// createCity(ourCiv(), Vector2(0f, 4f), "Connected2", capital = false, hasHarbor = true))
// //createWater(-2,4)
// val capital = testGame.addCity(ourCiv, testGame.tileMap[0, 0])
// val connectedCity1 = testGame.addCity(ourCiv, testGame.tileMap[0, 2])
// val connectedCity2 = testGame.addCity(ourCiv, testGame.tileMap[0, 4])
// val notConnectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, -2])
// connectedCity1.cityConstructions.addBuilding("Harbor")
// connectedCity2.cityConstructions.addBuilding("Harbor")
//
// val connectionsFinder = CapitalConnectionsFinder(ourCiv())
// val res = connectionsFinder.find()
// ourCiv.cache.updateCitiesConnectedToCapital()
//
// Assert.assertTrue(res.keys.count { it.name.startsWith("Connected") } == 2 && !res.keys.any { it.name == "Not connected" } )
// Assert.assertTrue(connectedCity1.isConnectedToCapital())
// Assert.assertTrue(connectedCity2.isConnectedToCapital())
// Assert.assertFalse(notConnectedCity.isConnectedToCapital())
// }
@Test
fun `Cities are connected by roads via Open Borders`() {
// Map: N-X=A-O=C
ourCiv().cities = listOf( createCity(ourCiv(), Vector2(0f, 0f), "Capital", true),
createCity(ourCiv(), Vector2(0f, -4f), "Not connected"),
createCity(ourCiv(), Vector2(0f, 4f), "Connected"))
val capital = testGame.addCity(ourCiv, testGame.tileMap[0, 0])
val connectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, 4])
val notConnectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, -4])
val openCiv = gameInfo.getCivilization("Germany")
openCiv.cities = listOf( createCity(openCiv, Vector2(0f, 2f), "Berlin", true))
meetCivAndSetBorders("Germany", true)
val openCiv = testGame.addCiv()
val openCivCapital = testGame.addCity(openCiv, testGame.tileMap[0, 2])
meetCivAndSetBorders(openCiv, true)
// The path to "not connected" goes through closed territory
val closedCiv = gameInfo.getCivilization("Greece")
closedCiv.cities = listOf( createCity(closedCiv, Vector2(0f, -2f), "Athens", true))
meetCivAndSetBorders("Greece", false)
val closedCiv = testGame.addCiv()
val closedCivCapital = testGame.addCity(closedCiv, testGame.tileMap[0, -2])
meetCivAndSetBorders(closedCiv, false)
createMedium(-4,-2, RoadStatus.Road)
createMedium(-2,0, RoadStatus.Railroad)
createMedium(0,2, RoadStatus.Road)
createMedium(2,4, RoadStatus.Railroad)
val connectionsFinder = CapitalConnectionsFinder(ourCiv())
val res = connectionsFinder.find()
ourCiv.cache.updateCitiesConnectedToCapital()
Assert.assertTrue(res.keys.any { it.name == "Connected" } && !res.keys.any { it.name == "Not connected" } )
Assert.assertTrue(connectedCity.isConnectedToCapital())
Assert.assertFalse(notConnectedCity.isConnectedToCapital())
}
// @Test
@ -168,45 +130,47 @@ class CapitalConnectionsFinderTests {
// // Map: A
// // ~~~~~
// // C O-N=N
// createLand(-4,-4) // capital is on an island
// createWater(-4,0)
// createLand(-4,2) // some land without access to ocean
// ourCiv().cities = listOf( createCity(ourCiv(), Vector2(0f, -4f), "Capital", true, hasHarbor = true),
// createCity(ourCiv(), Vector2(2f, 2f), "Not connected1", capital = false, hasHarbor = true), // cannot reach ocean
// createCity(ourCiv(), Vector2(2f, 0f), "Not connected2"), // has no harbor, has road to Berlin
// createCity(ourCiv(), Vector2(2f, -4f), "Connected", capital = false, hasHarbor = true))
// //createLand(-4,-4) // capital is on an island
// //createWater(-4,0)
// //createLand(-4,2) // some land without access to ocean
// val capital = testGame.addCity(ourCiv, testGame.tileMap[0, -4])
// val connectedCity = testGame.addCity(ourCiv, testGame.tileMap[2, -4])
// val notConnectedCity1 = testGame.addCity(ourCiv, testGame.tileMap[2, 2])
// val notConnectedCity2 = testGame.addCity(ourCiv, testGame.tileMap[2, 0])
// capital.cityConstructions.addBuilding("Harbor")
// notConnectedCity1.cityConstructions.addBuilding("Harbor")
// connectedCity.cityConstructions.addBuilding("Harbor")
//
// val openCiv = gameInfo.getCivilization("Germany")
// openCiv.cities = listOf( createCity(openCiv, Vector2(2f, -2f), "Berlin", true, hasHarbor = true))
// meetCivAndSetBorders("Germany", true)
// val openCiv = testGame.addCiv()
// val openCivCapital = testGame.addCity(openCiv, testGame.tileMap[2, -2])
// openCivCapital.cityConstructions.addBuilding("Harbor")
// meetCivAndSetBorders(openCiv, true)
//
// createMedium(-2,0, RoadStatus.Road)
// createMedium(0,2, RoadStatus.Railroad)
//
// val connectionsFinder = CapitalConnectionsFinder(ourCiv())
// val res = connectionsFinder.find()
// ourCiv.cache.updateCitiesConnectedToCapital()
//
// Assert.assertTrue(res.keys.any { it.name == "Connected" } && !res.keys.any { it.name.startsWith("Not connected") } )
// Assert.assertTrue(connectedCity.isConnectedToCapital())
// Assert.assertFalse(notConnectedCity1.isConnectedToCapital())
// Assert.assertFalse(notConnectedCity2.isConnectedToCapital())
// }
@Test
fun `Cities are connected by roads via City-States`() {
// Map: N=X-A=O-C
ourCiv().cities = listOf( createCity(ourCiv(), Vector2(0f, 0f), "Capital", true),
createCity(ourCiv(), Vector2(0f, -4f), "Not connected"),
createCity(ourCiv(), Vector2(0f, 4f), "Connected"))
val capital = testGame.addCity(ourCiv, testGame.tileMap[0, 0])
val connectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, 4])
val notConnectedCity = testGame.addCity(ourCiv, testGame.tileMap[0, -4])
val openCiv = gameInfo.getCivilization("Hanoi")
// openCiv.nation.cityStateType = "Cultured"
openCiv.cities = listOf( createCity(openCiv, Vector2(0f, 2f), "Berlin", true))
ourCiv().diplomacy["Hanoi"] = DiplomacyManager(ourCiv(), "Hanoi")
.apply { diplomaticStatus = DiplomaticStatus.Peace }
val openCiv = testGame.addCiv(cityStateType = "Cultured")
val openCivCapital = testGame.addCity(openCiv, testGame.tileMap[0, 2])
ourCiv.getDiplomacyManager(openCiv).makePeace()
val closedCiv = gameInfo.getCivilization("Genoa")
closedCiv.nation.cityStateType = "Cultured"
closedCiv.cities = listOf( createCity(closedCiv, Vector2(0f, -2f), "Athens", true))
ourCiv().diplomacy["Genoa"] = DiplomacyManager(ourCiv(), "Genoa")
.apply { diplomaticStatus = DiplomaticStatus.War }
val closedCiv = testGame.addCiv(cityStateType = "Cultured")
val closedCivCapital = testGame.addCity(closedCiv, testGame.tileMap[0, -2])
ourCiv.diplomacyFunctions.makeCivilizationsMeet(closedCiv)
ourCiv.getDiplomacyManager(closedCiv).declareWar()
createMedium(-4,-2, RoadStatus.Railroad)
@ -215,10 +179,9 @@ class CapitalConnectionsFinderTests {
createMedium(2,4, RoadStatus.Road)
val connectionsFinder = CapitalConnectionsFinder(ourCiv())
val res = connectionsFinder.find()
Assert.assertTrue(res.keys.any { it.name == "Connected" } && !res.keys.any { it.name == "Not connected" } )
ourCiv.cache.updateCitiesConnectedToCapital()
Assert.assertTrue(connectedCity.isConnectedToCapital())
Assert.assertFalse(notConnectedCity.isConnectedToCapital())
}
}