Asteroids на JavaScript: инерция, поворот корабля и дробление астероидов

Коротко

Asteroids — аркада Atari (ноябрь 1979), где корабль поворачивается, разгоняется тягой и летит по инерции, а астероиды при попадании дробятся на меньшие и быстрые. В коде на JavaScript тяга меняет скорость, а не позицию, затухание считается по полураспаду и не зависит от частоты кадров, а все объекты переходят через край поля по остатку от деления. Столкновения через границу проверяются по кратчайшей разнице координат, а предел в 26 астероидов, как в оригинале, не даёт экрану переполниться.

Содержание

  1. Что такое Asteroids и что в нём программировать
  2. Поворот корабля: угол в радианах
  3. Тяга и инерция: скорость вместо позиции
  4. Затухание, которое не зависит от частоты кадров
  5. Переход через край и столкновения через границу
  6. Пули: время жизни и скорость корабля
  7. Дробление астероидов и предел на экране
  8. Ядро на JavaScript и проверка в Node.js
  9. Обвязка для браузера: клавиши и векторная отрисовка
  10. Практический сценарий: честное возрождение корабля
  11. Когда вам это не подойдёт

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

Asteroids — аркадный автомат Atari, вышедший в Северной Америке в ноябре 1979 года; его придумали Лайл Рейнс и Эд Логг, программировал Логг. Игрок управляет треугольным кораблём: поворачивает его влево и вправо, стреляет прямо вперёд и включает тягу. Корабль продолжает лететь в выбранную сторону и без нажатий, а без тяги постепенно останавливается. Поле замкнуто по обеим осям: астероид, ушедший за верхний край, появляется снизу и летит дальше. При попадании астероиды распадаются на меньшие, которые быстрее, труднее попасть и дают больше очков.

Для разработчика это пять задач, каждая на 10–30 строк кода:

МеханикаЧто хранитьКак считать
Поворотangle в радианахangle += направление · скорость поворота · dt
Тяга и инерцияvx, vyк скорости прибавляется вектор по носу
Затуханиевремя полураспадамножитель 0,5 ^ (dt / T)
Переход через крайширина и высота поляостаток от деления и кратчайшая разница
Дроблениеразмер астероида 0, 1, 2два осколка следующего размера, предел 26

Все числа ниже — поле 800 × 600 px, скорости, радиусы и очки — наши значения для примера, а не параметры оригинального автомата, если не сказано иное.

Поворот корабля: угол в радианах

Направление корабля — одно число angle в радианах, а нос смотрит в точку (cos(angle), sin(angle)). Math.cos и Math.sin в JavaScript принимают именно радианы, поэтому градусы для них переводят умножением на π / 180. В canvas ось y направлена вниз, так что «нос вверх» — это −π / 2, то есть −90°.

Поворот — это скорость, умноженная на время кадра:

angle = angle + (вправо − влево) · ROT · dt
ROT = π рад/с = 180°/с  →  за 0,5 с поворот на 90°

В прогоне ниже корабль 30 кадров при 60 кадрах в секунду держит «влево»: нос уходит с −90° на −180°, то есть смотрит влево. Угол удобно не ограничивать диапазоном: синус и косинус дают те же значения для angle и angle + 2π.

Тяга и инерция: скорость вместо позиции

Инерция появляется сама, если клавиша тяги меняет скорость корабля, а позиция меняется только через скорость. Каждый кадр тяга добавляет к vx и vy вектор длиной THRUST · dt в сторону носа:

vx = vx + cos(angle) · THRUST · dt
vy = vy + sin(angle) · THRUST · dt
x  = x + vx · dt,   y = y + vy · dt

При THRUST = 200 px/с² за 1 с тяги корабль разгоняется до 200 px/с. Чтобы остановиться, его разворачивают носом назад и включают тягу: в нашем прогоне после разгона вправо до 200 px/с и 0,5 с тяги в обратную сторону корабль ещё летит вправо со скоростью 100 px/с. Именно это разделяет новичка и опытного игрока в Asteroids: нос и направление полёта — разные вещи.

