chore: File reorg

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

@@ -6,7 +6,7 @@ import com.unciv.json.HashMapVector2
 import com.unciv.json.json
 import com.unciv.logic.city.CityConstructions
 import com.unciv.logic.city.PerpetualConstruction
-import com.unciv.logic.civilization.TechManager
+import com.unciv.logic.civilization.managers.TechManager
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.civilization.diplomacy.DiplomacyManager
 import com.unciv.models.ruleset.ModOptions

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

@@ -17,7 +17,7 @@ import com.unciv.logic.civilization.LocationAction
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon
 import com.unciv.logic.civilization.PlayerType
-import com.unciv.logic.civilization.TechManager
+import com.unciv.logic.civilization.managers.TechManager
 import com.unciv.logic.map.TileInfo
 import com.unciv.logic.map.TileMap
 import com.unciv.models.Religion

core/src/com/unciv/logic/automation/civilization/NextTurnAutomation.kt

@@ -16,7 +16,7 @@ import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon
 import com.unciv.logic.civilization.PlayerType
 import com.unciv.logic.civilization.PopupAlert
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.civilization.diplomacy.DiplomaticModifiers
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus

core/src/com/unciv/logic/automation/civilization/ReligionAutomation.kt

@@ -4,7 +4,7 @@ import com.unciv.Constants
 import com.unciv.logic.city.CityInfo
 import com.unciv.logic.city.INonPerpetualConstruction
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.logic.map.TileInfo
 import com.unciv.models.ruleset.Belief
 import com.unciv.models.ruleset.BeliefType

core/src/com/unciv/logic/automation/unit/UnitAutomation.kt

@@ -10,7 +10,7 @@ import com.unciv.logic.battle.ICombatant
 import com.unciv.logic.battle.MapUnitCombatant
 import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.NotificationCategory
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
 import com.unciv.logic.map.MapUnit
 import com.unciv.logic.map.TileInfo

core/src/com/unciv/logic/city/CityInfo.kt

@@ -3,11 +3,16 @@ package com.unciv.logic.city
 import com.badlogic.gdx.math.Vector2
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.battle.CityCombatant
+import com.unciv.logic.city.managers.CityEspionageManager
+import com.unciv.logic.city.managers.CityExpansionManager
+import com.unciv.logic.city.managers.CityInfoConquestFunctions
+import com.unciv.logic.city.managers.CityPopulationManager
+import com.unciv.logic.city.managers.CityReligionManager
 import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon
 import com.unciv.logic.civilization.Proximity
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.map.RoadStatus
 import com.unciv.logic.map.TileInfo
