Корутины в Unity и производительно­сть WaitForSeconds

IEnumerator SpawnMonsters()
{
    while(gameIsRunning)
    {
        // создаём нового монстра
        SpawnMonster();
        // ждём 3 секунды
        yield return new WaitForSeconds(3.0f);
    }
}

IEnumerator SimpleCoroutine()
{
    Debug.Log("Начало корутины");
    yield return null;  // приостанавливаем до следующего кадра
    Debug.Log("После первого yield");
    yield return new WaitForSeconds(2f);  // ждём 2 секунды
    Debug.Log("После ожидания");
}

// Вариант 1: передача метода
StartCoroutine(SimpleCoroutine());
 
// Вариант 2: передача имени метода как строки
StartCoroutine("SimpleCoroutine");

// Останавливает одну конкретную корутину
Coroutine routine = StartCoroutine(SimpleCoroutine());
StopCoroutine(routine);
 
// Останавливает корутину по ссылке на метод
StopCoroutine(SimpleCoroutine());
 
// Останавливает корутину по имени
StopCoroutine("SimpleCoroutine");
 
// Останавливает все корутины на компоненте
StopAllCoroutines();

IEnumerator OuterCoroutine()
{
    Debug.Log("Начало внешней корутины");
    yield return StartCoroutine(InnerCoroutine());
    Debug.Log("Внешняя корутина продолжается после завершения вложенной");
}
 
IEnumerator InnerCoroutine()
{
    Debug.Log("Выполняется вложенная корутина");
    yield return new WaitForSeconds(1f);
    Debug.Log("Вложенная корутина завершается");
}

IEnumerator ComplexCoroutine()
{
    int localVar = 10;
    string message = "Привет из корутины";
    
    yield return null; // Здесь создаётся контекст с сохранением localVar и message
    
    localVar += 5;
    Debug.Log(message + ", localVar = " + localVar);
    
    yield return new WaitForSeconds(1f); // Ещё один контекст
    
    Debug.Log("Финальное значение: " + localVar);
}

IEnumerator LifecycleDemoCoroutine()
{
    Debug.Log("Корутина запущена");
    
    for(int i = 0; i < 10; i++)
    {
        Debug.Log("Итерация " + i);
        yield return new WaitForSeconds(1f);
        
        if(i == 5)
        {
            Debug.Log("Деактивируем объект...");
            gameObject.SetActive(false);
            
            // Эта строка никогда не выполнится немедленно
            // Корутина будет приостановлена до активации объекта
            Debug.Log("Этот код выполнится только после реактивации");
        }
    }
    
    Debug.Log("Корутина завершена");
}

public class CoroutineHost : MonoBehaviour
{
    public OtherScript otherScript;
    
    void Start()
    {
        // Запускаем корутину из другого скрипта
        // но она будет привязана к этому объекту
        StartCoroutine(otherScript.ExternalCoroutine());
    }
}
 
public class OtherScript : MonoBehaviour
{
    public IEnumerator ExternalCoroutine()
    {
        Debug.Log("Эта корутина определена в OtherScript");
        yield return new WaitForSeconds(1f);
        Debug.Log("Но выполняется на объекте CoroutineHost");
    }
}

// Неоптимальный подход
IEnumerator SpawnerBad()
{
    while(true)
    {
        SpawnEnemy();
        yield return new WaitForSeconds(2f); // Новый объект в каждой итерации
    }
}

// Оптимизированный подход
IEnumerator SpawnerGood()
{
    WaitForSeconds waitTime = new WaitForSeconds(2f); // Создаём один раз
    
    while(true)
    {
        SpawnEnemy();
        yield return waitTime; // Переиспользуем тот же объект
    }
}

IEnumerator SequentialActions()
{
    // Кешируем объекты для разных временных интервалов
    WaitForSeconds shortPause = new WaitForSeconds(0.5f);
    WaitForSeconds mediumPause = new WaitForSeconds(1f);
    WaitForSeconds longPause = new WaitForSeconds(3f);
    
    Debug.Log("Шаг 1");
    yield return shortPause;
    
    Debug.Log("Шаг 2");
    yield return mediumPause;
    
    Debug.Log("Шаг 3");
    yield return longPause;
    
    Debug.Log("Последовательность завершена");
}

// В меню паузы
Time.timeScale = 0; // Игра приостановлена
 
// Эта корутина "зависнет" навсегда
StartCoroutine(AnimateWithNormalTime());
 
// А эта продолжит работать
StartCoroutine(AnimateWithRealtime());
 
IEnumerator AnimateWithNormalTime()
{
    Debug.Log("Начало анимации (normal)");
    yield return new WaitForSeconds(2f); // Никогда не завершится при timeScale = 0
    Debug.Log("Конец анимации (normal)"); // Этот код не выполнится
}
 
