Added helper functions for onChange and selectboxes/checkboxes

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

@@ -66,12 +66,10 @@ class TileEditorOptionsTable(val mapEditorScreen: MapEditorScreen): Table(Camera
         val slider = Slider(1f,5f,1f, false, skin)
         val sliderLabel = "{Brush Size} $brushSize".toLabel()
 
-        slider.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        slider.onChange {
             brushSize = slider.getValue().toInt()
             sliderLabel.setText("{Brush Size} $brushSize".tr())
         }
-        })
 
         sliderTab.defaults().pad(5f)
         sliderTab.add(sliderLabel)

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

@@ -1,11 +1,8 @@
 package com.unciv.ui.newgamescreen
 
-import com.badlogic.gdx.scenes.scene2d.Actor
-import com.badlogic.gdx.scenes.scene2d.ui.Cell
 import com.badlogic.gdx.scenes.scene2d.ui.CheckBox
 import com.badlogic.gdx.scenes.scene2d.ui.SelectBox
 import com.badlogic.gdx.scenes.scene2d.ui.Table
-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
@@ -16,6 +13,7 @@ import com.unciv.models.ruleset.tech.TechEra
 import com.unciv.models.translations.tr
 import com.unciv.ui.utils.CameraStageBaseScreen
 import com.unciv.ui.utils.ImageGetter
+import com.unciv.ui.utils.onChange
 import com.unciv.ui.utils.toLabel
 
 class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlayerPickerTable:(desiredCiv:String)->Unit)
@@ -78,11 +76,7 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
         // activate once, so when we had a file map before we'll have the right things set for another one
         updateOnMapTypeChange()
 
-        mapTypeSelectBox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
-                updateOnMapTypeChange()
-            }
-        })
+        mapTypeSelectBox.onChange { updateOnMapTypeChange() }
 
         add(mapTypeSelectBox).row()
         add(mapTypeSpecificTable).colspan(2).row()
@@ -96,47 +90,35 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
         mapFileSelectBox.items = mapNames
         if (mapParameters.name in mapNames) mapFileSelectBox.selected = mapParameters.name
 
-        mapFileSelectBox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
-                mapParameters.name = mapFileSelectBox.selected!!
-            }
-        })
+        mapFileSelectBox.onChange { mapParameters.name = mapFileSelectBox.selected!! }
         return mapFileSelectBox
     }
 
+    private fun addCheckbox(text:String, initialState:Boolean, onChange:(newValue:Boolean)->Unit){
+        val checkbox = CheckBox(text.tr(), CameraStageBaseScreen.skin)
+        checkbox.isChecked = initialState
+        checkbox.onChange { onChange(checkbox.isChecked) }
+        add(checkbox).colspan(2).row()
+    }
 
     private fun addBarbariansCheckbox() {
-        val noBarbariansCheckbox = CheckBox("No barbarians".tr(), CameraStageBaseScreen.skin)
-        noBarbariansCheckbox.isChecked = newGameParameters.noBarbarians
-        noBarbariansCheckbox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
-                newGameParameters.noBarbarians = noBarbariansCheckbox.isChecked
-            }
-        })
-        add(noBarbariansCheckbox).colspan(2).row()
+        addCheckbox("No barbarians", newGameParameters.noBarbarians)
+            { newGameParameters.noBarbarians = it }
     }
 
     private fun addOneCityChallengeCheckbox() {
-        val oneCityChallengeCheckbox = CheckBox("One City Challenge".tr(), CameraStageBaseScreen.skin)
-        oneCityChallengeCheckbox.isChecked = newGameParameters.oneCityChallenge
-        oneCityChallengeCheckbox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
-                newGameParameters.oneCityChallenge = oneCityChallengeCheckbox.isChecked
-            }
-        })
-        add(oneCityChallengeCheckbox).colspan(2).row()
+        addCheckbox("One City Challenge", newGameParameters.oneCityChallenge)
+            { newGameParameters.oneCityChallenge = it }
     }
 
     private fun addIsOnlineMultiplayerCheckbox() {
 
         val isOnlineMultiplayerCheckbox = CheckBox("Online Multiplayer".tr(), CameraStageBaseScreen.skin)
         isOnlineMultiplayerCheckbox.isChecked = newGameParameters.isOnlineMultiplayer
-        isOnlineMultiplayerCheckbox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        isOnlineMultiplayerCheckbox.onChange {
             newGameParameters.isOnlineMultiplayer = isOnlineMultiplayerCheckbox.isChecked
             updatePlayerPickerTable("")
         }
-        })
         add(isOnlineMultiplayerCheckbox).colspan(2).row()
     }
 
@@ -149,46 +131,33 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
         cityStatesSelectBox.items = cityStatesArray
         cityStatesSelectBox.selected = newGameParameters.numberOfCityStates
         add(cityStatesSelectBox).row()
-        cityStatesSelectBox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        cityStatesSelectBox.onChange {
             newGameParameters.numberOfCityStates = cityStatesSelectBox.selected
         }
-        })
+    }
+
+    fun addSelectBox(text:String, values:Collection<String>, initialState:String, onChange: (newValue: String) -> Unit){
+        add(text.tr())
+        val selectBox = TranslatedSelectBox(values, initialState, CameraStageBaseScreen.skin)
+        selectBox.onChange { onChange(selectBox.selected.value) }
+        add(selectBox).fillX().row()
     }
 
     private fun addDifficultySelectBox() {
-        add("{Difficulty}:".tr())
-        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
-            }
-        })
-        add(difficultySelectBox).fillX().row()
+        addSelectBox("{Difficulty}:", ruleset.difficulties.keys, newGameParameters.difficulty)
+            {newGameParameters.difficulty = it}
     }
 
     private fun addGameSpeedSelectBox() {
-        add("{Game Speed}:".tr())
-        val gameSpeedSelectBox = TranslatedSelectBox(GameSpeed.values().map { it.name }, newGameParameters.gameSpeed.name, CameraStageBaseScreen.skin)
-        gameSpeedSelectBox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
-                newGameParameters.gameSpeed = GameSpeed.valueOf(gameSpeedSelectBox.selected.value)
-            }
-        })
-        add(gameSpeedSelectBox).fillX().row()
+        addSelectBox("{Game Speed}:", GameSpeed.values().map { it.name }, newGameParameters.gameSpeed.name)
+            {newGameParameters.gameSpeed = GameSpeed.valueOf(it)}
     }
 
     private fun addEraSelectBox() {
-        add("{Starting Era}:".tr())
         // The eras enum values are "Medieval" etc. but are shown to the player as "Medieval era".tr()
         // because in other languages "Medieval era" is one word
-        val eraSelectBox = TranslatedSelectBox(TechEra.values().map { it.name + " era" }, newGameParameters.startingEra.name + " era", CameraStageBaseScreen.skin)
-        eraSelectBox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
-                newGameParameters.startingEra = TechEra.valueOf(eraSelectBox.selected.value.replace(" era", ""))
-            }
-        })
-        add(eraSelectBox).fillX().row()
+        addSelectBox("{Starting Era}:", TechEra.values().map { it.name + " era" }, newGameParameters.startingEra.name + " era")
+            {newGameParameters.startingEra = TechEra.valueOf(it.replace(" era", ""))}
     }
 
 
@@ -203,8 +172,7 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
             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?) {
+            victoryCheckbox.onChange {
                 // If the checkbox is checked, adds the victoryTypes else remove it
                 if (victoryCheckbox.isChecked) {
                     newGameParameters.victoryTypes.add(victoryType)
@@ -212,7 +180,6 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
                     newGameParameters.victoryTypes.remove(victoryType)
                 }
             }
-            })
             victoryConditionsTable.add(victoryCheckbox).left()
             if (++i % 2 == 0) victoryConditionsTable.row()
         }
