Один ENTER_FRAME на весь проект

Один ENTER_FRAME на весь проектцентральный игровой цикл в AS3 и его наследник в JavaScript

Сотня слушателей кадра тормозит, путает порядок обновления и течёт памятью. Собираем один цикл с очередью подписчиков и delta time, а потом переносим его на requestAnimationFrame.

Раздел
ActionScript 3
Стек
ActionScript 3TypeScriptrequestAnimationFrame
Уровень
Средний
Опубликовано
Обновлено
Чтение
8 мин
Коротко
  • Один слушатель кадра вместо сотни: быстрее и порядок явный.
  • Добавление и удаление объектов применяйте вне обхода.
  • Скорость считайте от времени, dt ограничивайте сверху.
  • В браузере: один rAF-цикл и фиксированный шаг симуляции.
Как решаем
  1. Заведите интерфейс с методом tick(dt) или update(dt)
  2. Подпишите на кадр только центральный цикл
  3. Копите add/remove в очередях и применяйте в начале кадра
  4. Считайте dt через getTimer() и ограничьте его 0,25 с
  5. В JS симулируйте фиксированным шагом, рисуйте с alpha

Проблема: сто слушателей одного события#

В типичном Flash-проекте каждый движущийся объект подписывался на кадр сам: в конструкторе addEventListener(Event.ENTER_FRAME, onFrame), в onFrame немного логики. Пока объектов десяток, всё работает. Когда их сотни, начинаются неприятности.

  • Накладные расходы на рассылку. Плеер создаёт и рассылает событие каждому подписчику отдельно, и на каждый вызов уходит время.
  • Непредсказуемый порядок. Нельзя гарантировать, что физика обновится раньше камеры, а камера раньше интерфейса.
  • Утечки. Забытый removeEventListener держит удалённый со сцены объект в памяти, и он продолжает считать что-то в фоне.
  • Нет паузы. Чтобы остановить игру, приходится обходить все объекты и отписывать каждый.

Решение простое: один слушатель ENTER_FRAME на весь проект и центральный цикл, который сам вызывает update() у зарегистрированных объектов. Этот совет входит и в наш список 20 приёмов оптимизации ActionScript, здесь разберём его подробно.

Центральный цикл на ActionScript 3#

Нам нужны три вещи: интерфейс для подписчиков, очередь, в которой можно безопасно добавлять и удалять объекты прямо во время обхода, и расчёт прошедшего времени (delta time) через getTimer().

ActionScript 3
// engine/ITickable.as
package engine {
    public interface ITickable {
        function tick(dt:Number):void;
    }
}

// engine/GameLoop.as
package engine {
    import flash.display.Stage;
    import flash.events.Event;
    import flash.utils.getTimer;

    public final class GameLoop {
        private var _items:Vector.<ITickable> = new Vector.<ITickable>();
        private var _pending:Vector.<ITickable> = new Vector.<ITickable>();
        private var _removed:Vector.<ITickable> = new Vector.<ITickable>();
        private var _last:int;
        private var _stage:Stage;
        public var paused:Boolean = false;

        public function GameLoop(stage:Stage) {
            _stage = stage;
            _last = getTimer();
            _stage.addEventListener(Event.ENTER_FRAME, onFrame);
        }

        public function add(t:ITickable):void { _pending.push(t); }
        public function remove(t:ITickable):void { _removed.push(t); }

        private function onFrame(e:Event):void {
            var now:int = getTimer();
            var dt:Number = (now - _last) / 1000;
            _last = now;
            if (dt > 0.25) dt = 0.25;   // защита после зависания

            flush();
            if (paused) return;

            var n:int = _items.length;
            for (var i:int = 0; i < n; i++) {
                _items[i].tick(dt);
            }
        }

        private function flush():void {
            var t:ITickable;
            while (_pending.length) _items.push(_pending.shift());
            while (_removed.length) {
                t = _removed.pop();
                var idx:int = _items.indexOf(t);
                if (idx >= 0) _items.splice(idx, 1);
            }
        }

        public function dispose():void {
            _stage.removeEventListener(Event.ENTER_FRAME, onFrame);
            _items.length = 0;
        }
    }
}

Добавления и удаления копятся в отдельных очередях и применяются в начале кадра. Так объект может удалить сам себя внутри tick(), и обход не пропустит соседа и не выйдет за границы вектора.

Delta time вместо счёта кадров#

