Коротко
В 2D-игре видно то, что нарисовано позже, поэтому глубину задаёт порядок рисования. Ключ сортировки складывается из трёх частей: слой (земля, мир, передний план, интерфейс), внутри мирового слоя — Y точки опоры объекта, при равенстве — постоянный id. Высота прыжка хранится отдельно и на порядок не влияет, а сортировка почти готового списка каждый кадр стоит около n сравнений.
Содержание
- Почему порядок рисования и есть глубина
- Слои: грубый порядок от земли до интерфейса
- Сортировка по Y: какая точка объекта считается
- Ничьи и мигание: третий признак ключа
- Компаратор, который не сортирует
- Прыжок и высота над землёй
- Сколько стоит сортировать каждый кадр
- Код на JavaScript и проверка в Node.js
- Обвязка для браузера
- Практический сценарий: герой проходит мимо дерева
- Когда вам это не подойдёт
Почему порядок рисования и есть глубина
В обычном 2D-рисовании на canvas нет буфера глубины: каждая новая фигура ложится поверх уже нарисованного, и выше оказывается тот, кого нарисовали последним. Так работает режим наложения source-over, который у CanvasRenderingContext2D стоит по умолчанию. Значит, «кто перед кем» в 2D-игре решается одним вопросом — в каком порядке обходить список объектов при рисовании.
Этот подход называют алгоритмом художника: сначала дальнее, потом ближнее, как художник пишет горы, затем луг, затем деревья. Его описали Мартин Ньюэлл, Ричард Ньюэлл и Том Санча в 1972 году для трёхмерной графики, но в 2D он работает почти без оговорок: плоские спрайты не пересекают друг друга, а только перекрывают.
Запомнить достаточно одного правила: объект, который должен закрывать другой, рисуется после него. Числовое значение «глубины» само по себе не важно — важно, что список отсортирован так, чтобы это правило выполнялось.
Слои: грубый порядок от земли до интерфейса
Слой — первый и главный признак ключа: всё, что лежит на земле, рисуется раньше всего мира, а интерфейс — после. Для игры с видом сверху или сбоку хватает четырёх слоёв:
| Слой | Номер | Что в нём | Сортировка внутри |
|---|---|---|---|
| Земля | 0 | тени, лужи, следы, тайлы пола | нет, порядок добавления |
| Мир | 1 | герой, враги, деревья, бочки, сундуки | по Y точки опоры |
| Передний план | 2 | кроны над дорогой, арки, туман | нет |
| Интерфейс | 3 | счёт, здоровье, подсказки | нет |
Тень героя — частая ошибка новичка: если положить её в мировой слой, тень соседнего дерева может лечь поверх ног персонажа. Всё плоское, что лежит на земле, — в слой 0. Подробно о слоях уровня, фоне и параллаксе — в статьях про тайловые сетки и про камеру; здесь важно другое: что делать внутри мирового слоя, где объекты перекрывают друг друга по мере движения.
Сортировка по Y: какая точка объекта считается
Внутри мирового слоя объекты сортируют по Y точки опоры — нижней точки, которой объект касается земли: ноги героя, основание ствола, дно бочки. Чем ниже на экране опора, тем ближе объект к зрителю и тем позже его рисуют. Это работает и для вида сверху под углом, и для RPG с видом «три четверти».
Типичная ошибка — сортировать по координате, которая уже есть у спрайта: по верхнему краю (так удобно рисовать через drawImage) или по центру. Наш пример: дерево 64 × 96 px с основанием в y = 210, герой 32 × 48 px стоит чуть выше, ногами в y = 200, то есть за деревом.
| Ключ сортировки | Дерево | Герой | Порядок | Кто виден в точке (300, 180) |
|---|---|---|---|---|
| Верх спрайта | 114 | 152 | дерево → герой | герой (ошибка) |
| Центр спрайта | 162 | 176 | дерево → герой | герой (ошибка) |
| Точка опоры | 210 | 200 | герой → дерево | дерево (верно) |
Высокий объект всегда «выигрывает» по верху и центру, потому что его картинка начинается выше. Поэтому координату объекта удобно с самого начала хранить как точку опоры, а прямоугольник спрайта вычислять от неё: top = y − h. Тогда сортировать можно прямо по y, без пересчётов.
Ничьи и мигание: третий признак ключа
Если у двух объектов одинаковый Y, порядок между ними должен решать постоянный признак, например id, иначе они начнут меняться местами. Сортировка в JavaScript стабильна со стандарта ECMAScript 2019: равные элементы сохраняют свой порядок. Но это порядок в массиве, а он меняется, когда объект удаляют и добавляют снова — например, при возврате из пула.
В нашем прогоне две бочки стоят на одной линии y = 250 и перекрываются на 20 px. Раз в 15 кадров первый объект списка уходит в конец — как при повторном спавне. С ключом «только Y» за 120 кадров верхняя бочка сменилась 8 раз — игрок видит мигание. С ключом «Y, затем id» — ни разу.
Ключ целиком:
сначала layer по возрастанию
затем y опоры по возрастанию (только в мировом слое)
затем id по возрастанию (id выдаётся при создании и не меняется)
Компаратор, который не сортирует
Функция сравнения для sort обязана возвращать отрицательное число, ноль или положительное, и одинаково для пары (a, b) и (b, a) с обратным знаком. Сокращение вида (a, b) => a.y > b.y ? 1 : 0 выглядит рабочим, но нарушает это правило: для a < b оно говорит «равны». По документации MDN, V8 (Chrome, Node.js) и JavaScriptCore (Safari) такой массив не сортируют вовсе, а SpiderMonkey (Firefox) сортирует — то есть игра выглядит по-разному в разных браузерах.
Наш прогон в Node.js это подтверждает: [3, 1, 4, 1, 5, 9] с компаратором «1 или 0» остался [3, 1, 4, 1, 5, 9], а с a − b стал [1, 1, 3, 4, 5, 9]. Для чисел безопасна разность a.y − b.y, для составного ключа — цепочка «если признаки различаются, вернуть разность, иначе перейти к следующему», как в compareDepth ниже. Ещё одно требование MDN — компаратор не должен ничего менять: не двигайте в нём объекты и не пересчитывайте позиции.
Прыжок и высота над землёй
Высоту прыжка хранят отдельно от Y опоры: спрайт рисуют на z пикселей выше, а сортируют по Y на земле. Прыжок не перемещает героя вглубь сцены, он только поднимает картинку, поэтому место в порядке рисования не меняется.
Пример: бочка 40 × 40 px стоит опорой в y = 210, герой ногами в y = 220 — перед ней — и прыгает на высоту z = 40. Нижний край его картинки теперь 180, выше бочки. Если сортировать по нижнему краю картинки, в точке (300, 175) окажется бочка — герой «нырнул» за неё посреди прыжка. При сортировке по опоре там виден герой. Тень героя при этом остаётся в слое земли под точкой опоры и показывает игроку, где он приземлится.
нижний край картинки = y − z
верх картинки = y − z − h
ключ сортировки = y (z не участвует)
Сколько стоит сортировать каждый кадр
Сортировать весь мировой слой каждый кадр обычно дёшево, потому что между кадрами порядок почти не меняется. С версии V8 7.0 и Chrome 70 Array.prototype.sort работает по алгоритму Timsort (о переходе команда V8 написала 28 сентября 2018 года): он ищет уже упорядоченные участки, и полностью отсортированный массив проходит за линейное время.
Наш подсчёт вызовов компаратора на 1000 объектах в Node.js 24:
| Входной список | Сравнений |
|---|---|
| Случайный порядок | 8655 |
| Уже отсортирован (прошлый кадр, никто не двигался) | 999 |
| 50 объектов сдвинулись на ±2 px | 2317 |
Поэтому выгоднее сортировать один и тот же массив на месте, кадр за кадром, чем каждый раз собирать новый список в случайном порядке: тогда сортировка получает почти готовый вход. Если объекты лежат в разных атласах, сортировка по Y перемешивает их и увеличивает число вызовов отрисовки — как это посчитать, разобрано в статье про пакетную отрисовку.
Код на JavaScript и проверка в Node.js
Модуль ниже не рисует сам, а решает две задачи: вычисляет прямоугольник спрайта от точки опоры и сравнивает объекты по ключу «слой → Y → id». Для проверки в Node.js в нём есть программный «холст» topAt: он перебирает список в порядке рисования и возвращает имя последнего объекта, накрывшего точку, — так же, как это сделал бы canvas.
// depth.mjs — порядок отрисовки 2D: слои, сортировка по Y, стабильный ключ
export const LAYER = { GROUND: 0, WORLD: 1, OVER: 2, UI: 3 }; // снизу вверх
// Объект: x — центр, y — точка опоры на земле (ноги, основание ствола),
// z — высота над землёй (прыжок), w и h — размер спрайта в px
export function spriteRect(o) {
const bottom = o.y - (o.z ?? 0); // рисуем выше опоры на высоту прыжка
return { left: o.x - o.w / 2, top: bottom - o.h, right: o.x + o.w / 2, bottom };
}
// Составной ключ: слой → Y опоры (только в мире) → id. Возвращает −1, 0 или 1
export function compareDepth(a, b) {
if (a.layer !== b.layer) return a.layer - b.layer;
if (a.layer === LAYER.WORLD && a.y !== b.y) return a.y - b.y;
return a.id - b.id; // ничья решается одинаково в каждом кадре
}
// Программный «холст»: рисуем прямоугольники по порядку, позже нарисованный — сверху
export function topAt(list, px, py) {
let top = null;
for (const o of list) {
const r = spriteRect(o);
if (px >= r.left && px < r.right && py >= r.top && py < r.bottom) top = o.name;
}
return top;
}
// ---- проверка в Node.js ----
const tree = { id: 1, name: 'дерево', layer: LAYER.WORLD, x: 300, y: 210, w: 64, h: 96 };
const hero = { id: 2, name: 'герой', layer: LAYER.WORLD, x: 300, y: 200, w: 32, h: 48 };
const byKey = key => (a, b) => key(a) - key(b);
const top = o => spriteRect(o).top, center = o => (spriteRect(o).top + spriteRect(o).bottom) / 2;
// 1. Алгоритм художника: что нарисовано позже, то и сверху
console.log('1) рисуем дерево, потом героя → в точке (300, 180):', topAt([tree, hero], 300, 180),
'| наоборот →', topAt([hero, tree], 300, 180));
// 2. Герой стоит за деревом (опора 200 < 210): какой ключ сортировки даёт верную картинку
for (const [name, cmp] of [['верх спрайта', byKey(top)], ['центр спрайта', byKey(center)], ['точка опоры', compareDepth]]) {
const list = [tree, hero].sort(cmp);
console.log(`2) ключ «${name}»: порядок ${list.map(o => o.name).join(' → ')}, в (300, 180) видно: ${topAt(list, 300, 180)}`);
}
// 3. Ничья по Y: две бочки на одной линии, массив меняет порядок при возврате объекта из пула
const barrelA = { id: 10, name: 'бочка A', layer: LAYER.WORLD, x: 100, y: 250, w: 40, h: 40 };
const barrelB = { id: 11, name: 'бочка B', layer: LAYER.WORLD, x: 120, y: 250, w: 40, h: 40 };
for (const [name, cmp] of [['только Y', byKey(o => o.y)], ['Y, затем id', compareDepth]]) {
let objects = [barrelA, barrelB], last = null, flips = 0;
for (let frame = 0; frame < 120; frame++) {
if (frame % 15 === 14) objects = [...objects.slice(1), objects[0]]; // первый ушёл в конец списка
const seen = topAt([...objects].sort(cmp), 110, 240);
if (last && seen !== last) flips++;
last = seen;
}
console.log(`3) ключ «${name}»: за 120 кадров смен верхней бочки — ${flips}`);
}
// 4. Компаратор, который возвращает только 1 и 0, в V8 не сортирует
const ys = [3, 1, 4, 1, 5, 9];
console.log('4) (a > b ? 1 : 0):', JSON.stringify([...ys].sort((a, b) => (a > b ? 1 : 0))),
'| a − b:', JSON.stringify([...ys].sort((a, b) => a - b)));
// 5. Прыжок: сортируем по опоре на земле, а не по нижнему краю картинки
const barrel = { id: 3, name: 'бочка', layer: LAYER.WORLD, x: 300, y: 210, w: 40, h: 40 };
const jumper = { id: 4, name: 'герой', layer: LAYER.WORLD, x: 300, y: 220, z: 40, w: 32, h: 48 };
const byDrawnBottom = byKey(o => spriteRect(o).bottom);
console.log('5) герой в прыжке перед бочкой, в (300, 175) по опоре:', topAt([barrel, jumper].sort(compareDepth), 300, 175),
'| по нижнему краю картинки:', topAt([barrel, jumper].sort(byDrawnBottom), 300, 175));
// 6. Цена сортировки каждый кадр: 1000 объектов, считаем вызовы компаратора
function seeded(seed) { let s = seed >>> 0; return () => (s = (s * 1664525 + 1013904223) >>> 0) / 2 ** 32; }
const rand = seeded(53);
const world = Array.from({ length: 1000 }, (_, i) => ({ id: i, layer: LAYER.WORLD, y: Math.floor(rand() * 2000) }));
const count = arr => { let n = 0; arr.sort((a, b) => (n++, compareDepth(a, b))); return n; };
const randomCalls = count([...world]);
const sorted = [...world].sort(compareDepth);
const sortedCalls = count([...sorted]);
const moved = sorted.map(o => ({ ...o }));
for (let i = 0; i < 50; i++) moved[Math.floor(rand() * 1000)].y += Math.floor(rand() * 5) - 2; // 50 сдвинулись на ±2 px
const nearlyCalls = count(moved);
console.log(`6) 1000 объектов: случайный порядок — ${randomCalls} сравнений, уже отсортированы — ${sortedCalls}, после кадра с 50 сдвигами — ${nearlyCalls}`);
// 7. Сценарий: герой идёт вниз мимо дерева, опора с 190 до 228 px, шаг 2 px; смотрим точку на груди героя
let switches = 0, prev = null, switchY = null;
for (let y = 190; y <= 228; y += 2) {
const h = { ...hero, y };
const seen = topAt([tree, h].sort(compareDepth), 300, y - 20);
if (prev && seen !== prev) { switches++; switchY = y; }
prev = seen;
}
console.log(`7) проход мимо дерева: смен «кто сверху» — ${switches}, герой впереди с опоры y = ${switchY} px (у дерева 210)`);
Вывод прогона (проверено в Node.js 24.22.1, 11.11.2026):
1) рисуем дерево, потом героя → в точке (300, 180): герой | наоборот → дерево
2) ключ «верх спрайта»: порядок дерево → герой, в (300, 180) видно: герой
2) ключ «центр спрайта»: порядок дерево → герой, в (300, 180) видно: герой
2) ключ «точка опоры»: порядок герой → дерево, в (300, 180) видно: дерево
3) ключ «только Y»: за 120 кадров смен верхней бочки — 8
3) ключ «Y, затем id»: за 120 кадров смен верхней бочки — 0
4) (a > b ? 1 : 0): [3,1,4,1,5,9] | a − b: [1,1,3,4,5,9]
5) герой в прыжке перед бочкой, в (300, 175) по опоре: герой | по нижнему краю картинки: бочка
6) 1000 объектов: случайный порядок — 8655 сравнений, уже отсортированы — 999, после кадра с 50 сдвигами — 2317
7) проход мимо дерева: смен «кто сверху» — 1, герой впереди с опоры y = 210 px (у дерева 210)
Что показывают семь сценариев:
- 1. Алгоритм художника. В точке, где дерево и герой перекрываются, виден тот, кого нарисовали вторым.
- 2. Точка опоры. Ключи «верх спрайта» и «центр спрайта» ставят героя, который стоит за деревом, перед ним; ключ по опоре даёт верную картинку.
- 3. Ничьи. Без id верхняя из двух бочек на одной линии сменилась 8 раз за 120 кадров — каждый раз, когда список менял порядок; с id — 0 раз.
- 4. Компаратор. «1 или 0» в V8 оставил массив без изменений.
- 5. Прыжок. По опоре герой в прыжке остаётся перед бочкой, по нижнему краю картинки — прячется за неё.
- 6. Цена. 999 сравнений на готовом списке, 2317 после одного кадра движения, 8655 на случайном.
- 7. Проход мимо дерева. Порядок меняется ровно один раз — при опоре героя
y = 210, равной опоре дерева. При ничьей решает id: у героя он больше, поэтому герой уже впереди.
Обвязка для браузера
В браузере тот же ключ используется так: объекты лежат в одном массиве, массив сортируется на месте раз в кадр, затем обходится по порядку. Блок проверки в конце depth.mjs для браузера удалите или вынесите в отдельный файл.
// main.js — обвязка для браузера: один список, сортировка раз в кадр, рисование по порядку
import { LAYER, spriteRect, compareDepth } from './depth.mjs';
const canvas = document.querySelector('canvas');
const ctx = canvas.getContext('2d');
canvas.width = 640; canvas.height = 360;
let nextId = 1;
const make = (o) => ({ id: nextId++, z: 0, ...o }); // id выдаётся один раз и не меняется
const objects = [
make({ name: 'тень', layer: LAYER.GROUND, x: 300, y: 214, w: 56, h: 8, color: '#0004' }),
make({ name: 'дерево', layer: LAYER.WORLD, x: 300, y: 210, w: 64, h: 96, color: '#2a6' }),
make({ name: 'бочка', layer: LAYER.WORLD, x: 400, y: 260, w: 40, h: 40, color: '#a62' }),
make({ name: 'счёт', layer: LAYER.UI, x: 60, y: 30, w: 100, h: 20, color: '#fff' }),
];
const hero = make({ name: 'герой', layer: LAYER.WORLD, x: 200, y: 240, w: 32, h: 48, color: '#36c' });
objects.push(hero);
const held = new Set();
addEventListener('keydown', e => held.add(e.code));
addEventListener('keyup', e => held.delete(e.code));
let last = performance.now();
function frame(now) {
const dt = Math.min(now - last, 250) / 1000; last = now;
const speed = 120; // px/с
hero.x += ((held.has('ArrowRight') ? 1 : 0) - (held.has('ArrowLeft') ? 1 : 0)) * speed * dt;
hero.y += ((held.has('ArrowDown') ? 1 : 0) - (held.has('ArrowUp') ? 1 : 0)) * speed * dt;
objects.sort(compareDepth); // почти отсортированный список — дёшево
ctx.fillStyle = '#7b5'; ctx.fillRect(0, 0, canvas.width, canvas.height);
for (const o of objects) {
const r = spriteRect(o);
ctx.fillStyle = o.color;
ctx.fillRect(r.left, r.top, r.right - r.left, r.bottom - r.top);
}
requestAnimationFrame(frame);
}
requestAnimationFrame(frame);
Подключите main.js как модуль к странице с одним элементом canvas и откройте её через локальный сервер. Стрелками ведите синий прямоугольник-героя вокруг зелёного дерева: выше основания ствола он уходит за дерево, ниже — выходит вперёд, тень остаётся под всем, а счёт — поверх всего. Синтаксис обвязки проверен командой node --check. Три детали:
- id выдаётся один раз. Функция
makeприсваивает номер при создании; если объект возвращается из пула, номер не меняется. - Сортировка на месте.
objects.sort(compareDepth)каждый кадр получает массив, упорядоченный в прошлом кадре, — это вариант «почти отсортирован» из таблицы выше. - Дробные координаты. Герой движется со скоростью 120 px/с, и
yдробный; разностьa.y − b.yс ним работает, а округлять для сортировки не нужно.
Практический сценарий: герой проходит мимо дерева
Задача: в деревне с видом сверху герой должен проходить за деревом и перед ним без скачков картинки. Входные условия — дерево 64 × 96 px с основанием ствола в y = 210, герой 32 × 48 px идёт сверху вниз, опора меняется с 190 до 228 px с шагом 2 px. Шаги:
- Опора. Задать у дерева и героя
yточки опоры, а не верхнего угла картинки; прямоугольник спрайта считать черезspriteRect. - Слой. Дерево и героя положить в мировой слой, тень героя — в слой земли.
- Ключ. Сортировать по
compareDepth: слой → Y → id. - Проверка. На каждом шаге смотреть, кто виден в точке на груди героя (
y − 20), и считать, сколько раз ответ сменился.
Проверяемый итог — сценарий 7: ровно одна смена, при y = 210. Если смен больше одной, где-то порядок зависит от положения в массиве; если смена происходит не на уровне основания ствола, опора задана не той точкой. Тот же тест удобно держать для каждого нового высокого объекта: столба, дома, статуи.
Когда вам это не подойдёт
Сортировка «слой → Y → id» решает большинство сцен, но не все:
- Изометрия и объекты на нескольких клетках. В изометрической сетке ключом обычно служит сумма координат клетки, а длинные объекты вроде стены через три клетки одной точкой опоры не описываются: их режут на части по клеткам или сортируют по отношению «кто кого закрывает». Это тот случай, где алгоритм художника из 1972 года требует разрезать фигуры.
- Платформер с видом сбоку. Там глубина почти не меняется: игрок не уходит «вглубь», и хватает слоёв из таблицы выше без сортировки по Y.
- Многоэтажные уровни. Мост над дорогой, балкон, второй этаж: объект наверху может иметь меньший Y, чем объект под ним, но должен быть поверх. Нужен ещё один признак ключа — уровень высоты, — или отдельный слой для верхнего яруса.
- Тысячи объектов с разными текстурами в WebGL. Сортировка по Y рвёт пакеты по атласам. Там чаще используют буфер глубины и записывают Y в координату глубины, но полупрозрачные спрайты всё равно приходится сортировать.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: ноябрь 2026, 11.11.2026): MDN — CanvasRenderingContext2D: globalCompositeOperation (source-over по умолчанию — новая фигура рисуется поверх уже нарисованного); Wikipedia — Painter's algorithm (сортировка от дальнего к ближнему; Ньюэлл, Ньюэлл и Санча, 1972; разрезание при циклическом перекрытии); MDN — Array.prototype.sort() (требования к компаратору; стабильность с ECMAScript 2019; компаратор «1 или 0» в V8, JavaScriptCore и SpiderMonkey); V8 — Getting things sorted in V8 (28.09.2018; Timsort и стабильная сортировка с V8 7.0 / Chrome 70; отсортированный массив — за линейное время). Размеры объектов, координаты, число слоёв, скорость героя и подсчёт сравнений — наши значения и наш прогон в Node.js 24.
Читайте также: