Proper separation between "Scenario Map" and "Scenario"

core/src/com/unciv/MainMenuScreen.kt

@@ -147,7 +147,7 @@ class MainMenuScreen: CameraStageBaseScreen() {
             add(loadMapButton).row()
 
             if (UncivGame.Current.settings.extendedMapEditor) {
-                val loadScenarioButton = screen.getTableBlock("Load scenario", "OtherIcons/Scenario") {
+                val loadScenarioButton = screen.getTableBlock("Load scenario map", "OtherIcons/Scenario") {
                     val loadScenarioScreen = LoadScenarioScreen(null)
                     loadScenarioScreen.closeButton.isVisible = true
                     loadScenarioScreen.closeButton.onClick {

core/src/com/unciv/logic/GameStarter.kt

@@ -21,7 +21,7 @@ object GameStarter {
         gameInfo.gameParameters = gameSetupInfo.gameParameters
         val ruleset = RulesetCache.getComplexRuleset(gameInfo.gameParameters)
 
-        if (gameSetupInfo.mapParameters.type == MapType.scenario)
+        if (gameSetupInfo.mapParameters.type == MapType.scenarioMap)
             gameInfo.tileMap = MapSaver.loadScenario(gameSetupInfo.mapParameters.name).tileMap
         else if (gameSetupInfo.mapParameters.name != "")
             gameInfo.tileMap = MapSaver.loadMap(gameSetupInfo.mapParameters.name)
@@ -68,7 +68,7 @@ object GameStarter {
         }
 
         // and only now do we add units for everyone, because otherwise both the gameInfo.setTransients() and the placeUnit will both add the unit to the civ's unit list!
-        if (gameSetupInfo.mapParameters.type != MapType.scenario)
+        if (gameSetupInfo.mapParameters.type != MapType.scenarioMap)
             addCivStartingUnits(gameInfo)
 
         return gameInfo

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

@@ -26,9 +26,9 @@ object MapType {
     const val custom = "Custom"
 
     // Loaded scenario
-    const val scenario = "Scenario"
+    const val scenarioMap = "Scenario Map"
 
-    const val scenarioFromSavedGame = "ScenarioFromSavedGame"
+    const val scenario = "Scenario"
 
     // All ocean tiles
     const val empty = "Empty"

core/src/com/unciv/ui/mapeditor/LoadScenarioScreen.kt

@@ -23,7 +23,7 @@ class LoadScenarioScreen(previousMap: TileMap?): PickerScreen(){
     val deleteScenarioButton = "Delete scenario".toTextButton()
 
     init {
-        rightSideButton.setText("Load scenario".tr())
+        rightSideButton.setText("Load scenario map".tr())
         rightSideButton.onClick {
             val mapEditorScreen = MapEditorScreen(MapSaver.loadScenario(chosenScenario), chosenScenario)
             UncivGame.Current.setScreen(mapEditorScreen)

core/src/com/unciv/ui/mapeditor/MapEditorMenuPopup.kt

@@ -1,7 +1,6 @@
 package com.unciv.ui.mapeditor
 
 import com.badlogic.gdx.Gdx
-import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.badlogic.gdx.scenes.scene2d.ui.TextField
 import com.badlogic.gdx.utils.Json
 import com.unciv.Constants
@@ -13,8 +12,6 @@ import com.unciv.logic.map.RoadStatus
 import com.unciv.logic.map.Scenario
 import com.unciv.logic.map.TileMap
 import com.unciv.models.metadata.Player
-import com.unciv.ui.newgamescreen.GameOptionsTable
-import com.unciv.ui.newgamescreen.PlayerPickerTable
 import com.unciv.ui.saves.Gzip
 import com.unciv.ui.utils.*
 import com.unciv.ui.worldscreen.mainmenu.DropBox
@@ -159,9 +156,9 @@ class MapEditorMenuPopup(var mapEditorScreen: MapEditorScreen): Popup(mapEditorS
     private fun Popup.addScenarioButton() {
         var scenarioButton = "".toTextButton()
         if (mapEditorScreen.hasScenario()) {
-            scenarioButton.setText("Edit scenario")
+            scenarioButton.setText("Edit scenario parameters")
         } else {
-            scenarioButton.setText("Create scenario")
+            scenarioButton.setText("Create scenario map")
             // for newly created scenarios read players from tileMap
             val players = getPlayersFromMap(mapEditorScreen.tileMap)
             mapEditorScreen.gameSetupInfo.gameParameters.players = players
@@ -176,19 +173,20 @@ class MapEditorMenuPopup(var mapEditorScreen: MapEditorScreen): Popup(mapEditorS
     }
 
     private fun Popup.addSaveScenarioButton() {
-        val saveScenarioButton = "Save scenario".toTextButton()
+        val saveScenarioButton = "Save scenario map".toTextButton()
         add(saveScenarioButton).row()
         saveScenarioButton.onClick {
-            thread(name = "SaveScenario") {
+            thread(name = "SaveScenarioMap") {
                 try {
-                    mapEditorScreen.tileMap.mapParameters.type = MapType.scenario
+                    mapEditorScreen.tileMap.mapParameters.type = MapType.scenarioMap
                     mapEditorScreen.scenario = Scenario(mapEditorScreen.tileMap, mapEditorScreen.gameSetupInfo.gameParameters)
+                    mapEditorScreen.scenario!!.gameParameters.godMode = true // so we can edit this scenario when loading from the map
                     mapEditorScreen.scenarioName = mapNameEditor.text
                     MapSaver.saveScenario(mapNameEditor.text, mapEditorScreen.scenario!!)
 
                     close()
                     Gdx.app.postRunnable {
-                        ResponsePopup("Scenario saved", mapEditorScreen) // todo - add this text to translations
+                        ResponsePopup("Scenario Map saved", mapEditorScreen) // todo - add this text to translations
                     }
                 } catch (ex: Exception) {
                     ex.printStackTrace()
@@ -210,7 +208,7 @@ class MapEditorMenuPopup(var mapEditorScreen: MapEditorScreen): Popup(mapEditorS
     }
 
     private fun Popup.addLoadScenarioButton() {
-        val loadScenarioButton = "Load scenario".toTextButton()
+        val loadScenarioButton = "Load scenario map".toTextButton()
         loadScenarioButton.onClick {
             UncivGame.Current.setScreen(LoadScenarioScreen(mapEditorScreen.tileMap))
         }

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

@@ -18,8 +18,8 @@ class MapOptionsTable(val newGameScreen: NewGameScreen): Table() {
     private var mapTypeSpecificTable = Table()
     private val generatedMapOptionsTable = MapParametersTable(mapParameters)
     private val savedMapOptionsTable = Table()
-    private val savedScenarioOptionsTable = Table()
+    private val scenarioMapOptionsTable = Table()
-    private val scenarioFromSavedGameOptionsTable = Table()
+    private val scenarioOptionsTable = Table()
     var selectedScenarioSaveGame: GameInfo? = null
     lateinit var mapTypeSelectBox: TranslatedSelectBox
 
@@ -31,11 +31,12 @@ class MapOptionsTable(val newGameScreen: NewGameScreen): Table() {
 
     fun selectSavedGameAsScenario(gameName: String){
         val savedGame = GameSaver.loadGameByName(gameName)
-        mapParameters.type = MapType.scenarioFromSavedGame
+        mapParameters.type = MapType.scenario
         mapParameters.name = gameName
-        newGameScreen.updateTables()
         newGameScreen.gameSetupInfo.gameParameters = savedGame.gameParameters
         newGameScreen.gameSetupInfo.mapParameters = savedGame.tileMap.mapParameters
+        newGameScreen.updateRuleset()
+        newGameScreen.updateTables()
         selectedScenarioSaveGame = savedGame
     }
 
@@ -44,9 +45,9 @@ class MapOptionsTable(val newGameScreen: NewGameScreen): Table() {
         val mapTypes = arrayListOf("Generated")
         if (MapSaver.getMaps().isNotEmpty()) mapTypes.add(MapType.custom)
         if (MapSaver.getScenarios().isNotEmpty() && UncivGame.Current.settings.extendedMapEditor)
+            mapTypes.add(MapType.scenarioMap)
+        if (GameSaver.getSaves().any { it.toLowerCase().endsWith("scenario") })
             mapTypes.add(MapType.scenario)
-        if (UncivGame.Current.settings.extendedMapEditor && GameSaver.getSaves().any { it.endsWith("Scenario") })
-            mapTypes.add(MapType.scenarioFromSavedGame)
         mapTypeSelectBox = TranslatedSelectBox(mapTypes, "Generated", CameraStageBaseScreen.skin)
 
         val mapFileSelectBox = getMapFileSelectBox()
@@ -57,23 +58,24 @@ class MapOptionsTable(val newGameScreen: NewGameScreen): Table() {
                 .right().row()
 
 
-        val scenarioFileSelectBox = getScenarioFileSelectBox()
+        val scenarioMapSelectBox = getScenarioFileSelectBox()
-        savedScenarioOptionsTable.defaults().pad(5f)
+        scenarioMapOptionsTable.defaults().pad(5f)
-        savedScenarioOptionsTable.add("{Scenario file}:".toLabel()).left()
+        scenarioMapOptionsTable.add("{Scenario file}:".toLabel()).left()
         // because SOME people gotta give the hugest names to their maps
-        savedScenarioOptionsTable.add(scenarioFileSelectBox).maxWidth(newGameScreen.stage.width / 2)
+        scenarioMapOptionsTable.add(scenarioMapSelectBox).maxWidth(newGameScreen.stage.width / 2)
                 .right().row()
 
 
-        val scenarioFromSavedGameSelectBox = SelectBox<String>(CameraStageBaseScreen.skin)
+        val scenarioSelectBox = SelectBox<String>(CameraStageBaseScreen.skin)
         for (savedGame in GameSaver.getSaves()) {
-            if (savedGame.endsWith("Scenario"))
+            if (savedGame.toLowerCase().endsWith("scenario"))
-                scenarioFromSavedGameSelectBox.items.add(savedGame)
+                scenarioSelectBox.items.add(savedGame)
         }
-        scenarioFromSavedGameSelectBox.onChange { selectSavedGameAsScenario(scenarioFromSavedGameSelectBox.selected) }
+        scenarioSelectBox.onChange { selectSavedGameAsScenario(scenarioSelectBox.selected) }
-        scenarioFromSavedGameSelectBox.selected = scenarioFileSelectBox.items.first()
+        scenarioSelectBox.items = scenarioSelectBox.items // it doesn't register them until you do this.
-        scenarioFromSavedGameOptionsTable.add("{Scenario file}:".toLabel()).left()
+        scenarioSelectBox.selected = scenarioMapSelectBox.items.first()
-        scenarioFromSavedGameOptionsTable.add(scenarioFromSavedGameSelectBox)
+        scenarioOptionsTable.add("{Scenario file}:".toLabel()).left()
+        scenarioOptionsTable.add(scenarioSelectBox)
 
         fun updateOnMapTypeChange() {
             mapTypeSpecificTable.clear()
@@ -83,10 +85,10 @@ class MapOptionsTable(val newGameScreen: NewGameScreen): Table() {
                 mapTypeSpecificTable.add(savedMapOptionsTable)
                 newGameScreen.unlockTables()
                 newGameScreen.updateTables()
-            } else if (mapTypeSelectBox.selected.value == MapType.scenario) {
+            } else if (mapTypeSelectBox.selected.value == MapType.scenarioMap) {
-                mapParameters.type = MapType.scenario
+                mapParameters.type = MapType.scenarioMap
-                mapParameters.name = scenarioFileSelectBox.selected
+                mapParameters.name = scenarioMapSelectBox.selected
-                mapTypeSpecificTable.add(savedScenarioOptionsTable)
+                mapTypeSpecificTable.add(scenarioMapOptionsTable)
                 val scenario = MapSaver.loadScenario(mapParameters.name)
                 newGameScreen.gameSetupInfo.gameParameters = scenario.gameParameters
                 newGameScreen.gameSetupInfo.mapParameters = mapParameters
@@ -94,12 +96,10 @@ class MapOptionsTable(val newGameScreen: NewGameScreen): Table() {
                 // update PlayerTable and GameOptionsTable
                 newGameScreen.lockTables()
                 newGameScreen.updateTables()
-            } else if(mapTypeSelectBox.selected.value == MapType.scenarioFromSavedGame){
+            } else if(mapTypeSelectBox.selected.value == MapType.scenario){
-                selectSavedGameAsScenario(scenarioFromSavedGameSelectBox.selected)
+                selectSavedGameAsScenario(scenarioSelectBox.selected)
-                mapTypeSpecificTable.add(scenarioFromSavedGameOptionsTable)
+                mapTypeSpecificTable.add(scenarioOptionsTable)
-                newGameScreen.updateRuleset()
                 newGameScreen.lockTables()
-                newGameScreen.updateTables()
             } else { // generated map
                 mapParameters.name = ""
                 mapParameters.type = generatedMapOptionsTable.mapTypeSelectBox.selected.value

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

@@ -11,7 +11,6 @@ import com.unciv.logic.civilization.PlayerType
 import com.unciv.logic.map.MapParameters
 import com.unciv.logic.map.MapType
 import com.unciv.models.metadata.GameParameters
-import com.unciv.models.ruleset.Ruleset
 import com.unciv.models.ruleset.RulesetCache
 import com.unciv.models.translations.tr
 import com.unciv.ui.pickerscreens.PickerScreen
@@ -99,7 +98,7 @@ class NewGameScreen(previousScreen:CameraStageBaseScreen, _gameSetupInfo: GameSe
 
     private fun newGameThread() {
         try {
-            if (mapOptionsTable.mapTypeSelectBox.selected.value == MapType.scenarioFromSavedGame) {
+            if (mapOptionsTable.mapTypeSelectBox.selected.value == MapType.scenario) {
                 newGame = mapOptionsTable.selectedScenarioSaveGame
                 // to take the definition of which players are human and which are AI
                 for (player in gameSetupInfo.gameParameters.players) {