Вложенные корутины в Unity

IEnumerator MainCoroutine()
{
    Debug.Log("Начинаем основную корутину");
    
    // Пытаемся дождаться завершения дочерней корутины
    yield return StartCoroutine(ChildCoroutine());
    
    Debug.Log("Дочерняя корутина завершена");
}
 
IEnumerator ChildCoroutine()
{
    Debug.Log("Дочерняя корутина запущена");
    yield return new WaitForSeconds(2f);
    Debug.Log("Дочерняя корутина завершается");
}

IEnumerator ProblematicCoroutine()
{
    GameObject temporaryObject = new GameObject();
    MonoBehaviour component = temporaryObject.AddComponent<CoroutineRunner>();
    
    // Запускаем корутину на временном объекте
    yield return StartCoroutine(component.LongRunningTask());
    
    // Объект может быть уничтожен до завершения задачи
    Destroy(temporaryObject);
    
    // Этот код может никогда не выполниться
    Debug.Log("Задача завершена");
}

public class UIController : MonoBehaviour
{
    private bool isAnimating = false;
    
    public void OnButtonClick()
    {
        if (isAnimating) return; // Простая защита от двойного нажатия
        
        StartCoroutine(AnimateButton());
    }
    
    IEnumerator AnimateButton()
    {
        isAnimating = true;
        
        // Анимация может прерваться, и флаг останется true навсегда
        yield return StartCoroutine(ScaleAnimation());
        yield return StartCoroutine(ColorAnimation());
        
        isAnimating = false;
    }
}

IEnumerator DeepNestedCoroutine(int depth)
{
    if (depth <= 0)
    {
        yield return new WaitForSeconds(0.1f);
        yield break;
    }
    
    // Каждый уровень создает новый итератор
    yield return StartCoroutine(DeepNestedCoroutine(depth - 1));
    yield return StartCoroutine(DeepNestedCoroutine(depth - 1));
    
    // При depth=10 создается 2^10 = 1024 итератора
}

IEnumerator BadCoroutine()
{
    while (true)
    {
        // Создает новый объект каждую итерацию
        yield return new WaitForSeconds(Random.Range(0.1f, 0.5f));
        
        // Еще один объект для каждого кадра
        yield return new WaitForEndOfFrame();
    }
}

IEnumerator WaitForCondition()
{
    while (!someCondition)
    {
        // Выполняется 60 раз в секунду при 60 FPS
        yield return null;
    }
    
    // Гораздо эффективнее было бы:
    // yield return new WaitUntil(() => someCondition);
}

public class CoroutineNestingExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(ParentCoroutine());
    }
    
    IEnumerator ParentCoroutine()
    {
        Debug.Log("Родительская корутина начала работу");
        
        // Запуск дочерней корутины с ожиданием завершения
        yield return StartCoroutine(ChildCoroutine("Первая"));
        
        Debug.Log("Первая дочерняя завершена, запускаем вторую");
        
        // Последовательное выполнение
        yield return StartCoroutine(ChildCoroutine("Вторая"));
        
        Debug.Log("Родительская корутина завершена");
    }
    
    IEnumerator ChildCoroutine(string name)
    {
        Debug.Log($"Дочерняя корутина {name} запущена");
        
        for (int i = 0; i < 3; i++)
        {
            yield return new WaitForSeconds(0.5f);
            Debug.Log($"{name}: шаг {i + 1}");
        }
        
        Debug.Log($"Дочерняя корутина {name} завершена");
    }
}

IEnumerator AsyncCoroutineExample()
{
    Debug.Log("Запускаем фоновые задачи");
    
    // Запускаем анимацию фона (не ждем завершения)
    StartCoroutine(BackgroundAnimation());
    
    // Запускаем музыку (не ждем)
    StartCoroutine(PlayBackgroundMusic());
    
    // Продолжаем основную логику
    Debug.Log("Основная логика выполняется параллельно");
    
    yield return new WaitForSeconds(1f);
    Debug.Log("Основная задача завершена, фон может продолжать работу");
}

IEnumerator ConditionalCoroutineExample()
{
    Debug.Log("Запускаем управляемую корутину");
    
    Coroutine managedCoroutine = StartCoroutine(LongRunningTask());
    
    // Выполняем другую работу
    yield return new WaitForSeconds(2f);
    
    // Решаем прервать задачу по условию
    if (ShouldCancelTask())
    {
        StopCoroutine(managedCoroutine);
        Debug.Log("Задача прервана принудительно");
    }
    else
    {
        // Дожидаемся завершения
        yield return managedCoroutine;
        Debug.Log("Задача завершена естественно");
    }
}

public class CoroutineResult<T>
{
    public T Value { get; set; }
    public bool IsCompleted { get; set; }
}
 
IEnumerator DataExchangeExample()
{
    var result = new CoroutineResult<string>();
    
    yield return StartCoroutine(DataProducerCoroutine(result));
    
    if (result.IsCompleted)
    {
        Debug.Log($"Получен результат: {result.Value}");
    }
}
 
IEnumerator DataProducerCoroutine(CoroutineResult<string> result)
{
    yield return new WaitForSeconds(1f);
    
    result.Value = "Данные готовы";
    result.IsCompleted = true;
}

IEnumerator ProblematicDirectCall()
{
    Debug.Log("Начинаем работу");
    
    // НЕПРАВИЛЬНО: прямой вызов корутины
    AnimateObject(); // Весь код выполнится мгновенно, yield будет проигнорирован
    
    Debug.Log("Анимация 'завершена'");
    yield return new WaitForSeconds(1f);
}
 
IEnumerator AnimateObject()
{
    for (int i = 0; i < 10; i++)
    {
        transform.position += Vector3.up * 0.1f;
        yield return new WaitForSeconds(0.1f); // Этот yield никогда не выполнится
    }
}

IEnumerator StackContextExample()
{
    string localVariable = "Доступна в основной корутине";
    
    // Прямой вызов - переменная доступна
    DirectMethod();
    
    // Корутина - создается отдельный контекст
    yield return StartCoroutine(SeparateContext());
    
    // localVariable все еще доступна здесь
    Debug.Log(localVariable);
}
 
void DirectMethod()
{
    // Эта переменная НЕ видна из основной корутины
    string methodLocal = "Локальная переменная метода";
}
 
IEnumerator SeparateContext()
{
    // Эта корутина имеет свой собственный контекст
    // localVariable из StackContextExample здесь недоступна
    string contextLocal = "Локальная переменная корутины";
    yield return null;
}

// Тест производительности разных подходов
IEnumerator PerformanceComparison()
{
    System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
    
    // Прямые вызовы
    sw.Start();
    for (int i = 0; i < 1000; i++)
    {
        SimpleMath(); // ~0.1ms для 1000 вызовов
    }
    sw.Stop();
    Debug.Log($"Прямые вызовы: {sw.ElapsedMilliseconds}ms");
    
    // Корутины
    sw.Reset();
    sw.Start();
    for (int i = 0; i < 1000; i++)
    {
        StartCoroutine(SimpleMathCoroutine()); // ~15ms для 1000 вызовов
    }
    yield return new WaitForSeconds(0.1f); // даем время завершиться
    sw.Stop();
    Debug.Log($"Корутины: {sw.ElapsedMilliseconds}ms");
}

IEnumerator CalculateResult()
{
    yield return new WaitForSeconds(1f);
    // Как "вернуть" результат из корутины?
    // return 42; // Так нельзя!
}
 
void WrongUsage()
{
    // result будет содержать IEnumerator, а не число!
    var result = CalculateResult();
    Debug.Log($"Result: {result}"); // Выведет тип объекта, а не значение
}