@@ -109,7 +114,7 @@ class CityInfo : IsPartOfGameInfoSerialization {
     var health = 200
 
 
-    var population = PopulationManager()
+    var population = CityPopulationManager()
     var cityConstructions = CityConstructions()
     var expansion = CityExpansionManager()
     var religion = CityReligionManager()

core/src/com/unciv/logic/city/managers/CityEspionageManager.kt

@@ -1,6 +1,7 @@
-package com.unciv.logic.city
+package com.unciv.logic.city.managers
 
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.CivilizationInfo
 
 class CityEspionageManager : IsPartOfGameInfoSerialization{

core/src/com/unciv/logic/city/managers/CityExpansionManager.kt

@@ -1,8 +1,9 @@
-package com.unciv.logic.city
+package com.unciv.logic.city.managers
 
 import com.badlogic.gdx.math.Vector2
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.automation.Automation
+import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.LocationAction
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon

core/src/com/unciv/logic/city/managers/CityInfoConquestFunctions.kt

@@ -1,8 +1,10 @@
-package com.unciv.logic.city
+package com.unciv.logic.city.managers
 
 import com.unciv.Constants
 import com.unciv.UncivGame
 import com.unciv.logic.battle.Battle
+import com.unciv.logic.city.CityFlags
+import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon

core/src/com/unciv/logic/city/managers/CityPopulationManager.kt

@@ -1,7 +1,8 @@
-package com.unciv.logic.city
+package com.unciv.logic.city.managers
 
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.automation.Automation
+import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon
 import com.unciv.logic.map.TileInfo
@@ -14,7 +15,7 @@ import com.unciv.ui.utils.extensions.withoutItem
 import kotlin.math.floor
 import kotlin.math.pow
 
-class PopulationManager : IsPartOfGameInfoSerialization {
+class CityPopulationManager : IsPartOfGameInfoSerialization {
     @Transient
     lateinit var cityInfo: CityInfo
 
@@ -29,8 +30,8 @@ class PopulationManager : IsPartOfGameInfoSerialization {
 
 
     //region pure functions
-    fun clone(): PopulationManager {
-        val toReturn = PopulationManager()
+    fun clone(): CityPopulationManager {
+        val toReturn = CityPopulationManager()
         toReturn.specialistAllocations.add(specialistAllocations)
         toReturn.population = population
         toReturn.foodStored = foodStored

core/src/com/unciv/logic/city/managers/CityReligionManager.kt

@@ -1,7 +1,8 @@
-package com.unciv.logic.city
+package com.unciv.logic.city.managers
 
 import com.unciv.Constants
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon
 import com.unciv.models.Counter

core/src/com/unciv/logic/civilization/CivilizationInfo.kt

@@ -12,10 +12,22 @@ import com.unciv.logic.automation.ai.TacticalAI
 import com.unciv.logic.automation.civilization.NextTurnAutomation
 import com.unciv.logic.automation.unit.WorkerAutomation
 import com.unciv.logic.city.CityInfo
-import com.unciv.logic.civilization.RuinsManager.RuinsManager
+import com.unciv.logic.civilization.diplomacy.CityStateFunctions
+import com.unciv.logic.civilization.diplomacy.CityStatePersonality
+import com.unciv.logic.civilization.managers.EspionageManager
+import com.unciv.logic.civilization.managers.GoldenAgeManager
+import com.unciv.logic.civilization.managers.GreatPersonManager
+import com.unciv.logic.civilization.managers.PolicyManager
+import com.unciv.logic.civilization.managers.QuestManager
+import com.unciv.logic.civilization.managers.ReligionManager
+import com.unciv.logic.civilization.managers.RuinsManager
+import com.unciv.logic.civilization.managers.TechManager
+import com.unciv.logic.civilization.managers.VictoryManager
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.civilization.diplomacy.DiplomacyManager
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
+import com.unciv.logic.civilization.transients.CivInfoStatsForNextTurn
+import com.unciv.logic.civilization.transients.CivInfoTransientCache
 import com.unciv.logic.map.MapUnit
 import com.unciv.logic.map.TileInfo
 import com.unciv.logic.map.UnitMovementAlgorithms

core/src/com/unciv/logic/civilization/WonderInfo.kt

@@ -1,191 +0,0 @@
-package com.unciv.logic.civilization
-
-import com.badlogic.gdx.graphics.Color
-import com.unciv.UncivGame
-import com.unciv.logic.city.CityInfo
-import com.unciv.logic.map.TileInfo
-import com.unciv.models.ruleset.Building
-import com.unciv.models.ruleset.Era
-import com.unciv.models.ruleset.QuestName
-import com.unciv.models.ruleset.unique.UniqueType
-import com.unciv.models.translations.tr
-import com.unciv.ui.civilopedia.CivilopediaCategories
-
-class WonderInfo {
-    val gameInfo = UncivGame.Current.gameInfo!!
-    val viewingPlayer = gameInfo.getCurrentPlayerCivilization()
-    val ruleSet = gameInfo.ruleSet
-    private val hideReligionItems = !gameInfo.isReligionEnabled()
-    private val viewerEra = viewingPlayer.getEraNumber()
-    private val startingObsolete = ruleSet.eras[gameInfo.gameParameters.startingEra]!!.startingObsoleteWonders
-
-    enum class WonderStatus(val label: String) {
-        Hidden(""),
-        Unknown("Unknown"),
-        Unbuilt("Not built"),
-        NotFound("Not found"),
-        Known("Known"),
-        Owned("Owned")
-    }
-
-    class WonderInfo (
-        val name: String,
-        val category: CivilopediaCategories,
-        val groupName: String,
-        val groupColor: Color,
-        val status: WonderStatus,
-        val civ: CivilizationInfo?,
-        val city: CityInfo?,
-        val location: TileInfo?
-    ) {
-        val viewEntireMapForDebug = UncivGame.Current.viewEntireMapForDebug
-
-        fun getImage() = if (status == WonderStatus.Unknown && !viewEntireMapForDebug) null
-        else category.getImage?.invoke(name, if (category == CivilopediaCategories.Terrain) 50f else 45f)
-
-        fun getNameColumn() = when {
-            viewEntireMapForDebug -> name
-            status == WonderStatus.Unknown -> status.label
-            else -> name
-        }
-
-        fun getStatusColumn() = when {
-            status != WonderStatus.Known -> status.label
-            civ == null -> status.label
-            else -> civ.civName
-        }
-
-        fun getLocationColumn() = when {
-            status <= WonderStatus.NotFound -> ""
-            location == null -> ""
-            location.isCityCenter() -> location.getCity()!!.name
-            location.getCity() != null -> "Near [${location.getCity()!!}]"
-            city != null -> "Somewhere around [$city]"
-            viewEntireMapForDebug -> location.position.toString()
-            else -> "Far away"
-        }
-    }
-
-    private fun shouldBeDisplayed(wonder: Building, wonderEra: Int) = when {
-        wonder.hasUnique(UniqueType.HiddenFromCivilopedia) -> false
-        wonder.hasUnique(UniqueType.HiddenWithoutReligion) && hideReligionItems -> false
-        wonder.name in startingObsolete -> false
-        wonder.getMatchingUniques(UniqueType.HiddenWithoutVictoryType)
-            .any { unique ->
-                !gameInfo.gameParameters.victoryTypes.contains(unique.params[0])
-            } -> false
-        else -> wonderEra <= viewerEra
-    }
-
-    /** Do we know about a natural wonder despite not having found it yet? */
-    private fun knownFromQuest(name: String): Boolean {
-        // No, *your* civInfo's QuestManager has no idea about your quests
-        for (civ in gameInfo.civilizations) {
-            for (quest in civ.questManager.assignedQuests) {
-                if (quest.assignee != viewingPlayer.civName) continue
-                if (quest.questName == QuestName.FindNaturalWonder.value && quest.data1 == name)
-                    return true
-            }
-        }
-        return false
-    }
-
-    fun collectInfo(): Array<WonderInfo> {
-        val collator = UncivGame.Current.settings.getCollatorFromLocale()
-
-        // Maps all World Wonders by name to their era for grouping
-        val wonderEraMap: Map<String, Era> =
-                ruleSet.buildings.values.asSequence()
-                    .filter { it.isWonder }
-                    .associate { it.name to (ruleSet.eras[ruleSet.technologies[it.requiredTech]?.era()] ?: viewingPlayer.getEra()) }
-
-        // Maps all World Wonders by their position in sort order to their name
-        val allWonderMap: Map<Int, String> =
-                ruleSet.buildings.values.asSequence()
-                    .filter { it.isWonder }
-                    .sortedWith(compareBy<Building> { wonderEraMap[it.name]!!.eraNumber }.thenBy(collator) { it.name.tr() })
-                    .withIndex()
-                    .associate { it.index to it.value.name }
-        val wonderCount = allWonderMap.size
-
-        // Inverse of the above
-        val wonderIndexMap: Map<String, Int> = allWonderMap.map { it.value to it.key }.toMap()
-
-        // Maps all Natural Wonders on the map by name to their tile
-        val allNaturalsMap: Map<String, TileInfo> =
-                gameInfo.tileMap.values.asSequence()
-                    .filter { it.isNaturalWonder() }
-                    .associateBy { it.naturalWonder!! }
-        val naturalsCount = allNaturalsMap.size
-
-        // Natural Wonders sort order index to name
-        val naturalsIndexMap: Map<Int, String> = allNaturalsMap.keys
-            .sortedWith(compareBy(collator) { it.tr() })
-            .withIndex()
-            .associate { it.index to it.value }
-
-        // Pre-populate result with "Unknown" entries
-        val wonders = Array(wonderCount + naturalsCount) { index ->
-            if (index < wonderCount) {
-                val wonder = ruleSet.buildings[allWonderMap[index]!!]!!
-                val era = wonderEraMap[wonder.name]!!
-                val status = if (shouldBeDisplayed(wonder, era.eraNumber)) WonderStatus.Unbuilt else WonderStatus.Hidden
-                WonderInfo(
-                    allWonderMap[index]!!, CivilopediaCategories.Wonder,
-                    era.name, era.getColor(), status, null, null, null
-                )
-            } else {
-                WonderInfo(
-                    naturalsIndexMap[index - wonderCount]!!,
-                    CivilopediaCategories.Terrain,
-                    "Natural Wonders",
-                    Color.FOREST,
-                    WonderStatus.Unknown,
-                    null,
-                    null,
-                    null
-                )
-            }
-        }
-
-        for (city in gameInfo.getCities()) {
-            for (wonderName in city.cityConstructions.builtBuildings.intersect(wonderIndexMap.keys)) {
-                val index = wonderIndexMap[wonderName]!!
-                val status = when {
-                    viewingPlayer == city.civInfo -> WonderStatus.Owned
-                    viewingPlayer.hasExplored(city.location) -> WonderStatus.Known
-                    else -> WonderStatus.NotFound
-                }
-                wonders[index] = WonderInfo(
-                    wonderName, CivilopediaCategories.Wonder,
-                    wonders[index].groupName, wonders[index].groupColor,
-                    status, city.civInfo, city, city.getCenterTile()
-                )
-            }
-        }
-
-        for ((index, name) in naturalsIndexMap) {
-            val tile = allNaturalsMap[name]!!
-            val civ = tile.getOwner()
-            val status = when {
-                civ == viewingPlayer -> WonderStatus.Owned
-                name in viewingPlayer.naturalWonders -> WonderStatus.Known
-                else -> WonderStatus.NotFound
-            }
-            if (status == WonderStatus.NotFound && !knownFromQuest(name)) continue
-            val city = if (status == WonderStatus.NotFound) null
-            else tile.getTilesInDistance(5)
-                .filter { it.isCityCenter() }
-                .filter { viewingPlayer.knows(it.getOwner()!!) }
-                .filter { viewingPlayer.hasExplored(it) }
-                .sortedBy { it.aerialDistanceTo(tile) }
-                .firstOrNull()?.getCity()
-            wonders[index + wonderCount] = WonderInfo(
-                name, CivilopediaCategories.Terrain,
-                "Natural Wonders", Color.FOREST, status, civ, city, tile
-            )
-        }
-
-        return wonders
-    }
-}

core/src/com/unciv/logic/civilization/diplomacy/CityStateFunctions.kt

@@ -1,11 +1,17 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.diplomacy
 
 import com.unciv.Constants
 import com.unciv.logic.automation.civilization.NextTurnAutomation
-import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
-import com.unciv.logic.civilization.diplomacy.DiplomaticModifiers
-import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
-import com.unciv.logic.civilization.diplomacy.RelationshipLevel
+import com.unciv.logic.civilization.AlertType
+import com.unciv.logic.civilization.CivFlags
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.DiplomacyAction
+import com.unciv.logic.civilization.LocationAction
+import com.unciv.logic.civilization.NotificationCategory
+import com.unciv.logic.civilization.NotificationIcon
+import com.unciv.logic.civilization.PlayerType
+import com.unciv.logic.civilization.PopupAlert
+import com.unciv.logic.civilization.Proximity
 import com.unciv.models.ruleset.CityStateType
 import com.unciv.models.ruleset.Ruleset
 import com.unciv.models.ruleset.tile.ResourceSupplyList
@@ -75,7 +81,8 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
         val placedUnit = receivingCiv.placeUnitNearTile(cities.city1.location, giftedUnit.name)
             ?: return
         val locations = LocationAction(placedUnit.getTile().position, cities.city2.location)
-        receivingCiv.addNotification( "[${civInfo.civName}] gave us a [${giftedUnit.name}] as a gift!", locations, NotificationCategory.Units, civInfo.civName, giftedUnit.name)
+        receivingCiv.addNotification( "[${civInfo.civName}] gave us a [${giftedUnit.name}] as a gift!", locations,
+            NotificationCategory.Units, civInfo.civName, giftedUnit.name)
     }
 
     fun giveMilitaryUnitToPatron(receivingCiv: CivilizationInfo) {
@@ -231,8 +238,14 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
             if (newAllyName != null) {
                 val newAllyCiv = civInfo.gameInfo.getCivilization(newAllyName)
                 val text = "We have allied with [${civInfo.civName}]."
-                if (capitalLocation != null) newAllyCiv.addNotification(text, capitalLocation, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy)
-                else newAllyCiv.addNotification(text, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy)
+                if (capitalLocation != null) newAllyCiv.addNotification(text, capitalLocation,
+                    NotificationCategory.Diplomacy, civInfo.civName,
+                    NotificationIcon.Diplomacy
+                )
+                else newAllyCiv.addNotification(text,
+                    NotificationCategory.Diplomacy, civInfo.civName,
+                    NotificationIcon.Diplomacy
+                )
                 newAllyCiv.cache.updateViewableTiles()
                 newAllyCiv.cache.updateCivResources()
                 for (unique in newAllyCiv.getMatchingUniques(UniqueType.CityStateCanBeBoughtForGold))
@@ -252,8 +265,14 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
             if (oldAllyName != null) {
                 val oldAllyCiv = civInfo.gameInfo.getCivilization(oldAllyName)
                 val text = "We have lost alliance with [${civInfo.civName}]."
-                if (capitalLocation != null) oldAllyCiv.addNotification(text, capitalLocation, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy)
-                else oldAllyCiv.addNotification(text, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy)
+                if (capitalLocation != null) oldAllyCiv.addNotification(text, capitalLocation,
+                    NotificationCategory.Diplomacy, civInfo.civName,
+                    NotificationIcon.Diplomacy
+                )
+                else oldAllyCiv.addNotification(text,
+                    NotificationCategory.Diplomacy, civInfo.civName,
+                    NotificationIcon.Diplomacy
+                )
                 oldAllyCiv.cache.updateViewableTiles()
                 oldAllyCiv.cache.updateCivResources()
             }
@@ -291,10 +310,14 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
 
         otherCiv.addGold(-getDiplomaticMarriageCost())
         otherCiv.addNotification("We have married into the ruling family of [${civInfo.civName}], bringing them under our control.",
-            civInfo.getCapital()!!.location, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy, otherCiv.civName)
+            civInfo.getCapital()!!.location,
+            NotificationCategory.Diplomacy, civInfo.civName,
+            NotificationIcon.Diplomacy, otherCiv.civName)
         for (civ in civInfo.gameInfo.civilizations.filter { it != otherCiv })
             civ.addNotification("[${otherCiv.civName}] has married into the ruling family of [${civInfo.civName}], bringing them under their control.",
-                civInfo.getCapital()!!.location, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy, otherCiv.civName)
+                civInfo.getCapital()!!.location,
+                NotificationCategory.Diplomacy, civInfo.civName,
+                NotificationIcon.Diplomacy, otherCiv.civName)
         for (unit in civInfo.getCivUnits())
             unit.gift(otherCiv)
 
@@ -503,8 +526,11 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
                 bully.addNotification("[${protector.civName}] is upset that you demanded tribute from [${civInfo.civName}], whom they have pledged to protect!",
                     NotificationCategory.Diplomacy, NotificationIcon.Diplomacy, protector.civName)
             else    // Let humans choose who to side with
-                protector.popupAlerts.add(PopupAlert(AlertType.BulliedProtectedMinor,
-                    bully.civName + "@" + civInfo.civName))   // we need to pass both civs as argument, hence the horrible chimera
+                protector.popupAlerts.add(
+                    PopupAlert(
+                        AlertType.BulliedProtectedMinor,
+                    bully.civName + "@" + civInfo.civName)
+                )   // we need to pass both civs as argument, hence the horrible chimera
         }
 
         // Set a diplomatic flag so we remember for future quests (and not to give them any)
@@ -585,8 +611,11 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
                 attacker.addNotification("[${protector.civName}] is upset that you attacked [${civInfo.civName}], whom they have pledged to protect!",
                     NotificationCategory.Diplomacy, NotificationIcon.Diplomacy, protector.civName)
             else    // Let humans choose who to side with
-                protector.popupAlerts.add(PopupAlert(AlertType.AttackedProtectedMinor,
-                    attacker.civName + "@" + civInfo.civName))   // we need to pass both civs as argument, hence the horrible chimera
+                protector.popupAlerts.add(
+                    PopupAlert(
+                        AlertType.AttackedProtectedMinor,
+                    attacker.civName + "@" + civInfo.civName)
+                )   // we need to pass both civs as argument, hence the horrible chimera
         }
 
         // Set up war with major pseudo-quest

core/src/com/unciv/logic/civilization/diplomacy/CityStatePersonality.kt

@@ -1,4 +1,4 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.diplomacy
 
 enum class CityStatePersonality {
     Friendly,

core/src/com/unciv/logic/civilization/diplomacy/DiplomacyManager.kt

@@ -4,7 +4,6 @@ import com.badlogic.gdx.graphics.Color
 import com.unciv.Constants
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.civilization.AlertType
-import com.unciv.logic.civilization.CityStatePersonality
 import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon

core/src/com/unciv/logic/civilization/managers/EspionageManager.kt

@@ -1,9 +1,9 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.Constants
-import com.unciv.logic.GameInfo
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.city.CityInfo
+import com.unciv.logic.civilization.CivilizationInfo
 
 enum class SpyAction(val stringName: String) {
     None("None"),

core/src/com/unciv/logic/civilization/managers/GoldenAgeManager.kt

@@ -1,6 +1,10 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.civilization.AlertType
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.NotificationCategory
+import com.unciv.logic.civilization.PopupAlert
 import com.unciv.models.ruleset.unique.UniqueTriggerActivation
 import com.unciv.models.ruleset.unique.UniqueType
 import com.unciv.ui.utils.extensions.toPercent

core/src/com/unciv/logic/civilization/managers/GreatPersonManager.kt

@@ -1,6 +1,7 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.models.Counter
 
 // todo: Great Admiral?

core/src/com/unciv/logic/civilization/managers/PolicyManager.kt

@@ -1,6 +1,9 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.NotificationCategory
+import com.unciv.logic.civilization.NotificationIcon
 import com.unciv.logic.map.MapSize
 import com.unciv.models.ruleset.Policy
 import com.unciv.models.ruleset.Policy.PolicyBranchType
@@ -237,7 +240,9 @@ class PolicyManager : IsPartOfGameInfoSerialization {
                 "An unknown civilization has adopted the [${policy.name}] policy"
             }
             civ.addNotification(
-                "{${defaultNotificationText}}{${extraNotificationTextCopy}}", NotificationCategory.General, NotificationIcon.Culture
+                "{${defaultNotificationText}}{${extraNotificationTextCopy}}",
+                NotificationCategory.General,
+                NotificationIcon.Culture
             )
         }
     }

core/src/com/unciv/logic/civilization/managers/QuestManager.kt

@@ -1,10 +1,18 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.badlogic.gdx.math.Vector2
 import com.unciv.Constants
 import com.unciv.UncivGame
 import com.unciv.logic.GameInfo
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.civilization.diplomacy.CityStatePersonality
+import com.unciv.logic.civilization.CivFlags
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.DiplomacyAction
+import com.unciv.logic.civilization.NotificationCategory
+import com.unciv.logic.civilization.NotificationIcon
+import com.unciv.logic.civilization.PlayerType
+import com.unciv.logic.civilization.Proximity
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
 import com.unciv.logic.map.TileInfo
@@ -163,7 +171,9 @@ class QuestManager : IsPartOfGameInfoSerialization {
                 if (civInfo.gameInfo.turns == INDIVIDUAL_QUEST_FIRST_POSSIBLE_TURN)
                     Random.nextInt(INDIVIDUAL_QUEST_FIRST_POSSIBLE_TURN_RAND)
                 else
-                    INDIVIDUAL_QUEST_MIN_TURNS_BETWEEN + Random.nextInt(INDIVIDUAL_QUEST_RAND_TURNS_BETWEEN)
+                    INDIVIDUAL_QUEST_MIN_TURNS_BETWEEN + Random.nextInt(
+                        INDIVIDUAL_QUEST_RAND_TURNS_BETWEEN
+                    )
 
         individualQuestCountdown[challenger.civName] = (countdown * civInfo.gameInfo.speed.modifier).toInt()
     }
@@ -225,9 +235,13 @@ class QuestManager : IsPartOfGameInfoSerialization {
                     it.isMajorCiv()
                     && it.isAlive()
                     && !it.isAtWarWith(civInfo)
-                    && it.getProximity(civInfo) <= Proximity.Far }) {
+                    && it.getProximity(civInfo) <= Proximity.Far
+            }) {
                 otherCiv.addNotification("[${civInfo.civName}] is being invaded by Barbarians! Destroy Barbarians near their territory to earn Influence.",
-                    civInfo.getCapital()!!.location, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.War)
+                    civInfo.getCapital()!!.location,
+                    NotificationCategory.Diplomacy, civInfo.civName,
+                    NotificationIcon.War
+                )
             }
             civInfo.addFlag(CivFlags.TurnsTillCallForBarbHelp.name, 30)
         }
