Коротко
Тетрис на JavaScript держится на четырёх функциях: проверка, помещается ли фигура, поворот, падение и очистка полных строк. Фигура — 4 клетки в рамке 3 × 3 или 4 × 4 (у I) и поворачивается формулой (x, y) → (n − 1 − y, x), а если после поворота она упирается в стену или блоки, по Super Rotation System пробуют ещё 4 сдвига, прежде чем отказать. Полные строки удаляются фильтром, очки по Tetris Guideline — 100, 300, 500 и 800 × уровень за 1–4 линии, а фигура фиксируется через 0,5 с после касания.
Содержание
- Из чего состоит тетрис
- Фигура как 4 клетки и поворот на 90°
- Отталкивание от стен: 5 проверок
- Очистка линий и очки
- Падение по таймеру и задержка фиксации
- Ядро игры на JavaScript и проверка в Node.js
- Обвязка для браузера: клавиши и canvas
- Практический сценарий: тетрис за два занятия кружка
- Когда вам это не подойдёт
Из чего состоит тетрис
Тетрис — это поле из клеток, падающая фигура из 4 клеток и правило: заполненная строка исчезает, всё, что выше, опускается. Первую версию Алексей Пажитнов написал на компьютере «Электроника-60» в Вычислительном центре Академии наук; источники датируют её 1984 или 1985 годом, а The Tetris Company с 2009 года отмечает годовщину по дате 6 июня 1984 года. В той версии не было ни очков, ни уровней.
Современные правила записаны в Tetris Guideline — спецификации The Tetris Company для официальных игр с 2001 года. Из неё в нашем коде четыре вещи:
- Поле 10 клеток в ширину и 20 в высоту плюс скрытая зона сверху, где появляются фигуры. Нам хватит 2 скрытых строк:
H = 22. - Фигуры появляются горизонтально, по центру с округлением влево; J, L и T — плоской стороной вниз.
- Поворот по Super Rotation System (SRS) с отталкиванием от стен.
- Цвета: I — голубой, J — синий, L — оранжевый, O — жёлтый, S — зелёный, Z — красный, T — пурпурный.
Порядок фигур по Guideline задаёт мешок из 7: все 7 фигур перемешивают и выдают по одной. Как устроен такой мешок и почему он честнее простого случайного выбора, разобрано в статье про случайность без несправедливости — здесь его просто подключаем.
Фигура как 4 клетки и поворот на 90°
Фигуру удобно хранить как 4 клетки внутри квадратной рамки n × n и поворачивать каждую клетку по одной формуле. При повороте по часовой стрелке, когда y растёт вниз, как на canvas:
(x, y) → (n − 1 − y, x)
Для T, S, Z, J и L рамка 3 × 3, для I — 4 × 4, у O рамка 2 × 2, и её не поворачивают. Пример для T в рамке 3 × 3: клетки появления (1,0) (0,1) (1,1) (2,1) после поворота становятся (2,1) (1,0) (1,1) (1,2) — «нос» смотрит вправо. Это и есть базовый поворот SRS: без отталкивания все фигуры вращаются вокруг одной точки, у I и O она на пересечении линий сетки, у остальных — в центре одной из клеток.
Состояние поворота храним числом rot от 0 до 3: 0 — появление, 1 — после поворота по часовой (в SRS его называют R), 2 — два поворота, 3 — после поворота против часовой (L). Клетки фигуры на поле получаем, повернув базовые клетки rot раз и прибавив позицию рамки.
Отталкивание от стен: 5 проверок
Отталкивание (wall kick) — это попытка сдвинуть повёрнутую фигуру, если на новом месте она пересекает стену, пол или блоки. В SRS для каждого поворота проверяют 5 позиций по порядку: первая — без сдвига, остальные 4 — из таблицы; фигура встаёт в первую свободную, а если свободных нет, поворот не выполняется. У J, L, S, T и Z одна общая таблица, у I своя, O не отталкивается.
Фрагмент таблицы для J, L, S, T, Z (x вправо, y вверх — так записано в TetrisWiki):
| Поворот | Проверка 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 0 → R | (0, 0) | (−1, 0) | (−1, +1) | (0, −2) | (−1, −2) |
| R → 2 | (0, 0) | (+1, 0) | (+1, −1) | (0, +2) | (+1, +2) |
| 2 → L | (0, 0) | (+1, 0) | (+1, +1) | (0, −2) | (+1, −2) |
| L → 0 | (0, 0) | (−1, 0) | (−1, −1) | (0, +2) | (−1, +2) |
На поле y растёт вниз, поэтому при применении сдвига знак y меняют: (−1, +1) из таблицы значит «на клетку влево и на клетку вверх», то есть x − 1, y − 1. Обратные повороты используют те же числа с обратным знаком — поэтому, если поворот возможен в одну сторону, он возможен и обратно.
Очистка линий и очки
Полная строка — строка без пустых клеток, и удалить все такие строки можно одним фильтром: оставить неполные, а сверху добавить столько пустых, сколько удалили. Порядок важен: сначала фигуру вписывают в поле, потом ищут полные строки, потом считают очки.
Очки в современных играх по Guideline:
| Действие | Очки |
|---|---|
| 1 линия | 100 × уровень |
| 2 линии | 300 × уровень |
| 3 линии | 500 × уровень |
| 4 линии (тетрис) | 800 × уровень |
| мгновенное падение | 2 за клетку |
| ускоренное падение | 1 за клетку |
Уровень берут тот, что был до очистки. За 4 линии одним ходом дают в 8 раз больше, чем за одну, хотя линий всего в 4 раза больше, — так правило подталкивает держать колодец под палку I. Уровень в нашем коде растёт каждые 10 линий; это распространённый вариант, а не требование Guideline.
Падение по таймеру и задержка фиксации
Фигура опускается на одну строку каждые fallInterval(level) миллисекунд, а коснувшись опоры, не фиксируется сразу: по Guideline у игрока есть 0,5 с, чтобы сдвинуть или повернуть её. Сдвиг или поворот на опоре сбрасывает этот таймер, но не больше 15 раз — иначе фигуру можно вращать бесконечно. В Guideline описаны три варианта сброса, а поздние игры используют именно ограничение в 15 действий.
Интервал падения в нашем коде — 1000 − (уровень − 1) × 80 мс на строку, но не меньше 50 мс: на 1-м уровне 1 с, на 10-м — 280 мс. Это учебный ориентир, кривую скорости настраивают по плейтестам.
Ядро игры на JavaScript и проверка в Node.js
Ядро не знает ни про canvas, ни про клавиатуру: оно получает время кадра и одно действие и меняет состояние. Поэтому его можно проверить в Node.js без браузера — ниже 4 сценария прямо в конце файла.
// tetris-core.js — логика без отрисовки: поле, фигуры, поворот с отталкиванием, линии
export const W = 10, H = 22; // 20 видимых строк + 2 скрытые сверху
const SHAPES = { // состояние появления; y растёт вниз
I: { n: 4, cells: [[0, 1], [1, 1], [2, 1], [3, 1]] },
O: { n: 2, cells: [[0, 0], [1, 0], [0, 1], [1, 1]] },
T: { n: 3, cells: [[1, 0], [0, 1], [1, 1], [2, 1]] },
S: { n: 3, cells: [[1, 0], [2, 0], [0, 1], [1, 1]] },
Z: { n: 3, cells: [[0, 0], [1, 0], [1, 1], [2, 1]] },
J: { n: 3, cells: [[0, 0], [0, 1], [1, 1], [2, 1]] },
L: { n: 3, cells: [[2, 0], [0, 1], [1, 1], [2, 1]] },
};
// Таблицы отталкивания SRS (TetrisWiki): x вправо, y ВВЕРХ — при применении y меняем знак
const KICKS = {
'0>1': [[0, 0], [-1, 0], [-1, 1], [0, -2], [-1, -2]], '1>0': [[0, 0], [1, 0], [1, -1], [0, 2], [1, 2]],
'1>2': [[0, 0], [1, 0], [1, -1], [0, 2], [1, 2]], '2>1': [[0, 0], [-1, 0], [-1, 1], [0, -2], [-1, -2]],
'2>3': [[0, 0], [1, 0], [1, 1], [0, -2], [1, -2]], '3>2': [[0, 0], [-1, 0], [-1, -1], [0, 2], [-1, 2]],
'3>0': [[0, 0], [-1, 0], [-1, -1], [0, 2], [-1, 2]], '0>3': [[0, 0], [1, 0], [1, 1], [0, -2], [1, -2]],
};
const KICKS_I = {
'0>1': [[0, 0], [-2, 0], [1, 0], [-2, -1], [1, 2]], '1>0': [[0, 0], [2, 0], [-1, 0], [2, 1], [-1, -2]],
'1>2': [[0, 0], [-1, 0], [2, 0], [-1, 2], [2, -1]], '2>1': [[0, 0], [1, 0], [-2, 0], [1, -2], [-2, 1]],
'2>3': [[0, 0], [2, 0], [-1, 0], [2, 1], [-1, -2]], '3>2': [[0, 0], [-2, 0], [1, 0], [-2, -1], [1, 2]],
'3>0': [[0, 0], [1, 0], [-2, 0], [1, -2], [-2, 1]], '0>3': [[0, 0], [-1, 0], [2, 0], [-1, 2], [2, -1]],
};
export const emptyBoard = () => Array.from({ length: H }, () => Array(W).fill(null));
export function spawn(type) { // по центру, округление влево
const n = SHAPES[type].n;
return { type, rot: 0, x: Math.floor((W - n) / 2), y: 0 };
}
export function cells(p) { // клетки фигуры в координатах поля
const { n, cells: base } = SHAPES[p.type];
return base.map(([x, y]) => {
for (let r = 0; r < p.rot; r++) [x, y] = [n - 1 - y, x]; // поворот по часовой в рамке n×n
return [p.x + x, p.y + y];
});
}
export function fits(board, p) {
return cells(p).every(([x, y]) => x >= 0 && x < W && y < H && (y < 0 || board[y][x] === null));
}
export function move(board, p, dx, dy) {
const q = { ...p, x: p.x + dx, y: p.y + dy };
return fits(board, q) ? q : null;
}
export function rotate(board, p, dir, useKicks = true) { // dir: +1 по часовой, −1 против
if (p.type === 'O') return { piece: p, test: 0 };
const to = (p.rot + dir + 4) % 4;
const table = (p.type === 'I' ? KICKS_I : KICKS)[`${p.rot}>${to}`];
const tests = useKicks ? table : table.slice(0, 1);
for (let t = 0; t < tests.length; t++) {
const [kx, ky] = tests[t];
const q = { ...p, rot: to, x: p.x + kx, y: p.y - ky };
if (fits(board, q)) return { piece: q, test: t + 1 };
}
return null; // все 5 проверок заняты — поворота нет
}
export function hardDrop(board, p) {
let q = p, rows = 0, next;
while ((next = move(board, q, 0, 1))) { q = next; rows++; }
return { piece: q, rows };
}
export function lockAndClear(board, p) { // вписать фигуру и убрать полные строки
for (const [x, y] of cells(p)) board[y][x] = p.type;
const kept = board.filter(row => row.some(c => c === null));
const cleared = H - kept.length;
while (kept.length < H) kept.unshift(Array(W).fill(null));
board.splice(0, H, ...kept);
return cleared;
}
export const LINE_SCORE = [0, 100, 300, 500, 800]; // × уровень
// Цикл игры: падение по таймеру, задержка фиксации 0,5 с, не больше 15 сбросов
export const fallInterval = level => Math.max(50, 1000 - (level - 1) * 80); // мс на строку, наш ориентир
export function newGame(nextType) {
const g = { board: emptyBoard(), nextType, level: 1, lines: 0, score: 0, over: false };
g.piece = spawn(nextType()); g.fall = 0; g.lock = 0; g.resets = 0;
return g;
}
export function step(g, dt, action) { // action: 'left' | 'right' | 'cw' | 'ccw' | 'hard' | null
if (g.over) return;
const before = g.piece;
if (action === 'left' || action === 'right') g.piece = move(g.board, g.piece, action === 'left' ? -1 : 1, 0) ?? g.piece;
if (action === 'cw' || action === 'ccw') g.piece = rotate(g.board, g.piece, action === 'cw' ? 1 : -1)?.piece ?? g.piece;
if (action === 'hard') { const d = hardDrop(g.board, g.piece); g.score += d.rows * 2; return settle(g, d.piece); }
const grounded = !move(g.board, g.piece, 0, 1);
if (grounded) {
if (g.piece !== before && g.resets < 15) { g.lock = 0; g.resets++; } // движение на земле сбрасывает таймер
g.lock += dt;
if (g.lock >= 500) settle(g, g.piece);
} else {
g.fall += dt;
while (g.fall >= fallInterval(g.level)) {
g.fall -= fallInterval(g.level);
const down = move(g.board, g.piece, 0, 1);
if (!down) break;
g.piece = down;
}
}
}
function settle(g, p) {
const n = lockAndClear(g.board, p);
g.score += LINE_SCORE[n] * g.level; // уровень — до очистки
g.lines += n;
g.level = 1 + Math.floor(g.lines / 10);
g.piece = spawn(g.nextType()); g.fall = 0; g.lock = 0; g.resets = 0;
if (!fits(g.board, g.piece)) g.over = true; // новая фигура не помещается — конец
}
// ---- проверка в Node.js ----
const show = p => cells(p).map(c => c.join(',')).join(' ');
// 1. Поворот T у левой стены: без отталкивания и с ним
let b = emptyBoard();
let t = { type: 'T', rot: 1, x: -1, y: 10 }; // T «носом» вправо, прижата к левой стене
console.log('T у стены:', show(t), '| fits', fits(b, t));
console.log(' без отталкивания:', rotate(b, t, +1, false));
const r = rotate(b, t, +1);
console.log(' SRS: проверка', r.test, '→', show(r.piece));
// 2. I в колодце шириной 1 справа: встаёт вертикально и закрывает 4 линии
b = emptyBoard();
for (let y = H - 4; y < H; y++) for (let x = 0; x < W - 1; x++) b[y][x] = 'J';
let i = spawn('I');
i = rotate(b, i, +1).piece; // вертикально
while (move(b, i, 1, 0)) i = move(b, i, 1, 0); // вправо до упора
const drop = hardDrop(b, i);
const lines = lockAndClear(b, drop.piece);
const level = 1;
console.log('I в колодец: x =', drop.piece.x, '| упала на', drop.rows, 'строк | линий', lines,
'| очков', LINE_SCORE[lines] * level + drop.rows * 2, '| пустое поле:', b.every(row => row.every(c => c === null)));
// 3. Поворот невозможен ни в одной из 5 позиций
b = emptyBoard();
for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) b[y][x] = 'Z';
for (const [x, y] of [[3, 20], [4, 20], [5, 20], [6, 20]]) b[y][x] = null; // горизонтальная щель
console.log('I в щели высотой 1:', rotate(b, { type: 'I', rot: 0, x: 3, y: 19 }, +1));
// 4. Цикл: фигура падает сама и фиксируется через 0,5 с после касания
const order = ['O', 'T'];
const g = newGame(() => order.shift() ?? 'I');
let ms = 0, landed = null;
while (g.piece.type === 'O') {
step(g, 1000 / 60, null); ms += 1000 / 60;
if (landed === null && !move(g.board, g.piece, 0, 1)) landed = Math.round(ms);
}
console.log('O падала', landed, 'мс, зафиксирована через', Math.round(ms) - landed, 'мс после касания; следующая:', g.piece.type);
Ожидаемый вывод (проверено в Node.js 24.22.1, 11.11.2026):
T у стены: 1,11 0,10 0,11 0,12 | fits true
без отталкивания: null
SRS: проверка 2 → 1,12 2,11 1,11 0,11
I в колодец: x = 7 | упала на 18 строк | линий 4 | очков 836 | пустое поле: true
I в щели высотой 1: null
O падала 20017 мс, зафиксирована через 500 мс после касания; следующая: T
Что показывают сценарии:
- T у левой стены. Без отталкивания поворот R → 2 невозможен: одна клетка уходит за стену. С таблицей SRS срабатывает проверка 2 — сдвиг на клетку вправо.
- I в колодце. Четыре нижние строки заполнены, кроме правого столбца. Вертикальная I падает на 18 строк и убирает 4 линии: 800 × 1 + 18 × 2 = 836 очков, поле пустое.
- I в щели высотой 1. Все 5 проверок заняты, функция возвращает
null, фигура остаётся как была. - Фиксация. На 1-м уровне O падает 20 строк по 1 с, а фиксируется ровно через 500 мс после касания; 17 мс сверху — это шаг кадра 1/60 с.
Обвязка для браузера: клавиши и canvas
Браузерная часть только переводит клавиши в действия, вызывает step раз в кадр через requestAnimationFrame и рисует поле. Раскладка — как в стандартной раскладке Guideline для клавиатуры: стрелки влево и вправо — сдвиг, стрелка вверх — поворот по часовой, Z — против часовой, пробел — мгновенное падение.
// main.js — браузерная обвязка: клавиши, цикл кадра и отрисовка на canvas
import { W, H, cells, newGame, step } from './tetris-core.js';
import { makeBag } from './random-tools.js'; // мешок без повторов из статьи про случайность
const CELL = 24, HIDDEN = 2; // 2 верхние строки не рисуем
const canvas = document.querySelector('canvas');
canvas.width = W * CELL; canvas.height = (H - HIDDEN) * CELL;
const ctx = canvas.getContext('2d');
const COLORS = { I: '#3cc', O: '#ee3', T: '#a3c', S: '#3c3', Z: '#d33', J: '#36c', L: '#e83' };
const bag = makeBag(['I', 'J', 'L', 'O', 'S', 'T', 'Z'], Math.random);
const game = newGame(bag);
const KEYS = { ArrowLeft: 'left', ArrowRight: 'right', ArrowUp: 'cw', KeyZ: 'ccw', Space: 'hard' };
const queue = [];
addEventListener('keydown', e => {
const a = KEYS[e.code];
if (!a) return;
e.preventDefault();
if (!e.repeat || a === 'left' || a === 'right') queue.push(a); // автоповтор — только для сдвига
});
let last = performance.now();
function frame(now) {
const dt = Math.min(now - last, 100); last = now;
step(game, dt, queue.shift() ?? null); // одно действие за кадр
draw();
if (!game.over) requestAnimationFrame(frame);
}
function draw() {
ctx.fillStyle = '#111'; ctx.fillRect(0, 0, canvas.width, canvas.height);
const paint = (x, y, t) => {
if (y < HIDDEN) return;
ctx.fillStyle = COLORS[t];
ctx.fillRect(x * CELL + 1, (y - HIDDEN) * CELL + 1, CELL - 2, CELL - 2);
};
game.board.forEach((row, y) => row.forEach((t, x) => t && paint(x, y, t)));
for (const [x, y] of cells(game.piece)) paint(x, y, game.piece.type);
}
requestAnimationFrame(frame);
Здесь tetris-core.js — ядро из предыдущего раздела без блока проверки, а random-tools.js — функции из статьи про случайность. Клавиши читаются по event.code, поэтому раскладка не зависит от языка клавиатуры. Время кадра ограничено 100 мс: если вкладку свернули и вернули, фигура не пролетит всё поле за один кадр.
Практический сценарий: тетрис за два занятия кружка
Задача: группа школьников 12–14 лет за два занятия по 90 минут собирает свой тетрис и может объяснить, почему фигура у стены поворачивается. Входные условия — знакомы переменные, массивы и функции, есть ноутбуки с браузером и Node.js. Шаги:
- Занятие 1, первые 45 минут. Поле
emptyBoard, функцииcellsиfits, проверка в Node.js: фигура, вылезающая за стену, не помещается. Формулу поворота выводят на бумаге в клетку для T в рамке 3 × 3. - Занятие 1, вторые 45 минут.
rotateбез отталкивания (useKicks = false), затем с таблицей; сценарий 1 из кода — сначалаnull, потом проверка 2. - Занятие 2, первые 45 минут.
lockAndClearи очки; сценарий 2 должен дать 836. - Занятие 2, вторые 45 минут. Браузерная обвязка, мешок из 7, игра на время.
Проверяемый результат: у каждого ученика все 4 сценария дают ожидаемый вывод, а на вопрос «почему T у стены повернулась и сдвинулась» он отвечает словами «сработала проверка 2: сдвиг на клетку вправо».
Когда вам это не подойдёт
Учебный тетрис по этим правилам годится не для всего:
- Публикация под названием Tetris. Права на игру держат Tetris Holding и The Tetris Company: Guideline задаёт правила использования логотипа, на вариант мелодии «Коробейники» у компании звуковой товарный знак, а в деле Tetris Holding против Xio Interactive (2012) суд США признал, что слишком похожий внешний вид клона нарушает авторские права, хотя сами игровые идеи ими не защищены. Для публичной игры нужны своё название, своя графика и свои правила; это не юридическая консультация.
- Соревновательная игра. Для игры на скорость не хватает T-spin, комбо, бонусов за серии, удержания фигуры и очереди следующих фигур — всё это есть в Guideline, но выходит за рамки урока.
- Только сенсорный экран. Пять действий на клавишах плохо ложатся на касания; нужны жесты: свайп вниз для падения, касание для поворота.
- Первая игра в жизни. Для самого первого урока проще «Змейка» или пинг-понг: в тетрисе сразу поворот, таблицы и очистка строк.
Мы разрабатываем J2DRU — браузерный 2D игровой движок с картами из тайлов, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: 11.11.2026): TetrisWiki — Tetris Guideline (поле 10 × 20 и скрытая зона, появление фигур, цвета, мешок из 7, задержка фиксации 0,5 с и ограничение в 15 действий, раскладка клавиатуры, «Коробейники» и звуковой товарный знак); TetrisWiki — Super Rotation System (5 проверок, таблицы для J, L, S, T, Z и для I, O без отталкивания, x вправо и y вверх); TetrisWiki — Scoring (100/300/500/800 × уровень, уровень до очистки, 1 и 2 очка за клетку падения); Wikipedia — Tetris (Пажитнов, «Электроника-60», 1984 или 1985, годовщина 6 июня 1984 года, первая версия без очков и уровней); Wikipedia — Tetris Holding, LLC v. Xio Interactive, Inc. (решение от 30 мая 2012 года: игровые идеи не защищены, но внешний вид клона Mino признан слишком похожим; Tetris Holding держит авторские права на оригинал). Интервал падения, рост уровня каждые 10 линий и план занятий — наш ориентир; код и вывод — наш прогон в Node.js 24.
Читайте также: