---
title: "Flappy-клон на JavaScript: генерация труб и честный хитбокс"
description: "Как написать клон Flappy Bird на JavaScript для школьного кружка или первого проекта: взмах птицы с фиксированным шагом, генерация труб с зерном и пределом перепада, чтобы проход всегда был достижим, честный круглый хитбокс против прямоугольника трубы и одно очко за трубу. Четыре ловушки показаны прогоном в Node.js 24, плюс обвязка для canvas на том же модуле."
slug: flappy-klon-na-javascript-generaciya-trub-i-chestnyj-hitboks
date: 2026-11-19
updated: 2026-11-19
scheduled_at: "2026-11-19T19:00:00+03:00"
rubric: praktika-i-uroki
tags: ["javascript", "hitboksy", "procedurnaya-generaciya", "novichkam", "shkolnikam"]
reading_time: 22
draft: false
summary: "Flappy Bird — мобильная игра Донга Нгуена (iOS, май 2013), где птица сама падает, а нажатие подбрасывает её между парами зелёных труб. В клоне на JavaScript взмах задаёт скорость, а не прибавляет её, трубы получают высоту зазора от генератора с зерном, а соседние зазоры не могут отличаться больше, чем птица успевает подняться. В нашем прогоне чисто случайная высота дала 2,3% пар выше этой оценки при 6 нажатиях в секунду, хитбокс по картинке 48×40 убивал птицу в 5,6 px от трубы, а очко в каждом кадре превратило 20 труб в 785 очков."
---

## Коротко

Клон Flappy Bird держится на четырёх правилах: птица падает с ускорением, а нажатие задаёт ей скорость вверх; высота нового зазора выбирается рядом с прошлой, чтобы птица успела до него подняться; птица сталкивается с трубами кругом чуть меньше нарисованного тела, а не прямоугольником картинки; очко начисляется один раз за трубу по флагу. В нашем прогоне на JavaScript чисто случайная высота дала 2,3% пар выше оценки подъёма для игрока, который жмёт до 6 раз в секунду, а предел перепада в 220 px — ни одной, и автопилот прошёл 500 труб на шести зёрнах. Тот же предел при ускорении труб до 180 px/с снова стал опасным: проверку трассы нужно повторять при каждой смене скорости.

## Содержание

1. Что такое Flappy Bird и что в нём программировать
2. Правила нашего клона
3. Физика птицы: взмах задаёт скорость
4. Генерация труб: зазор, разброс и предел перепада
5. Честный хитбокс: круг против прямоугольника трубы
6. Очки: одно за трубу
7. Код логики на JavaScript
8. Проверка в Node.js
9. Что показал прогон: четыре ловушки
10. Что не подтвердилось
11. Обвязка для браузера: canvas и ввод
12. Практический сценарий: трасса под новую скорость
13. Когда вам это не подойдёт

## Что такое Flappy Bird и что в нём программировать

Flappy Bird — мобильная игра вьетнамского программиста и художника Донга Нгуена (студия .Gears), где птица по имени Faby летит вправо между парами зелёных труб и падает, если игрок не касается экрана. По Wikipedia, версия для iOS вышла 24 мая 2013 года, для Android — 30 января 2014 года. Касание подбрасывает птицу вверх, за каждую пройденную пару труб даётся одно очко, столкновение с трубой или землёй заканчивает игру. Зазоры у всех труб одного размера и стоят на случайной высоте; медали выдаются за 10, 20, 30 и 40 очков.

Популярность пришла не сразу: в январе 2014 года игра возглавила список бесплатных приложений App Store в США. Идею, по словам Нгуена в интервью Polygon, подсказало подбрасывание мячика для пинг-понга ракеткой: держать его в воздухе как можно дольше. Если хотите сравнить, как отскок устроен в настоящем пинг-понге на JavaScript, — статья про [пинг-понг для двоих](/blog/ping-pong-na-javascript-ii-sopernika-i-podacha).

После снятия игры клонов стало так много, что Apple и Google, по Wikipedia, начали отклонять игры со словом Flappy в названии. А в феврале 2014 года Code.org выпустила уроки, где ученик собирает свой Flappy-клон. Для учебной задачи игра удобна: механик мало, и каждая ломается заметно.

Программировать во Flappy-клоне нужно пять вещей:

| Механика | Что хранить | Где ломается |
|---|---|---|
| Падение и взмах | `y`, `vy` птицы | взмах прибавляет скорость, прыжок зависит от частоты кадров |
| Поток труб | `x` и высота зазора каждой трубы | трубы создаются и удаляются в неудачный момент |
| Высота зазора | генератор с зерном | случайная высота даёт непроходимую пару |
| Столкновение | хитбокс птицы, прямоугольники трубы | хитбокс по размеру картинки |
| Очки | флаг `scored` у трубы | очко в каждом кадре |

### Где источники расходятся

Даты и сроки в источниках о Flappy Bird совпадают не везде, и мы называем расхождения прямо. В английской Wikipedia во вводной части сказано, что Нгуен сделал игру за несколько дней, а в разделе о разработке — за два-три дня; русская Wikipedia тоже пишет о нескольких днях. Дату снятия обе Wikipedia во вводной части называют 10 февраля 2014 года. В разделе о снятии английская статья уточняет: 8 февраля Нгуен написал в Twitter, что уберёт игру через 22 часа, и игру убрали точно в срок, а одна из ссылок этого раздела (TechnoBuffalo) датирована 9 февраля. Точный час снятия мы не нашли и пишем: 10 февраля 2014 года по Wikipedia.