IEnumerator DeadlockExample()
{
    Debug.Log("Запускаем корутину A");
    yield return StartCoroutine(CoroutineA());
}
 
IEnumerator CoroutineA()
{
    Debug.Log("Корутина A ждет корутину B");
    yield return StartCoroutine(CoroutineB());
    Debug.Log("A завершена"); // Никогда не выполнится
}
 
IEnumerator CoroutineB()
{
    Debug.Log("Корутина B ждет корутину A");
    yield return StartCoroutine(CoroutineA()); // Рекурсивный вызов!
    Debug.Log("B завершена"); // Никогда не выполнится
}

IEnumerator ResourceLeakExample()
{
    Texture2D loadedTexture = null;
    
    try
    {
        // Загружаем ресурс
        yield return StartCoroutine(LoadTextureCoroutine(result => loadedTexture = result));
        
        // Используем ресурс
        yield return StartCoroutine(ProcessTexture(loadedTexture));
        
        // Если корутина прервется здесь, ресурс не освободится
        yield return StartCoroutine(ApplyEffects(loadedTexture));
    }
    finally
    {
        // Unity не гарантирует выполнение finally в корутинах!
        if (loadedTexture != null)
        {
            DestroyImmediate(loadedTexture);
        }
    }
}

public class ChainedCoroutineComponent : MonoBehaviour
{
    IEnumerator FragileChain()
    {
        Debug.Log("Начинаем цепочку");
        yield return StartCoroutine(Phase1());
        
        // Объект может быть уничтожен между фазами
        if (this == null) yield break; // Проверка обязательна!
        
        yield return StartCoroutine(Phase2());
        
        // transform может быть null здесь
        transform.position = Vector3.zero; // Потенциальная ошибка!
    }
    
    IEnumerator Phase1()
    {
        yield return new WaitForSeconds(5f);
        // Долгая операция, за время которой объект может исчезнуть
    }
    
    IEnumerator Phase2()
    {
        // Эта корутина может запуститься на уничтоженном объекте
        yield return new WaitForSeconds(2f);
    }
}

public class IncorrectStopExample : MonoBehaviour
{
    private Coroutine mainChain;
    
    void Start()
    {
        mainChain = StartCoroutine(MainChain());
    }
    
    IEnumerator MainChain()
    {
        // Запускаем дочерние корутины
        StartCoroutine(BackgroundTask()); // Эта корутина НЕ остановится
        yield return StartCoroutine(PrimaryTask());
        StartCoroutine(CleanupTask()); // И эта тоже
    }
    
    void OnDestroy()
    {
        // НЕПРАВИЛЬНО: останавливаем только главную цепочку
        if (mainChain != null)
        {
            StopCoroutine(mainChain);
        }
        // Дочерние корутины продолжат работать на уничтоженном объекте!
    }
}

public class SharedStateError : MonoBehaviour
{
    private int sharedCounter = 0;
    
    IEnumerator ProblematicChain()
    {
        sharedCounter = 10;
        
        // Запускаем параллельную корутину, которая может изменить счетчик
        StartCoroutine(ModifyCounter());
        
        yield return new WaitForSeconds(1f);
        
        // sharedCounter может быть уже не 10!
        yield return StartCoroutine(UseCounter(sharedCounter));
    }
    
    IEnumerator ModifyCounter()
    {
        yield return new WaitForSeconds(0.5f);
        sharedCounter = 0; // Неожиданно меняем значение
    }
    
    IEnumerator UseCounter(int expectedValue)
    {
        // expectedValue может не соответствовать реальному sharedCounter
        if (sharedCounter != expectedValue)
        {
            Debug.LogError("Состояние нарушено!");
        }
        yield return null;
    }
}

IEnumerator HardToDebugChain()
{
    yield return StartCoroutine(Step1());
    yield return StartCoroutine(Step2()); // Ошибка здесь
    yield return StartCoroutine(Step3()); // Этого мы никогда не увидим
}
 
IEnumerator Step2()
{
    // Сложная логика с потенциальной ошибкой
    yield return new WaitForSeconds(Random.Range(1f, 10f));
    if (Random.Range(0, 10) > 7)
    {
        throw new System.Exception("Случайная ошибка"); // Сложно отследить
    }
}

IEnumerator LeakyCoroutine()
{
    // Захватываем ресурсы
    AudioSource audioSource = GetComponent<AudioSource>();
    Texture2D temporaryTexture = new Texture2D(1024, 1024);
    List<GameObject> spawnedObjects = new List<GameObject>();
    
    for (int i = 0; i < 100; i++)
    {
        GameObject obj = Instantiate(prefab);
        spawnedObjects.Add(obj);
        yield return new WaitForSeconds(0.1f);
    }
    
    // Если корутину остановят до этого места, ресурсы не очистятся
    DestroyImmediate(temporaryTexture);
    foreach (var obj in spawnedObjects)
    {
        Destroy(obj);
    }
}
 
public void ForceStop()
{
    StopCoroutine(LeakyCoroutine()); // Утечка памяти гарантирована!
}

IEnumerator ParentCoroutineWithChildren()
{
    Debug.Log("Запускаем дочерние задачи");
    
    // Эти корутины НЕ остановятся при остановке родительской
    StartCoroutine(ChildTask1());
    StartCoroutine(ChildTask2());
    StartCoroutine(ChildTask3());
    
    yield return new WaitForSeconds(10f);
    Debug.Log("Родительская задача завершена");
}
 
Coroutine parentCoroutine;
 
void Start()
{
    parentCoroutine = StartCoroutine(ParentCoroutineWithChildren());
}
 
void StopEverything()
{
    // НЕПРАВИЛЬНО: дочерние задачи продолжат работу
    StopCoroutine(parentCoroutine);
}

void ProblematicStop()
{
    // Запускаем несколько корутин с одинаковым именем
    StartCoroutine(SameNamedTask());
    StartCoroutine(SameNamedTask());
    StartCoroutine(SameNamedTask());
    
    // Какую именно корутину остановит этот вызов? Неизвестно!
    StopCoroutine("SameNamedTask");
}
 
IEnumerator SameNamedTask()
{
    while (true)
    {
        yield return new WaitForSeconds(1f);
        Debug.Log($"Задача выполняется на {gameObject.name}");
    }
}

IEnumerator EventSubscriptionLeak()
{
    // Подписываемся на события
    GameEvents.OnPlayerDamaged += HandlePlayerDamage;
    GameEvents.OnItemCollected += HandleItemCollection;
    
    // Длительная обработка
    while (someCondition)
    {
        yield return new WaitForSeconds(0.5f);
        ProcessEventData();
    }
    
    // Если корутину остановят, отписка не произойдет
    GameEvents.OnPlayerDamaged -= HandlePlayerDamage;
    GameEvents.OnItemCollected -= HandleItemCollection;
}

public class ManagedCoroutine : MonoBehaviour
{
    private List<IDisposable> managedResources = new List<IDisposable>();
    private List<GameObject> spawnedObjects = new List<GameObject>();
    private Coroutine activeCoroutine;
    
    IEnumerator SafeCoroutine()
    {
        try
        {
            // Безопасное управление ресурсами
            AudioSource audio = GetComponent<AudioSource>();
            
            for (int i = 0; i < 100; i++)
            {
                if (this == null) yield break; // Проверка на уничтожение
                
                GameObject obj = Instantiate(prefab);
                spawnedObjects.Add(obj);
                
                yield return new WaitForSeconds(0.1f);
            }
        }
        finally
        {
            // Эта секция может не выполниться при StopCoroutine!
            CleanupResources();
        }
    }
    
    public void SafeStop()
    {
        if (activeCoroutine != null)
        {
            StopCoroutine(activeCoroutine);
        }
        
        // Принудительная очистка
        CleanupResources();
    }
    
    void CleanupResources()
    {
        foreach (var resource in managedResources)
        {
            resource?.Dispose();
        }
        managedResources.Clear();
        
        foreach (var obj in spawnedObjects)
        {
            if (obj != null) Destroy(obj);
        }
        spawnedObjects.Clear();
    }
}

public class CoroutineDebugger : MonoBehaviour
{
    private static Dictionary<string, float> coroutineTimings = new Dictionary<string, float>();
    private static Dictionary<string, int> coroutineDepth = new Dictionary<string, int>();
    
    public static IEnumerator TrackedCoroutine(string name, IEnumerator coroutine, int depth = 0)
    {
        float startTime = Time.realtimeSinceStartup;
        coroutineDepth[name] = depth;
        
        Debug.Log($"[{depth}] Staring coroutine: {name}");
        
        yield return coroutine;
        
        float endTime = Time.realtimeSinceStartup;
        float duration = endTime - startTime;
        coroutineTimings[name] = duration;
        
        Debug.Log($"[{depth}] Finished coroutine: {name}, duration: {duration:F3}s");
    }
}

IEnumerator DebuggableNestedCoroutines()
{
    yield return TrackedCoroutine("MainFlow", MainWorkflow(), 0);
}
 
IEnumerator MainWorkflow()
{
    yield return TrackedCoroutine("Phase1", Phase1(), 1);
    yield return TrackedCoroutine("Phase2", Phase2(), 1);
    yield return TrackedCoroutine("Phase3", Phase3(), 1);
}
 
IEnumerator Phase2()
{
    yield return TrackedCoroutine("SubPhase2A", SubPhase2A(), 2);
    yield return TrackedCoroutine("SubPhase2B", SubPhase2B(), 2);
}

public class CoroutineMonitor : MonoBehaviour
{
    public static CoroutineMonitor Instance;
    
    private List<CoroutineInfo> activeCoroutines = new List<CoroutineInfo>();
    
    void Awake()
    {
        Instance = this;
    }
    
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.F1))
        {
            LogCoroutineStats();
        }
    }
    
    void LogCoroutineStats()
    {
        Debug.Log($"Active coroutines: {activeCoroutines.Count}");
        for (int i = 0; i < activeCoroutines.Count; i++)
        {
            var info = activeCoroutines[i];
            float runTime = Time.realtimeSinceStartup - info.startTime;
            Debug.Log($"  [{i}] {info.name} - running for {runTime:F2}s, depth: {info.depth}");
        }
    }
}
 
[System.Serializable]
public class CoroutineInfo
{
    public string name;
    public float startTime;
    public int depth;
    public bool isActive;
}

public class CoroutineCoordinator : MonoBehaviour
{
private Dictionary<string, Coroutine> managedCoroutines = new Dictionary<string, Coroutine>();
private Dictionary<string, bool> completionFlags = new Dictionary<string, bool>();
 
public IEnumerator ExecuteSequence(string sequenceName, params IEnumerator[] coroutines)
{
    completionFlags[sequenceName] = false;
    
    for (int i = 0; i < coroutines.Length; i++)
    {
        string stepName = $"{sequenceName}_Step{i}";
        managedCoroutines[stepName] = StartCoroutine(coroutines[i]);
        
        yield return managedCoroutines[stepName];
        
        if (this == null) yield break; // Защита от уничтожения
    }
    
    completionFlags[sequenceName] = true;
}
 
public IEnumerator ExecuteParallel(string groupName, params IEnumerator[] coroutines)
{
    var parallelCoroutines = new Coroutine[coroutines.Length];
    
    // Запускаем все корутины одновременно
    for (int i = 0; i < coroutines.Length; i++)
    {
        string taskName = $"{groupName}_Task{i}";
        parallelCoroutines[i] = StartCoroutine(coroutines[i]);
        managedCoroutines[taskName] = parallelCoroutines[i];
    }
    
    // Ждем завершения всех
    foreach (var coroutine in parallelCoroutines)
    {
        yield return coroutine;
    }
    
    completionFlags[groupName] = true;
}
 
public void ForceStopGroup(string groupName)
{
    var keysToRemove = new List<string>();
    
    foreach (var kvp in managedCoroutines)
    {
        if (kvp.Key.StartsWith(groupName))
        {
            if (kvp.Value != null) StopCoroutine(kvp.Value);
            keysToRemove.Add(kvp.Key);
        }
    }
    
    keysToRemove.ForEach(key => managedCoroutines.Remove(key));
    completionFlags[groupName] = false;
}
}

public class CoroutineStateManager : MonoBehaviour
{
private static Dictionary<string, bool> globalStates = new Dictionary<string, bool>();
private static Dictionary<string, object> sharedData = new Dictionary<string, object>();
 
public static void SetState(string stateName, bool value)
{
    globalStates[stateName] = value;
    Debug.Log($"State {stateName} set to {value}");
}
 
public static bool GetState(string stateName)
{
    return globalStates.ContainsKey(stateName) && globalStates[stateName];
}
 
public static void SetData<T>(string dataKey, T value)
{
    sharedData[dataKey] = value;
}
 
public static T GetData<T>(string dataKey)
{
    if (sharedData.ContainsKey(dataKey) && sharedData[dataKey] is T)
    {
        return (T)sharedData[dataKey];
    }
    return default(T);
}
 
public static IEnumerator WaitForState(string stateName, bool expectedValue = true)
{
    while (GetState(stateName) != expectedValue)
    {
        yield return new WaitForSeconds(0.1f); // Проверяем каждые 100ms
    }
}
 
public static IEnumerator WaitForMultipleStates(params string[] stateNames)
{
    bool allStatesReached = false;
    
    while (!allStatesReached)
    {
        allStatesReached = true;
        
        foreach (string stateName in stateNames)
        {
            if (!GetState(stateName))
            {
                allStatesReached = false;
                break;
            }
        }
        
        yield return new WaitForSeconds(0.1f);
    }
}
}

public class TimedCoroutineManager : MonoBehaviour
{
private class TimedExecution
{
    public float executeAt;
    public IEnumerator coroutine;
    public string name;
}
 
private List<TimedExecution> scheduledCoroutines = new List<TimedExecution>();
private float timelineStart;
 
public void ScheduleCoroutine(string name, IEnumerator coroutine, float delay)
{
    scheduledCoroutines.Add(new TimedExecution
    {
        executeAt = timelineStart + delay,
        coroutine = coroutine,
        name = name
    });
}
 
public IEnumerator ExecuteTimeline()
{
    timelineStart = Time.time;
    var executedCoroutines = new List<Coroutine>();
    
    scheduledCoroutines = scheduledCoroutines.OrderBy(x => x.executeAt).ToList();
    
    foreach (var scheduled in scheduledCoroutines)
    {
        // Дождаться нужного времени
        while (Time.time < scheduled.executeAt)
        {
            yield return null;
        }
        
        // Запустить корутину
        Debug.Log($"Executing scheduled coroutine: {scheduled.name}");
        var coroutineRef = StartCoroutine(scheduled.coroutine);
        executedCoroutines.Add(coroutineRef);
    }
    
    // Дождаться завершения всех запущенных корутин
    foreach (var coroutine in executedCoroutines)
    {
        yield return coroutine;
    }
    
    scheduledCoroutines.Clear();
}
}