Предел скорости — 300 px/с: если длина вектора Math.hypot(vx, vy) больше, вектор укорачивают до 300, не меняя направления. Без предела корабль, разогнанный на протяжении 5 с, пересекает поле 800 px быстрее чем за секунду, и управлять им уже нельзя.

Затухание, которое не зависит от частоты кадров

Затухание без тяги нужно задавать временем, за которое скорость падает вдвое, а не множителем на кадр. Частая запись v = v · 0,99 каждый кадр зависит от частоты обновления экрана. Наш прогон для скорости 100 px/с через 1 с:

Частота кадров× 0,99 за кадрПолураспад 1,5 с
60 Гц54,7 px/с63,0 px/с
144 Гц23,5 px/с63,0 px/с

На мониторе 144 Гц корабль с «× 0,99» тормозит более чем вдвое сильнее, чем на 60 Гц. Множитель по полураспаду даёт одно и то же при любом dt:

k = 0,5 ^ (dt / HALF_LIFE),   v = v · k
HALF_LIFE = 1,5 с:  через 1 с  0,5 ^ (1 / 1,5) ≈ 0,63  →  100 px/с → 63 px/с

За 1,5 с без тяги скорость падает с 200 до 100 px/с, а корабль пролетает 215,6 px. Для сравнения, точный интеграл 200 · 1,5 / ln 2 · (1 − 0,5) ≈ 216,4 px: разница 0,8 px — плата за шаг 1/60 с, она одинакова в каждом прогоне.

Переход через край и столкновения через границу

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

wrap(v, n)      = ((v mod n) + n) mod n       wrap(−3, 800) = 797,  wrap(805, 800) = 5
wrapDelta(d, n) = d − n · round(d / n)        wrapDelta(5 − 795, 800) = 10

Если сравнивать координаты напрямую, астероид в x = 5 и корабль в x = 795 разделяют 790 px, хотя на замкнутом поле между ними 10 px и они касаются. Поэтому проверка кругов берёт расстояние Math.hypot(wrapDelta(dx, W), wrapDelta(dy, H)) и сравнивает его с суммой радиусов.

Та же ошибка встретилась нам в собственной проверке. Первый прогон показал, что корабль «пролетел −384,4 px»: он поднялся выше верхнего края, его y перешёл с 0 на 600, и простое вычитание координат дало чушь. После замены на wrapDelta прогон показывает 215,6 px. Любое «насколько далеко» на таком поле — расстояние до цели, прицел врага, радиус взрыва — считается только через кратчайшую разницу.

Это не теоретическая мелочь. В автомате Asteroids тарелки умели целиться только в корабль на экране, но не через границу поля. Игроки нашли «засаду» (lurking): держаться у края напротив тарелки и стрелять через границу, оставив на поле 1–2 астероида, чтобы набирать очки почти без риска. Владельцы залов жаловались на потерю выручки, и Atari выпустила исправленную микросхему памяти с программой (EPROM).

Пули: время жизни и скорость корабля

Пуля летит по прямой, переходит через край, как всё остальное, и исчезает по времени жизни. Без времени жизни пуля на замкнутом поле летела бы вечно. У нас скорость пули 400 px/с и время жизни 1 с: 60 кадров и 400 px пути, ровно половина ширины поля: пуля не успевает облететь поле ни по ширине (800 px), ни по высоте (600 px) и вернуться к месту выстрела.

Скорость пули складывается из скорости корабля и 400 px/с вдоль носа. В прогоне корабль летит вбок со скоростью 300 px/с, нос смотрит вверх, и пуля получает 500 px/с по диагонали. Если не прибавлять скорость корабля, на полном ходу пули отстают от него и кажутся «кривыми». Удаление пуль и осколков во время обхода списков — отдельная тема, и в коде ниже обход идёт по копии списка, как в статье про спавн и удаление объектов.

Дробление астероидов и предел на экране

