perf: Improve tech screen init latency by iterating all objects once, instead of all objects per tech, to find dependencies

Author: yairm210

build.gradle.kts

@@ -74,6 +74,8 @@ allprojects {
             "io.ktor.http.Parameters.get",
 
             "java.util.BitSet.clone",
+
+            "kotlin.collections.orEmpty",
         )
         wellKnownPureClasses = setOf(
         )

core/src/com/unciv/ui/images/ImageGetter.kt

@@ -31,6 +31,7 @@ import com.unciv.ui.screens.basescreen.BaseScreen
 import com.unciv.utils.Concurrency
 import com.unciv.utils.debug
 import kotlinx.coroutines.runBlocking
+import yairm210.purity.annotations.Readonly
 import kotlin.math.atan2
 import kotlin.math.max
 import kotlin.math.min
@@ -224,9 +225,11 @@ object ImageGetter {
     fun getExternalImage(fileName: String) =
         getExternalImage(Gdx.files.internal("ExtraImages/$fileName"))
 
-    fun getImage(fileName: String?, tintColor: Color? = null): Image = 
+    @Readonly @Suppress("purity") // only mutates the freshly-created Image it returns
+    fun getImage(fileName: String?, tintColor: Color? = null): Image =
         ImageWithCustomSize(getDrawable(fileName)).apply { color = tintColor ?: Color.WHITE }
 
+    @Readonly
     fun getDrawable(fileName: String?): TextureRegionDrawable =
         textureRegionDrawables[fileName] ?: textureRegionDrawables[whiteDotLocation]!!
 
@@ -251,6 +254,7 @@ object ImageGetter {
     fun imageExists(fileName: String) = textureRegionDrawables.containsKey(fileName)
     fun ninePatchImageExists(fileName: String) = ninePatchDrawables.containsKey(fileName)
 
+    @Readonly @Suppress("purity") // only mutates the freshly-created Image it returns
     fun getStatIcon(statName: String, size: Float = 20f): Image = getImage("StatIcons/$statName")
             .apply { setSize(size, size) }
 
@@ -267,6 +271,7 @@ object ImageGetter {
             getImage("UnitIcons/${unit.name}").apply { this.color = color }
         else getImage("UnitTypeIcons/${unit.type}").apply { this.color = color }
 
+    @Readonly @Suppress("purity") // only mutates the freshly-created Group it returns
     fun getConstructionPortrait(construction: String, size: Float): Group {
         if (ruleset.buildings.containsKey(construction)) {
             return PortraitBuilding(construction, size)
@@ -279,15 +284,18 @@ object ImageGetter {
         return getStatIcon(construction).surroundWithCircle(size).surroundWithThinCircle()
     }
 
+    @Readonly
     fun getUniquePortrait(uniqueName: String, size: Float): Group = PortraitUnique(uniqueName, size)
 
     fun getPromotionPortrait(promotionName: String, size: Float = 30f): Group = PortraitPromotion(promotionName, size)
 
+    @Readonly
     fun getResourcePortrait(resourceName: String, size: Float, amount: Int= 0): Group =
         PortraitResource(resourceName, size, amount)
 
     fun getTechIconPortrait(techName: String, circleSize: Float): Group = PortraitTech(techName, circleSize)
 
+    @Readonly
     fun getImprovementPortrait(improvementName: String, size: Float = 20f, isPillaged: Boolean = false): Portrait =
         PortraitImprovement(improvementName, size, false, isPillaged)
 
@@ -328,6 +336,7 @@ object ImageGetter {
 
     fun getTriangle() = getImage("OtherIcons/Triangle")
 
+    @Readonly @Suppress("purity") // only mutates the freshly-created Actor it returns
     fun getRedCross(size: Float, alpha: Float): Actor {
         val redCross = getImage("OtherIcons/Close")
         redCross.setSize(size, size)

core/src/com/unciv/ui/objectdescriptions/TechnologyDescriptions.kt

@@ -18,6 +18,7 @@ import com.unciv.ui.images.PortraitUnavailableWonderForTechTree
 import com.unciv.ui.screens.civilopediascreen.FormattedLine
 import com.unciv.ui.screens.civilopediascreen.ICivilopediaText
 import com.unciv.ui.screens.pickerscreens.TechButton
+import yairm210.purity.annotations.Readonly
 
 
 object TechnologyDescriptions {
@@ -89,16 +90,25 @@ object TechnologyDescriptions {
 
     /**
      *  Gets icons to display on a [TechButton] - all should be also described in [getDescription]
+     *
+     *  @param iconsIndex Optional precomputed [TechIconsIndex] (see [buildTechIconsIndex]) - when building
+     *  icons for every tech in the ruleset at once (as [com.unciv.ui.screens.pickerscreens.TechPickerScreen] does),
+     *  pass one in instead of letting each call re-scan the whole ruleset - see #15641.
      */
-    fun getTechEnabledIcons(tech: Technology, viewingCiv: Civilization, techIconSize: Float) = sequence {
+    @Readonly
+    fun getTechEnabledIcons(tech: Technology, viewingCiv: Civilization, techIconSize: Float, iconsIndex: TechIconsIndex? = null) = sequence {
         val ruleset = viewingCiv.gameInfo.ruleset
         val techName = tech.name
 
-        for (unit in getEnabledUnits(techName, ruleset, viewingCiv)) {
+        val enabledUnits = if (iconsIndex != null) iconsIndex.enabledUnitsByTech[techName].orEmpty().asSequence()
+            else getEnabledUnits(techName, ruleset, viewingCiv)
+        for (unit in enabledUnits) {
             yield(ImageGetter.getConstructionPortrait(unit.name, techIconSize))
         }
 
-        for (building in getEnabledBuildings(techName, ruleset, viewingCiv)) {
+        val enabledBuildings = if (iconsIndex != null) iconsIndex.enabledBuildingsByTech[techName].orEmpty().asSequence()
+            else getEnabledBuildings(techName, ruleset, viewingCiv)
+        for (building in enabledBuildings) {
             // We don't need to show the unavailable marker for techs that are already researched
             // since this is mostly a feature to choose which technologies to research.
             if (building.isWonder && !viewingCiv.tech.isResearched(techName)) {
@@ -119,26 +129,29 @@ object TechnologyDescriptions {
             }
         }
 
-        yieldAll(
-            getObsoletedObjects(techName, ruleset, viewingCiv)
-                .mapNotNull { it.getObsoletedIcon(techIconSize) }
-        )
+        val obsoletedObjects = if (iconsIndex != null) iconsIndex.obsoletedObjectsByTech[techName].orEmpty().asSequence()
+            else getObsoletedObjects(techName, ruleset, viewingCiv)
+        yieldAll(obsoletedObjects.mapNotNull { it.getObsoletedIcon(techIconSize) })
 
-        for (resource in ruleset.tileResources.values.filter { it.revealedBy == techName }) {
+        val revealedResources = if (iconsIndex != null) iconsIndex.resourcesByRevealedTech[techName].orEmpty().asSequence()
+            else ruleset.tileResources.values.asSequence().filter { it.revealedBy == techName }
+        for (resource in revealedResources) {
             yield(ImageGetter.getResourcePortrait(resource.name, techIconSize))
         }
 
-        for (improvement in ruleset.tileImprovements.values.asSequence()
-            .filter { it.techRequired == techName }
-            .filter { it.uniqueTo == null || viewingCiv.matchesFilter(it.uniqueTo!!) }
-        ) {
+        val requiredTechImprovements = if (iconsIndex != null) iconsIndex.improvementsByTechRequired[techName].orEmpty().asSequence()
+            else ruleset.tileImprovements.values.asSequence()
+                .filter { it.techRequired == techName }
+                .filter { it.uniqueTo == null || viewingCiv.matchesFilter(it.uniqueTo!!) }
+        for (improvement in requiredTechImprovements) {
             yield(ImageGetter.getImprovementPortrait(improvement.name, techIconSize))
         }
 
-        for (improvement in ruleset.tileImprovements.values.asSequence()
-            .filter { it.uniqueObjects.any { u -> u.allParams.contains(techName) } }
-            .filter { it.uniqueTo == null || viewingCiv.matchesFilter(it.uniqueTo!!) }
-        ) {
+        val uniqueParamImprovements = if (iconsIndex != null) iconsIndex.improvementsByUniqueTechParam[techName].orEmpty().asSequence()
+            else ruleset.tileImprovements.values.asSequence()
+                .filter { it.uniqueObjects.any { u -> u.allParams.contains(techName) } }
+                .filter { it.uniqueTo == null || viewingCiv.matchesFilter(it.uniqueTo!!) }
+        for (improvement in uniqueParamImprovements) {
             yield(ImageGetter.getUniquePortrait(improvement.name, techIconSize))
         }
 
@@ -155,6 +168,82 @@ object TechnologyDescriptions {
         }
     }
 
+    /**
+     *  Precomputes, in one pass over the ruleset, which units/buildings/resources/improvements
+     *  are unlocked or obsoleted by each tech - grouped by tech name for O(1) lookup in [getTechEnabledIcons].
+     *
+     *  Without this, opening [com.unciv.ui.screens.pickerscreens.TechPickerScreen] re-scanned the entire
+     *  ruleset (units, buildings, resources, improvements) once per tech - O(techs * rulesetObjects) total,
+     *  which was the dominant cost of constructing that screen and a contributor to a black-screen flash
+     *  on Android when it ran synchronously on the GL thread (#15641).
+     */
+    @Readonly @Suppress("purity") // only mutates the locally-built index maps/lists it returns
+    fun buildTechIconsIndex(ruleset: Ruleset, viewingCiv: Civilization): TechIconsIndex {
+        val filteredBuildings = getFilteredBuildings(ruleset, viewingCiv) { true }.toList()
+        val enabledBuildingsByTech = HashMap<String, MutableList<Building>>()
+        for (building in filteredBuildings)
+            for (tech in building.requiredTechs())
+                enabledBuildingsByTech.getOrPut(tech) { mutableListOf() }.add(building)
+
+        val filteredUnits = ruleset.units.values.asSequence()
+            .filter {
+                (it.uniqueTo != null && viewingCiv.matchesFilter(it.uniqueTo!!) ||
+                        it.uniqueTo == null && viewingCiv.getEquivalentUnit(it) == it)
+                        && !it.isHiddenFromCivilopedia(ruleset)
+            }.toList()
+        val enabledUnitsByTech = HashMap<String, MutableList<BaseUnit>>()
+        for (unit in filteredUnits)
+            for (tech in unit.requiredTechs())
+                enabledUnitsByTech.getOrPut(tech) { mutableListOf() }.add(unit)
+
+        val filteredImprovements = ruleset.tileImprovements.values.asSequence()
+            .filter { it.uniqueTo == null || viewingCiv.matchesFilter(it.uniqueTo!!) }
+            .toList()
+
+        val obsoletedObjectsByTech = HashMap<String, MutableList<RulesetStatsObject>>()
+        val obsoletionCandidates: Sequence<RulesetStatsObject> =
+            filteredBuildings.asSequence() + ruleset.tileResources.values.asSequence() + filteredImprovements.asSequence()
+        for (obj in obsoletionCandidates)
+            for (unique in obj.getMatchingUniques(UniqueType.ObsoleteWith))
+                obsoletedObjectsByTech.getOrPut(unique.params[0]) { mutableListOf() }.add(obj)
+
+        val resourcesByRevealedTech = HashMap<String, MutableList<TileResource>>()
+        for (resource in ruleset.tileResources.values) {
+            val revealedBy = resource.revealedBy ?: continue
+            resourcesByRevealedTech.getOrPut(revealedBy) { mutableListOf() }.add(resource)
+        }
+
+        val improvementsByTechRequired = HashMap<String, MutableList<TileImprovement>>()
+        for (improvement in filteredImprovements) {
+            val techRequired = improvement.techRequired ?: continue
+            improvementsByTechRequired.getOrPut(techRequired) { mutableListOf() }.add(improvement)
+        }
+
+        val improvementsByUniqueTechParam = HashMap<String, LinkedHashSet<TileImprovement>>()
+        for (improvement in filteredImprovements)
+            for (unique in improvement.uniqueObjects)
+                for (param in unique.allParams)
+                    improvementsByUniqueTechParam.getOrPut(param) { LinkedHashSet() }.add(improvement)
+
+        return TechIconsIndex(
+            enabledUnitsByTech,
+            enabledBuildingsByTech,
+            obsoletedObjectsByTech,
+            resourcesByRevealedTech,
+            improvementsByTechRequired,
+            improvementsByUniqueTechParam.mapValues { it.value.toList() }
+        )
+    }
+
+    class TechIconsIndex internal constructor(
+        val enabledUnitsByTech: Map<String, List<BaseUnit>>,
+        val enabledBuildingsByTech: Map<String, List<Building>>,
+        val obsoletedObjectsByTech: Map<String, List<RulesetStatsObject>>,
+        val resourcesByRevealedTech: Map<String, List<TileResource>>,
+        val improvementsByTechRequired: Map<String, List<TileImprovement>>,
+        val improvementsByUniqueTechParam: Map<String, List<TileImprovement>>
+    )
+
     /**
      * Implementation of [ICivilopediaText.getCivilopediaTextLines]
      */
@@ -273,6 +362,7 @@ object TechnologyDescriptions {
      * nuclear weapons and religion settings, and without those expressly hidden from Civilopedia.
      */
     // Used for Civilopedia, Alert and Picker, so if any of these decide to ignore the "Will not be displayed in Civilopedia" unique this needs refactoring
+    @Readonly
     private fun getEnabledBuildings(techName: String, ruleset: Ruleset, civInfo: Civilization?) =
             getFilteredBuildings(ruleset, civInfo) { it.requiredTechs().contains(techName) }
 
@@ -281,6 +371,7 @@ object TechnologyDescriptions {
      * nuclear weapons and religion settings, and without those expressly hidden from Civilopedia.
      */
     // Used for Civilopedia, Alert and Picker, so if any of these decide to ignore the "Will not be displayed in Civilopedia" unique this needs refactoring
+    @Readonly
     private fun getObsoletedObjects(techName: String, ruleset: Ruleset, civInfo: Civilization?): Sequence<RulesetStatsObject> =
             (
                     getFilteredBuildings(ruleset, civInfo) { true }
@@ -293,6 +384,7 @@ object TechnologyDescriptions {
             }
 
     /** Readability - for the 'obsoleted' in [getTechEnabledIcons] */
+    @Readonly @Suppress("purity") // only mutates the freshly-created icon it returns
     private fun RulesetStatsObject.getObsoletedIcon(techIconSize: Float) =
         when (this) {
             is Building -> ImageGetter.getConstructionPortrait(name, techIconSize)
@@ -306,6 +398,7 @@ object TechnologyDescriptions {
         }
 
     /** Common filtering for both [getEnabledBuildings] and [getObsoletedObjects], difference via predicate parameter */
+    @Readonly
     private fun getFilteredBuildings(
         ruleset: Ruleset,
         civInfo: Civilization?,
@@ -325,6 +418,7 @@ object TechnologyDescriptions {
      * nuclear weapons and religion settings, and without those expressly hidden from Civilopedia.
      */
     // Used for Civilopedia, Alert and Picker, so if any of these decide to ignore the "Will not be displayed in Civilopedia"/HiddenFromCivilopedia unique this needs refactoring
+    @Readonly
     private fun getEnabledUnits(techName: String, ruleset: Ruleset, civInfo: Civilization?): Sequence<BaseUnit> {
         return ruleset.units.values.asSequence()
             .filter {

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

@@ -21,7 +21,8 @@ import com.unciv.ui.components.extensions.toLabel
 class TechButton(
     techName: String,
     private val techManager: TechManager,
-    isWorldScreen: Boolean = true
+    isWorldScreen: Boolean = true,
+    private val techIconsIndex: TechnologyDescriptions.TechIconsIndex? = null
 ) : Table(BaseScreen.skin) {
 
     internal val text = "".toLabel().apply {
@@ -114,7 +115,7 @@ class TechButton(
         val civ = techManager.civInfo
         val tech = civ.gameInfo.ruleset.technologies[techName]!!
 
-        TechnologyDescriptions.getTechEnabledIcons(tech, civ, techIconSize = 30f)
+        TechnologyDescriptions.getTechEnabledIcons(tech, civ, techIconSize = 30f, iconsIndex = techIconsIndex)
             .take(5)
             .forEach { techEnabledIcons.add(it) }
 

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

@@ -17,6 +17,7 @@ import com.unciv.models.UncivSound
 import com.unciv.models.ruleset.tech.Technology
 import com.unciv.models.ruleset.unique.UniqueType
 import com.unciv.models.translations.tr
+import com.unciv.ui.objectdescriptions.TechnologyDescriptions
 import com.unciv.ui.components.NonTransformGroup
 import com.unciv.ui.components.extensions.colorFromRGB
 import com.unciv.ui.components.extensions.darken
@@ -146,6 +147,9 @@ class TechPickerScreen(
         for (label in eraLabels) label.remove()
         eraLabels.clear()
 
+        // Computed once for all techs instead of per-TechButton - see #15641
+        val techIconsIndex = TechnologyDescriptions.buildTechIconsIndex(ruleset, civInfo)
+
         val allTechs = ruleset.technologies.values
         if (allTechs.isEmpty()) return
         val columns = allTechs.maxOf { it.column!!.columnNumber } + 1
@@ -207,7 +211,7 @@ class TechPickerScreen(
                 if (tech == null) {
                     techTable.add(table).fill()
                 } else {
-                    val techButton = TechButton(tech.name, civTech, false)
+                    val techButton = TechButton(tech.name, civTech, false, techIconsIndex)
                     table.add(techButton)
                     techNameToButton[tech.name] = techButton
                     techButton.onClick { selectTechnology(tech, queue = false, center = false) }