Коротко
Asteroids — аркада Atari (ноябрь 1979), где корабль поворачивается, разгоняется тягой и летит по инерции, а астероиды при попадании дробятся на меньшие и быстрые. В коде на JavaScript тяга меняет скорость, а не позицию, затухание считается по полураспаду и не зависит от частоты кадров, а все объекты переходят через край поля по остатку от деления. Столкновения через границу проверяются по кратчайшей разнице координат, а предел в 26 астероидов, как в оригинале, не даёт экрану переполниться.
Содержание
- Что такое Asteroids и что в нём программировать
- Поворот корабля: угол в радианах
- Тяга и инерция: скорость вместо позиции
- Затухание, которое не зависит от частоты кадров
- Переход через край и столкновения через границу
- Пули: время жизни и скорость корабля
- Дробление астероидов и предел на экране
- Ядро на JavaScript и проверка в Node.js
- Обвязка для браузера: клавиши и векторная отрисовка
- Практический сценарий: честное возрождение корабля
- Когда вам это не подойдёт
Что такое 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 px | 40 px/с | 20 |
| Средний | 20 px | 70 px/с | 50 |
| Малый | 10 px | 110 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/с. Шаги:
- Пауза. После гибели ждать 2 с: игрок видит, что произошло, а осколки успевают разлететься.
- Свободная зона. Возрождать, только когда
safeToRespawnне находит ни одного астероида в круге радиусом 120 px вокруг центра. Проверка — та жеtouchingс переходом через край, поэтому круг 120 px плюс радиус большого астероида 40 px дают границу 160 px: в 150 px от центра возрождение запрещено, в 170 px разрешено. - Запас по времени. Малый астероид сразу за границей зоны — в 130 px от центра (120 + 10) — коснётся корабля радиусом 12 px на расстоянии 22 px, то есть пролетит 108 px за 108 / 110 ≈ 0,98 с; большой (160 → 52 px) — за 108 / 40 = 2,7 с. Значит, у игрока около секунды, чтобы развернуться и выстрелить или включить тягу. Если в вашей игре астероиды быстрее, увеличьте радиус пропорционально скорости самого быстрого.
- Проверка. Добавить в тесты сценарий «большой астероид в 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.
Читайте также:
- Как сделать Змейку на JS: таймер шага, хвост, переход через край
- Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы
- Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»
- Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого