Коротко
Match-3 на JavaScript — это двумерный массив цветов и один цикл после каждого хода: найти все серии из 3+ одинаковых фишек по строкам и столбцам, слить серии с общей фишкой (уголки L и T) в группу, убрать всё найденное разом, уплотнить каждый столбец вниз, досыпать новые фишки сверху и повторять, пока появляются новые серии — это и есть каскады. Обмен засчитывается, только если дал серию, иначе фишки возвращаются на место. Стартовое поле строят без готовых серий, а после каждого хода проверяют, что ход ещё есть, и перемешивают фишки, если его нет.
Содержание
- Откуда взялся match-3
- Из чего состоит игра в коде
- Поле и генератор с зерном
- Стартовое поле без готовых серий
- Обмен соседних фишек и откат
- Поиск серий по строкам и столбцам
- Удаление, падение и досыпка
- Каскады и очки
- Есть ли ход и перемешивание
- Код на JavaScript
- Проверка в Node.js
- Что показал прогон: четыре ловушки
- Что не подтвердилось
- Практический сценарий: сверить своё ядро с контрольными числами
- Когда вам это не подойдёт
Откуда взялся match-3
Первой игрой match-3 Wikipedia называет Shariki (1994) — головоломку для MS-DOS, которую написал российский разработчик Евгений Алемжин. Правила там уже те, что мы будем писать: игрок меняет местами соседние шарики, каждый обмен должен дать линию из трёх и больше шариков одного цвета по вертикали или горизонтали, линия исчезает, сверху падают новые, а игра заканчивается, когда совпадений больше нет.
Популярным жанр в 2000-х сделала прежде всего Bejeweled от PopCap Games. Здесь источники расходятся в годе: статья Wikipedia о жанре пишет «Bejeweled (2001)», а статья о самой игре — что она вышла в 2000 году как браузерная игра Diamond Mine на сайте команды, под нынешним именем попала на MSN Games, а розничная версия Bejeweled Deluxe вышла в мае 2001 года. Уровни с ограничением числа ходов, по той же Wikipedia, появились в match-3 вместе с Candy Crush Saga (2012). Про очки статья о жанре говорит то же, что мы заложим в код: за большие совпадения дают больше, а когда фишки падают на место убранных и складываются в новые совпадения, следующие совпадения ценятся выше.
Как match-3 соотносится с другими головоломками на сетке, мы рассказывали в статье про головоломки на сетке; дальше — только код.
Из чего состоит игра в коде
Игра в нашем примере — поле из чисел, генератор с зерном и несколько небольших функций, каждая из которых делает одну вещь. Отрисовки и мыши нет: ядро работает с данными, а браузерная обвязка только рисует поле и передаёт две клетки, которые игрок хочет обменять.
| Часть | Функция | Что делает |
|---|---|---|
| Генератор | makeRng | случайные числа из зерна |
| Старт | fillStart | поле без готовых серий |
| Ход | trySwap | обмен соседей или откат |
| Поиск | findRuns, groupRuns, shapeOf | серии, группы, форма группы |
| Удаление | removeGroups | убрать найденные клетки разом |
| Падение | gravity, refill | уплотнить столбцы, досыпать сверху |
| Каскады | resolve | повторять до стабилизации, считать очки |
| Тупик | listMoves, reshuffle | список ходов и перемешивание |
Порядок после хода всегда один и тот же: поиск → удаление → падение → досыпка → снова поиск. Ни один шаг не начинается, пока не закончился предыдущий.
Поле и генератор с зерном
Поле — это массив строк, а строка — массив чисел: g[r][c], где r — номер строки сверху, c — номер столбца слева, оба с нуля. Число — цвет фишки от 0 до 5, пустая клетка — -1. Для вывода цвета печатаются буквами A–F, а пустая клетка — точкой, поэтому поле в выводе прогона выглядит как 8 строк по 8 букв.
Случайность берётся не из Math.random, а из своего генератора с зерном: одно и то же зерно даёт одно и то же стартовое поле и одну и ту же досыпку. Это нужно для проверки (вывод совпадает байт в байт), для повтора уровня и для отладки: ошибку, которую нашёл игрок, можно воспроизвести по зерну. Зачем нужно зерно и как случайность сделать честной, мы разбирали в статье про случайность без несправедливости; а как одинаковые входные данные дают одинаковый результат во всей игре — в статье про повтор прохождения.
Наш генератор — линейный конгруэнтный: каждое следующее число получается из предыдущего умножением и сложением по модулю 2³². Умножение делается через Math.imul — по MDN, это 32-битное умножение «как в C». У такого генератора с модулем-степенью двойки, по Wikipedia, младшие биты повторяются с коротким периодом, поэтому мы берём число целиком и делим на 2³², а номер цвета получаем из старших разрядов через Math.floor(next() * n).
Стартовое поле без готовых серий
Стартовое поле заполняют слева направо и сверху вниз, а для каждой клетки перебрасывают цвет, если он дал бы тройку с двумя соседями слева или с двумя сверху. Справа и снизу проверять не нужно: эти клетки ещё пустые.
для каждой строки r сверху вниз, для каждого столбца c слева направо:
v = случайный цвет
пока (g[r][c−1] = v и g[r][c−2] = v) или (g[r−1][c] = v и g[r−2][c] = v):
v = случайный цвет
g[r][c] = v
Без этой проверки игрок получает очки до первого хода: поле само находит серии, убирает их и запускает каскады. На зерне 4 в нашем прогоне на таком поле было 2 серии, и до первого хода начислилось 270 очков за 3 каскада. С проверкой то же зерно дало поле без серий за 3 переброса цвета и с 15 ходами.
Обмен соседних фишек и откат
Обмен засчитывается, только если фишки соседние по стороне и после обмена на поле есть хотя бы одна серия; иначе фишки возвращаются на место. Соседство проверяют так: сумма разностей по строке и столбцу равна 1, поэтому диагональ и обмен через клетку не проходят.
ход(a, b):
1. a и b не соседи → «не соседи», поле не трогаем
2. обменять a и b
3. серий нет → обменять обратно, «нет серии, откат»
4. иначе → каскады до стабилизации, очки
В прогоне на поле с зерном 7: обмен (0,0)↔(0,2) отклонён как «не соседи», обмен (0,0)↔(0,1) откатился, а обмен (1,2)↔(1,3) стал ходом на 140 очков. После первых двух попыток поле не изменилось ни в одной клетке — это проверка, которую стоит держать в своих тестах.
Поиск серий по строкам и столбцам
Серию находят одним проходом по каждой строке и каждому столбцу: идём по клеткам, считаем, сколько подряд одинаковых, и если на смене цвета набралось 3 и больше — запоминаем серию. Поле во время поиска не меняется: функция findRuns только возвращает список серий с направлением, длиной и клетками.
Линия из 4 или 5 фишек — это одна серия длиной 4 или 5, а не две тройки внахлёст: проход по строке не начинает новую серию, пока не сменился цвет. В прогоне ход (1,2)↔(1,3) дал сначала линию 4, а потом каскадом — линию 5.
Уголки L, T и крест: слияние серий
Если горизонтальная и вертикальная серии делят одну фишку, это одно совпадение, и его собирают в группу по общим клеткам. Форму группы определяют по тому, где лежит общая фишка: на концах обеих серий — уголок L, на конце одной и в середине другой — T, в середине обеих — крест.
группа = серии, у которых есть общие клетки (сливаем, пока сливается)
форма:
1 серия → линия 3, 4, 5…
2 серии, общая на концах обеих → L
2 серии, общая на конце одной → T
2 серии, общая в середине обеих → крест
3 серии и больше → сложная
Ход (0,3)↔(1,3) на поле с зерном 7 даёт две серии по 3 фишки: по строке от клетки (1,1) и по столбцу от (1,3). Общая у них — клетка (1,3), на конце обеих, поэтому это уголок L из 5 фишек, а не 6. Форма пригодится, если вы захотите давать за L и T особую фишку, а число клеток — для очков.
Удаление, падение и досыпка
Сначала находят все серии на поле, потом убирают все их клетки разом, и только после этого фишки падают. Падение — это уплотнение каждого столбца вниз за один проход: указатель записи стоит на нижней клетке, мы идём снизу вверх и каждую непустую фишку переносим на указатель, поднимая его на одну клетку.
для каждого столбца c:
запись = нижняя строка
для r от нижней строки до верхней:
если g[r][c] не пусто: перенести g[r][c] в g[запись][c], запись = запись − 1
досыпка: каждая пустая клетка получает новый цвет из генератора
После такого уплотнения все пустые клетки в столбце оказываются сверху, и досыпка ставит новые фишки только над старыми. В прогоне ход (6,6)↔(6,7) убрал линию 4 в столбце 7, и столбец после падения выглядел так: ....AEEA — четыре пустые клетки сверху, четыре старые фишки внизу, под пустотой не висит ни одна. Как показать падение плавно, а не мгновенно, — дело отрисовки: логике достаточно запомнить при уплотнении, из какой строки в какую перенесена каждая фишка, а сам переход описан в статье про tween и функции плавности. Тетрис, где тоже убирают ряды и всё сверху опускается, устроен иначе — там сдвигаются целые строки; это разобрано в тетрисе на JavaScript.
Каскады и очки
Каскад — это повтор цикла «поиск → удаление → падение → досыпка» после одного хода, пока на поле появляются новые серии. Цикл кончается, когда поиск вернул пустой список; на всякий случай у него есть предохранитель — не больше 100 каскадов за ход, как советуют для любого while, который может не закончиться, в статье про циклы и ветвления.
Очки в нашем примере считаются по группе, а не по серии:
очки группы = 10 × число фишек в группе × номер каскада
Первый каскад идёт с множителем 1, второй — 2 и так далее; так поздние совпадения стоят дороже, как и описывает Wikipedia для жанра. Ход (1,2)↔(1,3) из прогона: каскад 1 — линия 4, 40 очков; каскад 2 — линия 5, 100 очков; итого 140, и после хода на поле нет ни одной серии. Как выбирать шаг множителя, потолок и окно серии в аркаде, мы разбирали отдельно в статье про очки, множители и рекорды; здесь множитель — просто номер каскада.
Есть ли ход и перемешивание
Ход есть, если хотя бы один обмен соседних фишек даёт серию; чтобы это узнать, перебирают обмен каждой фишки с правым и с нижним соседом, проверяют серии и возвращают фишки обратно. Левого и верхнего соседа отдельно проверять не нужно: обмен с ними уже проверен со стороны другой фишки.
Если ходов нет, фишки перемешивают алгоритмом Фишера — Йейтса и повторяют, пока поле не станет без готовых серий и хотя бы с одним ходом. Цвета при этом не меняются, меняются только места: у игрока остаются те же фишки. Сам алгоритм перемешивания и почему он честный, разобраны в статье про случайность.
Проверку делают после каждого хода, а не только на старте: каскады и досыпка могут привести к тупику в середине партии.
Код на JavaScript
Пример — два файла: match3.mjs с ядром игры и test.mjs, который прогоняет проверки по разделам и печатает итог. Нужен Node.js 24 и папка с этими файлами; запуск — node test.mjs. Случайность только из генератора с зерном, поэтому вывод повторяется байт в байт.
Опции включают ошибки для ловушек: noCheck в fillStart — старт без проверки серий, oneCellFall в gravity — падение на одну клетку за проход, onlyRight в listMoves — поиск ходов только обменом вправо; removeWhileScanning — удаление строчных серий сразу при находке, а pointsPerRun — очки за каждую серию отдельно, для сравнения.
// match3.mjs — ядро match-3 на чистом JavaScript; случайность только из генератора с зерном
export const W = 8;
export const H = 8;
export const COLORS = "ABCDEF";
export const EMPTY = -1;
// Линейный конгруэнтный генератор: одно и то же зерно даёт одно и то же поле
export function makeRng(seed) {
let s = seed >>> 0;
const next = () => {
s = (Math.imul(s, 1664525) + 1013904223) >>> 0;
return s / 4294967296;
};
return { next, int: (n) => Math.floor(next() * n) };
}
export const makeGrid = () => Array.from({ length: H }, () => new Array(W).fill(EMPTY));
export const copyGrid = (g) => g.map((row) => row.slice());
export const show = (g) => g.map((row) => row.map((v) => (v < 0 ? "." : COLORS[v])).join(""));
// Поле из строк букв — для собранных вручную примеров
export function parseGrid(lines) {
return lines.map((s) => [...s].map((ch) => (ch === "." ? EMPTY : COLORS.indexOf(ch))));
}
// Стартовое поле: перебрасываем цвет, пока он не дал бы тройку слева или сверху
export function fillStart(rng, opts = {}) {
const g = makeGrid();
let rerolls = 0;
for (let r = 0; r < H; r++) {
for (let c = 0; c < W; c++) {
let v = rng.int(COLORS.length);
while (!opts.noCheck && makesRun(g, r, c, v)) { v = rng.int(COLORS.length); rerolls += 1; }
g[r][c] = v;
}
}
return { g, rerolls };
}
function makesRun(g, r, c, v) {
const left = c >= 2 && g[r][c - 1] === v && g[r][c - 2] === v;
const up = r >= 2 && g[r - 1][c] === v && g[r - 2][c] === v;
return left || up;
}
// Все серии из 3+ одинаковых фишек по строкам и столбцам; поле не меняется
export function findRuns(g) {
const runs = [];
for (let r = 0; r < H; r++) scanLine(g, runs, "h", r);
for (let c = 0; c < W; c++) scanLine(g, runs, "v", c);
return runs;
}
function scanLine(g, runs, dir, k) {
const n = dir === "h" ? W : H;
const at = (i) => (dir === "h" ? g[k][i] : g[i][k]);
let i = 0;
while (i < n) {
let j = i + 1;
while (j < n && at(i) !== EMPTY && at(j) === at(i)) j += 1;
if (at(i) !== EMPTY && j - i >= 3) {
const cells = [];
for (let t = i; t < j; t++) cells.push(dir === "h" ? [k, t] : [t, k]);
runs.push({ dir, len: j - i, cells });
}
i = j;
}
}
// Серии с общей фишкой сливаем в одну группу: так L, T и крест считаются одним совпадением
export function groupRuns(runs) {
const groups = [];
for (const run of runs) {
const keys = run.cells.map(([r, c]) => r * W + c);
const hit = groups.filter((gr) => keys.some((key) => gr.cells.has(key)));
const merged = { runs: [run], cells: new Set(keys) };
for (const gr of hit) {
merged.runs.push(...gr.runs);
for (const key of gr.cells) merged.cells.add(key);
groups.splice(groups.indexOf(gr), 1);
}
groups.push(merged);
}
return groups;
}
// Форма группы: линия 3/4/5, уголок L, буква T, крест или сложная
export function shapeOf(group) {
if (group.runs.length === 1) return "линия " + group.runs[0].len;
if (group.runs.length > 2) return "сложная";
const [a, b] = group.runs;
const keysA = a.cells.map(([r, c]) => r * W + c);
const common = b.cells.map(([r, c]) => r * W + c).find((key) => keysA.includes(key));
const endA = common === keysA[0] || common === keysA[keysA.length - 1];
const keysB = b.cells.map(([r, c]) => r * W + c);
const endB = common === keysB[0] || common === keysB[keysB.length - 1];
if (endA && endB) return "L";
if (endA || endB) return "T";
return "крест";
}
// Очки: 10 за каждую убранную фишку, умножить на номер каскада
export const POINTS_PER_TILE = 10;
// Гравитация: каждый столбец уплотняется вниз за один проход
export function gravity(g, opts = {}) {
for (let c = 0; c < W; c++) {
if (opts.oneCellFall) { // ошибка для ловушки: каждая фишка опускается только на 1 клетку
for (let r = H - 1; r >= 1; r--) {
if (g[r][c] === EMPTY && g[r - 1][c] !== EMPTY) { g[r][c] = g[r - 1][c]; g[r - 1][c] = EMPTY; }
}
continue;
}
let write = H - 1;
for (let r = H - 1; r >= 0; r--) {
if (g[r][c] === EMPTY) continue;
const v = g[r][c];
g[r][c] = EMPTY;
g[write][c] = v;
write -= 1;
}
}
}
// Фишки, под которыми пусто: после правильного падения их 0
export function hanging(g) {
let n = 0;
for (let c = 0; c < W; c++) {
for (let r = 0; r < H - 1; r++) if (g[r][c] !== EMPTY && g[r + 1][c] === EMPTY) n += 1;
}
return n;
}
// Досыпка: каждая пустая клетка получает новую фишку; считаем, сколько встало под старыми
export function refill(g, rng) {
let added = 0;
let underOld = 0;
for (let c = 0; c < W; c++) {
let seenOld = false;
for (let r = 0; r < H; r++) {
if (g[r][c] !== EMPTY) { seenOld = true; continue; }
g[r][c] = rng.int(COLORS.length);
added += 1;
if (seenOld) underOld += 1; // новая фишка встала под старой — посреди столбца
}
}
return { added, underOld };
}
// Удаление: сначала находим все серии, потом убираем все их клетки разом
export function removeGroups(g, groups) {
let removed = 0;
for (const gr of groups) {
for (const key of gr.cells) {
const r = Math.floor(key / W);
const c = key % W;
if (g[r][c] !== EMPTY) { g[r][c] = EMPTY; removed += 1; }
}
}
return removed;
}
// Ошибка для ловушки: убирать строчную серию сразу при находке, потом искать столбцы
export function removeWhileScanning(g) {
let removed = 0;
for (const dir of ["h", "v"]) {
const runs = [];
for (let k = 0; k < (dir === "h" ? H : W); k++) scanLine(g, runs, dir, k);
for (const run of runs) {
for (const [r, c] of run.cells) if (g[r][c] !== EMPTY) { g[r][c] = EMPTY; removed += 1; }
}
}
return removed;
}
// Каскады: искать, убрать, уронить, досыпать — пока на поле есть серии
export function resolve(g, rng, opts = {}) {
const res = { cascades: 0, removed: 0, points: 0, pointsPerRun: 0, shapes: {},
hangingMax: 0, underOld: 0, log: [] };
while (res.cascades < 100) { // предохранитель: каскадов в одном ходе не больше 100
const runs = findRuns(g);
if (runs.length === 0) break;
res.cascades += 1;
const groups = groupRuns(runs);
let points = 0;
for (const gr of groups) {
const shape = shapeOf(gr);
res.shapes[shape] = (res.shapes[shape] || 0) + 1;
points += POINTS_PER_TILE * gr.cells.size * res.cascades;
// ошибка для сравнения: очки за каждую серию отдельно, общая фишка уголка — дважды
for (const run of gr.runs) res.pointsPerRun += POINTS_PER_TILE * run.len * res.cascades;
}
res.points += points;
const gone = removeGroups(g, groups);
res.removed += gone;
res.log.push({ cascade: res.cascades, gone, points, shapes: groups.map(shapeOf) });
gravity(g, opts);
res.hangingMax = Math.max(res.hangingMax, hanging(g));
res.underOld += refill(g, rng).underOld;
}
return res;
}
export const adjacent = (a, b) => Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) === 1;
function swapCells(g, a, b) {
const v = g[a[0]][a[1]];
g[a[0]][a[1]] = g[b[0]][b[1]];
g[b[0]][b[1]] = v;
}
// Ход игрока: обмен соседей; если серии нет — откат и ход не засчитан
export function trySwap(g, a, b, rng, opts = {}) {
if (!adjacent(a, b)) return { ok: false, why: "не соседи" };
swapCells(g, a, b);
if (findRuns(g).length === 0) { swapCells(g, a, b); return { ok: false, why: "нет серии, откат" }; }
return { ok: true, ...resolve(g, rng, opts) };
}
// Все ходы, которые дают серию: обмен с правым и с нижним соседом
export function listMoves(g, opts = {}) {
const moves = [];
for (let r = 0; r < H; r++) {
for (let c = 0; c < W; c++) {
const near = opts.onlyRight ? [[r, c + 1]] : [[r, c + 1], [r + 1, c]];
for (const b of near) {
if (b[0] >= H || b[1] >= W || g[r][c] === g[b[0]][b[1]]) continue;
swapCells(g, [r, c], b);
if (findRuns(g).length > 0) moves.push([[r, c], b]);
swapCells(g, [r, c], b);
}
}
}
return moves;
}
// Перемешивание Фишера — Йейтса, пока поле не станет без серий и хотя бы с одним ходом
export function reshuffle(g, rng) {
const pool = g.flat();
let tries = 0;
do {
for (let i = pool.length - 1; i > 0; i--) {
const j = rng.int(i + 1);
const v = pool[i];
pool[i] = pool[j];
pool[j] = v;
}
for (let k = 0; k < pool.length; k++) g[Math.floor(k / W)][k % W] = pool[k];
tries += 1;
} while (findRuns(g).length > 0 || listMoves(g).length === 0);
return tries;
}
// test.mjs — node test.mjs; вывод детерминирован: зерно задано, Math.random не используется
import { W, H, COLORS, makeRng, copyGrid, show, fillStart, findRuns, groupRuns, shapeOf, POINTS_PER_TILE,
gravity, hanging, refill, removeGroups, removeWhileScanning, resolve, trySwap, listMoves, reshuffle } from "./match3.mjs";
const out = [];
const say = (s) => out.push(s);
const num = (x, d) => x.toFixed(d).replace(".", ",");
const SEED = 7;
const fresh = () => { const rng = makeRng(SEED); return { rng, g: fillStart(rng).g }; };
const cell = (p) => "(" + p[0] + "," + p[1] + ")";
const board = (g) => { for (const line of show(g)) say(" " + line); };
say("# 0. Модель");
say("поле " + W + "×" + H + ", цветов " + COLORS.length + " (" + COLORS + "); очки = " + POINTS_PER_TILE +
" × фишек в группе × номер каскада; зерно " + SEED);
say("");
say("# 1. Стартовое поле игры, зерно " + SEED);
{
const rng = makeRng(SEED);
const { g, rerolls } = fillStart(rng);
board(g);
say("с проверкой: серий " + findRuns(g).length + ", ходов " + listMoves(g).length + ", перебросов цвета " + rerolls);
}
say("");
say("# 1а. Стартовое поле, зерно 4: без проверки и с проверкой");
{
const raw = makeRng(4);
const bad = fillStart(raw, { noCheck: true }).g;
board(bad);
const runs = findRuns(bad).length;
const res = resolve(bad, raw);
say("без проверки: серий на старте " + runs + ", даровых очков до первого хода " + res.points + ", каскадов " + res.cascades);
const st = fillStart(makeRng(4));
say("с проверкой: серий " + findRuns(st.g).length + ", перебросов цвета " + st.rerolls + ", ходов " + listMoves(st.g).length);
}
{
let withRuns = 0;
let freePoints = 0;
let rerolls = 0;
let movesSum = 0;
let movesMin = Infinity;
let movesMax = 0;
let dead = 0;
for (let s = 1; s <= 1000; s++) {
const raw = makeRng(s);
const bad = fillStart(raw, { noCheck: true }).g;
if (findRuns(bad).length > 0) withRuns += 1;
freePoints += resolve(bad, raw).points;
const st = fillStart(makeRng(s));
rerolls += st.rerolls;
const n = listMoves(st.g).length;
movesSum += n; movesMin = Math.min(movesMin, n); movesMax = Math.max(movesMax, n);
if (n === 0) dead += 1;
}
say("1000 зёрен без проверки: полей с готовой серией " + withRuns + ", даровых очков в среднем " + num(freePoints / 1000, 1));
say("1000 зёрен с проверкой: полей с серией 0, перебросов в среднем " + num(rerolls / 1000, 1) +
", ходов от " + movesMin + " до " + movesMax + ", в среднем " + num(movesSum / 1000, 1) + ", полей без хода " + dead);
}
say("");
say("# 2. Обмен и откат");
{
const { g, rng } = fresh();
const before = show(g).join("/");
for (const [a, b] of [[[0, 0], [0, 2]], [[0, 0], [0, 1]], [[1, 2], [1, 3]]]) {
const r = trySwap(g, a, b, rng);
say(cell(a) + "↔" + cell(b) + ": " + (r.ok ? "ход, очков " + r.points : r.why) +
"; поле не изменилось: " + (show(g).join("/") === before ? "да" : "нет"));
}
}
say("");
say("# 3. Серии, уголок и порядок удаления: ход (0,3)↔(1,3)");
{
const { g } = fresh();
[g[0][3], g[1][3]] = [g[1][3], g[0][3]];
const runs = findRuns(g);
for (const run of runs) say("серия " + (run.dir === "h" ? "по строке" : "по столбцу") + ": " + run.len + " фишки, от " + cell(run.cells[0]));
const groups = groupRuns(runs);
say("групп " + groups.length + ": " + groups.map((gr) => shapeOf(gr) + ", фишек " + gr.cells.size).join("; "));
const perGroup = groups.reduce((s, gr) => s + POINTS_PER_TILE * gr.cells.size, 0);
const perRun = runs.reduce((s, run) => s + POINTS_PER_TILE * run.len, 0);
say("очки: по группе " + perGroup + ", по каждой серии отдельно " + perRun);
const rev = groupRuns(runs.slice().reverse());
say("сначала столбцы, потом строки: групп " + rev.length + ", фишек " + rev[0].cells.size);
const a = copyGrid(g);
const b = copyGrid(g);
say("найти все, потом убрать: убрано " + removeGroups(a, groups) + ", серий осталось " + findRuns(a).length);
board(a);
const early = removeWhileScanning(b);
say("убирать строку сразу при находке: убрано " + early + ", фишек группы осталось на поле " + (groups[0].cells.size - early));
board(b);
}
say("");
say("# 4. Падение: ход (6,6)↔(6,7), столбец 7 после удаления, до досыпки");
for (const [label, opts] of [["уплотнение столбца", {}], ["на 1 клетку за проход", { oneCellFall: true }]]) {
const { g, rng } = fresh();
[g[6][6], g[6][7]] = [g[6][7], g[6][6]];
const groups = groupRuns(findRuns(g));
removeGroups(g, groups);
gravity(g, opts);
say(label + ": столбец 7 сверху вниз " + g.map((row) => (row[7] < 0 ? "." : COLORS[row[7]])).join("") +
", висят над пустотой " + hanging(g));
const r = refill(g, rng);
say(" досыпано " + r.added + ", из них встали под старыми фишками " + r.underOld);
}
say("");
say("# 5. Каскады и очки: ход (1,2)↔(1,3)");
{
const { g, rng } = fresh();
const r = trySwap(g, [1, 2], [1, 3], rng);
for (const c of r.log) say("каскад " + c.cascade + ": " + c.shapes.join(", ") + ", фишек " + c.gone + ", очков " + c.points);
say("итого: каскадов " + r.cascades + ", очков " + r.points + "; серий на поле после хода " + findRuns(g).length);
}
say("");
say("# 6. 200 партий по 30 ходов, зёрна 1–200, ход выбирает генератор из списка ходов");
function play(opts = {}) {
const t = { moves: 0, cascades: 0, deepest: 0, points: 0, perRun: 0, shapes: {}, dead: 0, tries: 0,
falseDead: 0, hangingMax: 0, underOld: 0, firstDead: null };
for (let s = 1; s <= 200; s++) {
const rng = makeRng(s);
const { g } = fillStart(rng);
for (let i = 1; i <= 30; i++) {
let moves = listMoves(g);
if (moves.length > 0 && listMoves(g, { onlyRight: true }).length === 0) t.falseDead += 1;
if (moves.length === 0) {
t.dead += 1;
if (!t.firstDead) t.firstDead = { seed: s, move: i, g: copyGrid(g) };
t.tries += reshuffle(g, rng);
moves = listMoves(g);
}
const [a, b] = moves[rng.int(moves.length)];
const r = trySwap(g, a, b, rng, opts);
t.moves += 1; t.cascades += r.cascades; t.deepest = Math.max(t.deepest, r.cascades);
t.points += r.points; t.perRun += r.pointsPerRun;
for (const k of Object.keys(r.shapes)) t.shapes[k] = (t.shapes[k] || 0) + r.shapes[k];
t.hangingMax = Math.max(t.hangingMax, r.hangingMax); t.underOld += r.underOld;
}
}
return t;
}
const t = play();
say("ходов " + t.moves + ", каскадов " + t.cascades + ", каскадов в самом длинном ходе " + t.deepest);
const total = Object.values(t.shapes).reduce((s, n) => s + n, 0);
const order = ["линия 3", "линия 4", "линия 5", "линия 6", "L", "T", "крест", "сложная"];
say("групп " + total + ": " + order.filter((k) => t.shapes[k]).map((k) => k + " — " + t.shapes[k]).join(", "));
const cross = t.shapes.L + t.shapes.T + (t.shapes["крест"] || 0) + (t.shapes["сложная"] || 0);
say("групп с общей фишкой (L, T, крест, сложная): " + cross + " из " + total);
say("очки по группам " + t.points + ", по каждой серии отдельно " + t.perRun + " (+" + num((t.perRun / t.points - 1) * 100, 1) + " %)");
say("тупиков без хода " + t.dead + ", попыток перемешивания " + t.tries);
say("проверка ходов только вправо: ложных «ходов нет» " + t.falseDead);
const f = play({ oneCellFall: true });
say("падение по 1 клетке: висят над пустотой до " + f.hangingMax + ", новых фишек под старыми " + f.underOld +
"; при уплотнении — " + t.hangingMax + " и " + t.underOld);
say("");
say("# 7. Первый тупик: зерно " + t.firstDead.seed + ", перед ходом " + t.firstDead.move);
{
const g = t.firstDead.g;
board(g);
say("ходов " + listMoves(g).length + ", серий " + findRuns(g).length);
const tries = reshuffle(g, makeRng(t.firstDead.seed));
say("перемешивание: попыток " + tries + ", ходов после " + listMoves(g).length + ", серий " + findRuns(g).length);
}
process.stdout.write(out.join("\n") + "\n");
Проверка в Node.js
Ниже — полный вывод node test.mjs на Node.js 24.22.1; мы запускали его 25 раз подряд, вывод совпадал байт в байт. Координаты клеток везде — (строка, столбец) с нуля, поле печатается сверху вниз.
Вывод прогона:
# 0. Модель
поле 8×8, цветов 6 (ABCDEF); очки = 10 × фишек в группе × номер каскада; зерно 7
# 1. Стартовое поле игры, зерно 7
BFDFAFCA
AFFDCDDE
ECCFCCAE
FCBFACCA
ADEADFBD
CBDEBAFD
CFCBBFDC
BCBAEEAD
с проверкой: серий 0, ходов 17, перебросов цвета 0
# 1а. Стартовое поле, зерно 4: без проверки и с проверкой
BDDEADAB
DEDCDEFC
BCDBBEAD
CACEEDED
BEDBACDA
ADFACAEC
CFFDADBB
BEBAEAAA
без проверки: серий на старте 2, даровых очков до первого хода 270, каскадов 3
с проверкой: серий 0, перебросов цвета 3, ходов 15
1000 зёрен без проверки: полей с готовой серией 904, даровых очков в среднем 158,9
1000 зёрен с проверкой: полей с серией 0, перебросов в среднем 2,8, ходов от 3 до 32, в среднем 14,5, полей без хода 0
# 2. Обмен и откат
(0,0)↔(0,2): не соседи; поле не изменилось: да
(0,0)↔(0,1): нет серии, откат; поле не изменилось: да
(1,2)↔(1,3): ход, очков 140; поле не изменилось: нет
# 3. Серии, уголок и порядок удаления: ход (0,3)↔(1,3)
серия по строке: 3 фишки, от (1,1)
серия по столбцу: 3 фишки, от (1,3)
групп 1: L, фишек 5
очки: по группе 50, по каждой серии отдельно 60
сначала столбцы, потом строки: групп 1, фишек 5
найти все, потом убрать: убрано 5, серий осталось 0
BFDDAFCA
A...CDDE
ECC.CCAE
FCB.ACCA
ADEADFBD
CBDEBAFD
CFCBBFDC
BCBAEEAD
убирать строку сразу при находке: убрано 3, фишек группы осталось на поле 2
BFDDAFCA
A...CDDE
ECCFCCAE
FCBFACCA
ADEADFBD
CBDEBAFD
CFCBBFDC
BCBAEEAD
# 4. Падение: ход (6,6)↔(6,7), столбец 7 после удаления, до досыпки
уплотнение столбца: столбец 7 сверху вниз ....AEEA, висят над пустотой 0
досыпано 4, из них встали под старыми фишками 0
на 1 клетку за проход: столбец 7 сверху вниз .AEEA..., висят над пустотой 1
досыпано 4, из них встали под старыми фишками 3
# 5. Каскады и очки: ход (1,2)↔(1,3)
каскад 1: линия 4, фишек 4, очков 40
каскад 2: линия 5, фишек 5, очков 100
итого: каскадов 2, очков 140; серий на поле после хода 0
# 6. 200 партий по 30 ходов, зёрна 1–200, ход выбирает генератор из списка ходов
ходов 6000, каскадов 8667, каскадов в самом длинном ходе 8
групп 9303: линия 3 — 8640, линия 4 — 502, линия 5 — 27, линия 6 — 1, L — 62, T — 56, крест — 9, сложная — 6
групп с общей фишкой (L, T, крест, сложная): 133 из 9303
очки по группам 431030, по каждой серии отдельно 433810 (+0,6 %)
тупиков без хода 6, попыток перемешивания 47
проверка ходов только вправо: ложных «ходов нет» 88
падение по 1 клетке: висят над пустотой до 4, новых фишек под старыми 6634; при уплотнении — 0 и 0
# 7. Первый тупик: зерно 72, перед ходом 25
BFDEFDAF
ECDDACBA
EABCBDDF
CAEAFABA
DFFECFDC
ACFBDBAA
FDECFECF
EACBFEDB
ходов 0, серий 0
перемешивание: попыток 2, ходов после 19, серий 0
Что показал прогон: четыре ловушки
Четыре ловушки воспроизвелись и изменили поле или счёт: ловушка 1 — раздел 3 вывода, ловушка 2 — раздел 1а, ловушка 3 — разделы 4 и 6, ловушка 4 — разделы 6 и 7. Ещё четыре ожидания прогон не подтвердил или подтвердил слабее — о них в следующем разделе.
Ловушка 1: убирать серию сразу при находке
Если убирать серию по строке сразу, как только её нашли, вертикальная часть уголка теряется: к поиску по столбцам общая фишка уже пуста, и от вертикальной тройки остаются 2 фишки. В разделе 3 вывода ход (0,3)↔(1,3) дал уголок L из 5 фишек: правильный порядок «найти все, потом убрать» убрал 5, а удаление при находке — только 3, и 2 фишки F остались стоять в столбце 3. Игрок видит, что собрал уголок, а поле убирает только его половину.
Ловушка редкая, поэтому её легко пропустить в ручной проверке: за 200 партий по 30 ходов групп с общей фишкой (L, T, крест, сложная) было 133 из 9303. Остальные — прямые линии, на которых ошибка ничего не меняет.
Ловушка 2: стартовое поле без проверки
Если заполнять поле случайными цветами без проверки, на нём почти всегда уже есть серии, и игра начисляет очки до первого хода. На 1000 зёрен без проверки готовая серия была на 904 полях, а даровых очков набегало в среднем 158,9 на партию. На зерне 4 — 2 серии, 270 очков и 3 каскада, пока игрок ещё ничего не сделал. С проверкой при заполнении серий на старте не было ни на одном из 1000 полей, а стоило это в среднем 2,8 переброса цвета на поле.
Ловушка 3: падение на одну клетку за проход
Если за проход опускать каждую фишку только на одну клетку вниз, после удаления четырёх фишек столбец не уплотняется, и досыпка ставит новые фишки под старые. В разделе 4 вывода столбец 7 после правильного падения — ....AEEA, а после падения «на 1 клетку» — .AEEA...: одна фишка висит над пустотой, и из 4 досыпанных 3 встали в самый низ, под старые фишки. Для игрока это выглядит как фишки, которые появились посреди поля из ниоткуда.
В партиях ошибка копится: за те же 6000 ходов с падением по 1 клетке над пустотой висело до 4 фишек сразу, а новых фишек под старыми встало 6634; при уплотнении столбца — 0 и 0.
Ловушка 4: тупик без ходов и проверка только вправо
Если не проверять, остался ли ход, партия рано или поздно встаёт: за 6000 ходов поле 6 раз оказывалось без единого хода. Первый тупик — зерно 72 перед 25-м ходом, поле напечатано в разделе 7 вывода: серий 0, ходов 0. Перемешивание за 2 попытки дало поле без серий и с 19 ходами; на все 6 тупиков ушло 47 попыток.
Вторая половина ловушки — неполная проверка. Если перебирать только обмены вправо, вертикальные ходы не видны: за 6000 ходов такая проверка 88 раз сказала «ходов нет», когда они были. Это 88 лишних перемешиваний, которые игрок увидит как беспричинную перестановку всего поля.
Что не подтвердилось
Четыре ожидания прогон не подтвердил или подтвердил слабее, чем мы думали:
- «Порядок поиска — сначала строки или сначала столбцы — меняет результат». Нет, если удалять после полного поиска: в разделе 3 обе очерёдности дали 1 группу из 5 фишек. Порядок важен только при удалении сразу при находке — это ловушка 1.
- «Уголок, посчитанный как две серии, сильно раздувает счёт». На одном уголке — заметно: 60 очков вместо 50, общая фишка посчитана дважды. Но за 6000 ходов разница всего +0,6 %: 433810 против 431030, потому что уголков мало. Исправить всё равно стоит — в уровнях с целью по очкам и с наградой за уголки это уже не мелочь.
- «Каскады могут не закончиться, нужен большой предохранитель». На поле 8×8 с 6 цветами — нет: самый длинный ход дал 8 каскадов, всего за 6000 ходов было 8667 каскадов, и предел 100 ни разу не сработал. Предохранитель мы оставили — он дешёвый и защищает от ошибки в падении или досыпке.
- «Стартовое поле может оказаться без хода». На 1000 зёрен — ни разу: ходов на старте было от 3 до 32, в среднем 14,5. Тупики появлялись только в середине партии, поэтому проверять нужно после каждого хода, а не только на старте.
Практический сценарий: сверить своё ядро с контрольными числами
Задача: вы переписали ядро под свою игру — другое поле в данных, свои имена функций, может быть, TypeScript — и хотите убедиться, что не внесли ни одной из четырёх ошибок. Входные данные — наш генератор с зерном, поле 8×8 из 6 цветов и правило очков из раздела 0.
- Старт. Зерно 7 с проверкой должно дать поле из раздела 1 буква в букву и 17 ходов; зерно 4 без проверки — 270 даровых очков. Если первое поле другое, у вас другой порядок заполнения или вызовов генератора.
- Откат. Обмены (0,0)↔(0,2) и (0,0)↔(0,1) на поле зерна 7 не должны менять ни одной клетки.
- Уголок. Ход (0,3)↔(1,3): одна группа L из 5 фишек, 50 очков. Если убрано 3 — у вас удаление при находке; если 60 очков — уголок считается двумя сериями.
- Каскады. Ход (1,2)↔(1,3): линия 4 за 40 очков, потом линия 5 за 100, итого 140.
- Падение. Ход (6,6)↔(6,7): столбец 7 до досыпки —
....AEEA. Если.AEEA..., фишки падают на одну клетку за проход. - Тупик. Зерно 72, 25-й ход в разделе 7: ваша проверка должна найти 0 ходов, а после перемешивания — хотя бы один.
Проверяемый итог: все шесть проверок совпали с выводом прогона. Если совпали пункты 1–5, а в партиях встречаются «беспричинные» перемешивания, проверьте, что поиск ходов смотрит и вправо, и вниз.
Когда вам это не подойдёт
Поиск серий по строкам и столбцам, падение по столбцам и досыпка сверху подходят для классического поля без препятствий; вот где этого мало:
- Особые фишки за 4, 5, L и T. Бонусные фишки требуют, чтобы после поиска на месте группы оставалась новая фишка, а её срабатывание убирало клетки вне серий. Форма группы из
shapeOf— только начало этой логики. - Поле с дырами, льдом и блоками. Если в столбце есть клетки, через которые фишки не падают, уплотнение «весь столбец вниз» не работает; падение считают по участкам между препятствиями.
- Уровни с ограничением ходов и гарантией прохождения. Проверить, что уровень проходится за N ходов, перебором дорого: по Wikipedia, обобщённые match-3 на поле n×n при известной заранее досыпке — NP-трудная задача. Практичнее прогнать бота на сотнях зёрен, как в разделе 6 нашего вывода, и дополнить это плейтестом.
- Игра в реальном времени. Если игрок может ходить, пока фишки ещё падают, цикл «поиск → удаление → падение» уже не идёт целиком за один вызов; у каждой фишки появляется своё состояние, и проверка серий учитывает только лежащие.
- Большие поля. Мы после каждого обмена в
listMovesищем серии по всему полю; на 8×8 это незаметно, но на больших полях проверяют только строку и столбец двух обменянных клеток.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200): Wikipedia — Tile-matching video game (Shariki (1994) — первая match-3; Bejeweled (2001); уровни с ограничением ходов с Candy Crush Saga (2012); больше очков за большие совпадения и за совпадения после падения; NP-трудность обобщённых match-3); Wikipedia — Shariki (1994, MS-DOS, Евгений Алемжин; каждый обмен должен дать совпадение, новые шарики падают сверху, конец игры — когда совпадений нет); Wikipedia — Bejeweled (video game) (PopCap Games; Diamond Mine в браузере в 2000 году, MSN Games, Bejeweled Deluxe в мае 2001 года); Wikipedia — Linear congruential generator (при модуле-степени двойки младшие биты имеют короткий период); MDN — Math.imul() (32-битное умножение «как в C»). Поле, цвета, правило очков, зёрна и все числа прогона — наш пример и наш прогон в Node.js 24.22.1.
Читайте также:
- Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого
- Тетрис на JavaScript: поворот фигур, отталкивание от стен и очистка линий
- Очки, множители серии и рекорды в 2D-игре: как считать награду, чтобы хотелось переиграть
- Головоломки на сетке: от Sokoban (1982) до современных инди
- Циклы и ветвления в игровой логике: ранний выход и бюджет кадра