got-mod-strategicview-plus/Class1.cs

using BepInEx;
using HarmonyLib;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
using TMPro;

namespace StrategicMapPlus
{
    [BepInPlugin("com.mod.strategicmapplus", "Strategic Map Plus", "28.0.0")]
    public class StrategicMapMod : BaseUnityPlugin
    {
        public static bool GlobalShowToggle = false;
        private float timer = 0f;
        private float interval = 0.5f;
        private bool texturesLoaded = false;

        public static Dictionary<string, Sprite> SpriteCache = new Dictionary<string, Sprite>();
        public static Dictionary<string, Texture2D> RawTextureCache = new Dictionary<string, Texture2D>();
        private HashSet<string> reportedMissingKeys = new HashSet<string>();

        void Awake()
        {
            Logger.LogInfo("Strategic Map Plus v28: Posición 0,0,0.");
        }

        void Update()
        {
            // Toggle con Ctrl + V
            if ((Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl)) && Input.GetKeyDown(KeyCode.V))
            {
                GlobalShowToggle = !GlobalShowToggle;
            }

            if (!texturesLoaded && Time.time > 3f) LoadTextures();

            timer += Time.deltaTime;
            if (timer < interval) return;
            timer = 0f;

            if (texturesLoaded) ScanStrategicMap();
        }

        void LoadTextures()
        {
            Texture2D[] allTextures = Resources.FindObjectsOfTypeAll<Texture2D>();
            Dictionary<string, Texture2D> textureLookup = new Dictionary<string, Texture2D>();

            foreach (var tex in allTextures)
            {
                if (tex != null && !string.IsNullOrEmpty(tex.name))
                {
                    if (!textureLookup.ContainsKey(tex.name)) textureLookup.Add(tex.name, tex);
                }
            }

            int loadedCount = 0;

            foreach (var kvp in Textures.TextureMap)
            {
                string logicKey = kvp.Key;
                string texName = kvp.Value;

                if (textureLookup.ContainsKey(texName))
                {
                    Texture2D tex = textureLookup[texName];
                    RawTextureCache[logicKey] = tex; // Guardamos la original para Debug
                    
                    Textures.IconOffset offset = null;
                    if (Textures.IconsOffsets.ContainsKey(logicKey)) offset = Textures.IconsOffsets[logicKey];

                    Texture2D roundTex = MakeTextureTransparent(tex, offset);
                    Sprite s = Sprite.Create(roundTex, new Rect(0, 0, roundTex.width, roundTex.height), new Vector2(0.5f, 0.5f));
                    SpriteCache[logicKey] = s;
                    loadedCount++;
                }
            }

            if (loadedCount > 0) texturesLoaded = true;
        }

        void ScanStrategicMap()
        {
            GameObject regionsRoot = GameObject.Find("UI/2DRoot/Layout/Limit/FrontDialogs/StrategicView/Root/Regions");
            if (regionsRoot == null || !regionsRoot.activeInHierarchy) return;

            foreach (Transform region in regionsRoot.transform)
            {
                Transform army = region.Find("Army");
                if (army == null) continue;

                Component defenseRenderer = army.GetComponent("iron.match.renderers.strategicview.DefenseCountRenderer");
                Transform visualRoot = army.Find("Root");
                Transform targetParent = (visualRoot != null) ? visualRoot : army;

                if (defenseRenderer != null)
                    ProcessRegion((MonoBehaviour)defenseRenderer, targetParent);
            }
        }

