"using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;

public class dissolvenzaImmagini : MonoBehaviour
{
    // Singleton instance
    public static dissolvenzaImmagini instance;

    [Header("Image Fade Settings")]
    public GameObject[] imageGroups;       // Array di gruppi di immagini
    public float fadeDuration = 3f;        // Durata della dissolvenza in secondi
    public float displayDuration = 2f;     // Durata della visualizzazione dell'immagine

    [Header("Special Images")]
    public GameObject enemyReachedPointImage;
    public GameObject enemyDefeatedImage;

    [Header("Enemy Spawn Settings")]
    public GameObject[] enemyPrefabs;      // Array di prefab dei nemici
    public Transform[] enemySpawnTransforms; // Punti di spawn dei nemici
    public List<int> enemyTriggerIndices;  // Indici dei gruppi di immagini che triggerano la generazione degli enemy
    public Transform playerTransform;       // Riferimento al Transform del player

    private int currentGroupIndex = 0;
    private List<GameObject> currentEnemies = new List<GameObject>();

    [Header("Player and Enemy Settings")]
    public controller playerMovement;      // Riferimento allo script di movimento del player
    public Player_combat_Mattina combat;   // Riferimento allo script di combattimento del player
    public enemySpawner[] enemySpawners;   // Array di spawner degli enemy (se utilizzati)

    void Awake()
    {
        // Imposta l'istanza singleton
        if (instance == null)
        {
            instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void Start()
    {
        // Imposta tutte le immagini con alpha 0 all'inizio
        foreach (GameObject group in imageGroups)
        {
            SetGroupAlpha(group, 0f);
        }

        // Disabilita il movimento e il combattimento del player all'inizio
        DisablePlayerAndEnemies();

        // Inizia la sequenza delle dissolvenze delle immagini
        StartCoroutine(ShowImageGroupsInSequence());
    }

    // Metodo per disabilitare movimento e combattimento del player e degli spawners
    void DisablePlayerAndEnemies()
    {
        if (playerMovement != null) playerMovement.enabled = false;
        if (combat != null) combat.enabled = false;

        foreach (enemySpawner spawner in enemySpawners)
        {
            if (spawner != null) spawner.enabled = false;
        }
    }

    // Metodo per abilitare movimento del player e gli spawners (combat non abilitato, gestito dagli enemy)
    void EnablePlayerAndEnemies()
    {
        if (playerMovement != null) playerMovement.enabled = true;

        foreach (enemySpawner spawner in enemySpawners)
        {
            if (spawner != null) spawner.enabled = true;
        }
    }

    // Coroutine che gestisce la sequenza di dissolvenza delle immagini
    IEnumerator ShowImageGroupsInSequence()
    {
        while (currentGroupIndex < imageGroups.Length)
        {
            GameObject group = imageGroups[currentGroupIndex];

            yield return StartCoroutine(FadeInGroup(group));
            yield return new WaitForSeconds(displayDuration);
            yield return StartCoroutine(FadeOutGroup(group));

            // Controlla se l'indice corrente è tra quelli che devono generare un enemy
            if (enemyTriggerIndices.Contains(currentGroupIndex))
            {
                yield return SpawnAndHandleEnemies();
            }

            currentGroupIndex++;
        }

        // Alla fine della sequenza, abilita movimento e gli spawners (combat gestito dagli enemy)
        EnablePlayerAndEnemies();
    }

    // Coroutine che genera un enemy e attende fino a che viene distrutto
    IEnumerator SpawnAndHandleEnemies()
    {
        int enemyIdx = enemyTriggerIndices.IndexOf(currentGroupIndex);

        if (enemyIdx < enemyPrefabs.Length && enemyIdx < enemySpawnTransforms.Length)
        {
            // Istanzia l'enemy nel punto di spawn designato
            GameObject enemy = Instantiate(
                enemyPrefabs[enemyIdx],
                enemySpawnTransforms[enemyIdx].position,
                Quaternion.identity
            );
            currentEnemies.Add(enemy);

            // Aggiungi e configura il componente EnemyMovement
            EnemyMovement movement = enemy.AddComponent<EnemyMovement>();
            movement.target = playerTransform;
            movement.stopDistance = 2.0f; // Imposta la distanza di stop desiderata
            movement.playerCombat = combat; // Assegna il riferimento allo script di combattimento del player
            movement.imageFadeController = this; // Assegna il riferimento allo script di dissolvenza

            // Assicurati che l'enemy abbia un componente Health
            Health health = enemy.GetComponent<Health>();
            if (health == null)
            {
                health = enemy.AddComponent<Health>();
                health.maxHealth = 100; // Configura questo valore secondo necessità
                health.imageFadeController = this; // Assegna il riferimento allo script di dissolvenza
            }

            // Abilita eventuali altri componenti necessari, come il combattimento dell'enemy
            Player_combat_Mattina enemyCombatComponent = enemy.GetComponent<Player_combat_Mattina>();
            if (enemyCombatComponent != null)
            {
                enemyCombatComponent.enabled = true;
            }
        }

        // Attendi fino a quando tutti gli enemy nella lista sono stati distrutti
        while (currentEnemies.Exists(e => e != null))
        {
            yield return null;
        }
    }

    // Metodo pubblico per mostrare un'immagine con dissolvenza, accessibile dagli altri script
    public IEnumerator ShowImageWithFade(GameObject imageGroup)
    {
        yield return StartCoroutine(FadeInGroup(imageGroup));
        yield return new WaitForSeconds(displayDuration);
        yield return StartCoroutine(FadeOutGroup(imageGroup));
    }

    // Coroutine per dissolvere in
    public IEnumerator FadeInGroup(GameObject group)
    {
        float elapsedTime = 0f;

        while (elapsedTime < fadeDuration)
        {
            elapsedTime += Time.deltaTime;
            SetGroupAlpha(group, Mathf.Clamp01(elapsedTime / fadeDuration));
            yield return null;
        }

        SetGroupAlpha(group, 1f);
    }

    // Coroutine per dissolvere out
    public IEnumerator FadeOutGroup(GameObject group)
    {
        float elapsedTime = 0f;

        while (elapsedTime < fadeDuration)
        {
            elapsedTime += Time.deltaTime;
            SetGroupAlpha(group, Mathf.Clamp01(1f - (elapsedTime / fadeDuration)));
            yield return null;
        }

        SetGroupAlpha(group, 0f);
    }

    // Metodo per impostare l'alpha di tutte le immagini in un gruppo
    void SetGroupAlpha(GameObject group, float alpha)
    {
        Image[] images = group.GetComponentsInChildren<Image>();
        foreach (Image img in images)
        {
            Color color = img.color;
            color.a = alpha;
            img.color = color;
        }
    }
}","using UnityEngine;

public class Health : MonoBehaviour
{
    public int maxHealth = 40;
    private int currentHealth;

    void Start()
    {
        currentHealth = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        currentHealth -= amount;
        if (currentHealth <= 0)
        {
            Die();
        }
    }

    void Die()
    {
        // Potresti aggiungere qui effetti visivi o suoni
        Destroy(gameObject);
    }
}"



Assets/codes/dissolvenzaImmagini.cs(137,24): error CS1061: 'Health' does not contain a definition for 'imageFadeController' and no accessible extension method 'imageFadeController' accepting a first argument of type 'Health' could be found (are you missing a using directive or an assembly reference?)