public class PriorityCoroutineQueue : MonoBehaviour
{
private class QueuedCoroutine
{
    public IEnumerator coroutine;
    public int priority;
    public string name;
    public System.Action<bool> onComplete;
}
 
private List<QueuedCoroutine> queue = new List<QueuedCoroutine>();
private bool isProcessing = false;
 
public void EnqueueCoroutine(string name, IEnumerator coroutine, int priority = 0, System.Action<bool> onComplete = null)
{
    queue.Add(new QueuedCoroutine
    {
        coroutine = coroutine,
        priority = priority,
        name = name,
        onComplete = onComplete
    });
    
    // Сортируем по приоритету (больший приоритет = выше в очереди)
    queue = queue.OrderByDescending(x => x.priority).ToList();
    
    if (!isProcessing)
    {
        StartCoroutine(ProcessQueue());
    }
}
 
IEnumerator ProcessQueue()
{
    isProcessing = true;
    
    while (queue.Count > 0)
    {
        var current = queue[0];
        queue.RemoveAt(0);
        
        Debug.Log($"Processing coroutine: {current.name} (priority: {current.priority})");
        
        bool completed = false;
        try
        {
            yield return StartCoroutine(current.coroutine);
            completed = true;
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Coroutine {current.name} failed: {e.Message}");
        }
        
        current.onComplete?.Invoke(completed);
    }
    
    isProcessing = false;
}
}

IEnumerator DifferentWaitingApproaches()
{
    // Способ 1: Стандартное ожидание через StartCoroutine
    yield return StartCoroutine(LongRunningTask());
    
    // Способ 2: Прямой yield return IEnumerator (работает в Unity 5.3+)
    yield return LongRunningTask();
    
    // Способ 3: Сохранение ссылки для управления
    Coroutine taskRef = StartCoroutine(LongRunningTask());
    yield return taskRef;
    
    Debug.Log("Все подходы завершены");
}
 
IEnumerator LongRunningTask()
{
    for (int i = 0; i < 5; i++)
    {
        Debug.Log($"Task step {i + 1}");
        yield return new WaitForSeconds(0.5f);
    }
}

IEnumerator FragileWaiting()
{
    Debug.Log("Запускаем долгую задачу");
    
    yield return StartCoroutine(VeryLongTask());
    
    // Этот код может никогда не выполниться!
    Debug.Log("Задача завершена");
    CleanupResources();
}
 
IEnumerator VeryLongTask()
{
    yield return new WaitForSeconds(10f);
    
    // Задача завершается, но родительская корутина может быть мертвой
    Debug.Log("Долгая задача завершена");
}

IEnumerator UnreliableErrorHandling()
{
    try
    {
        yield return StartCoroutine(ProblematicTask());
        Debug.Log("Задача 'завершена' успешно"); // Выполнится даже при ошибке
    }
    catch (System.Exception e)
    {
        // Этот блок НИКОГДА не выполнится для ошибок в дочерней корутине
        Debug.LogError($"Поймано исключение: {e.Message}");
    }
}
 
IEnumerator ProblematicTask()
{
    yield return new WaitForSeconds(1f);
    
    throw new System.InvalidOperationException("Что-то пошло не так!");
    // Исключение будет залогировано, но не пробросится в родительскую корутину
}

public class CoroutineResult<T>
{
    public T Value { get; set; }
    public bool IsSuccess { get; set; }
    public string ErrorMessage { get; set; }
    public System.Exception Exception { get; set; }
}
 
IEnumerator ReliableWaiting()
{
    var result = new CoroutineResult<string>();
    
    yield return StartCoroutine(SafeTask(result));
    
    if (result.IsSuccess)
    {
        Debug.Log($"Получен результат: {result.Value}");
    }
    else
    {
        Debug.LogError($"Задача завершилась с ошибкой: {result.ErrorMessage}");
    }
}
 
IEnumerator SafeTask(CoroutineResult<string> result)
{
    try
    {
        yield return new WaitForSeconds(2f);
        
        // Симуляция случайной ошибки
        if (UnityEngine.Random.Range(0, 2) == 0)
        {
            throw new System.Exception("Случайная ошибка");
        }
        
        result.Value = "Задача выполнена успешно";
        result.IsSuccess = true;
    }
    catch (System.Exception e)
    {
        result.IsSuccess = false;
        result.ErrorMessage = e.Message;
        result.Exception = e;
    }
}

IEnumerator WaitWithTimeout(IEnumerator targetCoroutine, float timeout)
{
    float startTime = Time.time;
    Coroutine runningCoroutine = StartCoroutine(targetCoroutine);
    
    while (runningCoroutine != null && Time.time - startTime < timeout)
    {
        yield return null;
    }
    
    if (Time.time - startTime >= timeout)
    {
        Debug.LogWarning("Корутина превысила лимит времени выполнения");
        StopCoroutine(runningCoroutine);
    }
}

public class GameStateFlags : MonoBehaviour
{
    private static Dictionary<string, bool> stateFlags = new Dictionary<string, bool>();
    private static Dictionary<string, List<System.Action>> stateCallbacks = new Dictionary<string, List<System.Action>>();
 
    public static void SetFlag(string flagName, bool value)
    {
        bool oldValue = GetFlag(flagName);
        stateFlags[flagName] = value;
 
        if (oldValue != value && value)
        {
            TriggerCallbacks(flagName);
        }
 
        Debug.Log($"Flag {flagName} set to {value}");
    }
 
    public static bool GetFlag(string flagName)
    {
        return stateFlags.ContainsKey(flagName) && stateFlags[flagName];
    }
 
    public static void WaitForFlag(string flagName, System.Action callback)
    {
        if (GetFlag(flagName))
        {
            callback?.Invoke();
            return;
        }
 
        if (!stateCallbacks.ContainsKey(flagName))
        {
            stateCallbacks[flagName] = new List<System.Action>();
        }
 
        stateCallbacks[flagName].Add(callback);
    }
 
    private static void TriggerCallbacks(string flagName)
    {
        if (!stateCallbacks.ContainsKey(flagName)) return;
 
        foreach (var callback in stateCallbacks[flagName])
        {
            callback?.Invoke();
        }
 
        stateCallbacks[flagName].Clear();
    }
}

IEnumerator LoadingCoordinator()
{
    Debug.Log("Начинаем загрузку уровня");
 
    // Запускаем независимые загрузчики
    StartCoroutine(AudioLoader());
    StartCoroutine(GraphicsLoader());
    StartCoroutine(AISystemLoader());
    StartCoroutine(UILoader());
 
    // Ждем готовности всех систем
    yield return StartCoroutine(WaitForAllSystems());
 
    GameStateFlags.SetFlag("Level_Ready", true);
    Debug.Log("Уровень полностью загружен");
}
 
IEnumerator AudioLoader()
{
    yield return new WaitForSeconds(UnityEngine.Random.Range(1f, 3f));
    Debug.Log("Аудио система готова");
    GameStateFlags.SetFlag("Audio_Ready", true);
}
 
IEnumerator GraphicsLoader()
{
    yield return new WaitForSeconds(UnityEngine.Random.Range(2f, 4f));
    Debug.Log("Графика готова");
    GameStateFlags.SetFlag("Graphics_Ready", true);
}
 
IEnumerator WaitForAllSystems()
{
    string[] requiredFlags = { "Audio_Ready", "Graphics_Ready", "AI_Ready", "UI_Ready" };
 
    while (true)
    {
        bool allReady = true;
        foreach (string flag in requiredFlags)
        {
            if (!GameStateFlags.GetFlag(flag))
            {
                allReady = false;
                break;
            }
        }
 
        if (allReady) break;
        yield return new WaitForSeconds(0.1f);
    }
}

public class CounterFlags : MonoBehaviour
{
    private static Dictionary<string, int> counters = new Dictionary<string, int>();
    private static Dictionary<string, int> targets = new Dictionary<string, int>();
 
    public static void SetTargetCount(string counterName, int target)
    {
        targets[counterName] = target;
        if (!counters.ContainsKey(counterName))
        {
            counters[counterName] = 0;
        }
    }
 
