---
title: "Match-3 на JavaScript: поиск совпадений, падение и каскады"
description: "Как собрать match-3 на чистом JavaScript: поле 8×8 как двумерный массив, генератор с зерном вместо Math.random, стартовое поле без готовых серий, обмен соседних фишек и откат, поиск серий по строкам и столбцам, слияние уголков L и T, удаление, падение столбца, досыпка сверху, каскады с очками и перемешивание, когда ходов нет. Четыре ловушки показаны прогоном в Node.js 24."
slug: match-3-na-javascript-sovpadeniya-padenie-i-kaskady
date: 2026-11-21
updated: 2026-11-21
scheduled_at: "2026-11-21T19:00:00+03:00"
rubric: praktika-i-uroki
tags: ["javascript", "golovolomki", "algoritmy", "sluchajnost", "novichkam"]
reading_time: 23
draft: false
summary: "Match-3 держится на одном цикле: найти все серии из трёх и больше одинаковых фишек по строкам и столбцам, слить серии с общей фишкой в одну группу, убрать их разом, уплотнить каждый столбец вниз, досыпать сверху и повторять, пока серии появляются. В нашем прогоне удаление серии сразу при находке оставило на поле 2 фишки уголка из 5, стартовое поле без проверки дало в среднем 158,9 очка до первого хода, падение на одну клетку за проход поставило 3 новые фишки под старые, а за 6000 ходов поле 6 раз осталось без единого хода."
---

## Коротко

Match-3 на JavaScript — это двумерный массив цветов и один цикл после каждого хода: найти все серии из 3+ одинаковых фишек по строкам и столбцам, слить серии с общей фишкой (уголки L и T) в группу, убрать всё найденное разом, уплотнить каждый столбец вниз, досыпать новые фишки сверху и повторять, пока появляются новые серии — это и есть каскады. Обмен засчитывается, только если дал серию, иначе фишки возвращаются на место. Стартовое поле строят без готовых серий, а после каждого хода проверяют, что ход ещё есть, и перемешивают фишки, если его нет.

## Содержание

1. Откуда взялся match-3
2. Из чего состоит игра в коде
3. Поле и генератор с зерном
4. Стартовое поле без готовых серий
5. Обмен соседних фишек и откат
6. Поиск серий по строкам и столбцам
7. Удаление, падение и досыпка
8. Каскады и очки
9. Есть ли ход и перемешивание
10. Код на JavaScript
11. Проверка в Node.js
12. Что показал прогон: четыре ловушки
13. Что не подтвердилось
14. Практический сценарий: сверить своё ядро с контрольными числами
15. Когда вам это не подойдёт

## Откуда взялся 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 соотносится с другими головоломками на сетке, мы рассказывали в статье про [головоломки на сетке](/blog/golovolomki-na-setke-ot-sokoban-1982-do-sovremennyh-indi); дальше — только код.

## Из чего состоит игра в коде

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

| Часть | Функция | Что делает |
|---|---|---|
| Генератор | `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`, а из своего генератора с зерном: одно и то же зерно даёт одно и то же стартовое поле и одну и ту же досыпку. Это нужно для проверки (вывод совпадает байт в байт), для повтора уровня и для отладки: ошибку, которую нашёл игрок, можно воспроизвести по зерну. Зачем нужно зерно и как случайность сделать честной, мы разбирали в статье про [случайность без несправедливости](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor); а как одинаковые входные данные дают одинаковый результат во всей игре — в статье про [повтор прохождения](/blog/povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya).

Наш генератор — линейный конгруэнтный: каждое следующее число получается из предыдущего умножением и сложением по модулю 2³². Умножение делается через `Math.imul` — по MDN, это 32-битное умножение «как в C». У такого генератора с модулем-степенью двойки, по Wikipedia, младшие биты повторяются с коротким периодом, поэтому мы берём число целиком и делим на 2³², а номер цвета получаем из старших разрядов через `Math.floor(next() * n)`.

## Стартовое поле без готовых серий

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