Флеш-ролик с frameRate = 30 на слабом компьютере легко выдавал 20 кадров в секунду. Если персонаж смещается на 5 пикселей за кадр, его скорость зависит от мощности машины. Поэтому tick() получает dt в секундах, а скорость задаётся в пикселях в секунду: x += speed * dt.

Ограничение dt сверху (у нас 0,25 секунды) защищает от скачка после того, как пользователь переключился на другое окно или плеер подвис на загрузке. Без него объект за один кадр пролетает сквозь стену.

Порядок обновления тоже стал явным. Если нужно, чтобы ввод обрабатывался до физики, а камера после неё, заведите несколько списков (фаз) и обходите их по очереди. Это гораздо надёжнее, чем приоритеты в addEventListener.

На практике нам хватало четырёх фаз: ввод, логика и физика, камера, интерфейс. Каждая фаза хранит свой вектор подписчиков, а GameLoop обходит их строго по порядку. Объект при регистрации сам указывает фазу, например loop.add(this, Phase.PHYSICS). Если позже понадобится, скажем, обновлять частицы после камеры, это правка в одном месте, а не поиск по проекту всех вызовов addEventListener.

Ещё одна тонкость: getTimer() возвращает миллисекунды целым числом, поэтому при 60 кадрах в секунду dt прыгает между 16 и 17 мс. Для логики игры это незаметно. Если же на dt завязана точная синхронизация с музыкой, усредняйте значение по нескольким кадрам или берите позицию звука из SoundChannel.position.

Пауза, замедление и отладка в одной точке#

Когда цикл один, многие задачи, которые раньше требовали обхода всех объектов, решаются одной строкой. Мы держим в классе цикла три поля: флаг паузы, множитель времени и счётчик кадров.

  • Пауза. Флаг paused проверяется до обхода списка. Анимации меню живут в отдельной фазе, которая обновляется всегда.
  • Замедление времени. Эффект «slow motion» делается умножением dt на коэффициент, например 0,3. Ни один объект об этом не знает.
  • Пошаговая отладка. В режиме разработки цикл можно остановить и продвигать по одному кадру клавишей. Так удобно ловить ошибки столкновений, которые на полной скорости не разглядеть.
  • Профилирование. Замер времени каждой фазы через getTimer() сразу показывает, кто съедает бюджет кадра: физика, ИИ противников или интерфейс.

Второе преимущество менее очевидно: объект, который не зарегистрирован в цикле, гарантированно не тратит процессор. При удалении со сцены достаточно вызвать loop.remove(this), и это единственная отписка, о которой нужно помнить. Сравните с проектом, где у каждого клипа свой ENTER_FRAME и где для поиска утечки приходится просматривать весь код.

Сам класс цикла лучше создавать один раз при старте приложения и передавать зависимостью, а не делать глобальным синглтоном. Тогда в тестах можно подставить ручной цикл и вызывать tick() с нужным dt без сцены и таймеров.

Что изменилось к 2026 году#

Flash Player не поддерживается с 31 декабря 2020 года, а сама идея перешла в браузер почти без изменений. Аналог ENTER_FRAME там requestAnimationFrame: браузер вызывает колбэк перед отрисовкой и передаёт отметку времени в миллисекундах. Отличия, которые стоит знать:

ВопросFlash, ENTER_FRAMEБраузер, requestAnimationFrame
ЧастотаЗадаётся stage.frameRateСовпадает с частотой экрана: 60, 120, 144 Гц и другие
ПодпискаПостоянная, до отпискиОдноразовая, колбэк перезапрашивает себя
ВремяgetTimer()Аргумент колбэка или performance.now()
Фоновая вкладкаПлеер сильно замедлялсяКолбэки приостанавливаются

Из-за разной частоты экранов в 2026 году делать физику на переменном dt рискованно: на мониторе 144 Гц и на телефоне 60 Гц столкновения дают разный результат. Поэтому в современном цикле симуляция идёт фиксированным шагом, а отрисовка как получится, с интерполяцией между двумя состояниями.

Есть и обратная сторона: если колбэк кадра не укладывается в бюджет, браузер просто пропускает отрисовку, и пользователь видит рывок. Поэтому центральный цикл в 2026 году так же полезен, как во Flash: он даёт одно место, где видно, сколько миллисекунд уходит на каждую фазу.

Один цикл с фиксированным шагом на TypeScript#

JavaScript
interface Tickable {
  update(dt: number): void;          // фиксированный шаг, секунды
  render?(alpha: number): void;      // 0..1, доля до следующего шага
}