    public static void IncrementCounter(string counterName)
    {
        if (!counters.ContainsKey(counterName))
        {
            counters[counterName] = 0;
        }
 
        counters[counterName]++;
        Debug.Log($"Counter {counterName}: {counters[counterName]}/{targets.GetValueOrDefault(counterName, 0)}");
    }
 
    public static bool IsTargetReached(string counterName)
    {
        return counters.GetValueOrDefault(counterName, 0) >= targets.GetValueOrDefault(counterName, 1);
    }
 
    public static IEnumerator WaitForTarget(string counterName)
    {
        while (!IsTargetReached(counterName))
        {
            yield return new WaitForSeconds(0.1f);
        }
    }
}

IEnumerator EnemySpawner()
{
    int enemyCount = UnityEngine.Random.Range(5, 10);
    CounterFlags.SetTargetCount("Enemies_Defeated", enemyCount);
 
    for (int i = 0; i < enemyCount; i++)
    {
        StartCoroutine(SpawnAndManageEnemy(i));
        yield return new WaitForSeconds(0.5f);
    }
 
    Debug.Log($"Заспавнено {enemyCount} врагов");
    yield return CounterFlags.WaitForTarget("Enemies_Defeated");
    
    Debug.Log("Все враги повержены!");
    GameStateFlags.SetFlag("Wave_Completed", true);
}
 
IEnumerator SpawnAndManageEnemy(int enemyId)
{
    GameObject enemy = Instantiate(enemyPrefab);
    enemy.name = $"Enemy_{enemyId}";
 
    // Симуляция жизни врага
    float lifeTime = UnityEngine.Random.Range(3f, 8f);
    yield return new WaitForSeconds(lifeTime);
 
    Destroy(enemy);
    CounterFlags.IncrementCounter("Enemies_Defeated");
    Debug.Log($"Враг {enemyId} уничтожен");
}

public class CoroutinePool : MonoBehaviour
{
    private class PooledCoroutine
    {
        public bool isActive;
        public IEnumerator currentTask;
        public Coroutine unityCoroutine;
        public System.Action<PooledCoroutine> onComplete;
        public string taskName;
    }
 
    private List<PooledCoroutine> pool = new List<PooledCoroutine>();
    private Queue<PooledCoroutine> availableCoroutines = new Queue<PooledCoroutine>();
    
    [SerializeField] private int poolSize = 20;
 
    void Awake()
    {
        InitializePool();
    }
 
    private void InitializePool()
    {
        for (int i = 0; i < poolSize; i++)
        {
            var pooledCoroutine = new PooledCoroutine();
            pool.Add(pooledCoroutine);
            availableCoroutines.Enqueue(pooledCoroutine);
        }
    }
 
    public bool TryExecuteTask(string taskName, IEnumerator task, System.Action onComplete = null)
    {
        if (availableCoroutines.Count == 0)
        {
            Debug.LogWarning($"Пул корутин исчерпан. Задача {taskName} отклонена");
            return false;
        }
 
        var pooledCoroutine = availableCoroutines.Dequeue();
        pooledCoroutine.isActive = true;
        pooledCoroutine.currentTask = task;
        pooledCoroutine.taskName = taskName;
        pooledCoroutine.onComplete = _ => {
            onComplete?.Invoke();
            ReturnToPool(pooledCoroutine);
        };
 
        pooledCoroutine.unityCoroutine = StartCoroutine(ExecutePooledTask(pooledCoroutine));
        return true;
    }
 
    private IEnumerator ExecutePooledTask(PooledCoroutine pooledCoroutine)
    {
        try
        {
            yield return StartCoroutine(pooledCoroutine.currentTask);
        }
        finally
        {
            pooledCoroutine.onComplete?.Invoke(pooledCoroutine);
        }
    }
 
    private void ReturnToPool(PooledCoroutine pooledCoroutine)
    {
        pooledCoroutine.isActive = false;
        pooledCoroutine.currentTask = null;
        pooledCoroutine.taskName = null;
        pooledCoroutine.unityCoroutine = null;
        pooledCoroutine.onComplete = null;
 
        availableCoroutines.Enqueue(pooledCoroutine);
    }
}

public class AdvancedCoroutinePool : MonoBehaviour
{
    private class PriorityTask
    {
        public string name;
        public IEnumerator task;
        public int priority;
        public System.Action onComplete;
        public float submittedAt;
    }
 
    private List<PooledCoroutine> pool = new List<PooledCoroutine>();
    private Queue<PooledCoroutine> availableCoroutines = new Queue<PooledCoroutine>();
    private Queue<PriorityTask> waitingTasks = new Queue<PriorityTask>();
 
    [SerializeField] private int initialPoolSize = 10;
    [SerializeField] private int maxPoolSize = 50;
    [SerializeField] private bool allowDynamicExpansion = true;
 
    public bool ExecuteWithPriority(string taskName, IEnumerator task, int priority = 0, System.Action onComplete = null)
    {
        if (TryGetAvailableCoroutine(out var pooledCoroutine))
        {
            AssignTask(pooledCoroutine, taskName, task, onComplete);
            return true;
        }
 
        if (allowDynamicExpansion && pool.Count < maxPoolSize)
        {
            ExpandPool(1);
            return ExecuteWithPriority(taskName, task, priority, onComplete);
        }
 
        // Добавляем в очередь ожидания
        waitingTasks.Enqueue(new PriorityTask
        {
            name = taskName,
            task = task,
            priority = priority,
            onComplete = onComplete,
            submittedAt = Time.time
        });
 
        Debug.LogWarning($"Задача {taskName} добавлена в очередь ожидания");
        return false;
    }
 
    private bool TryGetAvailableCoroutine(out PooledCoroutine pooledCoroutine)
    {
        if (availableCoroutines.Count > 0)
        {
            pooledCoroutine = availableCoroutines.Dequeue();
            return true;
        }
 
        pooledCoroutine = null;
        return false;
    }
 
    private void ExpandPool(int count)
    {
        for (int i = 0; i < count; i++)
        {
            var newPooledCoroutine = new PooledCoroutine();
            pool.Add(newPooledCoroutine);
            availableCoroutines.Enqueue(newPooledCoroutine);
        }
 
        Debug.Log($"Пул расширен на {count} корутин. Текущий размер: {pool.Count}");
    }
 
    private void ProcessWaitingQueue()
    {
        while (waitingTasks.Count > 0 && availableCoroutines.Count > 0)
        {
            var task = waitingTasks.Dequeue();
            var pooledCoroutine = availableCoroutines.Dequeue();
            AssignTask(pooledCoroutine, task.name, task.task, task.onComplete);
        }
    }
 
    void Update()
    {
        ProcessWaitingQueue();
    }
}

IEnumerator DeceptiveErrorHandling()
{
try
{
    Debug.Log("Запускаем потенциально проблемную задачу");
    yield return StartCoroutine(FailingCoroutine());
    
    // Этот код выполнится даже если дочерняя корутина упала с ошибкой!
    Debug.Log("Задача 'успешно' завершена");
}
catch (System.Exception e)
{
    // Этот блок НИКОГДА не сработает для исключений из дочерних корутин
    Debug.LogError($"Поймано исключение: {e.Message}");
}
}
 
IEnumerator FailingCoroutine()
{
yield return new WaitForSeconds(1f);
throw new System.ArgumentNullException("Симуляция ошибки");
// Исключение будет залогировано Unity, но не дойдет до родительской корутины
}

public class CoroutineResult
{
public bool IsSuccess { get; set; } = true;
public string ErrorMessage { get; set; }
public System.Exception Exception { get; set; }
public object Data { get; set; }
}
 