Попадание в астероид удаляет его, начисляет очки и создаёт два осколка следующего размера; малый астероид просто исчезает. У нас три размера:

РазмерРадиусСкоростьОчки (наши)
Большой40 px40 px/с20
Средний20 px70 px/с50
Малый10 px110 px/с100

Осколки разлетаются под ±0,5 рад (около ±29°) к курсу родителя плюс случайный разброс до ±0,2 рад. В прогоне с зерном 7 два средних осколка ушли курсом −35° и 38° со скоростью 70 px/с. Один большой астероид — это 1 + 2 + 4 = 7 попаданий и 20 + 2 · 50 + 4 · 100 = 520 очков; уровень из 4 больших — 28 попаданий.

Число осколков растёт вчетверо, поэтому нужен предел. В автомате Asteroids на экране одновременно не больше 26 астероидов: если их уже 26, большой даёт один средний вместо двух, а средний — один малый. Мы взяли тот же предел. В прогоне с 10 большими астероидами, где игрок бьёт сначала большие и средние, без предела понадобилось бы 70 попаданий, а с пределом — 56: на экране был пик ровно 26, и 14 раз осколок появлялся один.

Ядро на JavaScript и проверка в Node.js

Ядро не знает про клавиши и canvas: оно получает действия left, right, thrust, вызов fire и шаг времени dt. Случайность идёт через генератор с зерном, поэтому одинаковый ввод даёт одинаковую партию, и игру можно проверять скриптом в Node.js.

// asteroids.js — ядро Asteroids: инерция, поворот, переход через край, дробление
export const W = 800, H = 600;                         // поле, px
const ROT = Math.PI;                                   // поворот: π рад/с = 180°/с
const THRUST = 200, MAX_SPEED = 300;                   // px/с², px/с
const HALF_LIFE = 1.5;                                 // скорость без тяги падает вдвое за 1,5 с
const BULLET_SPEED = 400, BULLET_LIFE = 1;             // px/с, с
export const SIZES = [                                 // большой, средний, малый
  { r: 40, speed: 40, points: 20 },
  { r: 20, speed: 70, points: 50 },
  { r: 10, speed: 110, points: 100 },
];
export const MAX_ROCKS = 26;                           // предел одновременно живых астероидов

export const wrap = (v, n) => ((v % n) + n) % n;       // остаток от деления, работает и для −1
export const wrapDelta = (d, n) => d - n * Math.round(d / n);   // кратчайшая разница по оси

export function rng(seed) {                            // генератор с зерном: одинаковые прогоны
  let s = seed >>> 0;
  return () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 2 ** 32; };
}

export function createGame(seed = 1) {
  return {
    rand: rng(seed),
    ship: { x: W / 2, y: H / 2, vx: 0, vy: 0, angle: -Math.PI / 2, r: 12, alive: true },
    rocks: [], bullets: [], score: 0, events: [],
  };
}

export function addRock(g, x, y, size, angle) {
  if (g.rocks.length >= MAX_ROCKS) return false;
  const sp = SIZES[size].speed;
  g.rocks.push({ x, y, vx: Math.cos(angle) * sp, vy: Math.sin(angle) * sp, size, r: SIZES[size].r });
  return true;
}

export function stepShip(ship, input, dt) {            // input: { left, right, thrust }
  ship.angle += ((input.right ? 1 : 0) - (input.left ? 1 : 0)) * ROT * dt;
  if (input.thrust) {
    ship.vx += Math.cos(ship.angle) * THRUST * dt;     // тяга меняет скорость, а не позицию
    ship.vy += Math.sin(ship.angle) * THRUST * dt;
  } else {
    const k = Math.pow(0.5, dt / HALF_LIFE);           // затухание не зависит от частоты кадров
    ship.vx *= k; ship.vy *= k;
  }
  const sp = Math.hypot(ship.vx, ship.vy);
  if (sp > MAX_SPEED) { ship.vx *= MAX_SPEED / sp; ship.vy *= MAX_SPEED / sp; }
  ship.x = wrap(ship.x + ship.vx * dt, W);
  ship.y = wrap(ship.y + ship.vy * dt, H);
}

