applications/PoP: порт Prince of Persia — PoC (roomtest) + пайплайн
Порт PoP на Sprinter. Текущий PoC — applications/PoP/roomtest/: комната 1 (фон-композиция тайлов) + Kid с управлением на raw-клавиатуре и коллизией с картой. - roomtest — pop_bg (фон), pop_kid (спрайты Kid, column-major флип, seqtbl-анимация), pop_ctrl (порт control() PoP на held-state kbd_raw), pop_map (коллизия seg004/005: бег/стоп у стены, падение/приземление, отскок seq_47, вертикальный прыжок K4.1). MEMORY=small (DATA сразу за CODE, ~23КБ кода не лезет в huge). - toolchain (PoP) — pop_pack_kid/pop_pack_bg/render_room/extract — распаковка res-графики MSDOS в атласы + композиция комнат. - toolchain/ (корень) — make_hdd.sh (быстрый HDD-тест вместо FDD), png_strip.py / room_compose.py (ассет-пайплайн). - docs — PORT_PLAN, KID_PLAN, форматы ресурсов (Apple II / MSDOS / DAT). - bgtest/coltest/poc — ранние PoC (фон, коллизия, первый прототип). .gitignore: build-артефакты applications/*/*/*; исключены внешние референс-репозитории (SDLPoP/mininim/PR/Apple-II — свои git-клоны) и оригинальные game-данные MSDOS/ (копирайт, только для реверса форматов). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,34 @@
|
||||
# roomtest — проверка порта статического фона PoP (Шаг 3): реальная
|
||||
# композиция слоёв (pop_bg.c) для комнаты 1. --memory huge --gfx 256.
|
||||
|
||||
PROJ_ROOT := $(abspath $(CURDIR)/../../..)
|
||||
EXAMPLE := roomtest
|
||||
# small: W1+W2 как единое 32КБ-пространство, DATA сразу за CODE (иначе
|
||||
# CODE ~23КБ переполняет W1 и лезет в фиксированный DATA@0x8000 в huge).
|
||||
MEMORY ?= small
|
||||
EXTRA_FLAGS ?= --gfx 256
|
||||
EXTRA_SRCS := pop_bg.c pop_kid.c pop_ctrl.c pop_map.c
|
||||
|
||||
BG_DIR := $(CURDIR)/../poc/res/bg
|
||||
KID_DIR := $(CURDIR)/../poc/res/kid
|
||||
BG_DATA := $(BG_DIR)/pop_env0.atl $(BG_DIR)/pop_env1.atl $(BG_DIR)/pop_env2.atl \
|
||||
$(BG_DIR)/pop_env3.atl $(BG_DIR)/pop_env4.atl \
|
||||
$(BG_DIR)/pop_wall.atl $(BG_DIR)/pop_fore.atl
|
||||
# ВСЕ 28 страниц Kid — иначе кадры торможения/разворота/приседа (image>23)
|
||||
# не рисуются (kid_draw пропускает незагруженную страницу). Палитра —
|
||||
# ЕДИНАЯ игровая (env+wall+kid).
|
||||
KID_PAGES := $(foreach n,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27,$(KID_DIR)/kid$(n).atl)
|
||||
KID_DATA := $(KID_PAGES) $(KID_DIR)/kid.pal
|
||||
|
||||
EXTRA_DATA := $(BG_DATA) $(KID_DATA)
|
||||
include $(PROJ_ROOT)/app.mk
|
||||
|
||||
TC := $(PROJ_ROOT)/applications/PoP/toolchain
|
||||
$(BG_DATA): $(TC)/pop_pack_bg.py $(TC)/render_room.py
|
||||
cd $(TC) && python3 pop_pack_bg.py
|
||||
$(KID_DATA): $(TC)/pop_pack_kid.py $(TC)/pop_pack_bg.py
|
||||
cd $(TC) && python3 pop_pack_kid.py
|
||||
kid_data.h: $(TC)/pop_extract_kid_data.py
|
||||
cd $(TC) && python3 pop_extract_kid_data.py
|
||||
|
||||
$(EXAMPLE).exe: pop_bg.c pop_bg.h pop_kid.c pop_kid.h pop_ctrl.c pop_ctrl.h pop_map.c pop_map.h kid_data.h room1_data.h $(BG_DATA) $(KID_DATA)
|
||||
@@ -0,0 +1,474 @@
|
||||
/* kid_data.h — данные анимации Kid (frame_table + seqtbl +
|
||||
* offsets), извлечено toolchain/pop_extract_kid_data.py из
|
||||
* SDLPoP. НЕ править вручную. seqtbl адресуется базой
|
||||
* SEQTBL_BASE: kid_seqtbl[addr - SEQTBL_BASE]. */
|
||||
#ifndef KID_DATA_H
|
||||
#define KID_DATA_H
|
||||
#include <stdint.h>
|
||||
|
||||
#define SEQTBL_BASE 0x196Eu
|
||||
|
||||
/* {image, dx, dy, flags, sword}; chtab = sword>>6 (0=kid). */
|
||||
typedef struct { uint8_t image; int8_t dx, dy; uint8_t flags, sword; } kframe;
|
||||
#define KID_NFRAMES 241
|
||||
static const kframe kid_frames[KID_NFRAMES] = {
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{ 0, 1, 0,0xC4,0x00},
|
||||
{ 1, 1, 0,0x44,0x00},
|
||||
{ 2, 3, 0,0x47,0x00},
|
||||
{ 3, 4, 0,0x48,0x00},
|
||||
{ 4, 0, 0,0xE6,0x00},
|
||||
{ 5, 0, 0,0x49,0x00},
|
||||
{ 6, 0, 0,0x4A,0x00},
|
||||
{ 7, 0, 0,0xC5,0x00},
|
||||
{ 8, 0, 0,0x44,0x00},
|
||||
{ 9, 0, 0,0x47,0x00},
|
||||
{ 10, 0, 0,0x4B,0x00},
|
||||
{ 11, 0, 0,0x43,0x00},
|
||||
{ 12, 0, 0,0xC3,0x00},
|
||||
{ 13, 0, 0,0x47,0x00},
|
||||
{ 14, 0, 0,0x43,0x09},
|
||||
{ 15, 0, 0,0xC3,0x00},
|
||||
{ 16, 0, 0,0x44,0x00},
|
||||
{ 17, 0, 0,0x46,0x00},
|
||||
{ 18, 0, 0,0x48,0x00},
|
||||
{ 19, 0, 0,0x89,0x00},
|
||||
{ 20, 0, 0,0x0B,0x00},
|
||||
{ 21, 0, 0,0x8B,0x00},
|
||||
{ 22, 0, 0,0x11,0x00},
|
||||
{ 23, 0, 0,0x07,0x00},
|
||||
{ 24, 0, 0,0x05,0x00},
|
||||
{ 25, 0, 0,0xC1,0x00},
|
||||
{ 26, 0, 0,0xC6,0x00},
|
||||
{ 27, 0, 0,0x43,0x00},
|
||||
{ 28, 0, 0,0x48,0x00},
|
||||
{ 29, 0, 0,0x42,0x00},
|
||||
{ 30, 0, 0,0x42,0x00},
|
||||
{ 31, 0, 0,0xC2,0x00},
|
||||
{ 32, 0, 0,0xC2,0x00},
|
||||
{ 33, 0, 0,0x43,0x00},
|
||||
{ 34, 0, 0,0x48,0x00},
|
||||
{ 35, 0, 0,0xCE,0x00},
|
||||
{ 36, 0, 0,0xC1,0x00},
|
||||
{ 37, 0, 0,0x45,0x00},
|
||||
{ 38, 0, 0,0x8E,0x00},
|
||||
{ 39, 0, 0,0x0B,0x00},
|
||||
{ 40, 0, 0,0x8B,0x00},
|
||||
{ 41, 0, 0,0x8A,0x00},
|
||||
{ 42, 0, 0,0x01,0x00},
|
||||
{ 43, 0, 0,0xC4,0x00},
|
||||
{ 44, 0, 0,0xC3,0x00},
|
||||
{ 45, 0, 0,0xC3,0x00},
|
||||
{ 46, 0, 0,0xA5,0x00},
|
||||
{ 47, 0, 0,0xA4,0x00},
|
||||
{ 48, 0, 0,0x66,0x00},
|
||||
{ 49, 4, 0,0x67,0x00},
|
||||
{ 50, 3, 0,0x66,0x00},
|
||||
{ 51, 1, 0,0x44,0x00},
|
||||
{ 64, 0, 0,0xC2,0x00},
|
||||
{ 65, 0, 0,0x41,0x00},
|
||||
{ 66, 0, 0,0x42,0x00},
|
||||
{ 67, 0, 0,0x00,0x00},
|
||||
{ 68, 0, 0,0x00,0x00},
|
||||
{ 69, 0, 0,0x80,0x00},
|
||||
{ 70, 0, 0,0x00,0x00},
|
||||
{ 71, 0, 0,0x80,0x00},
|
||||
{ 72, 0, 0,0x00,0x00},
|
||||
{ 73, 0, 0,0x80,0x00},
|
||||
{ 74, 0, 0,0x00,0x00},
|
||||
{ 75, 0, 0,0x00,0x00},
|
||||
{ 76, 0, 0,0x80,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{ 80, -2, 0,0x41,0x00},
|
||||
{ 81, -2, 0,0x41,0x00},
|
||||
{ 82, -1, 0,0xC2,0x00},
|
||||
{ 83, -2, 0,0x42,0x00},
|
||||
{ 84, -2, 0,0x41,0x00},
|
||||
{ 85, -2, 0,0x41,0x00},
|
||||
{ 86, -2, 0,0x41,0x00},
|
||||
{ 87, -1, 0,0x07,0x00},
|
||||
{ 88, -1, 0,0x05,0x00},
|
||||
{ 89, 2, 0,0x07,0x00},
|
||||
{ 90, 2, 0,0x07,0x00},
|
||||
{ 91, 2, -3,0x00,0x00},
|
||||
{ 92, 2, -10,0x00,0x00},
|
||||
{ 93, 2, -11,0x80,0x00},
|
||||
{ 94, 3, -2,0x43,0x00},
|
||||
{ 95, 3, 0,0xC3,0x00},
|
||||
{ 96, 3, 0,0xC3,0x00},
|
||||
{ 97, 3, 0,0x63,0x00},
|
||||
{ 98, 4, 0,0xE3,0x00},
|
||||
{ 28, 0, 0,0x00,0x00},
|
||||
{ 99, 7, -14,0x80,0x00},
|
||||
{100, 7, -12,0x80,0x00},
|
||||
{101, 4, -12,0x00,0x00},
|
||||
{102, 3, -10,0x80,0x00},
|
||||
{103, 2, -10,0x80,0x00},
|
||||
{104, 1, -10,0x80,0x00},
|
||||
{105, 0, -11,0x00,0x00},
|
||||
{106, -1, -12,0x00,0x00},
|
||||
{107, -1, -14,0x00,0x00},
|
||||
{108, -1, -14,0x00,0x00},
|
||||
{109, -1, -15,0x80,0x00},
|
||||
{110, -1, -15,0x80,0x00},
|
||||
{111, 0, -15,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{112, 0, 0,0xC6,0x00},
|
||||
{113, 0, 0,0x46,0x00},
|
||||
{114, 0, 0,0xC5,0x00},
|
||||
{115, 0, 0,0x45,0x00},
|
||||
{116, 0, 0,0xC2,0x00},
|
||||
{117, 0, 0,0xC4,0x00},
|
||||
{118, 0, 0,0xC5,0x00},
|
||||
{119, 0, 0,0x46,0x00},
|
||||
{120, 0, 0,0x47,0x00},
|
||||
{121, 0, 0,0x47,0x00},
|
||||
{122, 0, 0,0x49,0x00},
|
||||
{123, 0, 0,0xC8,0x00},
|
||||
{124, 0, 0,0xC9,0x00},
|
||||
{125, 0, 0,0x49,0x00},
|
||||
{126, 0, 0,0x45,0x00},
|
||||
{127, 2, 0,0x45,0x00},
|
||||
{128, 2, 0,0xC5,0x00},
|
||||
{129, 0, 0,0xC3,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{133, 0, 0,0x43,0x00},
|
||||
{134, 0, 0,0xC4,0x00},
|
||||
{135, 0, 0,0xC5,0x00},
|
||||
{136, 0, 0,0x48,0x00},
|
||||
{137, 0, 0,0x6C,0x00},
|
||||
{138, 0, 0,0xEF,0x00},
|
||||
{139, 0, 0,0x63,0x00},
|
||||
{140, 0, 0,0xC3,0x00},
|
||||
{141, 0, 0,0x43,0x00},
|
||||
{142, 0, 0,0x43,0x00},
|
||||
{143, 0, 0,0x44,0x00},
|
||||
{144, 0, 0,0x44,0x00},
|
||||
{172, 0, 1,0xC1,0x00},
|
||||
{173, 0, 1,0xC7,0x00},
|
||||
{145, 0, -12,0x01,0x00},
|
||||
{146, 0, -21,0x00,0x00},
|
||||
{147, 1, -26,0x80,0x00},
|
||||
{148, 4, -32,0x80,0x00},
|
||||
{149, 6, -36,0x81,0x00},
|
||||
{150, 7, -41,0x82,0x00},
|
||||
{151, 2, 17,0x42,0x00},
|
||||
{152, 4, 9,0xC4,0x00},
|
||||
{153, 4, 5,0xC9,0x00},
|
||||
{154, 4, 4,0xC8,0x00},
|
||||
{155, 5, 0,0x69,0x00},
|
||||
{156, 5, 0,0xE9,0x00},
|
||||
{157, 5, 0,0xE8,0x00},
|
||||
{158, 5, 0,0x69,0x00},
|
||||
{159, 5, 0,0x69,0x00},
|
||||
{184, 0, 2,0x80,0x10},
|
||||
{174, 0, 2,0x80,0x1A},
|
||||
{175, 3, 2,0x00,0x12},
|
||||
{176, 7, 2,0xC4,0x16},
|
||||
{177, 10, 2,0x00,0x15},
|
||||
{178, 7, 2,0x80,0x17},
|
||||
{179, 4, 2,0x80,0x19},
|
||||
{180, 0, 2,0xCE,0x18},
|
||||
{181, 0, 2,0xCD,0x0F},
|
||||
{182, 3, 2,0x00,0x14},
|
||||
{183, 3, 2,0x00,0x1F},
|
||||
{184, 0, 2,0x80,0x10},
|
||||
{185, 0, 2,0x80,0x11},
|
||||
{186, 0, 2,0x00,0x20},
|
||||
{187, 0, 2,0x80,0x21},
|
||||
{188, 2, 2,0xC3,0x22},
|
||||
{ 14, 0, 0,0x43,0x00},
|
||||
{189, 7, 2,0x80,0x13},
|
||||
{190, 1, 2,0x80,0x0E},
|
||||
{191, 0, 2,0x80,0x1B},
|
||||
{181, 0, 2,0xCD,0x0F},
|
||||
{181, 0, 2,0xCD,0x0F},
|
||||
{112, 0, 0,0xC6,0x2B},
|
||||
{113, 0, 0,0x46,0x2C},
|
||||
{114, 0, 0,0xC5,0x2D},
|
||||
{115, 0, 0,0x45,0x2E},
|
||||
{114, 0, 0,0xC5,0x00},
|
||||
{ 78, 0, 3,0x8A,0x00},
|
||||
{ 77, 4, 3,0x87,0x00},
|
||||
{211, 0, 1,0x44,0x00},
|
||||
{212, 0, 1,0x44,0x00},
|
||||
{213, 0, 1,0x44,0x00},
|
||||
{214, 0, 1,0x47,0x00},
|
||||
{215, 0, 7,0x4B,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{ 79, 4, 7,0x49,0x00},
|
||||
{130, 0, 0,0x44,0x00},
|
||||
{131, 0, 0,0x44,0x00},
|
||||
{132, 0, 2,0x44,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{192, 0, 0,0x00,0x00},
|
||||
{193, 0, 1,0x00,0x00},
|
||||
{194, 0, 0,0x80,0x00},
|
||||
{195, 0, 0,0x00,0x00},
|
||||
{196, -1, 0,0x00,0x00},
|
||||
{197, -1, 0,0x00,0x00},
|
||||
{198, -1, 0,0x00,0x00},
|
||||
{199, -4, 0,0x00,0x00},
|
||||
{200, -4, 0,0x80,0x00},
|
||||
{201, -4, 0,0x00,0x00},
|
||||
{202, -4, 0,0x00,0x00},
|
||||
{203, -4, 0,0x00,0x00},
|
||||
{204, -4, 0,0x00,0x00},
|
||||
{205, -5, 0,0x00,0x00},
|
||||
{206, -5, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{207, 0, 1,0x46,0x00},
|
||||
{208, 0, 1,0xC6,0x00},
|
||||
{209, 0, 1,0xC8,0x00},
|
||||
{210, 0, 1,0x4A,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{255, 0, 0,0x00,0x00},
|
||||
{ 52, 0, 0,0x80,0x00},
|
||||
{ 53, 0, 0,0x00,0x00},
|
||||
{ 54, 0, 0,0x00,0x00},
|
||||
{ 55, 0, 0,0x00,0x00},
|
||||
{ 56, 0, 0,0x80,0x00},
|
||||
{ 57, 0, 0,0x00,0x00},
|
||||
{ 58, 0, 0,0x00,0x00},
|
||||
{ 59, 0, 0,0x00,0x00},
|
||||
{ 60, 0, 0,0x80,0x00},
|
||||
{ 61, 0, 0,0x00,0x00},
|
||||
{ 62, 0, 0,0x80,0x00},
|
||||
{ 63, 0, 0,0x00,0x00},
|
||||
{160, 1, 1,0xC3,0x23},
|
||||
{161, 0, 1,0x49,0x24},
|
||||
{162, 0, 1,0xC3,0x25},
|
||||
{163, 0, 1,0x49,0x26},
|
||||
{164, 0, 1,0xC3,0x27},
|
||||
{165, 1, 1,0x49,0x28},
|
||||
{166, 1, 1,0x43,0x29},
|
||||
{167, 1, 1,0xC9,0x2A},
|
||||
{168, 4, 1,0xC6,0x00},
|
||||
{169, 3, 1,0xCA,0x00},
|
||||
{170, 1, 1,0x43,0x00},
|
||||
{171, 1, 1,0xC8,0x00},
|
||||
};
|
||||
|
||||
#define KID_SEQTBL_LEN 2310
|
||||
static const uint8_t kid_seqtbl[KID_SEQTBL_LEN] = {
|
||||
0xF9,0x01,0xFF,0x81,0x19,0xF9,0x01,0x01,0x02,0x03,0x04,0xFB,
|
||||
0x08,0x05,0xFB,0x03,0x06,0xFB,0x03,0x07,0xFB,0x05,0x08,0xFB,
|
||||
0x01,0xF2,0x01,0x09,0xFB,0x02,0x0A,0xFB,0x04,0x0B,0xFB,0x05,
|
||||
0x0C,0xFB,0x02,0xF2,0x01,0x0D,0xFB,0x03,0x0E,0xFB,0x04,0xFF,
|
||||
0x81,0x19,0xF9,0x00,0x0F,0xFF,0xA0,0x19,0xF9,0x01,0xA6,0xFF,
|
||||
0xA8,0x19,0xF9,0x05,0xFB,0x0A,0xB1,0xB1,0xFB,0xF9,0xFA,0xFE,
|
||||
0xB2,0xFB,0x05,0xFA,0x02,0xA6,0xFB,0xFF,0xFF,0xD2,0x19,0xFF,
|
||||
0xD2,0x19,0xF9,0x01,0xFB,0x02,0xCF,0xD0,0xFB,0x02,0xD1,0xFB,
|
||||
0x02,0xD2,0xFB,0x03,0xF9,0x01,0xF2,0x00,0x9E,0xAA,0xAB,0xFF,
|
||||
0xD8,0x19,0xF9,0x05,0xF8,0xFF,0x00,0xAC,0xFB,0xFF,0xFA,0x01,
|
||||
0xAD,0xFB,0xFF,0xAE,0xFB,0xFF,0xFA,0x02,0xFB,0xFE,0xFA,0x01,
|
||||
0xFB,0xFB,0xFA,0xFC,0xFF,0x4D,0x1A,0xF9,0x01,0xF8,0x01,0x00,
|
||||
0x9B,0xFB,0x02,0xA5,0xFB,0xFE,0xFF,0xD2,0x19,0xF9,0x01,0xF8,
|
||||
0xFF,0x00,0x9B,0x9C,0x9D,0x9E,0xFF,0x2E,0x1A,0xF9,0x01,0xF8,
|
||||
0x01,0x00,0xFB,0x02,0xA3,0xFB,0x04,0xA4,0xA5,0xFF,0xD2,0x19,
|
||||
0xF9,0x01,0xF8,0x01,0x00,0xFB,0x06,0xA4,0xA5,0xFF,0xD2,0x19,
|
||||
0xF9,0x01,0xF8,0xFF,0x00,0xFB,0xFD,0xA0,0xFB,0xFE,0x9D,0xFF,
|
||||
0xD2,0x19,0xF9,0x01,0xF8,0xFF,0x00,0xA8,0xF9,0x01,0x97,0xF9,
|
||||
0x01,0x98,0x99,0x9A,0xF9,0x05,0x9B,0xF9,0x01,0x9C,0x9D,0xFF,
|
||||
0xD2,0x19,0xF9,0x01,0xA7,0xFF,0x4A,0x1A,0xA2,0xFF,0x45,0x1A,
|
||||
0xA9,0x96,0xFF,0xD2,0x19,0x9F,0xA0,0xFF,0x5F,0x1A,0xF9,0x01,
|
||||
0xF4,0xFF,0xD2,0x19,0xF9,0x05,0xFB,0xF8,0xFF,0xD2,0x19,0xF9,
|
||||
0x05,0xA0,0x9D,0xFF,0xD2,0x19,0xF9,0x07,0xFB,0xF8,0xFF,0x39,
|
||||
0x1B,0xF9,0x05,0xFE,0xFB,0x05,0xFF,0x2E,0x1A,0xF9,0x05,0xFE,
|
||||
0xFB,0x12,0xFF,0xA6,0x19,0xF9,0x01,0x10,0x11,0xFB,0x02,0x12,
|
||||
0xFB,0x02,0x13,0xFB,0x02,0x14,0xFB,0x02,0x15,0xFB,0x02,0x16,
|
||||
0xFB,0x07,0x17,0xFB,0x09,0x18,0xFB,0x05,0xFA,0xFA,0x19,0xFB,
|
||||
0x01,0xFA,0x06,0x1A,0xFB,0x04,0xF4,0xF2,0x01,0x1B,0xFB,0xFD,
|
||||
0x1C,0xFB,0x05,0x1D,0xF2,0x01,0x1E,0x1F,0x20,0x21,0xFB,0x01,
|
||||
0xFF,0xA0,0x19,0xF9,0x01,0xF2,0x01,0x22,0xFB,0x05,0x23,0xFB,
|
||||
0x06,0x24,0xFB,0x03,0x25,0xFB,0x05,0xF2,0x01,0x26,0xFB,0x07,
|
||||
0x27,0xFB,0x0C,0xFA,0xFD,0x28,0xFB,0x08,0xFA,0xF7,0x29,0xFB,
|
||||
0x08,0xFA,0xFE,0x2A,0xFB,0x04,0xFA,0x0B,0x2B,0xFB,0x04,0xFA,
|
||||
0x03,0x2C,0xFB,0x05,0xF4,0xF2,0x01,0xFF,0x81,0x19,0xF9,0x01,
|
||||
0xFB,0x01,0x6B,0xFB,0x02,0xFB,0x02,0x6C,0xFB,0x02,0x6D,0xFB,
|
||||
0x02,0x6D,0xFB,0x02,0x6D,0xFF,0x16,0x1B,0x00,0xF9,0x01,0xFB,
|
||||
0x01,0x6E,0x6F,0xFB,0x02,0x70,0xFB,0x02,0x6C,0xFB,0x02,0x6D,
|
||||
0xFF,0x29,0x1B,0xF9,0x07,0xFE,0xFB,0x06,0x2D,0xFB,0x01,0x2E,
|
||||
0xFF,0xC4,0x19,0xF9,0x07,0xFE,0xFB,0x06,0x2D,0xFB,0x01,0x2E,
|
||||
0xFB,0x02,0x2F,0xFB,0xFF,0x30,0xFB,0x01,0x31,0xFB,0xFE,0x32,
|
||||
0x33,0x34,0xFF,0xA0,0x19,0xF9,0x01,0xFB,0xFF,0xFF,0x75,0x19,
|
||||
0xF9,0x01,0xFB,0x01,0x35,0xFB,0x01,0xF2,0x01,0x36,0xFB,0x08,
|
||||
0x37,0xF2,0x01,0x38,0xFB,0x07,0x39,0xFB,0x03,0x3A,0xFB,0x01,
|
||||
0x3B,0x3C,0xFB,0x02,0x3D,0xFB,0xFF,0x3E,0x3F,0x40,0xFB,0xFF,
|
||||
0x41,0xFB,0xF2,0xFE,0xFF,0x95,0x19,0xF9,0x03,0xFA,0xFF,0x66,
|
||||
0xFB,0xFE,0xFA,0x06,0x67,0xFB,0xFE,0xFA,0x09,0x68,0xFB,0xFF,
|
||||
0xFA,0x0C,0x69,0xFB,0xFD,0xF8,0x00,0x0F,0xFF,0x49,0x1D,0xF9,
|
||||
0x03,0xFA,0xFF,0xFB,0xFE,0x66,0xFB,0xFD,0xFA,0x06,0x67,0xFB,
|
||||
0xFD,0xFA,0x09,0x68,0xFB,0xFE,0xFA,0x0C,0x69,0xFB,0xFD,0xF8,
|
||||
0x00,0x0F,0xFF,0x49,0x1D,0xF9,0x03,0xFB,0x01,0xFA,0xFF,0x66,
|
||||
0xFB,0x02,0xFA,0x06,0x67,0xFB,0xFF,0xFA,0x09,0x68,0xFA,0x0C,
|
||||
0x69,0xFB,0xFE,0xF8,0x01,0x0F,0xFF,0x49,0x1D,0xF9,0x03,0xFB,
|
||||
0x01,0xFA,0x03,0xF7,0x06,0x1C,0x66,0xFB,0x02,0xFA,0x06,0x67,
|
||||
0xFB,0xFF,0xFA,0x09,0x68,0xFA,0x0C,0x69,0xFB,0xFE,0xF8,0x01,
|
||||
0x0F,0xFF,0x49,0x1D,0xFB,0xFF,0xFA,0xFD,0xFF,0xE4,0x1B,0xFB,
|
||||
0x01,0xFF,0xDB,0x1B,0x66,0xFB,0x02,0xFA,0x03,0x67,0xFB,0xFF,
|
||||
0xFA,0x04,0x68,0xFA,0x05,0x69,0xFB,0xFE,0xF8,0x01,0x06,0xFF,
|
||||
0x49,0x1D,0xF9,0x03,0xFB,0x01,0xFA,0x03,0x66,0xFB,0x02,0xFA,
|
||||
0x06,0x67,0xFB,0x01,0xFA,0x09,0x68,0xFB,0x02,0xFA,0x0C,0x69,
|
||||
0xF8,0x02,0x0F,0xFF,0x49,0x1D,0xF9,0x03,0xFB,0x01,0xFA,0x03,
|
||||
0x66,0xFB,0x03,0xFA,0x06,0x67,0xFB,0x02,0xFA,0x09,0x68,0xFB,
|
||||
0x03,0xFA,0x0C,0x69,0xF8,0x03,0x0F,0xFF,0x49,0x1D,0xF9,0x01,
|
||||
0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0xF9,
|
||||
0x02,0x4E,0x4F,0x50,0xFF,0xA1,0x1C,0xF9,0x01,0x43,0x44,0x45,
|
||||
0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0xF9,0x02,0xFB,0x01,
|
||||
0x4E,0xFB,0x02,0x4F,0xFB,0x01,0x50,0xFF,0xA1,0x1C,0xF9,0x01,
|
||||
0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0xFB,0xFF,
|
||||
0x4D,0xF9,0x02,0xFB,0xFE,0x4E,0xFB,0xFF,0x4F,0xFB,0xFF,0x50,
|
||||
0xFF,0xA1,0x1C,0xF9,0x02,0x5B,0x5A,0x59,0x58,0x57,0x57,0x57,
|
||||
0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,
|
||||
0x61,0x60,0x5F,0x5E,0x5D,0x5C,0x5B,0x5A,0x59,0x58,0x57,0x58,
|
||||
0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x5F,0x5E,0x5D,0x5C,
|
||||
0xFF,0x25,0x1D,0xF9,0x06,0x5C,0x5D,0x5D,0x5C,0x5C,0x5B,0xFF,
|
||||
0xD8,0x1C,0x87,0x88,0x89,0x89,0x8A,0x8A,0x8A,0x8A,0x89,0x88,
|
||||
0x87,0xFB,0xF9,0xFF,0x25,0x1D,0xF9,0x01,0x94,0x91,0x90,0x8F,
|
||||
0x8E,0x8D,0xFB,0xFB,0xFA,0x3F,0xFC,0xF9,0x03,0x8C,0x8A,0x88,
|
||||
0x5B,0xF9,0x02,0xFF,0xA4,0x1C,0xF9,0x01,0x87,0x88,0x89,0x8A,
|
||||
0x8B,0x8C,0xFB,0x05,0xFA,0xC1,0xFD,0x8D,0x8E,0x8F,0x90,0x91,
|
||||
0x92,0x93,0x94,0xF9,0x05,0x95,0xF9,0x01,0x76,0x77,0xFB,0x01,
|
||||
0xFF,0xA0,0x19,0x51,0x52,0xF9,0x05,0x53,0xF9,0x01,0xF4,0xF2,
|
||||
0x00,0x54,0x55,0xFB,0x03,0xFF,0xA0,0x19,0xF9,0x03,0x51,0xFA,
|
||||
0x06,0x51,0xFA,0x09,0x51,0xFA,0x0C,0xFB,0x02,0xF8,0x00,0x0C,
|
||||
0xFF,0x49,0x1D,0xF9,0x04,0x6A,0xFF,0x4B,0x1D,0xF9,0x01,0x35,
|
||||
0xFB,0x02,0xF2,0x01,0x36,0xFB,0x07,0x37,0xF2,0x01,0x38,0xFB,
|
||||
0x02,0x31,0xFB,0xFE,0x32,0x33,0x34,0xFF,0xA0,0x19,0xF9,0x01,
|
||||
0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,
|
||||
0xF9,0x00,0xF5,0x4F,0xFF,0x25,0x1D,0xF9,0x01,0x43,0x44,0x45,
|
||||
0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0xFA,0xFC,
|
||||
0x4F,0xFA,0xFE,0x4F,0x4F,0xFA,0x02,0x4F,0xFA,0x04,0xFF,0x25,
|
||||
0x1D,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0xFA,
|
||||
0xFF,0x4D,0xFA,0xFD,0x4E,0xFA,0xFC,0x4F,0xFA,0xF6,0x4F,0xFA,
|
||||
0xF7,0x4F,0xFA,0xF8,0x4F,0xFA,0xF9,0x4F,0xFA,0xFA,0x4F,0xFA,
|
||||
0xFB,0x4F,0xFA,0xFC,0x4F,0xFA,0xFD,0x4F,0xFA,0xFE,0x4F,0xFA,
|
||||
0xFE,0x4F,0xFA,0xFF,0x4F,0xFA,0xFF,0x4F,0xFA,0xFF,0x4F,0x4F,
|
||||
0x4F,0x4F,0xFA,0x01,0x4F,0xFA,0x01,0x4F,0xFA,0x02,0x4F,0xFA,
|
||||
0x02,0x4F,0xFA,0x03,0x4F,0xFA,0x04,0x4F,0xFA,0x05,0x4F,0xFA,
|
||||
0x06,0x4F,0xF8,0x00,0x06,0xFF,0x49,0x1D,0xF9,0x03,0x50,0xFF,
|
||||
0xA1,0x1C,0xF9,0x05,0xFB,0xFC,0x32,0x33,0x34,0xFF,0xA0,0x19,
|
||||
0xF9,0x05,0xFB,0x01,0xFA,0x03,0xF7,0x25,0x1E,0x66,0xFB,0x02,
|
||||
0xFA,0x06,0x67,0xFB,0xFF,0xFA,0x09,0x68,0xFA,0x0C,0x69,0xFB,
|
||||
0xFE,0xF8,0x00,0x0F,0xFF,0x49,0x1D,0x66,0xFB,0x02,0xFA,0x03,
|
||||
0x67,0xFB,0xFF,0xFA,0x04,0x68,0xFA,0x05,0x69,0xFB,0xFE,0xF8,
|
||||
0x00,0x06,0xFF,0x49,0x1D,0xF9,0x05,0xFB,0xFF,0xFA,0xFC,0x66,
|
||||
0xFB,0xFF,0xFA,0x03,0xFB,0xFD,0xFA,0x01,0xF4,0xFB,0x01,0xF2,
|
||||
0x01,0x6B,0xFB,0x02,0x6C,0xF2,0x01,0x6D,0xFF,0xB3,0x1F,0x79,
|
||||
0xFB,0x01,0x7A,0x7B,0xFB,0x02,0x7C,0xFB,0x04,0x7D,0xFB,0x03,
|
||||
0x7E,0xFB,0xFC,0x56,0xF2,0x01,0xF4,0xFB,0xFC,0x74,0xFB,0xFE,
|
||||
0x75,0x76,0x77,0xFF,0xA0,0x19,0xFB,0xFB,0xFF,0xA0,0x19,0xF9,
|
||||
0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,
|
||||
0x04,0x7D,0xFB,0x03,0x7E,0xFB,0xFF,0xFB,0x03,0x7F,0x80,0x81,
|
||||
0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,
|
||||
0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,0x04,0x7D,0xFB,0x03,0x7E,
|
||||
0xFB,0xFF,0xFB,0x02,0x7F,0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,
|
||||
0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,
|
||||
0x7C,0xFB,0x04,0x7D,0xFB,0x03,0x7E,0xFB,0xFF,0xFB,0x01,0x7F,
|
||||
0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,
|
||||
0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,0x04,0x7D,0xFB,
|
||||
0x03,0x7E,0xFB,0xFF,0x7F,0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,
|
||||
0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,
|
||||
0x7C,0xFB,0x04,0x7D,0xFB,0x03,0x7E,0xFB,0xFE,0x80,0x81,0x82,
|
||||
0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFF,0xFC,0x1E,0xF9,
|
||||
0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,
|
||||
0x04,0x7D,0xFB,0xFF,0x7F,0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,
|
||||
0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,
|
||||
0x7C,0xFB,0x02,0x81,0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,
|
||||
0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x02,0x7C,0xFB,0x02,
|
||||
0x81,0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,0x01,
|
||||
0x7A,0xFB,0x01,0x7B,0xFB,0x02,0x7C,0xFB,0x01,0x81,0x82,0x83,
|
||||
0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,
|
||||
0x7B,0xFB,0x02,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,
|
||||
0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x01,0x83,0x84,0xFF,0xA0,0x19,
|
||||
0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x84,0xFF,0xA0,0x19,
|
||||
0xF9,0x01,0x79,0xFB,0x01,0x84,0xFF,0xA0,0x19,0xF9,0x01,0xFB,
|
||||
0x01,0x6B,0xFB,0x02,0x6C,0x6D,0xFF,0xAF,0x1F,0xF9,0x05,0xFB,
|
||||
0x01,0x6E,0x6F,0xFB,0x02,0x70,0x71,0xFB,0x01,0x72,0x73,0x74,
|
||||
0xFB,0xFC,0x75,0x76,0x77,0xFF,0xA0,0x19,0xF9,0x01,0xF3,0x01,
|
||||
0xE5,0xE5,0xE5,0xE5,0xE5,0xE5,0xE6,0xE7,0xE8,0xFF,0xDA,0x1F,
|
||||
0xF9,0x01,0xFB,0xFB,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,
|
||||
0x85,0x85,0x86,0x86,0x86,0x30,0xFB,0x01,0x31,0xFB,0xFE,0xF9,
|
||||
0x05,0x32,0xF9,0x01,0x33,0x34,0xFF,0xA0,0x19,0xF9,0x01,0xFB,
|
||||
0xFB,0xEA,0xEC,0xEE,0xF0,0x86,0xFB,0xFF,0xFF,0xA0,0x19,0xF9,
|
||||
0x01,0xFB,0x04,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xF2,0x03,
|
||||
0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCD,0xCD,0xF3,0x01,
|
||||
0xCD,0xCD,0xC9,0xC6,0xFB,0xFC,0xFF,0xA0,0x19,0xF9,0x05,0xF4,
|
||||
0xFB,0x01,0x6B,0xFB,0x02,0x6C,0xF9,0x01,0x6D,0xFF,0x36,0x20,
|
||||
0xF9,0x01,0xFA,0xFE,0xFB,0x01,0x6B,0xFB,0x02,0x6C,0x6D,0xFB,
|
||||
0x01,0x6E,0x6F,0xFB,0x02,0x70,0x71,0xFB,0x01,0xFA,0x01,0x72,
|
||||
0xFA,0x01,0x73,0xFB,0xFE,0xFF,0x78,0x19,0xF9,0x05,0xF4,0xFA,
|
||||
0xFE,0xFB,0x01,0xFB,0x02,0x6C,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,
|
||||
0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,
|
||||
0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0xFB,
|
||||
0x01,0x6E,0x6E,0x6E,0x6F,0xFB,0x02,0x70,0x71,0xFB,0x01,0xFA,
|
||||
0x01,0x72,0xFA,0x01,0x73,0x74,0xFB,0xFC,0x75,0x76,0x77,0xFF,
|
||||
0xA0,0x19,0xF9,0x05,0xF4,0xFA,0xFE,0xFB,0x03,0xB9,0xF6,0xB9,
|
||||
0xFF,0xA5,0x20,0xF9,0x05,0xFF,0xAE,0x20,0xF9,0x01,0xF6,0xB3,
|
||||
0xB4,0xB5,0xB6,0xFB,0x01,0xB7,0xFB,0xFC,0xB9,0xFF,0xBA,0x20,
|
||||
0xF9,0x01,0xF4,0xFB,0x04,0xB1,0xF6,0xB1,0xFF,0xC5,0x20,0xF9,
|
||||
0x01,0xB2,0xF6,0xB2,0xFF,0xCD,0x20,0xFF,0x5A,0x20,0xF8,0x00,
|
||||
0x00,0xF9,0x04,0xB9,0xFF,0xD9,0x20,0xF9,0x05,0xFB,0xFB,0xFA,
|
||||
0xFF,0xF2,0x01,0xD9,0xDA,0xDB,0xFB,0x01,0xDC,0xFB,0xFC,0xFA,
|
||||
0xFD,0xF2,0x01,0xDD,0xFB,0xFC,0xFA,0xFE,0xDE,0xFB,0xFE,0xFA,
|
||||
0xFD,0xDF,0xFB,0xFD,0xFA,0xF8,0xF2,0x04,0xF2,0x01,0xE0,0xFB,
|
||||
0xFF,0xFA,0xFF,0xE1,0xFB,0xFD,0xFA,0xFC,0xE2,0xFB,0xFF,0xFA,
|
||||
0xFB,0xF2,0x01,0xE3,0xFB,0xFE,0xFA,0xFF,0xE4,0x00,0xF2,0x01,
|
||||
0x00,0x00,0x00,0xF2,0x01,0x00,0x00,0x00,0xF2,0x01,0x00,0x00,
|
||||
0x00,0xF2,0x01,0xF1,0x00,0xFF,0x2E,0x21,0x36,0xFF,0x32,0x21,
|
||||
0x55,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x44,
|
||||
0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x53,0x54,0x4C,0xFF,0x4B,
|
||||
0x21,0xFB,0x01,0x30,0xFB,0x02,0x31,0xFB,0x06,0x32,0xFB,0x01,
|
||||
0x33,0xFB,0xFF,0x34,0xFB,0x01,0x35,0xFB,0x01,0xFF,0x51,0x21,
|
||||
0xFB,0x01,0x37,0x38,0xFF,0x32,0x21,0x4D,0x4E,0x4F,0x50,0x51,
|
||||
0x52,0xFB,0x01,0x36,0x36,0x36,0x36,0x36,0x36,0x39,0x3A,0x3B,
|
||||
0x3C,0x3D,0xFB,0x02,0x3E,0xFB,0xFF,0x3F,0xFB,0xFD,0x40,0x41,
|
||||
0xFB,0xFF,0x42,0xFE,0xFB,0x10,0xFB,0x03,0xFF,0x54,0x21,0x0B,
|
||||
0xFF,0x95,0x21,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xFE,
|
||||
0xFB,0x08,0x0B,0xFF,0x95,0x21,0xFE,0xFB,0x0B,0x0C,0xFB,0x01,
|
||||
0x0D,0xFB,0x01,0x0E,0xFB,0x03,0x0F,0xFB,0x01,0x10,0x11,0xFF,
|
||||
0xB8,0x21,0x13,0xFF,0xBC,0x21,0x14,0xFF,0xC0,0x21,0x15,0xFB,
|
||||
0x01,0x16,0x17,0x18,0xFB,0x01,0x19,0xFB,0xFD,0x1A,0xFB,0xFE,
|
||||
0x1B,0xFB,0xFC,0x1C,0xFB,0xFD,0x1D,0xFB,0xFE,0x1E,0xFB,0xFD,
|
||||
0x1F,0xFB,0xFF,0x20,0x21,0xFF,0xE2,0x21,0x25,0xFF,0xE6,0x21,
|
||||
0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0xFE,
|
||||
0xFB,0x0C,0x0B,0xFF,0xF8,0x21,0x0B,0x0B,0xFE,0xFB,0x0D,0x2F,
|
||||
0x2E,0x2D,0x2C,0x2B,0x2A,0x29,0x28,0x27,0x26,0x25,0x24,0x24,
|
||||
0x24,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x23,
|
||||
0x23,0x24,0x24,0x24,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,
|
||||
0x22,0x22,0x23,0x23,0x24,0x24,0x24,0x23,0x23,0x23,0x22,0x22,
|
||||
0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x23,0x23,0x23,0x24,0xFF,
|
||||
0x3C,0x22,0x01,0x12,0xFF,0x41,0x22,0xF9,0x01,0xBA,0xFB,0x05,
|
||||
0xBA,0xFB,0x03,0xBB,0xFB,0x04,0xFF,0x47,0x22,0xBA,0xFF,0x53,
|
||||
0x22,0xBC,0xFF,0x57,0x22,0xF9,0x00,0xBA,0xBA,0xBA,0xBC,0xBC,
|
||||
0xBC,0xBC,0xBC,0xBC,0xBC,0xBC,0xFE,0xFB,0x08,0xFF,0x47,0x22,
|
||||
0xBA,0xBA,0xBC,0xFF,0x70,0x22,
|
||||
};
|
||||
|
||||
#define KID_NSEQ 115
|
||||
static const uint16_t kid_seq_off[KID_NSEQ] = {
|
||||
0x0000,0x1973,0x19A0,0x1A93,0x1ACD,0x1B39,0x1B5A,0x1BDB,
|
||||
0x1C54,0x1CA1,0x1D04,0x1D25,0x1D49,0x1D4F,0x1D68,0x1DF6,
|
||||
0x1C84,0x202B,0x1C1C,0x1C01,0x205A,0x1C38,0x209C,0x1D36,
|
||||
0x1C69,0x1CD1,0x1B04,0x1B1A,0x1D7D,0x1F9E,0x1F92,0x1F82,
|
||||
0x1F72,0x1F5D,0x1F48,0x1F33,0x1F19,0x1F13,0x1EF7,0x1EDA,
|
||||
0x1EBB,0x1E9C,0x1E7D,0x1B53,0x1E59,0x1E06,0x1E3B,0x1DFC,
|
||||
0x1D9B,0x1FB3,0x1FA7,0x20BE,0x20D1,0x20D4,0x20C9,0x19C4,
|
||||
0x1A13,0x1A2E,0x1A3C,0x1A7C,0x1A83,0x1A63,0x1A5E,0x1A68,
|
||||
0x1A6E,0x1A75,0x1A5A,0x19F9,0x1CEC,0x1A54,0x20DD,0x20AE,
|
||||
0x1E78,0x1CDC,0x19DC,0x1A42,0x1A07,0x19A8,0x2009,0x1B1B,
|
||||
0x1A8B,0x1B85,0x1BA1,0x1BBF,0x196E,0x20A9,0x1A22,0x19A6,
|
||||
0x19AC,0x1B2D,0x19C1,0x1FCA,0x1FDA,0x1FFB,0x2195,0x2132,
|
||||
0x214F,0x2166,0x2199,0x21A8,0x216D,0x226E,0x2136,0x21BC,
|
||||
0x1BFA,0x2245,0x2253,0x225B,0x21C4,0x21C0,0x21E6,0x21EA,
|
||||
0x21FC,0x2240,0x2257,
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,394 @@
|
||||
/*
|
||||
* pop_bg.c — статический фон комнаты PoP композицией слоёв (порт
|
||||
* applications/PoP/toolchain/render_room.py -> seg008.c draw_tile/
|
||||
* wall_pattern). Подробности алгоритма — в render_room.py и
|
||||
* memory/pop_background_strategy.
|
||||
*
|
||||
* Только DUNGEON-стиль (Фаза 1). Анимация (пламя факелов, шипы, дверь-
|
||||
* плита, сама решётка ворот) НЕ рисуется — отдельными sprite_t поверх
|
||||
* (Фаза 2). Решётка ворот из ЛЕВОЙ комнаты рисуется статичным кадром.
|
||||
*/
|
||||
#include <graphics.h>
|
||||
#include <gfx.h>
|
||||
#include <sprite.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include "pop_bg.h"
|
||||
|
||||
/* ---- Атласы (прямая адресация) ------------------------------------- */
|
||||
static atlas_t env[5];
|
||||
static atlas_t wall_at;
|
||||
static atlas_t fore_at;
|
||||
|
||||
static const char *const ENV_ATL[5] = {
|
||||
"pop_env0.atl", "pop_env1.atl", "pop_env2.atl",
|
||||
"pop_env3.atl", "pop_env4.atl"
|
||||
};
|
||||
|
||||
int pop_bg_load(void)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 5; i++)
|
||||
if (atlas_load(&env[i], ENV_ATL[i]) != 0) return -1;
|
||||
if (atlas_load(&wall_at, "pop_wall.atl") != 0) return -1;
|
||||
if (atlas_load(&fore_at, "pop_fore.atl") != 0) return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void pop_bg_free(void)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 5; i++)
|
||||
atlas_free(&env[i]);
|
||||
atlas_free(&wall_at);
|
||||
atlas_free(&fore_at);
|
||||
}
|
||||
|
||||
/* Блит ленты idx атласа a: НИЗ спрайта на ybottom, левый край x,
|
||||
* прозрачно (0xFF). w/h читаются из getimage-заголовка ленты (в W0). */
|
||||
static void blit_b(atlas_t *a, uint8_t idx, int x, int ybottom)
|
||||
{
|
||||
const uint8_t *img;
|
||||
uint16_t w, h;
|
||||
if (idx >= a->count)
|
||||
return;
|
||||
img = (const uint8_t *)atlas_image(a, idx);
|
||||
gfx_w0_map(a->page);
|
||||
w = (uint16_t)(img[0] | ((uint16_t)img[1] << 8));
|
||||
h = (uint16_t)(img[2] | ((uint16_t)img[3] << 8));
|
||||
if (w && h)
|
||||
gfx_blit(x, ybottom - (int)h + 1, img);
|
||||
gfx_w0_unmap();
|
||||
}
|
||||
|
||||
static void env_b(uint8_t id, int x, int yb) { blit_b(&env[id >> 5], (uint8_t)(id & 31), x, yb); }
|
||||
static void wall_b(uint8_t id, int x, int yb) { blit_b(&wall_at, id, x, yb); }
|
||||
static void fore_b(uint8_t id, int x, int yb) { blit_b(&fore_at, id, x, yb); }
|
||||
|
||||
/* ---- Таблица тайлов (piece, seg008.c:27) --------------------------- */
|
||||
typedef struct {
|
||||
uint8_t base_id, floor_left; int8_t base_y;
|
||||
uint8_t right_id, floor_right; int8_t right_y;
|
||||
uint8_t stripe_id, topright_id, bottom_id, fore_id, fore_x; int8_t fore_y;
|
||||
} piece;
|
||||
|
||||
static const piece tile_table[31] = {
|
||||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* 00 empty */
|
||||
{ 41, 1, 0, 42, 1, 2, 145, 0, 43, 0, 0, 0}, /* 01 floor */
|
||||
{127, 1, 0, 133, 1, 2, 145, 0, 43, 0, 0, 0}, /* 02 spike */
|
||||
{ 92, 1, 0, 93, 1, 2, 0, 94, 43, 95, 1, 0}, /* 03 pillar */
|
||||
{ 46, 1, 0, 47, 1, 2, 0, 48, 43, 49, 3, 0}, /* 04 gate */
|
||||
{ 41, 1, 1, 35, 1, 3, 145, 0, 36, 0, 0, 0}, /* 05 stuck floor */
|
||||
{ 41, 1, 0, 42, 1, 2, 145, 0, 96, 0, 0, 0}, /* 06 close button */
|
||||
{ 46, 1, 0, 0, 0, 2, 0, 0, 43, 49, 3, 0}, /* 07 door top w/floor */
|
||||
{ 86, 1, 0, 87, 1, 2, 0, 0, 43, 88, 1, 0}, /* 08 big pillar bottom */
|
||||
{ 0, 0, 0, 89, 0, 3, 0, 90, 0, 91, 1, 3}, /* 09 big pillar top */
|
||||
{ 41, 1, 0, 42, 1, 2, 145, 0, 43, 12, 2, -3}, /* 0A potion */
|
||||
{ 0, 1, 0, 0, 0, 0, 145, 0, 0, 0, 0, 0}, /* 0B loose floor */
|
||||
{ 0, 0, 0, 0, 0, 2, 0, 0, 85, 49, 3, 0}, /* 0C door top */
|
||||
{ 75, 1, 0, 42, 1, 2, 0, 0, 43, 77, 0, 0}, /* 0D mirror */
|
||||
{ 97, 1, 0, 98, 1, 2, 145, 0, 43,100, 0, 0}, /* 0E debris */
|
||||
{147, 1, 0, 42, 1, 1, 145, 0,149, 0, 0, 0}, /* 0F open button */
|
||||
{ 41, 1, 0, 37, 0, 0, 0, 38, 43, 0, 0, 0}, /* 10 leveldoor left */
|
||||
{ 0, 0, 0, 39, 1, 2, 0, 40, 43, 0, 0, 0}, /* 11 leveldoor right */
|
||||
{ 0, 0, 0, 42, 1, 2, 145, 0, 43, 0, 0, 0}, /* 12 chomper */
|
||||
{ 41, 1, 0, 42, 1, 2, 0, 0, 43, 0, 0, 0}, /* 13 torch */
|
||||
{ 0, 0, 0, 1, 1, 2, 0, 2, 0, 0, 0, 0}, /* 14 wall */
|
||||
{ 30, 1, 0, 31, 1, 2, 0, 0, 43, 0, 0, 0}, /* 15 skeleton */
|
||||
{ 41, 1, 0, 42, 1, 2, 145, 0, 43, 0, 0, 0}, /* 16 sword */
|
||||
{ 41, 1, 0, 10, 0, 0, 0, 11, 43, 0, 0, 0}, /* 17 balcony left */
|
||||
{ 0, 0, 0, 12, 1, 2, 0, 13, 43, 0, 0, 0}, /* 18 balcony right */
|
||||
{ 92, 1, 0, 42, 1, 2, 145, 0, 43, 95, 1, 0}, /* 19 lattice pillar */
|
||||
{ 1, 0, 0, 0, 0, 0, 0, 0, 2, 9, 0,-53}, /* 1A lattice down */
|
||||
{ 3, 0,-10, 0, 0, 0, 0, 0, 0, 9, 0,-53}, /* 1B lattice small */
|
||||
{ 4, 0,-10, 0, 0, 0, 0, 0, 0, 9, 0,-53}, /* 1C lattice left */
|
||||
{ 5, 0,-10, 0, 0, 0, 0, 0, 0, 9, 0,-53}, /* 1D lattice right */
|
||||
{ 97, 1, 0, 98, 1, 2, 0, 0, 43,100, 0, 0}, /* 1E debris w/torch */
|
||||
};
|
||||
|
||||
/* ---- Константные таблицы (render_room.py) -------------------------- */
|
||||
static const uint8_t COL_XH[10] = {0, 4, 8, 12, 16, 20, 24, 28, 32, 36};
|
||||
static const uint8_t TBL_LINE[3] = {0, 10, 20};
|
||||
static const uint8_t WALL_FRAM_BOTTOM[4] = {7, 9, 5, 3};
|
||||
static const uint8_t WALL_FRAM_MAIN[4] = {8, 10, 6, 4};
|
||||
static const uint8_t DOOR_FRAM_SLICE[9] = {67, 59, 58, 57, 56, 55, 54, 53, 52};
|
||||
static const uint8_t SPIKES_FRAM_RIGHT[10] = {0, 134, 135, 136, 137, 138, 137, 135, 134, 0};
|
||||
static const uint8_t BLUELINE_FRAM1[4] = {0, 124, 125, 126};
|
||||
static const int8_t BLUELINE_FRAM_Y[4] = {0, -20, -20, 0};
|
||||
static const uint8_t BLUELINE_FRAM3[4] = {44, 44, 45, 45};
|
||||
static const uint8_t LPOS[5] = {58, 41, 37, 20, 16};
|
||||
static const uint8_t RPOS[4] = {52, 42, 31, 21};
|
||||
|
||||
/* Wall (chtab_7) id: делители/блок/марки. */
|
||||
#define RES_WALL_RNDBLOCK 13
|
||||
#define RES_WALL_DIVIDER1 11
|
||||
#define RES_WALL_MARK_TL 14
|
||||
#define RES_WALL_MARK_BL 15
|
||||
#define RES_WALL_MARK_TR 16
|
||||
#define RES_WALL_MARK_BR 17
|
||||
|
||||
/* ---- Текущая комната (globals для tile_code/mod) ------------------- */
|
||||
static const uint8_t *g_fg, *g_bg, *g_lfg, *g_lbg;
|
||||
static uint8_t g_room;
|
||||
|
||||
static uint8_t tile_code(int row, int col)
|
||||
{
|
||||
if (col < 0) {
|
||||
if (g_lfg && row >= 0 && row < 3) return g_lfg[row];
|
||||
return 20; /* уровневая кромка = стена */
|
||||
}
|
||||
if (row < 0) return 1; /* верхняя кромка = пол */
|
||||
if (row > 2 || col > 9) return 20;
|
||||
return g_fg[row * 10 + col];
|
||||
}
|
||||
|
||||
static uint8_t tile_mod(int row, int col)
|
||||
{
|
||||
if (col < 0) {
|
||||
if (g_lbg && row >= 0 && row < 3) return g_lbg[row];
|
||||
return 0;
|
||||
}
|
||||
if (row < 0 || row > 2 || col > 9) return 0;
|
||||
return g_bg[row * 10 + col];
|
||||
}
|
||||
|
||||
/* seg008.c:1255 (без FAKE_TILES): сосед — стена, если его тип == 20.
|
||||
* На кромке col0 сосед по умолчанию = стена (как render_room). */
|
||||
static uint8_t wall_modifier(int row, int col)
|
||||
{
|
||||
uint8_t lw = (col > 0) ? (tile_code(row, col - 1) == 20) : 1;
|
||||
uint8_t rw = (col < 9) ? (tile_code(row, col + 1) == 20) : 1;
|
||||
if (lw && rw) return 3; /* WWW */
|
||||
if (lw) return 2; /* WWS */
|
||||
if (rw) return 1; /* SWW */
|
||||
return 0; /* SWS */
|
||||
}
|
||||
|
||||
/* ---- PRNG (seg009.c:321, 32-бит LCG) — только на ВХОД в комнату ---- */
|
||||
static unsigned long rnd_seed;
|
||||
|
||||
static uint16_t prandom(uint16_t maxv)
|
||||
{
|
||||
rnd_seed = rnd_seed * 214013UL + 2531011UL;
|
||||
return (uint16_t)((uint16_t)(rnd_seed >> 16) % (uint16_t)(maxv + 1));
|
||||
}
|
||||
|
||||
/* ---- Декали-марки стен (seg008.c:2041/2056) ------------------------ */
|
||||
static void draw_left_mark(uint16_t dv, int arg2, int arg1, int row, int col)
|
||||
{
|
||||
uint8_t image_id = (dv & 1) ? RES_WALL_MARK_BL : RES_WALL_MARK_TL;
|
||||
int lv2 = 0;
|
||||
int xh = COL_XH[col];
|
||||
int dby = 63 * row + 65;
|
||||
if (dv > 3) lv2 = arg1 + 6;
|
||||
else if (dv > 1) lv2 = arg2 + 6;
|
||||
wall_b(image_id, (xh + ((dv == 2 || dv == 3) ? 1 : 0)) * 8 + lv2, dby - LPOS[dv]);
|
||||
}
|
||||
|
||||
static void draw_right_mark(uint16_t dv, int arg1, int row, int col)
|
||||
{
|
||||
uint8_t image_id = (dv & 1) ? RES_WALL_MARK_BR : RES_WALL_MARK_TR;
|
||||
int a = (dv < 2) ? 24 : arg1 - 3;
|
||||
int xh = COL_XH[col];
|
||||
int dby = 63 * row + 65;
|
||||
wall_b(image_id, (xh + ((dv > 1) ? 1 : 0)) * 8 + a, dby - RPOS[dv]);
|
||||
}
|
||||
|
||||
/* ---- wall_pattern (seg008.c:1928, dungeon-ветка) ------------------- */
|
||||
static void wall_pattern(int row, int col, int which_part)
|
||||
{
|
||||
int xh = COL_XH[col];
|
||||
int dby = 63 * row + 65;
|
||||
unsigned long saved = rnd_seed;
|
||||
uint16_t mid_div, mid_off, bot_div, bot_off;
|
||||
uint8_t bg;
|
||||
|
||||
rnd_seed = (unsigned long)(g_room + TBL_LINE[row] + col);
|
||||
prandom(1); /* сброс */
|
||||
mid_div = prandom(1);
|
||||
mid_off = prandom(4);
|
||||
bot_div = prandom(1);
|
||||
bot_off = prandom(4);
|
||||
bg = wall_modifier(row, col);
|
||||
|
||||
if (bg == 3) { /* WWW */
|
||||
if (which_part) {
|
||||
if (prandom(4) == 0)
|
||||
wall_b(RES_WALL_RNDBLOCK, xh * 8, dby - 42);
|
||||
wall_b((uint8_t)(RES_WALL_DIVIDER1 + mid_div), (xh + 1) * 8 + mid_off, dby - 21);
|
||||
}
|
||||
wall_b((uint8_t)(RES_WALL_DIVIDER1 + bot_div), xh * 8 + bot_off, dby);
|
||||
if (which_part) {
|
||||
if (prandom(4) == 0)
|
||||
draw_right_mark(prandom(3), mid_off, row, col);
|
||||
if (prandom(4) == 0)
|
||||
draw_left_mark(prandom(4), mid_off - mid_div, bot_off - bot_div, row, col);
|
||||
}
|
||||
} else if (bg == 0) { /* SWS */
|
||||
if (which_part) {
|
||||
if (prandom(6) == 0)
|
||||
draw_left_mark(prandom(1), mid_off - mid_div, bot_off - bot_div, row, col);
|
||||
}
|
||||
} else if (bg == 1) { /* SWW */
|
||||
if (which_part) {
|
||||
if (prandom(4) == 0)
|
||||
wall_b(RES_WALL_RNDBLOCK, xh * 8, dby - 42);
|
||||
wall_b((uint8_t)(RES_WALL_DIVIDER1 + mid_div), (xh + 1) * 8 + mid_off, dby - 21);
|
||||
if (prandom(4) == 0)
|
||||
draw_right_mark(prandom(3), mid_off, row, col);
|
||||
if (prandom(4) == 0)
|
||||
draw_left_mark(prandom(3), mid_off - mid_div, bot_off - bot_div, row, col);
|
||||
}
|
||||
} else { /* WWS (bg==2) */
|
||||
if (which_part)
|
||||
wall_b((uint8_t)(RES_WALL_DIVIDER1 + mid_div), (xh + 1) * 8 + mid_off, dby - 21);
|
||||
wall_b((uint8_t)(RES_WALL_DIVIDER1 + bot_div), xh * 8 + bot_off, dby);
|
||||
if (which_part) {
|
||||
if (prandom(4) == 0)
|
||||
draw_right_mark((uint16_t)(prandom(1) + 2), mid_off, row, col);
|
||||
if (prandom(4) == 0)
|
||||
draw_left_mark(prandom(4), mid_off - mid_div, bot_off - bot_div, row, col);
|
||||
}
|
||||
}
|
||||
rnd_seed = saved;
|
||||
}
|
||||
|
||||
/* topright тайла снизу-слева (seg008.c:410). */
|
||||
static void draw_topright(uint8_t tt, int x, int dby)
|
||||
{
|
||||
if (tt == 7 || tt == 12) return;
|
||||
if (tt == 20) { wall_b(2, x, dby); return; }
|
||||
if (tile_table[tt].topright_id)
|
||||
env_b(tile_table[tt].topright_id, x, dby);
|
||||
}
|
||||
|
||||
/* Решётка ворот (portcullis) из ЛЕВОЙ комнаты (seg008.c:1110). */
|
||||
static void draw_gate_back(uint8_t modl, int xh, int dby, int dmy)
|
||||
{
|
||||
int x = xh * 8;
|
||||
int gate_top_y = dby - 62;
|
||||
int openness = (((modl > 188) ? 188 : modl) >> 2) + 1;
|
||||
int gate_bot_y = dmy - openness;
|
||||
int yb, gate_frame;
|
||||
|
||||
if (gate_bot_y + 12 < dmy)
|
||||
env_b(50, x, gate_bot_y);
|
||||
else
|
||||
env_b(51, x, gate_bot_y - 2);
|
||||
yb = gate_bot_y - 12;
|
||||
if (yb < 192) {
|
||||
while (yb >= 0 && yb > 7 && (yb - 7) > gate_top_y) {
|
||||
env_b(52, x, yb);
|
||||
yb -= 8;
|
||||
}
|
||||
}
|
||||
gate_frame = yb - gate_top_y + 1;
|
||||
if (gate_frame > 0 && gate_frame < 9)
|
||||
env_b(DOOR_FRAM_SLICE[gate_frame], x, yb);
|
||||
}
|
||||
|
||||
/* ---- draw_tile (seg008.c:155) — одна клетка ------------------------ */
|
||||
static void draw_tile(int row, int col)
|
||||
{
|
||||
uint8_t code = tile_code(row, col);
|
||||
uint8_t lcode = tile_code(row, col - 1);
|
||||
uint8_t lmod = tile_mod(row, col - 1);
|
||||
int xh = COL_XH[col];
|
||||
int x = xh * 8;
|
||||
int dby = 63 * row + 65;
|
||||
int dmy = dby - 3;
|
||||
const piece *t = &tile_table[code];
|
||||
const piece *lt = &tile_table[lcode];
|
||||
uint8_t rbl_code;
|
||||
uint8_t wmod;
|
||||
|
||||
/* тайл снизу-слева (для topright) */
|
||||
if (row + 1 > 2) rbl_code = 1; /* ниже нижнего ряда = пол */
|
||||
else rbl_code = tile_code(row + 1, col - 1);
|
||||
|
||||
/* --- floorright (seg008.c:392) — только can_see_bottomleft --- */
|
||||
if (code == 0 || code == 9 || code == 12 || code == 26) {
|
||||
draw_topright(rbl_code, x, dby);
|
||||
/* floor-right тень (blitters_9_black) на ЧЁРНОМ фоне = no-op
|
||||
* (чёрный силуэт по чёрному) — не рисуем. Если tile_left имеет
|
||||
* floor_right: lt->floor_right. */
|
||||
}
|
||||
|
||||
/* --- draw_tile_right (seg008.c:456) --- */
|
||||
if (code != 20) {
|
||||
if (lcode == 20) {
|
||||
wall_b(1, x, tile_table[20].right_y + dmy); /* грань стены */
|
||||
} else if (lcode == 0) {
|
||||
if (lmod <= 3 && BLUELINE_FRAM1[lmod])
|
||||
env_b(BLUELINE_FRAM1[lmod], x, BLUELINE_FRAM_Y[lmod] + dmy);
|
||||
} else if (lcode == 1) {
|
||||
uint8_t num;
|
||||
env_b(42, x, tile_table[1].right_y + dmy); /* правый треуг. пола */
|
||||
num = (lmod <= 3) ? lmod : 0;
|
||||
if (num != 0) /* dungeon: level_type=0 */
|
||||
env_b(BLUELINE_FRAM3[num], x, dmy - 20); /* силуэт кладки */
|
||||
} else {
|
||||
if (lt->right_id)
|
||||
env_b(lt->right_id, x, lt->right_y + dmy);
|
||||
/* stripe — только палас, dungeon пропускает */
|
||||
}
|
||||
}
|
||||
|
||||
/* --- draw_tile_anim_right (seg008.c:530) — статичные части --- */
|
||||
if (lcode == 4) { /* gate: решётка */
|
||||
draw_gate_back(lmod, xh, dby, dmy);
|
||||
} else if (lcode == 11) { /* loose: правый край */
|
||||
env_b(42, x, dby - 1);
|
||||
} else if (lcode == 2) { /* spike: статич. кадр */
|
||||
uint8_t sf = (lmod & 0x80) ? 5 : lmod;
|
||||
if (sf < 10 && SPIKES_FRAM_RIGHT[sf])
|
||||
env_b(SPIKES_FRAM_RIGHT[sf], x, dmy - 7);
|
||||
}
|
||||
|
||||
/* --- draw_tile_bottom (seg008.c:570) --- */
|
||||
if (code == 20) {
|
||||
wmod = wall_modifier(row, col);
|
||||
wall_b(WALL_FRAM_BOTTOM[wmod], x, dby); /* сплошная нижняя грань */
|
||||
wall_pattern(row, col, 0);
|
||||
} else if (t->bottom_id) {
|
||||
env_b(t->bottom_id, x, dby);
|
||||
}
|
||||
|
||||
/* --- draw_loose (seg008.c:600) — статич. кадр --- */
|
||||
if (code == 11)
|
||||
env_b(43, x, dby); /* loose_fram_bottom[0] */
|
||||
|
||||
/* --- draw_tile_base (seg008.c:611) --- */
|
||||
{
|
||||
uint8_t base_id = t->base_id;
|
||||
if (code == 11) base_id = 41; /* loose_fram_left[0] */
|
||||
if (base_id)
|
||||
env_b(base_id, x, t->base_y + dmy);
|
||||
}
|
||||
|
||||
/* --- draw_tile_fore (seg008.c:690) --- */
|
||||
if (code == 20) {
|
||||
wmod = wall_modifier(row, col);
|
||||
wall_b(WALL_FRAM_MAIN[wmod], x, dmy); /* основная грань */
|
||||
wall_pattern(row, col, 1);
|
||||
}
|
||||
if (t->fore_id)
|
||||
fore_b(t->fore_id, t->fore_x * 8 + x, t->fore_y + dmy);
|
||||
}
|
||||
|
||||
void pop_room_draw(uint8_t room_num,
|
||||
const uint8_t *fg, const uint8_t *bg,
|
||||
const uint8_t *lcol_fg, const uint8_t *lcol_bg)
|
||||
{
|
||||
int row, col;
|
||||
g_room = room_num;
|
||||
g_fg = fg; g_bg = bg;
|
||||
g_lfg = lcol_fg; g_lbg = lcol_bg;
|
||||
|
||||
/* прозрачный блит: 0xFF не пишется (чёрный фон/нижние слои проступают) */
|
||||
gfx_set_bank(GFX_BANK_TRANSPARENT);
|
||||
for (row = 2; row >= 0; row--) /* снизу вверх (2,1,0) */
|
||||
for (col = 0; col < 10; col++)
|
||||
draw_tile(row, col);
|
||||
gfx_set_bank(GFX_BANK_NORMAL);
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* pop_bg.h — отрисовка СТАТИЧЕСКОГО фона комнаты PoP композицией слоёв
|
||||
* (порт seg008.c draw_tile/wall_pattern, Шаг 3). Рисует прямо в текущую
|
||||
* страницу (banked GFX_BANK_TRANSPARENT — в видео-ОЗУ + теневую копию,
|
||||
* 0xFF прозрачен), ОДИН раз при входе в комнату.
|
||||
*
|
||||
* Данные: getimage-спрайты в атласах pop_env0..4/pop_wall/pop_fore
|
||||
* (toolchain/pop_pack_bg.py), палитра pop_bg.pal. Прямая адресация
|
||||
* id: env[id>>5] idx id&31, wall idx=id, fore idx=id — ноль remap-таблиц.
|
||||
*/
|
||||
#ifndef POP_BG_H
|
||||
#define POP_BG_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* Загрузить 7 атласов фона. Звать ДО initgraph (как poc.c — atlas_load
|
||||
* трогает W3; проверенный порядок). Палитру pop_bg.pal грузит ПРИЛОЖЕНИЕ
|
||||
* после initgraph (gfx_pal_fload). 0 — OK, -1 — ошибка. */
|
||||
int pop_bg_load(void);
|
||||
|
||||
/* Освободить EMM-страницы атласов. */
|
||||
void pop_bg_free(void);
|
||||
|
||||
/* Нарисовать комнату: fg[30]/bg[30] — foretable-коды/backtable-модификаторы
|
||||
* (по строкам, row*10+col). lcol_fg/lcol_bg — 3 тайла правого столбца
|
||||
* ЛЕВОЙ соседней комнаты (для границы, напр. решётки ворот), или 0 —
|
||||
* тогда левая кромка = стена. room_num — номер комнаты (зерно стен). */
|
||||
void pop_room_draw(uint8_t room_num,
|
||||
const uint8_t *fg, const uint8_t *bg,
|
||||
const uint8_t *lcol_fg, const uint8_t *lcol_bg);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,368 @@
|
||||
/*
|
||||
* pop_ctrl.c — управление Kid (Фаза K2b). Порт SDLPoP:
|
||||
* вход — read_user_control/user_control/rest_ctrl_1/save_ctrl_1
|
||||
* (seg006.c) поверх held-state <kbd_raw.h>;
|
||||
* диспетчер — control() + control_standing/turning/startrun/running/
|
||||
* crouched (seg005.c), Kid-only ветки (без меча/стражи);
|
||||
* действия — forward/back/up/down_pressed, crouch, standing_jump,
|
||||
* run_jump, safe_step (seg005.c).
|
||||
*
|
||||
* Map-запросы (стена/край/захват) ЗАСТАБЛЕНЫ «открытый пол» (map_* ниже) —
|
||||
* реальная коллизия в K3/K4. Поэтому: forward -> всегда бег, down -> присед,
|
||||
* back -> разворот, up+forward -> прыжок с места; osторожный шаг и climb
|
||||
* помечены TODO(K3/K4).
|
||||
*
|
||||
* Значения CONTROL_* (types.h): RELEASED=0, IGNORE=1, HELD=-1;
|
||||
* X: LEFT/FORWARD=-1, RIGHT/BACKWARD=+1; Y: UP=-1, DOWN=+1.
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include <kbd_raw.h>
|
||||
#include "pop_kid.h"
|
||||
#include "pop_map.h"
|
||||
|
||||
/* ---- CONTROL_* и seq/frame id (подмножество types.h) --------------- */
|
||||
#define CONTROL_RELEASED 0
|
||||
#define CONTROL_IGNORE 1
|
||||
#define CONTROL_HELD (-1)
|
||||
#define CONTROL_HELD_LEFT (-1)
|
||||
#define CONTROL_HELD_RIGHT 1
|
||||
#define CONTROL_HELD_FORWARD (-1)
|
||||
#define CONTROL_HELD_BACKWARD 1
|
||||
#define CONTROL_HELD_UP (-1)
|
||||
#define CONTROL_HELD_DOWN 1
|
||||
|
||||
#define DIR_RIGHT 0 /* dir_0_right */
|
||||
|
||||
#define SEQ_1_START_RUN 1
|
||||
#define SEQ_2_STAND 2
|
||||
#define SEQ_3_STANDING_JUMP 3
|
||||
#define SEQ_4_RUN_JUMP 4
|
||||
#define SEQ_5_TURN 5
|
||||
#define SEQ_6_RUN_TURN 6
|
||||
#define SEQ_13_STOP_RUN 13
|
||||
#define SEQ_26_CROUCH_WHILE_RUNNING 26
|
||||
#define SEQ_43_START_RUN_AFTER_TURN 43
|
||||
#define SEQ_49_STAND_UP_FROM_CROUCH 49
|
||||
#define SEQ_50_CROUCH 50
|
||||
#define SEQ_79_CROUCH_HOP 79
|
||||
#define SEQ_STEP_BASE 28 /* +distance(1..14) = seq 29..42 шаг-N */
|
||||
#define SEQ_39_UNSAFE_STEP 39 /* шаг за кромку (distance 11) */
|
||||
#define SEQ_44_STEP_ON_EDGE 44
|
||||
#define SEQ_14_JUMP_INTO_CEILING 14 /* прыжок вверх: сверху стена/пол */
|
||||
#define SEQ_28_JUMP_NOTHING_ABOVE 28 /* прыжок вверх: сверху пусто */
|
||||
|
||||
#define FRAME_7_RUN 7
|
||||
#define FRAME_11_RUN 11
|
||||
#define FRAME_15_STAND 15
|
||||
#define FRAME_48_TURN 48
|
||||
#define FRAME_50_TURN 50
|
||||
#define FRAME_67_JUMPUP1 67
|
||||
#define FRAME_70_JUMPHANG 70
|
||||
#define FRAME_87_HANG1 87
|
||||
#define FRAME_109_CROUCH 109
|
||||
|
||||
/* ---- Состояние управления (seg006 globals) ------------------------ *
|
||||
* control_x/y/shift — «сырое» состояние осей ЭТОГО кадра (абсолютно:
|
||||
* X LEFT/-1..RIGHT/+1); *_forward/backward/up/down/shift2 — конечный
|
||||
* автомат held/released/ignore (авто-повтор); ctrl1_* — их память между
|
||||
* кадрами (rest/save). */
|
||||
static int8_t control_x, control_y, control_shift;
|
||||
static int8_t control_forward, control_backward, control_up, control_down, control_shift2;
|
||||
static int8_t ctrl1_forward, ctrl1_backward, ctrl1_up, ctrl1_down, ctrl1_shift2;
|
||||
|
||||
/* ---- seqtbl_offset_char: сменить последовательность Kid ------------ *
|
||||
* Обёртка над kid_set_seq (единая точка в pop_kid — kid_seq_off/kid_seqtbl
|
||||
* не дублируются в этот TU). */
|
||||
#define seqtbl_offset_char(seq) kid_set_seq(seq)
|
||||
|
||||
static int8_t release_arrows(void)
|
||||
{
|
||||
control_backward = control_forward = control_up = control_down = CONTROL_RELEASED;
|
||||
return CONTROL_IGNORE; /* seg006: return 1 */
|
||||
}
|
||||
|
||||
/* Край/стена впереди — из pop_map (get_edge_distance): pop_edge_distance()
|
||||
* возвращает дистанцию и ставит pop_edge_type() = EDGE_WALL/FLOOR/CLOSER. */
|
||||
|
||||
/* ---- Действия (seg005) -------------------------------------------- */
|
||||
static void crouch(void)
|
||||
{
|
||||
seqtbl_offset_char(SEQ_50_CROUCH);
|
||||
control_down = release_arrows();
|
||||
}
|
||||
|
||||
static void standing_jump(void)
|
||||
{
|
||||
control_up = control_forward = CONTROL_IGNORE;
|
||||
seqtbl_offset_char(SEQ_3_STANDING_JUMP);
|
||||
}
|
||||
|
||||
static void run_jump(void)
|
||||
{
|
||||
/* Оригинал выравнивает Kid по краю пола (нужны tile-запросы) — это
|
||||
* полировка K3; K2b просто запускает run-jump. */
|
||||
if (Kid.frame >= FRAME_7_RUN) {
|
||||
control_up = release_arrows();
|
||||
seqtbl_offset_char(SEQ_4_RUN_JUMP);
|
||||
}
|
||||
}
|
||||
|
||||
static void safe_step(void); /* fwd */
|
||||
|
||||
static void forward_pressed(void)
|
||||
{
|
||||
int distance = pop_edge_distance();
|
||||
if (pop_edge_type() == EDGE_WALL && distance < 8) {
|
||||
/* рядом стена — вместо бега осторожный шаг (в стену не разбежится) */
|
||||
if (control_forward == CONTROL_HELD)
|
||||
safe_step();
|
||||
} else {
|
||||
seqtbl_offset_char(SEQ_1_START_RUN);
|
||||
}
|
||||
}
|
||||
|
||||
static void back_pressed(void)
|
||||
{
|
||||
control_backward = release_arrows();
|
||||
/* Kid без меча -> просто разворот. */
|
||||
seqtbl_offset_char(SEQ_5_TURN);
|
||||
}
|
||||
|
||||
static void down_pressed(void)
|
||||
{
|
||||
control_down = CONTROL_IGNORE; /* без авто-повтора */
|
||||
/* climb-down у края (seq_68) — K4 (зацеп/спуск); пока просто присед. */
|
||||
crouch();
|
||||
}
|
||||
|
||||
/* Вертикальный прыжок вверх (seg005 jump_up, упрощённо): сверху сплошное
|
||||
* (стена/пол) → seq_14 (в потолок), иначе seq_28 (пусто сверху). Зацеп за
|
||||
* уступ сверху-впереди (can_grab) — K4.2, пока чистый вертикальный прыжок. */
|
||||
static void jump_up(void)
|
||||
{
|
||||
control_up = release_arrows();
|
||||
if (pop_above_solid())
|
||||
seqtbl_offset_char(SEQ_14_JUMP_INTO_CEILING);
|
||||
else
|
||||
seqtbl_offset_char(SEQ_28_JUMP_NOTHING_ABOVE);
|
||||
}
|
||||
|
||||
static void up_pressed(void)
|
||||
{
|
||||
/* (дверь уровня/телепорт — нет в тесте.) ↑+forward = прыжок с места;
|
||||
* иначе вертикальный прыжок вверх. */
|
||||
if (control_x == CONTROL_HELD_FORWARD)
|
||||
standing_jump();
|
||||
else
|
||||
jump_up();
|
||||
}
|
||||
|
||||
/* Осторожный шаг (Shift+forward): шаг РОВНО до кромки/стены. distance>0 —
|
||||
* шаг длины distance (seq 29..42 = step1..step14); ==0 у края — шаг на
|
||||
* кромку (seq_44) либо неосторожный шаг за край (seq_39). Порт seg005. */
|
||||
static void safe_step(void)
|
||||
{
|
||||
int distance;
|
||||
control_shift2 = CONTROL_IGNORE; /* без авто-повтора */
|
||||
control_forward = CONTROL_IGNORE;
|
||||
distance = pop_edge_distance();
|
||||
if (distance) {
|
||||
Kid.repeat = 1;
|
||||
seqtbl_offset_char((uint8_t)(distance + SEQ_STEP_BASE));
|
||||
} else if (pop_edge_type() == EDGE_WALL) {
|
||||
/* вплотную к стене: маленький шаг-1 — check_bumped отскочит назад
|
||||
* (шаг назад со звуком, как оригинал), НЕ seq_39 (шаг за край=падение). */
|
||||
Kid.repeat = 1;
|
||||
seqtbl_offset_char((uint8_t)(1 + SEQ_STEP_BASE));
|
||||
} else if (Kid.repeat != 0) {
|
||||
Kid.repeat = 0;
|
||||
seqtbl_offset_char(SEQ_44_STEP_ON_EDGE);
|
||||
} else {
|
||||
seqtbl_offset_char(SEQ_39_UNSAFE_STEP); /* реальный обрыв (edge=CLOSER) */
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- control_* обработчики состояний ------------------------------ */
|
||||
static void control_crouched(void)
|
||||
{
|
||||
if (control_y != CONTROL_HELD_DOWN) {
|
||||
seqtbl_offset_char(SEQ_49_STAND_UP_FROM_CROUCH);
|
||||
} else if (control_forward == CONTROL_HELD) {
|
||||
control_forward = CONTROL_IGNORE;
|
||||
seqtbl_offset_char(SEQ_79_CROUCH_HOP);
|
||||
}
|
||||
}
|
||||
|
||||
static void control_standing(void)
|
||||
{
|
||||
/* Kid charid_0, без меча: остаётся нижняя часть control_standing. */
|
||||
if (control_shift == CONTROL_HELD) {
|
||||
if (control_backward == CONTROL_HELD) back_pressed();
|
||||
else if (control_up == CONTROL_HELD) up_pressed();
|
||||
else if (control_down == CONTROL_HELD) down_pressed();
|
||||
else if (control_x == CONTROL_HELD_FORWARD && control_forward == CONTROL_HELD)
|
||||
safe_step();
|
||||
} else if (control_forward == CONTROL_HELD) {
|
||||
if (control_up == CONTROL_HELD) standing_jump(); /* keyboard mode */
|
||||
else forward_pressed();
|
||||
} else if (control_backward == CONTROL_HELD) {
|
||||
back_pressed();
|
||||
} else if (control_up == CONTROL_HELD) {
|
||||
if (control_forward == CONTROL_HELD) standing_jump();
|
||||
else up_pressed();
|
||||
} else if (control_down == CONTROL_HELD) {
|
||||
down_pressed();
|
||||
} else if (control_x == CONTROL_HELD_FORWARD) {
|
||||
forward_pressed();
|
||||
}
|
||||
}
|
||||
|
||||
static void control_turning(void)
|
||||
{
|
||||
if (control_shift >= CONTROL_RELEASED &&
|
||||
control_x == CONTROL_HELD_FORWARD && control_y >= CONTROL_RELEASED) {
|
||||
seqtbl_offset_char(SEQ_43_START_RUN_AFTER_TURN);
|
||||
}
|
||||
}
|
||||
|
||||
static void control_startrun(void)
|
||||
{
|
||||
if (control_y == CONTROL_HELD_UP && control_x == CONTROL_HELD_FORWARD)
|
||||
standing_jump();
|
||||
}
|
||||
|
||||
static void control_running(void)
|
||||
{
|
||||
/* Стену НЕ обрабатываем тут — check_bumped (pop_phys_tick) даёт отскок
|
||||
* seq_47 при беге в стену (как оригинал), с корректной позицией. */
|
||||
if (control_x == CONTROL_RELEASED &&
|
||||
(Kid.frame == FRAME_7_RUN || Kid.frame == FRAME_11_RUN)) {
|
||||
control_forward = release_arrows();
|
||||
seqtbl_offset_char(SEQ_13_STOP_RUN);
|
||||
} else if (control_x == CONTROL_HELD_BACKWARD) {
|
||||
control_backward = release_arrows();
|
||||
seqtbl_offset_char(SEQ_6_RUN_TURN);
|
||||
} else if (control_y == CONTROL_HELD_UP && control_up == CONTROL_HELD) {
|
||||
run_jump();
|
||||
} else if (control_down == CONTROL_HELD) {
|
||||
control_down = CONTROL_IGNORE;
|
||||
seqtbl_offset_char(SEQ_26_CROUCH_WHILE_RUNNING);
|
||||
}
|
||||
}
|
||||
|
||||
/* control() — диспетчер по кадру (seg005.c:252), Kid жив, без меча. */
|
||||
static void control(void)
|
||||
{
|
||||
uint8_t f = Kid.frame;
|
||||
if (f == FRAME_15_STAND || (f >= FRAME_50_TURN && f < 53))
|
||||
control_standing();
|
||||
else if (f == FRAME_48_TURN)
|
||||
control_turning();
|
||||
else if (f < 4)
|
||||
control_startrun();
|
||||
else if (f >= FRAME_67_JUMPUP1 && f < FRAME_70_JUMPHANG)
|
||||
; /* control_jumpup — K4 */
|
||||
else if (f < FRAME_15_STAND)
|
||||
control_running();
|
||||
else if (f >= FRAME_87_HANG1 && f < 100)
|
||||
; /* control_hanging — K4 */
|
||||
else if (f == FRAME_109_CROUCH)
|
||||
control_crouched();
|
||||
}
|
||||
|
||||
/* ---- Модель ввода (seg006) ---------------------------------------- */
|
||||
static void read_input(void)
|
||||
{
|
||||
uint8_t l = kbd_raw_down(KBD_LEFT);
|
||||
uint8_t r = kbd_raw_down(KBD_RIGHT);
|
||||
uint8_t u = kbd_raw_down(KBD_UP);
|
||||
uint8_t d = kbd_raw_down(KBD_DOWN);
|
||||
control_x = r ? CONTROL_HELD_RIGHT : (l ? CONTROL_HELD_LEFT : CONTROL_RELEASED);
|
||||
control_y = d ? CONTROL_HELD_DOWN : (u ? CONTROL_HELD_UP : CONTROL_RELEASED);
|
||||
control_shift = (kbd_raw_down(KBD_LSHIFT) || kbd_raw_down(KBD_RSHIFT))
|
||||
? CONTROL_HELD : CONTROL_RELEASED;
|
||||
}
|
||||
|
||||
/* read_user_control (seg006:1557): «свежее нажатие» (RELEASED->HELD) с
|
||||
* подавлением авто-повтора (IGNORE держится, пока клавишу не отпустят). */
|
||||
static void read_user_control(void)
|
||||
{
|
||||
if (control_forward >= CONTROL_RELEASED) {
|
||||
if (control_x == CONTROL_HELD_FORWARD) {
|
||||
if (control_forward == CONTROL_RELEASED) control_forward = CONTROL_HELD;
|
||||
} else control_forward = CONTROL_RELEASED;
|
||||
}
|
||||
if (control_backward >= CONTROL_RELEASED) {
|
||||
if (control_x == CONTROL_HELD_BACKWARD) {
|
||||
if (control_backward == CONTROL_RELEASED) control_backward = CONTROL_HELD;
|
||||
} else control_backward = CONTROL_RELEASED;
|
||||
}
|
||||
if (control_up >= CONTROL_RELEASED) {
|
||||
if (control_y == CONTROL_HELD_UP) {
|
||||
if (control_up == CONTROL_RELEASED) control_up = CONTROL_HELD;
|
||||
} else control_up = CONTROL_RELEASED;
|
||||
}
|
||||
if (control_down >= CONTROL_RELEASED) {
|
||||
if (control_y == CONTROL_HELD_DOWN) {
|
||||
if (control_down == CONTROL_RELEASED) control_down = CONTROL_HELD;
|
||||
} else control_down = CONTROL_RELEASED;
|
||||
}
|
||||
if (control_shift2 >= CONTROL_RELEASED) {
|
||||
if (control_shift == CONTROL_HELD) {
|
||||
if (control_shift2 == CONTROL_RELEASED) control_shift2 = CONTROL_HELD;
|
||||
} else control_shift2 = CONTROL_RELEASED;
|
||||
}
|
||||
}
|
||||
|
||||
static void flip_control_x(void)
|
||||
{
|
||||
int8_t t;
|
||||
control_x = (int8_t)-control_x;
|
||||
t = control_forward; control_forward = control_backward; control_backward = t;
|
||||
}
|
||||
|
||||
/* user_control (seg006:0DC0): «вперёд» относительно направления Kid. */
|
||||
static void user_control(void)
|
||||
{
|
||||
if (Kid.direction >= DIR_RIGHT) {
|
||||
flip_control_x();
|
||||
control();
|
||||
flip_control_x();
|
||||
} else {
|
||||
control();
|
||||
}
|
||||
}
|
||||
|
||||
static void rest_ctrl_1(void)
|
||||
{
|
||||
control_forward = ctrl1_forward; control_backward = ctrl1_backward;
|
||||
control_up = ctrl1_up; control_down = ctrl1_down; control_shift2 = ctrl1_shift2;
|
||||
}
|
||||
static void save_ctrl_1(void)
|
||||
{
|
||||
ctrl1_forward = control_forward; ctrl1_backward = control_backward;
|
||||
ctrl1_up = control_up; ctrl1_down = control_down; ctrl1_shift2 = control_shift2;
|
||||
}
|
||||
|
||||
/* ---- Публичный API ------------------------------------------------ */
|
||||
int pop_ctrl_init(void)
|
||||
{
|
||||
control_forward = control_backward = control_up = control_down = CONTROL_RELEASED;
|
||||
control_shift2 = CONTROL_RELEASED;
|
||||
ctrl1_forward = ctrl1_backward = ctrl1_up = ctrl1_down = ctrl1_shift2 = CONTROL_RELEASED;
|
||||
return kbd_raw_open();
|
||||
}
|
||||
|
||||
void pop_ctrl_close(void)
|
||||
{
|
||||
kbd_raw_close();
|
||||
}
|
||||
|
||||
void pop_ctrl_tick(void)
|
||||
{
|
||||
rest_ctrl_1();
|
||||
read_input();
|
||||
read_user_control();
|
||||
user_control(); /* -> control(): может сменить Kid.curr_seq */
|
||||
save_ctrl_1();
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* pop_ctrl.h — управление Kid (Фаза K2b): порт диспетчера control()
|
||||
* (SDLPoP seg005.c) + модель ввода read_user_control/user_control
|
||||
* (seg006.c) поверх held-state клавиатуры <kbd_raw.h>.
|
||||
*
|
||||
* Kid-only подмножество: без меча и стражи. Map-запросы (стена/край/
|
||||
* захват) ЗАСТАБЛЕНЫ «открытый пол» — реальная коллизия (стоп у стены,
|
||||
* падение в ямы, повисание) приходит в K3/K4. Даёт отклик на клавиши:
|
||||
* бег влево/вправо, разворот, стоп, присед, прыжок с места, прыжок в
|
||||
* беге, присед-прыжок.
|
||||
*
|
||||
* Раскладка (kbd_raw, PS/2 Set 2): ←/→ = движение, ↓ = присед, ↑ =
|
||||
* прыжок вверх (с →), Shift = осторожный шаг (K3). ESC — выход (проверяет
|
||||
* приложение сам, канал raw забирает весь ввод у DSS).
|
||||
*/
|
||||
#ifndef POP_CTRL_H
|
||||
#define POP_CTRL_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* Открыть raw-канал клавиатуры и обнулить память авто-повтора.
|
||||
* 0 — OK, -1 — ошибка (EBUSY и пр., см. kbd_raw_open). */
|
||||
int pop_ctrl_init(void);
|
||||
void pop_ctrl_close(void);
|
||||
|
||||
/* Один кадр ввода: прочитать клавиши -> обновить control_* -> прогнать
|
||||
* диспетчер control() (может сменить Kid.curr_seq). Звать ПЕРЕД
|
||||
* kid_tick() (play_seq продолжит с новой последовательности). */
|
||||
void pop_ctrl_tick(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,220 @@
|
||||
/*
|
||||
* pop_kid.c — движок Kid (Фаза K1): порт seg006.c play_seq/load_frame +
|
||||
* seqtbl-интерпретатор. Данные — kid_data.h.
|
||||
*/
|
||||
#include <graphics.h>
|
||||
#include <gfx.h>
|
||||
#include <sprite.h>
|
||||
#include "pop_kid.h"
|
||||
#include "kid_data.h"
|
||||
|
||||
kid_t Kid;
|
||||
|
||||
/* Координатные таблицы (data.h). */
|
||||
static const uint8_t x_bump[20] = {
|
||||
(uint8_t)-12, 2, 16, 30, 44, 58, 72, 86, 100, 114,
|
||||
128, 142, 156, 170, 184, 198, 212, 226, 240, 254
|
||||
};
|
||||
static const int16_t y_land[5] = {-8, 55, 118, 181, 244};
|
||||
#define FIRST_ONSCREEN_COLUMN 5
|
||||
#define TILE_SIZEX 14
|
||||
|
||||
/* ---- Атласы Kid (прямая адресация image>>3) ------------------------ */
|
||||
#define KID_MAXPAGES 28
|
||||
static atlas_t kidp[KID_MAXPAGES];
|
||||
static uint8_t kid_npages;
|
||||
|
||||
int pop_kid_load(uint8_t npages)
|
||||
{
|
||||
static const char *const names[KID_MAXPAGES] = {
|
||||
"kid0.atl","kid1.atl","kid2.atl","kid3.atl","kid4.atl","kid5.atl",
|
||||
"kid6.atl","kid7.atl","kid8.atl","kid9.atl","kid10.atl","kid11.atl",
|
||||
"kid12.atl","kid13.atl","kid14.atl","kid15.atl","kid16.atl","kid17.atl",
|
||||
"kid18.atl","kid19.atl","kid20.atl","kid21.atl","kid22.atl","kid23.atl",
|
||||
"kid24.atl","kid25.atl","kid26.atl","kid27.atl"
|
||||
};
|
||||
uint8_t i;
|
||||
if (npages > KID_MAXPAGES) npages = KID_MAXPAGES;
|
||||
for (i = 0; i < npages; i++)
|
||||
if (atlas_load(&kidp[i], names[i]) != 0)
|
||||
return -1;
|
||||
kid_npages = npages;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void pop_kid_free(void)
|
||||
{
|
||||
uint8_t i;
|
||||
for (i = 0; i < kid_npages; i++)
|
||||
atlas_free(&kidp[i]);
|
||||
kid_npages = 0;
|
||||
}
|
||||
|
||||
/* ---- seqtbl-доступ (база SEQTBL_BASE) ------------------------------ */
|
||||
#define SEQ(cs) kid_seqtbl[(uint16_t)((cs) - SEQTBL_BASE)]
|
||||
|
||||
static uint8_t char_dx_forward(int8_t dx)
|
||||
{
|
||||
if (Kid.direction < 0) dx = (int8_t)-dx;
|
||||
return (uint8_t)(Kid.x + dx);
|
||||
}
|
||||
|
||||
/* Аксессоры к текущему кадру (для pop_map — без дублирования kid_frames). */
|
||||
int8_t kid_cur_dx(void) { return kid_frames[Kid.frame].dx; }
|
||||
uint8_t kid_cur_flags(void) { return kid_frames[Kid.frame].flags; }
|
||||
|
||||
/* seqtbl_offset_char: сменить последовательность Kid (единая точка —
|
||||
* pop_ctrl/pop_map зовут ЕЁ, а не дублируют kid_seq_off/kid_seqtbl). */
|
||||
void kid_set_seq(uint8_t seq_id) { Kid.curr_seq = kid_seq_off[seq_id]; }
|
||||
|
||||
/* play_seq (seg006.c:570): крутит опкоды до КАДРА (байт < 0xF0). */
|
||||
void play_seq(void)
|
||||
{
|
||||
for (;;) {
|
||||
uint8_t cmd = SEQ(Kid.curr_seq);
|
||||
Kid.curr_seq++;
|
||||
switch (cmd) {
|
||||
case 0xFB: /* DX */
|
||||
Kid.x = char_dx_forward((int8_t)SEQ(Kid.curr_seq));
|
||||
Kid.curr_seq++;
|
||||
break;
|
||||
case 0xFA: /* DY */
|
||||
Kid.y = (uint8_t)(Kid.y + (int8_t)SEQ(Kid.curr_seq));
|
||||
Kid.curr_seq++;
|
||||
break;
|
||||
case 0xFE: /* FLIP */
|
||||
Kid.direction = (int8_t)~Kid.direction;
|
||||
break;
|
||||
case 0xF7: /* JMP_IF_FEATHER: нет пера -> пропустить адрес */
|
||||
Kid.curr_seq += 2;
|
||||
break;
|
||||
case 0xFF: { /* JMP */
|
||||
uint16_t a = (uint16_t)(SEQ(Kid.curr_seq) |
|
||||
((uint16_t)SEQ((uint16_t)(Kid.curr_seq + 1)) << 8));
|
||||
Kid.curr_seq = a;
|
||||
break;
|
||||
}
|
||||
case 0xFD: /* UP */
|
||||
Kid.curr_row--;
|
||||
break;
|
||||
case 0xFC: /* DOWN */
|
||||
Kid.curr_row++;
|
||||
break;
|
||||
case 0xF9: /* ACTION */
|
||||
Kid.action = SEQ(Kid.curr_seq);
|
||||
Kid.curr_seq++;
|
||||
break;
|
||||
case 0xF8: /* SET_FALL */
|
||||
Kid.fall_x = (int8_t)SEQ(Kid.curr_seq); Kid.curr_seq++;
|
||||
Kid.fall_y = (int8_t)SEQ(Kid.curr_seq); Kid.curr_seq++;
|
||||
break;
|
||||
case 0xF5: case 0xF4: /* KNOCK up/down */
|
||||
break;
|
||||
case 0xF2: /* SOUND — потребить 1 байт */
|
||||
Kid.curr_seq++;
|
||||
break;
|
||||
case 0xF1: /* END_LEVEL */
|
||||
break;
|
||||
case 0xF3: /* GET_ITEM — потребить 1 байт */
|
||||
Kid.curr_seq++;
|
||||
break;
|
||||
case 0xF6: /* DIE nop */
|
||||
break;
|
||||
default: /* КАДР */
|
||||
Kid.frame = cmd;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void kid_init(uint8_t seq_id, int8_t col, int8_t row, int8_t dir)
|
||||
{
|
||||
Kid.curr_col = col;
|
||||
Kid.curr_row = row;
|
||||
Kid.direction = dir;
|
||||
Kid.x = (uint8_t)(x_bump[col + FIRST_ONSCREEN_COLUMN] + TILE_SIZEX);
|
||||
Kid.y = (uint8_t)y_land[row + 1];
|
||||
Kid.fall_x = Kid.fall_y = 0;
|
||||
Kid.repeat = 0;
|
||||
Kid.curr_seq = kid_seq_off[seq_id];
|
||||
play_seq(); /* до первого кадра */
|
||||
}
|
||||
|
||||
void kid_tick(void)
|
||||
{
|
||||
play_seq();
|
||||
}
|
||||
|
||||
/* Отрисовка текущего кадра: obj_x=(char_x+dx)*2-116, obj_y=char_y+dy
|
||||
* (seg008.c:1728 load_frame_to_obj). НИЗ спрайта на obj_y, левый край
|
||||
* на obj_x. Калибровка XOFF/YOFF — сверить с эталоном.
|
||||
*
|
||||
* Зеркалирование (K2a): спрайты Kid хранятся ЛИЦОМ ВЛЕВО (как в оригинале).
|
||||
* seg008.c:864 — флип, когда персонаж смотрит ВПРАВО (direction==dir_0_right
|
||||
* ==0), и тогда xpos -= image->w (draw_mid). Реализуем бесплатным
|
||||
* горизонтальным флипом column-major спрайта (gfx_blit_cols flip=1):
|
||||
* зеркало происходит ВНУТРИ [x,x+w), поэтому при флипе подаём x=obj_x-w,
|
||||
* чтобы «hot-point» кадра остался на месте.
|
||||
*
|
||||
* Kid рисуется банком GFX_BANK_SPRITE (только видео-ОЗУ, НЕ теневая копия
|
||||
* — 0xFF прозрачен), чтобы kid_heal() мог восстановить чистый фон из
|
||||
* теневой копии (фон запёкся в неё при pop_room_draw). Прямоугольник
|
||||
* последней отрисовки запоминается для heal. */
|
||||
#define KID_XOFF 0
|
||||
#define KID_YOFF 0
|
||||
|
||||
static int kid_lx, kid_ly;
|
||||
static uint16_t kid_lw, kid_lh;
|
||||
static uint8_t kid_lvalid;
|
||||
|
||||
/* Восстановить фон из теневой копии на месте ПРЕДЫДУЩЕГО кадра Kid. */
|
||||
void kid_heal(void)
|
||||
{
|
||||
if (kid_lvalid)
|
||||
gfx_heal(kid_lx, kid_ly, kid_lw, kid_lh);
|
||||
kid_lvalid = 0;
|
||||
}
|
||||
|
||||
void kid_draw(void)
|
||||
{
|
||||
kframe fr = kid_frames[Kid.frame];
|
||||
int fwd, obj_x, obj_y, top;
|
||||
uint8_t page, idx;
|
||||
const uint8_t *img;
|
||||
uint16_t w, h;
|
||||
|
||||
if (fr.image == 255)
|
||||
return; /* пустой кадр */
|
||||
fwd = (int)Kid.x + ((Kid.direction < 0) ? -fr.dx : fr.dx);
|
||||
obj_x = (fwd << 1) - 116;
|
||||
obj_y = (int)Kid.y + fr.dy;
|
||||
if ((int8_t)(fr.flags ^ Kid.direction) >= 0)
|
||||
obj_x++; /* even/odd pixel (в ЛОГИЧЕСКОЙ координате) */
|
||||
/* seg008 calc_screen_x_coord: логическая X (280 шир = 28px/тайл) ->
|
||||
* экран (320 шир = 32px/тайл), ×320/280 = ×8/7. БЕЗ этого Kid уезжает
|
||||
* влево от тайлов тем сильнее, чем правее (col9 ~36px). Коллизия — в
|
||||
* логической системе (не масштабируется). */
|
||||
obj_x = obj_x * 8 / 7;
|
||||
|
||||
page = (uint8_t)(fr.image >> 3);
|
||||
idx = (uint8_t)(fr.image & 7);
|
||||
if (page >= kid_npages)
|
||||
return; /* страница не загружена */
|
||||
img = (const uint8_t *)atlas_image(&kidp[page], idx);
|
||||
gfx_w0_map(kidp[page].page);
|
||||
w = (uint16_t)(img[0] | ((uint16_t)img[1] << 8));
|
||||
h = (uint16_t)(img[2] | ((uint16_t)img[3] << 8));
|
||||
if (w && h) {
|
||||
uint8_t flip = (Kid.direction >= 0); /* dir_0_right -> зеркало */
|
||||
int bx = obj_x + KID_XOFF;
|
||||
if (flip)
|
||||
bx -= (int)w; /* seg008: xpos -= image->w */
|
||||
top = obj_y - (int)h + 1 + KID_YOFF;
|
||||
gfx_set_bank(GFX_BANK_SPRITE); /* видео-ОЗУ, без теневой копии */
|
||||
gfx_blit_cols(bx, top, img, flip);
|
||||
gfx_set_bank(GFX_BANK_NORMAL);
|
||||
kid_lx = bx; kid_ly = top;
|
||||
kid_lw = w; kid_lh = h; kid_lvalid = 1;
|
||||
}
|
||||
gfx_w0_unmap();
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
/*
|
||||
* pop_kid.h — движок анимации/движения Kid (Фаза K1): интерпретатор
|
||||
* seqtbl (play_seq) + frame_table. Порт SDLPoP seg006.c. Данные —
|
||||
* kid_data.h (pop_extract_kid_data.py).
|
||||
*
|
||||
* K1: только проигрывание последовательностей кадров с авторскими
|
||||
* смещениями (движение = SEQ_DX/DY + frame.dx/dy). Управление (K2) и
|
||||
* коллизия карты (K3) — отдельно.
|
||||
*/
|
||||
#ifndef POP_KID_H
|
||||
#define POP_KID_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* Состояние персонажа (подмножество char_type, types.h). */
|
||||
typedef struct {
|
||||
uint8_t frame;
|
||||
uint8_t x, y;
|
||||
int8_t direction; /* -1 влево, 0 вправо */
|
||||
int8_t curr_col, curr_row;
|
||||
uint8_t action;
|
||||
int8_t fall_x, fall_y;
|
||||
uint8_t repeat;
|
||||
uint16_t curr_seq; /* адрес в seqtbl (база SEQTBL_BASE) */
|
||||
} kid_t;
|
||||
|
||||
extern kid_t Kid;
|
||||
|
||||
/* Загрузить npages атласов Kid (kid0..kid{npages-1}.atl). ДО initgraph.
|
||||
* 0 — OK, -1 — ошибка. */
|
||||
int pop_kid_load(uint8_t npages);
|
||||
void pop_kid_free(void);
|
||||
|
||||
/* Инициализировать Kid: последовательность seq_id, клетка col/row,
|
||||
* направление dir (-1/0). Ставит x/y по x_bump/y_land. */
|
||||
void kid_init(uint8_t seq_id, int8_t col, int8_t row, int8_t dir);
|
||||
|
||||
/* Один логический тик: play_seq() — продвинуть последовательность до
|
||||
* следующего кадра (применить SEQ_DX/DY/ACTION/...). */
|
||||
void kid_tick(void);
|
||||
|
||||
/* play_seq напрямую (для pop_map start_fall — переход в fall-seq в тот же
|
||||
* physics-шаг, как оригинал). */
|
||||
void play_seq(void);
|
||||
|
||||
/* Поля текущего кадра kid_frames[Kid.frame] (pop_map, без дублирования
|
||||
* таблицы во втором TU). */
|
||||
int8_t kid_cur_dx(void);
|
||||
uint8_t kid_cur_flags(void);
|
||||
|
||||
/* Сменить последовательность (Kid.curr_seq = kid_seq_off[seq_id]) — единая
|
||||
* точка для pop_ctrl/pop_map (иначе каждый дублировал бы kid_seqtbl ~2.3КБ). */
|
||||
void kid_set_seq(uint8_t seq_id);
|
||||
|
||||
/* Нарисовать текущий кадр Kid (банк GFX_BANK_SPRITE — видео-ОЗУ, без
|
||||
* теневой копии; запоминает прямоугольник для kid_heal). */
|
||||
void kid_draw(void);
|
||||
|
||||
/* Восстановить фон (из теневой копии) на месте ПРЕДЫДУЩЕГО кадра Kid —
|
||||
* вместо перерисовки всего экрана. Звать ПЕРЕД kid_tick/kid_draw. */
|
||||
void kid_heal(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,382 @@
|
||||
/*
|
||||
* pop_map.c — коллизия Kid с картой (Фаза K3.2: падение). Порт SDLPoP
|
||||
* seg005/seg006. Пер-кадровый physics-диспетч check_action() по Char.action:
|
||||
* grounded (stand/run/step/crouch) -> check_on_floor(): кадр с флагом
|
||||
* FRAME_NEEDS_FLOOR (0x40), под персонажем не floor -> start_fall();
|
||||
* стена -> in_wall();
|
||||
* freefall (action 4) -> do_fall(): fall_y-ускорение (в fall_accel/speed),
|
||||
* достиг y_land[curr_row+1] -> land()/inc_curr_row.
|
||||
*
|
||||
* Координатная система PoP: экран.left = 58, тайл = 14 ед. (TILE_SIZEX);
|
||||
* col = (xpos-58)/14 (округл. вниз), xl = остаток; get_tile_div_mod_m7 =
|
||||
* div_mod(xpos-7). Карта: fg[row*10+col] & 0x1F; col<0/>9,row<0/>2 = стена.
|
||||
*
|
||||
* MVP: без spike/HP/grab/gate — падение + мягкое/среднее приземление.
|
||||
* Бег В стену (check_bumped) и осторожный шаг у края (get_edge_distance) —
|
||||
* следующим шагом.
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include "pop_kid.h"
|
||||
#include "pop_map.h"
|
||||
|
||||
/* ---- Тайлы / действия / seq id (подмножество PoP) ------------------ */
|
||||
#define TILE_EMPTY 0
|
||||
#define TILE_WALL 20
|
||||
#define ACT_STAND 0
|
||||
#define ACT_RUNJUMP 1
|
||||
#define ACT_HANGCLIMB 2
|
||||
#define ACT_MIDAIR 3
|
||||
#define ACT_FREEFALL 4
|
||||
#define ACT_BUMPED 5
|
||||
#define ACT_HANGSTRAIGHT 6
|
||||
|
||||
#define SEQ_7_FALL 7 /* stepfall (stand/run/step/crouch) */
|
||||
#define SEQ_17_SOFT_LAND 17
|
||||
#define SEQ_18_FALL_STANDJUMP 18
|
||||
#define SEQ_19_FALL 19 /* stepfall2 (run frames 9/13) */
|
||||
#define SEQ_20_MEDIUM_LAND 20
|
||||
#define SEQ_21_FALL_RUNJUMP 21
|
||||
#define SEQ_47_BUMP 47 /* удар в стену: dx(-4) отскок + 50-52 + stand */
|
||||
|
||||
#define FRAME_NEEDS_FLOOR 0x40
|
||||
#define FRAME_WEIGHT_X 0x1F
|
||||
#define TILE_SIZEX 14
|
||||
#define TILE_RIGHTX 13
|
||||
#define SCREENSPACE_X 58
|
||||
#define FALL_ACCEL 3
|
||||
#define FALL_MAX 33
|
||||
|
||||
#define TILE_MIDX 7
|
||||
#define FIRST_ONSCREEN_COLUMN 5
|
||||
#define FRAME_THIN 0x20
|
||||
|
||||
static const int16_t y_land[5] = {-8, 55, 118, 181, 244};
|
||||
static const int8_t dir_front[2] = {-1, 1}; /* [dir+1]: dir=-1->-1, 0->+1 */
|
||||
static const int16_t x_bump[20] = {
|
||||
-12, 2, 16, 30, 44, 58, 72, 86, 100, 114,
|
||||
128, 142, 156, 170, 184, 198, 212, 226, 240, 254
|
||||
};
|
||||
/* wall_type(tile): gate/doortop=1, mirror=2, chomper=3, wall=4, иначе 0. */
|
||||
static const int8_t wall_dl[6] = {0, 10, 0, -1, 0, 0}; /* wall_dist_from_left */
|
||||
static const int8_t wall_dr[6] = {0, 0, 10, 13, 0, 0}; /* wall_dist_from_right */
|
||||
static int8_t g_infrontx; /* колонка «перед персонажем» (set в get_tile_infrontof) */
|
||||
|
||||
/* ---- Карта комнаты ------------------------------------------------- */
|
||||
uint8_t pop_fell_out; /* 1 = Kid упал за низ комнаты (сброс приложением) */
|
||||
static const uint8_t *g_fg; /* fg[30], row*10+col */
|
||||
static uint8_t g_curr_tile; /* = curr_tile2: тайл последнего get_tile */
|
||||
static uint8_t g_obj_xl; /* позиция внутри тайла (get_tile_div_mod) */
|
||||
|
||||
void pop_map_set(const uint8_t *fg) { g_fg = fg; }
|
||||
|
||||
static uint8_t get_tile(int8_t col, int8_t row)
|
||||
{
|
||||
if (col < 0 || col > 9 || row < 0 || row > 2)
|
||||
g_curr_tile = TILE_WALL; /* край уровня = стена */
|
||||
else
|
||||
g_curr_tile = g_fg[row * 10 + col] & 0x1F;
|
||||
return g_curr_tile;
|
||||
}
|
||||
|
||||
static uint8_t tile_is_floor(uint8_t t)
|
||||
{
|
||||
switch (t) {
|
||||
case 0: case 9: case 12: case 20:
|
||||
case 26: case 27: case 28: case 29:
|
||||
return 0;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static uint8_t get_tile_at_char(void)
|
||||
{
|
||||
return get_tile(Kid.curr_col, Kid.curr_row);
|
||||
}
|
||||
|
||||
static uint8_t get_tile_infrontof_char(void)
|
||||
{
|
||||
g_infrontx = (int8_t)(dir_front[Kid.direction + 1] + Kid.curr_col);
|
||||
return get_tile(g_infrontx, Kid.curr_row);
|
||||
}
|
||||
|
||||
static uint8_t wall_type(uint8_t t)
|
||||
{
|
||||
switch (t) {
|
||||
case 4: case 7: case 12: return 1; /* стена справа (gate/doortop) */
|
||||
case 13: return 2; /* стена слева (mirror) */
|
||||
case 18: return 3; /* chomper */
|
||||
case 20: return 4; /* стена с обеих сторон */
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- Координаты ---------------------------------------------------- */
|
||||
static int char_dx_forward(int8_t dx)
|
||||
{
|
||||
int d = dx;
|
||||
if (Kid.direction < 0) d = -d;
|
||||
return (int)Kid.x + d;
|
||||
}
|
||||
|
||||
/* col = (xpos-58)/14 округл. вниз; g_obj_xl = позиция в тайле (0..13). */
|
||||
static int8_t get_tile_div_mod(int xpos)
|
||||
{
|
||||
int x = xpos - SCREENSPACE_X;
|
||||
int xh = x / TILE_SIZEX;
|
||||
int xl = x % TILE_SIZEX;
|
||||
if (xl < 0) { --xh; xl += TILE_SIZEX; } /* округление вниз */
|
||||
g_obj_xl = (uint8_t)xl;
|
||||
return (int8_t)xh;
|
||||
}
|
||||
|
||||
static int8_t get_tile_div_mod_m7(int xpos) { return get_tile_div_mod(xpos - 7); }
|
||||
|
||||
/* «весовая» точка кадра (dx с вычетом weight-битов флагов), в направлении. */
|
||||
static int dx_weight(void)
|
||||
{
|
||||
int8_t offset = (int8_t)(kid_cur_dx() - (kid_cur_flags() & FRAME_WEIGHT_X));
|
||||
return char_dx_forward(offset);
|
||||
}
|
||||
|
||||
static void determine_col(void)
|
||||
{
|
||||
Kid.curr_col = get_tile_div_mod_m7(dx_weight());
|
||||
}
|
||||
|
||||
/* расстояние до края тайла (для in_wall). */
|
||||
static int distance_to_edge(int xpos)
|
||||
{
|
||||
int d;
|
||||
get_tile_div_mod_m7(xpos); /* -> g_obj_xl */
|
||||
d = g_obj_xl;
|
||||
if (Kid.direction == 0) d = TILE_RIGHTX - d; /* dir_0_right */
|
||||
return d;
|
||||
}
|
||||
static int distance_to_edge_weight(void) { return distance_to_edge(dx_weight()); }
|
||||
|
||||
/* ---- ТОЧНАЯ коллизия со стеной (seg004) --------------------------- *
|
||||
* Передний край персонажа char_x_*_coll = char_dx_forward(cur_frame.dx)
|
||||
* (obj_x/2+58 сокращается ровно к этому; ширина спрайта НЕ нужна), ∓4 для
|
||||
* THIN-кадров. dist_from_wall_forward — расстояние переднего края до грани
|
||||
* стены tiletype в колонке tcol: >0 зазор, <=0 достал/зашёл (насколько). */
|
||||
static int char_front_coll(void)
|
||||
{
|
||||
int cx = char_dx_forward(kid_cur_dx());
|
||||
if (kid_cur_flags() & FRAME_THIN)
|
||||
cx += (Kid.direction < 0) ? 4 : -4; /* THIN: край внутрь */
|
||||
return cx;
|
||||
}
|
||||
|
||||
static int dist_from_wall_forward(uint8_t tiletype, int8_t tcol)
|
||||
{
|
||||
uint8_t type = wall_type(tiletype);
|
||||
int coll_left, cx;
|
||||
if (type == 0) return 127;
|
||||
coll_left = x_bump[tcol + FIRST_ONSCREEN_COLUMN] + TILE_MIDX;
|
||||
cx = char_front_coll();
|
||||
if (Kid.direction < 0) /* лицом влево */
|
||||
return cx - (coll_left + TILE_RIGHTX - wall_dr[type]);
|
||||
else /* лицом вправо */
|
||||
return wall_dl[type] + coll_left - cx;
|
||||
}
|
||||
|
||||
/* Выровнять передний край РОВНО к грани стены, если он зашёл за неё (bumped:
|
||||
* Char.x += dist; char_dx_forward отражает знак для обоих направлений).
|
||||
* Стена ищется под персонажем, иначе перед ним. */
|
||||
static void in_wall(void)
|
||||
{
|
||||
uint8_t t; int8_t tcol; int d;
|
||||
t = get_tile_at_char(); tcol = Kid.curr_col;
|
||||
if (!wall_type(t)) { t = get_tile_infrontof_char(); tcol = g_infrontx; }
|
||||
if (!wall_type(t)) return;
|
||||
d = dist_from_wall_forward(t, tcol);
|
||||
if (d < 0) {
|
||||
Kid.x = (uint8_t)char_dx_forward((int8_t)d); /* край -> грань */
|
||||
determine_col();
|
||||
get_tile_at_char();
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- Падение ------------------------------------------------------- */
|
||||
static void inc_curr_row(void) { Kid.curr_row++; }
|
||||
|
||||
static void land(void)
|
||||
{
|
||||
uint8_t seq;
|
||||
Kid.y = (uint8_t)y_land[Kid.curr_row + 1];
|
||||
/* к краю пола — чуть назад (как оригинал) */
|
||||
if (!tile_is_floor(get_tile_infrontof_char()) && distance_to_edge_weight() < 3)
|
||||
Kid.x = (uint8_t)char_dx_forward(-3);
|
||||
if (Kid.fall_y < 22)
|
||||
seq = SEQ_17_SOFT_LAND; /* 1 этаж — мягко */
|
||||
else
|
||||
seq = SEQ_20_MEDIUM_LAND; /* 2+ этажа — присесть (HP/смерть — позже) */
|
||||
Kid.fall_x = Kid.fall_y = 0;
|
||||
kid_set_seq(seq);
|
||||
play_seq();
|
||||
determine_col();
|
||||
}
|
||||
|
||||
static void start_fall(void)
|
||||
{
|
||||
uint8_t frame = Kid.frame, seq;
|
||||
inc_curr_row();
|
||||
if (frame == 9 || frame == 13) seq = SEQ_19_FALL; /* падение из бега */
|
||||
else if (frame == 26) seq = SEQ_18_FALL_STANDJUMP;
|
||||
else if (frame == 44) seq = SEQ_21_FALL_RUNJUMP;
|
||||
else seq = SEQ_7_FALL; /* stand/step/crouch */
|
||||
kid_set_seq(seq);
|
||||
play_seq();
|
||||
determine_col();
|
||||
if (get_tile_at_char() == TILE_WALL)
|
||||
in_wall();
|
||||
}
|
||||
|
||||
static void do_fall(void)
|
||||
{
|
||||
uint8_t nrow = (uint8_t)(Kid.curr_row + 1);
|
||||
if (nrow > 4) nrow = 4; /* защита y_land[] от выхода */
|
||||
if ((uint16_t)y_land[nrow] > (uint16_t)Kid.y) {
|
||||
/* ещё летит (check_grab — K4) */
|
||||
} else {
|
||||
if (get_tile_at_char() == TILE_WALL)
|
||||
in_wall();
|
||||
if (tile_is_floor(g_curr_tile))
|
||||
land();
|
||||
else if (Kid.curr_row < 2)
|
||||
inc_curr_row(); /* следующий ряд ВНУТРИ комнаты */
|
||||
else
|
||||
pop_fell_out = 1; /* упал за низ комнаты (нет пола,
|
||||
комнаты снизу нет) — приложение
|
||||
сбросит Kid (K-later: переход) */
|
||||
}
|
||||
}
|
||||
|
||||
static void fall_accel(void)
|
||||
{
|
||||
if (Kid.action == ACT_FREEFALL) {
|
||||
int fy = (uint8_t)Kid.fall_y + FALL_ACCEL;
|
||||
if (fy > FALL_MAX) fy = FALL_MAX;
|
||||
Kid.fall_y = (int8_t)fy;
|
||||
}
|
||||
}
|
||||
|
||||
static void fall_speed(void)
|
||||
{
|
||||
Kid.y = (uint8_t)(Kid.y + (uint8_t)Kid.fall_y);
|
||||
if (Kid.action == ACT_FREEFALL) {
|
||||
Kid.x = (uint8_t)char_dx_forward(Kid.fall_x);
|
||||
determine_col();
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- get_edge_distance (seg004:067C) — ТОЧНО ---------------------- *
|
||||
* Расстояние переднего края до стены/края впереди + тип g_edge_type: WALL
|
||||
* (стена в пределах тайла), FLOOR (пол — далеко, 11), CLOSER (край уступа
|
||||
* над ямой — distance_to_edge_weight). Стена сперва под персонажем, потом
|
||||
* перед ним; dist<=TILE_RIGHTX -> WALL, иначе FLOOR. */
|
||||
static uint8_t g_edge_type;
|
||||
|
||||
static int edge_classify(int d)
|
||||
{
|
||||
if (d <= TILE_RIGHTX) g_edge_type = EDGE_WALL;
|
||||
else { g_edge_type = EDGE_FLOOR; d = 11; }
|
||||
return d;
|
||||
}
|
||||
|
||||
int pop_edge_distance(void)
|
||||
{
|
||||
uint8_t t; int d;
|
||||
determine_col();
|
||||
t = get_tile_at_char();
|
||||
if (wall_type(t)) {
|
||||
d = dist_from_wall_forward(t, Kid.curr_col);
|
||||
if (d >= 0) return edge_classify(d);
|
||||
}
|
||||
t = get_tile_infrontof_char();
|
||||
if (wall_type(t)) {
|
||||
d = dist_from_wall_forward(t, g_infrontx);
|
||||
if (d >= 0) return edge_classify(d);
|
||||
}
|
||||
if (tile_is_floor(t)) { g_edge_type = EDGE_FLOOR; return 11; }
|
||||
g_edge_type = EDGE_CLOSER; /* яма впереди — до кромки уступа */
|
||||
return distance_to_edge_weight();
|
||||
}
|
||||
|
||||
uint8_t pop_edge_type(void) { return g_edge_type; }
|
||||
|
||||
/* Тайл НАД персонажем (curr_row-1, curr_col) сплошной (стена/пол)? — выбор
|
||||
* seq прыжка вверх: solid -> seq_14 (в потолок), иначе seq_28 (пусто сверху).
|
||||
* K4.1 упрощение: без grab-логики (уступ сверху-впереди) — та в K4.2. */
|
||||
uint8_t pop_above_solid(void)
|
||||
{
|
||||
uint8_t t = get_tile(Kid.curr_col, (int8_t)(Kid.curr_row - 1));
|
||||
return (t == TILE_WALL || tile_is_floor(t));
|
||||
}
|
||||
|
||||
/* Стена впереди достаточно близко для стопа бега? Детект (без сдвига —
|
||||
* позицию держит check_bumped=in_wall). d<=2: передний край почти у грани. */
|
||||
int pop_wall_ahead(void)
|
||||
{
|
||||
int d = pop_edge_distance();
|
||||
return (g_edge_type == EDGE_WALL && d <= 2);
|
||||
}
|
||||
|
||||
/* ---- Диспетчер ----------------------------------------------------- */
|
||||
static void check_on_floor(void)
|
||||
{
|
||||
if (kid_cur_flags() & FRAME_NEEDS_FLOOR) {
|
||||
if (get_tile_at_char() == TILE_WALL)
|
||||
in_wall(); /* забежал в стену -> выровнять */
|
||||
if (!tile_is_floor(g_curr_tile))
|
||||
start_fall();
|
||||
}
|
||||
}
|
||||
|
||||
static void check_action(void)
|
||||
{
|
||||
uint8_t action = Kid.action, frame = Kid.frame;
|
||||
if (action == ACT_BUMPED || action == ACT_HANGSTRAIGHT) {
|
||||
if (frame == 109 || (frame >= 110 && frame <= 119))
|
||||
check_on_floor();
|
||||
} else if (action == ACT_FREEFALL) {
|
||||
do_fall();
|
||||
} else if (action == ACT_MIDAIR) {
|
||||
/* frames 102..105: check_grab — K4 */
|
||||
} else if (action != ACT_HANGCLIMB) {
|
||||
check_on_floor();
|
||||
}
|
||||
}
|
||||
|
||||
/* check_bumped (seg004): если передний край ЗАШЁЛ за грань стены — выровнять
|
||||
* к грани И проиграть отскок seq_47_bump (dx−4 назад + кадры 50-52 + stand),
|
||||
* как в оригинале (bumped_floor). Это даёт «шаг назад со звуком» при беге/
|
||||
* шаге в стену вместо падения. Уже в отскоке (action bumped) — только
|
||||
* выравниваем, без рестарта. В падении/висе не трогаем. */
|
||||
static void check_bumped(void)
|
||||
{
|
||||
uint8_t t; int8_t tcol; int d;
|
||||
if (Kid.action == ACT_FREEFALL || Kid.action == ACT_HANGCLIMB) return;
|
||||
t = get_tile_at_char(); tcol = Kid.curr_col;
|
||||
if (!wall_type(t)) { t = get_tile_infrontof_char(); tcol = g_infrontx; }
|
||||
if (!wall_type(t)) return;
|
||||
d = dist_from_wall_forward(t, tcol);
|
||||
if (d >= 0) return; /* ещё не зашёл за грань */
|
||||
Kid.x = (uint8_t)char_dx_forward((int8_t)d); /* край -> грань */
|
||||
determine_col();
|
||||
if (Kid.action == ACT_BUMPED) return; /* уже в отскоке — не рестартить */
|
||||
Kid.fall_y = 0;
|
||||
kid_set_seq(SEQ_47_BUMP); /* отскок (TODO: bumped_sound) */
|
||||
play_seq();
|
||||
determine_col();
|
||||
}
|
||||
|
||||
void pop_phys_tick(void)
|
||||
{
|
||||
fall_accel();
|
||||
fall_speed();
|
||||
determine_col();
|
||||
check_bumped(); /* удержать у стены до check_action (порядок PoP) */
|
||||
check_action();
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
/*
|
||||
* pop_map.h — коллизия Kid с картой комнаты (Фаза K3): тайловые запросы
|
||||
* + физика падения + приземление. Порт SDLPoP seg005/seg006
|
||||
* (check_on_floor/start_fall/do_fall/fall_accel/fall_speed/land/in_wall).
|
||||
*
|
||||
* K3.2 (падение): Kid, сойдя/сбежав с края пола (тайл под ним не floor),
|
||||
* начинает падать (fall_y-ускорение, Char.y растёт), приземляется на пол
|
||||
* ниже (soft/medium land) или продолжает вниз. Стена под персонажем —
|
||||
* in_wall (выталкивание). Бег В стену (check_bumped) — отдельным шагом.
|
||||
*/
|
||||
#ifndef POP_MAP_H
|
||||
#define POP_MAP_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* Задать карту текущей комнаты: fg[30] = коды тайлов (row*10+col, 3×10).
|
||||
* col<0/>9 или row<0/>2 трактуются как стена (край уровня). */
|
||||
void pop_map_set(const uint8_t *fg);
|
||||
|
||||
/* Установлен в 1, когда Kid упал ниже комнаты (комнаты снизу нет в этом
|
||||
* тесте). Приложение должно сбросить Kid (kid_init) и снять флаг. */
|
||||
extern uint8_t pop_fell_out;
|
||||
|
||||
/* Пер-кадровая физика ПОСЛЕ kid_tick(play_seq): fall_accel + fall_speed +
|
||||
* determine_col + check_action (триггер падения / do_fall / приземление).
|
||||
* Порядок как в оригинале (seg000 play_kid_frame). */
|
||||
void pop_phys_tick(void);
|
||||
|
||||
/* Тип препятствия/края ВПЕРЕДИ по направлению (pop_edge_type после
|
||||
* pop_edge_distance): для control (бежать / осторожный шаг / стоп у стены). */
|
||||
#define EDGE_CLOSER 0 /* край уступа над ямой (дистанция = до кромки) */
|
||||
#define EDGE_WALL 1 /* стена впереди/под персонажем */
|
||||
#define EDGE_FLOOR 2 /* пол (нет препятствия рядом, дистанция = 11) */
|
||||
|
||||
/* Расстояние до края/стены впереди + побочно g_edge_type (pop_edge_type). */
|
||||
int pop_edge_distance(void);
|
||||
uint8_t pop_edge_type(void);
|
||||
|
||||
/* Стена впереди в пределах стопа? Если да — прижимает Kid.x к корректной
|
||||
* позиции (передний край у стены, симметрично) и возвращает 1. Для
|
||||
* control_running (чистый стоп у стены). */
|
||||
int pop_wall_ahead(void);
|
||||
|
||||
/* Тайл над персонажем сплошной (стена/пол)? — выбор seq вертикального
|
||||
* прыжка вверх (K4.1). */
|
||||
uint8_t pop_above_solid(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,10 @@
|
||||
/* room1_data.h — данные комнаты 1 ур.1 (res2001) + левый столбец
|
||||
* соседа (room 5 col9) для границы-решётки. Сгенерировано
|
||||
* gen из render_room; fg=foretable code, bg=backtable modifier. */
|
||||
#ifndef ROOM1_DATA_H
|
||||
#define ROOM1_DATA_H
|
||||
static const unsigned char room1_fg[30] = {0x00,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x14,0x14,0x13,0x13,0x01,0x03,0x00,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x0E,0x03,0x0B,0x01,0x01,0x14};
|
||||
static const unsigned char room1_bg[30] = {0xFF,0xFF,0xFF,0x00,0x01,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00};
|
||||
static const unsigned char leftcol_fg[3] = {0x04,0x14,0x14};
|
||||
static const unsigned char leftcol_bg[3] = {0x01,0x00,0x00};
|
||||
#endif
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* roomtest.c — проверка порта статического фона (Шаг 3): рисует комнату 1
|
||||
* уровня 1 реальной композицией слоёв (pop_bg.c) и держит на экране.
|
||||
* Сверять на MAME с эталоном applications/PoP/toolchain/1.1-2.png.
|
||||
*/
|
||||
#include <graphics.h>
|
||||
#include <gfx.h>
|
||||
#include <sprite.h>
|
||||
#include <conio.h>
|
||||
#include <stdio.h>
|
||||
#include <kbd_raw.h>
|
||||
#include "pop_bg.h"
|
||||
#include "pop_kid.h"
|
||||
#include "pop_ctrl.h"
|
||||
#include "pop_map.h"
|
||||
#include "room1_data.h"
|
||||
|
||||
/* seq_2_stand (types.h seqids) — Kid стоит, ждёт ввода. */
|
||||
#define SEQ_STAND 2
|
||||
|
||||
int main(void)
|
||||
{
|
||||
if (pop_bg_load() != 0) { /* атласы — ДО initgraph */
|
||||
puts("pop_bg_load failed");
|
||||
return 1;
|
||||
}
|
||||
if (pop_kid_load(28) != 0) { /* ВСЕ страницы: бег+стоп+разворот+присед+прыжок */
|
||||
puts("kid atlas load failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
initgraph();
|
||||
gfx_set_draw_page(0);
|
||||
gfx_set_visible_page(0);
|
||||
if (gfx_pal_fload(0, "kid.pal") < 0) /* единая игровая палитра */
|
||||
gfx_pal_fload(0, "a:\\kid.pal");
|
||||
gfx_pal_sync();
|
||||
|
||||
/* Фон комнаты рисуется ОДИН РАЗ — в видео-ОЗУ И теневую копию
|
||||
* (GFX_BANK_TRANSPARENT внутри pop_room_draw). Дальше каждый тик
|
||||
* восстанавливаем ТОЛЬКО прямоугольник Кида из теневой копии (heal),
|
||||
* а не весь экран. */
|
||||
setfillstyle(SOLID_FILL, BLACK);
|
||||
bar(0, 0, 319, 255);
|
||||
pop_room_draw(1, room1_fg, room1_bg, leftcol_fg, leftcol_bg);
|
||||
|
||||
/* K2b: Kid стоит на уступе (row1), управляется с клавиатуры.
|
||||
* ←/→ бег, ↓ присед, ↑+→ прыжок с места, Shift шаг (K3). ESC — выход. */
|
||||
pop_map_set(room1_fg); /* карта для коллизии/падения (K3) */
|
||||
kid_init(SEQ_STAND, 1, 1, 0);
|
||||
kid_draw();
|
||||
|
||||
if (pop_ctrl_init() != 0) { /* raw-канал клавиатуры (забирает ввод у DSS) */
|
||||
closegraph();
|
||||
puts("kbd_raw open failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
while (!kbd_raw_down(KBD_ESC)) {
|
||||
gfx_wait_vsync();
|
||||
gfx_wait_vsync();
|
||||
gfx_wait_vsync();
|
||||
pop_ctrl_tick(); /* ввод -> control(): смена seq */
|
||||
kid_heal(); /* стереть прошлый кадр (фон из тени) */
|
||||
kid_tick(); /* play_seq: следующий кадр */
|
||||
pop_phys_tick(); /* K3: падение/приземление/стена */
|
||||
if (pop_fell_out) { /* упал за низ комнаты — сброс на старт */
|
||||
pop_fell_out = 0;
|
||||
kid_init(SEQ_STAND, 1, 1, 0);
|
||||
}
|
||||
kid_draw(); /* нарисовать новый кадр */
|
||||
}
|
||||
|
||||
pop_ctrl_close();
|
||||
closegraph();
|
||||
pop_bg_free();
|
||||
pop_kid_free();
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user