export class Loop {
  private items = new Set<Tickable>();
  private readonly step = 1 / 60;
  private acc = 0;
  private last = 0;
  private rafId = 0;

  add(t: Tickable) { this.items.add(t); }
  remove(t: Tickable) { this.items.delete(t); }

  start() {
    this.last = performance.now();
    this.rafId = requestAnimationFrame(this.frame);
  }

  stop() { cancelAnimationFrame(this.rafId); }

  private frame = (now: number) => {
    let dt = (now - this.last) / 1000;
    this.last = now;
    if (dt > 0.25) dt = 0.25;
    this.acc += dt;

    while (this.acc >= this.step) {
      for (const t of this.items) t.update(this.step);
      this.acc -= this.step;
    }

    const alpha = this.acc / this.step;
    for (const t of this.items) t.render?.(alpha);

    this.rafId = requestAnimationFrame(this.frame);
  };
}

document.addEventListener('visibilitychange', () => {
  // при возврате на вкладку не догоняем пропущенное время
  if (document.visibilityState === 'visible') loop.start();
  else loop.stop();
});

Здесь Set решает проблему, ради которой в AS3 мы заводили очереди: по спецификации элемент, удалённый во время обхода for...of, просто не будет посещён, а добавленный будет посещён в этом же проходе. Если вам важно, чтобы новые объекты начинали жить со следующего кадра, оставьте отложенную очередь, как в версии на ActionScript.

Ограничение dt по-прежнему нужно: иначе после долгой паузы цикл while попытается прогнать тысячи шагов симуляции подряд и подвесит вкладку. Для плавности движения внутри render комбинируйте прошлое и текущее положение объекта с коэффициентом alpha. Кривые для таких анимаций мы разбирали в заметке про easing в JS и AS.

Типичные ошибки при переходе на один цикл#

  • Несколько вызовов requestAnimationFrame из разных модулей. Это тот же десяток слушателей ENTER_FRAME, только в браузере. Все модули регистрируются в одном цикле.
  • Логика в setInterval. Таймер не синхронизирован с отрисовкой и даёт дрожание.
  • Тяжёлая работа в кадре. Поиск пути или разбор больших данных выносите в Web Worker, а в цикл передавайте готовый результат.
  • Позиции в пикселях за кадр. Код, перенесённый из старого Flash-проекта как есть, на экране 120 Гц двигает объекты вдвое быстрее. Переведите все скорости в единицы в секунду до переноса.
  • Чтение размеров DOM в цикле. Вызов getBoundingClientRect() после изменения стилей заставляет браузер пересчитать раскладку. Сначала прочитайте всё нужное, потом пишите.
  • Пауза через остановку цикла. Обычно удобнее флаг paused: интерфейс и анимация меню продолжают работать, а мир игры стоит.

Больше практики по браузерному коду в разделе JavaScript, а остальные заметки по Flash в ActionScript 3.

1слушатель кадра на весь проект
1/60 стипичный фиксированный шаг физики
0,25 спредел dt в наших примерах

«Порядок обновления должен быть записан в коде, а не зависеть от того, кто первым подписался на событие.»

Главный вывод заметки

Вопросы и ответы

Вопросы и ответы

Почему один слушатель быстрее, если код update всё равно выполняется для каждого объекта?
Экономится рассылка события: плеер не создаёт и не доставляет вызов каждому подписчику отдельно. Обычный цикл по вектору с прямым вызовом метода дешевле. Дополнительно вы получаете явный порядок обновления и одну точку для паузы.
Зачем ограничивать delta time?
После паузы, переключения вкладки или долгой загрузки прошедшее время может составить несколько секунд. Без ограничения объекты пролетят сквозь стены, а цикл с фиксированным шагом попытается выполнить тысячи шагов подряд и подвесит страницу.
Можно ли использовать setInterval вместо requestAnimationFrame?
Для анимации не стоит. Таймер не синхронизирован с обновлением экрана, поэтому движение дрожит, и он продолжает работать в фоновой вкладке. requestAnimationFrame вызывается перед отрисовкой и приостанавливается, когда вкладку не видно.
Нужен ли фиксированный шаг, если в игре нет физики?
Для простых анимаций интерфейса достаточно переменного dt. Фиксированный шаг важен там, где результат должен быть одинаковым на любых экранах: столкновения, сетевые игры, повторы. На мониторах 60 и 144 Гц переменный шаг даёт разную траекторию.
Заметка обновлена 12 ноября 2026: код проверен на актуальных версиях, добавлены современные варианты.

Читайте также