Гонка с видом сверху на JavaScript: чекпойнты, круги и место в заезде

Коротко

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

Содержание

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

Что должна считать гонка

Гонке нужны три числа на каждую машину: сколько кругов она честно проехала, какие ворота ждёт следующими и какое у неё место. Всё остальное — руль, занос, отрисовка — к правилам заезда отношения не имеет и в этой статье почти не участвует.

Сам жанр подробно разобран в статье про гонки с видом сверху: вся трасса на одном экране, несколько машин, несколько кругов. Там же — расчёт обзора и общего кадра на двоих, здесь его повторять не будем. Нам из истории нужно только одно: уже в Gran Trak 10 (1974) на экране был счётчик пройденных контрольных точек, а в Super Sprint (1986) победитель определялся после трёх кругов. Счёт кругов и мест — ядро жанра с самого начала.

Важно не спутать слова. «Чекпойнт» в платформере — это точка сохранения, куда игрок возвращается после поражения; где их ставить и сколько стоит ошибка, разобрано в статье про контрольные точки в 2D-игре. В гонке чекпойнт — это ворота на трассе, которые нужно проехать, чтобы круг засчитали. Ничего не сохраняется и никто никуда не возвращается. Чтобы не путаться, дальше пишем «ворота».

Проверять будем по правилам, которые легко сформулировать словами:

  • круг засчитан, только если машина проехала все ворота по порядку и последней — линию финиша;
  • проезд ворот назад, повторный проезд тех же ворот и проезд «не тех» ворот круга не дают;
  • срезка, которая пропускает ворота, круга не даёт;
  • место — по пройденной дистанции, а не по координатам;
  • две машины в одном кадре на финише различаются по доле кадра.

Трасса как данные: кольцо и четверо ворот

Трасса в нашем примере — прямоугольное кольцо 400 × 300 px с газоном 200 × 100 px в центре и четырьмя воротами поперёк дороги. Машины едут по часовой стрелке. Ворота стоят посреди каждой прямой:

(0,0) ----------------------- финиш ---------------------- (400,0)
  |            верх: едем вправо   | x=200, y 0..100            |
  |      (100,100) +---------------+---------------+ (300,100)  |
  |                |                               |            |
  Ч3 ------------- |      газон 200 × 100 px       | ---------- Ч1
  y=150, x 0..100  |                               |  y=150, x 300..400
  |  левая: вверх  |                               | правая: вниз
  |      (100,200) +---------------+---------------+ (300,200)  |
  |            низ: едем влево     | x=200, y 200..300          |
(0,300) ----------------------- Ч2 ---------------------- (400,300)

Шаблон ворот, который можно копировать в свой формат уровня:

ПолеЧто значитПример
порядковый номерномер в массиве = порядок проезда, 0 — финиш0
nameподпись для отладки"финиш"
aконец отрезка у внутреннего края дороги (у газона){ x: 200, y: 100 }
bконец отрезка у внешнего края{ x: 200, y: 0 }

Порядок концов a и b — не мелочь: он задаёт, какое направление проезда считается «вперёд». Правило на всю трассу одно: при езде по часовой стрелке a всегда у газона, b — у внешней стены. Перепутаете концы у одних ворот — их будет можно проехать только задом, и круг не засчитается никогда. У нас это случилось при первом же прогоне: у ворот Ч1 и Ч3 концы стояли наоборот, и честный круг давал 0. Поэтому в проверочном файле первая строка — именно «честный круг».

Ворот четыре, а не сорок, потому что задача ворот — не мерить путь, а запрещать срезку. Ставьте их так, чтобы между соседними воротами не было короткого пути в обход трассы. На кольце с газоном хватает одних ворот на каждой прямой. На трассе со шпилькой или с двумя дорогами рядом через забор нужны ворота и в повороте.

Ворота — отрезок, а не точка

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

Вариант «в лоб» — точка в центре дороги и радиус: «если машина ближе 20 px к точке, чекпойнт пройден». У него две проблемы. Машина может проехать по краю дороги дальше радиуса и не получить ворота. А быстрая машина за один кадр может оказаться до точки и сразу после неё, ни разу не попав в круг. Отрезок от края до края дороги закрывает обе: объехать нельзя, перепрыгнуть за кадр нельзя.