IEnumerator SafeNestedExecution()
{
var result = new CoroutineResult();
 
yield return StartCoroutine(SafeOperation(result));
 
if (result.IsSuccess)
{
    Debug.Log($"Операция завершена успешно: {result.Data}");
}
else
{
    Debug.LogError($"Операция завершилась с ошибкой: {result.ErrorMessage}");
    HandleOperationFailure(result.Exception);
}
}
 
IEnumerator SafeOperation(CoroutineResult result)
{
try
{
    yield return new WaitForSeconds(1f);
    
    // Симуляция потенциальной ошибки
    if (UnityEngine.Random.Range(0, 2) == 0)
    {
        throw new System.InvalidOperationException("Случайная ошибка");
    }
    
    result.Data = "Успешный результат";
}
catch (System.Exception e)
{
    result.IsSuccess = false;
    result.ErrorMessage = e.Message;
    result.Exception = e;
}
}

IEnumerator ComplexNestingWithErrorHandling()
{
var phase1Result = new CoroutineResult();
yield return StartCoroutine(Phase1(phase1Result));
 
if (!phase1Result.IsSuccess)
{
    Debug.LogError("Phase1 failed, aborting sequence");
    yield return StartCoroutine(Cleanup());
    yield break;
}
 
var phase2Result = new CoroutineResult();
yield return StartCoroutine(Phase2(phase2Result, phase1Result.Data));
 
if (!phase2Result.IsSuccess)
{
    Debug.LogError("Phase2 failed, rolling back Phase1");
    yield return StartCoroutine(RollbackPhase1(phase1Result.Data));
    yield break;
}
 
Debug.Log("Вся последовательность выполнена успешно");
}

IEnumerator ParallelExecutionWithErrorHandling()
{
var results = new CoroutineResult[3];
for (int i = 0; i < results.Length; i++)
{
    results[i] = new CoroutineResult();
}
 
// Запускаем параллельные задачи
var coroutines = new Coroutine[]
{
    StartCoroutine(ParallelTask(results[0], "Task1")),
    StartCoroutine(ParallelTask(results[1], "Task2")), 
    StartCoroutine(ParallelTask(results[2], "Task3"))
};
 
// Ждем завершения всех
foreach (var coroutine in coroutines)
{
    yield return coroutine;
}
 
// Анализируем результаты
int successCount = 0;
for (int i = 0; i < results.Length; i++)
{
    if (results[i].IsSuccess)
    {
        successCount++;
    }
    else
    {
        Debug.LogError($"Task{i+1} failed: {results[i].ErrorMessage}");
    }
}
 
Debug.Log($"Завершилось успешно задач: {successCount}/{results.Length}");
}

public class TimeoutManager : MonoBehaviour
{
public static IEnumerator WithTimeout(IEnumerator coroutine, float timeoutSeconds, System.Action onTimeout = null)
{
float startTime = Time.time;
Coroutine runningCoroutine = Instance.StartCoroutine(coroutine);
bool completed = false;
 
// Корутина-наблюдатель для отслеживания завершения
Instance.StartCoroutine(TrackCompletion(() => completed = true));
 
while (!completed && Time.time - startTime < timeoutSeconds)
{
    yield return null;
}
 
if (!completed)
{
    Debug.LogWarning($"Корутина превысила таймаут {timeoutSeconds}с");
    Instance.StopCoroutine(runningCoroutine);
    onTimeout?.Invoke();
}
 
IEnumerator TrackCompletion(System.Action onComplete)
{
    yield return runningCoroutine;
    onComplete?.Invoke();
}
}
 
public static TimeoutManager Instance { get; private set; }
 
void Awake()
{
Instance = this;
}
}

public class AdvancedTimeoutCoroutine : MonoBehaviour
{
private class TimeoutContext
{
    public float originalTimeout;
    public float currentTimeout;
    public bool canExtend;
    public int extensionsUsed;
    public int maxExtensions;
    public System.Action<string> onTimeout;
    public System.Action onSuccess;
}
 
public static IEnumerator ExecuteWithDynamicTimeout(string taskName, IEnumerator task, float baseTimeout, int maxExtensions = 2)
{
var context = new TimeoutContext
{
    originalTimeout = baseTimeout,
    currentTimeout = baseTimeout,
    canExtend = maxExtensions > 0,
    maxExtensions = maxExtensions
};
 
float startTime = Time.time;
bool taskCompleted = false;
Coroutine taskCoroutine = Instance.StartCoroutine(WrapTask(task, () => taskCompleted = true));
 
while (!taskCompleted)
{
    float elapsed = Time.time - startTime;
    
    if (elapsed >= context.currentTimeout)
    {
        if (context.canExtend && context.extensionsUsed < context.maxExtensions)
        {
            Debug.LogWarning($"Задача {taskName} превысила таймаут, продлеваем на {baseTimeout}с");
            context.currentTimeout += baseTimeout;
            context.extensionsUsed++;
        }
        else
        {
            Debug.LogError($"Задача {taskName} окончательно превысила таймаут");
            Instance.StopCoroutine(taskCoroutine);
            yield break;
        }
    }
    
    yield return null;
}
 
Debug.Log($"Задача {taskName} завершена за {Time.time - startTime:F2}с");
}
 
private static IEnumerator WrapTask(IEnumerator task, System.Action onComplete)
{
yield return task;
onComplete?.Invoke();
}
}

IEnumerator ResourceAwareOperation()
{
List<System.IDisposable> resources = new List<System.IDisposable>();
bool operationCompleted = false;
 
try
{
    // Регистрируем ресурсы для автоматической очистки
    var networkStream = OpenNetworkConnection();
    resources.Add(networkStream);
    
    var tempFile = CreateTemporaryFile();
    resources.Add(tempFile);
    
    // Основная работа с возможным зависанием
    yield return StartCoroutine(UnreliableNetworkOperation(networkStream));
    yield return StartCoroutine(ProcessTempFile(tempFile));
    
    operationCompleted = true;
}
finally
{
    // Этот блок может НЕ выполниться при принудительной остановке
    if (!operationCompleted)
    {
        Debug.LogWarning("Операция была прервана, но finally может не сработать");
    }
    
    CleanupResources(resources);
}
}
 
void CleanupResources(List<System.IDisposable> resources)
{
foreach (var resource in resources)
{
    try
    {
        resource?.Dispose();
    }
    catch (System.Exception e)
    {
        Debug.LogError($"Ошибка при освобождении ресурса: {e.Message}");
    }
}
}

public class AdvancedCoroutineManager : MonoBehaviour
{
private static AdvancedCoroutineManager instance;
public static AdvancedCoroutineManager Instance => instance;
 
private Dictionary<string, ManagedCoroutineGroup> coroutineGroups = new Dictionary<string, ManagedCoroutineGroup>();
private List<ManagedCoroutine> allCoroutines = new List<ManagedCoroutine>();
 
private class ManagedCoroutine
{
public string id;
public string groupName;
public Coroutine unityCoroutine;
public float startTime;
public float timeout;
public bool hasTimeout;
public System.Action<bool> onComplete;
public CoroutineStatus status;
}
 
private class ManagedCoroutineGroup
{
public string name;
public List<string> coroutineIds;
public int maxConcurrent;
public Queue<System.Func<IEnumerator>> pendingTasks;
public bool isPaused;
}
 
public enum CoroutineStatus
{
Running,
Paused,
Completed,
Failed,
TimedOut
}
 
void Awake()
{
instance = this;
StartCoroutine(MonitorCoroutines());
}
 
public string ExecuteManagedCoroutine(string groupName, IEnumerator coroutine, float timeout = 0f, System.Action<bool> onComplete = null)
{
string coroutineId = System.Guid.NewGuid().ToString();
 
if (!coroutineGroups.ContainsKey(groupName))
{
CreateGroup(groupName);
}
 
var group = coroutineGroups[groupName];
 
if (group.isPaused || (group.maxConcurrent > 0 && GetActiveCoroutinesInGroup(groupName) >= group.maxConcurrent))
{
group.pendingTasks.Enqueue(() => coroutine);
return coroutineId;
}
 
var managedCoroutine = new ManagedCoroutine
{
id = coroutineId,
groupName = groupName,
startTime = Time.time,
timeout = timeout,
hasTimeout = timeout > 0f,
onComplete = onComplete,
status = CoroutineStatus.Running
};
 
managedCoroutine.unityCoroutine = StartCoroutine(ExecuteWithManagement(managedCoroutine, coroutine));
allCoroutines.Add(managedCoroutine);
group.coroutineIds.Add(coroutineId);
 
return coroutineId;
}
 
public void CreateGroup(string groupName, int maxConcurrent = 0)
{
if (!coroutineGroups.ContainsKey(groupName))
{
coroutineGroups[groupName] = new ManagedCoroutineGroup
{
    name = groupName,
    coroutineIds = new List<string>(),
    maxConcurrent = maxConcurrent,
    pendingTasks = new Queue<System.Func<IEnumerator>>(),
    isPaused = false
};
}
}
 
public void PauseGroup(string groupName)
{
if (coroutineGroups.ContainsKey(groupName))
{
coroutineGroups[groupName].isPaused = true;
 
foreach (string coroutineId in coroutineGroups[groupName].coroutineIds)
{
    var coroutine = allCoroutines.Find(c => c.id == coroutineId);
    if (coroutine?.status == CoroutineStatus.Running)
    {
        coroutine.status = CoroutineStatus.Paused;
        StopCoroutine(coroutine.unityCoroutine);
    }
}
}
}
 
private IEnumerator ExecuteWithManagement(ManagedCoroutine managedCoroutine, IEnumerator coroutine)
{
bool completed = false;
 
try
{
yield return StartCoroutine(coroutine);
completed = true;
managedCoroutine.status = CoroutineStatus.Completed;
}
catch (System.Exception e)
{
Debug.LogError($"Корутина {managedCoroutine.id} завершилась с ошибкой: {e.Message}");
managedCoroutine.status = CoroutineStatus.Failed;
}
finally
{
managedCoroutine.onComplete?.Invoke(completed);
CleanupCoroutine(managedCoroutine.id);
ProcessPendingTasks(managedCoroutine.groupName);
}
}
 
private IEnumerator MonitorCoroutines()
{
while (true)
{
yield return new WaitForSeconds(1f);
 
for (int i = allCoroutines.Count - 1; i >= 0; i--)
{
    var coroutine = allCoroutines[i];
    
    if (coroutine.hasTimeout && coroutine.status == CoroutineStatus.Running)
    {
        float elapsed = Time.time - coroutine.startTime;
        if (elapsed >= coroutine.timeout)
        {
            Debug.LogWarning($"Корутина {coroutine.id} превысила таймаут {coroutine.timeout}с");
            coroutine.status = CoroutineStatus.TimedOut;
            StopCoroutine(coroutine.unityCoroutine);
            coroutine.onComplete?.Invoke(false);
            CleanupCoroutine(coroutine.id);
        }
    }
}
}
}
 
private int GetActiveCoroutinesInGroup(string groupName)
{
if (!coroutineGroups.ContainsKey(groupName)) return 0;
 
return coroutineGroups[groupName].coroutineIds.Count(id => 
    allCoroutines.Any(c => c.id == id && 
        (c.status == CoroutineStatus.Running || c.status == CoroutineStatus.Paused)));
}
 
private void CleanupCoroutine(string coroutineId)
{
allCoroutines.RemoveAll(c => c.id == coroutineId);
 
foreach (var group in coroutineGroups.Values)
{
group.coroutineIds.RemoveAll(id => id == coroutineId);
}
}
 
private void ProcessPendingTasks(string groupName)
{
if (!coroutineGroups.ContainsKey(groupName)) return;
 
var group = coroutineGroups[groupName];
 
while (group.pendingTasks.Count > 0 && !group.isPaused && 
       GetActiveCoroutinesInGroup(groupName) < group.maxConcurrent)
{
var taskFactory = group.pendingTasks.Dequeue();
ExecuteManagedCoroutine(groupName, taskFactory.Invoke());
}
}
}