IEnumerator AnimateWithRealtime()
{
    Debug.Log("Начало анимации (realtime)");
    yield return new WaitForSecondsRealtime(2f); // Отработает через 2 секунды
    Debug.Log("Конец анимации (realtime)");
}

// Замедление игры вдвое
Time.timeScale = 0.5f;
StartCoroutine(SlowMotionCoroutine());
 
IEnumerator SlowMotionCoroutine()
{
    Debug.Log("Начало замедления");
    yield return new WaitForSeconds(1f); // Фактически выполнится за 2 секунды реального времени
    Debug.Log("Прошло 1 секунда игрового времени (или 2 секунды реального)");
}

IEnumerator BulletTimeEffect()
{
    float originalTimeScale = Time.timeScale;
    Time.timeScale = 0.3f; // Замедляем время
    
    // Ждём 2 секунды ИГРОВОГО времени (около 6.7 секунд реального)
    yield return new WaitForSeconds(2f);
    
    // Постепенно возвращаем нормальную скорость
    float duration = 1f; // Длительность перехода в игровом времени
    float elapsed = 0;
    
    while (elapsed < duration)
    {
        elapsed += Time.deltaTime; // Заметьте: это уже замедленный deltaTime
        Time.timeScale = Mathf.Lerp(0.3f, originalTimeScale, elapsed / duration);
        yield return null;
    }
    
    Time.timeScale = originalTimeScale; // Гарантируем точное значение
}

public class TimerManager : MonoBehaviour 
{
    private class TimerTask 
    {
        public float Duration;
        public float ElapsedTime;
        public Action OnComplete;
        public bool UseRealtime;
        public bool IsPaused;
        
        public bool IsCompleted => UseRealtime 
            ? (ElapsedTime >= Duration)
            : (ElapsedTime >= Duration && !IsPaused);
    }
    
    private List<TimerTask> _activeTasks = new List<TimerTask>();
    private List<TimerTask> _tasksToAdd = new List<TimerTask>();
    private List<TimerTask> _tasksToRemove = new List<TimerTask>();
    
    // Глобальный доступ через синглтон (можно заменить на DI)
    private static TimerManager _instance;
    public static TimerManager Instance => _instance;
    
    private void Awake() 
    {
        if (_instance != null && _instance != this) 
        {
            Destroy(gameObject);
            return;
        }
        
        _instance = this;
        DontDestroyOnLoad(gameObject);
    }
    
    private void Update() 
    {
        // Добавляем новые задачи
        if (_tasksToAdd.Count > 0) 
        {
            _activeTasks.AddRange(_tasksToAdd);
            _tasksToAdd.Clear();
        }
        
        // Обновляем таймеры
        foreach (var task in _activeTasks) 
        {
            if (task.IsPaused) continue;
            
            task.ElapsedTime += task.UseRealtime 
                ? Time.unscaledDeltaTime 
                : Time.deltaTime;
                
            if (task.IsCompleted) 
            {
                task.OnComplete?.Invoke();
                _tasksToRemove.Add(task);
            }
        }
        
        // Удаляем завершённые задачи
        if (_tasksToRemove.Count > 0) 
        {
            foreach (var task in _tasksToRemove) 
                _activeTasks.Remove(task);
                
            _tasksToRemove.Clear();
        }
    }
    
    // Публичный метод для создания таймера
    public void CreateTimer(float duration, Action onComplete, bool useRealtime = false) 
    {
        var task = new TimerTask 
        {
            Duration = duration,
            ElapsedTime = 0,
            OnComplete = onComplete,
            UseRealtime = useRealtime,
            IsPaused = false
        };
        
        _tasksToAdd.Add(task);
    }
}

void Start() 
{
    TimerManager.Instance.CreateTimer(2.0f, () => {
        Debug.Log("Прошло 2 секунды!");
    });
}

void Start() 
{
    // Выполнится через 2 секунды
    Invoke("DelayedFunction", 2.0f);
    
    // Будет выполняться каждые 3 секунды, начиная через 1 секунду
    InvokeRepeating("RepeatedFunction", 1.0f, 3.0f);
}
 
void DelayedFunction() 
{
    Debug.Log("Вызвано с задержкой");
}
 
void RepeatedFunction() 
{
    Debug.Log("Повторяющийся вызов");
}

public class EventTimer : MonoBehaviour 
{
    private float _timer = 0;
    private float _targetTime;
    private System.Action _callback;
    private bool _isRunning = false;
    
    public void StartTimer(float time, System.Action onComplete) 
    {
        _timer = 0;
        _targetTime = time;
        _callback = onComplete;
        _isRunning = true;
    }
    