export function fire(g) {                              // пуля наследует скорость корабля
  const s = g.ship, c = Math.cos(s.angle), n = Math.sin(s.angle);
  g.bullets.push({ x: s.x + c * s.r, y: s.y + n * s.r,
    vx: s.vx + c * BULLET_SPEED, vy: s.vy + n * BULLET_SPEED, life: BULLET_LIFE });
}

export const touching = (a, b) =>                     // круги с учётом перехода через край
  Math.hypot(wrapDelta(a.x - b.x, W), wrapDelta(a.y - b.y, H)) < a.r + b.r;

export function splitRock(g, rock) {                   // попадание: очки и осколки
  g.score += SIZES[rock.size].points;
  g.rocks.splice(g.rocks.indexOf(rock), 1);
  if (rock.size === SIZES.length - 1) return 0;        // малый просто исчезает
  const base = Math.atan2(rock.vy, rock.vx);
  let made = 0;
  for (const turn of [-0.5, 0.5])                      // два осколка под ±0,5 рад к старому курсу
    if (addRock(g, rock.x, rock.y, rock.size + 1, base + turn + (g.rand() - 0.5) * 0.4)) made++;
  return made;
}

export function step(g, input, dt) {
  if (g.ship.alive) stepShip(g.ship, input, dt);
  for (const r of g.rocks) { r.x = wrap(r.x + r.vx * dt, W); r.y = wrap(r.y + r.vy * dt, H); }
  for (const b of g.bullets) { b.x = wrap(b.x + b.vx * dt, W); b.y = wrap(b.y + b.vy * dt, H); b.life -= dt; }
  g.bullets = g.bullets.filter(b => b.life > 0);
  for (const b of [...g.bullets]) {                    // копии списков: в обходе их меняем
    const hit = g.rocks.find(r => touching({ ...b, r: 2 }, r));
    if (hit) { b.life = 0; splitRock(g, hit); }
  }
  g.bullets = g.bullets.filter(b => b.life > 0);
  if (g.ship.alive && g.rocks.some(r => touching(g.ship, r))) { g.ship.alive = false; g.events.push('корабль разбит'); }
}

export function safeToRespawn(g, radius = 120) {       // возрождать в центре, только если рядом пусто
  const c = { x: W / 2, y: H / 2, r: radius };
  return !g.rocks.some(r => touching(c, r));
}

// ---- проверка в Node.js ----
const DT = 1 / 60, deg = a => Math.round(a * 180 / Math.PI), f1 = v => v.toFixed(1);
const ship = () => ({ x: 400, y: 300, vx: 0, vy: 0, angle: -Math.PI / 2, r: 12 });

// 1. Поворот: 30 кадров влево
let s = ship(); for (let i = 0; i < 30; i++) stepShip(s, { left: 1 }, DT);
console.log('1) поворот 0,5 с влево: нос', deg(-Math.PI / 2), '° →', deg(s.angle), '°');

// 2. Инерция: 1 с тяги вверх, потом 1,5 с без тяги
s = ship(); for (let i = 0; i < 60; i++) stepShip(s, { thrust: 1 }, DT);
const y1 = s.y; console.log('2) после 1 с тяги: скорость', f1(Math.hypot(s.vx, s.vy)), 'px/с');
for (let i = 0; i < 90; i++) stepShip(s, {}, DT);
console.log('   ещё 1,5 с без тяги: скорость', f1(Math.hypot(s.vx, s.vy)), 'px/с, пролетел', f1(-wrapDelta(s.y - y1, H)), 'px, y =', f1(s.y));

// 3. Разворот: тяга вправо 1 с, затем курс влево и тяга 0,5 с
s = ship(); s.angle = 0; for (let i = 0; i < 60; i++) stepShip(s, { thrust: 1 }, DT);
s.angle = Math.PI; for (let i = 0; i < 30; i++) stepShip(s, { thrust: 1 }, DT);
console.log('3) разворот носом назад, 0,5 с тяги: vx =', f1(s.vx), 'px/с — корабль ещё летит вправо');

// 4. Затухание за 1 с при 60 и 144 Гц: «умножить на 0,99 за кадр» против полураспада
for (const hz of [60, 144]) {
  let naive = 100; for (let i = 0; i < hz; i++) naive *= 0.99;
  const t = ship(); t.vx = 100; for (let i = 0; i < hz; i++) stepShip(t, {}, 1 / hz);
  console.log(`4) ${hz} Гц: 0,99 за кадр → ${f1(naive)} px/с; полураспад 1,5 с → ${f1(t.vx)} px/с`);
}

// 5. Переход через край и столкновение через край
console.log('5) wrap(-3, 800) =', wrap(-3, W), '| wrap(805, 800) =', wrap(805, W), '| wrapDelta(5 − 795) =', wrapDelta(5 - 795, W));
console.log('   круги r = 10 в x = 5 и x = 795 касаются:', touching({ x: 5, y: 300, r: 10 }, { x: 795, y: 300, r: 10 }));

// 6. Пуля: дальность и скорость корабля
let g = createGame(); fire(g); const b0 = { ...g.bullets[0] }; let frames = 0;
while (g.bullets.length) { step(g, {}, DT); frames++; }
console.log('6) пуля живёт', frames, 'кадров, путь', 400 * frames / 60, 'px = половина ширины поля');
g = createGame(); g.ship.vx = 300; fire(g);
console.log('   на скорости 300 px/с вбок пуля летит со скоростью', f1(Math.hypot(g.bullets[0].vx, g.bullets[0].vy)), 'px/с');

// 7. Дробление: один большой астероид до конца
g = createGame(7); addRock(g, 100, 100, 0, 0); let hits = 0;
while (g.rocks.length) { splitRock(g, g.rocks[0]); hits++; }
console.log('7) один большой: попаданий', hits, '| очков', g.score);
g = createGame(7); addRock(g, 100, 100, 0, 0); splitRock(g, g.rocks[0]);
console.log('   осколки:', g.rocks.map(r => `r=${r.r}, ${f1(Math.hypot(r.vx, r.vy))} px/с, курс ${deg(Math.atan2(r.vy, r.vx))}°`).join('; '));

// 8. Предел 26: 10 больших, бьём всегда первый в списке, считаем пик и одиночные осколки
g = createGame(3); for (let i = 0; i < 10; i++) addRock(g, 80 * i, 50, 0, i);
let peak = 0, single = 0, total = 0;
while (g.rocks.length) {
  const r = g.rocks.find(x => x.size < 2) || g.rocks[0];
  const made = splitRock(g, r); total++;
  if (r.size < 2 && made < 2) single++;
  peak = Math.max(peak, g.rocks.length);
}
console.log('8) 10 больших: пик', peak, 'из', MAX_ROCKS, '| попаданий', total, '| раз осколок один', single);

// 9. Безопасное возрождение
g = createGame(); addRock(g, 400 + 150, 300, 0, 0);
console.log('9) большой в 150 px от центра — можно возродить:', safeToRespawn(g));
g.rocks[0].x = 400 + 170; console.log('   в 170 px —', safeToRespawn(g));

// 10. Детерминизм: два прогона с одним зерном
const run = seed => { const q = createGame(seed); for (let i = 0; i < 4; i++) addRock(q, 100 + i * 150, 80, 0, q.rand() * 6.28);
  for (let i = 0; i < 600; i++) { if (i % 20 === 0) fire(q); step(q, { left: i % 120 < 60 ? 1 : 0, thrust: i % 90 < 30 ? 1 : 0 }, DT); }
  return `${q.score} очков, ${q.rocks.length} астероидов, корабль ${q.ship.alive ? 'цел' : 'разбит'}`; };