Проверка строится на векторном произведении — одной формуле, которая говорит, с какой стороны от прямой лежит точка:

side(P) = (b.x − a.x) · (P.y − a.y) − (b.y − a.y) · (P.x − a.x)

side < 0 — точка до ворот, side ≥ 0 — после.
Шаг p → q пересёк прямую ворот, если знаки side(p) и side(q) разные.
Доля шага до пересечения: t = side(p) / (side(p) − side(q)), от 0 до 1.
Место на воротах: u — проекция точки пересечения на a → b, от 0 до 1.
Проезд засчитан, если 0 ≤ u ≤ 1. Вперёд — если side(p) < 0, назад — если side(p) ≥ 0.

Знак говорит о направлении, а u — о том, что машина проехала именно сквозь ворота, а не мимо них по продолжению линии. Вторую проверку легко забыть, потому что на вид всё работает. В прогоне ниже видно, чем это кончается: без проверки u машина, срезавшая через газон, получает ворота Ч1, к которым даже не подъезжала. Её путь пересёк прямую y = 150 в точке x = 250, а ворота Ч1 занимают только x от 300 до 400.

Доля шага t нужна для времени финиша с долей кадра; как связаны кадр и шаг движения, разобрано в статье про игровой цикл и столкновения.

Зачёт круга: ворота строго по порядку

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

состояние машины:  lap — кругов, next — номер ворот, которые ждём

каждый кадр:
  c = пересечение шага p → q с воротами GATES[next]
  если c не «вперёд» — ничего не делаем
  если next = 0 (финиш) — lap = lap + 1, запоминаем время
  next = (next + 1) по модулю числа ворот

Старт: машины стоят сразу за линией финиша, поэтому финиш уже позади и next = 1. Первый проезд линии — конец первого круга. Если ваша стартовая решётка стоит перед линией, начните с next = 0 и не прибавляйте круг за первый проезд — или начните с lap = -1.

Почему этого достаточно против хитростей:

Что делает машинаЧто происходит с nextИтог
Едет по трассе1 → 2 → 3 → 0 → 1круг засчитан
Срезает через газон мимо Ч1остаётся 1: Ч2, Ч3 и финиш — «не те» воротакруга нет, пока не вернётся к Ч1
Сдаёт назад через финиш и снова едет вперёдостаётся 1: финиш уже не ждуткруга нет
Едет весь круг задом наперёдостаётся 1: все ворота проезжаются назадкруга нет

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

Место в заезде: круги, ворота и доля пути

Место определяют по одному числу — прогрессу: круги × число ворот + пройденные на этом круге ворота + доля пути от последних ворот до следующих. Чем больше прогресс, тем выше место. Финишировавшие стоят выше всех, кто ещё едет, и сортируются по времени финиша.

прогресс = lap · N + пройдено_ворот_на_круге + f

N                     — число ворот (у нас 4)
пройдено_ворот        — (next − 1 + N) по модулю N
f                     — проекция позиции на отрезок «центр последних ворот → центр следующих»,
                        обрезанная до 0..0,999

Обрезка до 0,999 нужна, чтобы машина, которая стоит у самых ворот, но ещё их не пересекла, не сравнялась с той, что уже проехала. Ноль снизу — чтобы машина, сдавшая назад за последние ворота, не получила отрицательный прогресс и не обогнала саму себя в прошлом круге.

Наивное место — «кто ближе к своим следующим воротам» или «у кого больше x» — ломается в первый же заезд, где кто-то отстаёт. В прогоне ниже машина, отстающая на полкруга, стоит в 30 px от финиша и по наивной таблице оказывается первой: она ближе всех к своим воротам. То, что ворота у неё другие и круг другой, наивная сортировка не видит.

Проекция на отрезок между центрами соседних ворот — приближение. На прямых и плавных поворотах её хватает, чтобы различить машины, которые идут рядом. На трассе, где путь между воротами сильно петляет, прогресс в повороте может на мгновение «застыть» или скакнуть; лечится это дополнительными воротами в повороте или средней линией трассы — об этом в последнем разделе.

Финиш в одном кадре: время с долей кадра

