---
title: "Слои отрисовки и порядок глубины: Z-order и сортировка по Y в 2D"
description: "Почему в 2D-игре глубина — это порядок рисования, как задать слои и сортировать объекты внутри слоя по точке опоры, а не по верху спрайта, зачем ключу id для ничьих, почему компаратор «1 или 0» не сортирует и как не сломать порядок прыжком. Код на JavaScript проверен в Node.js 24 семью сценариями: 1000 объектов — 999 сравнений на почти готовом списке против 8655 на случайном."
slug: sloi-otrisovki-i-poryadok-glubiny-z-order-i-sortirovka-po-y-v-2d
date: 2026-11-14
updated: 2026-11-14
scheduled_at: "2026-11-14T09:00:00+03:00"
rubric: ustrojstvo-2d-igr
tags: ["otrisovka", "z-order", "sortirovka", "javascript", "novichkam"]
reading_time: 20
draft: false
summary: "В 2D-игре видно то, что нарисовано позже, поэтому глубина задаётся порядком рисования: сначала слой (земля, мир, передний план, интерфейс), внутри мирового слоя — Y точки опоры объекта, при равенстве — постоянный id. Сортировать по верху или центру спрайта нельзя: высокое дерево тогда рисуется раньше героя, который стоит за ним. Высоту прыжка держат отдельно от Y опоры, а компаратор возвращает отрицательное, ноль или положительное число — иначе V8 оставит массив как есть."
---

## Коротко

В 2D-игре видно то, что нарисовано позже, поэтому глубину задаёт порядок рисования. Ключ сортировки складывается из трёх частей: слой (земля, мир, передний план, интерфейс), внутри мирового слоя — Y точки опоры объекта, при равенстве — постоянный id. Высота прыжка хранится отдельно и на порядок не влияет, а сортировка почти готового списка каждый кадр стоит около n сравнений.

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

1. Почему порядок рисования и есть глубина
2. Слои: грубый порядок от земли до интерфейса
3. Сортировка по Y: какая точка объекта считается
4. Ничьи и мигание: третий признак ключа
5. Компаратор, который не сортирует
6. Прыжок и высота над землёй
7. Сколько стоит сортировать каждый кадр
8. Код на JavaScript и проверка в Node.js
9. Обвязка для браузера
10. Практический сценарий: герой проходит мимо дерева
11. Когда вам это не подойдёт

## Почему порядок рисования и есть глубина

В обычном 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» — ни разу.

Ключ целиком:

```text
сначала 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) окажется бочка — герой «нырнул» за неё посреди прыжка. При сортировке по опоре там виден герой. Тень героя при этом остаётся в слое земли под точкой опоры и показывает игроку, где он приземлится.

```text
нижний край картинки = 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.

```js
// 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):

```text
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` для браузера удалите или вынесите в отдельный файл.

```js
// 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. Шаги:

1. **Опора.** Задать у дерева и героя `y` точки опоры, а не верхнего угла картинки; прямоугольник спрайта считать через `spriteRect`.
2. **Слой.** Дерево и героя положить в мировой слой, тень героя — в слой земли.
3. **Ключ.** Сортировать по `compareDepth`: слой → Y → id.
4. **Проверка.** На каждом шаге смотреть, кто виден в точке на груди героя (`y − 20`), и считать, сколько раз ответ сменился.

Проверяемый итог — сценарий 7: ровно одна смена, при `y = 210`. Если смен больше одной, где-то порядок зависит от положения в массиве; если смена происходит не на уровне основания ствола, опора задана не той точкой. Тот же тест удобно держать для каждого нового высокого объекта: столба, дома, статуи.

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

Сортировка «слой → Y → id» решает большинство сцен, но не все:

- **Изометрия и объекты на нескольких клетках.** В изометрической сетке ключом обычно служит сумма координат клетки, а длинные объекты вроде стены через три клетки одной точкой опоры не описываются: их режут на части по клеткам или сортируют по отношению «кто кого закрывает». Это тот случай, где алгоритм художника из 1972 года требует разрезать фигуры.
- **Платформер с видом сбоку.** Там глубина почти не меняется: игрок не уходит «вглубь», и хватает слоёв из таблицы выше без сортировки по Y.
- **Многоэтажные уровни.** Мост над дорогой, балкон, второй этаж: объект наверху может иметь меньший Y, чем объект под ним, но должен быть поверх. Нужен ещё один признак ключа — уровень высоты, — или отдельный слой для верхнего яруса.
- **Тысячи объектов с разными текстурами в WebGL.** Сортировка по Y рвёт пакеты по атласам. Там чаще используют буфер глубины и записывают Y в координату глубины, но полупрозрачные спрайты всё равно приходится сортировать.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=sloi-otrisovki-i-poryadok-glubiny-z-order-i-sortirovka-po-y-v-2d) (подача заявки не гарантирует приглашение).

**Источники (проверено: ноябрь 2026, 11.11.2026):** [MDN — CanvasRenderingContext2D: globalCompositeOperation](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation) (`source-over` по умолчанию — новая фигура рисуется поверх уже нарисованного); [Wikipedia — Painter's algorithm](https://en.wikipedia.org/wiki/Painter%27s_algorithm) (сортировка от дальнего к ближнему; Ньюэлл, Ньюэлл и Санча, 1972; разрезание при циклическом перекрытии); [MDN — Array.prototype.sort()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) (требования к компаратору; стабильность с ECMAScript 2019; компаратор «1 или 0» в V8, JavaScriptCore и SpiderMonkey); [V8 — Getting things sorted in V8](https://v8.dev/blog/array-sort) (28.09.2018; Timsort и стабильная сортировка с V8 7.0 / Chrome 70; отсортированный массив — за линейное время). Размеры объектов, координаты, число слоёв, скорость героя и подсчёт сравнений — наши значения и наш прогон в Node.js 24.

**Читайте также:**
- [Тайловые сетки и устройство 2D-миров: слои уровня и автотайлинг](/blog/tajlovye-setki-i-ustrojstvo-2d-mirov)
- [Камера, параллакс и «джус»: как оживить плоскую сцену в 2D-игре](/blog/kamera-parallaks-i-game-feel-v-2d-igre)
- [Отрисовка 2D-игры в браузере: пакетная отправка спрайтов](/blog/webgpu-i-webgl2-kak-rabotaet-otrisovka-2d-igry)
- [Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly)