Причины снятия тоже расходятся. Сам Нгуен в интервью Forbes объяснил, что игра стала вызывать зависимость. Вьетнамская Tuoi Tre News передавала версию о претензиях Nintendo, но представитель Nintendo, по данным The Wall Street Journal, это отрицал. Ещё одна спорная тема — заимствование: вьетнамские и французские издания сравнивали Flappy Bird с игрой Piou Piou vs. Cactus 2011 года, а Нгуен ответил её автору, что, по его мнению, не знал о ней. Платформы: в английской статье — iOS и Android, в русской карточке игры добавлен Windows Phone.

## Правила нашего клона

Наш клон — поле 400×600 px, птица стоит на месте по горизонтали, а трубы едут на неё справа налево. Все числа ниже — наши значения для примера, а не параметры игры Нгуена: подбирать их под Flappy Bird мы не пытались.

| Параметр | Значение | Зачем |
|---|---|---|
| Поле | 400×600 px, земля с y = 560 | столкновение с землёй — конец игры |
| Шаг физики | 1/60 с | одинаковый прыжок на любом мониторе |
| Гравитация | 1600 px/с² | птица падает с ускорением |
| Взмах | скорость 400 px/с вверх | высота одного взмаха |
| Падение не быстрее | 600 px/с | птица не разгоняется бесконечно |
| Птица | x = 100, тело — круг r = 15, картинка 48×40 | то, что видит игрок |
| Хитбокс птицы | круг r = 12 | то, чем птица сталкивается |
| Труба | ширина 64 px, зазор 140 px | проход для птицы |
| Шаг труб | 190 px | расстояние между левыми краями соседних труб |
| Центр зазора | от 100 до 460 px | зазор не уходит за край поля |
| Скорость труб | 150 px/с | время между трубами |

Главное число для генерации: в зазоре 140 px круг радиусом 12 свободен по высоте только на 116 px, всё остальное — касание трубы.

## Физика птицы: взмах задаёт скорость

Взмах должен не прибавлять скорость, а заменять её: `vy = −400 px/с` при каждом нажатии, чем бы птица ни занималась до этого. Если прибавлять, взмах при падении только притормозит птицу, и одно касание будет давать разный результат. При замене оно всегда одинаковое:

```text
при нажатии:   vy = −FLAP
каждый шаг:    vy = min(vy + GRAVITY · STEP, MAX_FALL)
               y  = y + vy · STEP
STEP = 1/60 с, FLAP = 400 px/с, GRAVITY = 1600 px/с², MAX_FALL = 600 px/с
```

В нашем прогоне один взмах поднимает птицу на 46,7 px, верхняя точка — через 15 шагов, а с места до 600 px/с птица разгоняется за 23 шага.

Шаг всегда один и тот же, 1/60 с, сколько бы кадров ни рисовал монитор: браузер, по MDN, вызывает отрисовку примерно с частотой экрана, а физика догоняет время целыми шагами. Почему с переменным `dt` высота прыжка зависит от компьютера и как устроен аккумулятор времени, разобрано в статье про [игровой цикл и столкновения AABB](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb); здесь мы его просто используем и отдельно не проверяем.

Потолок у нас не убивает, а останавливает птицу: это наш выбор, смерть от невидимой границы выглядит как ошибка игры.

## Генерация труб: зазор, разброс и предел перепада

Генератор труб выдаёт одно число — высоту центра зазора для следующей трубы, а всё остальное (ширина, размер зазора, шаг) постоянно. Новая труба появляется за правым краем, когда последняя отъехала на шаг труб, и удаляется, когда целиком ушла за левый край. Труб на экране одновременно немного, поэтому пул объектов здесь не нужен: создание и удаление по времени жизни подробно разобраны в статье про [спавн, удаление и пулы](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly).

Высоту берём из генератора с зерном `mulberry32`, как в статье про [случайность без несправедливости](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor). По MDN начальное зерно `Math.random` выбирает браузер, задать или сбросить его нельзя, а нам нужна одна и та же трасса при каждом запуске, чтобы проверять её скриптом.

### Почему чисто случайная высота опасна

Чисто случайная высота опасна тем, что соседние зазоры могут оказаться у разных краёв экрана, и птица не успеет подняться от одного к другому. Генератор `randomGaps` выбирает центр от 100 до 460 px независимо от прошлой трубы. Падать птица умеет быстро, а подниматься — только взмахами, поэтому опасен прежде всего подъём.

### Сколько птица успевает подняться между трубами

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

```text
нужный подъём  = (центр₁ − центр₂) − (ЗАЗОР − 2·r)
шагов между    = ⌊(ШАГ_ТРУБ − ШИРИНА − 2·r) / скорость / STEP⌋
пара проходима (оценка), если нужный подъём ≤ лучший подъём за эти шаги
```

Лучший подъём зависит от того, как часто игрок жмёт. Функция `climbLimit` перебирает, через сколько шагов делать каждый следующий взмах, и выбирает самый высокий результат. Наше допущение для живого игрока — не больше 6 нажатий в секунду, то есть между нажатиями не меньше 10 шагов; для сравнения считаем и 60 нажатий в секунду — взмах в каждом шаге.

При 150 px/с между трубами 40 шагов. При 6 нажатиях в секунду птица поднимается на 168,9 px, а значит, следующий зазор может быть выше прошлого не больше чем на 284,9 px. При 60 нажатиях — 248,9 и 364,9 px. Это оценка сверху: она говорит, какая пара непроходима для такого игрока в нашей модели, но не обещает, что остальные пройти легко.

### Предел перепада

Предел перепада — это правило генератора: новая высота выбирается не из всего диапазона, а в окне ±220 px вокруг прошлой, обрезанном краями поля. В коде это `limitedGaps`. 220 px мы взяли с запасом от оценки 284,9 px, а запас проверили автопилотом — он прошёл 500 труб на каждом из шести зёрен. Окно симметричное: падать птице легче, чем подниматься, но автопилот на случайной трассе однажды погиб и на спуске 323 px.

Разброс высоты остаётся: за восемь труб с зерном 20261119 центры зазоров прыгают от 198 до 430 px. Предел убирает только перепады, которые птице не взять.

## Честный хитбокс: круг против прямоугольника трубы

Честный хитбокс птицы — круг чуть меньше нарисованного тела, а не прямоугольник по размеру картинки. Трубы — это два прямоугольника: верхний от края поля до зазора и нижний от зазора до земли, и птица проверяется против каждого.

### Почему не по размеру картинки

Прямоугольник по размеру картинки включает прозрачные поля вокруг птицы, и игра засчитывает смерть, когда тело до трубы ещё не дотронулось. У нас картинка 48×40, а тело на ней — круг радиусом 15: в углах и по бокам картинки пусто. Если взять хитбоксом всю картинку, птица «бьётся» о воздух. Почему опасные объекты вообще делают меньше спрайта и на сколько их уменьшают — в статье про [патрулирование врагов и читаемые опасности](/blog/patrulirovanie-vragov-i-chitaemye-opasnosti); здесь та же идея применена к герою.

### Круг или уменьшенный прямоугольник

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

```text
nx = clamp(cx, left, right)
ny = clamp(cy, top, bottom)
касание, если (cx − nx)² + (cy − ny)² < r²
```

Прямоугольник против прямоугольника без поворота — это четыре сравнения AABB, как в MDN и в статье про [игровой цикл и столкновения](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb). Для птицы мы сравнили три варианта: круг r = 12, квадрат 24×24 и картинку 48×40. Круг удобен ещё и тем, что не меняется при наклоне птицы: если картинка наклоняется вслед за скоростью, круговой хитбокс поворачивать не нужно.

Проверить хитбокс глазами помогает отладочная отрисовка: в обвязке ниже клавиша H рисует круг поверх птицы, а полноценный оверлей с хитбоксами всех объектов описан в статье про [отладочный оверлей](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij). Хитбоксы атак, активные кадры и неуязвимость — тема отдельной статьи; во Flappy-клоне их нет.

## Очки: одно за трубу

Очко начисляется один раз за трубу: в момент, когда труба целиком ушла левее хитбокса птицы, у неё ставится флаг `scored`, и повторно её уже не считают. Без флага условие «птица правее трубы» истинно в каждом шаге после пролёта, и очко прибавляется в каждом шаге, пока труба не уйдёт с экрана. Как превращать очки в награду — серии, множители, рекорды — в статье про [очки и рекорды](/blog/ochki-mnozhiteli-serii-i-rekordy-kak-schitat-nagradu).

Порядок в шаге: сначала движение птицы и труб, потом очки, потом столкновение.

## Код логики на JavaScript

Логика — один модуль `flappy.mjs` без canvas и клавиш: в каждом шаге он получает только «было ли нажатие». Поэтому одну и ту же логику проверяет скрипт в Node.js и рисует браузер. Запуск — Node.js 24, модули ES (`.mjs`), без сторонних пакетов.

```js
// flappy.mjs — логика Flappy-клона: птица, трубы, хитбокс, очки (без canvas)
export const W = 400, H = 600, GROUND = 560;      // поле и верх земли, px
export const STEP = 1 / 60;                       // фиксированный шаг физики, с
export const GRAVITY = 1600, FLAP = 400, MAX_FALL = 600;   // px/с², px/с, px/с
export const BIRD_X = 100, BIRD_R = 12;           // птица стоит на месте по x; круг-хитбокс
export const BODY_R = 15;                         // нарисованное тело птицы, px
export const IMG_W = 48, IMG_H = 40;              // картинка птицы целиком, с прозрачными углами
export const PIPE_W = 64, GAP = 140, SPACING = 190;        // ширина трубы, зазор, шаг труб
export const MIN_C = 100, MAX_C = GROUND - 100;   // центр зазора: от 100 до 460 px
export const MAX_STEP = 220;                      // предел перепада соседних зазоров, px

export function mulberry32(seed) {                // генератор с зерном, как в статье 44
  return function () {
    seed |= 0; seed = (seed + 0x6D2B79F5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

// Генератор 1: каждая высота случайна сама по себе
export function randomGaps(seed) {
  const rnd = mulberry32(seed);
  return () => Math.round(MIN_C + rnd() * (MAX_C - MIN_C));
}

// Генератор 2: новая высота отличается от прошлой не больше чем на limit
export function limitedGaps(seed, limit = MAX_STEP) {
  const rnd = mulberry32(seed);
  let last = Math.round((MIN_C + MAX_C) / 2);
  return () => {
    const lo = Math.max(MIN_C, last - limit), hi = Math.min(MAX_C, last + limit);
    last = Math.round(lo + rnd() * (hi - lo));
    return last;
  };
}

export function createGame(nextGap, opts = {}) {
  return {
    nextGap,
    speed: opts.speed || 150,                     // скорость труб, px/с
    hitbox: opts.hitbox || 'circle',              // 'circle', 'box' (24×24) или 'image' (48×40)
    scoring: opts.scoring || 'once',              // 'once' — флаг у трубы, 'frame' — ошибка
    bird: { y: 300, vy: 0 },
    pipes: [], score: 0, steps: 0, alive: true,
  };
}

function spawnPipes(g) {                          // новая труба, когда последняя ушла на SPACING
  const last = g.pipes[g.pipes.length - 1];
  if (!last || last.x <= W - SPACING) {
    const x = last ? last.x + SPACING : W;
    g.pipes.push({ x: x, gap: g.nextGap(), scored: false });
  }
}

// Прямоугольники трубы: верхняя часть и нижняя часть до земли
export function pipeRects(p) {
  return [
    { x: p.x, y: 0, w: PIPE_W, h: p.gap - GAP / 2 },
    { x: p.x, y: p.gap + GAP / 2, w: PIPE_W, h: GROUND - (p.gap + GAP / 2) },
  ];
}

export function circleRect(cx, cy, r, b) {        // ближайшая к центру точка прямоугольника
  const nx = Math.max(b.x, Math.min(cx, b.x + b.w));
  const ny = Math.max(b.y, Math.min(cy, b.y + b.h));
  const dx = cx - nx, dy = cy - ny;
  return dx * dx + dy * dy < r * r;
}

export function boxRect(cx, cy, w, h, b) {        // AABB: четыре сравнения
  return cx - w / 2 < b.x + b.w && cx + w / 2 > b.x &&
         cy - h / 2 < b.y + b.h && cy + h / 2 > b.y;
}

export function distToPipe(y, p) {                // от центра птицы до ближайшей точки трубы
  return Math.min(...pipeRects(p).map(b => {
    const nx = Math.max(b.x, Math.min(BIRD_X, b.x + b.w));
    const ny = Math.max(b.y, Math.min(y, b.y + b.h));
    return Math.hypot(BIRD_X - nx, y - ny);
  }));
}

export function hits(kind, y, p) {
  return pipeRects(p).some(b =>
    kind === 'circle' ? circleRect(BIRD_X, y, BIRD_R, b) :
    kind === 'box' ? boxRect(BIRD_X, y, 24, 24, b) :
    kind === 'body' ? circleRect(BIRD_X, y, BODY_R, b) :
    boxRect(BIRD_X, y, IMG_W, IMG_H, b));
}

export function step(g, flap) {                   // один шаг 1/60 с; flap — было ли нажатие
  if (!g.alive) return;
  const b = g.bird;
  if (flap) b.vy = -FLAP;                         // взмах задаёт скорость, а не прибавляет
  b.vy = Math.min(b.vy + GRAVITY * STEP, MAX_FALL);
  b.y += b.vy * STEP;
  if (b.y < BIRD_R) { b.y = BIRD_R; b.vy = 0; }   // потолок не убивает, только держит
  spawnPipes(g);
  for (const p of g.pipes) p.x -= g.speed * STEP;
  for (const p of g.pipes) {
    if (g.scoring === 'frame') {
      if (p.x + PIPE_W < BIRD_X) g.score++;       // ошибка: +1 в каждом кадре после трубы
    } else if (!p.scored && p.x + PIPE_W < BIRD_X - BIRD_R) {
      p.scored = true; g.score++;                 // одно очко за трубу, флаг не даст второго
    }
  }
  while (g.pipes.length && g.pipes[0].x + PIPE_W < 0) g.pipes.shift();   // ушла за экран
  g.steps++;
  const hb = g.hitbox === 'box' ? 24 : g.hitbox === 'image' ? IMG_H : BIRD_R * 2;
  if (b.y + hb / 2 >= GROUND || g.pipes.some(p => hits(g.hitbox, b.y, p))) g.alive = false;
}

// Оценка сверху: на сколько пикселей центр следующего зазора может быть выше
// прошлого, если между трубами steps шагов, а жать можно не чаще раза в tap шагов
export function climbLimit(speed, tap) {
  const steps = Math.floor((SPACING - PIPE_W - 2 * BIRD_R) / speed / STEP);
  const rise = L => {                             // подъём за L шагов после одного взмаха
    let vy = -FLAP, y = 0;
    for (let i = 0; i < L; i++) { vy = Math.min(vy + GRAVITY * STEP, MAX_FALL); y += vy * STEP; }
    return -y;
  };
  const best = new Array(steps + 1).fill(-Infinity);
  best[0] = 0;                                    // лучший случай: взмах в первый же шаг
  let top = -Infinity;
  for (let t = 0; t < steps; t++) {
    if (best[t] === -Infinity) continue;
    for (let L = 1; t + L <= steps; L++) {        // следующий взмах через L шагов
      const h = best[t] + rise(L);
      if (t + L === steps) top = Math.max(top, h);
      else if (L >= tap) best[t + L] = Math.max(best[t + L], h);
    }
  }
  return { steps: steps, rise: top, maxUp: top + GAP - 2 * BIRD_R };
}

// Автопилот для проверки: держится у нижнего края зазора, а внутри трубы
// заранее поднимается к следующему зазору, если тот выше. Жмёт не чаще раза в tap шагов
export function autopilot(g, state, tap = 10) {
  const ahead = g.pipes.filter(p => p.x + PIPE_W > BIRD_X - BIRD_R);
  const low = p => p.gap + GAP / 2 - BIRD_R - 14; // выше нижнего края на два шага падения
  const high = p => p.gap - GAP / 2 + BIRD_R + 56; // ниже верхнего края на высоту взмаха
  let aim = ahead.length ? low(ahead[0]) : 300;
  if (ahead.length > 1 && ahead[0].x < BIRD_X + BIRD_R)
    aim = Math.max(high(ahead[0]), Math.min(aim, low(ahead[1])));
  state.cool = (state.cool || 0) - 1;
  if (state.cool <= 0 && g.bird.y > aim) { state.cool = tap; return true; }
  return false;
}
```

Автопилот в конце модуля нужен только для проверки: он держит птицу у нижнего края следующего зазора и жмёт не чаще заданного. Это не лучший игрок, а простое правило, и в прогоне видно, где его не хватает.