Если две машины пересекли финиш в одном и том же кадре, их различают по доле кадра t, которую уже посчитала проверка ворот: время финиша = номер кадра − 1 + t. При 60 кадрах в секунду один кадр — около 16,7 мс, а машины, которые идут бампер к бамперу, расходятся меньше чем на один шаг. Две машины на финише в одном кадре — обычное дело для плотного заезда.

В нашем прогоне Красная (6 px за кадр) и Синяя (6,003 px за кадр) обе пересекают финиш на 499-м кадре. По номеру кадра это ничья. По доле кадра Синяя — 8,301 с, Красная — 8,306 с. Синяя первая, и это совпадает с тем, что она на 0,05 % быстрее.

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

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

Модуль ниже ничего не рисует: в нём ворота трассы, проверка пересечения, четыре счётчика кругов (три наивных и правильный), прогресс и таблица мест. Машины едут по заранее заданному пути — ломаной — с постоянной скоростью; это сценарий вместо руля, чтобы прогон был одинаковым при каждом запуске. Запуск — Node.js 24.22.1.

/** race.mjs — чекпойнты трассы, зачёт кругов и место в заезде */

// Трасса-кольцо 400 × 300 px, в центре газон 200 × 100 px.
// Ворота — отрезки поперёк дороги. Порядок в массиве = порядок проезда.
// a — внутренний край дороги (у газона), b — внешний. Едем по часовой стрелке:
// «вперёд» — переход с отрицательной стороны отрезка на положительную.
export const GATES = [
  { name: "финиш", a: { x: 200, y: 100 }, b: { x: 200, y: 0 } },   // верх, едем вправо
  { name: "Ч1", a: { x: 300, y: 150 }, b: { x: 400, y: 150 } },     // справа, едем вниз
  { name: "Ч2", a: { x: 200, y: 200 }, b: { x: 200, y: 300 } },     // низ, едем влево
  { name: "Ч3", a: { x: 100, y: 150 }, b: { x: 0, y: 150 } },       // слева, едем вверх
];

const cross = (ax, ay, bx, by) => ax * by - ay * bx;

// С какой стороны отрезка ворот стоит точка: < 0 — до ворот, >= 0 — после.
export function side(g, p) {
  return cross(g.b.x - g.a.x, g.b.y - g.a.y, p.x - g.a.x, p.y - g.a.y);
}

// Пересекло ли движение p → q ворота g за этот шаг.
// dir: 1 — вперёд, -1 — назад, 0 — нет; t — доля шага (0..1), где случилось пересечение.
// infinite = true — наивная проверка: ворота считаются бесконечной прямой.
export function crossGate(g, p, q, infinite = false) {
  const s0 = side(g, p), s1 = side(g, q);
  if ((s0 < 0) === (s1 < 0)) return { dir: 0, t: 0 };
  const t = s0 / (s0 - s1);
  const x = p.x + (q.x - p.x) * t, y = p.y + (q.y - p.y) * t;
  const gx = g.b.x - g.a.x, gy = g.b.y - g.a.y;
  const u = ((x - g.a.x) * gx + (y - g.a.y) * gy) / (gx * gx + gy * gy);
  if (!infinite && (u < 0 || u > 1)) return { dir: 0, t: 0 }; // мимо отрезка ворот
  return { dir: s0 < 0 ? 1 : -1, t };
}

// Ворота строго по порядку; круг — только когда ждали именно финиш.
function ordered(infinite) {
  return (car, p, q, tick) => {
    const c = crossGate(GATES[car.next], p, q, infinite);
    if (c.dir !== 1) return;
    if (car.next === 0) {
      car.lap++;
      car.lapAt.push(tick - 1 + c.t); // время в кадрах с долей кадра
    }
    car.next = (car.next + 1) % GATES.length;
  };
}

// Четыре способа считать круги: три наивных и правильный.
export const counters = {
  // 1. Любое пересечение линии финиша = круг.
  anyCross(car, p, q) {
    if (crossGate(GATES[0], p, q).dir !== 0) car.lap++;
  },
  // 2. Пересечение финиша вперёд = круг.
  forwardOnly(car, p, q) {
    if (crossGate(GATES[0], p, q).dir === 1) car.lap++;
  },
  // 3. Ворота по порядку, но каждые ворота — бесконечная прямая.
  orderedLine: ordered(true),
  // 4. Ворота по порядку, и пересечь нужно именно отрезок.
  ordered: ordered(false),
};