@@ -334,7 +348,8 @@ class QuestManager : IsPartOfGameInfoSerialization {
 
             assignedQuests.add(newQuest)
             assignee.addNotification("[${civInfo.civName}] assigned you a new quest: [${quest.name}].",
-                    DiplomacyAction(civInfo.civName), NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
+                    DiplomacyAction(civInfo.civName),
+                NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
 
             if (quest.isIndividual())
                 individualQuestCountdown[assignee.civName] = UNSET
@@ -440,11 +455,13 @@ class QuestManager : IsPartOfGameInfoSerialization {
         if (winners.isEmpty()) {
             assignee.addNotification(
                     "[${civInfo.civName}] no longer needs your help with the [${assignedQuest.questName}] quest.",
-                    civInfo.getCapital()!!.location, NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
+                    civInfo.getCapital()!!.location,
+                NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
         } else {
             assignee.addNotification(
                     "The [${assignedQuest.questName}] quest for [${civInfo.civName}] has ended. It was won by [${winners.joinToString { it.assignee.tr() }}].",
-                    civInfo.getCapital()!!.location, NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
+                    civInfo.getCapital()!!.location,
+                NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
         }
     }
 
@@ -524,7 +541,8 @@ class QuestManager : IsPartOfGameInfoSerialization {
             assignedQuests.removeAll(revokedQuests)
             if (revokedQuests.count() > 0)
                 bully.addNotification("[${civInfo.civName}] cancelled the quests they had given you because you demanded tribute from them.",
-                    DiplomacyAction(civInfo.civName), NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
+                    DiplomacyAction(civInfo.civName),
+                    NotificationCategory.Diplomacy, civInfo.civName, "OtherIcons/Quest")
         }
     }
 

core/src/com/unciv/logic/civilization/managers/ReligionManager.kt

@@ -1,8 +1,9 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.Constants
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.city.CityInfo
+import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.logic.map.MapUnit
 import com.unciv.models.Counter
 import com.unciv.models.Religion

core/src/com/unciv/logic/civilization/managers/RuinsManager.kt

@@ -1,4 +1,4 @@
-package com.unciv.logic.civilization.RuinsManager
+package com.unciv.logic.civilization.managers
 // Why is this the only file in its own package?
 
 import com.unciv.logic.IsPartOfGameInfoSerialization

core/src/com/unciv/logic/civilization/managers/TechManager.kt

@@ -1,7 +1,16 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.logic.IsPartOfGameInfoSerialization
 import com.unciv.logic.city.CityInfo
+import com.unciv.logic.civilization.AlertType
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.LocationAction
+import com.unciv.logic.civilization.MayaLongCountAction
+import com.unciv.logic.civilization.NotificationCategory
+import com.unciv.logic.civilization.NotificationIcon
+import com.unciv.logic.civilization.PlayerType
+import com.unciv.logic.civilization.PopupAlert
+import com.unciv.logic.civilization.TechAction
 import com.unciv.logic.map.MapSize
 import com.unciv.logic.map.RoadStatus
 import com.unciv.models.ruleset.Era
@@ -263,7 +272,9 @@ class TechManager : IsPartOfGameInfoSerialization {
             city.updateCitizens = true
         }
 
-        civInfo.addNotification("Research of [$techName] has completed!", TechAction(techName), NotificationCategory.General, NotificationIcon.Science, techName)
+        civInfo.addNotification("Research of [$techName] has completed!", TechAction(techName),
+            NotificationCategory.General,
+            NotificationIcon.Science, techName)
         if (isNewTech)
             civInfo.popupAlerts.add(PopupAlert(AlertType.TechResearched, techName))
 
@@ -300,19 +311,29 @@ class TechManager : IsPartOfGameInfoSerialization {
                 val city = cities.first()
                 if (construction is BaseUnit && construction.upgradesTo != null) {
                     val text = "[${city.name}] changed production from [$unit] to [${construction.upgradesTo!!}]"
-                    civInfo.addNotification(text, city.location, NotificationCategory.Production, unit, NotificationIcon.Construction, construction.upgradesTo!!)
+                    civInfo.addNotification(text, city.location,
+                        NotificationCategory.Production, unit,
+                        NotificationIcon.Construction, construction.upgradesTo!!)
                 } else {
                     val text = "[$unit] has become obsolete and was removed from the queue in [${city.name}]!"
-                    civInfo.addNotification(text, city.location, NotificationCategory.Production, NotificationIcon.Construction)
+                    civInfo.addNotification(text, city.location,
+                        NotificationCategory.Production,
+                        NotificationIcon.Construction
+                    )
                 }
             } else {
                 val locationAction = LocationAction(cities.asSequence().map { it.location })
                 if (construction is BaseUnit && construction.upgradesTo != null) {
                     val text = "[${cities.size}] cities changed production from [$unit] to [${construction.upgradesTo!!}]"
-                    civInfo.addNotification(text, locationAction, NotificationCategory.Production, unit, NotificationIcon.Construction, construction.upgradesTo!!)
+                    civInfo.addNotification(text, locationAction,
+                        NotificationCategory.Production, unit,
+                        NotificationIcon.Construction, construction.upgradesTo!!)
                 } else {
                     val text = "[$unit] has become obsolete and was removed from the queue in [${cities.size}] cities!"
-                    civInfo.addNotification(text, locationAction, NotificationCategory.Production, NotificationIcon.Construction)
+                    civInfo.addNotification(text, locationAction,
+                        NotificationCategory.Production,
+                        NotificationIcon.Construction
+                    )
                 }
             }
         }
@@ -331,15 +352,22 @@ class TechManager : IsPartOfGameInfoSerialization {
         updateEra()
         val currentEra = civInfo.getEra()
         if (previousEra != currentEra) {
-            civInfo.addNotification("You have entered the [$currentEra]!", NotificationCategory.General, NotificationIcon.Science)
+            civInfo.addNotification("You have entered the [$currentEra]!",
+                NotificationCategory.General,
+                NotificationIcon.Science
+            )
             if (civInfo.isMajorCiv()) {
                 for (knownCiv in civInfo.getKnownCivs()) {
                     knownCiv.addNotification("[${civInfo.civName}] has entered the [$currentEra]!",
-                        NotificationCategory.General, civInfo.civName, NotificationIcon.Science)
+                        NotificationCategory.General, civInfo.civName, NotificationIcon.Science
+                    )
                 }
             }
             for (policyBranch in getRuleset().policyBranches.values.filter { it.era == currentEra.name && civInfo.policies.isAdoptable(it) }) {
-                civInfo.addNotification("[${policyBranch.name}] policy branch unlocked!", NotificationCategory.General, NotificationIcon.Culture)
+                civInfo.addNotification("[${policyBranch.name}] policy branch unlocked!",
+                    NotificationCategory.General,
+                    NotificationIcon.Culture
+                )
             }
 
             val erasPassed = getRuleset().eras.values

core/src/com/unciv/logic/civilization/managers/VictoryManager.kt

@@ -1,7 +1,8 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.managers
 
 import com.unciv.Constants
 import com.unciv.logic.IsPartOfGameInfoSerialization
+import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.models.Counter
 import com.unciv.models.ruleset.Milestone
 import com.unciv.models.ruleset.unique.UniqueType

core/src/com/unciv/logic/civilization/transients/CapitalConnectionsFinder.kt

@@ -1,6 +1,7 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.transients
 
 import com.unciv.logic.city.CityInfo
+import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.logic.map.BFS
 import com.unciv.logic.map.RoadStatus
 import com.unciv.logic.map.TileInfo

core/src/com/unciv/logic/civilization/transients/CivInfoStatsForNextTurn.kt

@@ -1,6 +1,8 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.transients
 
 import com.unciv.Constants
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.PlayerType
 import com.unciv.logic.civilization.diplomacy.RelationshipLevel
 import com.unciv.logic.map.RoadStatus
 import com.unciv.models.ruleset.Policy

core/src/com/unciv/logic/civilization/transients/CivInfoTransientCache.kt

@@ -1,7 +1,12 @@
-package com.unciv.logic.civilization
+package com.unciv.logic.civilization.transients
 
 import com.unciv.Constants
 import com.unciv.UncivGame
+import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.NotificationCategory
+import com.unciv.logic.civilization.NotificationIcon
+import com.unciv.logic.civilization.PlayerType
+import com.unciv.logic.civilization.Proximity
 import com.unciv.logic.map.MapShape
 import com.unciv.logic.map.TileInfo
 import com.unciv.models.ruleset.tile.ResourceSupplyList
@@ -41,9 +46,15 @@ class CivInfoTransientCache(val civInfo: CivilizationInfo) {
                 if (metCiv == civInfo || metCiv.isBarbarian() || civInfo.diplomacy.containsKey(metCiv.civName)) continue
                 civInfo.makeCivilizationsMeet(metCiv)
                 civInfo.addNotification("We have encountered [${metCiv.civName}]!",
-                    entry.value.position, NotificationCategory.Diplomacy, metCiv.civName, NotificationIcon.Diplomacy)
+                    entry.value.position,
+                    NotificationCategory.Diplomacy, metCiv.civName,
+                    NotificationIcon.Diplomacy
+                )
                 metCiv.addNotification("We have encountered [${civInfo.civName}]!",
-                    entry.value.position, NotificationCategory.Diplomacy, civInfo.civName, NotificationIcon.Diplomacy)
+                    entry.value.position,
+                    NotificationCategory.Diplomacy, civInfo.civName,
+                    NotificationIcon.Diplomacy
+                )
             }
 
             discoverNaturalWonders()
@@ -144,7 +155,8 @@ class CivInfoTransientCache(val civInfo: CivilizationInfo) {
             if (goldGained > 0) {
                 civInfo.addGold(goldGained)
                 civInfo.addNotification("We have received [$goldGained] Gold for discovering [${tile.naturalWonder}]",
-                    NotificationCategory.General, NotificationIcon.Gold)
+                    NotificationCategory.General, NotificationIcon.Gold
+                )
             }
 
         }