## Проверка в Node.js

Проверочный файл `test.mjs` запускает все сценарии по порядку: параметры, взмах, оценку подъёма и четыре ловушки. Строки вида «погиб после трубы» — это число пройденных труб для каждого из шести зёрен.

```js
// test.mjs — проверка в Node.js 24: node test.mjs
import * as F from './flappy.mjs';

const SEEDS = [1, 2, 3, 4, 5, 20261119];
const f1 = v => v.toFixed(1).replace('.', ',');
const pct = (a, b) => (a / b * 100).toFixed(1).replace('.', ',') + '%';

function course(makeGen, seed, n) {               // заранее выписанная трасса из n зазоров
  const gen = makeGen(seed), gaps = [];
  for (let i = 0; i < n; i++) gaps.push(gen());
  return gaps;
}
function play(gaps, opts, goal, tap, watch) {     // автопилот играет, пока не пройдёт goal труб
  let i = 0;
  const g = F.createGame(() => gaps[i++], opts), st = {};
  while (g.alive && g.score < goal) {
    const flap = F.autopilot(g, st, tap);
    F.step(g, flap);
    if (watch) watch(g, flap);
  }
  return g;
}

console.log('0) поле', F.W + '×' + F.H, 'px, земля y =', F.GROUND + ', шаг 1/60 с, гравитация', F.GRAVITY,
  'px/с², взмах', F.FLAP, 'px/с, падение не быстрее', F.MAX_FALL, 'px/с');
console.log('   труба', F.PIPE_W, 'px, зазор', F.GAP, 'px, шаг труб', F.SPACING, 'px, центр зазора от', F.MIN_C,
  'до', F.MAX_C, 'px; птица x =', F.BIRD_X + ', круг r =', F.BIRD_R + ', тело r =', F.BODY_R + ', картинка',
  F.IMG_W + '×' + F.IMG_H + '; свободно по высоте в зазоре:', F.GAP - 2 * F.BIRD_R, 'px');

// 1. Взмах и падение
const b = F.createGame(() => 280);
let apex = 1;
F.step(b, true);
while (b.bird.vy < 0) { F.step(b, false); apex++; }
const top = 300 - b.bird.y;
let fall = 0, v = 0;
while (v < F.MAX_FALL) { v = Math.min(v + F.GRAVITY * F.STEP, F.MAX_FALL); fall++; }
console.log('1) взмах: подъём', f1(top), 'px, шагов до верхней точки:', apex + '; разгон с места до', F.MAX_FALL, 'px/с, шагов:', fall);

// 2. Оценка: насколько выше может быть следующий зазор
for (const speed of [150, 180]) for (const tap of [10, 1]) {
  const c = F.climbLimit(speed, tap);
  console.log('2) трубы', speed, 'px/с, между нажатиями шагов ≥', tap, '(до', 60 / tap, 'в секунду): шагов между трубами', c.steps +
    ', подъём', f1(c.rise), 'px, следующий зазор выше не больше чем на', f1(c.maxUp), 'px');
}

// 3. Ловушка 1: случайная высота каждой трубы
const lim150 = F.climbLimit(150, 10).maxUp;
for (const [name, make] of [['случайная', F.randomGaps], ['с пределом ' + F.MAX_STEP, F.limitedGaps]]) {
  const gaps = course(make, 20261119, 10001);
  let over = 0, worst = 0;
  for (let i = 1; i < gaps.length; i++) {
    const up = gaps[i - 1] - gaps[i];
    if (up > lim150) over++;
    worst = Math.max(worst, up);
  }
  console.log('3) высота', name + ': из 10000 пар выше оценки', over, '(' + pct(over, 10000) + '), самый большой подъём', worst, 'px');
}
const deaths = [];
for (const seed of SEEDS) {
  const gaps = course(F.randomGaps, seed, 700);
  const g = play(gaps, {}, 500, 10);
  const up = gaps[g.score - 1] - gaps[g.score];
  deaths.push(g.score + ' (' + (up > 0 ? 'подъём ' + up : 'спуск ' + -up) + (up > lim150 ? ', выше оценки' : '') + ')');
}
console.log('   автопилот, случайная высота, погиб после трубы:', deaths.join('; '));
const fast = SEEDS.map(s => play(course(F.randomGaps, s, 700), {}, 500, 1).score);
console.log('   то же, до 60 нажатий в секунду:', fast.join(', '));
const okLim = SEEDS.map(s => play(course(F.limitedGaps, s, 700), {}, 500, 10).score);
console.log('   автопилот, предел', F.MAX_STEP, 'px, пройдено труб:', okLim.join(', '));

// 4. Ловушка 2: хитбокс по картинке
const img = SEEDS.map(s => play(course(F.limitedGaps, s, 700), { hitbox: 'image' }, 500, 10).score);
console.log('4) хитбокс 48×40 по картинке, погиб после трубы:', img.join(', '));
let first = null, imgOnly = 0, boxOnly = 0, circOnly = 0, steps = 0;
play(course(F.limitedGaps, 20261119, 700), {}, 500, 10, g => {
  steps++;
  const y = g.bird.y;
  const near = g.pipes.reduce((a, p) => F.distToPipe(y, p) < F.distToPipe(y, a) ? p : a);
  const body = F.hits('body', y, near);
  if (F.hits('image', y, near) && !body) {
    imgOnly++;
    if (!first) first = { score: g.score, step: g.steps, gap: F.distToPipe(y, near) - F.BODY_R };
  }
  if (F.hits('box', y, near) && !body) boxOnly++;
  if (F.hits('circle', y, near) && !body) circOnly++;
});
console.log('   500 труб, зерно 20261119, всего шагов', steps + '; картинка задевает трубу, а тело нет, шагов:', imgOnly);
console.log('   первый раз: шаг', first.step + ', пройдено труб', first.score + ', от тела до трубы', f1(first.gap), 'px');
console.log('   квадрат 24×24 задевает трубу без тела, шагов:', boxOnly + '; круг r = 12:', circOnly);

// 5. Ловушка 3: очки в каждом кадре
const gaps5 = course(F.limitedGaps, 20261119, 50);
let k = 0;
const bad = F.createGame(() => gaps5[k++], { scoring: 'frame' });
const good = play(gaps5, {}, 20, 10, (g, flap) => F.step(bad, flap));
console.log('5) пройдено 20 труб: очко по флагу —', good.score + ', +1 в каждом кадре —', bad.score);

// 6. Ловушка 4: скорость выросла, а предел остался в пикселях
for (const limit of [F.MAX_STEP, 160]) {
  const r = SEEDS.map(s => play(course(sd => F.limitedGaps(sd, limit), s, 700), { speed: 180 }, 500, 10).score);
  console.log('6) скорость 180 px/с, предел', limit, 'px, пройдено труб:', r.join(', '));
}

// 7. Зерно: та же трасса при повторе
const a = course(F.limitedGaps, 20261119, 8), c = course(F.limitedGaps, 20261119, 8);
console.log('7) зерно 20261119:', a.join(' '), '| повтор совпал:', a.join() === c.join());
```