// Машина стартует сразу за линией финиша: ворота 0 уже позади, ждём Ч1.
export function newCar(name, path, speed) {
  return { name, path, speed, dist: 0, pos: { ...path[0] }, lap: 0, next: 1, lapAt: [], done: false };
}

// Точка на ломаной на расстоянии d от начала (сценарий вместо руля).
export function pointAt(path, d) {
  for (let i = 1; i < path.length; i++) {
    const a = path[i - 1], b = path[i];
    const len = Math.hypot(b.x - a.x, b.y - a.y);
    if (d <= len) return { x: a.x + (b.x - a.x) * d / len, y: a.y + (b.y - a.y) * d / len };
    d -= len;
  }
  return { ...path[path.length - 1] };
}

// Прогресс по трассе: круги, пройденные ворота и доля пути до следующих ворот.
const mid = (g) => ({ x: (g.a.x + g.b.x) / 2, y: (g.a.y + g.b.y) / 2 });
export function progress(car) {
  const n = GATES.length;
  const prev = mid(GATES[(car.next - 1 + n) % n]), next = mid(GATES[car.next]);
  const vx = next.x - prev.x, vy = next.y - prev.y;
  let f = ((car.pos.x - prev.x) * vx + (car.pos.y - prev.y) * vy) / (vx * vx + vy * vy);
  f = Math.min(Math.max(f, 0), 0.999);
  return car.lap * n + (car.next - 1 + n) % n + f;
}

// Наивное место: кто ближе к своим следующим воротам.
export function naiveOrder(cars) {
  const d = (c) => Math.hypot(c.pos.x - mid(GATES[c.next]).x, c.pos.y - mid(GATES[c.next]).y);
  return [...cars].sort((a, b) => d(a) - d(b)).map((c) => c.name);
}

// Правильное место: финишировавшие — по времени финиша, остальные — по прогрессу.
export function standings(cars) {
  return [...cars].sort((a, b) => {
    if (a.done && b.done) return a.lapAt[a.lapAt.length - 1] - b.lapAt[b.lapAt.length - 1];
    if (a.done !== b.done) return a.done ? -1 : 1;
    return progress(b) - progress(a);
  });
}

// Один кадр заезда: двигаем машины и считаем ворота выбранным счётчиком.
export function tick(cars, count, t, laps) {
  for (const car of cars) {
    if (car.done) continue;
    const p = car.pos;
    car.dist += car.speed;
    car.pos = pointAt(car.path, car.dist);
    count(car, p, car.pos, t);
    if (car.lap >= laps) car.done = true;
  }
}

Проверочный файл делает две вещи. Сначала прогоняет четыре сценария езды через каждый из четырёх счётчиков кругов. Потом устраивает заезд на 3 круга для четырёх машин и печатает наивную и правильную таблицу на 240-м кадре и итог финиша.

import { GATES, counters, newCar, tick, standings, naiveOrder, progress } from "./race.mjs";

const P = (x, y) => ({ x, y });
// Чистый круг по середине дороги: 990 px от старта до линии финиша.
const LAP = [P(350, 50), P(350, 250), P(50, 250), P(50, 50), P(210, 50)];
const laps = (k) => [P(210, 50)].concat(...Array(k).fill(LAP));

// 1. Кто сколько кругов «проехал» по мнению трёх счётчиков
const tests = {
  "честный круг": [P(210, 50), ...LAP, P(215, 50)],
  "срезал через газон": [P(210, 50), P(250, 50), P(250, 250), P(50, 250), P(50, 50), P(215, 50)],
  "круг задом наперёд": [P(210, 50), P(50, 50), P(50, 250), P(350, 250), P(350, 50), P(190, 50)],
  "ёрзает у финиша": [P(210, 50), P(190, 50), P(215, 50), P(190, 50), P(215, 50), P(190, 50), P(215, 50)],
};
for (const [name, path] of Object.entries(tests)) {
  const row = [];
  for (const k of ["anyCross", "forwardOnly", "orderedLine", "ordered"]) {
    const car = newCar(name, path, 4);
    for (let t = 1; t <= 400; t++) tick([car], counters[k], t, 99);
    row.push(k + "=" + car.lap);
  }
  console.log(name.padEnd(20), row.join("  "));
}