```text
для каждой строки 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, поэтому диагональ и обмен через клетку не проходят.

```text
ход(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, в середине обеих — крест.

```text
группа = серии, у которых есть общие клетки (сливаем, пока сливается)
форма:
  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 особую фишку, а число клеток — для очков.

## Удаление, падение и досыпка

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

```text
для каждого столбца c:
  запись = нижняя строка
  для r от нижней строки до верхней:
    если g[r][c] не пусто: перенести g[r][c] в g[запись][c], запись = запись − 1
досыпка: каждая пустая клетка получает новый цвет из генератора
```

После такого уплотнения все пустые клетки в столбце оказываются сверху, и досыпка ставит новые фишки только над старыми. В прогоне ход (6,6)↔(6,7) убрал линию 4 в столбце 7, и столбец после падения выглядел так: `....AEEA` — четыре пустые клетки сверху, четыре старые фишки внизу, под пустотой не висит ни одна. Как показать падение плавно, а не мгновенно, — дело отрисовки: логике достаточно запомнить при уплотнении, из какой строки в какую перенесена каждая фишка, а сам переход описан в статье про [tween и функции плавности](/blog/plavnye-perehody-tween-i-funkcii-plavnosti-na-javascript). Тетрис, где тоже убирают ряды и всё сверху опускается, устроен иначе — там сдвигаются целые строки; это разобрано в [тетрисе на JavaScript](/blog/tetris-na-javascript-povorot-figur-ottalkivanie-ot-sten-i-ochistka-linij).

## Каскады и очки

Каскад — это повтор цикла «поиск → удаление → падение → досыпка» после одного хода, пока на поле появляются новые серии. Цикл кончается, когда поиск вернул пустой список; на всякий случай у него есть предохранитель — не больше 100 каскадов за ход, как советуют для любого `while`, который может не закончиться, в статье про [циклы и ветвления](/blog/cikly-i-vetvleniya-v-igrovoj-logike-rannij-vyhod-i-byudzhet-16-ms).

Очки в нашем примере считаются по группе, а не по серии:

```text
очки группы = 10 × число фишек в группе × номер каскада
```

Первый каскад идёт с множителем 1, второй — 2 и так далее; так поздние совпадения стоят дороже, как и описывает Wikipedia для жанра. Ход (1,2)↔(1,3) из прогона: каскад 1 — линия 4, 40 очков; каскад 2 — линия 5, 100 очков; итого 140, и после хода на поле нет ни одной серии. Как выбирать шаг множителя, потолок и окно серии в аркаде, мы разбирали отдельно в статье про [очки, множители и рекорды](/blog/ochki-mnozhiteli-serii-i-rekordy-kak-schitat-nagradu); здесь множитель — просто номер каскада.

## Есть ли ход и перемешивание

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

Если ходов нет, фишки перемешивают алгоритмом Фишера — Йейтса и повторяют, пока поле не станет без готовых серий и хотя бы с одним ходом. Цвета при этом не меняются, меняются только места: у игрока остаются те же фишки. Сам алгоритм перемешивания и почему он честный, разобраны в статье про [случайность](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor).

Проверку делают после каждого хода, а не только на старте: каскады и досыпка могут привести к тупику в середине партии.

## Код на JavaScript

Пример — два файла: `match3.mjs` с ядром игры и `test.mjs`, который прогоняет проверки по разделам и печатает итог. Нужен Node.js 24 и папка с этими файлами; запуск — `node test.mjs`. Случайность только из генератора с зерном, поэтому вывод повторяется байт в байт.

Опции включают ошибки для ловушек: `noCheck` в `fillStart` — старт без проверки серий, `oneCellFall` в `gravity` — падение на одну клетку за проход, `onlyRight` в `listMoves` — поиск ходов только обменом вправо; `removeWhileScanning` — удаление строчных серий сразу при находке, а `pointsPerRun` — очки за каждую серию отдельно, для сравнения.

```js
// 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;
}
```

```js
// 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 раз подряд, вывод совпадал байт в байт. Координаты клеток везде — (строка, столбец) с нуля, поле печатается сверху вниз.

**Вывод прогона:**

```text
# 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.

1. **Старт.** Зерно 7 с проверкой должно дать поле из раздела 1 буква в букву и 17 ходов; зерно 4 без проверки — 270 даровых очков. Если первое поле другое, у вас другой порядок заполнения или вызовов генератора.
2. **Откат.** Обмены (0,0)↔(0,2) и (0,0)↔(0,1) на поле зерна 7 не должны менять ни одной клетки.
3. **Уголок.** Ход (0,3)↔(1,3): одна группа L из 5 фишек, 50 очков. Если убрано 3 — у вас удаление при находке; если 60 очков — уголок считается двумя сериями.
4. **Каскады.** Ход (1,2)↔(1,3): линия 4 за 40 очков, потом линия 5 за 100, итого 140.
5. **Падение.** Ход (6,6)↔(6,7): столбец 7 до досыпки — `....AEEA`. Если `.AEEA...`, фишки падают на одну клетку за проход.
6. **Тупик.** Зерно 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. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=match-3-na-javascript-sovpadeniya-padenie-i-kaskady) (подача заявки не гарантирует приглашение).

**Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200):** [Wikipedia — Tile-matching video game](https://en.wikipedia.org/wiki/Tile-matching_video_game) (Shariki (1994) — первая match-3; Bejeweled (2001); уровни с ограничением ходов с Candy Crush Saga (2012); больше очков за большие совпадения и за совпадения после падения; NP-трудность обобщённых match-3); [Wikipedia — Shariki](https://en.wikipedia.org/wiki/Shariki) (1994, MS-DOS, Евгений Алемжин; каждый обмен должен дать совпадение, новые шарики падают сверху, конец игры — когда совпадений нет); [Wikipedia — Bejeweled (video game)](https://en.wikipedia.org/wiki/Bejeweled_(video_game)) (PopCap Games; Diamond Mine в браузере в 2000 году, MSN Games, Bejeweled Deluxe в мае 2001 года); [Wikipedia — Linear congruential generator](https://en.wikipedia.org/wiki/Linear_congruential_generator) (при модуле-степени двойки младшие биты имеют короткий период); [MDN — Math.imul()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul) (32-битное умножение «как в C»). Поле, цвета, правило очков, зёрна и все числа прогона — наш пример и наш прогон в Node.js 24.22.1.

**Читайте также:**
- [Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor)
- [Тетрис на JavaScript: поворот фигур, отталкивание от стен и очистка линий](/blog/tetris-na-javascript-povorot-figur-ottalkivanie-ot-sten-i-ochistka-linij)
- [Очки, множители серии и рекорды в 2D-игре: как считать награду, чтобы хотелось переиграть](/blog/ochki-mnozhiteli-serii-i-rekordy-kak-schitat-nagradu)
- [Головоломки на сетке: от Sokoban (1982) до современных инди](/blog/golovolomki-na-setke-ot-sokoban-1982-do-sovremennyh-indi)
- [Циклы и ветвления в игровой логике: ранний выход и бюджет кадра](/blog/cikly-i-vetvleniya-v-igrovoj-logike-rannij-vyhod-i-byudzhet-16-ms)