**Вывод прогона:**

```text
0) поле 400×600 px, земля y = 560, шаг 1/60 с, гравитация 1600 px/с², взмах 400 px/с, падение не быстрее 600 px/с
   труба 64 px, зазор 140 px, шаг труб 190 px, центр зазора от 100 до 460 px; птица x = 100, круг r = 12, тело r = 15, картинка 48×40; свободно по высоте в зазоре: 116 px
1) взмах: подъём 46,7 px, шагов до верхней точки: 15; разгон с места до 600 px/с, шагов: 23
2) трубы 150 px/с, между нажатиями шагов ≥ 10 (до 6 в секунду): шагов между трубами 40, подъём 168,9 px, следующий зазор выше не больше чем на 284,9 px
2) трубы 150 px/с, между нажатиями шагов ≥ 1 (до 60 в секунду): шагов между трубами 40, подъём 248,9 px, следующий зазор выше не больше чем на 364,9 px
2) трубы 180 px/с, между нажатиями шагов ≥ 10 (до 6 в секунду): шагов между трубами 34, подъём 148,9 px, следующий зазор выше не больше чем на 264,9 px
2) трубы 180 px/с, между нажатиями шагов ≥ 1 (до 60 в секунду): шагов между трубами 34, подъём 211,6 px, следующий зазор выше не больше чем на 327,6 px
3) высота случайная: из 10000 пар выше оценки 231 (2,3%), самый большой подъём 356 px
3) высота с пределом 220: из 10000 пар выше оценки 0 (0,0%), самый большой подъём 220 px
   автопилот, случайная высота, погиб после трубы: 62 (подъём 295, выше оценки); 19 (подъём 336, выше оценки); 103 (подъём 299, выше оценки); 7 (спуск 323); 34 (подъём 257); 4 (подъём 278)
   то же, до 60 нажатий в секунду: 74, 19, 104, 7, 59, 172
   автопилот, предел 220 px, пройдено труб: 500, 500, 500, 500, 500, 500
4) хитбокс 48×40 по картинке, погиб после трубы: 5, 4, 2, 11, 2, 6
   500 труб, зерно 20261119, всего шагов 38075; картинка задевает трубу, а тело нет, шагов: 188
   первый раз: шаг 572, пройдено труб 6, от тела до трубы 5,6 px
   квадрат 24×24 задевает трубу без тела, шагов: 0; круг r = 12: 0
5) пройдено 20 труб: очко по флагу — 20, +1 в каждом кадре — 785
6) скорость 180 px/с, предел 220 px, пройдено труб: 110, 162, 33, 7, 16, 26
6) скорость 180 px/с, предел 160 px, пройдено труб: 500, 500, 500, 500, 500, 500
7) зерно 20261119: 310 232 198 393 216 270 430 386 | повтор совпал: true
```

## Что показал прогон: четыре ловушки

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

### Ловушка 1: чисто случайная высота

Чисто случайная высота дала 231 пару из 10000 (2,3%), где следующий зазор выше оценки в 284,9 px для 6 нажатий в секунду, а самый большой подъём — 356 px. Автопилот погиб после 62, 19, 103, 7, 34 и 4 труб. В трёх случаях — на подъёме выше оценки (295, 336 и 299 px), в одном — на спуске 323 px, ещё в двух — на подъёмах 257 и 278 px, которые оценка считает возможными. С пределом 220 px выше оценки 0 пар, самый большой подъём ровно 220 px, а автопилот прошёл 500 труб на всех шести зёрнах.

### Ловушка 2: хитбокс по размеру картинки

С хитбоксом 48×40 по картинке автопилот погиб после 5, 4, 2, 11, 2 и 6 труб на тех же шести трассах, которые с кругом прошёл до конца, по 500 труб. На зерне 20261119 за 38075 шагов картинка задевала трубу без касания тела в 188 шагах. Первый раз — на шаге 572, после 6 пройденных труб, когда от тела до трубы оставалось 5,6 px. Игрок видит, что птица пролетела мимо, а игра заканчивается.

### Ловушка 3: очко в каждом кадре