// 2. Заезд на 3 круга, 60 кадров в секунду
const cars = [
  newCar("Красная", laps(4), 6),
  newCar("Синяя", laps(4), 6.003),
  newCar("Жёлтая", laps(4), 5.5),
  newCar("Зелёная", laps(4), 4),
];
for (let t = 1; t <= 560; t++) {
  tick(cars, counters.ordered, t, 3);
  if (t === 240) {
    console.log("кадр 240, наивно:", naiveOrder(cars).join(", "));
    standings(cars).forEach((c, i) => console.log("  " + (i + 1) + ". " + c.name.padEnd(8) +
      " круг " + (c.lap + 1) + ", ждёт " + GATES[c.next].name + ", прогресс " + progress(c).toFixed(3)));
  }
}
console.log("финиш:");
standings(cars).forEach((c, i) => {
  const f = c.lapAt[c.lapAt.length - 1];
  console.log("  " + (i + 1) + ". " + c.name.padEnd(8) + (c.done
    ? " кадр " + Math.ceil(f) + ", время " + (f / 60).toFixed(3) + " с"
    : " на трассе, круг " + (c.lap + 1) + ", прогресс " + progress(c).toFixed(3)));
});

Вывод прогона (Node.js 24.22.1, node test.mjs):

честный круг         anyCross=1  forwardOnly=1  orderedLine=1  ordered=1
срезал через газон   anyCross=1  forwardOnly=1  orderedLine=1  ordered=0
круг задом наперёд   anyCross=2  forwardOnly=0  orderedLine=0  ordered=0
ёрзает у финиша      anyCross=6  forwardOnly=3  orderedLine=0  ordered=0
кадр 240, наивно: Зелёная, Синяя, Красная, Жёлтая
  1. Синяя    круг 2, ждёт Ч2, прогресс 5.773
  2. Красная  круг 2, ждёт Ч2, прогресс 5.769
  3. Жёлтая   круг 2, ждёт Ч2, прогресс 5.246
  4. Зелёная  круг 1, ждёт финиш, прогресс 3.862
финиш:
  1. Синяя    кадр 499, время 8.301 с
  2. Красная  кадр 499, время 8.306 с
  3. Жёлтая   кадр 544, время 9.061 с
  4. Зелёная  на трассе, круг 3, прогресс 9.000

Что показал прогон: три наивных счётчика и наивная таблица

Прогон показывает, что каждый наивный счётчик ломается на своей хитрости, и только счётчик «ворота по порядку и сквозь отрезок» даёт правильный ответ во всех четырёх сценариях. Сводка:

СценарийЛюбое пересечение финишаФиниш вперёдВорота по порядку, прямаяВорота по порядку, отрезокДолжно быть
Честный круг11111
Срезал через газон11100
Круг задом наперёд20000
Ёрзает у финиша63000

Что из этого следует:

  • Любое пересечение финиша — самая частая ошибка новичка: «машина коснулась линии — круг». Три поездки туда-обратно через финиш дали 6 кругов, круг задом наперёд — 2.
  • Проверка направления спасает от езды задом, но не от «ёрзания»: назад через линию — не считается, вперёд — считается снова. Три круга за 145 px езды на месте — при 4 px за кадр это 37 кадров, меньше секунды.
  • Порядок ворот с бесконечными прямыми закрывает почти всё, но срезка через газон проходит. Путь срезки пересёк продолжение линии Ч1 в стороне от дороги, и счётчик принял это за проезд ворот. Ошибка коварная: на честной езде её не видно вообще.
  • Порядок ворот с отрезками не дал ни одного лишнего круга. Срезавшая машина стоит на нуле и ждёт Ч1.

Срезка, кстати, короче честного круга: 805 px против 1005 px в том же сценарии, на 20 % (наш расчёт по точкам пути из проверочного файла). Если срезку засчитывать, она станет главным путём, а трасса — декорацией.

Таблица на 240-м кадре показывает вторую ловушку. Наивная сортировка «кто ближе к своим воротам» выдала порядок Зелёная, Синяя, Красная, Жёлтая. Зелёная (4 px за кадр) на первом круге, в 30 px от финиша; остальные уже на втором круге и ждут Ч2. Правильная таблица ставит Зелёную последней с прогрессом 3,862 против 5,246–5,773 у остальных. Синяя и Красная на одном круге у одних ворот разошлись на 0,004 — почти вплотную, но порядок определён.

На финише Жёлтая (5,5 px за кадр) приходит на 544-м кадре, 9,061 с, а Зелёная к 560-му кадру ещё на третьем круге: прогресс 9,000 — ровно на воротах Ч1.

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

Чтобы проехать трассу самому, хватит короткой обвязки: машина игрока двигается стрелками, бот едет по сценарию, ворота, которые игрок ждёт, подсвечены жёлтым, таблица мест рисуется на газоне. Управление здесь нарочно самое простое — 2,5 px за кадр по осям, без поворота и заноса; машину с инерцией и поворотом можно собрать по статье про Asteroids на JavaScript, правила заезда от этого не изменятся.

// main.mjs — обвязка для браузера: машина игрока на стрелках, ворота и таблица мест
import { GATES, counters, newCar, tick, standings } from "./race.mjs";

const canvas = document.querySelector("canvas");
const ctx = canvas.getContext("2d");
canvas.width = 400; canvas.height = 300;

const held = new Set();
addEventListener("keydown", (e) => held.add(e.code));
addEventListener("keyup", (e) => held.delete(e.code));

const P = (x, y) => ({ x, y });
const LAP = [P(350, 50), P(350, 250), P(50, 250), P(50, 50), P(210, 50)];
const bot = newCar("Бот", [P(210, 50)].concat(LAP, LAP, LAP, LAP), 3);
const player = newCar("Вы", [P(210, 30)], 0); // путь не нужен: двигаем сами
const LAPS = 3;
let frame = 0;

function loop() {
  frame++;
  tick([bot], counters.ordered, frame, LAPS);
  if (!player.done) {
    const p = player.pos;
    const dx = (held.has("ArrowRight") ? 2.5 : 0) - (held.has("ArrowLeft") ? 2.5 : 0);
    const dy = (held.has("ArrowDown") ? 2.5 : 0) - (held.has("ArrowUp") ? 2.5 : 0);
    player.pos = P(p.x + dx, p.y + dy);
    counters.ordered(player, p, player.pos, frame);
    if (player.lap >= LAPS) player.done = true;
  }
  ctx.fillStyle = "#555"; ctx.fillRect(0, 0, 400, 300);   // дорога
  ctx.fillStyle = "#3a7"; ctx.fillRect(100, 100, 200, 100); // газон
  GATES.forEach((g, i) => {
    ctx.strokeStyle = i === player.next ? "#ff0" : "#999";   // жёлтые — те, что ждём
    ctx.beginPath(); ctx.moveTo(g.a.x, g.a.y); ctx.lineTo(g.b.x, g.b.y); ctx.stroke();
  });
  ctx.fillStyle = "#e33"; ctx.fillRect(player.pos.x - 5, player.pos.y - 5, 10, 10);
  ctx.fillStyle = "#39f"; ctx.fillRect(bot.pos.x - 5, bot.pos.y - 5, 10, 10);
  ctx.fillStyle = "#fff";
  standings([player, bot]).forEach((c, i) =>
    ctx.fillText((i + 1) + ". " + c.name + " — круг " + Math.min(c.lap + 1, LAPS), 140, 140 + i * 16));
  requestAnimationFrame(loop);
}
requestAnimationFrame(loop);

Подключите main.mjs как модуль к странице с одним элементом canvas и откройте её через локальный сервер. Синтаксис обвязки проверен командой node --check, в Node.js она не запускается: ей нужен браузер. Стен в обвязке нет, газон проезжаемый — попробуйте срезать и посмотрите, что жёлтые ворота Ч1 никуда не денутся.

При движении по клеткам проверка та же: шаг от клетки к клетке — тоже отрезок (сетка против свободного движения — в статье про движение по сетке).

Практический сценарий: трасса для кружка на четыре машины

Задача: собрать первую гонку на занятии кружка — одна трасса, игрок и три бота, 3 круга, таблица мест на экране — и убедиться до игры, что круги и места считаются честно. Входные условия — трасса и ядро из этой статьи, 60 кадров в секунду.