console.log('10) 10 с одного и того же ввода, зерно 42:', run(42), '| повтор совпал:', run(42) === run(42));

Вывод прогона (проверено в Node.js 24.22.1, 11.11.2026):

1) поворот 0,5 с влево: нос -90 ° → -180 °
2) после 1 с тяги: скорость 200.0 px/с
   ещё 1,5 с без тяги: скорость 100.0 px/с, пролетел 215.6 px, y = 582.8
3) разворот носом назад, 0,5 с тяги: vx = 100.0 px/с — корабль ещё летит вправо
4) 60 Гц: 0,99 за кадр → 54.7 px/с; полураспад 1,5 с → 63.0 px/с
4) 144 Гц: 0,99 за кадр → 23.5 px/с; полураспад 1,5 с → 63.0 px/с
5) wrap(-3, 800) = 797 | wrap(805, 800) = 5 | wrapDelta(5 − 795) = 10
   круги r = 10 в x = 5 и x = 795 касаются: true
6) пуля живёт 60 кадров, путь 400 px = половина ширины поля
   на скорости 300 px/с вбок пуля летит со скоростью 500.0 px/с
7) один большой: попаданий 7 | очков 520
   осколки: r=20, 70.0 px/с, курс -35°; r=20, 70.0 px/с, курс 38°
8) 10 больших: пик 26 из 26 | попаданий 56 | раз осколок один 14
9) большой в 150 px от центра — можно возродить: false
   в 170 px — true
10) 10 с одного и того же ввода, зерно 42: 210 очков, 7 астероидов, корабль цел | повтор совпал: true

Что показывают десять сценариев:

  • 1–3. Поворот и инерция. 0,5 с поворота — ровно 90°. После 1 с тяги скорость 200 px/с, ещё 1,5 с без тяги — 100 px/с и 215,6 px пути; корабль прошёл через верхний край и оказался в y = 582,8. Разворот с тягой 0,5 с только гасит половину скорости.
  • 4. Затухание. «× 0,99 за кадр» даёт 54,7 и 23,5 px/с при 60 и 144 Гц, полураспад — 63,0 px/с в обоих случаях.
  • 5. Край поля. wrap возвращает координаты в поле, а круги радиусом 10 px в x = 5 и x = 795 касаются через границу.
  • 6. Пули. 60 кадров жизни и 400 px пути; на скорости корабля 300 px/с вбок пуля летит со скоростью 500 px/с.
  • 7–8. Дробление. Один большой астероид — 7 попаданий и 520 очков; 10 больших с пределом 26 — 56 попаданий, 14 одиночных осколков.
  • 9. Возрождение. Большой астероид в 150 px от центра блокирует возрождение, в 170 px — уже нет (об этом ниже).
  • 10. Детерминизм. 10 с одного и того же ввода с зерном 42 дают одинаковую партию: 210 очков, 7 астероидов на поле, корабль цел.

Обвязка для браузера: клавиши и векторная отрисовка

Обвязка читает клавиши по KeyboardEvent.code, крутит ядро с фиксированным шагом 1/60 с и рисует всё линиями, как на векторном мониторе оригинала. Для браузера блок проверки в конце asteroids.js удалите или вынесите в отдельный файл.

// main.js — обвязка для браузера: клавиши, фиксированный шаг, векторная отрисовка
import { W, H, createGame, addRock, step, fire, safeToRespawn } from './asteroids.js';

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

const held = new Set();
let game = createGame(Date.now()), level = 0, deadFor = 0;
addEventListener('keydown', e => {
  held.add(e.code);
  if (e.code === 'Space' && !e.repeat && game.ship.alive && game.bullets.length < 4) fire(game); // не больше 4 пуль
});
addEventListener('keyup', e => held.delete(e.code));
const input = () => ({
  left: held.has('ArrowLeft') || held.has('KeyA'),
  right: held.has('ArrowRight') || held.has('KeyD'),
  thrust: held.has('ArrowUp') || held.has('KeyW'),
});

