perf(render): Separate yields to different tile layer

core/src/com/unciv/ui/components/tilegroups/CityTileGroup.kt

@@ -55,8 +55,8 @@ class CityTileGroup(val city: City, tile: Tile, tileSetStrings: TileSetStrings,
             // Does not belong to us
             tile.getOwner() != city.civ -> {
                 setDimmed(0.6f)
-                layerMisc.setYieldVisible(UncivGame.Current.settings.showTileYields)
-                layerMisc.dimYields(true)
+                layerYield.setYieldVisible(UncivGame.Current.settings.showTileYields)
+                layerYield.dimYields(true)
 
                 // Can be purchased in principle? Add icon.
                 if (city.expansion.canBuyTile(tile)) {
@@ -81,20 +81,20 @@ class CityTileGroup(val city: City, tile: Tile, tileSetStrings: TileSetStrings,
             // Out of city range
             tile !in city.tilesInRange -> {
                 setDimmed(1f)
-                layerMisc.dimYields(true)
+                layerYield.dimYields(true)
             }
 
             // Worked by another city
             tile.isWorked() && tile.getWorkingCity() != city -> {
                 setDimmed(1f)
-                layerMisc.dimYields(true)
+                layerYield.dimYields(true)
             }
 
             // City Center
             tile.isCityCenter() -> {
                 icon = ImageGetter.getImage("TileIcons/CityCenter")
                 // Night mode does not apply to the city tile itself
-                layerMisc.dimYields(false)
+                layerYield.dimYields(false)
             }
 
             // Does not provide yields
@@ -108,7 +108,7 @@ class CityTileGroup(val city: City, tile: Tile, tileSetStrings: TileSetStrings,
                 icon = ImageGetter.getImage("TileIcons/Blockaded")
                 tileState = CityTileState.BLOCKADED
                 setUndimmed()
-                layerMisc.dimYields(true)
+                layerYield.dimYields(true)
             }
 
             // Locked
@@ -116,7 +116,7 @@ class CityTileGroup(val city: City, tile: Tile, tileSetStrings: TileSetStrings,
                 icon = ImageGetter.getImage("TileIcons/Locked")
                 tileState = CityTileState.WORKABLE
                 setUndimmed()
-                layerMisc.dimYields(false)
+                layerYield.dimYields(false)
             }
 
             // Worked
@@ -124,7 +124,7 @@ class CityTileGroup(val city: City, tile: Tile, tileSetStrings: TileSetStrings,
                 icon = ImageGetter.getImage("TileIcons/Worked")
                 tileState = CityTileState.WORKABLE
                 setUndimmed()
-                layerMisc.dimYields(false)
+                layerYield.dimYields(false)
             }
 
             // Provides yield without worker assigned (isWorked already tested above)
@@ -138,7 +138,7 @@ class CityTileGroup(val city: City, tile: Tile, tileSetStrings: TileSetStrings,
                 icon = ImageGetter.getImage("TileIcons/NotWorked")
                 tileState = CityTileState.WORKABLE
                 setUndimmed()
-                layerMisc.dimYields(true)
+                layerYield.dimYields(true)
             }
         }
 

core/src/com/unciv/ui/components/tilegroups/TileGroup.kt

@@ -42,23 +42,29 @@ open class TileGroup(
     @Suppress("LeakingThis") val layerFeatures = TileLayerFeatures(this, groupSize)
     @Suppress("LeakingThis") val layerBorders = TileLayerBorders(this, groupSize)
     @Suppress("LeakingThis") val layerMisc = TileLayerMisc(this, groupSize)
+    @Suppress("LeakingThis") val layerYield = TileLayerYield(this, groupSize)
     @Suppress("LeakingThis") val layerOverlay = TileLayerOverlay(this, groupSize)
     @Suppress("LeakingThis") val layerUnitArt = TileLayerUnitSprite(this, groupSize)
     @Suppress("LeakingThis") val layerUnitFlag = TileLayerUnitFlag(this, groupSize)
     @Suppress("LeakingThis") val layerCityButton = TileLayerCityButton(this, groupSize)
+    
+    val allLayers = listOf(
+        layerTerrain,
+        layerFeatures,
+        layerBorders,
+        layerMisc,
+        layerYield,
+        layerOverlay,
+        layerUnitArt,
+        layerUnitFlag,
+        layerCityButton
+    )
 
     init {
         this.setSize(groupSize, groupSize)
         this.isTransform = false // Cannot be a NonTransformGroup as this causes font-rendered terrain to be upside-down
 
-        this.addActor(layerTerrain)
-        this.addActor(layerFeatures)
-        this.addActor(layerBorders)
-        this.addActor(layerMisc)
-        this.addActor(layerOverlay)
-        this.addActor(layerUnitArt)
-        this.addActor(layerUnitFlag)
-        this.addActor(layerCityButton)
+        for (layer in allLayers) this.addActor(layer)
 
         layerTerrain.update(null)
     }
@@ -72,21 +78,15 @@ open class TileGroup(
     private fun reset(localUniqueCache: LocalUniqueCache) {
         layerTerrain.reset()
         layerBorders.reset()
-        layerMisc.reset(localUniqueCache)
+        layerMisc.reset()
+        layerYield.reset(localUniqueCache)
         layerOverlay.reset()
         layerUnitArt.reset()
         layerUnitFlag.reset()
     }
 
     private fun setAllLayersVisible(isVisible: Boolean) {
-        layerTerrain.isVisible = isVisible
-        layerFeatures.isVisible = isVisible
-        layerBorders.isVisible = isVisible
-        layerMisc.isVisible = isVisible
-        layerOverlay.isVisible = isVisible
-        layerUnitArt.isVisible = isVisible
-        layerUnitFlag.isVisible = isVisible
-        layerCityButton.isVisible = isVisible
+        for (layer in allLayers) layer.isVisible = isVisible
     }
 
     open fun update(
@@ -114,15 +114,8 @@ open class TileGroup(
         }
 
         removeMissingModReferences()
-
-        layerTerrain.update(viewingCiv, localUniqueCache)
-        layerFeatures.update(viewingCiv, localUniqueCache)
-        layerBorders.update(viewingCiv, localUniqueCache)
-        layerOverlay.update(viewingCiv, localUniqueCache)
-        layerMisc.update(viewingCiv, localUniqueCache)
-        layerUnitArt.update(viewingCiv, localUniqueCache)
-        layerUnitFlag.update(viewingCiv, localUniqueCache)
-        layerCityButton.update(viewingCiv, localUniqueCache)
+        
+        for (layer in allLayers) layer.update(viewingCiv, localUniqueCache)
         
         if (!wasPreviouslyVisible){ // newly revealed tile!
             layerTerrain.parent.addAction( 

core/src/com/unciv/ui/components/tilegroups/TileGroupMap.kt

@@ -102,6 +102,7 @@ class TileGroupMap<T: TileGroup>(
         val featureLayers = ArrayList<TileLayerFeatures>(numberOfTilegroups)
         val borderLayers = ArrayList<TileLayerBorders>(numberOfTilegroups)
         val miscLayers = ArrayList<TileLayerMisc>(numberOfTilegroups)
+        val yieldLayers = ArrayList<TileLayerYield>(numberOfTilegroups)
         val pixelUnitLayers = ArrayList<TileLayerUnitSprite>(numberOfTilegroups)
         val circleFogCrosshairLayers = ArrayList<TileLayerOverlay>(numberOfTilegroups)
         val unitLayers = ArrayList<TileLayerUnitFlag>(numberOfTilegroups)
@@ -117,6 +118,7 @@ class TileGroupMap<T: TileGroup>(
             featureLayers.add(group.layerFeatures.apply { setPosition(group.x, group.y) })
             borderLayers.add(group.layerBorders.apply { setPosition(group.x, group.y) })
             miscLayers.add(group.layerMisc.apply { setPosition(group.x, group.y) })
+            yieldLayers.add(group.layerYield.apply { setPosition(group.x, group.y) })
             pixelUnitLayers.add(group.layerUnitArt.apply { setPosition(group.x, group.y) })
             circleFogCrosshairLayers.add(group.layerOverlay.apply { setPosition(group.x, group.y) })
             unitLayers.add(group.layerUnitFlag.apply { setPosition(group.x, group.y) })
@@ -128,6 +130,7 @@ class TileGroupMap<T: TileGroup>(
             featureLayers,
             borderLayers,
             miscLayers,
+            yieldLayers,
             pixelUnitLayers,
             circleFogCrosshairLayers,
             tileGroups, // The above layers are for the visual layers, this is for the clickability of the tile

core/src/com/unciv/ui/components/tilegroups/layers/TileLayerMisc.kt

@@ -47,6 +47,63 @@ private class MapArrow(val targetTile: Tile, val arrowType: MapArrowType, val st
     }
 }
 
+class TileLayerYield(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, size){
+    private val yields = YieldGroup().apply {
+        // Unlike resource or improvement this is created and added only once,
+        // It's the contents that get updated
+        isVisible = false
+        setOrigin(Align.center)
+        setScale(0.7f)
+        y = tileGroup.height * 0.25f - height / 2
+        // Adding YieldGroup to miscLayerGroup
+        this@TileLayerYield.addActor(this)
+    }
+    
+    override fun doUpdate(viewingCiv: Civilization?, localUniqueCache: LocalUniqueCache) {
+        val showTileYields = if (tileGroup is WorldTileGroup) UncivGame.Current.settings.showTileYields else true
+        updateYieldIcon(viewingCiv, showTileYields, localUniqueCache)
+    }
+
+    // JN updating display of tile yields
+    private fun updateYieldIcon(
+        viewingCiv: Civilization?,
+        show: Boolean,
+        localUniqueCache: LocalUniqueCache
+    ) {
+        val effectiveVisible = show &&
+                !tileGroup.isForMapEditorIcon &&  // don't have a map to calc yields
+                !(viewingCiv == null && tileGroup.isForceVisible) // main menu background
+
+        // Hiding yield icons (in order to update)
+        yields.isVisible = false
+        if (effectiveVisible) yields.run {
+            // Update YieldGroup Icon
+            if (tileGroup is CityTileGroup)
+                setStats(tile.stats.getTileStats(tileGroup.city, viewingCiv, localUniqueCache))
+            else
+                setStats(tile.stats.getTileStats(viewingCiv, localUniqueCache))
+            toFront()
+            centerX(tileGroup)
+            isVisible = true
+        }
+    }
+
+    fun setYieldVisible(isVisible: Boolean) {
+        yields.isVisible = isVisible
+        this.isVisible = isVisible // don't try rendering the layer if there's nothing in it
+    }
+    
+    fun dimYields(dim: Boolean) { yields.color.a = if (dim) 0.5f else 1f }
+
+    fun reset(localUniqueCache: LocalUniqueCache) {
+        updateYieldIcon(null, false, localUniqueCache)
+    }
+
+    override fun act(delta: Float) {}
+    override fun hit(x: Float, y: Float, touchable: Boolean): Actor? = null
+    override fun draw(batch: Batch?, parentAlpha: Float) = super.draw(batch, parentAlpha)
+}
+
 class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, size) {
 
     // For different unit views, we want to effectively "ignore" the terrain and color it by special view
@@ -65,17 +122,6 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
 
     override fun draw(batch: Batch?, parentAlpha: Float) = super.draw(batch, parentAlpha)
 
-    private val yields = YieldGroup().apply {
-        // Unlike resource or improvement this is created and added only once,
-        // It's the contents that get updated
-        isVisible = false
-        setOrigin(Align.center)
-        setScale(0.7f)
-        y = tileGroup.height * 0.25f - height / 2
-        // Adding YieldGroup to miscLayerGroup
-        this@TileLayerMisc.addActor(this)
-    }
-
     /** Array list of all arrows to draw from this tile on the next update. */
     private val arrowsToDraw = ArrayList<MapArrow>()
     private val arrows = HashMap<Tile, ArrayList<Actor>>()
@@ -280,29 +326,6 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
         }
     }
 
-    // JN updating display of tile yields
-    private fun updateYieldIcon(
-        viewingCiv: Civilization?,
-        show: Boolean,
-        localUniqueCache: LocalUniqueCache
-    ) {
-        val effectiveVisible = show &&
-                !tileGroup.isForMapEditorIcon &&  // don't have a map to calc yields
-                !(viewingCiv == null && tileGroup.isForceVisible) // main menu background
-
-        // Hiding yield icons (in order to update)
-        yields.isVisible = false
-        if (effectiveVisible) yields.run {
-            // Update YieldGroup Icon
-            if (tileGroup is CityTileGroup)
-                setStats(tile.stats.getTileStats(tileGroup.city, viewingCiv, localUniqueCache))
-            else
-                setStats(tile.stats.getTileStats(viewingCiv, localUniqueCache))
-            toFront()
-            centerX(tileGroup)
-            isVisible = true
-        }
-    }
 
     fun removeWorkedIcon() {
         workedIcon?.remove()
@@ -364,26 +387,19 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
 
     fun dimImprovement(dim: Boolean) { improvementIcon?.color?.a = if (dim) 0.5f else 1f }
     fun dimResource(dim: Boolean) { resourceIcon?.color?.a = if (dim) 0.5f else 1f }
-    fun dimYields(dim: Boolean) { yields.color.a = if (dim) 0.5f else 1f }
     fun dimPopulation(dim: Boolean) { workedIcon?.color?.a = if (dim) 0.4f else 1f }
 
-    fun setYieldVisible(isVisible: Boolean) {
-        yields.isVisible = isVisible
-        determineVisibility()
-    }
 
     override fun doUpdate(viewingCiv: Civilization?, localUniqueCache: LocalUniqueCache) {
 
         var showResourcesAndImprovements = true
-        var showTileYields = true
 
         if (tileGroup is WorldTileGroup) {
             showResourcesAndImprovements = UncivGame.Current.settings.showResourcesAndImprovements
-            showTileYields = UncivGame.Current.settings.showTileYields
         }
+        
 
         updateImprovementIcon(viewingCiv, showResourcesAndImprovements)
-        updateYieldIcon(viewingCiv, showTileYields, localUniqueCache)
         updateResourceIcon(viewingCiv, showResourcesAndImprovements)
         if (tileGroup !is WorldTileGroup || DebugUtils.SHOW_TILE_COORDS)
             updateStartingLocationIcon(true)
@@ -391,8 +407,7 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
     }
 
     override fun determineVisibility() {
-        isVisible = yields.isVisible
-                || resourceIcon?.isVisible == true
+        isVisible = resourceIcon?.isVisible == true
                 || improvementIcon?.isVisible == true
                 || workedIcon != null
                 || hexOutlineIcon != null
@@ -401,9 +416,8 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
                 || terrainOverlay != null
     }
 
-    fun reset(localUniqueCache: LocalUniqueCache) {
+    fun reset() {
         updateImprovementIcon(null, false)
-        updateYieldIcon(null, false, localUniqueCache)
         updateResourceIcon(null, false)
         updateStartingLocationIcon(false)
         clearArrows()