SlotsAndDaggersAccessibilityMod.cs

using System;
using System.Collections;
using System.Runtime.InteropServices;
using System.Text;
using System.Reflection;
using MelonLoader;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using HarmonyLib;
using System.Collections.Generic;
using System.Linq;

[assembly: MelonInfo(typeof(SlotsAndDaggersAccessibility.AccessibilityMod), "Slots And Daggers Accessibility", "1.0.0", "Accessibility Team")]
[assembly: MelonGame("Friedemann", "SlotsAndDaggers")]

namespace SlotsAndDaggersAccessibility
{
    public class AccessibilityMod : MelonMod
    {
        // NVDA Controller Client P/Invoke - has proper speech queuing
        [DllImport("nvdaControllerClient64.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
        private static extern int nvdaController_testIfRunning();

        [DllImport("nvdaControllerClient64.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
        private static extern int nvdaController_speakText([MarshalAs(UnmanagedType.LPWStr)] string text);

        [DllImport("nvdaControllerClient64.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
        private static extern int nvdaController_cancelSpeech();

        // TOLK P/Invoke declarations
        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern void Tolk_Load();

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern void Tolk_Unload();

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        private static extern bool Tolk_Output([MarshalAs(UnmanagedType.LPWStr)] string text, bool interrupt);

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        private static extern bool Tolk_Speak([MarshalAs(UnmanagedType.LPWStr)] string text, bool interrupt);

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern bool Tolk_Silence();

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        private static extern IntPtr Tolk_DetectScreenReader();

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern bool Tolk_HasSpeech();

        [DllImport("Tolk.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern bool Tolk_IsSpeaking();

        private static bool tolkInitialized = false;
        private static bool useNVDADirect = false;
        private static GameObject lastSelectedObject = null;
        private static string lastAnnouncedText = "";
        private static float lastAnnouncementTime = 0f;
        private const float ANNOUNCEMENT_COOLDOWN = 0.05f;
        public static GameState previousGameState = GameState.NoState;
        public static bool suppressNextButtonAnnouncement = false;
        public static float suppressUIFeedbackUntil = 0f;

        public override void OnInitializeMelon()
        {
            LoggerInstance.Msg("Initializing Slots And Daggers Accessibility Mod...");
            
            // Try NVDA Controller Client first for proper queuing
            try
            {
                int result = nvdaController_testIfRunning();
                if (result == 0)
                {
                    useNVDADirect = true;
                    LoggerInstance.Msg("NVDA Controller Client initialized successfully");
                    nvdaController_speakText("Slots And Daggers Accessibility Mod loaded successfully");
                }
                else
                {
                    throw new Exception("NVDA not running");
                }
            }
            catch
            {
                // Fallback to TOLK
                try
                {
                    Tolk_Load();
                    tolkInitialized = true;
                    
                    IntPtr srPtr = Tolk_DetectScreenReader();
                    string screenReaderName = srPtr != IntPtr.Zero ? Marshal.PtrToStringUni(srPtr) : "None";
                    
                    LoggerInstance.Msg($"TOLK initialized successfully. Screen reader detected: {screenReaderName}");
                    Speak("Slots And Daggers Accessibility Mod loaded successfully", true);
                }
                catch (Exception ex)
                {
                    LoggerInstance.Error($"Failed to initialize screen reader support: {ex.Message}");
                }
            }

            // Apply Harmony patches
            try
            {
                LoggerInstance.Msg("Applying Harmony patches...");
                HarmonyInstance.PatchAll();
                LoggerInstance.Msg("Harmony patches applied successfully");
            }
            catch (Exception ex)
            {
                LoggerInstance.Error($"Failed to apply Harmony patches: {ex.Message}");
            }
        }

        public override void OnDeinitializeMelon()
        {
            if (tolkInitialized)
            {
                LoggerInstance.Msg("Unloading TOLK...");
                Tolk_Unload();
                tolkInitialized = false;
            }
        }

        public override void OnUpdate()
        {
            // Check for UI focus changes
            CheckUIFocusChanges();
            
            // Hotkey: P = Player Status (only during gameplay or in modifier shop)
            if (UnityEngine.InputSystem.Keyboard.current != null && 
                UnityEngine.InputSystem.Keyboard.current.pKey.wasPressedThisFrame)
            {
                MelonLogger.Msg($"P key pressed. State: {previousGameState}");
                MelonLogger.Msg($"ModifierManager null: {Main.ModifierManager == null}");
                if (Main.ModifierManager != null)
                {
                    MelonLogger.Msg($"ModifierManager active: {Main.ModifierManager.gameObject.activeInHierarchy}");
                }
                MelonLogger.Msg($"IsInGameplay: {IsInGameplay()}");
                
                // In modifier shop, announce chips only
                // Check if ModifierManager exists and we're not in active gameplay
                if (Main.ModifierManager != null && 
                    Main.ModifierManager.gameObject.activeInHierarchy &&
                    !IsInGameplay())
                {
                    AnnounceChips();
                }
                // During gameplay, announce full player status
                else if (IsInGameplay())
                {
                    AnnouncePlayerStatus();
                }
            }
            
            // Hotkey: E = Enemy Status (only during gameplay when enemy exists)
            if (UnityEngine.InputSystem.Keyboard.current != null && 
                UnityEngine.InputSystem.Keyboard.current.eKey.wasPressedThisFrame)
            {
                if (IsInGameplay())
                {
                    AnnounceEnemyStatus();
                }
            }
        }
        
        private bool IsInGameplay()
        {
            // Check if we're in active gameplay states
            return previousGameState == GameState.Spinning ||
                   previousGameState == GameState.ExecutingSlots ||
                   previousGameState == GameState.UsePowerUps ||
                   previousGameState == GameState.PlayerAttack ||
                   previousGameState == GameState.EncounterAttack ||
                   previousGameState == GameState.UpgradeShop ||
                   previousGameState == GameState.NewEncounter;
        }
        
        private void AnnounceChips()
        {
            MelonLogger.Msg("AnnounceChips called");
            if (Main.PlayerInventory == null)
            {
                MelonLogger.Msg("PlayerInventory is null");
                SpeakImmediate("Chips unavailable");
                return;
            }
            
            string status = string.Format("Chips: {0}", Main.PlayerInventory.Chips);
            MelonLogger.Msg($"Announcing: {status}");
            SpeakImmediate(status);
        }
        
        private void AnnouncePlayerStatus()
        {
            if (Main.HealthManager == null || Main.PlayerInventory == null)
            {
                SpeakImmediate("Player status unavailable");
                return;
            }
            
            string status = string.Format("Player: Health {0:F0} out of {1:F0}. Shield {2:F0}. Coins {3}.",
                Main.HealthManager.CurrentHealth,
                Main.HealthManager.MaxHealth,
                Main.HealthManager.CurrentShield,
                Main.PlayerInventory.TotalCoins);
            
            SpeakImmediate(status);
        }
        
        private void AnnounceEnemyStatus()
        {
            if (Main.EncounterManager == null || Main.EncounterManager.CurrentEncounter == null)
            {
                SpeakImmediate("No enemy");
                return;
            }
            
            var encounter = Main.EncounterManager.CurrentEncounter;
            string status = string.Format("Enemy: {0}. Health {1:F0} out of {2:F0}",
                encounter.name.Replace("(Clone)", "").Trim(),
                encounter.CurrentHealth,
                encounter.FullHealth);
            
            // Add shield information
            if (encounter.CurrentShield > 0)
            {
                status += string.Format(". Shield {0:F0}", encounter.CurrentShield);
            }
            
            // Add attack intention information
            float physAttack = encounter.CurrentAttackStrengthPhysical;
            float magAttack = encounter.CurrentAttackStrengthMagical;
            
            if (physAttack > 0 || magAttack > 0)
            {
                status += ". Next attack: ";
                if (physAttack > 0)
                {
                    status += string.Format("Physical {0:F0}", physAttack);
                }
                if (magAttack > 0)
                {
                    if (physAttack > 0) status += ", ";
                    status += string.Format("Magical {0:F0}", magAttack);
                }
            }
            
            SpeakImmediate(status);
        }

        private void CheckUIFocusChanges()
        {
            if (EventSystem.current == null) return;

            GameObject currentSelected = EventSystem.current.currentSelectedGameObject;
            
            if (currentSelected != lastSelectedObject && currentSelected != null)
            {
                lastSelectedObject = currentSelected;
                
                // Don't announce UI during splash screen/loading or when no proper game state
                if (previousGameState == GameState.SplashScreen || 
                    previousGameState == GameState.NoState ||
                    Main.GameManager == null ||
                    Main.GameManager.CurrentGameState == GameState.SplashScreen ||
                    Main.GameManager.CurrentGameState == GameState.NoState)
                {
                    return;
                }
                
                // Check if we should suppress this announcement
                if (suppressNextButtonAnnouncement)
                {
                    suppressNextButtonAnnouncement = false;
                    return;
                }
                
                MelonLogger.Msg($"[UI] Selected object: {currentSelected.name}, Components: {string.Join(", ", currentSelected.GetComponents<Component>().Select(c => c.GetType().Name))}");
                AnnounceUIElement(currentSelected);
            }
        }

        private void AnnounceUIElement(GameObject obj)
        {
            if (obj == null) return;

            // Check for mod dongle (modifier shop)
            var modDongle = obj.GetComponent<ModDongle>();
            if (modDongle != null)
            {
                var modifier = modDongle.Modifier;
                if (modifier != null)
                {
                    string announcement = modifier.Description() + ". Cost: " + modifier.CurrentCost + " coins";
                    SpeakImmediate(announcement);
                    return;
                }
            }

            // Check for upgrade shop option - don't announce here, UIFeedbackManager handles it
            var upgradeShopOption = obj.GetComponent<UpgradeShopOption>();
            if (upgradeShopOption != null)
            {
                // Upgrade shop announcements are handled by UIFeedbackManager, don't announce the button itself
                return;
            }

            // Check for progress icon
            var progressIcon = obj.GetComponent<ProgressIcon>();
            if (progressIcon != null)
            {
                // Access private fields using reflection
                var displayNameField = typeof(ProgressIcon).GetField("displayName", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                var descriptionField = typeof(ProgressIcon).GetField("description", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                var unlockedField = typeof(ProgressIcon).GetField("unlocked", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                
                if (displayNameField != null)
                {
                    string displayName = displayNameField.GetValue(progressIcon) as string;
                    string description = descriptionField?.GetValue(progressIcon) as string;
                    bool unlocked = unlockedField != null && (bool)unlockedField.GetValue(progressIcon);
                    
                    string announcement = displayName;
                    if (!unlocked)
                    {
                        announcement += " - Locked";
                    }
                    else if (!string.IsNullOrEmpty(description))
                    {
                        announcement += ". " + description;
                    }
                    
                    SpeakImmediate(announcement);
                    return;
                }
            }

            // Check for level selection button - don't announce here, patches handle it
            var levelSelectButton = obj.GetComponent<LevelSelectButton>();
            if (levelSelectButton != null)
            {
                // Level announcements are handled by patches, don't announce the button itself
                return;
            }

            // Check for equipment selection button - don't announce here, patches handle it
            var equipmentButton = obj.GetComponent<EquipmentSelectionButton>();
            if (equipmentButton != null)
            {
                // Equipment announcements are handled by patches, don't announce the button itself
                return;
            }

            // Check for power-up button - don't announce here, patch handles it
            var powerUpButton = obj.GetComponent<PowerUpButton>();
            if (powerUpButton != null)
            {
                // Power-up announcements are handled by PowerUpButton_SelectButton_Patch
                return;
            }

            // Check for slot symbol inventory icon - don't announce these
            var slotSymbolIcon = obj.GetComponent<SlotSymbolInventoryIcon>();
            if (slotSymbolIcon != null)
            {
                // Don't announce inventory icons
                return;
            }

            // Check for slider
            var slider = obj.GetComponent<Slider>();
            if (slider != null)
            {
                string sliderName = GetUIElementLabel(obj);
                if (string.IsNullOrEmpty(sliderName))
                {
                    sliderName = obj.name.Replace("Slider", "").Replace("slider", "");
                }
                float percentage = (slider.value / (slider.maxValue - slider.minValue)) * 100f;
                string announcement = string.Format("{0}: {1:F0}%", sliderName, percentage);
                SpeakImmediate(announcement);
                return;
            }

            // Check for toggle
            var toggle = obj.GetComponent<Toggle>();
            if (toggle != null)
            {
                string toggleName = GetUIElementLabel(obj);
                if (string.IsNullOrEmpty(toggleName))
                {
                    toggleName = obj.name.Replace("Toggle", "").Replace("toggle", "");
                }
                string state = toggle.isOn ? "On" : "Off";
                string announcement = string.Format("{0}: {1}", toggleName, state);
                SpeakImmediate(announcement);
                return;
            }

            // Check for dropdown
            var dropdown = obj.GetComponent<TMPro.TMP_Dropdown>();
            if (dropdown != null)
            {
                string dropdownName = GetUIElementLabel(obj);
                if (string.IsNullOrEmpty(dropdownName))
                {
                    dropdownName = obj.name.Replace("Dropdown", "").Replace("dropdown", "");
                }
                string selectedOption = dropdown.options[dropdown.value].text;
                string announcement = string.Format("{0}: {1}", dropdownName, selectedOption);
                SpeakImmediate(announcement);
                return;
            }

            Button button = obj.GetComponent<Button>();
            if (button != null)
            {
                string buttonText = GetButtonText(obj);

                // Don't announce the STOP button (start/stop spinning button)
                if (!string.IsNullOrEmpty(buttonText) && buttonText.ToUpper().Contains("STOP"))
                {
                    return;
                }

                if (!string.IsNullOrEmpty(buttonText))
                {
                    // Check if this is a health/shield display and add values
                    string announcement = buttonText;
                    
                    if (Main.HealthManager != null)
                    {
                        // Check if button text contains health or shield keywords
                        string lowerText = buttonText.ToLower();
                        if (lowerText.Contains("health") || lowerText.Contains("hp") || obj.name.ToLower().Contains("health"))
                        {
                            announcement = string.Format("{0}: {1:F0} out of {2:F0}", 
                                buttonText, 
                                Main.HealthManager.CurrentHealth, 
                                Main.HealthManager.MaxHealth);
                        }
                        else if (lowerText.Contains("shield") || obj.name.ToLower().Contains("shield"))
                        {
                            announcement = string.Format("{0}: {1:F0}", 
                                buttonText, 
                                Main.HealthManager.CurrentShield);
                        }
                    }
                    
                    // UI elements should interrupt and speak immediately (no ", button" suffix)
                    SpeakImmediate(announcement);
                }
            }
        }

        private string GetUIElementLabel(GameObject obj)
        {
            // Try to find a label in parent or sibling objects
            Transform parent = obj.transform.parent;
            if (parent != null)
            {
                // Check all children of parent for a label
                foreach (Transform child in parent)
                {
                    var tmp = child.GetComponent<TMPro.TextMeshProUGUI>();
                    if (tmp != null && !string.IsNullOrEmpty(tmp.text) && child.gameObject != obj)
                    {
                        return tmp.text;
                    }
                }
            }
            
            // Try to get from the object itself
            var tmpSelf = obj.GetComponentInChildren<TMPro.TextMeshProUGUI>();
            if (tmpSelf != null && !string.IsNullOrEmpty(tmpSelf.text))
            {
                return tmpSelf.text;
            }
            
            return null;
        }

        private string GetButtonText(GameObject obj)
        {
            // Try to get text from TextMeshProUGUI
            var tmp = obj.GetComponentInChildren<TMPro.TextMeshProUGUI>();
            if (tmp != null && !string.IsNullOrEmpty(tmp.text))
            {
                return CleanButtonText(tmp.text);
            }

            // Try to get text from Unity UI Text
            var text = obj.GetComponentInChildren<UnityEngine.UI.Text>();
            if (text != null && !string.IsNullOrEmpty(text.text))
            {
                return CleanButtonText(text.text);
            }

            // Use object name as fallback
            return CleanButtonText(obj.name);
        }

        private string CleanButtonText(string text)
        {
            if (string.IsNullOrEmpty(text)) return text;
            
            // Remove common prefixes
            text = text.Replace("Button Icon ", "");
            text = text.Replace("Button ", "");
            text = text.Replace("button icon ", "");
            text = text.Replace("button ", "");
            
            // Remove (Clone) suffix
            text = text.Replace("(Clone)", "");
            
            return text.Trim();
        }

        // Speak immediately, interrupting current speech (for UI elements)
        public static void SpeakImmediate(string text)
        {
            if (string.IsNullOrEmpty(text)) return;

            try
            {
                string cleanText = CleanText(text);
                if (!string.IsNullOrEmpty(cleanText))
                {
                    if (useNVDADirect)
                    {
                        nvdaController_cancelSpeech();
                        nvdaController_speakText(cleanText);
                    }
                    else if (tolkInitialized)
                    {
                        Tolk_Speak(cleanText, true);
                    }
                }
            }
            catch (Exception ex)
            {
                MelonLogger.Error("Failed to speak immediate: " + ex.Message);
            }
        }

        // Speak - let NVDA handle speech priorities based on user settings
        public static void Speak(string text, bool interrupt = false)
        {
            if (string.IsNullOrEmpty(text)) return;

            // Prevent duplicate announcements within cooldown period
            if (text == lastAnnouncedText && Time.time - lastAnnouncementTime < ANNOUNCEMENT_COOLDOWN)
            {
                return;
            }

            try
            {
                string cleanText = CleanText(text);
                if (!string.IsNullOrEmpty(cleanText))
                {
                    // Log what's being spoken, current game state, and call stack
                    var stackTrace = new System.Diagnostics.StackTrace(1, true);
                    var callerFrame = stackTrace.GetFrame(0);
                    string caller = callerFrame != null ? $"{callerFrame.GetMethod().DeclaringType?.Name}.{callerFrame.GetMethod().Name}" : "Unknown";
                    MelonLogger.Msg($"[SPEAK] State: {previousGameState} | Interrupt: {interrupt} | Caller: {caller} | Text: {cleanText}");

                    if (useNVDADirect)
                    {
                        if (interrupt)
                        {
                            nvdaController_cancelSpeech();
                        }
                        nvdaController_speakText(cleanText);
                    }
                    else if (tolkInitialized)
                    {
                        Tolk_Speak(cleanText, interrupt);
                    }
                    lastAnnouncedText = text;
                    lastAnnouncementTime = Time.time;
                }
            }
            catch (Exception ex)
            {
                MelonLogger.Error("Failed to speak: " + ex.Message);
            }
        }

        private static string CleanText(string text)
        {
            // Simple HTML tag removal without regex
            string cleanText = text;
            while (cleanText.IndexOf('<') >= 0 && cleanText.IndexOf('>') > cleanText.IndexOf('<'))
            {
                int start = cleanText.IndexOf('<');
                int end = cleanText.IndexOf('>', start);
                cleanText = cleanText.Remove(start, end - start + 1);
            }
            return cleanText.Trim();
        }

        public static void SpeakDelayed(string text, float delay, bool interrupt = false)
        {
            MelonCoroutines.Start(SpeakDelayedCoroutine(text, delay, interrupt));
        }

        private static IEnumerator SpeakDelayedCoroutine(string text, float delay, bool interrupt)
        {
            yield return new WaitForSeconds(delay);
            Speak(text, interrupt);
        }
    }

    // ============================
    // Harmony Patches
    // ============================

    // Patch GameManager.SwitchState to announce game state changes
    [HarmonyPatch(typeof(GameManager), "SwitchState")]
    public class GameManager_SwitchState_Patch
    {
        static void Postfix(GameState newState, GameManager __instance)
        {
            // If we're ending the ExecutingSlots phase, announce all accumulated results
            if (AccessibilityMod.previousGameState == GameState.ExecutingSlots && newState != GameState.ExecutingSlots)
            {
                // Announce all accumulated symbol results in order
                SlotSymbolAttack_Execute_Patch.AnnounceTotalDamage();
                SlotSymbolCoin_Execute_Patch.AnnounceTotalCoins();
                SlotSymbolHeal_Execute_Patch.AnnounceTotalHealing();
                SlotSymbolShield_Execute_Patch.AnnounceTotalShields();
                SlotSymbolRespin_Execute_Patch.AnnounceRespins();

                // Suppress UIFeedbackManager announcements for 1 second to avoid duplicate symbol lists
                AccessibilityMod.suppressUIFeedbackUntil = Time.time + 1f;
            }

            // Update previous state
            AccessibilityMod.previousGameState = newState;
            
            string announcement = GetGameStateAnnouncement(newState);
            if (!string.IsNullOrEmpty(announcement))
            {
                // Don't interrupt during combat flow - let messages finish
                bool shouldInterrupt = newState == GameState.LevelSelect || 
                                      newState == GameState.EquipmentSelect ||
                                      newState == GameState.NewLevel ||
                                      newState == GameState.NewEncounter ||
                                      newState == GameState.GameOver ||
                                      newState == GameState.GameWon ||
                                      newState == GameState.NoGameSession;
                AccessibilityMod.Speak(announcement, shouldInterrupt);
            }
        }

        private static string GetGameStateAnnouncement(GameState state)
        {
            // Most state announcements are handled by UIFeedbackManager which uses localized text
            // Only announce states that don't have UI feedback
            switch (state)
            {
                case GameState.SplashScreen:
                    // Read the game title from the UI if available, otherwise minimal announcement
                    return "Loading...";
                // Don't announce these - UIFeedbackManager handles them with localized text
                case GameState.LevelSelect:
                case GameState.EquipmentSelect:
                case GameState.NewLevel:
                case GameState.NewEncounter:
                case GameState.Spinning:
                case GameState.ExecutingSlots:
                case GameState.PlayerAttack:
                case GameState.EncounterAttack:
                case GameState.UsePowerUps:
                case GameState.EncounterDefeat:
                case GameState.UpgradeShop:
                case GameState.GameOver:
                case GameState.GameWon:
                case GameState.NoGameSession:
                    return null;
                default:
                    return null;
            }
        }
    }

    // Patch StartStopButton - disabled, no need to announce activation
    // Users already hear the button text from CheckUIFocusChanges
    /*
    [HarmonyPatch(typeof(StartStopButton), "SelectButton")]
    public class StartStopButton_SelectButton_Patch
    {
        static void Postfix(StartStopButton __instance)
        {
            AccessibilityMod.Speak("Spin button activated", false);
        }
    }
    */

    // Patch SlotSymbolAttack execution to announce attack results
    [HarmonyPatch(typeof(SlotSymbolAttack), "ExecuteCoroutine", new Type[] { typeof(int), typeof(Vector3), typeof(SpinnerWheel), typeof(int) })]
    public class SlotSymbolAttack_Execute_Patch
    {
        private static float totalPhysDamage = 0;
        private static float totalMagDamage = 0;
        private static int attackCount = 0;
        private static bool hasCritical = false;

        static void Postfix(SlotSymbolAttack __instance, int symbolCount)
        {
            // Calculate actual damage including all modifiers
            float physDamage = __instance.CurrentStrengthPhysical;
            float magDamage = __instance.CurrentStrengthMagical;

            // Add shield and coin bonuses
            physDamage += __instance.CurrentPhysicalDamagePerShield * Main.HealthManager.CurrentShield;
            magDamage += __instance.CurrentMagicalDamagePerShield * Main.HealthManager.CurrentShield;
            physDamage += __instance.CurrentPhysicalDamagePerCoin * (float)Main.PlayerInventory.TotalCoins;
            magDamage += __instance.CurrentMagicalDamagePerCoin * (float)Main.PlayerInventory.TotalCoins;

            // Apply critical multipliers
            if (symbolCount == 3)
            {
                physDamage *= 3f;
                magDamage *= 3f;
                hasCritical = true;
            }
            else if (symbolCount == 5)
            {
                physDamage *= 15f;
                magDamage *= 15f;
                hasCritical = true;
            }

            // Accumulate damage
            totalPhysDamage += physDamage;
            totalMagDamage += magDamage;
            attackCount++;
        }

        // This will be called at end of spin
        public static void AnnounceTotalDamage()
        {
            if (attackCount > 0)
            {
                string announcement = string.Format("{0} Attack{1}. ", attackCount, attackCount > 1 ? "s" : "");

                if (totalPhysDamage > 0)
                {
                    announcement += string.Format("Physical: {0:F0}. ", totalPhysDamage);
                }

                if (totalMagDamage > 0)
                {
                    announcement += string.Format("Magical: {0:F0}. ", totalMagDamage);
                }

                if (hasCritical)
                {
                    announcement += "Critical! ";
                }

                // Announce enemy health after attacks
                if (Main.EncounterManager != null && Main.EncounterManager.CurrentEncounter != null)
                {
                    announcement += string.Format("Enemy health: {0:F0}", Main.EncounterManager.CurrentEncounter.CurrentHealth);
                }

                AccessibilityMod.Speak(announcement, false);

                // Reset counters
                totalPhysDamage = 0;
                totalMagDamage = 0;
                attackCount = 0;
                hasCritical = false;
            }
        }
    }

    // Patch SlotSymbolCoin execution to announce coin gains
    [HarmonyPatch(typeof(SlotSymbolCoin), "ExecuteCoroutine", new Type[] { typeof(int), typeof(Vector3), typeof(SpinnerWheel), typeof(int) })]
    public class SlotSymbolCoin_Execute_Patch
    {
        private static int totalCoins = 0;
        private static int coinCount = 0;
        private static bool hasCritical = false;

        static void Postfix(SlotSymbolCoin __instance, int symbolCount)
        {
            int coinValue = Mathf.CeilToInt(__instance.AnalysisOnlyBaseCoinValue);

            if (symbolCount == 3)
            {
                coinValue *= __instance.AnalysisOnlyMultiplierCritical;
                hasCritical = true;
            }
            else if (symbolCount == 5)
            {
                coinValue *= __instance.AnalysisOnlyMultiplierCritical * 5;
                hasCritical = true;
            }

            totalCoins += coinValue;
            coinCount++;
        }

        public static void AnnounceTotalCoins()
        {
            if (coinCount > 0)
            {
                string announcement = string.Format("{0} Coin symbol{1}. Gained: {2}. ",
                    coinCount, coinCount > 1 ? "s" : "", totalCoins);

                if (hasCritical)
                {
                    announcement += "Critical! ";
                }

                announcement += string.Format("Total: {0}", Main.PlayerInventory.TotalCoins);

                AccessibilityMod.Speak(announcement, false);

                totalCoins = 0;
                coinCount = 0;
                hasCritical = false;
            }
        }
    }

    // Patch SlotSymbolHeal execution to announce healing
    [HarmonyPatch(typeof(SlotSymbolHeal), "ExecuteCoroutine", new Type[] { typeof(int), typeof(Vector3), typeof(SpinnerWheel), typeof(int) })]
    public class SlotSymbolHeal_Execute_Patch
    {
        private static float totalHeal = 0;
        private static int healCount = 0;
        private static bool hasCritical = false;

        static void Postfix(SlotSymbolHeal __instance, int symbolCount)
        {
            float healValue = __instance.AnalysisOnlyBaseHeal;

            if (symbolCount == 3)
            {
                healValue *= __instance.AnalysisOnlyMultiplierCritical;
                hasCritical = true;
            }
            else if (symbolCount == 5)
            {
                healValue *= __instance.AnalysisOnlyMultiplierCritical * 5;
                hasCritical = true;
            }

            healValue *= Main.MultiplierManager.CurrentMultiplierHeal;

            totalHeal += healValue;
            healCount++;
        }

        public static void AnnounceTotalHealing()
        {
            if (healCount > 0)
            {
                string announcement = string.Format("{0} Heal symbol{1}. Healed: {2:F0}. ",
                    healCount, healCount > 1 ? "s" : "", totalHeal);

                if (hasCritical)
                {
                    announcement += "Critical! ";
                }

                if (Main.HealthManager != null)
                {
                    announcement += string.Format("Health: {0:F0} out of {1:F0}",
                        Main.HealthManager.CurrentHealth,
                        Main.HealthManager.MaxHealth);
                }

                AccessibilityMod.Speak(announcement, false);

                totalHeal = 0;
                healCount = 0;
                hasCritical = false;
            }
        }
    }

    // Patch SlotSymbolShield execution to announce shield gains
    [HarmonyPatch(typeof(SlotSymbolShield), "ExecuteCoroutine", new Type[] { typeof(int), typeof(Vector3), typeof(SpinnerWheel), typeof(int) })]
    public class SlotSymbolShield_Execute_Patch
    {
        private static int shieldCount = 0;
        private static bool hasCritical = false;

        static void Postfix(SlotSymbolShield __instance, int symbolCount)
        {
            if (symbolCount == 3 || symbolCount == 5)
            {
                hasCritical = true;
            }
            shieldCount++;
        }

        public static void AnnounceTotalShields()
        {
            if (shieldCount > 0)
            {
                string announcement = string.Format("{0} Shield symbol{1}. ",
                    shieldCount, shieldCount > 1 ? "s" : "");

                if (hasCritical)
                {
                    announcement += "Critical! ";
                }

                if (Main.HealthManager != null)
                {
                    announcement += string.Format("Total shields: {0:F0}", Main.HealthManager.CurrentShield);
                }

                AccessibilityMod.Speak(announcement, false);

                shieldCount = 0;
                hasCritical = false;
            }
        }
    }

    // Patch SlotSymbolRespin execution to announce respins
    [HarmonyPatch(typeof(SlotSymbolRespin), "ExecuteCoroutine", new Type[] { typeof(int), typeof(Vector3), typeof(SpinnerWheel), typeof(int) })]
    public class SlotSymbolRespin_Execute_Patch
    {
        private static int respinCount = 0;

        static void Postfix(SlotSymbolRespin __instance)
        {
            respinCount++;
        }

        public static void AnnounceRespins()
        {
            if (respinCount > 0)
            {
                string announcement = string.Format("{0} Respin symbol{1}. Spinning again.",
                    respinCount, respinCount > 1 ? "s" : "");

                AccessibilityMod.Speak(announcement, false);

                respinCount = 0;
            }
        }
    }

    // Patch UpgradeShopOption.Select to announce cost
    [HarmonyPatch(typeof(UpgradeShopOption), "Select")]
    public class UpgradeShopOption_Select_Patch
    {
        static void Postfix(UpgradeShopOption __instance)
        {
            // Get the cost using reflection
            var costField = typeof(UpgradeShopOption).GetField("upgradeCost", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
            if (costField != null)
            {
                int cost = (int)costField.GetValue(__instance);
                
                // Announce cost after a short delay to let the name/description be read first
                string announcement = string.Format("Cost: {0} coins", cost);
                AccessibilityMod.Speak(announcement, false);
            }
        }
    }

    // Patch HealthManager.AddHealth to announce health changes
    [HarmonyPatch(typeof(HealthManager), "AddHealth")]
    public class HealthManager_AddHealth_Patch
    {
        static void Postfix(HealthManager __instance, float amount)
        {
            if (amount > 0)
            {
                // Don't announce during slot execution to avoid interruptions
                if (AccessibilityMod.previousGameState != GameState.ExecutingSlots)
                {
                    AccessibilityMod.Speak("Gained " + amount.ToString("F0") + " health. Current health: " + __instance.CurrentHealth.ToString("F0") + " out of " + __instance.MaxHealth.ToString("F0"), false);
                }
            }
        }
    }

    // AddCoins and TakeDamage patches removed - method signatures don't match

    // Patch HealthManager.AddShields to announce shield gains
    [HarmonyPatch(typeof(HealthManager), "AddShields")]
    public class HealthManager_AddShields_Patch
    {
        static void Postfix(HealthManager __instance, float amount)
        {
            // Don't announce during slot execution to avoid interruptions
            if (AccessibilityMod.previousGameState != GameState.ExecutingSlots)
            {
                AccessibilityMod.Speak($"Gained {amount:F0} shield. Current shield: {__instance.CurrentShield:F0}", false);
            }
        }
    }

    // Patch HealthManager.AttackPlayer to announce damage taken
    [HarmonyPatch(typeof(HealthManager), "AttackPlayer", new Type[] { typeof(float), typeof(float) })]
    public class HealthManager_AttackPlayer_Patch
    {
        static void Prefix(HealthManager __instance, float physicalStrength, float magicalStrength, out float __state)
        {
            // Store health before attack
            __state = __instance.CurrentHealth;
        }

        static void Postfix(HealthManager __instance, float physicalStrength, float magicalStrength, float __state)
        {
            float healthLost = __state - __instance.CurrentHealth;
            if (healthLost > 0)
            {
                // Don't announce during slot execution to avoid interruptions
                if (AccessibilityMod.previousGameState != GameState.ExecutingSlots)
                {
                    // Just announce the damage number
                    string announcement = string.Format("{0:F0}", healthLost);
                    
                    if (__instance.CurrentShield > 0)
                    {
                        announcement += string.Format(". Shield: {0:F0}", __instance.CurrentShield);
                    }
                    
                    announcement += string.Format(". Health: {0:F0}", __instance.CurrentHealth);
                    
                    AccessibilityMod.Speak(announcement, false);
                }
            }
        }
    }

    // NOTE: PlayerInventory.AddCoins, Encounter.Setup, and Encounter.Hit patches removed
    // due to method signature mismatches in the net35 game assembly

    // Patch UIFeedbackManager.PrintMessageToDisplay to speak UI messages
    [HarmonyPatch(typeof(UIFeedbackManager), "PrintMessageToDisplay")]
    public class UIFeedbackManager_PrintMessage_Patch
    {
        static void Postfix(string message)
        {
            if (!string.IsNullOrEmpty(message))
            {
                // Log all messages for debugging
                MelonLogger.Msg($"[UIFeedback-Display] State: {AccessibilityMod.previousGameState} | Suppress until: {AccessibilityMod.suppressUIFeedbackUntil} | Time: {Time.time} | Message: {message}");

                // Filter out specific messages we don't want to hear (case-insensitive)
                string messageLower = message.ToLower();
                if (messageLower.Contains("executing!") || messageLower.Contains("stop") || messageLower.Contains("enemy attacking"))
                {
                    MelonLogger.Msg("[UIFeedback-Display] Filtered out");
                    return;
                }

                // Suppress messages right after announcing results (to skip duplicate symbol lists)
                if (Time.time < AccessibilityMod.suppressUIFeedbackUntil)
                {
                    MelonLogger.Msg("[UIFeedback-Display] Suppressed by time window");
                    return;
                }

                // During power-up selection, don't announce power-up descriptions or costs
                // (PowerUpButton patch handles the full announcement when navigating)
                if (AccessibilityMod.previousGameState == GameState.UsePowerUps)
                {
                    MelonLogger.Msg("[UIFeedback-Display] Suppressed (PowerUps state)");
                    return;
                }

                // Don't announce UI feedback during slot execution to avoid interruptions
                if (AccessibilityMod.previousGameState != GameState.ExecutingSlots)
                {
                    MelonLogger.Msg("[UIFeedback-Display] Speaking message");
                    AccessibilityMod.Speak(message, false);
                }
                else
                {
                    MelonLogger.Msg("[UIFeedback-Display] Suppressed (ExecutingSlots state)");
                }
            }
        }
    }

    // Patch UIFeedbackManager.PrintMessageToTitleDisplay for title announcements
    [HarmonyPatch(typeof(UIFeedbackManager), "PrintMessageToTitleDisplay")]
    public class UIFeedbackManager_PrintTitle_Patch
    {
        static void Postfix(string message)
        {
            if (!string.IsNullOrEmpty(message))
            {
                // Log all title messages for debugging
                MelonLogger.Msg($"[UIFeedback-Title] State: {AccessibilityMod.previousGameState} | Suppress until: {AccessibilityMod.suppressUIFeedbackUntil} | Time: {Time.time} | Message: {message}");

                // Suppress messages right after announcing results (to skip duplicate symbol lists)
                if (Time.time < AccessibilityMod.suppressUIFeedbackUntil)
                {
                    MelonLogger.Msg("[UIFeedback-Title] Suppressed by time window");
                    return;
                }

                // Don't announce title messages during slot execution to avoid interruptions
                if (AccessibilityMod.previousGameState != GameState.ExecutingSlots &&
                    AccessibilityMod.previousGameState != GameState.UsePowerUps &&
                    AccessibilityMod.previousGameState != GameState.PlayerAttack &&
                    AccessibilityMod.previousGameState != GameState.EncounterAttack)
                {
                    MelonLogger.Msg("[UIFeedback-Title] Speaking message");
                    AccessibilityMod.Speak(message, true);
                }
                else
                {
                    MelonLogger.Msg("[UIFeedback-Title] Suppressed by game state");
                }
            }
        }
    }

    // Patch PowerUpsManager to announce power-up selection
    [HarmonyPatch(typeof(PowerUpsManager), "ShowPowerUpsBar")]
    public class PowerUpsManager_ShowPowerUps_Patch
    {
        static void Postfix()
        {
            AccessibilityMod.Speak("Select a power-up", false);
        }
    }

    // Patch PowerUpButton to announce full power-up details when selected
    [HarmonyPatch(typeof(PowerUpButton), "SelectButton")]
    public class PowerUpButton_SelectButton_Patch
    {
        static bool Prefix(PowerUpButton __instance)
        {
            if (__instance != null && __instance.PowerUp != null)
            {
                PowerUp powerUp = __instance.PowerUp;
                
                // Get the full description which includes internal description and cost
                string fullDescription = powerUp.GetDescription();
                
                // Build announcement with name first
                string announcement = powerUp.displayName + ". " + fullDescription;
                
                AccessibilityMod.SpeakImmediate(announcement);
            }
            
            // Let the original method run
            return true;
        }
    }

    // Patch SpinnerWheel.Stop to announce spin results
    [HarmonyPatch(typeof(SpinnerWheel), "Stop")]
    public class SpinnerWheel_Stop_Patch
    {
        private static float lastSpinTime = 0f;
        private const float RAPID_SPIN_THRESHOLD = 0.1f; // 100ms - auto-spins happen within milliseconds

        private static string GetLocalizedSymbolName(SlotSymbol symbol)
        {
            if (symbol == null) return "";

            // DisplayName should contain the localized name if the game is properly configured
            // The game's SlotSymbol objects use Unity's localization system
            return symbol.DisplayName;
        }

        static void Postfix(SpinnerWheel __instance, SlotSymbol __result)
        {
            if (__result != null)
            {
                float currentTime = Time.time;
                float timeSinceLastSpin = currentTime - lastSpinTime;

                // Only announce if this is NOT a rapid auto-spin
                // Manual spins are 1+ seconds apart, auto-spins are milliseconds apart
                // If it's been more than 100ms since last spin, it's likely manual
                if (lastSpinTime == 0f || timeSinceLastSpin > RAPID_SPIN_THRESHOLD)
                {
                    string symbolName = GetLocalizedSymbolName(__result);
                    AccessibilityMod.Speak(symbolName, false);
                    lastSpinTime = currentTime;
                }
                else
                {
                    // Rapid spin detected (auto-spin), suppress but update time
                    lastSpinTime = currentTime;
                }
            }
        }
    }

    // Patch StoryBeatManager to announce story text
    [HarmonyPatch(typeof(StoryBeatManager), "TypeText")]
    public class StoryBeatManager_TypeText_Patch
    {
        static void Prefix(string fullText)
        {
            if (!string.IsNullOrEmpty(fullText))
            {
                AccessibilityMod.Speak(fullText, true);
            }
        }
    }

    // Patch UIManager.ShowSafetyDialogue to announce the dialogue message
    [HarmonyPatch(typeof(UIManager), "ShowSafetyDialogue")]
    public class UIManager_ShowSafetyDialogue_Patch
    {
        static void Postfix(UIManager __instance)
        {
            // Get the actual message text from the UI
            var messageField = typeof(UIManager).GetField("safetyDialogueMessage", 
                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
            if (messageField != null)
            {
                var messageComponent = messageField.GetValue(__instance) as TMPro.TextMeshProUGUI;
                if (messageComponent != null)
                {
                    string message = messageComponent.text;
                    // Suppress the next button announcement and speak the dialog message
                    AccessibilityMod.suppressNextButtonAnnouncement = true;
                    
                    if (!string.IsNullOrEmpty(message))
                    {
                        AccessibilityMod.SpeakImmediate(message);
                    }
                    else
                    {
                        // Empty message means quit dialog - check if there's a localized string
                        AccessibilityMod.SpeakImmediate("Quit the game?");
                    }
                }
            }
        }
    }

    // Patch LevelSelectionManager to announce level selection
    [HarmonyPatch(typeof(LevelSelectionManager), "ShowLevelSelectionScreen")]
    public class LevelSelectionManager_Show_Patch
    {
        static void Postfix()
        {
            AccessibilityMod.Speak("Select a level", false);
        }
    }

    // Patch EquipmentSelectionManager to announce equipment selection
    [HarmonyPatch(typeof(EquipmentSelectionManager), "ShowEquipmentSelectionScreen")]
    public class EquipmentSelectionManager_Show_Patch
    {
        static void Postfix()
        {
            AccessibilityMod.Speak("Select your starting equipment", false);
        }
    }

    // Patch GameOverScreenUGUI to announce game over details
    [HarmonyPatch(typeof(GameOverScreenUGUI), "ShowContinueButton")]
    public class GameOverScreenUGUI_ShowContinueButton_Patch
    {
        static void Prefix()
        {
            // When continue button appears, announce the final stats
            if (Main.ScoreManager != null)
            {
                int finalScore = Main.ScoreManager.CurrentScore;
                int highscore = Main.ScoreManager.CurrentHighscore;
                int chipsEarned = Main.ScoreManager.ChipsEarnedThisRun;
                int totalChips = Main.PlayerInventory != null ? Main.PlayerInventory.Chips : 0;

                string announcement = string.Format(
                    "Game Over. Final score: {0}. High score: {1}. Chips earned this run: {2}. Total chips: {3}. Press Enter to continue.",
                    finalScore, highscore, chipsEarned, totalChips);

                AccessibilityMod.Speak(announcement, true);
            }
        }
    }

    // Patch Slider to announce value changes
    [HarmonyPatch(typeof(Slider), "Set", new Type[] { typeof(float), typeof(bool) })]
    public class Slider_Set_Patch
    {
        private static Dictionary<Slider, float> lastAnnouncedValues = new Dictionary<Slider, float>();
        private const float ANNOUNCE_THRESHOLD = 0.05f; // Only announce if value changes by 5% or more
        
        static void Postfix(Slider __instance, float input)
        {
            if (__instance == null || !__instance.gameObject.activeInHierarchy) return;
            
            // Check if this slider is selected by the EventSystem
            if (EventSystem.current != null && EventSystem.current.currentSelectedGameObject == __instance.gameObject)
            {
                // Only announce if value changed significantly
                if (!lastAnnouncedValues.ContainsKey(__instance) || 
                    Mathf.Abs(lastAnnouncedValues[__instance] - __instance.value) >= ANNOUNCE_THRESHOLD * (__instance.maxValue - __instance.minValue))
                {
                    float percentage = ((__instance.value - __instance.minValue) / (__instance.maxValue - __instance.minValue)) * 100f;
                    AccessibilityMod.SpeakImmediate($"{Mathf.RoundToInt(percentage)}%");
                    lastAnnouncedValues[__instance] = __instance.value;
                }
            }
        }
    }

    // Patch Toggle to announce state changes
    [HarmonyPatch(typeof(Toggle), "Set", new Type[] { typeof(bool), typeof(bool) })]
    public class Toggle_Set_Patch
    {
        static void Postfix(Toggle __instance, bool value)
        {
            if (__instance == null || !__instance.gameObject.activeInHierarchy) return;
            
            // Check if this toggle is selected by the EventSystem
            if (EventSystem.current != null && EventSystem.current.currentSelectedGameObject == __instance.gameObject)
            {
                string state = value ? "On" : "Off";
                AccessibilityMod.SpeakImmediate(state);
            }
        }
    }

    // Patch TMP_Dropdown to announce selection changes
    // DISABLED: Method signature issue causing Harmony to fail
    /*
    [HarmonyPatch(typeof(TMPro.TMP_Dropdown), "Set", new Type[] { typeof(int), typeof(bool) })]
    public class TMP_Dropdown_Set_Patch
    {
        static void Postfix(TMPro.TMP_Dropdown __instance, int value)
        {
            if (__instance == null || !__instance.gameObject.activeInHierarchy) return;
            
            // Check if this dropdown is selected by the EventSystem
            if (EventSystem.current != null && EventSystem.current.currentSelectedGameObject == __instance.gameObject)
            {
                if (value >= 0 && value < __instance.options.Count)
                {
                    string selectedOption = __instance.options[value].text;
                    AccessibilityMod.SpeakImmediate(selectedOption);
                }
            }
        }
    }
    */

    // Patch Button OnClick to provide audio feedback
    [HarmonyPatch(typeof(Button), "Press")]
    public class Button_Press_Patch
    {
        static void Prefix(Button __instance)
        {
            // Disabled - no need to announce button activation
            // Users already hear the button text from CheckUIFocusChanges
            /*
            if (__instance != null && __instance.IsInteractable())
            {
                // Get button text for announcement
                var tmp = __instance.GetComponentInChildren<TMPro.TextMeshProUGUI>();
                if (tmp != null && !string.IsNullOrEmpty(tmp.text))
                {
                    AccessibilityMod.Speak($"{tmp.text}, activated", false);
                }
            }
            */
        }
    }
}