@@ -165,13 +177,15 @@ class CivInfoTransientCache(val civInfo: CivilizationInfo) {
             for (city in citiesReachedToMediums.keys)
                 if (city !in civInfo.citiesConnectedToCapitalToMediums && city.civInfo == civInfo && city != civInfo.getCapital()!!)
                     civInfo.addNotification("[${city.name}] has been connected to your capital!",
-                        city.location, NotificationCategory.Cities, NotificationIcon.Gold)
+                        city.location, NotificationCategory.Cities, NotificationIcon.Gold
+                    )
 
             // This may still contain cities that have just been destroyed by razing - thus the population test
             for (city in civInfo.citiesConnectedToCapitalToMediums.keys)
                 if (!citiesReachedToMediums.containsKey(city) && city.civInfo == civInfo && city.population.population > 0)
                     civInfo.addNotification("[${city.name}] has been disconnected from your capital!",
-                        city.location, NotificationCategory.Cities, NotificationIcon.Gold)
+                        city.location, NotificationCategory.Cities, NotificationIcon.Gold
+                    )
         }
 
         civInfo.citiesConnectedToCapitalToMediums = citiesReachedToMediums

core/src/com/unciv/models/ruleset/unique/Unique.kt

@@ -6,7 +6,7 @@ import com.unciv.logic.battle.CombatAction
 import com.unciv.logic.battle.MapUnitCombatant
 import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.models.ruleset.Ruleset
 import com.unciv.models.ruleset.RulesetValidator
 import com.unciv.models.stats.Stats