public class ScenarioCoroutineManager : MonoBehaviour
{
private static ScenarioCoroutineManager _instance;
public static ScenarioCoroutineManager Instance
{
    get
    {
        if (_instance == null)
        {
            var go = new GameObject("ScenarioCoroutineManager");
            _instance = go.AddComponent<ScenarioCoroutineManager>();
            DontDestroyOnLoad(go);
        }
        return _instance;
    }
}
 
private Dictionary<string, ScenarioContext> scenarios = new Dictionary<string, ScenarioContext>();
private List<CoroutineNode> activeNodes = new List<CoroutineNode>();
 
private class ScenarioContext
{
    public string name;
    public Dictionary<string, object> sharedData;
    public List<string> nodeIds;
    public ScenarioStatus status;
    public float startTime;
    public System.Action<ScenarioContext> onComplete;
    public int priority;
}
 
private class CoroutineNode
{
    public string id;
    public string scenarioName;
    public string nodeName;
    public Coroutine coroutine;
    public NodeStatus status;
    public List<string> dependencies;
    public List<string> dependents;
    public System.Func<ScenarioContext, IEnumerator> task;
    public float timeout;
    public int retryCount;
    public int maxRetries;
}
 
public enum ScenarioStatus { Pending, Running, Completed, Failed, Cancelled }
public enum NodeStatus { Waiting, Running, Completed, Failed, Retrying }
 
public string CreateScenario(string scenarioName, int priority = 0)
{
    var context = new ScenarioContext
    {
        name = scenarioName,
        sharedData = new Dictionary<string, object>(),
        nodeIds = new List<string>(),
        status = ScenarioStatus.Pending,
        startTime = Time.time,
        priority = priority
    };
 
    scenarios[scenarioName] = context;
    return scenarioName;
}
 
public string AddNode(string scenarioName, string nodeName, System.Func<ScenarioContext, IEnumerator> task,
                      string[] dependencies = null, float timeout = 0f, int maxRetries = 0)
{
    if (!scenarios.ContainsKey(scenarioName))
        throw new System.ArgumentException($"Сценарий {scenarioName} не найден");
 
    string nodeId = $"{scenarioName}_{nodeName}_{System.Guid.NewGuid().ToString("N")[..8]}";
 
    var node = new CoroutineNode
    {
        id = nodeId,
        scenarioName = scenarioName,
        nodeName = nodeName,
        status = NodeStatus.Waiting,
        dependencies = dependencies?.ToList() ?? new List<string>(),
        dependents = new List<string>(),
        task = task,
        timeout = timeout,
        maxRetries = maxRetries
    };
 
    activeNodes.Add(node);
    scenarios[scenarioName].nodeIds.Add(nodeId);
 
    // Обновляем связи зависимостей
    foreach (string dependency in node.dependencies)
    {
        var depNode = activeNodes.Find(n => n.nodeName == dependency && n.scenarioName == scenarioName);
        if (depNode != null)
        {
            depNode.dependents.Add(nodeId);
        }
    }
 
    return nodeId;
}
 
public void ExecuteScenario(string scenarioName, System.Action<ScenarioContext> onComplete = null)
{
    if (!scenarios.ContainsKey(scenarioName))
        return;
 
    var context = scenarios[scenarioName];
    context.onComplete = onComplete;
    context.status = ScenarioStatus.Running;
 
    StartCoroutine(RunScenario(context));
}
 
private IEnumerator RunScenario(ScenarioContext context)
{
    var scenarioNodes = activeNodes.Where(n => n.scenarioName == context.name).ToList();
 
    while (scenarioNodes.Any(n => n.status == NodeStatus.Waiting || n.status == NodeStatus.Running || n.status == NodeStatus.Retrying))
    {
        // Запускаем ноды, готовые к выполнению
        var readyNodes = scenarioNodes.Where(n => n.status == NodeStatus.Waiting && 
                                                   AreAllDependenciesSatisfied(n, scenarioNodes)).ToList();
 
        foreach (var node in readyNodes)
        {
            node.status = NodeStatus.Running;
            node.coroutine = StartCoroutine(ExecuteNode(node, context));
        }
 
        yield return new WaitForSeconds(0.1f);
 
        // Проверяем статус завершения
        bool allCompleted = scenarioNodes.All(n => n.status == NodeStatus.Completed);
        bool anyFailed = scenarioNodes.Any(n => n.status == NodeStatus.Failed);
 
        if (allCompleted)
        {
            context.status = ScenarioStatus.Completed;
            break;
        }
 
        if (anyFailed && !scenarioNodes.Any(n => n.status == NodeStatus.Retrying))
        {
            context.status = ScenarioStatus.Failed;
            break;
        }
    }
 
    context.onComplete?.Invoke(context);
    CleanupScenario(context.name);
}
 
private bool AreAllDependenciesSatisfied(CoroutineNode node, List<CoroutineNode> scenarioNodes)
{
    return node.dependencies.All(dep => 
        scenarioNodes.Any(n => n.nodeName == dep && n.status == NodeStatus.Completed));
}
 
private IEnumerator ExecuteNode(CoroutineNode node, ScenarioContext context)
{
    float startTime = Time.time;
    bool nodeCompleted = false;
 
    try
    {
        // Выполняем задачу ноды с учетом таймаута
        if (node.timeout > 0)
        {
            yield return StartCoroutine(ExecuteWithTimeout(node.task(context), node.timeout, 
                () => nodeCompleted = true));
        }
        else
        {
            yield return StartCoroutine(node.task(context));
            nodeCompleted = true;
        }
 
        if (nodeCompleted)
        {
            node.status = NodeStatus.Completed;
            Debug.Log($"Нода {node.nodeName} в сценарии {context.name} завершена успешно");
        }
        else
        {
            throw new System.TimeoutException($"Нода {node.nodeName} превысила таймаут {node.timeout}с");
        }
    }
    catch (System.Exception e)
    {
        Debug.LogError($"Ошибка в ноде {node.nodeName}: {e.Message}");
 
        if (node.retryCount < node.maxRetries)
        {
            node.retryCount++;
            node.status = NodeStatus.Retrying;
            Debug.Log($"Повторная попытка {node.retryCount}/{node.maxRetries} для ноды {node.nodeName}");
            
            yield return new WaitForSeconds(Mathf.Pow(2, node.retryCount)); // Экспоненциальная задержка
            node.status = NodeStatus.Waiting;
        }
        else
        {
            node.status = NodeStatus.Failed;
        }
    }
}
 
private IEnumerator ExecuteWithTimeout(IEnumerator task, float timeout, System.Action onComplete)
{
    float startTime = Time.time;
    Coroutine taskCoroutine = StartCoroutine(task);
    bool completed = false;
 
    StartCoroutine(TrackCompletion());
 
    while (!completed && Time.time - startTime < timeout)
    {
        yield return null;
    }
 
    if (!completed)
    {
        StopCoroutine(taskCoroutine);
    }
 
    IEnumerator TrackCompletion()
    {
        yield return taskCoroutine;
        completed = true;
        onComplete?.Invoke();
    }
}
 
public void SetSharedData<T>(string scenarioName, string key, T value)
{
    if (scenarios.ContainsKey(scenarioName))
    {
        scenarios[scenarioName].sharedData[key] = value;
    }
}
 
public T GetSharedData<T>(string scenarioName, string key, T defaultValue = default(T))
{
    if (scenarios.ContainsKey(scenarioName) && 
        scenarios[scenarioName].sharedData.ContainsKey(key) &&
        scenarios[scenarioName].sharedData[key] is T)
    {
        return (T)scenarios[scenarioName].sharedData[key];
    }
    return defaultValue;
}
 
private void CleanupScenario(string scenarioName)
{
    if (scenarios.ContainsKey(scenarioName))
    {
        var context = scenarios[scenarioName];
        activeNodes.RemoveAll(n => context.nodeIds.Contains(n.id));
        scenarios.Remove(scenarioName);
    }
}
}

public class ReactiveCoroutineSystem : MonoBehaviour
{
private static ReactiveCoroutineSystem _instance;
public static ReactiveCoroutineSystem Instance => _instance;
 
private Dictionary<string, List<System.Func<object, IEnumerator>>> eventCoroutines = new Dictionary<string, List<System.Func<object, IEnumerator>>>();
private Dictionary<string, Queue<object>> eventQueue = new Dictionary<string, Queue<object>>();
private Dictionary<string, bool> isProcessingEvent = new Dictionary<string, bool>();
 
void Awake()
{
_instance = this;
StartCoroutine(ProcessEventQueue());
}
 
public void SubscribeCoroutine(string eventName, System.Func<object, IEnumerator> coroutineFactory)
{
if (!eventCoroutines.ContainsKey(eventName))
{
    eventCoroutines[eventName] = new List<System.Func<object, IEnumerator>>();
    eventQueue[eventName] = new Queue<object>();
    isProcessingEvent[eventName] = false;
}
 
eventCoroutines[eventName].Add(coroutineFactory);
Debug.Log($"Корутина подписана на событие {eventName}");
}
 
public void PublishEvent(string eventName, object eventData = null)
{
if (!eventQueue.ContainsKey(eventName)) return;
 
eventQueue[eventName].Enqueue(eventData ?? new object());
Debug.Log($"Событие {eventName} добавлено в очередь");
}
 
private IEnumerator ProcessEventQueue()
{
while (true)
{
    foreach (var eventType in eventQueue.Keys.ToList())
    {
        if (eventQueue[eventType].Count > 0 && !isProcessingEvent[eventType])
        {
            yield return StartCoroutine(ProcessSingleEvent(eventType));
        }
    }
    
    yield return new WaitForSeconds(0.05f); // Проверяем события 20 раз в секунду
}
}
 
private IEnumerator ProcessSingleEvent(string eventName)
{
isProcessingEvent[eventName] = true;
 
while (eventQueue[eventName].Count > 0)
{
    var eventData = eventQueue[eventName].Dequeue();
    
    if (eventCoroutines.ContainsKey(eventName))
    {
        var coroutines = new List<Coroutine>();
        
        // Запускаем все подписанные корутины параллельно
        foreach (var coroutineFactory in eventCoroutines[eventName])
        {
            var coroutine = StartCoroutine(SafeExecuteReactiveCoroutine(coroutineFactory, eventData, eventName));
            coroutines.Add(coroutine);
        }
        
        // Ждем завершения всех корутин для этого события
        foreach (var coroutine in coroutines)
        {
            yield return coroutine;
        }
    }
}
 
isProcessingEvent[eventName] = false;
}
 
private IEnumerator SafeExecuteReactiveCoroutine(System.Func<object, IEnumerator> coroutineFactory, object eventData, string eventName)
{
try
{
    yield return StartCoroutine(coroutineFactory(eventData));
}
catch (System.Exception e)
{
    Debug.LogError($"Ошибка в реактивной корутине для события {eventName}: {e.Message}");
}
}
}