function nextLevel() {                                 // 4 больших на первом уровне, дальше +1
  level++;
  for (let i = 0; i < 3 + level; i++) addRock(game, game.rand() * W, 0, 0, game.rand() * Math.PI * 2);
}

function shape(x, y, angle, points) {                  // контур из точек, повёрнутый на angle
  ctx.beginPath();
  points.forEach(([px, py], i) => {
    const c = Math.cos(angle), s = Math.sin(angle);
    const X = x + px * c - py * s, Y = y + px * s + py * c;
    i ? ctx.lineTo(X, Y) : ctx.moveTo(X, Y);
  });
  ctx.closePath(); ctx.stroke();
}
function drawWrapped(o, draw) {                        // у края рисуем и копию с другой стороны
  for (const dx of [-W, 0, W]) for (const dy of [-H, 0, H]) {
    const x = o.x + dx, y = o.y + dy;
    if (x + o.r > 0 && x - o.r < W && y + o.r > 0 && y - o.r < H) draw(x, y);
  }
}

let acc = 0, last = performance.now();
function frame(now) {
  acc += Math.min(now - last, 250) / 1000; last = now;
  while (acc >= 1 / 60) {
    step(game, input(), 1 / 60); acc -= 1 / 60;
    if (!game.ship.alive && (deadFor += 1 / 60) > 2 && safeToRespawn(game)) {
      Object.assign(game.ship, { x: W / 2, y: H / 2, vx: 0, vy: 0, angle: -Math.PI / 2, alive: true });
      deadFor = 0;
    }
    if (game.rocks.length === 0) nextLevel();
  }

  ctx.fillStyle = '#000'; ctx.fillRect(0, 0, W, H);
  ctx.strokeStyle = '#fff'; ctx.fillStyle = '#fff';
  for (const r of game.rocks) drawWrapped(r, (x, y) => shape(x, y, 0,
    [0, 1, 2, 3, 4, 5, 6, 7].map(i => [Math.cos(i * 0.785) * r.r, Math.sin(i * 0.785) * r.r])));
  const s = game.ship;
  if (s.alive) drawWrapped(s, (x, y) => shape(x, y, s.angle, [[14, 0], [-10, -8], [-6, 0], [-10, 8]]));
  for (const b of game.bullets) ctx.fillRect(b.x - 1, b.y - 1, 2, 2);
  ctx.fillText(`Очки: ${game.score}  Уровень: ${level}`, 10, 16);
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

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

  • Выстрел по нажатию, а не по удержанию. Проверка !e.repeat не даёт автоповтору клавиатуры стрелять очередью, а предел в 4 пули на поле — наш выбор — заставляет целиться.
  • Копии у края. Функция drawWrapped рисует объект ещё раз с другой стороны поля, пока он пересекает границу: иначе у края видна только половина астероида, а в момент, когда центр переходит границу, он целиком «выпрыгивает» с другой стороны.
  • Ограничение 250 мс. После переключения вкладки игра просчитает разом не больше 15 шагов, а не сотни.

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

Практический сценарий: честное возрождение корабля

Задача: после гибели корабль должен возрождаться в центре так, чтобы не погибнуть в первую же секунду. Входные условия — поле 800 × 600 px, большой астероид радиусом 40 px летит со скоростью 40 px/с, малый — 110 px/с. Шаги:

  1. Пауза. После гибели ждать 2 с: игрок видит, что произошло, а осколки успевают разлететься.
  2. Свободная зона. Возрождать, только когда safeToRespawn не находит ни одного астероида в круге радиусом 120 px вокруг центра. Проверка — та же touching с переходом через край, поэтому круг 120 px плюс радиус большого астероида 40 px дают границу 160 px: в 150 px от центра возрождение запрещено, в 170 px разрешено.
  3. Запас по времени. Малый астероид сразу за границей зоны — в 130 px от центра (120 + 10) — коснётся корабля радиусом 12 px на расстоянии 22 px, то есть пролетит 108 px за 108 / 110 ≈ 0,98 с; большой (160 → 52 px) — за 108 / 40 = 2,7 с. Значит, у игрока около секунды, чтобы развернуться и выстрелить или включить тягу. Если в вашей игре астероиды быстрее, увеличьте радиус пропорционально скорости самого быстрого.
  4. Проверка. Добавить в тесты сценарий «большой астероид в 150 и в 170 px» и запускать его после каждого изменения радиусов и скоростей.

Проверяемый итог — сценарий 9 возвращает false и true, и в партии ни разу не бывает гибели раньше чем через 0,9 с после возрождения (по расчёту выше — не меньше 0,98 с). Сама пауза в 2 с — наше значение: в оригинале у корабля вместо этого есть гиперпространство, которое переносит его в случайную точку экрана с риском взорваться или появиться на астероиде.

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

Такое ядро Asteroids и простая физика подходят не всегда:

  • Точная физика. Здесь нет массы, отскоков астероидов друг от друга и вращения от удара: астероиды пролетают друг сквозь друга. Если это нужно, берите физический движок, а не самописный цикл.
  • Сотни объектов. Проверка «каждая пуля с каждым астероидом» при пределе 26 и 4 пулях — около сотни пар за кадр, это дёшево. Для тысяч объектов нужен пространственный хеш, а у замкнутого поля к нему добавляются клетки по краям.
  • Мир больше экрана. Переход через край подходит для поля, которое видно целиком. В большом мире с камерой края нет, и wrap придётся заменить на границы карты или подгрузку участков.
  • Сенсорные экраны. Схема «поворот + тяга + выстрел» на клавиатуре играется хорошо, а на телефоне с тремя экранными кнопками — заметно хуже; там лучше управление «лететь туда, куда указывает палец».

Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).