core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt

@@ -248,7 +248,7 @@ enum class UniqueParameterType(
             }
         },
 
-    /** Implemented by [PopulationManager.getPopulationFilterAmount][com.unciv.logic.city.PopulationManager.getPopulationFilterAmount] */
+    /** Implemented by [PopulationManager.getPopulationFilterAmount][com.unciv.logic.city.CityPopulationManager.getPopulationFilterAmount] */
     PopulationFilter("populationFilter", "Followers of this Religion", null, "Population Filters") {
         private val knownValues = setOf("Population", "Specialists", "Unemployed", "Followers of the Majority Religion", "Followers of this Religion")
         override fun getErrorSeverity(

core/src/com/unciv/models/ruleset/unique/UniqueTriggerActivation.kt

@@ -9,7 +9,7 @@ import com.unciv.logic.civilization.LocationAction
 import com.unciv.logic.civilization.MayaLongCountAction
 import com.unciv.logic.civilization.NotificationCategory
 import com.unciv.logic.civilization.NotificationIcon
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.logic.map.MapUnit
 import com.unciv.logic.map.TileInfo
 import com.unciv.models.ruleset.BeliefType

core/src/com/unciv/models/translations/TranslationFileWriter.kt

@@ -4,7 +4,7 @@ import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.files.FileHandle
 import com.unciv.json.fromJsonFile
 import com.unciv.json.json
-import com.unciv.logic.civilization.SpyAction
+import com.unciv.logic.civilization.managers.SpyAction
 import com.unciv.models.metadata.BaseRuleset
 import com.unciv.models.metadata.LocaleCode
 import com.unciv.models.ruleset.*

core/src/com/unciv/ui/cityscreen/CityReligionInfoTable.kt

@@ -4,7 +4,7 @@ import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.unciv.Constants
 import com.unciv.UncivGame
-import com.unciv.logic.city.CityReligionManager
+import com.unciv.logic.city.managers.CityReligionManager
 import com.unciv.models.Religion
 import com.unciv.ui.civilopedia.CivilopediaCategories
 import com.unciv.ui.civilopedia.CivilopediaScreen

core/src/com/unciv/ui/overviewscreen/EspionageOverviewScreen.kt

@@ -8,8 +8,8 @@ import com.badlogic.gdx.utils.Align
 import com.unciv.UncivGame
 import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.Spy
-import com.unciv.logic.civilization.SpyAction
+import com.unciv.logic.civilization.managers.Spy
+import com.unciv.logic.civilization.managers.SpyAction
 import com.unciv.models.translations.tr
 import com.unciv.ui.images.ImageGetter
 import com.unciv.ui.pickerscreens.PickerScreen

core/src/com/unciv/ui/overviewscreen/GlobalPoliticsOverviewTable.kt

@@ -11,7 +11,6 @@ import com.unciv.Constants
 import com.unciv.UncivGame
 import com.unciv.logic.HexMath
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.WonderInfo
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
 import com.unciv.logic.civilization.diplomacy.RelationshipLevel

core/src/com/unciv/ui/overviewscreen/WonderOverviewTable.kt

@@ -1,10 +1,18 @@
 package com.unciv.ui.overviewscreen
 
+import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.badlogic.gdx.utils.Align
 import com.unciv.UncivGame
+import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.WonderInfo
+import com.unciv.logic.map.TileInfo
+import com.unciv.models.ruleset.Building
+import com.unciv.models.ruleset.Era
+import com.unciv.models.ruleset.QuestName
+import com.unciv.models.ruleset.unique.UniqueType
+import com.unciv.models.translations.tr
+import com.unciv.ui.civilopedia.CivilopediaCategories
 import com.unciv.ui.civilopedia.CivilopediaScreen
 import com.unciv.ui.images.ImageGetter
 import com.unciv.ui.utils.extensions.onClick
@@ -80,3 +88,183 @@ class WonderOverviewTab(
         }
     }
 }
+
+
+class WonderInfo {
+    val gameInfo = UncivGame.Current.gameInfo!!
+    val viewingPlayer = gameInfo.getCurrentPlayerCivilization()
+    val ruleSet = gameInfo.ruleSet
+    private val hideReligionItems = !gameInfo.isReligionEnabled()
+    private val viewerEra = viewingPlayer.getEraNumber()
+    private val startingObsolete = ruleSet.eras[gameInfo.gameParameters.startingEra]!!.startingObsoleteWonders
+
+    enum class WonderStatus(val label: String) {
+        Hidden(""),
+        Unknown("Unknown"),
+        Unbuilt("Not built"),
+        NotFound("Not found"),
+        Known("Known"),
+        Owned("Owned")
+    }
+
+    class WonderInfo (
+        val name: String,
+        val category: CivilopediaCategories,
+        val groupName: String,
+        val groupColor: Color,
+        val status: WonderStatus,
+        val civ: CivilizationInfo?,
+        val city: CityInfo?,
+        val location: TileInfo?
+    ) {
+        val viewEntireMapForDebug = UncivGame.Current.viewEntireMapForDebug
+
+        fun getImage() = if (status == WonderStatus.Unknown && !viewEntireMapForDebug) null
+        else category.getImage?.invoke(name, if (category == CivilopediaCategories.Terrain) 50f else 45f)
+
+        fun getNameColumn() = when {
+            viewEntireMapForDebug -> name
+            status == WonderStatus.Unknown -> status.label
+            else -> name
+        }
+
+        fun getStatusColumn() = when {
+            status != WonderStatus.Known -> status.label
+            civ == null -> status.label
+            else -> civ.civName
+        }
+
+        fun getLocationColumn() = when {
+            status <= WonderStatus.NotFound -> ""
+            location == null -> ""
+            location.isCityCenter() -> location.getCity()!!.name
+            location.getCity() != null -> "Near [${location.getCity()!!}]"
+            city != null -> "Somewhere around [$city]"
+            viewEntireMapForDebug -> location.position.toString()
+            else -> "Far away"
+        }
+    }
+
+    private fun shouldBeDisplayed(wonder: Building, wonderEra: Int) = when {
+        wonder.hasUnique(UniqueType.HiddenFromCivilopedia) -> false
+        wonder.hasUnique(UniqueType.HiddenWithoutReligion) && hideReligionItems -> false
+        wonder.name in startingObsolete -> false
+        wonder.getMatchingUniques(UniqueType.HiddenWithoutVictoryType)
+            .any { unique ->
+                !gameInfo.gameParameters.victoryTypes.contains(unique.params[0])
+            } -> false
+        else -> wonderEra <= viewerEra
+    }
+
+    /** Do we know about a natural wonder despite not having found it yet? */
+    private fun knownFromQuest(name: String): Boolean {
+        // No, *your* civInfo's QuestManager has no idea about your quests
+        for (civ in gameInfo.civilizations) {
+            for (quest in civ.questManager.assignedQuests) {
+                if (quest.assignee != viewingPlayer.civName) continue
+                if (quest.questName == QuestName.FindNaturalWonder.value && quest.data1 == name)
+                    return true
+            }
+        }
+        return false
+    }
+
+    fun collectInfo(): Array<WonderInfo> {
+        val collator = UncivGame.Current.settings.getCollatorFromLocale()
+
+        // Maps all World Wonders by name to their era for grouping
+        val wonderEraMap: Map<String, Era> =
+                ruleSet.buildings.values.asSequence()
+                    .filter { it.isWonder }
+                    .associate { it.name to (ruleSet.eras[ruleSet.technologies[it.requiredTech]?.era()] ?: viewingPlayer.getEra()) }
+
+        // Maps all World Wonders by their position in sort order to their name
+        val allWonderMap: Map<Int, String> =
+                ruleSet.buildings.values.asSequence()
+                    .filter { it.isWonder }
+                    .sortedWith(compareBy<Building> { wonderEraMap[it.name]!!.eraNumber }.thenBy(collator) { it.name.tr() })
+                    .withIndex()
+                    .associate { it.index to it.value.name }
+        val wonderCount = allWonderMap.size
+
+        // Inverse of the above
+        val wonderIndexMap: Map<String, Int> = allWonderMap.map { it.value to it.key }.toMap()
+
+        // Maps all Natural Wonders on the map by name to their tile
+        val allNaturalsMap: Map<String, TileInfo> =
+                gameInfo.tileMap.values.asSequence()
+                    .filter { it.isNaturalWonder() }
+                    .associateBy { it.naturalWonder!! }
+        val naturalsCount = allNaturalsMap.size
+
+        // Natural Wonders sort order index to name
+        val naturalsIndexMap: Map<Int, String> = allNaturalsMap.keys
+            .sortedWith(compareBy(collator) { it.tr() })
+            .withIndex()
+            .associate { it.index to it.value }
+
+        // Pre-populate result with "Unknown" entries
+        val wonders = Array(wonderCount + naturalsCount) { index ->
+            if (index < wonderCount) {
+                val wonder = ruleSet.buildings[allWonderMap[index]!!]!!
+                val era = wonderEraMap[wonder.name]!!
+                val status = if (shouldBeDisplayed(wonder, era.eraNumber)) WonderStatus.Unbuilt else WonderStatus.Hidden
+                WonderInfo(
+                    allWonderMap[index]!!, CivilopediaCategories.Wonder,
+                    era.name, era.getColor(), status, null, null, null
+                )
+            } else {
+                WonderInfo(
+                    naturalsIndexMap[index - wonderCount]!!,
+                    CivilopediaCategories.Terrain,
+                    "Natural Wonders",
+                    Color.FOREST,
+                    WonderStatus.Unknown,
+                    null,
+                    null,
+                    null
+                )
+            }
+        }
+
+        for (city in gameInfo.getCities()) {
+            for (wonderName in city.cityConstructions.builtBuildings.intersect(wonderIndexMap.keys)) {
+                val index = wonderIndexMap[wonderName]!!
+                val status = when {
+                    viewingPlayer == city.civInfo -> WonderStatus.Owned
+                    viewingPlayer.hasExplored(city.location) -> WonderStatus.Known
+                    else -> WonderStatus.NotFound
+                }
+                wonders[index] = WonderInfo(
+                    wonderName, CivilopediaCategories.Wonder,
+                    wonders[index].groupName, wonders[index].groupColor,
+                    status, city.civInfo, city, city.getCenterTile()
+                )
+            }
+        }
+
+        for ((index, name) in naturalsIndexMap) {
+            val tile = allNaturalsMap[name]!!
+            val civ = tile.getOwner()
+            val status = when {
+                civ == viewingPlayer -> WonderStatus.Owned
+                name in viewingPlayer.naturalWonders -> WonderStatus.Known
+                else -> WonderStatus.NotFound
+            }
+            if (status == WonderStatus.NotFound && !knownFromQuest(name)) continue
+            val city = if (status == WonderStatus.NotFound) null
+            else tile.getTilesInDistance(5)
+                .filter { it.isCityCenter() }
+                .filter { viewingPlayer.knows(it.getOwner()!!) }
+                .filter { viewingPlayer.hasExplored(it) }
+                .sortedBy { it.aerialDistanceTo(tile) }
+                .firstOrNull()?.getCity()
+            wonders[index + wonderCount] = WonderInfo(
+                name, CivilopediaCategories.Terrain,
+                "Natural Wonders", Color.FOREST, status, civ, city, tile
+            )
+        }
+
+        return wonders
+    }
+}

