byte theme_id;        // b1 - индекс темы (0, 1, 2)
	byte spawn_y;         // b2 - Y координата спавна в тайлах
	byte spawn_x;         // b3 - X координата спавна в тайлах  
	byte ball_type;       // b4 - 0=маленький, другое=большой
	byte exit_y_tiles;    // this.ar - Y тайла выхода (h.java:199, h.java:640)
	byte exit_x_tiles;    // this.D  - X тайла выхода (h.java:200, h.java:641)
	byte enemy_count;     // j - количество врагов
	// Далее: enemy_count записей по 9 байт (moving objects / enemies)
	```

**Подтверждение смысла `exit_x/exit_y` по коду:**
- `h.b(levelIndex)` читает `this.ar` и `this.D` из meta-chunk сразу после `ball_type` (h.java:195-201).
- В `h.c(Graphics)` эти значения используются как координаты тайла выхода: `n=this.ar`, `i1=this.D`; затем один раз вычисляются пиксельные координаты двери `P=i1*16`, `R=n*16` (h.java:640-646).
- Условие завершения уровня в `a.d()` проверяет попадание игрока в прямоугольник `32×48` относительно `E.P/E.R` при `E.o==true` (a.java:607-612), то есть `E.P/E.R` — именно позиция двери в пикселях, а `this.ar/this.D` — её позиция в тайлах.

### Спавн игрока (пиксели)

`h.b(level)` превращает `spawn_x/spawn_y` в пиксели так:
- `spawnPx = spawnTiles * 16 + 8`, если `ball_type == 0`
- `spawnPx = spawnTiles * 16 + 12`, если `ball_type != 0`

И выбирает стартовый спрайт мяча:
- `ball_type == 0` → sprite index `0`
- иначе → sprite index `11`

### Enemy record: ровно 9 байт (h.java:208-240)

| Offset | Type | Имя (предлагаемое) | Описание / куда кладется |
|---:|---:|---|---|
| 0 | `i8` | `enemyType` | `this.ao[i]` (используется как тип поведения/спрайта) |
| 1 | `i8` | `tileX0` | `this.f[i][0]` (один угол bbox/области движения в тайлах) |
| 2 | `i8` | `tileY0` | `this.f[i][1]` |
| 3 | `i8` | `tileX1` | `this.k[i][0]` (второй угол bbox/области движения) |
| 4 | `i8` | `tileY1` | `this.k[i][1]` |
| 5 | `i8` | `initOffA` | `byte * 16` → `this.ag[i][1]` (пиксельный оффсет внутри области) |
| 6 | `i8` | `initOffB` | `byte * 16` → `this.ag[i][0]` |
| 7 | `i8` | `speedA` | `this.s[i][1]` (скорость/псевдо‑скорость по оси A) |
| 8 | `i8` | `speedB` | `this.s[i][0]` (скорость по оси B) |

**Нормализация области:** если `tileX0 > tileX1` **или** `tileY0 > tileY1`, код:
- меняет местами `X0↔X1` и `Y0↔Y1`,
- пересчитывает `initOffA/initOffB` как ширину/высоту области в пикселях: `(X1-X0)*16`, `(Y1-Y0)*16`,
- если `speedA>0` или `speedB>0` — инвертирует знак (чтобы движение “поехало” в ожидаемую сторону).

Практический дамп этих записей из `bounce_back/original_code/.../res/lf` можно получить скриптом `bounce_back/dump_lf_enemies.py`.

### TileMap chunk (следующий chunk)

`g.java` ожидает `tileMap` в виде:
- `u8 height`
- `u8 width`
- затем `height * width` байт тайлов (в строковом порядке), где:
  - `tileId = tileByte & 0x7F`
  - `tileByte & 0x80` — флаг заливки `bgColor` перед рисованием тайла (и используется в коллизиях как часть “тайла”)

---

## Формат `/res/b` (Ball) — маски игрока + спрайты (FACT)

Источник: конструктор `a(...)` (Player) читает `/res/b` через `c("/res/b")` (a.java:83).

`/res/b` — контейнер `c.java`. Порядок чтения элементов:

1) **chunk[0] = player masks (binary, НЕ PNG)**

Формат chunk[0] (a.java:89-99):
- `u8 maskCount` (a.java:89-90)
- для каждой маски `i`:
  - `u8 w`, `u8 h` (a.java:92-94)
  - `boolean[w][h]` заполнение `readBoolean()` (1 байт) (a.java:95-98)

Ориентация маски:
- используется как `mask[x][y]` при вызове tile-engine collision (см. `g.java:395`).

2) **chunk[1..25] = 25 PNG спрайтов мяча**

Оригинал читает 25 изображений подряд через `c.a()` (a.java:104-108) и кладёт в `a.w[0..24]`.

### Выбор маски по spriteIndex (FACT)

Перед коллизиями игрок выбирает индекс маски так (a.java:243-249):
- `spriteIndex ∈ [0..8]` или `[20..22]` → mask `0`
- `spriteIndex ∈ [9..19]` → mask `1`

Размер collision-rect берётся из выбранной маски:
- `w = mask.length`, `h = mask[0].length`, `rect = (x - w/2, y - h/2, w, h)` (a.java:250-255).

---

## Враги / moving objects (h.java)

В этой сборке “враги” — это набор движущихся объектов, полностью задаваемых данными из `/res/lf`.

### Runtime‑модель (массивы h.java)

После чтения enemy records `h.b(level)` инициализирует массивы длиной `enemy_count (j)`:
- `ao[i]` — `enemyType` из `/res/lf`
- `f[i][0..1]`, `k[i][0..1]` — углы bbox/области движения (тайлы)
- `ag[i][0..1]` — текущий пиксельный оффсет внутри области (меняется каждый tick)
- `s[i][0..1]` — скорости/псевдо‑скорости (меняются каждый tick)

### Размеры хитбокса (h.a/h.b)

Используются в player↔enemy коллизии (`a.java`, метод `a(..., boolean)`):

| enemyType | widthPx | heightPx |
|---:|---:|---:|
| `0` | `32` | `32` |
| `1` | `16` | `16` |
| `2` | `24` | `11` |

### Update на каждый tick (h.d)

- Для `enemyType == 0` и `enemyType == 2`:
  - объект двигается по двум осям внутри прямоугольной области, скорость задается как **пиксели на tick** (через `abs(speed)` и знак),
  - при достижении 0 или max (ширины/высоты области) скорость по соответствующей оси разворачивается.
- Для `enemyType == 1`:
  - движение по одной оси с “псевдо‑ускорением” (через `speedA`), с ограничением и разворотом на краях.

### Рендер (h.b(Graphics))

`enemyType` выбирает спрайт из `ac[]`:
- `type 2` → `ac[0]`
- `type 0` → `ac[1]`
- `type 1` → `ac[2]` или `ac[3]` (в зависимости от направления `s[i][1]`)

Для отрисовки используется: `baseTile * 16 + agOffset` (то есть `ag[]` — именно **в пикселях**).

---

## Формат метаданных тайлов (/res/tf)

**Загрузка:** `h.java:254-256`

`/res/tf` — бинарный контейнер из **2 объектов** (в этой версии): первый содержит заголовок + таблицу анимаций + метаданные части тайлов, второй — хвост метаданных тайлов (см. `g.java`).

### Заголовок (object 0)

| Поле | Тип | Смысл | Значение в этой версии |
|---|---:|---|---|
| `images_total` | `u8` | Всего изображений-тайлов для слоя | `111` |
| `images_base` | `u8` | Сколько из них лежит в base-контейнере (`/res/if0` или `/res/ib0`) | `104` |
| `clampX` | `u8` | **Clamp по X** (1=clamp, 0=wrap) | `1` |
| `clampY` | `u8` | **Clamp по Y** (1=clamp, 0=wrap) | `1` |
| `tileW` | `u8` | Ширина тайла (если `12`, нормализуется в `16`) | `12 → 16` |
| `tileH` | `u8` | Высота тайла (если `12`, нормализуется в `16`) | `12 → 16` |
| `tileCount` | `u8` | Кол-во тайлов (типов) | `117` |
| `splitIndex` | `u8` | Индекс тайла, с которого чтение метаданных переключается на object 1 | `110` |
| `tileIdMask` | `u8` | Маска `tileId` в `tileMap` байте | `0x7F` |
| `tileFlagMask` | `u8` | Маска флага в `tileMap` байте (используется для заливки фона) | `0x80` |
| `bgColor` | `u32` | Цвет заливки (ARGB/RGB в зависимости от платформы) | `0x7F00007F` |

### Таблица анимаций (object 0, сразу после заголовка)

| Поле | Тип | Смысл | Значение в этой версии |
|---|---:|---|---|
| `animCount (U)` | `u8` | Кол-во групп анимации | `20` |

Сразу после 14-байтового заголовка объекта 0 идёт `animCount` (1 байт); отдельного “global reserved byte” между заголовком и `animCount` нет.

**Для каждой группы (0..animCount-1):**

| Поле | Тип | Смысл | Значение в этой версии |
|---|---:|---|---|
| `reserved` | `u8` | Не используется (пропускается в `g.java:193`) | — |
| `period (O[i])` | `u8` | Период в тиках до смены кадра | `5` (для всех групп) |
| `frameCount` | `u8` | Кол-во кадров в группе | 2–3 |
| `frames[] (m[i])` | `u8[]` | Список `tileId`, которые будут подставляться по кругу | (см. файлы) |

### Метаданные тайла (object 0/1)

Запись на каждый `tileId` (всего `tileCount` записей). Для `tileId < splitIndex` читается из object 0 **после** таблицы анимаций, для `tileId >= splitIndex` — из object 1.

| Поле | Тип | Смысл |
|---|---:|---|
| `tileIdEcho` | `i8` | В этой версии равен текущему `tileId` (0..116) и в коде не сохраняется (похоже на контроль/заглушку) |
| `renderType (v[tile])` | `u8` | `0`=пусто, `1`=картинка, `3`=анимация через `animGroup` |
| `imageIndex (T[tile])` | `u8` | Индекс изображения в `V[]` (tile atlas/images) |
| `transform (b[tile])` | `u8` | Rotate/flip (используется в draw и в `collisionType=3`) |
| `collisionType (l[tile])` | `u8` | `0`=нет, `1`=mask без трансформаций, `2`=solid, `3`=mask с трансформациями + алиас маски |
| `mask` | `bool[tileH][tileW]` | Присутствует только при `collisionType=1` (256 байт при 16×16); индексация как `mask[y][x]` |
| `aux (af[tile])` | `u32` | Перегруженное поле: при `renderType=3` это `animGroup`; при `collisionType=3` это `maskBaseTileId` для алиаса `s[tile]=s[aux]` |

### Семантика байта карты `tileMap`

`tileId = tileByte & tileIdMask` (обычно `0x7F`), а `tileByte & tileFlagMask` (обычно `0x80`) в `g.a(...)` приводит к заливке под тайлом `bgColor` перед рисованием.

---

## Контракт коллизий (g.java)

Самый рискованный участок порта — pixel-perfect коллизии тайлов. Детальный “collision contract” (подпись `collisionTest`, математика выбора тайлов, `collisionType`, `transform`, `aux` alias, и минимальные тест‑кейсы по реальным уровням) вынесен в [`COLLISION_CONTRACT.md`](COLLISION_CONTRACT.md).

## Константы физики (из анализа a.java)

### Прыжок
- **Normal:** `-125` (метод `h()` строка 543)
- **Inverted:** `-180` (+44% силы, строка 545)
- **Popped:** `-95` (-24% силы, строка 547)

### Бонусы
- **Длительность:** `450` тиков (строки 505, 512, 519)
- **Модификатор прыжка:** `+25%` (строка 549-555)

### Горизонтальное движение
- **Ускорение:** `18` normal, `22` с бонусом (строка 1394)
- **Макс. скорость:** `60` normal, `100` с бонусом (строка 1398)
- **Трение:** `3` в воздухе, `8` на земле (строка 1410)

### Entity ID бонусов
- **ID 11:** Включить инверсию (`this.I = true`)
- **ID 18:** Выключить инверсию (`this.I = false`)
- **ID 15:** Бонус гравитации
- **ID 22:** Бонус прыжка
- **ID 26:** Бонус скорости
- **ID 39:** Бонус скорости 2

---

## Примечания для портирования на SDL2

### Критические различия с bounce_zero

1. **Размер тайла:** 16×16 px (vs 12×12 в zero)
2. **Framerate:** 20 FPS / 50ms (vs 30 FPS в zero)
3. **Формат ресурсов:** Контейнеры `/res/*` (vs отдельные файлы)
4. **Система тем:** 3 визуальные темы (vs 1 в zero)
5. **Инверсия:** Постоянное состояние через boolean (vs временный бонус в zero)

### Приоритеты реализации

1. ✅ Парсер контейнеров (`c.java` → SDL2 resource loader)
2. ⏳ Распаковка `/res/lf` (формат уровней)
3. ⏳ Распаковка `/res/tf` (метаданные тайлов)
4. ⏳ Распаковка `/res/if*` (текстуры по темам)
5. ⏳ Распаковка `/res/b` (спрайты мяча)
6. ⏳ Система инверсии гравитации
7. ⏳ Физика с новыми константами

---

## История изменений

- **2026-02-04:** Создан файл, добавлена карта ресурсов, частичный анализ Player (a.java)
- **2026-02-04:** Проанализированы `b.java`/`d.java` и формат/использование `/res/r` (демо/реплей)
- **2026-02-04:** Найдены две исходные сборки (`G313002`/`G313003`) с одинаковой логикой, но разными языками строк (EN/RU); различие по разрешению задается через поля `Nokia-MIDlet-*-Display-Size` в `MANIFEST.MF`
- *Дополняется по мере анализа...*

---

## TODO - Требует анализа

- [ ] Детальная структура `/res/tf` (метаданные тайлов)
- [ ] Формат анимаций тайлов
- [ ] `/res/tf` — точный формат и таблицы: `tileType (v)`, `collisionType (l)`, `transform (b)`, анимации (`U/O/m`)
- [ ] Класс `i.java` (MenuCanvas) - полный маппинг режимов `uiMode (V)` и сценариев экранов `screenId (g)`
- [ ] Класс `e.java` - назначение и связи с UI/score/RMS
- [ ] `/res/lf`: проверить, встречаются ли `enemyType` кроме `0..2` (в коде поведение описано только для них)
- [ ] Формат collision masks в `/res/tf`