From 38b9b13a0a45438369cbaa3237d3df1cf0f4451a Mon Sep 17 00:00:00 2001 From: Yair Morgenstern Date: Fri, 6 Dec 2019 13:59:12 +0200 Subject: [PATCH] Ruleset should have a lower-case s, because it's not, you know, a Set Also, Rulesets can now read rules from any json folder --- core/src/com/unciv/UncivGame.kt | 6 +-- core/src/com/unciv/logic/GameInfo.kt | 2 +- core/src/com/unciv/logic/GameStarter.kt | 10 ++-- .../logic/civilization/CivilizationInfo.kt | 5 +- core/src/com/unciv/logic/map/MapGenerator.kt | 40 +++++++------- core/src/com/unciv/logic/map/MapUnit.kt | 6 +-- core/src/com/unciv/logic/map/RoadStatus.kt | 4 +- core/src/com/unciv/logic/map/TileInfo.kt | 14 ++--- core/src/com/unciv/logic/map/TileMap.kt | 10 ++-- .../com/unciv/models/gamebasics/Building.kt | 12 ++--- .../gamebasics/{RuleSet.kt => Ruleset.kt} | 49 ++++++++++++----- .../unciv/models/gamebasics/Translations.kt | 4 +- .../models/gamebasics/tech/Technology.kt | 14 ++--- .../unciv/models/gamebasics/tile/Terrain.kt | 6 +-- .../models/gamebasics/tile/TileImprovement.kt | 6 +-- .../unciv/models/gamebasics/unit/BaseUnit.kt | 6 +-- core/src/com/unciv/ui/CivilopediaScreen.kt | 34 ++++++------ core/src/com/unciv/ui/LanguagePickerScreen.kt | 8 +-- .../com/unciv/ui/mapeditor/MapEditorScreen.kt | 2 +- .../ui/mapeditor/TileEditorOptionsTable.kt | 4 +- .../com/unciv/ui/newgamescreen/NationTable.kt | 32 +++++------ .../unciv/ui/newgamescreen/NewGameScreen.kt | 3 +- .../NewGameScreenOptionsTable.kt | 53 +++++++++++++++++-- .../ui/newgamescreen/PlayerPickerTable.kt | 4 +- core/src/com/unciv/ui/utils/Fonts.kt | 2 +- core/src/com/unciv/ui/utils/ImageGetter.kt | 2 +- core/src/com/unciv/ui/utils/Tutorials.kt | 5 +- .../optionstable/WorldScreenOptionsTable.kt | 8 +-- .../gdxtesting/examples/BasicTests.java | 4 +- .../gdxtesting/examples/TranslationTests.java | 20 +++---- 30 files changed, 225 insertions(+), 150 deletions(-) rename core/src/com/unciv/models/gamebasics/{RuleSet.kt => Ruleset.kt} (74%) diff --git a/core/src/com/unciv/UncivGame.kt b/core/src/com/unciv/UncivGame.kt index 84dcbdf246..bb90d2c994 100644 --- a/core/src/com/unciv/UncivGame.kt +++ b/core/src/com/unciv/UncivGame.kt @@ -8,7 +8,7 @@ import com.badlogic.gdx.audio.Music import com.unciv.logic.GameInfo import com.unciv.logic.GameSaver import com.unciv.logic.GameStarter -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.metadata.GameParameters import com.unciv.models.metadata.GameSettings import com.unciv.ui.LanguagePickerScreen @@ -36,11 +36,11 @@ class UncivGame(val version: String) : Game() { val musicLocation = "music/thatched-villagers.mp3" var isInitialized=false - lateinit var ruleSet:RuleSet + lateinit var ruleset:Ruleset override fun create() { Current = this - ruleSet = RuleSet() + ruleset = Ruleset(true) if(Gdx.app.type!= Application.ApplicationType.Desktop) viewEntireMapForDebug=false diff --git a/core/src/com/unciv/logic/GameInfo.kt b/core/src/com/unciv/logic/GameInfo.kt index 713b638a93..294f5eff97 100644 --- a/core/src/com/unciv/logic/GameInfo.kt +++ b/core/src/com/unciv/logic/GameInfo.kt @@ -20,7 +20,7 @@ class GameInfo { /** This is used in multiplayer games, where I may have a saved game state on my phone * that is inconsistent with the saved game on the cloud */ @Transient var isUpToDate=false - @Transient var ruleSet = UncivGame.Current.ruleSet + @Transient var ruleSet = UncivGame.Current.ruleset var civilizations = mutableListOf() var difficulty="Chieftain" // difficulty is game-wide, think what would happen if 2 human players could play on different difficulties? diff --git a/core/src/com/unciv/logic/GameStarter.kt b/core/src/com/unciv/logic/GameStarter.kt index 14286173ae..2235f3b688 100644 --- a/core/src/com/unciv/logic/GameStarter.kt +++ b/core/src/com/unciv/logic/GameStarter.kt @@ -5,7 +5,7 @@ import com.unciv.Constants import com.unciv.UncivGame import com.unciv.logic.civilization.CivilizationInfo import com.unciv.logic.map.* -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.metadata.GameParameters import java.util.* import kotlin.collections.ArrayList @@ -17,7 +17,7 @@ class GameStarter{ val gameInfo = GameInfo() gameInfo.gameParameters = newGameParameters - val gameBasics = UncivGame.Current.ruleSet + val gameBasics = UncivGame.Current.ruleset if(newGameParameters.mapType==MapType.file) gameInfo.tileMap = MapSaver().loadMap(newGameParameters.mapFileName!!) @@ -54,9 +54,9 @@ class GameStarter{ return gameInfo } - private fun addCivilizations(newGameParameters: GameParameters, gameInfo: GameInfo, ruleSet: RuleSet) { + private fun addCivilizations(newGameParameters: GameParameters, gameInfo: GameInfo, ruleset: Ruleset) { val availableCivNames = Stack() - availableCivNames.addAll(ruleSet.Nations.filter { !it.value.isCityState() }.keys.shuffled()) + availableCivNames.addAll(ruleset.Nations.filter { !it.value.isCityState() }.keys.shuffled()) availableCivNames.removeAll(newGameParameters.players.map { it.chosenCiv }) availableCivNames.remove("Barbarians") @@ -82,7 +82,7 @@ class GameStarter{ val availableCityStatesNames = Stack() // since we shuffle and then order by, we end up with all the city states with starting tiles first in a random order, // and then all the other city states in a random order! Because the sortedBy function is stable! - availableCityStatesNames.addAll(ruleSet.Nations.filter { it.value.isCityState() }.keys + availableCityStatesNames.addAll(ruleset.Nations.filter { it.value.isCityState() }.keys .shuffled().sortedByDescending { it in cityStatesWithStartingLocations }) for (cityStateName in availableCityStatesNames.take(newGameParameters.numberOfCityStates)) { diff --git a/core/src/com/unciv/logic/civilization/CivilizationInfo.kt b/core/src/com/unciv/logic/civilization/CivilizationInfo.kt index c207b126ce..97f32ae799 100644 --- a/core/src/com/unciv/logic/civilization/CivilizationInfo.kt +++ b/core/src/com/unciv/logic/civilization/CivilizationInfo.kt @@ -112,8 +112,9 @@ class CivilizationInfo { fun getTranslatedNation(): Nation { val language = UncivGame.Current.settings.language.replace(" ","_") - if(!Gdx.files.internal("jsons/Nations/Nations_$language.json").exists()) return nation - val translatedNation = gameInfo.ruleSet.getFromJson(Array::class.java, "Nations/Nations_$language") + val filePath = "jsons/Nations/Nations_$language.json" + if(!Gdx.files.internal(filePath).exists()) return nation + val translatedNation = gameInfo.ruleSet.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/logic/map/MapGenerator.kt b/core/src/com/unciv/logic/map/MapGenerator.kt index 5fdf53b9d9..a40fae5e3c 100644 --- a/core/src/com/unciv/logic/map/MapGenerator.kt +++ b/core/src/com/unciv/logic/map/MapGenerator.kt @@ -4,7 +4,7 @@ import com.badlogic.gdx.math.Vector2 import com.unciv.Constants import com.unciv.logic.HexMath import com.unciv.models.Counter -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tile.ResourceType import com.unciv.models.gamebasics.tile.TerrainType import com.unciv.models.metadata.GameParameters @@ -27,26 +27,26 @@ class MapType { class MapGenerator { - fun generateMap(gameParameters: GameParameters, ruleSet: RuleSet): TileMap { + fun generateMap(gameParameters: GameParameters, ruleset: Ruleset): TileMap { val mapRadius = gameParameters.mapRadius val mapType = gameParameters.mapType - val map = TileMap(mapRadius, ruleSet) + val map = TileMap(mapRadius, ruleset) // Step one - separate land and water, in form of Grasslands and Oceans if (mapType == MapType.perlin) MapLandmassGenerator().generateLandPerlin(map) else MapLandmassGenerator().generateLandCellularAutomata(map, mapRadius, mapType) - divideIntoBiomes(map, 6, 0.05f, mapRadius, ruleSet) + divideIntoBiomes(map, 6, 0.05f, mapRadius, ruleset) for (tile in map.values) tile.setTransients() setWaterTiles(map) - for (tile in map.values) randomizeTile(tile, gameParameters, ruleSet) + for (tile in map.values) randomizeTile(tile, gameParameters, ruleset) - randomizeResources(map, mapRadius, ruleSet) + randomizeResources(map, mapRadius, ruleset) return map } @@ -93,12 +93,12 @@ class MapGenerator { } } - fun randomizeTile(tileInfo: TileInfo, gameParameters: GameParameters, ruleSet: RuleSet) { + fun randomizeTile(tileInfo: TileInfo, gameParameters: GameParameters, ruleset: Ruleset) { if (tileInfo.getBaseTerrain().type == TerrainType.Land && Math.random() < 0.05f) { tileInfo.baseTerrain = Constants.mountain tileInfo.setTransients() } - addRandomTerrainFeature(tileInfo, ruleSet) + addRandomTerrainFeature(tileInfo, ruleset) maybeAddAncientRuins(tileInfo, gameParameters) } @@ -106,10 +106,10 @@ class MapGenerator { return (sin(3.1416 / 3) * vector.y).toFloat() } - fun divideIntoBiomes(map: TileMap, averageTilesPerArea: Int, waterPercent: Float, distance: Int, ruleSet: RuleSet) { + fun divideIntoBiomes(map: TileMap, averageTilesPerArea: Int, waterPercent: Float, distance: Int, ruleset: Ruleset) { val areas = ArrayList() - val terrains = ruleSet.Terrains.values + val terrains = ruleset.Terrains.values .filter { it.type === TerrainType.Land && it.name != Constants.lakes && it.name != Constants.mountain } for (tile in map.values.filter { it.baseTerrain == Constants.grassland }) tile.baseTerrain = "" // So we know it's not chosen @@ -184,9 +184,9 @@ class MapGenerator { } - fun addRandomTerrainFeature(tileInfo: TileInfo, ruleSet: RuleSet) { + fun addRandomTerrainFeature(tileInfo: TileInfo, ruleset: Ruleset) { if (tileInfo.getBaseTerrain().canHaveOverlay && Math.random() > 0.7f) { - val secondaryTerrains = ruleSet.Terrains.values + val secondaryTerrains = ruleset.Terrains.values .filter { it.type === TerrainType.TerrainFeature && it.occursOn != null && it.occursOn.contains(tileInfo.baseTerrain) } if (secondaryTerrains.any()) tileInfo.terrainFeature = secondaryTerrains.random().name } @@ -200,19 +200,19 @@ class MapGenerator { } - fun randomizeResources(mapToReturn: TileMap, distance: Int, ruleSet: RuleSet) { + fun randomizeResources(mapToReturn: TileMap, distance: Int, ruleset: Ruleset) { for (tile in mapToReturn.values) if (tile.resource != null) tile.resource = null - randomizeStrategicResources(mapToReturn, distance, ruleSet) - randomizeResource(mapToReturn, distance, ResourceType.Luxury, ruleSet) - randomizeResource(mapToReturn, distance, ResourceType.Bonus, ruleSet) + randomizeStrategicResources(mapToReturn, distance, ruleset) + randomizeResource(mapToReturn, distance, ResourceType.Luxury, ruleset) + randomizeResource(mapToReturn, distance, ResourceType.Bonus, ruleset) } // Here, we need each specific resource to be spread over the map - it matters less if specific resources are near each other - private fun randomizeStrategicResources(mapToReturn: TileMap, distance: Int, ruleSet: RuleSet) { - val resourcesOfType = ruleSet.TileResources.values.filter { it.resourceType == ResourceType.Strategic } + private fun randomizeStrategicResources(mapToReturn: TileMap, distance: Int, ruleset: Ruleset) { + val resourcesOfType = ruleset.TileResources.values.filter { it.resourceType == ResourceType.Strategic } for (resource in resourcesOfType) { val suitableTiles = mapToReturn.values .filter { it.resource == null && resource.terrainsCanBeFoundOn.contains(it.getLastTerrain().name) } @@ -227,8 +227,8 @@ class MapGenerator { } // Here, we need there to be some luxury/bonus resource - it matters less what - private fun randomizeResource(mapToReturn: TileMap, distance: Int, resourceType: ResourceType, ruleSet: RuleSet) { - val resourcesOfType = ruleSet.TileResources.values.filter { it.resourceType == resourceType } + private fun randomizeResource(mapToReturn: TileMap, distance: Int, resourceType: ResourceType, ruleset: Ruleset) { + val resourcesOfType = ruleset.TileResources.values.filter { it.resourceType == resourceType } val suitableTiles = mapToReturn.values .filter { it.resource == null && resourcesOfType.any { r -> r.terrainsCanBeFoundOn.contains(it.getLastTerrain().name) } } diff --git a/core/src/com/unciv/logic/map/MapUnit.kt b/core/src/com/unciv/logic/map/MapUnit.kt index dbe257c3b4..be9d229a04 100644 --- a/core/src/com/unciv/logic/map/MapUnit.kt +++ b/core/src/com/unciv/logic/map/MapUnit.kt @@ -8,7 +8,7 @@ import com.unciv.logic.automation.WorkerAutomation import com.unciv.logic.civilization.CivilizationInfo import com.unciv.logic.map.action.MapUnitAction import com.unciv.logic.map.action.StringAction -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tech.TechEra import com.unciv.models.gamebasics.tile.TerrainType import com.unciv.models.gamebasics.unit.BaseUnit @@ -265,10 +265,10 @@ class MapUnit { //endregion //region state-changing functions - fun setTransients(ruleSet: RuleSet) { + fun setTransients(ruleset: Ruleset) { promotions.unit=this mapUnitAction?.unit = this - baseUnit=ruleSet.Units[name]!! + baseUnit=ruleset.Units[name]!! updateUniques() } diff --git a/core/src/com/unciv/logic/map/RoadStatus.kt b/core/src/com/unciv/logic/map/RoadStatus.kt index f9d2ba19d9..71e84926e8 100644 --- a/core/src/com/unciv/logic/map/RoadStatus.kt +++ b/core/src/com/unciv/logic/map/RoadStatus.kt @@ -2,7 +2,7 @@ package com.unciv.logic.map import com.unciv.logic.map.RoadStatus.Railroad import com.unciv.logic.map.RoadStatus.Road -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset /** * You can use RoadStatus.name to identify [Road] and [Railroad] @@ -15,6 +15,6 @@ enum class RoadStatus { Railroad; /** returns null for [None] */ - fun improvement(ruleSet: RuleSet) = ruleSet.TileImprovements[this.name] + fun improvement(ruleset: Ruleset) = ruleset.TileImprovements[this.name] } diff --git a/core/src/com/unciv/logic/map/TileInfo.kt b/core/src/com/unciv/logic/map/TileInfo.kt index 7da59194e0..adad4ffb24 100644 --- a/core/src/com/unciv/logic/map/TileInfo.kt +++ b/core/src/com/unciv/logic/map/TileInfo.kt @@ -5,7 +5,7 @@ import com.unciv.Constants import com.unciv.UncivGame import com.unciv.logic.city.CityInfo import com.unciv.logic.civilization.CivilizationInfo -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tile.* import com.unciv.models.gamebasics.tr import com.unciv.models.stats.Stats @@ -13,7 +13,7 @@ import kotlin.math.abs open class TileInfo { @Transient lateinit var tileMap: TileMap - @Transient lateinit var ruleSet: RuleSet // a tile can be a tile with a ruleset, even without a map. + @Transient lateinit var ruleset: Ruleset // a tile can be a tile with a ruleset, even without a map. @Transient var owningCity:CityInfo?=null @Transient private lateinit var baseTerrainObject:Terrain @@ -85,11 +85,11 @@ open class TileInfo { fun getTileResource(): TileResource = if (resource == null) throw Exception("No resource exists for this tile!") - else ruleSet.TileResources[resource!!]!! + else ruleset.TileResources[resource!!]!! fun isCityCenter(): Boolean = getCity()?.location == position - fun getTileImprovement(): TileImprovement? = if (improvement == null) null else ruleSet.TileImprovements[improvement!!] + fun getTileImprovement(): TileImprovement? = if (improvement == null) null else ruleset.TileImprovements[improvement!!] // This is for performance - since we access the neighbors of a tile ALL THE TIME, @@ -118,7 +118,7 @@ open class TileInfo { } fun getTerrainFeature(): Terrain? { - return if (terrainFeature == null) null else ruleSet.Terrains[terrainFeature!!] + return if (terrainFeature == null) null else ruleset.Terrains[terrainFeature!!] } fun isWorked(): Boolean { @@ -310,7 +310,7 @@ open class TileInfo { //region state-changing functions fun setTransients(){ - baseTerrainObject = ruleSet.Terrains[baseTerrain]!! // This is a HACK. + baseTerrainObject = ruleset.Terrains[baseTerrain]!! // This is a HACK. isWater = getBaseTerrain().type==TerrainType.Water isLand = getBaseTerrain().type==TerrainType.Land isOcean = baseTerrain == Constants.ocean @@ -318,7 +318,7 @@ open class TileInfo { for (unit in getUnits()) { unit.currentTile = this unit.assignOwner(tileMap.gameInfo.getCivilization(unit.owner),false) - unit.setTransients(ruleSet) + unit.setTransients(ruleset) } } diff --git a/core/src/com/unciv/logic/map/TileMap.kt b/core/src/com/unciv/logic/map/TileMap.kt index 05bd0a958a..e024386b9e 100644 --- a/core/src/com/unciv/logic/map/TileMap.kt +++ b/core/src/com/unciv/logic/map/TileMap.kt @@ -5,7 +5,7 @@ import com.unciv.Constants import com.unciv.logic.GameInfo import com.unciv.logic.HexMath import com.unciv.logic.civilization.CivilizationInfo -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset class TileMap { @@ -32,10 +32,10 @@ class TileMap { - constructor(radius:Int, ruleSet: RuleSet){ + constructor(radius:Int, ruleset: Ruleset){ for(vector in HexMath().getVectorsInDistance(Vector2.Zero, radius)) tileList.add(TileInfo().apply { position = vector; baseTerrain= Constants.grassland }) - setTransients(ruleSet) + setTransients(ruleset) } @@ -146,7 +146,7 @@ class TileMap { return viewableTiles } - fun setTransients(ruleSet: RuleSet) { + fun setTransients(ruleset: Ruleset) { if(tiles.any()) tileList.addAll(tiles.values) @@ -164,7 +164,7 @@ class TileMap { for (tileInfo in values){ tileMatrix[tileInfo.position.x.toInt()-leftX][tileInfo.position.y.toInt()-bottomY] = tileInfo tileInfo.tileMap = this - tileInfo.ruleSet = ruleSet + tileInfo.ruleset = ruleset tileInfo.setTransients() } } diff --git a/core/src/com/unciv/models/gamebasics/Building.kt b/core/src/com/unciv/models/gamebasics/Building.kt index c65d5d4afd..f7ade4c31c 100644 --- a/core/src/com/unciv/models/gamebasics/Building.kt +++ b/core/src/com/unciv/models/gamebasics/Building.kt @@ -45,14 +45,14 @@ class Building : NamedStats(), IConstruction{ var resourceBonusStats: Stats? = null - fun getShortDescription(ruleSet: RuleSet): String { // should fit in one line + fun getShortDescription(ruleset: Ruleset): String { // should fit in one line val infoList= mutableListOf() val str = getStats(null).toString() if(str.isNotEmpty()) infoList += str for(stat in getStatPercentageBonuses(null).toHashMap()) if(stat.value!=0f) infoList+="+${stat.value.toInt()}% ${stat.key.toString().tr()}" - val improvedResources = ruleSet.TileResources.values.filter { it.building==name }.map { it.name.tr() } + val improvedResources = ruleset.TileResources.values.filter { it.building==name }.map { it.name.tr() } if(improvedResources.isNotEmpty()){ // buildings that improve resources infoList += improvedResources.joinToString()+ " {provide} ".tr()+ resourceBonusStats.toString() @@ -66,7 +66,7 @@ class Building : NamedStats(), IConstruction{ return infoList.joinToString() } - fun getDescription(forBuildingPickerScreen: Boolean, civInfo: CivilizationInfo?, ruleSet: RuleSet): String { + fun getDescription(forBuildingPickerScreen: Boolean, civInfo: CivilizationInfo?, ruleset: Ruleset): String { val stats = getStats(civInfo) val stringBuilder = StringBuilder() if(uniqueTo!=null) stringBuilder.appendln("Unique to [$uniqueTo], replaces [$replaces]".tr()) @@ -102,7 +102,7 @@ class Building : NamedStats(), IConstruction{ if (gpp.culture != 0f) stringBuilder.appendln("+" + gpp.culture.toInt() + " "+"[Great Artist] points".tr()) } if (resourceBonusStats != null) { - val resources = ruleSet.TileResources.values.filter { name == it.building }.joinToString { it.name.tr() } + val resources = ruleset.TileResources.values.filter { name == it.building }.joinToString { it.name.tr() } stringBuilder.appendln("$resources {provide} $resourceBonusStats".tr()) } @@ -367,8 +367,8 @@ class Building : NamedStats(), IConstruction{ return false } - fun getBaseBuilding(ruleSet: RuleSet): Building { + fun getBaseBuilding(ruleset: Ruleset): Building { if(replaces==null) return this - else return ruleSet.Buildings[replaces!!]!! + else return ruleset.Buildings[replaces!!]!! } } diff --git a/core/src/com/unciv/models/gamebasics/RuleSet.kt b/core/src/com/unciv/models/gamebasics/Ruleset.kt similarity index 74% rename from core/src/com/unciv/models/gamebasics/RuleSet.kt rename to core/src/com/unciv/models/gamebasics/Ruleset.kt index 96ceb69b5a..561d33e653 100644 --- a/core/src/com/unciv/models/gamebasics/RuleSet.kt +++ b/core/src/com/unciv/models/gamebasics/Ruleset.kt @@ -12,7 +12,7 @@ import com.unciv.models.gamebasics.unit.Promotion import com.unciv.models.stats.INamed import kotlin.collections.set -class RuleSet { +class Ruleset { val Buildings = LinkedHashMap() val Terrains = LinkedHashMap() val TileResources = LinkedHashMap() @@ -25,8 +25,8 @@ class RuleSet { val Difficulties = LinkedHashMap() val Translations = Translations() - fun getFromJson(tClass: Class, name: String): T { - val jsonText = Gdx.files.internal("jsons/$name.json").readString(Charsets.UTF_8.name()) + 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) } @@ -37,10 +37,31 @@ class RuleSet { return hashMap } - init { + fun clone(): Ruleset{ + val newRuleset = Ruleset(false) + newRuleset.Buildings.putAll(Buildings) + newRuleset.Difficulties.putAll(Difficulties) + newRuleset.Nations .putAll(Nations) + newRuleset.PolicyBranches.putAll(PolicyBranches) + newRuleset.Technologies.putAll(Technologies) + newRuleset.Buildings.putAll(Buildings) + newRuleset.Terrains.putAll(Terrains) + newRuleset.TileImprovements.putAll(TileImprovements) + newRuleset.TileResources.putAll(TileResources) + newRuleset.Translations.putAll(Translations) + newRuleset.UnitPromotions.putAll(UnitPromotions) + newRuleset.Units.putAll(Units) + return newRuleset + } + + constructor(load:Boolean=true){ + if(load) load() + } + + fun load(folderPath: String="jsons") { val gameBasicsStartTime = System.currentTimeMillis() - val techColumns = getFromJson(Array::class.java, "Techs") + val techColumns = getFromJson(Array::class.java, "$folderPath/Techs.json") for (techColumn in techColumns) { for (tech in techColumn.techs) { if (tech.cost==0) tech.cost = techColumn.techCost @@ -49,7 +70,7 @@ class RuleSet { } } - Buildings += createHashmap(getFromJson(Array::class.java, "Buildings")) + Buildings += createHashmap(getFromJson(Array::class.java, "$folderPath/Buildings.json")) for (building in Buildings.values) { if (building.requiredTech == null) continue val column = Technologies[building.requiredTech!!]!!.column @@ -57,13 +78,13 @@ class RuleSet { building.cost = if (building.isWonder || building.isNationalWonder) column!!.wonderCost else column!!.buildingCost } - Terrains += createHashmap(getFromJson(Array::class.java, "Terrains")) - TileResources += createHashmap(getFromJson(Array::class.java, "TileResources")) - TileImprovements += createHashmap(getFromJson(Array::class.java, "TileImprovements")) - Units += createHashmap(getFromJson(Array::class.java, "Units")) - UnitPromotions += createHashmap(getFromJson(Array::class.java, "UnitPromotions")) + 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")) - PolicyBranches += createHashmap(getFromJson(Array::class.java, "Policies")) + PolicyBranches += createHashmap(getFromJson(Array::class.java, "$folderPath/Policies.json")) for (branch in PolicyBranches.values) { branch.requires = ArrayList() branch.branch = branch @@ -74,10 +95,10 @@ class RuleSet { branch.policies.last().name = branch.name + " Complete" } - Nations += createHashmap(getFromJson(Array::class.java, "Nations/Nations")) + Nations += createHashmap(getFromJson(Array::class.java, "$folderPath/Nations/Nations.json")) for(nation in Nations.values) nation.setTransients() - Difficulties += createHashmap(getFromJson(Array::class.java, "Difficulties")) + Difficulties += createHashmap(getFromJson(Array::class.java, "$folderPath/Difficulties.json")) val gameBasicsLoadTime = System.currentTimeMillis() - gameBasicsStartTime println("Loading game basics - "+gameBasicsLoadTime+"ms") diff --git a/core/src/com/unciv/models/gamebasics/Translations.kt b/core/src/com/unciv/models/gamebasics/Translations.kt index 6a31fdd0fe..8c46675dbc 100644 --- a/core/src/com/unciv/models/gamebasics/Translations.kt +++ b/core/src/com/unciv/models/gamebasics/Translations.kt @@ -90,7 +90,7 @@ fun String.tr(): String { val translationStringWithSquareBracketsOnly = replace(squareBraceRegex,"[]") - val translationEntry = UncivGame.Current.ruleSet.Translations.values + val translationEntry = UncivGame.Current.ruleset.Translations.values .firstOrNull { translationStringWithSquareBracketsOnly == it.entryWithShortenedSquareBrackets } if(translationEntry==null || @@ -115,6 +115,6 @@ fun String.tr(): String { return Regex("\\{(.*?)\\}").replace(this) { it.groups[1]!!.value.tr() } } - val translation = UncivGame.Current.ruleSet.Translations.get(this, UncivGame.Current.settings.language) // single word + val translation = UncivGame.Current.ruleset.Translations.get(this, UncivGame.Current.settings.language) // single word return translation } diff --git a/core/src/com/unciv/models/gamebasics/tech/Technology.kt b/core/src/com/unciv/models/gamebasics/tech/Technology.kt index 10384c1604..786fa5e678 100644 --- a/core/src/com/unciv/models/gamebasics/tech/Technology.kt +++ b/core/src/com/unciv/models/gamebasics/tech/Technology.kt @@ -3,7 +3,7 @@ package com.unciv.models.gamebasics.tech import com.unciv.UncivGame import com.unciv.logic.civilization.CivilizationInfo import com.unciv.models.gamebasics.Building -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.models.gamebasics.unit.BaseUnit import java.util.* @@ -20,11 +20,11 @@ class Technology { var row: Int = 0 var quote="" - fun getDescription(ruleSet: RuleSet): String { + fun getDescription(ruleset: Ruleset): String { val lineList = ArrayList() // more readable than StringBuilder, with same performance for our use-case for (unique in uniques) lineList += unique.tr() - val improvedImprovements = ruleSet.TileImprovements.values + val improvedImprovements = ruleset.TileImprovements.values .filter { it.improvingTech == name }.groupBy { it.improvingTechStats.toString() } for (improvement in improvedImprovements) { val impimpString = improvement.value.joinToString { it.name.tr() } + @@ -46,20 +46,20 @@ class Technology { if (regularBuildings.isNotEmpty()) { lineList += "{Buildings enabled}: " for (building in regularBuildings) - lineList += "* " + building.name.tr() + " (" + building.getShortDescription(ruleSet) + ")" + lineList += "* " + building.name.tr() + " (" + building.getShortDescription(ruleset) + ")" } val wonders = enabledBuildings.filter { it.isWonder || it.isNationalWonder } if (wonders.isNotEmpty()) { lineList += "{Wonders enabled}: " for (wonder in wonders) - lineList += " * " + wonder.name.tr() + " (" + wonder.getShortDescription(ruleSet) + ")" + lineList += " * " + wonder.name.tr() + " (" + wonder.getShortDescription(ruleset) + ")" } - val revealedResource = ruleSet.TileResources.values.filter { it.revealedBy == name }.map { it.name }.firstOrNull() // can only be one + val revealedResource = ruleset.TileResources.values.filter { it.revealedBy == name }.map { it.name }.firstOrNull() // can only be one if (revealedResource != null) lineList += "Reveals [$revealedResource] on the map".tr() - val tileImprovements = ruleSet.TileImprovements.values.filter { it.techRequired == name } + val tileImprovements = ruleset.TileImprovements.values.filter { it.techRequired == name } if (tileImprovements.isNotEmpty()) lineList += "{Tile improvements enabled}: " + tileImprovements.joinToString { it.name.tr() } diff --git a/core/src/com/unciv/models/gamebasics/tile/Terrain.kt b/core/src/com/unciv/models/gamebasics/tile/Terrain.kt index 45e3195277..506c466111 100644 --- a/core/src/com/unciv/models/gamebasics/tile/Terrain.kt +++ b/core/src/com/unciv/models/gamebasics/tile/Terrain.kt @@ -1,19 +1,19 @@ package com.unciv.models.gamebasics.tile import com.badlogic.gdx.graphics.Color -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.models.stats.NamedStats import com.unciv.ui.utils.colorFromRGB class Terrain : NamedStats() { - fun getDescription(ruleSet: RuleSet): String { + fun getDescription(ruleset: Ruleset): String { val sb = StringBuilder() sb.appendln(this.clone().toString()) if (occursOn != null) { sb.appendln("Occurs on [${occursOn.joinToString(", ")}]".tr()) } - val resourcesFound = ruleSet.TileResources.values.filter { it.terrainsCanBeFoundOn.contains(name) } + val resourcesFound = ruleset.TileResources.values.filter { it.terrainsCanBeFoundOn.contains(name) } if (resourcesFound.isNotEmpty()) { sb.appendln("May contain [${resourcesFound.joinToString(", ") { it.name.tr() }}]".tr()) } diff --git a/core/src/com/unciv/models/gamebasics/tile/TileImprovement.kt b/core/src/com/unciv/models/gamebasics/tile/TileImprovement.kt index 427adf377a..ddddb3c50d 100644 --- a/core/src/com/unciv/models/gamebasics/tile/TileImprovement.kt +++ b/core/src/com/unciv/models/gamebasics/tile/TileImprovement.kt @@ -1,7 +1,7 @@ package com.unciv.models.gamebasics.tile import com.unciv.logic.civilization.CivilizationInfo -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.models.stats.NamedStats import com.unciv.models.stats.Stats @@ -30,7 +30,7 @@ class TileImprovement : NamedStats() { return realTurnsToBuild.roundToInt() } - fun getDescription(ruleSet: RuleSet): String { + fun getDescription(ruleset: Ruleset): String { val stringBuilder = StringBuilder() if (this.clone().toString().isNotEmpty()) stringBuilder.appendln(this.clone().toString()) if (!terrainsCanBeBuiltOn.isEmpty()) { @@ -41,7 +41,7 @@ class TileImprovement : NamedStats() { stringBuilder.appendln("Can be built on ".tr() + terrainsCanBeBuiltOnString.joinToString(", "))//language can be changed when setting changes. } val statsToResourceNames = HashMap>() - for (tr: TileResource in ruleSet.TileResources.values.filter { it.improvement == name }) { + for (tr: TileResource in ruleset.TileResources.values.filter { it.improvement == name }) { val statsString = tr.improvementStats.toString() if (!statsToResourceNames.containsKey(statsString)) statsToResourceNames[statsString] = ArrayList() diff --git a/core/src/com/unciv/models/gamebasics/unit/BaseUnit.kt b/core/src/com/unciv/models/gamebasics/unit/BaseUnit.kt index b0fb1960e9..8017115394 100644 --- a/core/src/com/unciv/models/gamebasics/unit/BaseUnit.kt +++ b/core/src/com/unciv/models/gamebasics/unit/BaseUnit.kt @@ -6,7 +6,7 @@ import com.unciv.logic.city.CityConstructions import com.unciv.logic.city.IConstruction import com.unciv.logic.civilization.CivilizationInfo import com.unciv.logic.map.MapUnit -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.Translations import com.unciv.models.gamebasics.tr import com.unciv.models.stats.INamed @@ -78,11 +78,11 @@ class BaseUnit : INamed, IConstruction { return sb.toString() } - fun getMapUnit(ruleSet: RuleSet): MapUnit { + fun getMapUnit(ruleset: Ruleset): MapUnit { val unit = MapUnit() unit.name = name - unit.setTransients(ruleSet) // must be after setting name because it sets the baseUnit according to the name + unit.setTransients(ruleset) // must be after setting name because it sets the baseUnit according to the name return unit } diff --git a/core/src/com/unciv/ui/CivilopediaScreen.kt b/core/src/com/unciv/ui/CivilopediaScreen.kt index 2b5d65d5d2..c9bedd25ee 100644 --- a/core/src/com/unciv/ui/CivilopediaScreen.kt +++ b/core/src/com/unciv/ui/CivilopediaScreen.kt @@ -4,12 +4,12 @@ import com.badlogic.gdx.Gdx import com.badlogic.gdx.scenes.scene2d.Actor import com.badlogic.gdx.scenes.scene2d.ui.* import com.unciv.UncivGame -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.ui.utils.* import java.util.* -class CivilopediaScreen(ruleSet: RuleSet) : CameraStageBaseScreen() { +class CivilopediaScreen(ruleset: Ruleset) : CameraStageBaseScreen() { class CivilopediaEntry { var name: String var description: String @@ -68,26 +68,30 @@ class CivilopediaScreen(ruleSet: RuleSet) : CameraStageBaseScreen() { val language = UncivGame.Current.settings.language.replace(" ","_") - val basicHelpFileName = if(Gdx.files.internal("jsons/BasicHelp/BasicHelp_$language.json").exists())"BasicHelp/BasicHelp_$language" - else "BasicHelp/BasicHelp" + val languageBasicHelpLocation = "jsons/BasicHelp/BasicHelp_$language.json" + val generalBasicHelpLocation = "jsons/BasicHelp/BasicHelp.json" + val basicHelpFileName = + if(Gdx.files.internal(languageBasicHelpLocation).exists()) + languageBasicHelpLocation + else generalBasicHelpLocation - categoryToEntries["Basics"] = ruleSet.getFromJson(Array::class.java, basicHelpFileName).toList() - categoryToEntries["Buildings"] = ruleSet.Buildings.values - .map { CivilopediaEntry(it.name,it.getDescription(false, null,ruleSet), + categoryToEntries["Basics"] = ruleset.getFromJson(Array::class.java, basicHelpFileName).toList() + categoryToEntries["Buildings"] = ruleset.Buildings.values + .map { CivilopediaEntry(it.name,it.getDescription(false, null,ruleset), ImageGetter.getConstructionImage(it.name)) } - categoryToEntries["Resources"] = ruleSet.TileResources.values + categoryToEntries["Resources"] = ruleset.TileResources.values .map { CivilopediaEntry(it.name,it.getDescription(), ImageGetter.getResourceImage(it.name,50f)) } - categoryToEntries["Terrains"] = ruleSet.Terrains.values - .map { CivilopediaEntry(it.name,it.getDescription(ruleSet)) } - categoryToEntries["Tile Improvements"] = ruleSet.TileImprovements.values - .map { CivilopediaEntry(it.name,it.getDescription(ruleSet), + categoryToEntries["Terrains"] = ruleset.Terrains.values + .map { CivilopediaEntry(it.name,it.getDescription(ruleset)) } + categoryToEntries["Tile Improvements"] = ruleset.TileImprovements.values + .map { CivilopediaEntry(it.name,it.getDescription(ruleset), ImageGetter.getImprovementIcon(it.name,50f)) } - categoryToEntries["Units"] = ruleSet.Units.values + categoryToEntries["Units"] = ruleset.Units.values .map { CivilopediaEntry(it.name,it.getDescription(false), ImageGetter.getConstructionImage(it.name)) } - categoryToEntries["Technologies"] = ruleSet.Technologies.values - .map { CivilopediaEntry(it.name,it.getDescription(ruleSet), + categoryToEntries["Technologies"] = ruleset.Technologies.values + .map { CivilopediaEntry(it.name,it.getDescription(ruleset), ImageGetter.getTechIconGroup(it.name,50f)) } categoryToEntries["Tutorials"] = Tutorials().getTutorialsOfLanguage("English").keys diff --git a/core/src/com/unciv/ui/LanguagePickerScreen.kt b/core/src/com/unciv/ui/LanguagePickerScreen.kt index a2824e5cc9..1b35fb0686 100644 --- a/core/src/com/unciv/ui/LanguagePickerScreen.kt +++ b/core/src/com/unciv/ui/LanguagePickerScreen.kt @@ -5,7 +5,7 @@ import com.badlogic.gdx.scenes.scene2d.Touchable import com.badlogic.gdx.scenes.scene2d.ui.Label import com.badlogic.gdx.scenes.scene2d.ui.Table import com.unciv.UncivGame -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.ui.pickerscreens.PickerScreen import com.unciv.ui.utils.ImageGetter @@ -14,7 +14,7 @@ import com.unciv.ui.utils.onClick import com.unciv.ui.utils.toLabel -class LanguageTable(val language:String, ruleSet: RuleSet):Table(){ +class LanguageTable(val language:String, ruleset: Ruleset):Table(){ private val blue = ImageGetter.getBlue() private val darkBlue = blue.cpy().lerp(Color.BLACK,0.5f)!! val percentComplete: Int @@ -24,7 +24,7 @@ class LanguageTable(val language:String, ruleSet: RuleSet):Table(){ defaults().pad(10f) if(ImageGetter.imageExists("FlagIcons/$language")) add(ImageGetter.getImage("FlagIcons/$language")).size(40f) - val translations = ruleSet.Translations + val translations = ruleset.Translations val availableTranslations = translations.filter { it.value.containsKey(language) } if(language=="English") percentComplete = 100 @@ -61,7 +61,7 @@ class LanguagePickerScreen: PickerScreen(){ "If you want to help translating the game into your language, \n"+ " instructions are in the Github readme! (Menu > Community > Github)",skin)).pad(10f).row() - val ruleSet = UncivGame.Current.ruleSet + val ruleSet = UncivGame.Current.ruleset languageTables.addAll(ruleSet.Translations.getLanguages().map { LanguageTable(it,ruleSet) } .sortedByDescending { it.percentComplete } ) diff --git a/core/src/com/unciv/ui/mapeditor/MapEditorScreen.kt b/core/src/com/unciv/ui/mapeditor/MapEditorScreen.kt index 68a5e6b959..4ebb0da67d 100644 --- a/core/src/com/unciv/ui/mapeditor/MapEditorScreen.kt +++ b/core/src/com/unciv/ui/mapeditor/MapEditorScreen.kt @@ -19,7 +19,7 @@ class MapEditorScreen(): CameraStageBaseScreen(){ var mapName = "My first map" lateinit var mapHolder: TileGroupMap private val showHideEditorOptionsButton = TextButton(">",skin) - val ruleSet = UncivGame.Current.ruleSet + val ruleSet = UncivGame.Current.ruleset private val tileEditorOptions = TileEditorOptionsTable(this) constructor(mapNameToLoad:String?):this(){ diff --git a/core/src/com/unciv/ui/mapeditor/TileEditorOptionsTable.kt b/core/src/com/unciv/ui/mapeditor/TileEditorOptionsTable.kt index 0d8e74857e..2f5bad998e 100644 --- a/core/src/com/unciv/ui/mapeditor/TileEditorOptionsTable.kt +++ b/core/src/com/unciv/ui/mapeditor/TileEditorOptionsTable.kt @@ -157,7 +157,7 @@ class TileEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(Camera clearSelection() selectedResource = resource val tileInfo = TileInfo() - tileInfo.ruleSet = mapEditorScreen.ruleSet + tileInfo.ruleset = mapEditorScreen.ruleSet val terrain = resource.terrainsCanBeFoundOn.first() val terrainObject = ruleSet.Terrains[terrain]!! @@ -181,7 +181,7 @@ class TileEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(Camera private fun addTerrainOptions(terrainFeaturesTable: Table, baseTerrainTable: Table) { for (terrain in ruleSet.Terrains.values) { val tileInfo = TileInfo() - tileInfo.ruleSet = mapEditorScreen.ruleSet + tileInfo.ruleset = mapEditorScreen.ruleSet if (terrain.type == TerrainType.TerrainFeature) { tileInfo.baseTerrain = when { terrain.occursOn != null -> terrain.occursOn.first() diff --git a/core/src/com/unciv/ui/newgamescreen/NationTable.kt b/core/src/com/unciv/ui/newgamescreen/NationTable.kt index 805f06c899..ae0421d596 100644 --- a/core/src/com/unciv/ui/newgamescreen/NationTable.kt +++ b/core/src/com/unciv/ui/newgamescreen/NationTable.kt @@ -3,7 +3,7 @@ package com.unciv.ui.newgamescreen import com.badlogic.gdx.scenes.scene2d.Touchable import com.badlogic.gdx.scenes.scene2d.ui.Label import com.badlogic.gdx.scenes.scene2d.ui.Table -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.Nation import com.unciv.models.gamebasics.Translations import com.unciv.models.gamebasics.tr @@ -11,7 +11,7 @@ import com.unciv.ui.utils.CameraStageBaseScreen import com.unciv.ui.utils.ImageGetter import com.unciv.ui.utils.toLabel -class NationTable(val nation: Nation, width:Float, ruleSet: RuleSet) +class NationTable(val nation: Nation, width:Float, ruleset: Ruleset) : Table(CameraStageBaseScreen.skin) { private val innerTable = Table() @@ -25,12 +25,12 @@ class NationTable(val nation: Nation, width:Float, ruleSet: RuleSet) titleTable.add(nation.getLeaderDisplayName().toLabel(nation.getInnerColor(),24)) innerTable.add(titleTable).row() - innerTable.add(getUniqueLabel(nation,ruleSet).apply { setWrap(true) }).width(width) + innerTable.add(getUniqueLabel(nation,ruleset).apply { setWrap(true) }).width(width) touchable = Touchable.enabled add(innerTable) } - private fun getUniqueLabel(nation: Nation, ruleSet: RuleSet): Label { + private fun getUniqueLabel(nation: Nation, ruleset: Ruleset): Label { val textList = ArrayList() if (nation.unique != null) { @@ -38,17 +38,17 @@ class NationTable(val nation: Nation, width:Float, ruleSet: RuleSet) textList += "" } - addUniqueBuildingsText(nation, textList,ruleSet) - addUniqueUnitsText(nation, textList,ruleSet) - addUniqueImprovementsText(nation, textList,ruleSet) + addUniqueBuildingsText(nation, textList,ruleset) + addUniqueUnitsText(nation, textList,ruleset) + addUniqueImprovementsText(nation, textList,ruleset) return textList.joinToString("\n").tr().trim().toLabel(nation.getInnerColor()) } - private fun addUniqueBuildingsText(nation: Nation, textList: ArrayList, ruleSet: RuleSet) { - for (building in ruleSet.Buildings.values + private fun addUniqueBuildingsText(nation: Nation, textList: ArrayList, ruleset: Ruleset) { + for (building in ruleset.Buildings.values .filter { it.uniqueTo == nation.name }) { - val originalBuilding = ruleSet.Buildings[building.replaces!!]!! + val originalBuilding = ruleset.Buildings[building.replaces!!]!! textList += building.name.tr() + " - {replaces} " + originalBuilding.name.tr() val originalBuildingStatMap = originalBuilding.toHashMap() @@ -70,10 +70,10 @@ class NationTable(val nation: Nation, width:Float, ruleSet: RuleSet) } } - private fun addUniqueUnitsText(nation: Nation, textList: ArrayList, ruleSet: RuleSet) { - for (unit in ruleSet.Units.values + private fun addUniqueUnitsText(nation: Nation, textList: ArrayList, ruleset: Ruleset) { + for (unit in ruleset.Units.values .filter { it.uniqueTo == nation.name }) { - val originalUnit = ruleSet.Units[unit.replaces!!]!! + val originalUnit = ruleset.Units[unit.replaces!!]!! textList += unit.name.tr() + " - {replaces} " + originalUnit.name.tr() if (unit.cost != originalUnit.cost) @@ -93,14 +93,14 @@ class NationTable(val nation: Nation, width:Float, ruleSet: RuleSet) for (unique in originalUnit.uniques.filterNot { it in unit.uniques }) textList += " " + "Lost ability".tr() + "(vs " + originalUnit.name.tr() + "): " + Translations.translateBonusOrPenalty(unique) for (promotion in unit.promotions.filter { it !in originalUnit.promotions }) - textList += " " + promotion.tr() + " (" + Translations.translateBonusOrPenalty(ruleSet.UnitPromotions[promotion]!!.effect) + ")" + textList += " " + promotion.tr() + " (" + Translations.translateBonusOrPenalty(ruleset.UnitPromotions[promotion]!!.effect) + ")" textList += "" } } - private fun addUniqueImprovementsText(nation: Nation, textList: ArrayList, ruleSet: RuleSet) { - for (improvement in ruleSet.TileImprovements.values + private fun addUniqueImprovementsText(nation: Nation, textList: ArrayList, ruleset: Ruleset) { + for (improvement in ruleset.TileImprovements.values .filter { it.uniqueTo == nation.name }) { textList += improvement.name.tr() diff --git a/core/src/com/unciv/ui/newgamescreen/NewGameScreen.kt b/core/src/com/unciv/ui/newgamescreen/NewGameScreen.kt index b94897c873..e2cc58faaa 100644 --- a/core/src/com/unciv/ui/newgamescreen/NewGameScreen.kt +++ b/core/src/com/unciv/ui/newgamescreen/NewGameScreen.kt @@ -9,6 +9,7 @@ import com.unciv.logic.GameInfo import com.unciv.logic.GameSaver import com.unciv.logic.GameStarter import com.unciv.logic.civilization.PlayerType +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.ui.pickerscreens.PickerScreen import com.unciv.ui.utils.disable @@ -23,7 +24,7 @@ import kotlin.concurrent.thread class NewGameScreen: PickerScreen(){ val newGameParameters= UncivGame.Current.gameInfo.gameParameters - val ruleSet = UncivGame.Current.ruleSet + val ruleSet = Ruleset(true) init { setDefaultCloseAction() diff --git a/core/src/com/unciv/ui/newgamescreen/NewGameScreenOptionsTable.kt b/core/src/com/unciv/ui/newgamescreen/NewGameScreenOptionsTable.kt index e46a2cff78..59dddd77a2 100644 --- a/core/src/com/unciv/ui/newgamescreen/NewGameScreenOptionsTable.kt +++ b/core/src/com/unciv/ui/newgamescreen/NewGameScreenOptionsTable.kt @@ -1,5 +1,6 @@ package com.unciv.ui.newgamescreen +import com.badlogic.gdx.Gdx import com.badlogic.gdx.scenes.scene2d.Actor import com.badlogic.gdx.scenes.scene2d.ui.CheckBox import com.badlogic.gdx.scenes.scene2d.ui.SelectBox @@ -8,7 +9,7 @@ import com.badlogic.gdx.scenes.scene2d.utils.ChangeListener import com.badlogic.gdx.utils.Array import com.unciv.logic.MapSaver import com.unciv.logic.map.MapType -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.VictoryType import com.unciv.models.gamebasics.tech.TechEra import com.unciv.models.gamebasics.tr @@ -17,7 +18,7 @@ import com.unciv.models.metadata.GameSpeed import com.unciv.ui.utils.CameraStageBaseScreen import com.unciv.ui.utils.toLabel -class NewGameScreenOptionsTable(val newGameParameters: GameParameters, val ruleSet: RuleSet, val onMultiplayerToggled:()->Unit) +class NewGameScreenOptionsTable(val newGameParameters: GameParameters, val ruleset: Ruleset, val onMultiplayerToggled:()->Unit) : Table(CameraStageBaseScreen.skin){ init{ addMapTypeSizeAndFile() @@ -31,6 +32,8 @@ class NewGameScreenOptionsTable(val newGameParameters: GameParameters, val ruleS addNoRuinsCheckbox() addIsOnlineMultiplayerCheckbox() + addModCheckboxes() + pack() } @@ -128,7 +131,7 @@ class NewGameScreenOptionsTable(val newGameParameters: GameParameters, val ruleS val cityStatesSelectBox = SelectBox(CameraStageBaseScreen.skin) val cityStatesArray = Array() - (0..ruleSet.Nations.filter { it.value.isCityState() }.size).forEach { cityStatesArray.add(it) } + (0..ruleset.Nations.filter { it.value.isCityState() }.size).forEach { cityStatesArray.add(it) } cityStatesSelectBox.items = cityStatesArray cityStatesSelectBox.selected = newGameParameters.numberOfCityStates add(cityStatesSelectBox).pad(10f).row() @@ -141,7 +144,7 @@ class NewGameScreenOptionsTable(val newGameParameters: GameParameters, val ruleS private fun addDifficultySelectBox() { add("{Difficulty}:".tr()) - val difficultySelectBox = TranslatedSelectBox(ruleSet.Difficulties.keys, newGameParameters.difficulty, CameraStageBaseScreen.skin) + val difficultySelectBox = TranslatedSelectBox(ruleset.Difficulties.keys, newGameParameters.difficulty, CameraStageBaseScreen.skin) difficultySelectBox.addListener(object : ChangeListener() { override fun changed(event: ChangeEvent?, actor: Actor?) { newGameParameters.difficulty = difficultySelectBox.selected.value @@ -236,4 +239,46 @@ class NewGameScreenOptionsTable(val newGameParameters: GameParameters, val ruleS } + fun addModCheckboxes(){ + + add("{Victory conditions}:".tr()).colspan(2).row() + + // Create a checkbox for each VictoryType existing + var i = 0 + val modCheckboxTable = Table().apply { defaults().pad(10f) } + + val mods = Gdx.files.local("mods") + + for(modFolder in mods.list()){ + if(modFolder.list().any { it.name()=="jsons" }) { + val ruleSet = Ruleset(false) + + try { + val modRuleset = ruleSet.load(modFolder.path() + "/jsons") + + }catch (ex:Exception){} + } + } + + for (victoryType in VictoryType.values()) { + if (victoryType == VictoryType.Neutral) continue + val victoryCheckbox = CheckBox(victoryType.name.tr(), CameraStageBaseScreen.skin) + victoryCheckbox.name = victoryType.name + victoryCheckbox.isChecked = newGameParameters.victoryTypes.contains(victoryType) + victoryCheckbox.addListener(object : ChangeListener() { + override fun changed(event: ChangeEvent?, actor: Actor?) { + // If the checkbox is checked, adds the victoryTypes else remove it + if (victoryCheckbox.isChecked) { + newGameParameters.victoryTypes.add(victoryType) + } else { + newGameParameters.victoryTypes.remove(victoryType) + } + } + }) + modCheckboxTable.add(victoryCheckbox) + if (++i % 2 == 0) modCheckboxTable.row() + } + add(modCheckboxTable).colspan(2).row() + } + } \ No newline at end of file diff --git a/core/src/com/unciv/ui/newgamescreen/PlayerPickerTable.kt b/core/src/com/unciv/ui/newgamescreen/PlayerPickerTable.kt index aafc27a080..e22e48ab4d 100644 --- a/core/src/com/unciv/ui/newgamescreen/PlayerPickerTable.kt +++ b/core/src/com/unciv/ui/newgamescreen/PlayerPickerTable.kt @@ -10,7 +10,7 @@ import com.badlogic.gdx.scenes.scene2d.ui.TextField import com.badlogic.gdx.utils.Align import com.unciv.UncivGame import com.unciv.logic.civilization.PlayerType -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.models.metadata.GameParameters import com.unciv.models.metadata.Player @@ -39,7 +39,7 @@ class PlayerPickerTable(val newGameScreen: NewGameScreen, val newGameParameters: } } - fun getPlayerTable(player: Player, ruleSet: RuleSet): Table { + fun getPlayerTable(player: Player, ruleset: Ruleset): Table { val playerTable = Table() playerTable.pad(20f) playerTable.background = ImageGetter.getBackground(ImageGetter.getBlue().lerp(Color.BLACK, 0.8f)) diff --git a/core/src/com/unciv/ui/utils/Fonts.kt b/core/src/com/unciv/ui/utils/Fonts.kt index b97245b913..b14d46114a 100644 --- a/core/src/com/unciv/ui/utils/Fonts.kt +++ b/core/src/com/unciv/ui/utils/Fonts.kt @@ -36,7 +36,7 @@ class Fonts { if (Gdx.files.internal("jsons/Tutorials/Tutorials_$language.json").exists()) charSet.addAll(Gdx.files.internal("jsons/Tutorials/Tutorials_$language.json").readString().asIterable()) - for (entry in UncivGame.Current.ruleSet.Translations.entries) { + for (entry in UncivGame.Current.ruleset.Translations.entries) { for (lang in entry.value) { if (lang.key == language) charSet.addAll(lang.value.asIterable()) } diff --git a/core/src/com/unciv/ui/utils/ImageGetter.kt b/core/src/com/unciv/ui/utils/ImageGetter.kt index 3e73ba69ea..6a8a1d30cc 100644 --- a/core/src/com/unciv/ui/utils/ImageGetter.kt +++ b/core/src/com/unciv/ui/utils/ImageGetter.kt @@ -33,7 +33,7 @@ object ImageGetter { setTextureRegionDrawables() } - fun getRuleSet() = UncivGame.Current.ruleSet + fun getRuleSet() = UncivGame.Current.ruleset fun setTextureRegionDrawables(){ textureRegionDrawables.clear() diff --git a/core/src/com/unciv/ui/utils/Tutorials.kt b/core/src/com/unciv/ui/utils/Tutorials.kt index 70fcb6b9d3..23f30603bc 100644 --- a/core/src/com/unciv/ui/utils/Tutorials.kt +++ b/core/src/com/unciv/ui/utils/Tutorials.kt @@ -36,12 +36,13 @@ class Tutorials{ } fun getTutorialsOfLanguage(language: String): HashMap> { - if(!Gdx.files.internal("jsons/Tutorials/Tutorials_$language.json").exists()) return hashMapOf() + val filePath = "jsons/Tutorials/Tutorials_$language.json" + if(!Gdx.files.internal(filePath).exists()) return hashMapOf() // ...Yes. Disgusting. I wish I didn't have to do this. val x = LinkedHashMap>>() val tutorials: LinkedHashMap>> = - UncivGame.Current.ruleSet.getFromJson(x.javaClass, "Tutorials/Tutorials_$language") + UncivGame.Current.ruleset.getFromJson(x.javaClass, filePath) val tutorialMap = HashMap>() for (tutorial in tutorials){ val list = ArrayList() diff --git a/core/src/com/unciv/ui/worldscreen/optionstable/WorldScreenOptionsTable.kt b/core/src/com/unciv/ui/worldscreen/optionstable/WorldScreenOptionsTable.kt index 8aa02dd70f..b86e43d9e7 100644 --- a/core/src/com/unciv/ui/worldscreen/optionstable/WorldScreenOptionsTable.kt +++ b/core/src/com/unciv/ui/worldscreen/optionstable/WorldScreenOptionsTable.kt @@ -7,18 +7,18 @@ import com.badlogic.gdx.scenes.scene2d.ui.* import com.badlogic.gdx.scenes.scene2d.utils.ChangeListener import com.badlogic.gdx.utils.Array import com.unciv.UncivGame -import com.unciv.models.gamebasics.RuleSet +import com.unciv.models.gamebasics.Ruleset import com.unciv.models.gamebasics.tr import com.unciv.ui.utils.* import com.unciv.ui.worldscreen.WorldScreen import kotlin.concurrent.thread -class Language(val language:String, ruleSet: RuleSet){ +class Language(val language:String, ruleset: Ruleset){ val percentComplete:Int init{ - val availableTranslations = ruleSet.Translations.count { it.value.containsKey(language) } + val availableTranslations = ruleset.Translations.count { it.value.containsKey(language) } if(language=="English") percentComplete = 100 - else percentComplete = (availableTranslations*100 / ruleSet.Translations.size) + else percentComplete = (availableTranslations*100 / ruleset.Translations.size) } override fun toString(): String { val spaceSplitLang = language.replace("_"," ") diff --git a/tests/src/de/tomgrill/gdxtesting/examples/BasicTests.java b/tests/src/de/tomgrill/gdxtesting/examples/BasicTests.java index 9021507c47..b0b8690e3e 100644 --- a/tests/src/de/tomgrill/gdxtesting/examples/BasicTests.java +++ b/tests/src/de/tomgrill/gdxtesting/examples/BasicTests.java @@ -3,7 +3,7 @@ package de.tomgrill.gdxtesting.examples; import com.badlogic.gdx.Gdx; -import com.unciv.models.gamebasics.RuleSet; +import com.unciv.models.gamebasics.Ruleset; import org.junit.Test; import org.junit.runner.RunWith; @@ -26,7 +26,7 @@ public class BasicTests { @Test public void gameBasicsLoad() { assertTrue("This test will only pass when the jsons can be loaded", - new RuleSet().getBuildings().size() > 0); + new Ruleset(true).getBuildings().size() > 0); } diff --git a/tests/src/de/tomgrill/gdxtesting/examples/TranslationTests.java b/tests/src/de/tomgrill/gdxtesting/examples/TranslationTests.java index f1a25b4069..60a0c6b54b 100644 --- a/tests/src/de/tomgrill/gdxtesting/examples/TranslationTests.java +++ b/tests/src/de/tomgrill/gdxtesting/examples/TranslationTests.java @@ -2,7 +2,7 @@ package de.tomgrill.gdxtesting.examples; -import com.unciv.models.gamebasics.RuleSet; +import com.unciv.models.gamebasics.Ruleset; import org.junit.Test; import org.junit.runner.RunWith; @@ -17,30 +17,32 @@ import static org.junit.Assert.assertTrue; @RunWith(GdxTestRunner.class) public class TranslationTests { + + Ruleset ruleSet = new Ruleset(true); @Test public void translationsLoad() { assertTrue("This test will only pass there are translations", - new RuleSet().getTranslations().size() > 0); + ruleSet.getTranslations().size() > 0); } @Test public void allUnitsHaveTranslation() { - Boolean allUnitsHaveTranslation = allStringAreTranslated(new RuleSet().getUnits().keySet()); + Boolean allUnitsHaveTranslation = allStringAreTranslated(ruleSet.getUnits().keySet()); assertTrue("This test will only pass when there is a translation for all units", allUnitsHaveTranslation); } @Test public void allBuildingsHaveTranslation() { - Boolean allBuildingsHaveTranslation = allStringAreTranslated(new RuleSet().getBuildings().keySet()); + Boolean allBuildingsHaveTranslation = allStringAreTranslated(ruleSet.getBuildings().keySet()); assertTrue("This test will only pass when there is a translation for all buildings", allBuildingsHaveTranslation); } @Test public void allTerrainsHaveTranslation() { - Set strings = new RuleSet().getTerrains().keySet(); + Set strings = ruleSet.getTerrains().keySet(); Boolean allStringsHaveTranslation = allStringAreTranslated(strings); assertTrue("This test will only pass when there is a translation for all buildings", allStringsHaveTranslation); @@ -48,7 +50,7 @@ public class TranslationTests { @Test public void allImprovementsHaveTranslation() { - Set strings = new RuleSet().getTileImprovements().keySet(); + Set strings = ruleSet.getTileImprovements().keySet(); Boolean allStringsHaveTranslation = allStringAreTranslated(strings); assertTrue("This test will only pass when there is a translation for all improvements", allStringsHaveTranslation); @@ -56,7 +58,7 @@ public class TranslationTests { @Test public void allTechnologiesHaveTranslation() { - Set strings = new RuleSet().getTechnologies().keySet(); + Set strings = ruleSet.getTechnologies().keySet(); Boolean allStringsHaveTranslation = allStringAreTranslated(strings); assertTrue("This test will only pass when there is a translation for all technologies", allStringsHaveTranslation); @@ -64,7 +66,7 @@ public class TranslationTests { @Test public void allPromotionsHaveTranslation() { - Set strings = new RuleSet().getUnitPromotions().keySet(); + Set strings = ruleSet.getUnitPromotions().keySet(); Boolean allStringsHaveTranslation = allStringAreTranslated(strings); assertTrue("This test will only pass when there is a translation for all promotions", allStringsHaveTranslation); @@ -73,7 +75,7 @@ public class TranslationTests { private Boolean allStringAreTranslated(Set strings) { boolean allBuildingsHaveTranslation = true; for (String unitName : strings) { - if (!new RuleSet().getTranslations().containsKey(unitName)) { + if (!ruleSet.getTranslations().containsKey(unitName)) { allBuildingsHaveTranslation = false; System.out.println(unitName); }