core/src/com/unciv/ui/pickerscreens/ReligionPickerScreenCommon.kt

@@ -10,7 +10,7 @@ import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.unciv.Constants
 import com.unciv.UncivGame
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.ReligionManager
+import com.unciv.logic.civilization.managers.ReligionManager
 import com.unciv.models.UncivSound
 import com.unciv.models.ruleset.Belief
 import com.unciv.models.ruleset.BeliefType

core/src/com/unciv/ui/pickerscreens/TechButton.kt

@@ -6,7 +6,7 @@ import com.badlogic.gdx.scenes.scene2d.Touchable
 import com.badlogic.gdx.scenes.scene2d.ui.Image
 import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.badlogic.gdx.utils.Align
-import com.unciv.logic.civilization.TechManager
+import com.unciv.logic.civilization.managers.TechManager
 import com.unciv.models.ruleset.Building
 import com.unciv.models.ruleset.tile.TileImprovement
 import com.unciv.models.ruleset.tile.TileResource

core/src/com/unciv/ui/pickerscreens/TechPickerScreen.kt

@@ -9,7 +9,7 @@ import com.badlogic.gdx.utils.Align
 import com.unciv.Constants
 import com.unciv.UncivGame
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.TechManager
+import com.unciv.logic.civilization.managers.TechManager
 import com.unciv.models.UncivSound
 import com.unciv.models.ruleset.tech.Technology
 import com.unciv.models.ruleset.unique.UniqueType

