Simplified mod management, in preparation for mod information within the maps

core/src/com/unciv/logic/map/TileInfo.kt

@@ -498,14 +498,15 @@ open class TileInfo {
                     && (terrainFeature == Constants.jungle || terrainFeature == Constants.forest)
                     && isFriendlyTerritory(civInfo)
 
-    fun isRulesetCompatible(ruleset: Ruleset): Boolean {
+    fun getRulesetIncompatability(ruleset: Ruleset):String{
-        if (!ruleset.terrains.containsKey(baseTerrain)) return false
+        if (!ruleset.terrains.containsKey(baseTerrain)) return "Base terrain $baseTerrain does not exist in ruleset!"
-        if (terrainFeature != null && !ruleset.terrains.containsKey(terrainFeature)) return false
+        if (terrainFeature != null && !ruleset.terrains.containsKey(terrainFeature)) return "Terrain feature $terrainFeature does not exist in ruleset!"
-        if (resource != null && !ruleset.tileResources.containsKey(resource)) return false
+        if (resource != null && !ruleset.tileResources.containsKey(resource)) return "Resource $resource does not exist in ruleset!"
-        if (improvement != null && !ruleset.tileImprovements.containsKey(baseTerrain)) return false
+        if (improvement != null && !ruleset.tileImprovements.containsKey(baseTerrain)) return "Improvement $improvement does not exist in ruleset!"
-        return true
+        return ""
     }
 
+
     //endregion
 
     //region state-changing functions
@@ -515,6 +516,8 @@ open class TileInfo {
     }
 
     fun setTerrainTransients() {
+        if (!ruleset.terrains.containsKey(baseTerrain))
+            throw Exception()
         baseTerrainObject = ruleset.terrains[baseTerrain]!!
         isWater = getBaseTerrain().type == TerrainType.Water
         isLand = getBaseTerrain().type == TerrainType.Land

core/src/com/unciv/models/ruleset/Ruleset.kt

@@ -352,13 +352,13 @@ object RulesetCache :HashMap<String,Ruleset>() {
     }
 
 
-    fun getBaseRuleset() = this[BaseRuleset.Civ_V_Vanilla.fullName]!!
+    fun getBaseRuleset() = this[BaseRuleset.Civ_V_Vanilla.fullName]!!.clone() // safeguard, o no-one edits the base ruleset by mistake
 
     fun getComplexRuleset(gameParameters: GameParameters): Ruleset {
         val newRuleset = Ruleset()
         val loadedMods = gameParameters.mods.filter { containsKey(it) }.map { this[it]!! }
         if (loadedMods.none { it.modOptions.isBaseRuleset })
-            newRuleset.add(this[gameParameters.baseRuleset.fullName]!!)
+            newRuleset.add(getBaseRuleset())
         for (mod in loadedMods.sortedByDescending { it.modOptions.isBaseRuleset }) {
             newRuleset.add(mod)
             newRuleset.mods += mod.name

core/src/com/unciv/ui/newgamescreen/ModCheckboxTable.kt

@@ -13,13 +13,14 @@ import com.unciv.ui.utils.toLabel
 class ModCheckboxTable(val gameParameters: GameParameters, val screen: CameraStageBaseScreen, onUpdate: (String) -> Unit): Table(){
     init {
         val modRulesets = RulesetCache.values.filter { it.name != "" }
+        val mods = gameParameters.mods
 
         val baseRulesetCheckboxes = ArrayList<CheckBox>()
         val extentionRulesetModButtons = ArrayList<CheckBox>()
 
         for (mod in modRulesets) {
             val checkBox = CheckBox(mod.name.tr(), CameraStageBaseScreen.skin)
-            if (mod.name in gameParameters.mods) checkBox.isChecked = true
+            if (mod.name in mods) checkBox.isChecked = true
             checkBox.onChange {
                 if (checkBox.isChecked) {
                     val modLinkErrors = mod.checkModLinks()
@@ -29,19 +30,19 @@ class ModCheckboxTable(val gameParameters: GameParameters, val screen: CameraSta
                         return@onChange
                     }
 
-                    val previousMods = gameParameters.mods.toList()
+                    val previousMods = mods.toList()
 
                     if (mod.modOptions.isBaseRuleset)
                         for (oldBaseRuleset in previousMods) // so we don't get concurrent modification excpetions
                             if (modRulesets.firstOrNull { it.name == oldBaseRuleset }?.modOptions?.isBaseRuleset == true)
-                                gameParameters.mods.remove(oldBaseRuleset)
+                                mods.remove(oldBaseRuleset)
-                    gameParameters.mods.add(mod.name)
+                    mods.add(mod.name)
 
                     var isCompatibleWithCurrentRuleset = true
                     var complexModLinkErrors = ""
                     try {
                         val newRuleset = RulesetCache.getComplexRuleset(gameParameters)
-                        newRuleset.modOptions.isBaseRuleset = true
+                        newRuleset.modOptions.isBaseRuleset = true // This is so the checkModLinks finds all connections
                         complexModLinkErrors = newRuleset.checkModLinks()
                         if (complexModLinkErrors != "") isCompatibleWithCurrentRuleset = false
                     } catch (x: Exception) {
@@ -53,13 +54,13 @@ class ModCheckboxTable(val gameParameters: GameParameters, val screen: CameraSta
                     if (!isCompatibleWithCurrentRuleset) {
                         ToastPopup("The mod you selected is incompatible with the defined ruleset!\n\n$complexModLinkErrors", screen)
                         checkBox.isChecked = false
-                        gameParameters.mods.clear()
+                        mods.clear()
-                        gameParameters.mods.addAll(previousMods)
+                        mods.addAll(previousMods)
                         return@onChange
                     }
 
                 } else {
-                    gameParameters.mods.remove(mod.name)
+                    mods.remove(mod.name)
                 }
 
                 onUpdate(mod.name)