Enemy indicator, city culture hex outline + misc (#8629)

* Rework of UnitGroup, City culture tile hex-outline, tweak enemy indicators

* Rework of UnitGroup, City culture tile hex-outline, tweak enemy indicators

* Better embarked selection sprite

* Small fixes

* Hotfix fog

---------

Co-authored-by: tunerzinc@gmail.com <vfylfhby>

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

@@ -28,6 +28,7 @@ import com.unciv.ui.tilegroups.TileSetStrings
 import com.unciv.ui.utils.BaseScreen
 import com.unciv.ui.utils.KeyCharAndCode
 import com.unciv.ui.utils.RecreateOnResize
+import com.unciv.ui.utils.extensions.colorFromRGB
 import com.unciv.ui.utils.extensions.disable
 import com.unciv.ui.utils.extensions.keyShortcuts
 import com.unciv.ui.utils.extensions.onActivation
@@ -226,18 +227,16 @@ class CityScreen(
         }
         for (tileGroup in tileGroups) {
             tileGroup.update()
-            tileGroup.layerOverlay.hideHighlight()
+            tileGroup.layerMisc.removeHexOutline()
             when {
-                tileGroup.tile == nextTileToOwn -> {
+                tileGroup.tile == nextTileToOwn ->
-                    tileGroup.layerOverlay.showHighlight(Color.PURPLE)
+                    tileGroup.layerMisc.addHexOutline(colorFromRGB(200, 20, 220))
-                    tileGroup.setColor(0f, 0f, 0f, 0.7f)
-                }
                 /** Support for [UniqueType.CreatesOneImprovement] */
                 tileGroup.tile == selectedQueueEntryTargetTile ->
-                    tileGroup.layerOverlay.showHighlight(Color.BROWN, 0.7f)
+                    tileGroup.layerMisc.addHexOutline(Color.BROWN)
                 pickTileData != null && city.tiles.contains(tileGroup.tile.position) ->
                     getPickImprovementColor(tileGroup.tile).run {
-                        tileGroup.layerOverlay.showHighlight(first, second) }
+                        tileGroup.layerMisc.addHexOutline(first.cpy().apply { this.a = second }) }
             }
         }
     }

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

@@ -178,6 +178,12 @@ object ImageGetter {
         return textureRegionDrawables[fileName] ?: textureRegionDrawables[whiteDotLocation]!!
     }
 