Источники (проверено: ноябрь 2026, 11.11.2026): Wikipedia — Asteroids (video game) (Atari, Северная Америка — ноябрь 1979; Лайл Рейнс и Эд Логг; поворот, выстрел вперёд и тяга, полёт по инерции и остановка без тяги; поле, замкнутое по обеим осям; осколки меньше, быстрее и дороже; гиперпространство; тарелки не целятся через границу, стратегия lurking и исправленный EPROM; предел 26 астероидов и один осколок при пределе; векторный монитор); MDN — Math.sin() (угол в радианах); MDN — KeyboardEvent: code property (физическая клавиша независимо от раскладки); MDN — JavaScript modules (import и export, запуск через локальный сервер). Размер поля, скорости, радиусы, очки, полураспад 1,5 с, пауза 2 с и радиус 120 px — наши значения; код и вывод — наш прогон в Node.js 24.

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

Частые вопросы

Как сделать инерцию корабля в JavaScript?

Храните у корабля скорость vx и vy и меняйте позицию только через неё. Тяга каждый кадр добавляет к скорости cos(угла) и sin(угла), умноженные на ускорение и dt, поэтому после отпускания тяги корабль продолжает лететь, а разворот носом назад сначала тормозит его.

Почему корабль тормозит по-разному на разных мониторах?

Обычно потому, что трение задано как «умножить скорость на 0,99 каждый кадр». За 1 с при 60 Гц от 100 px/с остаётся 54,7 px/с, а при 144 Гц — 23,5 px/с. Множитель 0,5 в степени dt / T, где T — время, за которое скорость падает вдвое, даёт одинаковый результат при любой частоте кадров.

Как проверить столкновение, если объект наполовину за краем экрана?

Считайте разницу координат с учётом перехода через край: d − n · round(d / n), где n — ширина или высота поля. Для точек в x = 5 и x = 795 на поле 800 px разница будет 10 px, а не 790, и столкновение не потеряется.

Что делать, если астероидов становится слишком много?

Поставьте предел на число одновременно живых астероидов. В автомате Asteroids он равен 26: при пределе большой астероид даёт один средний вместо двух. В нашем прогоне с 10 большими астероидами это сократило уровень с 70 до 56 попаданий.