За 20 пройденных труб счёт по флагу — 20, а «+1 в каждом кадре, пока птица правее трубы» — 785. Нажатия у обеих игр одинаковые, отличается только строка начисления очков.

### Ловушка 4: скорость выросла, а предел остался в пикселях

Предел в 220 px подобран для 150 px/с, и при 180 px/с он перестаёт быть безопасным. Шагов между трубами становится 34 вместо 40, оценка подъёма падает до 264,9 px при 6 нажатиях в секунду, и автопилот гибнет после 110, 162, 33, 7, 16 и 26 труб. С пределом 160 px на той же скорости — 500 труб на всех шести зёрнах. Если скорость растёт по ходу игры (как строить такой рост — в статье про [кривую сложности](/blog/krivaya-slozhnosti-i-dinamicheskaya-podstrojka-novichok-i-opytnyj)), предел перепада должен зависеть от текущей скорости, а не стоять константой.

Зерно 20261119 дважды дало одни и те же восемь высот; на таком детерминизме строится и [повтор прохождения](/blog/povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya) целиком.

## Что не подтвердилось

Три ожидания прогон не подтвердил, и мы говорим об этом прямо.

1. **«Чисто случайная высота даёт строго непроходимую пару».** Для игрока, который жмёт до 60 раз в секунду, оценка — 364,9 px, а самый большой подъём из 10000 случайных пар — 356 px. Значит, оценка не нашла ни одной пары, непроходимой для такого игрока. Непроходимые пары появились только при нашем допущении о 6 нажатиях в секунду. При этом наш автопилот с 60 нажатиями всё равно гибнет после 74, 19, 104, 7, 59 и 172 труб: он не лучший игрок, и доказать проходимость случайной трассы этим прогоном нельзя.
2. **«Если предел ниже оценки, трасса безопасна».** Не так. При 150 px/с автопилот погибал на случайной трассе и на подъёмах 257 и 278 px — ниже оценки 284,9 px. При 180 px/с предел 220 px ниже оценки 264,9 px, а автопилот всё равно гибнет. Оценка говорит только, что невозможно в модели; безопасный предел подбирается проверкой.
3. **«Уменьшенный квадрат тоже убивает без касания».** Углы квадрата 24×24 чуть выходят за круг тела, и мы ждали ложных касаний. В прогоне на 500 труб — 0 шагов, как и у круга r = 12. Квадрат на такой трассе оказался честным; круг мы оставили, потому что его не нужно поворачивать вместе с птицей.

## Обвязка для браузера: canvas и ввод

Обвязка импортирует тот же `flappy.mjs`, что и проверка, и добавляет только ввод, цикл с фиксированным шагом и рисование — своих правил в ней нет.

```js
// main.mjs — обвязка для браузера: ввод, фиксированный шаг, отрисовка на canvas
import { W, H, GROUND, STEP, BIRD_X, BODY_R, BIRD_R, pipeRects,
  createGame, limitedGaps, step } from './flappy.mjs';

const canvas = document.querySelector('canvas');
const ctx = canvas.getContext('2d');
canvas.width = W; canvas.height = H;

let seed = 1, game = createGame(limitedGaps(seed));
let wantFlap = false, acc = 0, last = performance.now(), debug = false;

function press() {
  if (!game.alive) { seed++; game = createGame(limitedGaps(seed)); return; }
  wantFlap = true;                                // взмах применится в ближайшем шаге
}
addEventListener('keydown', e => {
  if (e.code === 'Space' && !e.repeat) { e.preventDefault(); press(); }
  if (e.code === 'KeyH') debug = !debug;          // показать хитбокс
});
canvas.addEventListener('pointerdown', press);

function draw() {
  ctx.fillStyle = '#7ec8e3'; ctx.fillRect(0, 0, W, H);
  ctx.fillStyle = '#3a9d3a';
  for (const p of game.pipes) for (const r of pipeRects(p)) ctx.fillRect(r.x, r.y, r.w, r.h);
  ctx.fillStyle = '#c8a165'; ctx.fillRect(0, GROUND, W, H - GROUND);
  ctx.fillStyle = '#f4d03f';                      // тело птицы: круг радиусом BODY_R
  ctx.beginPath(); ctx.arc(BIRD_X, game.bird.y, BODY_R, 0, Math.PI * 2); ctx.fill();
  if (debug) {                                    // честный хитбокс поверх картинки
    ctx.strokeStyle = '#d00';
    ctx.beginPath(); ctx.arc(BIRD_X, game.bird.y, BIRD_R, 0, Math.PI * 2); ctx.stroke();
  }
  ctx.fillStyle = '#000'; ctx.font = '24px sans-serif';
  ctx.fillText('Очки: ' + game.score, 12, 32);
  if (!game.alive) ctx.fillText('Пробел или касание — заново', 12, 64);
}

function frame(now) {
  acc += Math.min((now - last) / 1000, 0.25);     // после фоновой вкладки не больше 15 шагов
  last = now;
  while (acc >= STEP) {
    step(game, wantFlap);
    wantFlap = false;
    acc -= STEP;
  }
  draw();
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);
```

Положите `flappy.mjs` и `main.mjs` рядом, подключите `main.mjs` к странице с одним элементом `canvas` как модуль и откройте страницу через локальный сервер: руководство MDN по модулям JavaScript советует именно так. Детали, которые легко пропустить:

