From 1cc8227025d03a37037de4b411cfda5267ea522a Mon Sep 17 00:00:00 2001 From: Vladimir Tanakov Date: Mon, 30 Dec 2019 19:04:12 +0300 Subject: [PATCH] Fix civilopedia parsing, fix dialog does not call update to enable next turn button (#1553) --- core/src/com/unciv/JsonParser.kt | 14 +++++ .../logic/civilization/CivilizationInfo.kt | 6 +- core/src/com/unciv/models/Tutorial.kt | 52 ++++++++-------- core/src/com/unciv/models/ruleset/Ruleset.kt | 61 +++++++++---------- core/src/com/unciv/ui/CivilopediaScreen.kt | 9 +-- .../unciv/ui/tutorials/TutorialController.kt | 5 +- .../com/unciv/ui/tutorials/TutorialMiner.kt | 26 +++++--- .../unciv/ui/utils/CameraStageBaseScreen.kt | 31 +++++++--- .../com/unciv/ui/worldscreen/WorldScreen.kt | 20 ++++-- .../src/com/unciv/testing/TranslationTests.kt | 22 +++---- .../com/unciv/testing/TutorialMinerTests.kt | 34 +++++++++++ .../unciv/testing/TutorialTranslationTests.kt | 2 +- 12 files changed, 181 insertions(+), 101 deletions(-) create mode 100644 core/src/com/unciv/JsonParser.kt create mode 100644 tests/src/com/unciv/testing/TutorialMinerTests.kt diff --git a/core/src/com/unciv/JsonParser.kt b/core/src/com/unciv/JsonParser.kt new file mode 100644 index 0000000000..d3af7c41f9 --- /dev/null +++ b/core/src/com/unciv/JsonParser.kt @@ -0,0 +1,14 @@ +package com.unciv + +import com.badlogic.gdx.Gdx +import com.badlogic.gdx.utils.Json + +class JsonParser { + + private val json = Json().apply { ignoreUnknownFields = true } + + fun getFromJson(tClass: Class, filePath: String): T { + val jsonText = Gdx.files.internal(filePath).readString(Charsets.UTF_8.name()) + return json.fromJson(tClass, jsonText) + } +} \ No newline at end of file diff --git a/core/src/com/unciv/logic/civilization/CivilizationInfo.kt b/core/src/com/unciv/logic/civilization/CivilizationInfo.kt index 555e733d8d..7457972075 100644 --- a/core/src/com/unciv/logic/civilization/CivilizationInfo.kt +++ b/core/src/com/unciv/logic/civilization/CivilizationInfo.kt @@ -4,6 +4,7 @@ import com.badlogic.gdx.Gdx import com.badlogic.gdx.graphics.Color import com.badlogic.gdx.math.Vector2 import com.unciv.Constants +import com.unciv.JsonParser import com.unciv.UncivGame import com.unciv.logic.GameInfo import com.unciv.logic.automation.NextTurnAutomation @@ -26,6 +27,9 @@ import kotlin.collections.HashMap import kotlin.math.roundToInt class CivilizationInfo { + + private val jsonParser = JsonParser() + @Transient lateinit var gameInfo: GameInfo @Transient lateinit var nation:Nation /** @@ -117,7 +121,7 @@ class CivilizationInfo { val language = UncivGame.Current.settings.language.replace(" ","_") val filePath = "jsons/Nations/Nations_$language.json" if(!Gdx.files.internal(filePath).exists()) return nation - val translatedNation = gameInfo.ruleSet.getFromJson(Array::class.java, filePath) + val translatedNation = jsonParser.getFromJson(Array::class.java, filePath) .firstOrNull { it.name==civName} if(translatedNation==null) // this language's trnslation doesn't contain this nation yet, return nation // default to english diff --git a/core/src/com/unciv/models/Tutorial.kt b/core/src/com/unciv/models/Tutorial.kt index a9a0e97faf..84b7c22cc6 100644 --- a/core/src/com/unciv/models/Tutorial.kt +++ b/core/src/com/unciv/models/Tutorial.kt @@ -1,32 +1,32 @@ package com.unciv.models -enum class Tutorial(val value: String) { +enum class Tutorial(val value: String, val isCivilopedia: Boolean) { - Introduction("Introduction"), - NewGame("New_Game"), - SlowStart("_Slow_Start"), - CultureAndPolicies("Culture_and_Policies"), - Happiness("Happiness"), - Unhappiness("Unhappiness"), - GoldenAge("Golden_Age"), - RoadsAndRailroads("Roads_and_Railroads"), - VictoryTypes("Victory_Types"), - EnemyCity("Enemy_City"), - LuxuryResource("Luxury_Resource"), - StrategicResource("Strategic_Resource"), - EnemyCityNeedsConqueringWithMeleeUnit("_EnemyCityNeedsConqueringWithMeleeUnit"), - AfterConquering("After_Conquering"), - BarbarianEncountered("_BarbarianEncountered"), - OtherCivEncountered("_OtherCivEncountered"), - ApolloProgram("Apollo_Program"), - InjuredUnits("Injured_Units"), - Workers("Workers"), - SiegeUnits("Siege_Units"), - Embarking("Embarking"), - CityRange("City_Range"), - IdleUnits("Idle_Units"), - ContactMe("Contact_Me"), - Pillaging("_Pillaging"); + Introduction("Introduction", true), + NewGame("New_Game", true), + SlowStart("_Slow_Start", false), + CultureAndPolicies("Culture_and_Policies", true), + Happiness("Happiness", true), + Unhappiness("Unhappiness", true), + GoldenAge("Golden_Age", true), + RoadsAndRailroads("Roads_and_Railroads", true), + VictoryTypes("Victory_Types", true), + EnemyCity("Enemy_City", true), + LuxuryResource("Luxury_Resource", true), + StrategicResource("Strategic_Resource", true), + EnemyCityNeedsConqueringWithMeleeUnit("_EnemyCityNeedsConqueringWithMeleeUnit", false), + AfterConquering("After_Conquering", true), + BarbarianEncountered("_BarbarianEncountered", false), + OtherCivEncountered("_OtherCivEncountered", false), + ApolloProgram("Apollo_Program", true), + InjuredUnits("Injured_Units", true), + Workers("Workers", true), + SiegeUnits("Siege_Units", true), + Embarking("Embarking", true), + CityRange("City_Range", true), + IdleUnits("Idle_Units", true), + ContactMe("Contact_Me", true), + Pillaging("_Pillaging", false); companion object { fun findByName(name: String): Tutorial? = values().find { it.value == name } diff --git a/core/src/com/unciv/models/ruleset/Ruleset.kt b/core/src/com/unciv/models/ruleset/Ruleset.kt index 7fffcd3c50..8e60b0d7fe 100644 --- a/core/src/com/unciv/models/ruleset/Ruleset.kt +++ b/core/src/com/unciv/models/ruleset/Ruleset.kt @@ -1,7 +1,6 @@ package com.unciv.models.ruleset -import com.badlogic.gdx.Gdx -import com.badlogic.gdx.utils.Json +import com.unciv.JsonParser import com.unciv.models.ruleset.tech.TechColumn import com.unciv.models.ruleset.tech.Technology import com.unciv.models.ruleset.tile.Terrain @@ -12,8 +11,11 @@ import com.unciv.models.ruleset.unit.Promotion import com.unciv.models.stats.INamed import kotlin.collections.set -class Ruleset { - var name="" +class Ruleset(load: Boolean = true) { + + private val jsonParser = JsonParser() + + var name = "" val mods = LinkedHashSet() val buildings = LinkedHashMap() val terrains = LinkedHashMap() @@ -26,20 +28,16 @@ class Ruleset { val policyBranches = LinkedHashMap() val difficulties = LinkedHashMap() - fun clone(): Ruleset{ + fun clone(): Ruleset { val newRuleset = Ruleset(false) newRuleset.add(this) return newRuleset } - constructor(load:Boolean=true){ - if(load) load() - } - - - fun getFromJson(tClass: Class, filePath:String): T { - val jsonText = Gdx.files.internal(filePath).readString(Charsets.UTF_8.name()) - return Json().apply { ignoreUnknownFields = true }.fromJson(tClass, jsonText) + init { + if (load) { + load() + } } private fun createHashmap(items: Array): LinkedHashMap { @@ -49,10 +47,10 @@ class Ruleset { return hashMap } - fun add(ruleset: Ruleset){ + fun add(ruleset: Ruleset) { buildings.putAll(ruleset.buildings) difficulties.putAll(ruleset.difficulties) - nations .putAll(ruleset.nations) + nations.putAll(ruleset.nations) policyBranches.putAll(ruleset.policyBranches) technologies.putAll(ruleset.technologies) buildings.putAll(ruleset.buildings) @@ -63,7 +61,7 @@ class Ruleset { units.putAll(ruleset.units) } - fun clearExceptModNames(){ + fun clearExceptModNames() { buildings.clear() difficulties.clear() nations.clear() @@ -77,19 +75,18 @@ class Ruleset { units.clear() } - fun load(folderPath: String="jsons") { - + fun load(folderPath: String = "jsons") { val gameBasicsStartTime = System.currentTimeMillis() - val techColumns = getFromJson(Array::class.java, "$folderPath/Techs.json") + val techColumns = jsonParser.getFromJson(Array::class.java, "$folderPath/Techs.json") for (techColumn in techColumns) { for (tech in techColumn.techs) { - if (tech.cost==0) tech.cost = techColumn.techCost + if (tech.cost == 0) tech.cost = techColumn.techCost tech.column = techColumn technologies[tech.name] = tech } } - buildings += createHashmap(getFromJson(Array::class.java, "$folderPath/Buildings.json")) + buildings += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/Buildings.json")) for (building in buildings.values) { if (building.requiredTech == null) continue val column = technologies[building.requiredTech!!]!!.column @@ -97,13 +94,13 @@ class Ruleset { building.cost = if (building.isWonder || building.isNationalWonder) column!!.wonderCost else column!!.buildingCost } - terrains += createHashmap(getFromJson(Array::class.java, "$folderPath/Terrains.json")) - tileResources += createHashmap(getFromJson(Array::class.java, "$folderPath/TileResources.json")) - tileImprovements += createHashmap(getFromJson(Array::class.java, "$folderPath/TileImprovements.json")) - units += createHashmap(getFromJson(Array::class.java, "$folderPath/Units.json")) - unitPromotions += createHashmap(getFromJson(Array::class.java, "$folderPath/UnitPromotions.json")) + terrains += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/Terrains.json")) + tileResources += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/TileResources.json")) + tileImprovements += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/TileImprovements.json")) + units += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/Units.json")) + unitPromotions += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/UnitPromotions.json")) - policyBranches += createHashmap(getFromJson(Array::class.java, "$folderPath/Policies.json")) + policyBranches += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/Policies.json")) for (branch in policyBranches.values) { branch.requires = ArrayList() branch.branch = branch @@ -114,15 +111,13 @@ class Ruleset { branch.policies.last().name = branch.name + " Complete" } - nations += createHashmap(getFromJson(Array::class.java, "$folderPath/Nations/Nations.json")) - for(nation in nations.values) nation.setTransients() + nations += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/Nations/Nations.json")) + for (nation in nations.values) nation.setTransients() - difficulties += createHashmap(getFromJson(Array::class.java, "$folderPath/Difficulties.json")) + difficulties += createHashmap(jsonParser.getFromJson(Array::class.java, "$folderPath/Difficulties.json")) val gameBasicsLoadTime = System.currentTimeMillis() - gameBasicsStartTime - println("Loading game basics - "+gameBasicsLoadTime+"ms") - + println("Loading game basics - " + gameBasicsLoadTime + "ms") } - } diff --git a/core/src/com/unciv/ui/CivilopediaScreen.kt b/core/src/com/unciv/ui/CivilopediaScreen.kt index 98e9caccf9..2b53f1a291 100644 --- a/core/src/com/unciv/ui/CivilopediaScreen.kt +++ b/core/src/com/unciv/ui/CivilopediaScreen.kt @@ -2,6 +2,7 @@ package com.unciv.ui import com.badlogic.gdx.scenes.scene2d.Actor import com.badlogic.gdx.scenes.scene2d.ui.* +import com.unciv.JsonParser import com.unciv.UncivGame import com.unciv.models.ruleset.Ruleset import com.unciv.models.translations.tr @@ -12,13 +13,13 @@ import java.util.* class CivilopediaScreen(ruleset: Ruleset) : CameraStageBaseScreen() { class CivilopediaEntry(var name: String, var description: String, var image: Actor? = null) - val categoryToEntries = LinkedHashMap>() - val categoryToButtons = LinkedHashMap() + private val categoryToEntries = LinkedHashMap>() + private val categoryToButtons = LinkedHashMap() - val entrySelectTable = Table().apply { defaults().pad(5f) } + private val entrySelectTable = Table().apply { defaults().pad(5f) } val description = "".toLabel() - val tutorialMiner = TutorialMiner() + private val tutorialMiner = TutorialMiner(JsonParser()) fun select(category: String) { entrySelectTable.clear() diff --git a/core/src/com/unciv/ui/tutorials/TutorialController.kt b/core/src/com/unciv/ui/tutorials/TutorialController.kt index 9e46e69185..bb56de2940 100644 --- a/core/src/com/unciv/ui/tutorials/TutorialController.kt +++ b/core/src/com/unciv/ui/tutorials/TutorialController.kt @@ -10,6 +10,7 @@ class TutorialController( private val tutorialQueue = mutableSetOf() private var isTutorialShowing = false + var allTutorialsShowedCallback: (() -> Unit)? = null fun showTutorial(tutorial: Tutorial) { if (!UncivGame.Current.settings.showTutorials) return @@ -23,7 +24,9 @@ class TutorialController( private fun showTutorialIfNeeded() { val tutorial = tutorialQueue.firstOrNull() - if (tutorial != null && !isTutorialShowing) { + if (tutorial == null) { + allTutorialsShowedCallback?.invoke() + } else if (!isTutorialShowing) { isTutorialShowing = true val texts = tutorialMiner.getTutorial(tutorial, UncivGame.Current.settings.language) tutorialRender.showTutorial(TutorialForRender(tutorial, texts)) { diff --git a/core/src/com/unciv/ui/tutorials/TutorialMiner.kt b/core/src/com/unciv/ui/tutorials/TutorialMiner.kt index 2511546fae..4655179aad 100644 --- a/core/src/com/unciv/ui/tutorials/TutorialMiner.kt +++ b/core/src/com/unciv/ui/tutorials/TutorialMiner.kt @@ -2,22 +2,34 @@ package com.unciv.ui.tutorials import com.badlogic.gdx.Gdx import com.badlogic.gdx.utils.Array -import com.unciv.UncivGame +import com.unciv.JsonParser import com.unciv.models.Tutorial -class TutorialMiner { +class TutorialMiner(private val jsonParser: JsonParser) { companion object { private const val TUTORIALS_PATH = "jsons/Tutorials/Tutorials_%s.json" } - fun getAllTutorials(language: String): Map> { + fun getCivilopediaTutorials(language: String): Map> = + getAllTutorials(language).filter { it.key.isCivilopedia } + + fun getTutorial(tutorial: Tutorial, language: String): List { + val tutors = getAllTutorials(language)[tutorial] + if (tutors != null) { + return tutors + } else { + return emptyList() + } + } + + private fun getAllTutorials(language: String): Map> { val path = TUTORIALS_PATH.format(language) if (!Gdx.files.internal(path).exists()) return emptyMap() // ...Yes. Disgusting. I wish I didn't have to do this. val x = LinkedHashMap>>() - val tutorials: LinkedHashMap>> = UncivGame.Current.ruleset.getFromJson(x.javaClass, path) + val tutorials: LinkedHashMap>> = jsonParser.getFromJson(x.javaClass, path) val tutorialMap = mutableMapOf>() for (tutorial in tutorials) { @@ -25,10 +37,4 @@ class TutorialMiner { } return tutorialMap } - - fun getCivilopediaTutorials(language: String): Map> = - getAllTutorials(language).filter { !it.key.name.startsWith("_") } - - fun getTutorial(tutorial: Tutorial, language: String): List = - getAllTutorials(language)[tutorial] ?: emptyList() } \ No newline at end of file diff --git a/core/src/com/unciv/ui/utils/CameraStageBaseScreen.kt b/core/src/com/unciv/ui/utils/CameraStageBaseScreen.kt index 36154b8b4c..8a20afa0ac 100644 --- a/core/src/com/unciv/ui/utils/CameraStageBaseScreen.kt +++ b/core/src/com/unciv/ui/utils/CameraStageBaseScreen.kt @@ -7,10 +7,24 @@ import com.badlogic.gdx.graphics.Color import com.badlogic.gdx.graphics.GL20 import com.badlogic.gdx.graphics.g2d.Batch import com.badlogic.gdx.graphics.g2d.SpriteBatch -import com.badlogic.gdx.scenes.scene2d.* -import com.badlogic.gdx.scenes.scene2d.ui.* +import com.badlogic.gdx.scenes.scene2d.Actor +import com.badlogic.gdx.scenes.scene2d.InputEvent +import com.badlogic.gdx.scenes.scene2d.InputListener +import com.badlogic.gdx.scenes.scene2d.Stage +import com.badlogic.gdx.scenes.scene2d.Touchable +import com.badlogic.gdx.scenes.scene2d.ui.Button +import com.badlogic.gdx.scenes.scene2d.ui.Cell +import com.badlogic.gdx.scenes.scene2d.ui.CheckBox +import com.badlogic.gdx.scenes.scene2d.ui.Image +import com.badlogic.gdx.scenes.scene2d.ui.Label +import com.badlogic.gdx.scenes.scene2d.ui.SelectBox +import com.badlogic.gdx.scenes.scene2d.ui.Skin +import com.badlogic.gdx.scenes.scene2d.ui.Table +import com.badlogic.gdx.scenes.scene2d.ui.TextButton +import com.badlogic.gdx.scenes.scene2d.ui.TextField import com.badlogic.gdx.scenes.scene2d.utils.ClickListener import com.badlogic.gdx.utils.viewport.ExtendViewport +import com.unciv.JsonParser import com.unciv.UncivGame import com.unciv.models.Tutorial import com.unciv.models.translations.tr @@ -26,7 +40,9 @@ open class CameraStageBaseScreen : Screen { var stage: Stage var hasPopupOpen = false - private var tutorialController: TutorialController? = null + val tutorialController by lazy { + TutorialController(TutorialMiner(JsonParser()), TutorialRender(this)) + } init { val width:Float @@ -40,10 +56,8 @@ open class CameraStageBaseScreen : Screen { height = resolutions[1] stage = Stage(ExtendViewport(width, height), batch) - } - override fun show() {} override fun render(delta: Float) { @@ -67,14 +81,11 @@ open class CameraStageBaseScreen : Screen { override fun dispose() {} fun displayTutorial(tutorial: Tutorial) { - if (tutorialController == null) { - tutorialController = TutorialController(TutorialMiner(), TutorialRender(this)) - } - tutorialController?.showTutorial(tutorial) + tutorialController.showTutorial(tutorial) } fun hasVisibleDialogs(): Boolean = - tutorialController?.isTutorialShowing() == true || stage.actors.any { it is TradePopup } || hasPopupOpen + tutorialController.isTutorialShowing() || stage.actors.any { it is TradePopup } || hasPopupOpen companion object { var skin = Skin(Gdx.files.internal("skin/flat-earth-ui.json")) diff --git a/core/src/com/unciv/ui/worldscreen/WorldScreen.kt b/core/src/com/unciv/ui/worldscreen/WorldScreen.kt index f1626c43b2..330f262ff2 100644 --- a/core/src/com/unciv/ui/worldscreen/WorldScreen.kt +++ b/core/src/com/unciv/ui/worldscreen/WorldScreen.kt @@ -25,7 +25,15 @@ import com.unciv.ui.pickerscreens.PolicyPickerScreen import com.unciv.ui.pickerscreens.TechButton import com.unciv.ui.pickerscreens.TechPickerScreen import com.unciv.ui.trade.DiplomacyScreen -import com.unciv.ui.utils.* +import com.unciv.ui.utils.CameraStageBaseScreen +import com.unciv.ui.utils.ImageGetter +import com.unciv.ui.utils.centerX +import com.unciv.ui.utils.colorFromRGB +import com.unciv.ui.utils.disable +import com.unciv.ui.utils.enable +import com.unciv.ui.utils.onClick +import com.unciv.ui.utils.setFontSize +import com.unciv.ui.utils.toLabel import com.unciv.ui.worldscreen.bottombar.BattleTable import com.unciv.ui.worldscreen.bottombar.TileInfoTable import com.unciv.ui.worldscreen.optionstable.OnlineMultiplayer @@ -121,12 +129,16 @@ class WorldScreen(val viewingCiv:CivilizationInfo) : CameraStageBaseScreen() { }, Actions.delay(10f)))) // delay is in seconds } + tutorialController.allTutorialsShowedCallback = { + shouldUpdate = true + } + // don't run update() directly, because the UncivGame.worldScreen should be set so that the city buttons and tile groups // know what the viewing civ is. - shouldUpdate=true + shouldUpdate = true } - fun loadLatestMultiplayerState(){ + private fun loadLatestMultiplayerState(){ val loadingGamePopup = PopupTable(this) loadingGamePopup.add("Loading latest game state...") loadingGamePopup.open() @@ -430,7 +442,7 @@ class WorldScreen(val viewingCiv:CivilizationInfo) : CameraStageBaseScreen() { } } - fun updateNextTurnButton(isSomethingOpen: Boolean) { + private fun updateNextTurnButton(isSomethingOpen: Boolean) { val text = when { !isPlayersTurn -> "Waiting for other players..." viewingCiv.shouldGoToDueUnit() -> "Next unit" diff --git a/tests/src/com/unciv/testing/TranslationTests.kt b/tests/src/com/unciv/testing/TranslationTests.kt index bbc7b40d4a..e5a0531882 100644 --- a/tests/src/com/unciv/testing/TranslationTests.kt +++ b/tests/src/com/unciv/testing/TranslationTests.kt @@ -3,6 +3,7 @@ package com.unciv.testing import com.badlogic.gdx.Gdx import com.badlogic.gdx.utils.Array +import com.unciv.JsonParser import com.unciv.models.ruleset.Nation import com.unciv.models.ruleset.Ruleset import com.unciv.models.translations.Translations @@ -10,12 +11,13 @@ import org.junit.Assert import org.junit.Before import org.junit.Test import org.junit.runner.RunWith -import java.util.* +import java.util.HashSet @RunWith(GdxTestRunner::class) class TranslationTests { - var translations = Translations() - var ruleSet = Ruleset(true) + private var translations = Translations() + private var ruleSet = Ruleset(true) + private val jsonParser = JsonParser() @Before fun loadTranslations() { @@ -39,8 +41,8 @@ class TranslationTests { fun allUnitUniquesHaveTranslation() { val strings: MutableSet = HashSet() for (unit in ruleSet.units.values) for (unique in unit.uniques) if (!unique.startsWith("Bonus") - && !unique.startsWith("Penalty") - && !unique.contains("[")) // templates + && !unique.startsWith("Penalty") + && !unique.contains("[")) // templates strings.add(unique) val allStringsHaveTranslation = allStringAreTranslated(strings) Assert.assertTrue(allStringsHaveTranslation) @@ -151,7 +153,7 @@ class TranslationTests { @Test fun allTranslatedNationsFilesAreSerializable() { for (file in Gdx.files.internal("jsons/Nations").list()) { - ruleSet.getFromJson(Array().javaClass, file.path()) + jsonParser.getFromJson(Array().javaClass, file.path()) } Assert.assertTrue("This test will only pass when there is a translation for all promotions", true) @@ -167,18 +169,16 @@ class TranslationTests { val placeholders = placeholderPattern.findAll(key).map { it.value }.toList() for (language in languages) { placeholders.forEach { placeholder -> - if(!translations.get(key, language).contains(placeholder)) { + if (!translations.get(key, language).contains(placeholder)) { allTranslationsHaveCorrectPlaceholders = false println("Placeholder `$placeholder` not found in `$language` for key `$key`") } } - } } Assert.assertTrue( - "This test will only pass when all translations' placeholders match those of the key", - allTranslationsHaveCorrectPlaceholders + "This test will only pass when all translations' placeholders match those of the key", + allTranslationsHaveCorrectPlaceholders ) } - } \ No newline at end of file diff --git a/tests/src/com/unciv/testing/TutorialMinerTests.kt b/tests/src/com/unciv/testing/TutorialMinerTests.kt new file mode 100644 index 0000000000..d47df85c96 --- /dev/null +++ b/tests/src/com/unciv/testing/TutorialMinerTests.kt @@ -0,0 +1,34 @@ +package com.unciv.testing + +import com.unciv.JsonParser +import com.unciv.models.Tutorial +import com.unciv.ui.tutorials.TutorialMiner +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(GdxTestRunner::class) +class TutorialMinerTests { + + private val languages = listOf( + "English", "Czech", "French", "Italian", + "Korean", "Polish", "Ukrainian", "Russian", + "Simplified_Chinese", "Traditional_Chinese" + ) + private val jsonParser = JsonParser() + private val tutorialMiner = TutorialMiner(jsonParser) + + @Test + fun getCivilopediaTutorials() { + // GIVEN + val expectedTutorKeys = Tutorial.values().filter { it.isCivilopedia }.map { it.value } + + // WHEN + val result = languages.map { it to tutorialMiner.getCivilopediaTutorials(it).map { it.key.value } } + + // THEN + result.forEach { (language, keys) -> + assertTrue("$language civilopedia does not match", keys.containsAll(expectedTutorKeys)) + } + } +} \ No newline at end of file diff --git a/tests/src/com/unciv/testing/TutorialTranslationTests.kt b/tests/src/com/unciv/testing/TutorialTranslationTests.kt index 2585caef0a..8f248ef310 100644 --- a/tests/src/com/unciv/testing/TutorialTranslationTests.kt +++ b/tests/src/com/unciv/testing/TutorialTranslationTests.kt @@ -24,7 +24,7 @@ class TutorialTranslationTests { @Test fun testValidNumberOfTranslationTutorials() { - languages.forEach { language -> + for (language in languages) { val keys = getKeysForLanguage(language) assertTrue("$language tutorial does not match", keys.size == tutorialCount) }