AnarchistGamers/Unciv
1
0
Fork 0
mirror of https://github.com/yairm210/Unciv.git synced 2025-09-27 22:06:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

Ruleset should have a lower-case s, because it's not, you know, a Set

Browse Source 
Also, Rulesets can now read rules from any json folder
This commit is contained in:
Yair Morgenstern 2019-12-06 13:59:12 +02:00
parent c32e3fce3c
commit 38b9b13a0a
30 changed files with 225 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/src/com/unciv/UncivGame.kt
View File

@ -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

2
core/src/com/unciv/logic/GameInfo.kt
View File

@ -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<CivilizationInfo>()
var difficulty="Chieftain" // difficulty is game-wide, think what would happen if 2 human players could play on different difficulties?

10
core/src/com/unciv/logic/GameStarter.kt
View File

@ -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<String>()
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<String>()
// 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)) {

5
core/src/com/unciv/logic/civilization/CivilizationInfo.kt
View File

@ -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<Nation>::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<Nation>::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

40
core/src/com/unciv/logic/map/MapGenerator.kt
View File

@ -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<Area>()
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) } }

6
core/src/com/unciv/logic/map/MapUnit.kt
View File

@ -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()
}

4
core/src/com/unciv/logic/map/RoadStatus.kt
View File

@ -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]
}

14
core/src/com/unciv/logic/map/TileInfo.kt
View File

@ -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)
}
}

10
core/src/com/unciv/logic/map/TileMap.kt
View File

@ -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()
}
}

12
core/src/com/unciv/models/gamebasics/Building.kt
View File

@ -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<String>()
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!!]!!
}
}

49
core/src/com/unciv/models/gamebasics/RuleSet.kt → core/src/com/unciv/models/gamebasics/Ruleset.kt
View File

@ -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<String, Building>()
val Terrains = LinkedHashMap<String, Terrain>()
val TileResources = LinkedHashMap<String, TileResource>()
@ -25,8 +25,8 @@ class RuleSet {
val Difficulties = LinkedHashMap<String, Difficulty>()
val Translations = Translations()
fun <T> getFromJson(tClass: Class<T>, name: String): T {
val jsonText = Gdx.files.internal("jsons/$name.json").readString(Charsets.UTF_8.name())
fun <T> getFromJson(tClass: Class<T>, 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<TechColumn>::class.java, "Techs")
val techColumns = getFromJson(Array<TechColumn>::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<Building>::class.java, "Buildings"))
Buildings += createHashmap(getFromJson(Array<Building>::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<Terrain>::class.java, "Terrains"))
TileResources += createHashmap(getFromJson(Array<TileResource>::class.java, "TileResources"))
TileImprovements += createHashmap(getFromJson(Array<TileImprovement>::class.java, "TileImprovements"))
Units += createHashmap(getFromJson(Array<BaseUnit>::class.java, "Units"))
UnitPromotions += createHashmap(getFromJson(Array<Promotion>::class.java, "UnitPromotions"))
Terrains += createHashmap(getFromJson(Array<Terrain>::class.java, "$folderPath/Terrains.json"))
TileResources += createHashmap(getFromJson(Array<TileResource>::class.java, "$folderPath/TileResources.json"))
TileImprovements += createHashmap(getFromJson(Array<TileImprovement>::class.java, "$folderPath/TileImprovements.json"))
Units += createHashmap(getFromJson(Array<BaseUnit>::class.java, "$folderPath/Units.json"))
UnitPromotions += createHashmap(getFromJson(Array<Promotion>::class.java, "$folderPath/UnitPromotions.json"))
PolicyBranches += createHashmap(getFromJson(Array<PolicyBranch>::class.java, "Policies"))
PolicyBranches += createHashmap(getFromJson(Array<PolicyBranch>::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<Nation>::class.java, "Nations/Nations"))
Nations += createHashmap(getFromJson(Array<Nation>::class.java, "$folderPath/Nations/Nations.json"))
for(nation in Nations.values) nation.setTransients()
Difficulties += createHashmap(getFromJson(Array<Difficulty>::class.java, "Difficulties"))
Difficulties += createHashmap(getFromJson(Array<Difficulty>::class.java, "$folderPath/Difficulties.json"))
val gameBasicsLoadTime = System.currentTimeMillis() - gameBasicsStartTime
println("Loading game basics - "+gameBasicsLoadTime+"ms")

4
core/src/com/unciv/models/gamebasics/Translations.kt
View File

@ -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
}

14
core/src/com/unciv/models/gamebasics/tech/Technology.kt
View File

@ -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<String>() // 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() }