Порядок работы:

  1. Нарисовать трассу на бумаге и поставить ворота. На каждой прямой по воротам, финиш — первые. Проверка глазами: между любыми соседними воротами нет пути короче, чем по дороге.
  2. Записать ворота данными. Для каждых — a у внутреннего края, b у внешнего, при езде по часовой стрелке.
  3. Первый прогон — честный круг. Если ordered дал 0, у каких-то ворот перепутаны концы. Выведите номер next, на котором машина застряла: это и есть перевёрнутые ворота.
  4. Прогнать четыре хитрости: срезку, круг задом наперёд, езду туда-обратно у финиша и ещё одну, подсказанную самой трассой (например, разворот перед последними воротами). Ожидание — 0 кругов у каждой.
  5. Проверить таблицу мест на отстающем. Поставить одного бота медленнее на треть (у нас 4 px против 6) и вывести таблицу в момент, когда лидер его почти догнал. Отстающий должен быть последним.
  6. Проверить финиш в одном кадре. Две машины с почти равной скоростью (6 и 6,003 px за кадр) должны финишировать в одном кадре и получить разное время.
  7. Только потом подключать руль и отрисовку. Если ошибка появилась после этого, она в управлении, а не в правилах заезда.

Проверяемый итог: таблица «сценарий → кругов» совпадает с колонкой «Должно быть» из раздела выше, а в заезде место отстающей машины последнее при любом моменте проверки. Шаги 1–4 — хорошее упражнение само по себе: ученики придумывают, как обмануть счётчик, а код должен устоять.

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

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

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

  • Извилистая трасса с длинными поворотами. Проекция на отрезок между центрами ворот в петляющем повороте врёт: прогресс замирает или скачет, и места меняются на глазах у игрока. Нужна средняя линия трассы — ломаная из десятков точек — и прогресс как длина пути вдоль неё до ближайшей точки.
  • Открытый мир без трассы. Если машина едет «из точки A в точку B» любым путём, ворота по порядку не нужны: хватает зоны финиша и времени. Места тогда — по расстоянию до цели или по времени прибытия.
  • Гонка «на выбывание» или с перевесом очков. Если отстающий выбывает, когда пропадает с экрана, правила другие: важен не круг, а отрыв. Это режим, о котором шла речь в истории жанра.
  • Сетевая гонка. У каждого игрока свой кадр, и «кто первым пересёк линию» должен решать кто-то один для всех — обычно сервер, а не локальный цикл каждого игрока. Код этой статьи годится для одного компьютера и общего экрана.
  • Развилки и альтернативные пути. Если трасса раздваивается и обе дороги честные, одних ворот на шаг мало: нужны ворота «одни из двух», то есть список допустимых ворот на каждом шаге вместо одного номера.

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

Источники (проверено: ноябрь 2026, 11.11.2026): Wikipedia — Gran Trak 10 (Atari, май 1974; вид сверху; на экране — оставшееся время и число пройденных контрольных точек); Wikipedia — Super Sprint (Atari Games, 1986; трасса целиком на экране; победитель определяется после трёх кругов). Трасса, ворота, правила зачёта, формула прогресса, сценарии, скорости и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.

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

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

Почему нельзя засчитывать круг за каждое пересечение линии финиша?

Потому что линию можно пересечь не проехав трассу: сдать назад и проехать снова, развернуться или срезать. В нашем прогоне счётчик «любое пересечение» дал 6 кругов машине, которая трижды съездила туда-обратно через финиш, а счётчик «только вперёд» — 3 круга ей же. Честный круг — это все ворота трассы по порядку, и финиш последним.

Чем ворота-отрезок лучше точки-чекпойнта с радиусом?

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

Как определить место в заезде, если две машины на одном круге?

Сравнить прогресс: число кругов, затем число пройденных ворот на этом круге, затем долю пути от последних ворот до следующих. В нашем примере на 240-м кадре две машины на одном круге и у одних ворот разошлись на 0,004 круга — этого хватает, чтобы таблица мест не прыгала.

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

Считать момент пересечения с долей кадра: пересечение отрезков сразу даёт, на какой доле шага машина коснулась линии. В нашем прогоне обе машины пересекли финиш на 499-м кадре, но одна — на 8,301 с, другая — на 8,306 с.