+    fun getDrawableOrNull(fileName: String?): TextureRegionDrawable? {
+        if (fileName == null)
+            return null
+        return textureRegionDrawables[fileName]
+    }
+
     fun getNinePatch(fileName: String?, tintColor: Color? = null): NinePatchDrawable {
         val drawable = ninePatchDrawables[fileName] ?: NinePatchDrawable(NinePatch(textureRegionDrawables[whiteDotLocation]!!.region))
 

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

@@ -78,13 +78,14 @@ open class TileGroup(
         layerTerrain.reset()
         layerBorders.reset()
         layerMisc.reset()
+        layerOverlay.reset()
         layerUnitArt.reset()
         layerUnitFlag.reset()
-        layerOverlay.setFog(true)
     }
 
     open fun update(viewingCiv: Civilization? = null) {
 
+        layerMisc.removeHexOutline()
         layerOverlay.hideHighlight()
         layerOverlay.hideCrosshair()
 

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

@@ -61,6 +61,7 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
     private val arrowsToDraw = ArrayList<MapArrow>()
     private val arrows = HashMap<Tile, ArrayList<Actor>>()
 
+    private var hexOutlineIcon: Actor? = null
     private var resourceName: String? = null
     private var resourceIcon: Actor? = null
     private var workedIcon: Actor? = null
@@ -256,6 +257,21 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
         determineVisibility()
     }
 
+    fun addHexOutline(color: Color) {
+        hexOutlineIcon?.remove()
+        hexOutlineIcon = ImageGetter.getImage("OtherIcons/HexagonOutline").setHexagonSize(1f)
+        hexOutlineIcon!!.color = color
+        addActor(hexOutlineIcon)
+        hexOutlineIcon!!.toBack()
+        determineVisibility()
+    }
+
+    fun removeHexOutline() {
+        hexOutlineIcon?.remove()
+        hexOutlineIcon = null
+        determineVisibility()
+    }
+
 
     fun addArrow(targetTile: Tile, type: MapArrowType) {
         if (targetTile.position != tile().position)
@@ -298,6 +314,7 @@ class TileLayerMisc(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, si
                 || resourceIcon?.isVisible == true
                 || improvementIcon != null
                 || workedIcon != null
+                || hexOutlineIcon != null
                 || arrows.isNotEmpty()
                 || startingLocationIcons.isNotEmpty()
     }

core/src/com/unciv/ui/tilegroups/layers/TileLayerOverlay.kt

@@ -40,11 +40,6 @@ class TileLayerOverlay(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
         determineVisibility()
     }
 
-    fun setFog(isVisible: Boolean) {
-        fog.isVisible = isVisible && !tileGroup.isForceVisible
-        determineVisibility()
-    }
-
     fun showHighlight(color: Color, alpha: Float = 0.3f) {
         highlight.isVisible = true
         highlight.color = color.cpy().apply { a = alpha }
@@ -61,10 +56,19 @@ class TileLayerOverlay(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
         determineVisibility()
     }
 
+    fun reset() {
+        fog.isVisible = true
+        highlight.isVisible = false
+        crosshair.isVisible = false
+        determineVisibility()
+    }
+
     override fun doUpdate(viewingCiv: Civilization?) {
 
         val isViewable = viewingCiv == null || isViewable(viewingCiv)
-        setFog(!isViewable)
+
+        if (!isViewable && !tileGroup.isForceVisible)
+            fog.isVisible = true
 
         if (viewingCiv == null)
             return

core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitArt.kt

@@ -8,15 +8,17 @@ import com.unciv.logic.map.mapunit.MapUnit
 import com.unciv.ui.images.ImageGetter
 import com.unciv.ui.tilegroups.TileGroup
 
+private class UnitArtSlot : Group() {
+    var imageLocation = ""
+}
+
 class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, size) {
 
     override fun act(delta: Float) {}
     override fun hit(x: Float, y: Float, touchable: Boolean): Actor? = null
 
-    private var locations = Array(2){""}
+    private var slot1: UnitArtSlot = UnitArtSlot()
-
+    private var slot2: UnitArtSlot = UnitArtSlot()
-    private var slot1: Group = Group()
-    private var slot2: Group = Group()
 
     init {
         addActor(slot1)
@@ -27,7 +29,7 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
             || viewingCiv.viewableInvisibleUnitsTiles.contains(tileGroup.tile)
             || !tileGroup.tile.hasEnemyInvisibleUnit(viewingCiv)
 
-    private fun updateSlot(index: Int, unit: MapUnit?, isShown: Boolean) {
+    private fun updateSlot(slot: UnitArtSlot, unit: MapUnit?, isShown: Boolean) {
 
         var location = ""
         var nationName = ""
@@ -37,11 +39,9 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
             nationName = "${unit.civ.civName}-"
         }
 
-        if (locations[index] != "$nationName$location") {
+        if (slot.imageLocation != "$nationName$location") {
-            locations[index] = "$nationName$location"
+            slot.imageLocation = "$nationName$location"
-
+            slot.clear()
-            val group: Group = if (index == 0) slot1 else slot2
-            group.clear()
 
             if (location != "" && ImageGetter.imageExists(location)) {
                 val nation = unit!!.civ.nation
@@ -52,7 +52,7 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
                     nation.getOuterColor()
                 )
                 for (pixelUnitImage in pixelUnitImages) {
-                    group.addActor(pixelUnitImage)
+                    slot.addActor(pixelUnitImage)
                     pixelUnitImage.setHexagonSize()// Treat this as A TILE, which gets overlayed on the base tile.
                 }
             }
@@ -75,8 +75,8 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
         val isSlot1Shown = isPixelUnitsEnabled && isViewable
         val isSlot2Shown = isPixelUnitsEnabled && isViewable && isVisibleMilitary
 
-        updateSlot(0, slot1Unit, isShown = isSlot1Shown)
+        updateSlot(slot1, slot1Unit, isShown = isSlot1Shown)
-        updateSlot(1, slot2Unit, isShown = isSlot2Shown)
+        updateSlot(slot2, slot2Unit, isShown = isSlot2Shown)
     }
 
     override fun determineVisibility() {
@@ -84,7 +84,10 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup,
     }
 
     fun reset() {
-        updateSlot(0, null, false)
+        slot1.clear()
-        updateSlot(1, null, false)
+        slot2.clear()
+
+        slot1.imageLocation = ""
+        slot2.imageLocation = ""
     }
 }

core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitFlag.kt

@@ -51,7 +51,7 @@ class TileLayerUnitFlag(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup
         var newIcon: UnitGroup? = null
 
         if (unit != null && isViewable) {
-            newIcon = UnitGroup(unit, 25f)
+            newIcon = UnitGroup(unit, 30f)
             addActor(newIcon)
             setIconPosition(slot, newIcon)
 

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

@@ -1,102 +1,149 @@
 package com.unciv.ui.utils
 
+import com.badlogic.gdx.graphics.Color
+import com.badlogic.gdx.graphics.g2d.Batch
 import com.badlogic.gdx.scenes.scene2d.Group
 import com.badlogic.gdx.scenes.scene2d.actions.Actions
 import com.badlogic.gdx.scenes.scene2d.actions.RepeatAction
 import com.badlogic.gdx.scenes.scene2d.ui.Image
+import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable
 import com.badlogic.gdx.utils.Align
 import com.unciv.UncivGame
 import com.unciv.logic.map.mapunit.MapUnit
 import com.unciv.ui.images.ImageGetter
-import com.unciv.ui.utils.extensions.center
+import com.unciv.ui.utils.extensions.addToCenter
 import com.unciv.ui.utils.extensions.colorFromRGB
+import com.unciv.ui.utils.extensions.setSize
 import com.unciv.ui.utils.extensions.surroundWithCircle
 import com.unciv.ui.utils.extensions.surroundWithThinCircle
 
-class UnitGroup(val unit: MapUnit, val size: Float): Group() {
+class FlagBackground(drawable: TextureRegionDrawable, size: Float): Image(drawable) {
-    var actionGroup :Group? = null
+
-    val flagIcon = ImageGetter.getUnitIcon(unit.name, unit.civ.nation.getInnerColor())
+    var drawableInner: TextureRegionDrawable? = null
-        .apply {
+
-            if (unit.isCivilian())
+    var innerColor: Color = Color.WHITE
-                setSize(size * 0.60f, size * 0.60f)
+    var outerColor: Color = Color.RED
-            else
+    var outlineColor: Color = Color.WHITE
-                setSize(size * 0.75f, size * 0.75f) }
+
-    var flagSelection: Image = getBackgroundSelectionForUnit()
+    var drawOutline = false
-    var flagBg: Group = Group()
+
+    private val innerMultiplier = 0.88f
+    private val outlineMultiplier = 1.08f
+
+    private val innerWidth: Float; private val innerHeight: Float
+    private val innerOffsetX: Float; private val innerOffsetY: Float
+
+    private val outlineWidth: Float; private val outlineHeight: Float
+    private val outlineOffsetX: Float; private val outlineOffsetY: Float
 
     init {
 
-        val outerBg = getBackgroundImageForUnit()
+        val ratio = height/width
-        val innerBg = getBackgroundImageForUnit()
+        width = size
-        val maskBg = getBackgroundMaskForUnit()
+        height = size * ratio
 
-        val sizeSelectionX = size*1.9f; val sizeSelectionY = sizeSelectionX*flagSelection.height/flagSelection.width
+        innerWidth = width * innerMultiplier; innerHeight = height * innerMultiplier
-        val sizeOuterBgX = size*1.15f; val sizeOuterBgY = sizeOuterBgX*outerBg.height/outerBg.width
+        innerOffsetX = (width - innerWidth) / 2; innerOffsetY = (height - innerHeight) / 2
-        val sizeInnerBgX = size; val sizeInnerBgY = sizeInnerBgX*innerBg.height/innerBg.width
 
-        setSize(sizeOuterBgX, sizeOuterBgY)
+        outlineWidth = width * outlineMultiplier; outlineHeight = height * outlineMultiplier
+        outlineOffsetX = (outlineWidth - width) / 2; outlineOffsetY = (outlineHeight - height) / 2
+    }
 
-        flagSelection.color.set(1f, 1f, 1f, 0f)
+    override fun getDrawable(): TextureRegionDrawable {
+        return super.getDrawable() as TextureRegionDrawable
+    }
+
+    override fun draw(batch: Batch?, parentAlpha: Float) {
+        val alpha = color.a*parentAlpha
+        val drawable = drawable
+
+        if (drawOutline) {
+            batch?.setColor(outlineColor.r, outlineColor.g, outlineColor.b, outlineColor.a*alpha)
+            drawable.draw(batch, x-outlineOffsetX, y-outlineOffsetY, outlineWidth, outlineHeight)
+        }
+
+        batch?.setColor(outerColor.r, outerColor.g, outerColor.b, outerColor.a*alpha)
+        drawable.draw(batch, x, y, width, height)
+
+        batch?.setColor(innerColor.r, innerColor.g, innerColor.b, innerColor.a * alpha)
+        if (drawableInner == null) {
+            drawable.draw(batch, x + innerOffsetX, y + innerOffsetY, innerWidth, innerHeight)
+        } else {
+            drawableInner!!.draw(batch, x, y, width, height)
+        }
+    }
+
+}
+
+class UnitGroup(val unit: MapUnit, val size: Float): Group() {
+    var actionGroup :Group? = null
+
+    private val flagIcon = ImageGetter.getUnitIcon(unit.name, unit.civ.nation.getInnerColor())
+    private var flagBg: FlagBackground = FlagBackground(getBackgroundDrawableForUnit(), size)
+    private var flagSelection: Image = getBackgroundSelectionForUnit()
+    private var flagMask: Image? = getBackgroundMaskForUnit()
+
+    init {
+
+        isTransform = false // performance helper - nothing here is rotated or scaled
+        color.a *= UncivGame.Current.settings.unitIconOpacity
+
+        val sizeSelectionX = size*1.6f
+        val sizeSelectionY = sizeSelectionX*flagSelection.height/flagSelection.width
+
+        setSize(flagBg.width, flagBg.height)
+
+        flagSelection.color.set(1f, 1f, 0.9f, 0f)
         flagSelection.align = Align.center
         flagSelection.setSize(sizeSelectionX, sizeSelectionY)
-        flagSelection.center(this)
 
-        flagBg.setSize(sizeOuterBgX, sizeOuterBgY)
+        flagBg.innerColor = unit.civ.nation.getOuterColor()
+        flagBg.outerColor = unit.civ.nation.getInnerColor()
+        flagBg.outlineColor = flagBg.innerColor
+        flagBg.drawableInner = getBackgroundInnerDrawableForUnit()
 
-        // 0f (invisible) to 1f (fully opaque)
+        if (flagMask != null) {
-        flagIcon.color.a = UncivGame.Current.settings.unitIconOpacity
+            flagMask!!.setSize(size*0.88f, size*0.88f * flagMask!!.height / flagMask!!.width)
+        }
 
-        outerBg.color = unit.civ.nation.getInnerColor()
+        val flagIconSizeMultiplier: Float = if (unit.isCivilian()) 0.5f else 0.65f
-        outerBg.color.a = UncivGame.Current.settings.unitIconOpacity
+        flagIcon.setSize(size * flagIconSizeMultiplier)
-        outerBg.setSize(sizeOuterBgX, sizeOuterBgY)
-        outerBg.center(flagBg)
 
-        innerBg.color = unit.civ.nation.getOuterColor()
+        addToCenter(flagSelection)
-        innerBg.color.a = UncivGame.Current.settings.unitIconOpacity
+        addToCenter(flagBg)
-        innerBg.setSize(sizeInnerBgX, sizeInnerBgY)
+        if (flagMask != null)
-        innerBg.center(flagBg)
+            addToCenter(flagMask!!)
-
+        addToCenter(flagIcon)
-        maskBg?.color?.a = UncivGame.Current.settings.unitIconOpacity
-        maskBg?.setSize(size, size*maskBg.height / maskBg.width)
-        maskBg?.center(flagBg)
-
-        flagBg.addActor(outerBg)
-        flagBg.addActor(innerBg)
-        if (maskBg != null)
-            flagBg.addActor(maskBg)
-        flagBg.center(this)
-
-        flagIcon.center(this)
-
-        addActor(flagSelection)
-        addActor(flagBg)
-        addActor(flagIcon)
 
         val actionImage = getActionImage()
         if (actionImage != null) {
-            val actionCircle = actionImage
+            actionGroup = actionImage
-                .surroundWithCircle(size / 2 * 0.9f)
+                .surroundWithCircle(size/2 * 0.9f)
                 .surroundWithThinCircle()
-            actionCircle.setPosition(size / 2, 0f)
+            actionGroup!!.setPosition(size/2, 0f)
-            actionCircle.color.a = UncivGame.Current.settings.unitIconOpacity
+            addActor(actionGroup)
-            addActor(actionCircle)
-            actionGroup = actionCircle
-            actionCircle.toFront()
         }
 
         if (unit.health < 100) { // add health bar
             addActor(ImageGetter.getHealthBar(unit.health.toFloat(), 100f, size))
         }
-
-        isTransform = false // performance helper - nothing here is rotated or scaled
     }
 
-    private fun getBackgroundImageForUnit(): Image {
+    private fun getBackgroundDrawableForUnit(): TextureRegionDrawable {
         return when {
-            unit.isEmbarked() -> ImageGetter.getImage("UnitFlagIcons/UnitFlagEmbark")
+            unit.isEmbarked() -> ImageGetter.getDrawable("UnitFlagIcons/UnitFlagEmbark")
-            unit.isFortified() -> ImageGetter.getImage("UnitFlagIcons/UnitFlagFortify")
+            unit.isFortified() -> ImageGetter.getDrawable("UnitFlagIcons/UnitFlagFortify")
-            unit.isCivilian() -> ImageGetter.getImage("UnitFlagIcons/UnitFlagCivilian")
+            unit.isCivilian() -> ImageGetter.getDrawable("UnitFlagIcons/UnitFlagCivilian")
-            else -> ImageGetter.getImage("UnitFlagIcons/UnitFlag")
+            else -> ImageGetter.getDrawable("UnitFlagIcons/UnitFlag")
+        }
+    }
+
+    private fun getBackgroundInnerDrawableForUnit(): TextureRegionDrawable? {
+        return when {
+            unit.isEmbarked() -> ImageGetter.getDrawableOrNull("UnitFlagIcons/UnitFlagEmbarkInner")
+            unit.isFortified() -> ImageGetter.getDrawableOrNull("UnitFlagIcons/UnitFlagFortifyInner")
+            unit.isCivilian() -> ImageGetter.getDrawableOrNull("UnitFlagIcons/UnitFlagCivilianInner")
+            else -> ImageGetter.getDrawableOrNull("UnitFlagIcons/UnitFlagInner")
         }
     }
 
@@ -135,16 +182,12 @@ class UnitGroup(val unit: MapUnit, val size: Float): Group() {
     }
 
     fun highlightRed() {
-        flagSelection.color = colorFromRGB(230, 20, 0).apply { a = 1.0f }
+        flagSelection.color = colorFromRGB(230, 0, 0).apply { a = 1f }
-        flagSelection.width *= 0.9f
+        flagBg.drawOutline = true
-        flagSelection.height *= 0.9f
-        flagSelection.center(flagSelection.parent)
     }
 
     fun selectUnit() {
-
+        color.a = 1f
-        //Make unit icon background colors fully opaque when units are selected
-        flagBg.children.forEach { it.color?.a = 1f }
 
         //If unit is idle, leave actionGroup at 50% opacity when selected
         if (unit.isIdle()) {
@@ -160,6 +203,7 @@ class UnitGroup(val unit: MapUnit, val size: Float): Group() {
         val alpha = if (shouldBeFaded) 0.5f else 1f
         flagIcon.color.a = alpha
         flagBg.color.a = alpha
+        flagSelection.color.a = 1f
 
         if (UncivGame.Current.settings.continuousRendering) {
             flagSelection.color.a = 1f
@@ -167,7 +211,7 @@ class UnitGroup(val unit: MapUnit, val size: Float): Group() {
                 Actions.repeat(
                     RepeatAction.FOREVER,
                     Actions.sequence(
-                        Actions.alpha(0.6f, 1f),
+                        Actions.alpha(0.7f, 1f),
                         Actions.alpha(1f, 1f)
                     )
                 )

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

@@ -733,8 +733,7 @@ class WorldMapHolder(
             for (tileGroup in tileGroups.values) {
                 tileGroup.layerCityButton.isTransform = false // to save on rendering time to improve framerate
             }
-        }
+        } else if (clampedCityButtonZoom >= minZoom) {
-        if (clampedCityButtonZoom < 1 && clampedCityButtonZoom >= minZoom) {
             for (tileGroup in tileGroups.values) {
                 // ONLY set those groups that have active city buttons as transformable!
                 // This is massively framerate-improving!