6
core/src/com/unciv/models/gamebasics/tile/Terrain.kt
View File

@ -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())
}

6
core/src/com/unciv/models/gamebasics/tile/TileImprovement.kt
View File

@ -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<String, ArrayList<String>>()
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()

6
core/src/com/unciv/models/gamebasics/unit/BaseUnit.kt
View File

@ -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
}

34
core/src/com/unciv/ui/CivilopediaScreen.kt
View File

@ -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<CivilopediaEntry>::class.java, basicHelpFileName).toList()
categoryToEntries["Buildings"] = ruleSet.Buildings.values
.map { CivilopediaEntry(it.name,it.getDescription(false, null,ruleSet),
categoryToEntries["Basics"] = ruleset.getFromJson(Array<CivilopediaEntry>::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

8
core/src/com/unciv/ui/LanguagePickerScreen.kt
View File

@ -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 } )

2
core/src/com/unciv/ui/mapeditor/MapEditorScreen.kt
View File

@ -19,7 +19,7 @@ class MapEditorScreen(): CameraStageBaseScreen(){
var mapName = "My first map"
lateinit var mapHolder: TileGroupMap<TileGroup>
private val showHideEditorOptionsButton = TextButton(">",skin)
val ruleSet = UncivGame.Current.ruleSet
val ruleSet = UncivGame.Current.ruleset
private val tileEditorOptions = TileEditorOptionsTable(this)
constructor(mapNameToLoad:String?):this(){

4
core/src/com/unciv/ui/mapeditor/TileEditorOptionsTable.kt
View File

@ -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()

32
core/src/com/unciv/ui/newgamescreen/NationTable.kt
View File

@ -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<String>()
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<String>, ruleSet: RuleSet) {
for (building in ruleSet.Buildings.values
private fun addUniqueBuildingsText(nation: Nation, textList: ArrayList<String>, 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<String>, ruleSet: RuleSet) {
for (unit in ruleSet.Units.values
private fun addUniqueUnitsText(nation: Nation, textList: ArrayList<String>, 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<String>, ruleSet: RuleSet) {
for (improvement in ruleSet.TileImprovements.values
private fun addUniqueImprovementsText(nation: Nation, textList: ArrayList<String>, ruleset: Ruleset) {
for (improvement in ruleset.TileImprovements.values
.filter { it.uniqueTo == nation.name }) {
textList += improvement.name.tr()

3
core/src/com/unciv/ui/newgamescreen/NewGameScreen.kt
View File

@ -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()

53
core/src/com/unciv/ui/newgamescreen/NewGameScreenOptionsTable.kt
View File

@ -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<Int>(CameraStageBaseScreen.skin)
val cityStatesArray = Array<Int>()
(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()
}
}

4
core/src/com/unciv/ui/newgamescreen/PlayerPickerTable.kt
View File

@ -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))

2
core/src/com/unciv/ui/utils/Fonts.kt
View File

@ -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())
}

2
core/src/com/unciv/ui/utils/ImageGetter.kt
View File

@ -33,7 +33,7 @@ object ImageGetter {
setTextureRegionDrawables()
}
fun getRuleSet() = UncivGame.Current.ruleSet
fun getRuleSet() = UncivGame.Current.ruleset
fun setTextureRegionDrawables(){
textureRegionDrawables.clear()

5
core/src/com/unciv/ui/utils/Tutorials.kt
View File

@ -36,12 +36,13 @@ class Tutorials{
}
fun getTutorialsOfLanguage(language: String): HashMap<String, ArrayList<String>> {
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<String, Array<Array<String>>>()
val tutorials: LinkedHashMap<String, Array<Array<String>>> =
UncivGame.Current.ruleSet.getFromJson(x.javaClass, "Tutorials/Tutorials_$language")
UncivGame.Current.ruleset.getFromJson(x.javaClass, filePath)
val tutorialMap = HashMap<String, ArrayList<String>>()
for (tutorial in tutorials){
val list = ArrayList<String>()

8
core/src/com/unciv/ui/worldscreen/optionstable/WorldScreenOptionsTable.kt
View File

@ -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("_"," ")

4
tests/src/de/tomgrill/gdxtesting/examples/BasicTests.java
View File

@ -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);
}

20
tests/src/de/tomgrill/gdxtesting/examples/TranslationTests.java
View File

@ -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<String> strings = new RuleSet().getTerrains().keySet();
Set<String> 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<String> strings = new RuleSet().getTileImprovements().keySet();
Set<String> 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<String> strings = new RuleSet().getTechnologies().keySet();
Set<String> 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<String> strings = new RuleSet().getUnitPromotions().keySet();
Set<String> 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<String> 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);
}