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

Proper separation between "Scenario Map" and "Scenario"

Browse Source
This commit is contained in:
Yair Morgenstern 2020-08-13 17:40:48 +03:00
parent a27aecda09
commit d090b0567c
7 changed files with 41 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/com/unciv/MainMenuScreen.kt
View File

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

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

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

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

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

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

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

18
core/src/com/unciv/ui/mapeditor/MapEditorMenuPopup.kt
View File

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

52
core/src/com/unciv/ui/newgamescreen/MapOptionsTable.kt
View File

@ -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 scenarioFromSavedGameOptionsTable = Table()
private val scenarioMapOptionsTable = 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()
savedScenarioOptionsTable.defaults().pad(5f)
savedScenarioOptionsTable.add("{Scenario file}:".toLabel()).left()
val scenarioMapSelectBox = getScenarioFileSelectBox()
scenarioMapOptionsTable.defaults().pad(5f)
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"))
scenarioFromSavedGameSelectBox.items.add(savedGame)
if (savedGame.toLowerCase().endsWith("scenario"))
scenarioSelectBox.items.add(savedGame)
}
scenarioFromSavedGameSelectBox.onChange { selectSavedGameAsScenario(scenarioFromSavedGameSelectBox.selected) }
scenarioFromSavedGameSelectBox.selected = scenarioFileSelectBox.items.first()
scenarioFromSavedGameOptionsTable.add("{Scenario file}:".toLabel()).left()
scenarioFromSavedGameOptionsTable.add(scenarioFromSavedGameSelectBox)
scenarioSelectBox.onChange { selectSavedGameAsScenario(scenarioSelectBox.selected) }
scenarioSelectBox.items = scenarioSelectBox.items // it doesn't register them until you do this.
scenarioSelectBox.selected = scenarioMapSelectBox.items.first()
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) {
mapParameters.type = MapType.scenario
mapParameters.name = scenarioFileSelectBox.selected
mapTypeSpecificTable.add(savedScenarioOptionsTable)
} else if (mapTypeSelectBox.selected.value == MapType.scenarioMap) {
mapParameters.type = MapType.scenarioMap
mapParameters.name = scenarioMapSelectBox.selected
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){
selectSavedGameAsScenario(scenarioFromSavedGameSelectBox.selected)
mapTypeSpecificTable.add(scenarioFromSavedGameOptionsTable)
newGameScreen.updateRuleset()
} else if(mapTypeSelectBox.selected.value == MapType.scenario){
selectSavedGameAsScenario(scenarioSelectBox.selected)
mapTypeSpecificTable.add(scenarioOptionsTable)
newGameScreen.lockTables()
newGameScreen.updateTables()
} else { // generated map
mapParameters.name = ""
mapParameters.type = generatedMapOptionsTable.mapTypeSelectBox.selected.value

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

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