        void ProcessRegion(MonoBehaviour renderer, Transform parentTransform)
        {
            var visualizer = parentTransform.GetComponent<StrategicDisplay>();
            if (visualizer == null)
            {
                visualizer = parentTransform.gameObject.AddComponent<StrategicDisplay>();
                visualizer.Initialize();
            }

            var traverse = Traverse.Create(renderer);
            var model = traverse.Property("model").GetValue();
            if (model == null) { visualizer.Hide(); return; }

            var children = Traverse.Create(model).Field("Children").GetValue() as IEnumerable;
            if (children == null) children = Traverse.Create(model).Field("children").GetValue() as IEnumerable;

            string orderType = "";
            bool isSpecial = false;
            int strength = 0;
            bool found = false;

            if (children != null)
            {
                foreach (var child in children)
                {
                    var childTrav = Traverse.Create(child);
                    var attributesObj = childTrav.Field("attributes").GetValue();
                    if (attributesObj != null)
                    {
                        var valuesDict = Traverse.Create(attributesObj).Field("data").GetValue() as IDictionary;
                        if (valuesDict != null && valuesDict.Contains(400003))
                        {
                            object typeCont = valuesDict[400003];
                            object typeVal = Traverse.Create(typeCont).Property("Value").GetValue();

                            if (typeVal?.ToString() == "Order")
                            {
                                if (valuesDict.Contains(400038)) // OrderType
                                {
                                    object oCont = valuesDict[400038];
                                    object oVal = Traverse.Create(oCont).Property("Value").GetValue();
                                    var list = oVal as IList;
                                    if (list != null && list.Count > 0) orderType = list[0].ToString();
                                }
                                if (valuesDict.Contains(400039)) // HasStar
                                {
                                    object sCont = valuesDict[400039];
                                    object sVal = Traverse.Create(sCont).Property("Value").GetValue();
                                    if (sVal != null && sVal.ToString().ToLower() == "true") isSpecial = true;
                                }
                                if (valuesDict.Contains(400004)) // Strength
                                {
                                    object strCont = valuesDict[400004];
                                    object strVal = Traverse.Create(strCont).Property("Value").GetValue();
                                    int.TryParse(strVal?.ToString(), out strength);
                                }
                                found = true;
                                break;
                            }
                        }
                    }
                }
            }

            if (!found)
            {
                visualizer.Hide();
                return;
            }

            // Generar clave lógica
            string generatedKey = $"{orderType}_{strength}";
            if (isSpecial) generatedKey += "_Star";

            if (SpriteCache.ContainsKey(generatedKey))
            {
                Texture2D raw = RawTextureCache.ContainsKey(generatedKey) ? RawTextureCache[generatedKey] : null;
                visualizer.ShowIcon(SpriteCache[generatedKey], raw);
            }
            else
            {
                if (!reportedMissingKeys.Contains(generatedKey))
                {
                    Logger.LogWarning($"[FALTA MAPEO] El juego pide: '{generatedKey}'");
                    reportedMissingKeys.Add(generatedKey);
                }
                visualizer.ShowText(generatedKey);
            }
        }