    private void Update() 
    {
        if (!_isRunning) return;
        
        _timer += Time.deltaTime;
        
        if (_timer >= _targetTime) 
        {
            _isRunning = false;
            _callback?.Invoke();
        }
    }
}

public class SimpleDelay : MonoBehaviour 
{
    private float _delayTimer = 0;
    private bool _shouldExecute = false;
    private float _delayDuration = 3.0f;
    
    void Start() 
    {
        // Инициируем задержку
        _shouldExecute = true;
    }
    
    void Update() 
    {
        if (_shouldExecute) 
        {
            _delayTimer += Time.deltaTime;
            
            if (_delayTimer >= _delayDuration) 
            {
                Debug.Log("Задержка завершена");
                _shouldExecute = false;
                _delayTimer = 0;
            }
        }
    }
}

void Start() 
{
    // Задержка выполнения через DOTween
    DOVirtual.DelayedCall(2.0f, () => {
        Debug.Log("Выполнено через DOTween");
    });
    
    // Анимация с задержкой
    transform.DOMove(new Vector3(5, 0, 0), 1.0f)
        .SetDelay(0.5f)
        .OnComplete(() => {
            Debug.Log("Анимация завершена");
        });
}

public class CoroutinePool : MonoBehaviour
{
    // Словарь пулов для различных значений времени
    private static Dictionary<float, WaitForSeconds> _timePool = new Dictionary<float, WaitForSeconds>();
    
    // Метод для получения WaitForSeconds из пула
    public static WaitForSeconds Wait(float time)
    {
        // Округляем до сотых для уменьшения количества разных значений
        float roundedTime = Mathf.Round(time * 100f) / 100f;
        
        // Проверяем, есть ли такой объект в пуле
        if (!_timePool.TryGetValue(roundedTime, out WaitForSeconds wait))
        {
            // Если нет, создаём и добавляем в пул
            wait = new WaitForSeconds(roundedTime);
            _timePool.Add(roundedTime, wait);
        }
        
        return wait;
    }
}

IEnumerator PooledCoroutine()
{
    Debug.Log("Начало корутины");
    yield return CoroutinePool.Wait(1.5f); // Берём из пула вместо создания нового
    Debug.Log("Середина");
    yield return CoroutinePool.Wait(0.75f); // И здесь тоже
    Debug.Log("Конец корутины");
}

async void StartAsyncOperation()
{
    Debug.Log("Начало асинхронной операции");
    await Task.Delay(1000); // Задержка в миллисекундах
    Debug.Log("Прошла 1 секунда");
    await Task.Delay(2000);
    Debug.Log("Прошло ещё 2 секунды");
}

async UniTaskVoid UniTaskExample()
{
    Debug.Log("Начало");
    
    // Ждём точно 1 секунду, независимо от кадров
    await UniTask.Delay(1000);
    Debug.Log("После 1 секунды");
    
    // Ждём 1 кадр
    await UniTask.Yield();
    Debug.Log("Следующий кадр");
    
    // Ждём до конца кадра (аналог WaitForEndOfFrame)
    await UniTask.WaitForEndOfFrame();
    Debug.Log("Конец кадра");
    
    // Ждём условия (аналог WaitUntil)
    await UniTask.WaitUntil(() => Input.GetKeyDown(KeyCode.Space));
    Debug.Log("Клавиша пробел нажата");
}

async UniTaskVoid AdvancedAsyncExample()
{
    try
    {
        Debug.Log("Начинаем загрузку данных");
        
        // Запускаем два асинхронных процесса параллельно
        UniTask<GameData> gameDataTask = LoadGameDataAsync();
        UniTask<PlayerData> playerDataTask = LoadPlayerDataAsync();
        
        // Ждём завершения обоих процессов
        await UniTask.WhenAll(gameDataTask, playerDataTask);
        
        // Получаем результаты
        GameData gameData = await gameDataTask;
        PlayerData playerData = await playerDataTask;
        
        Debug.Log("Все данные загружены успешно");
        InitializeGame(gameData, playerData);
    }
    catch (Exception e)
    {
        Debug.LogError($"Произошла ошибка при загрузке: {e.Message}");
        ShowErrorScreen();
    }
}
 
async UniTask<GameData> LoadGameDataAsync()
{
    // Симуляция загрузки с задержкой
    await UniTask.Delay(1500);
    
    if (Random.value < 0.1f) // 10% шанс ошибки
        throw new Exception("Не удалось подключиться к серверу");
    
    return new GameData();
}
 
async UniTask<PlayerData> LoadPlayerDataAsync()
{
    await UniTask.Delay(1000);
    return new PlayerData();
}

// Неправильно
while(true) {
    DoSomething();
    yield return new WaitForSeconds(1f);
}
 
// Правильно
WaitForSeconds delay = new WaitForSeconds(1f);
while(true) {
    DoSomething();
    yield return delay;
}