- **Нажатие, а не удержание.** Проверка `!e.repeat` по MDN отсекает автоповтор клавиши, иначе зажатый пробел машет крыльями сам.
- **Взмах в ближайшем шаге.** Нажатие только ставит `wantFlap`, а применяет его шаг физики: так взмах не зависит от того, в какой момент кадра пришло событие.
- **Фоновая вкладка.** По MDN `requestAnimationFrame` в большинстве браузеров приостанавливается в фоновой вкладке; при возврате время кадра обрезается, и игра не просчитывает разом сотни шагов.
- **Картинка вместо круга.** Если рисуете птицу спрайтом, хитбокс остаётся кругом из `flappy.mjs`; как не размыть пиксельный спрайт при увеличении — в статье про [пиксель-арт в браузере](/blog/piksel-art-v-brauzere-bez-razmytiya).

Синтаксис обвязки проверен командой `node --check`.

## Практический сценарий: трасса под новую скорость

Задача: после первых труб игра ускоряет трубы со 150 до 180 px/с, и нужно, чтобы трасса осталась проходимой для игрока, который жмёт не чаще 6 раз в секунду. Шаги:

1. **Посчитать оценку.** `climbLimit(180, 10)` даёт 34 шага между трубами и 264,9 px — больше этого зазор в нашей модели не может быть выше прошлого.
2. **Взять предел с запасом.** Первая попытка — оставить 220 px, ведь это меньше 264,9.
3. **Прогнать автопилот.** Шесть зёрен по 500 труб на скорости 180 px/с. С пределом 220 px — гибель после 110, 162, 33, 7, 16 и 26 труб.
4. **Уменьшить предел и повторить.** С пределом 160 px — 500 труб на всех шести зёрнах.
5. **Записать предел в таблицу скоростей.** Для 150 px/с — 220 px, для 180 px/с — 160 px; генератор берёт предел по текущей скорости.

Проверяемый итог: строка «скорость 180 px/с, предел 160 px» в выводе прогона показывает 500 на всех шести зёрнах. Если меняете гравитацию, силу взмаха, размер зазора или шаг труб, повторяйте шаги 1–4: оценка и предел зависят от всех этих чисел.

## Когда вам это не подойдёт

Круг, флаг очков и предел перепада хороши для Flappy-клона и похожих игр «одна кнопка — один объект»; вот где их мало:

- **Сложная форма героя.** Если у персонажа длинный хвост, крылья или оружие, которыми он должен задевать препятствия, одного круга мало: нужны несколько кругов или прямоугольников.
- **Уровни, нарисованные вручную.** Если трассу расставляет дизайнер, генератор не нужен, а проходимость проверяют тем же автопилотом по готовым данным.
- **Таблица рекордов на сервере.** Счёт, посчитанный в браузере, можно подделать; что с этим делать — в статье про [таблицу рекордов](/blog/tablica-rekordov-sortirovka-nichi-i-pochemu-schet-na-kliente-mozhno-poddelat).
- **Очень быстрые объекты.** Если за один шаг объекты сдвигаются друг относительно друга больше, чем на толщину препятствия вместе с хитбоксом героя, проверка в конце шага пропустит касание; это разбирается в статье про [туннелирование быстрых объектов](/blog/tunnelirovanie-bystryh-obektov-swept-aabb-i-nepreryvnaya-proverka-stolknovenij).
- **Доказательство проходимости.** Оценка находит только заведомо непроходимые пары, а автопилот показывает только то, что прошёл он сам. Строгая гарантия требует перебора всех нажатий, а для длинной трассы это намного дороже.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=flappy-klon-na-javascript-generaciya-trub-i-chestnyj-hitboks) (подача заявки не гарантирует приглашение).

**Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200):** [Wikipedia — Flappy Bird](https://en.wikipedia.org/wiki/Flappy_Bird) (Донг Нгуен и .Gears; iOS — 24 мая 2013, Android — 30 января 2014; правила, одно очко за пару труб, медали за 10, 20, 30 и 40 очков; несколько дней и два-три дня разработки по разным разделам; пинг-понг как источник идеи по Polygon; январь 2014 — первое место среди бесплатных в App Store США; 8 февраля — объявление о снятии через 22 часа, 10 февраля 2014 — снятие; Forbes, Tuoi Tre News и опровержение Nintendo в WSJ; Piou Piou vs. Cactus; отказ Apple и Google принимать игры со словом Flappy; уроки Code.org, февраль 2014); [Википедия — Flappy Bird](https://ru.wikipedia.org/wiki/Flappy_Bird) (дата снятия 10 февраля 2014; разработка за несколько дней; Windows Phone в списке платформ); [MDN — 2D collision detection](https://developer.mozilla.org/en-US/docs/Games/Techniques/2D_collision_detection) (AABB четырьмя сравнениями, столкновение кругов, хитбокс как простая форма вместо точного контура); [MDN — Math.random()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) (зерно выбирает реализация, задать или сбросить его нельзя); [MDN — Window.requestAnimationFrame()](https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame) (приостановка в фоновых вкладках); [MDN — KeyboardEvent.repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) (автоповтор зажатой клавиши); [MDN — JavaScript modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules) (запуск примеров через локальный сервер). Поле, параметры птицы и труб, допущение о 6 нажатиях в секунду, автопилот и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.

**Читайте также:**
- [Игровой цикл (Game Loop) и физика столкновений (AABB, хитбоксы и триггеры) простыми словами и на уровне профи](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb)
- [Патрулирование врагов и читаемые опасности: как настроить честные столкновения и окно предупреждения](/blog/patrulirovanie-vragov-i-chitaemye-opasnosti)
- [Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor)
- [Кривая сложности и динамическая подстройка: как не потерять ни новичка, ни опытного](/blog/krivaya-slozhnosti-i-dinamicheskaya-podstrojka-novichok-i-opytnyj)
- [Отладочный оверлей на JavaScript: хитбоксы, FPS и журнал событий](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij)