core/src/com/unciv/ui/trade/DiplomacyScreen.kt

@@ -8,7 +8,7 @@ import com.badlogic.gdx.utils.Align
 import com.unciv.Constants
 import com.unciv.UncivGame
 import com.unciv.logic.civilization.AlertType
-import com.unciv.logic.civilization.AssignedQuest
+import com.unciv.logic.civilization.managers.AssignedQuest
 import com.unciv.logic.civilization.CivilizationInfo
 import com.unciv.logic.civilization.PopupAlert
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags

core/src/com/unciv/ui/worldscreen/WorldScreen.kt

@@ -18,7 +18,7 @@ import com.unciv.UncivGame
 import com.unciv.logic.GameInfo
 import com.unciv.logic.UncivShowableException
 import com.unciv.logic.civilization.CivilizationInfo
-import com.unciv.logic.civilization.ReligionState
+import com.unciv.logic.civilization.managers.ReligionState
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
 import com.unciv.logic.event.EventBus
 import com.unciv.logic.map.MapVisualization

tests/src/com/unciv/logic/civilization/CapitalConnectionsFinderTests.kt

@@ -5,6 +5,7 @@ import com.unciv.logic.GameInfo
 import com.unciv.logic.city.CityInfo
 import com.unciv.logic.civilization.diplomacy.DiplomacyManager
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
+import com.unciv.logic.civilization.transients.CapitalConnectionsFinder
 import com.unciv.logic.map.RoadStatus
 import com.unciv.logic.map.TileInfo
 import com.unciv.logic.map.TileMap