@@ -238,13 +205,12 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
         for(mod in modRulesets){
             val checkBox = CheckBox(mod.name.tr(),CameraStageBaseScreen.skin)
             if (mod.name in newGameParameters.mods) checkBox.isChecked = true
-            checkBox.addListener(object : ChangeListener() {
-                override fun changed(event: ChangeEvent?, actor: Actor?) {
-                    if(checkBox.isChecked) newGameParameters.mods.add(mod.name)
+            checkBox.onChange {
+                if (checkBox.isChecked) newGameParameters.mods.add(mod.name)
                 else newGameParameters.mods.remove(mod.name)
                 reloadMods()
                 var desiredCiv = ""
-                    if (checkBox.isChecked){
+                if (checkBox.isChecked) {
                     val modNations = RulesetCache[mod.name]?.nations
                     if (modNations != null && modNations.size > 0) {
                         desiredCiv = modNations.keys.first()
@@ -252,7 +218,6 @@ class NewGameScreenOptionsTable(val newGameScreen: NewGameScreen, val updatePlay
                 }
                 updatePlayerPickerTable(desiredCiv)
             }
-            })
             modCheckboxTable.add(checkBox).row()
         }
 

core/src/com/unciv/ui/saves/LoadGameScreen.kt

@@ -13,11 +13,7 @@ import com.unciv.logic.GameSaver
 import com.unciv.logic.UncivShowableException
 import com.unciv.models.translations.tr
 import com.unciv.ui.pickerscreens.PickerScreen
-import com.unciv.ui.utils.disable
-import com.unciv.ui.utils.enable
-import com.unciv.ui.utils.onClick
-import com.unciv.ui.utils.toLabel
-import com.unciv.ui.utils.Popup
+import com.unciv.ui.utils.*
 import java.text.SimpleDateFormat
 import java.util.*
 
@@ -96,11 +92,9 @@ class LoadGameScreen : PickerScreen() {
         rightSideTable.add(copySavedGameToClipboardButton).row()
 
         showAutosavesCheckbox.isChecked = false
-        showAutosavesCheckbox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        showAutosavesCheckbox.onChange {
                 updateLoadableGames(showAutosavesCheckbox.isChecked)
             }
-        })
         rightSideTable.add(showAutosavesCheckbox).row()
         return rightSideTable
     }

core/src/com/unciv/ui/saves/SaveGameScreen.kt

@@ -10,6 +10,7 @@ import com.unciv.logic.GameSaver
 import com.unciv.models.translations.tr
 import com.unciv.ui.pickerscreens.PickerScreen
 import com.unciv.ui.utils.enable
+import com.unciv.ui.utils.onChange
 import com.unciv.ui.utils.onClick
 import com.unciv.ui.utils.toLabel
 import kotlin.concurrent.thread
@@ -44,11 +45,9 @@ class SaveGameScreen : PickerScreen() {
 
         val showAutosavesCheckbox = CheckBox("Show autosaves".tr(), skin)
         showAutosavesCheckbox.isChecked = false
-        showAutosavesCheckbox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        showAutosavesCheckbox.onChange {
                 updateShownSaves(showAutosavesCheckbox.isChecked)
             }
-        })
         newSave.add(showAutosavesCheckbox).row()
 
         topTable.add(newSave)

core/src/com/unciv/ui/utils/CameraStageBaseScreen.kt

@@ -9,6 +9,7 @@ import com.badlogic.gdx.graphics.g2d.Batch
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.badlogic.gdx.scenes.scene2d.*
 import com.badlogic.gdx.scenes.scene2d.ui.*
+import com.badlogic.gdx.scenes.scene2d.utils.ChangeListener
 import com.badlogic.gdx.scenes.scene2d.utils.ClickListener
 import com.badlogic.gdx.utils.viewport.ExtendViewport
 import com.unciv.UncivGame
@@ -142,6 +143,14 @@ fun Actor.onClick(function: () -> Unit): Actor {
     return this
 }
 
+fun Actor.onChange(function: () -> Unit){
+    this.addListener(object : ChangeListener() {
+        override fun changed(event: ChangeEvent?, actor: Actor?) {
+            function()
+        }
+    })
+}
+
 fun Actor.surroundWithCircle(size:Float,resizeActor:Boolean=true): IconCircleGroup {
     return IconCircleGroup(size,this,resizeActor)
 }

core/src/com/unciv/ui/worldscreen/mainmenu/WorldScreenOptionsPopup.kt

@@ -186,13 +186,11 @@ class WorldScreenOptionsPopup(val worldScreen:WorldScreen) : Popup(worldScreen){
 
         val soundEffectsVolumeSlider = Slider(0f, 1.0f, 0.1f, false, skin)
         soundEffectsVolumeSlider.value = UncivGame.Current.settings.soundEffectsVolume
-        soundEffectsVolumeSlider.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        soundEffectsVolumeSlider.onChange {
                 UncivGame.Current.settings.soundEffectsVolume = soundEffectsVolumeSlider.value
                 UncivGame.Current.settings.save()
                 Sounds.play(UncivSound.Click)
             }
-        })
         innerTable.add(soundEffectsVolumeSlider).pad(10f).row()
     }
 
@@ -203,18 +201,16 @@ class WorldScreenOptionsPopup(val worldScreen:WorldScreen) : Popup(worldScreen){
 
             val musicVolumeSlider = Slider(0f, 1.0f, 0.1f, false, skin)
             musicVolumeSlider.value = UncivGame.Current.settings.musicVolume
-            musicVolumeSlider.addListener(object : ChangeListener() {
-                override fun changed(event: ChangeEvent?, actor: Actor?) {
+            musicVolumeSlider.onChange {
                 UncivGame.Current.settings.musicVolume = musicVolumeSlider.value
                 UncivGame.Current.settings.save()
 
                 val music = UncivGame.Current.music
                 if (music == null) // restart music, if it was off at the app start
-                        thread(name="Music") { UncivGame.Current.startMusic() }
+                    thread(name = "Music") { UncivGame.Current.startMusic() }
 
                 music?.volume = 0.4f * musicVolumeSlider.value
             }
-            })
             innerTable.add(musicVolumeSlider).pad(10f).row()
         }
         else{
@@ -253,15 +249,13 @@ class WorldScreenOptionsPopup(val worldScreen:WorldScreen) : Popup(worldScreen){
         resolutionSelectBox.selected = UncivGame.Current.settings.resolution
         innerTable.add(resolutionSelectBox).minWidth(240f).pad(10f).row()
 
-        resolutionSelectBox.addListener(object : ChangeListener() {
-            override fun changed(event: ChangeEvent?, actor: Actor?) {
+        resolutionSelectBox.onChange {
             UncivGame.Current.settings.resolution = resolutionSelectBox.selected
             UncivGame.Current.settings.save()
             UncivGame.Current.worldScreen = WorldScreen(worldScreen.viewingCiv)
             UncivGame.Current.setWorldScreen()
             WorldScreenOptionsPopup(UncivGame.Current.worldScreen).open()
         }
-        })
     }
 
     private fun addTileSetSelectBox(innerTable: Table) {