        // Función auxiliar que podrías llamar desde tu parche de Harmony
        public static Texture2D MakeTextureTransparent(Texture originalTexture, Textures.IconOffset offset = null)
        {
            if (originalTexture == null) return null;

            // 1. Crear una RenderTexture temporal para poder leer la textura original
            RenderTexture tmp = RenderTexture.GetTemporary(
                originalTexture.width,
                originalTexture.height,
                0,
                RenderTextureFormat.Default,
                RenderTextureReadWrite.Linear);

            // 2. Copiar la textura original a la RenderTexture (esto "desbloquea" los píxeles)
            Graphics.Blit(originalTexture, tmp);
            
            // 3. Activar la RenderTexture para leerla
            RenderTexture previous = RenderTexture.active;
            RenderTexture.active = tmp;

            // 4. Crear una nueva Texture2D leíble
            Texture2D newTexture = new Texture2D(originalTexture.width, originalTexture.height);
            newTexture.ReadPixels(new Rect(0, 0, tmp.width, tmp.height), 0, 0);
            
            // 5. MODIFICAR LOS PÍXELES (Lógica de Re-muestreo / Resampling)
            // En lugar de mover la máscara, dejamos la máscara fija en el centro y movemos la textura (Source).
            // Esto permite hacer CLAMP (repetir bordes) para evitar cortes rectos.

            Color[] sourcePixels = newTexture.GetPixels(); // Píxeles originales (Source)
            Color[] finalPixels = new Color[sourcePixels.Length]; // Píxeles destino (Destination)
            
            float width = newTexture.width;
            float height = newTexture.height;
            Vector2 center = new Vector2(width / 2f, height / 2f);
            
            // Configuración por defecto
            float maskRadius = (Mathf.Min(width, height) / 2f);
            float shiftX = 0f;
            float shiftY = 0f;

            if (offset != null)
            {
                // Size: Escala de la máscara (1.0 = toca bordes)
                if (offset.size > 0) maskRadius *= offset.size;

                // Offset: Desplazamiento del CONTENIDO (UV Shift)
                // Si Offset X > 0 (positivo), queremos ver lo que hay a la derecha,
                // por tanto "desplazamos la textura hacia la izquierda" (sumamos al índice de lectura).
                shiftX = offset.x * width;
                shiftY = offset.y * height;
            } else
            {
                // Default
                offset = new Textures.IconOffset(0.07f, 0, 0.9f);

                if (offset.size > 0) maskRadius *= offset.size;
                shiftX = offset.x * width;
                shiftY = offset.y * height;
            }

            int w = (int)width;
            int h = (int)height;

            for (int i = 0; i < finalPixels.Length; i++)
            {
                int x = i % w;
                int y = i / w;

                // 1. MÁSCARA (Siempre centrada en el output)
                float dist = Vector2.Distance(new Vector2(x, y), center);
                if (dist > maskRadius)
                {
                    finalPixels[i] = Color.clear;
                    continue;
                }

                // 2. MUESTREO (Sampling) con Offset
                // Calculamos qué píxel de la textura original corresponde a esta posición (x,y)
                int srcX = (int)(x + shiftX);
                int srcY = (int)(y + shiftY);

                // 3. CLAMP (Repetir bordes)
                // Si nos salimos de la textura, repetimos el último píxel válido.
                // Esto evita el "corte recto" transparente (siempre que el borde tenga color).
                srcX = Mathf.Clamp(srcX, 0, w - 1);
                srcY = Mathf.Clamp(srcY, 0, h - 1);

                // Leemos del array original
                int srcIndex = srcY * w + srcX;
                finalPixels[i] = sourcePixels[srcIndex];
            }

            newTexture.SetPixels(finalPixels);
            newTexture.Apply();

            // 6. Limpieza
            RenderTexture.active = previous;
            RenderTexture.ReleaseTemporary(tmp);

            return newTexture;
        }
    }

    // --- VISUALIZADOR ---
    public class StrategicDisplay : MonoBehaviour
    {
        private GameObject displayObj;
        private Image iconImage;
        private TextMeshProUGUI debugText;
        private bool isInitialized = false;
        private bool hasContent = false;

        // --- ZONA DEBUG EN INSPECTOR ---
        public bool DebugMode = false;
        public float DebugOffsetX = 0f;
        public float DebugOffsetY = 0f;
        public float DebugSize = 1f;
        
        private Texture2D _rawTexture; // La textura original sin recortar
        private Texture2D _generatedDebugTex; // Para limpiar memoria
        private Sprite _defaultSprite; // Sprite original para restaurar
        private float _lastX, _lastY, _lastSize;
        private bool _lastDebugMode;

        void Update()
        {
            if (!isInitialized || displayObj == null) return;
            
            // Lógica de visualización (V o Ctrl+V)
            bool shouldShow = hasContent && (StrategicMapMod.GlobalShowToggle || Input.GetKey(KeyCode.V));
            if (displayObj.activeSelf != shouldShow)
            {
                displayObj.SetActive(shouldShow);
            }

            // Lógica de DEBUG en tiempo real
            if (_rawTexture != null)
            {
                // Si activamos el modo debug, forzamos actualización
                if (DebugMode && !_lastDebugMode)
                {
                    _lastDebugMode = true;
                    UpdateDebugTexture();
                }
                else if (!DebugMode && _lastDebugMode)
                {
                     _lastDebugMode = false;
                     // AL SALIR DEL DEBUG: Restaurar el sprite original
                     if (iconImage != null && _defaultSprite != null) iconImage.sprite = _defaultSprite;
                }

                if (DebugMode)
                {
                    if (_lastX != DebugOffsetX || _lastY != DebugOffsetY || _lastSize != DebugSize)
                    {
                        UpdateDebugTexture();
                    }
                }
            }
        }

        private void UpdateDebugTexture()
        {
            _lastX = DebugOffsetX;
            _lastY = DebugOffsetY;
            _lastSize = DebugSize;

            if (_generatedDebugTex != null) Destroy(_generatedDebugTex);

            var debugOffset = new Textures.IconOffset(DebugOffsetX, DebugOffsetY, DebugSize);
            _generatedDebugTex = StrategicMapMod.MakeTextureTransparent(_rawTexture, debugOffset);
            
            if (_generatedDebugTex != null)
            {
                Sprite debugSprite = Sprite.Create(_generatedDebugTex, new Rect(0, 0, _generatedDebugTex.width, _generatedDebugTex.height), new Vector2(0.5f, 0.5f));
                if (iconImage != null) iconImage.sprite = debugSprite;
            }
        }

        public void Initialize()
        {
            if (isInitialized && displayObj != null) return;
            if (displayObj != null) Destroy(displayObj);

            try
            {
                displayObj = new GameObject("OrderIcon_Mod");
                displayObj.transform.SetParent(this.transform, false);

                // POSICIÓN EXACTA 0,0,0
                displayObj.transform.localPosition = Vector3.zero;

                // Aseguramos capa correcta
                displayObj.layer = this.gameObject.layer;

                RectTransform rt = displayObj.AddComponent<RectTransform>();
                rt.sizeDelta = new Vector2(45, 45); // Tamaño del icono

                iconImage = displayObj.AddComponent<Image>();
                iconImage.raycastTarget = false;
                iconImage.color = Color.white;

                // Backup Text
                GameObject textObj = new GameObject("BackupText");
                textObj.transform.SetParent(displayObj.transform, false);
                textObj.layer = this.gameObject.layer;

                RectTransform textRt = textObj.AddComponent<RectTransform>();
                textRt.anchoredPosition = Vector2.zero;

                debugText = textObj.AddComponent<TextMeshProUGUI>();
                debugText.alignment = TextAlignmentOptions.Center;
                debugText.fontSize = 14;
                debugText.fontStyle = FontStyles.Bold;
                debugText.color = Color.magenta;

                // CRUCIAL: Ponemos el icono al final de la lista de hijos para que se pinte ENCIMA
                displayObj.transform.SetAsLastSibling();

                // Inicialmente oculto
                displayObj.SetActive(false);

                isInitialized = true;
            }
            catch (System.Exception e)
            {
                Debug.LogWarning("Error UI: " + e.Message);
                if (displayObj != null) Destroy(displayObj);
                isInitialized = false;
            }
        }

        public void Hide()
        {
            hasContent = false;
            if (displayObj != null && displayObj.activeSelf) displayObj.SetActive(false);
        }

        public void ShowIcon(Sprite s, Texture2D raw = null)
        {
            if (!isInitialized) Initialize();
            if (!isInitialized) return;

            // Guardamos la referencia raw para el debug
            _rawTexture = raw;
            _defaultSprite = s; // Guardamos el sprite base

            // Aseguramos orden de dibujado (Encima de todo)
            displayObj.transform.SetAsLastSibling();

            if (s != null)
            {
                // Solo sobreescribimos visualmente si NO estamos en modo debug
                if (!DebugMode)
                {
                    iconImage.sprite = s;
                }
                
                iconImage.enabled = true;
                if (debugText != null) debugText.text = "";
                hasContent = true;
            }
        }

        public void ShowText(string t)
        {
            if (!isInitialized) Initialize();
            if (!isInitialized) return;

            displayObj.transform.SetAsLastSibling();

            if (iconImage != null) iconImage.enabled = false;
            if (debugText != null) debugText.text = t;
            hasContent = true;
        }
    }
}