snark13/Sprinter-SDCC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SprPoP: музыка без перелинковки — длины и длительности уехали на диск

Browse Source 
Часть I плана music_runtime_index_plan.md (MI0..MI5).  gen/pop_music_tbl.h
и gen/pop_music_ticks.h УДАЛЕНЫ: длины треков и длительности реплик
читаются из MUS/mus.idx (формат PMI1, tools/pop_idx.py, тесты в
make test-tools).  Один и тот же sprpop.exe работает с любым из четырёх
наборов записей — sha256 бинарника при смене MUSIC_FMT не меняется.

ГДЕ ЖИВЁТ ИНДЕКС.  228 байт таблицы в W2 не положить (свободной кучи там
порядка двух сотен), поэтому индекс лежит в одной странице EMM, а в
резиденте от него два байта.  Данные в странице — со смещения 0x100:
gfx_w0_page_prepare пишет в неё стабы прерываний (0x38 и 0x66), и с нуля
они попали бы прямо в записи id 10 и 21.  Со смещением работает штатная
защита, а не запрет прерываний (тот же приём, что CFG_BASE в
pop_config.c).  Число страниц в индексе не хранится — считается из blocks,
чтобы не разъехалось.

ПАУЗА КОНЦА УРОВНЯ — СОСТОЯНИЕМ, А НЕ СЧЁТЧИКОМ.  pop_endmus_left и
POP_MUS_TICKS_32/41 удалены; главный цикл ждёт pop_music_active() —
«заявка лежит, идёт загрузка или трек звучит».  Одного busy мало: между
заявкой и первой нотой 190-230 мс (замер в sound_plan §9).  Прежний
счётчик закрывал эту щель ценой зависимости EXE от набора и жёсткого
делителя /4, который врал в режимах FAST/FASTEST (там логический кадр 3
кадра луча, а не 4).  Побочно исправилось расхождение с SDLPoP: при
выключенном звуке заявка не кладётся, и уровень меняется сразу, как в
оригинале (seg006:651 + seg003:387) — раньше игра держала пройденный
уровень лишние 12 секунд в тишине.

PV-СЦЕНА — на четырёх якорях (8 байт статики), которые считаются из
индекса при входе в сцену; прежние выражения шкалы не изменились.  План
предлагал протащить структуру времён через пять функций — для сцены,
которая идёт раз за запуск, это того не стоит.

ПАМЯТЬ.  За обе фазы резидент не вырос, а освободился: _CODE 23865 ->
23544, куча 239 -> 256 Б.  Банк 9 похудел на 118 Б (ушла pop_mus_tbl из
rodata), банк 11 — на длительности реплик.

ПРОВЕРЕНО В MAME: exe побайтово одинаков для flac и mt32; все 22 трека в
индексах различаются, и контрольные значения совпали с предсказанными
планом (m41 732->685, m50 831->867, m53 985->1044, m56 9865->10462
блоков, 78->82 страницы); на mt32 PV-сцена проходит целиком по его
длительностям; без mus.idx музыки нет, эффекты работают, игра проходима.

НЕ ПРОВЕРЕНО: потоковый m56 на 82 страницах — до финала надо дойти в
игре.  Единственный оставшийся пункт приёмки, отмечен в sound_plan §11.5.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011MsUsEFAQfsjjQpJ7RtKVY
This commit is contained in:
Alexander Petrov
2026-08-31 17:17:59 +03:00
parent 2349481b86
commit df5071a967
17 changed files with 587 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files
applications/SprPoP/src/pop_intro.c
+73 -42
View File
@@ -15,7 +15,6 @@
#include "pop_shadow.h"
#include "pop_sfx.h"
#include "pop_music.h"
#include "pop_music_ticks.h" /* POP_MUS_TICKS_<id> — длина реплик набора */
#include "pop_arc.h"
#include "pv_arc.h"
#include "pop_cutscene.h"
@@ -60,9 +59,10 @@
* своего куска (например, всё поведение Джафара — от PV_DIALOG1_START).
* 2) «ЖДЁМ КОНЦА РЕПЛИКИ» — PV_M50_END и PV_EXIT_START. Это целиком
* длина НАШЕЙ записи, и она у каждого набора своя: m50 — 831 тик на
* flac против 867 на mt32, m53 — 985 против 1044. Поэтому берём их
* из POP_MUS_TICKS_<id>, которые печатает упаковщик того набора,
* которым собрана сборка (gen/pop_music_tbl.h).
* flac против 867 на mt32, m53 — 985 против 1044. Раньше их
* печатал упаковщик в gen/pop_music_ticks.h, из-за чего EXE был
* привязан к набору; теперь они приезжают из индекса набора
* (MUS/mus.idx) при входе в сцену — см. ЯКОРЯ ниже.
*
* Всё, что стоит ПОСЛЕ реплики, сдвигается вместе с её концом — отсюда
* сложения от PV_M50_END и PV_EXIT_START вместо литералов. */
@@ -72,46 +72,76 @@ enum {
/* Конец m50: кадр становится 8. Прежний литерал 846 отвечал длине 834
* тика — на три больше нашей записи (831); расхождение осталось с
* времён, когда длину подставляли руками. */
PV_M50_END = PV_MUS_2_START + POP_MUS_TICKS_50,
PV_WAIT_END = PV_M50_END + 40, /* +frame(5) -> створка ворот */
PV_GATE_END = PV_WAIT_END + 48,
PV_DOOR_END = PV_GATE_END + 24,
PV_TURN_START = PV_DOOR_END,
PV_WALK1_START = PV_DOOR_END + 40,
PV_DIALOG1_START = PV_WALK1_START + 48, /* Джафар входит — реплика m53 */
/* Ниже — биты сценария внутри реплики Джафара, все от её начала. */
PV_MUS_4_LOAD = PV_DIALOG1_START + 54, /* подкачка m52 */
PV_WALK2_START = PV_DIALOG1_START + 176,
PV_DIALOG2_START = PV_DIALOG1_START + 416,
/* ПОДГОНКА ЗАКЛИНАНИЯ ПОД МУЗЫКУ СНЯТА (2026-08-28): теперь 0.
*
* История: сцена была render-bound — кадр рисовался дороже своего
* бюджета, кадровая ветка пейсинга догона не имела, и анимация шла
* ~49 тиков в секунду вместо 60 (замер 2026-08-27). Реплика Джафара
* при этом играет по РЕАЛЬНОМУ времени, поэтому кода приходила
* примерно на секунду раньше молнии, и жест целиком (замах, шаг
* назад, вспышка) сдвигали раньше сценария на подобранные на слух
* 100 тиков.
*
* Причину убрали: отрисовка разложена по кадровым интервалам
* (pv_restore_bg), сцена идёт по единственным часам — кадрам луча, —
* и подкачка трека оплачивается интервалом (pop_music_load_step).
* После этого подгонка стала вредной: молния била больше чем на
* секунду раньше коды (проверка пользователем 2026-08-28). Константу
* оставляем на месте — если запись другого набора (mt32/ogg) снова
* разъедется, крутить надо её, а не тайминги сценария. */
PV_MAGIC_LEAD = 0,
PV_RAISE_START = PV_DIALOG1_START + 696 - PV_MAGIC_LEAD,
PV_STEPBACK_START = PV_DIALOG1_START + 703 - PV_MAGIC_LEAD,
PV_MAGIC_START = PV_DIALOG1_START + 822 - PV_MAGIC_LEAD,
/* Конец m53 — снова длина записи, а не бит сценария. */
PV_EXIT_START = PV_DIALOG1_START + POP_MUS_TICKS_53,
PV_MUS_4_START = PV_EXIT_START + 42, /* +frame(6) -> «Джафар уходит» */
PV_GLASS_DONE = PV_EXIT_START + 210,
PV_SLUMP_START = PV_EXIT_START + 273,
PV_ANIM_TICKS = PV_EXIT_START + 469
PV_MAGIC_LEAD = 0
};
/* ПОДГОНКА ЗАКЛИНАНИЯ ПОД МУЗЫКУ СНЯТА (2026-08-28): теперь 0.
*
* История: сцена была render-bound — кадр рисовался дороже своего
* бюджета, кадровая ветка пейсинга догона не имела, и анимация шла
* ~49 тиков в секунду вместо 60 (замер 2026-08-27). Реплика Джафара
* при этом играет по РЕАЛЬНОМУ времени, поэтому кода приходила
* примерно на секунду раньше молнии, и жест целиком (замах, шаг
* назад, вспышка) сдвигали раньше сценария на подобранные на слух
* 100 тиков.
*
* Причину убрали: отрисовка разложена по кадровым интервалам
* (pv_restore_bg), сцена идёт по единственным часам — кадрам луча, —
* и подкачка трека оплачивается интервалом (pop_music_load_step).
* После этого подгонка стала вредной: молния била больше чем на
* секунду раньше коды (проверка пользователем 2026-08-28). Константу
* оставляем на месте — если запись другого набора (mt32/ogg) снова
* разъедется, крутить надо её, а не тайминги сценария. */
/* ЯКОРЯ ШКАЛЫ. Четыре точки, от которых отсчитывается всё остальное;
* считаются ОДИН РАЗ при входе в сцену из длительностей набора
* (pop_music_info). Держать их статикой, а не тащить структуру времён
* через пять функций: восемь байт против переделки всех сигнатур, а
* сцена всё равно одна на запуск.
*
* Нет индекса или трека — длительность нулевая, и сцена просто проходит
* без пауз на реплики: ждать нечего, звука-то нет. */
static uint16_t pv_m50_end; /* конец «принцесса ждёт» (m50) */
static uint16_t pv_dialog1; /* Джафар входит — начало реплики m53 */
static uint16_t pv_exit; /* конец m53: Джафар уходит */
static uint16_t pv_anim_end; /* конец всей сцены */
/* Ниже — те же выражения, что были в enum: биты сценария отсчитываются от
* своего якоря и от записи НЕ зависят. */
#define PV_M50_END pv_m50_end
#define PV_WAIT_END ((uint16_t)(pv_m50_end + 40))
#define PV_GATE_END ((uint16_t)(pv_m50_end + 88))
#define PV_DOOR_END ((uint16_t)(pv_m50_end + 112))
#define PV_TURN_START PV_DOOR_END
#define PV_WALK1_START ((uint16_t)(pv_m50_end + 152))
#define PV_DIALOG1_START pv_dialog1
#define PV_MUS_4_LOAD ((uint16_t)(pv_dialog1 + 54))
#define PV_WALK2_START ((uint16_t)(pv_dialog1 + 176))
#define PV_DIALOG2_START ((uint16_t)(pv_dialog1 + 416))
#define PV_RAISE_START ((uint16_t)(pv_dialog1 + 696 - PV_MAGIC_LEAD))
#define PV_STEPBACK_START ((uint16_t)(pv_dialog1 + 703 - PV_MAGIC_LEAD))
#define PV_MAGIC_START ((uint16_t)(pv_dialog1 + 822 - PV_MAGIC_LEAD))
#define PV_EXIT_START pv_exit
#define PV_MUS_4_START ((uint16_t)(pv_exit + 42))
#define PV_GLASS_DONE ((uint16_t)(pv_exit + 210))
#define PV_SLUMP_START ((uint16_t)(pv_exit + 273))
#define PV_ANIM_TICKS pv_anim_end
/* Собрать шкалу под НАШ набор записей. 200 — цепочка битов сценария от
* конца m50 до входа Джафара (40+48+24+40+48), 469 — хвост после его
* ухода; оба от записи не зависят. */
static void pv_timing_init(void)
{
pop_mus_info_t m50, m53;
(void)pop_music_info(POP_MUS_STORY_2, &m50);
(void)pop_music_info(POP_MUS_STORY_3, &m53);
pv_m50_end = (uint16_t)(PV_MUS_2_START + m50.ticks);
pv_dialog1 = (uint16_t)(pv_m50_end + 200);
pv_exit = (uint16_t)(pv_dialog1 + m53.ticks);
pv_anim_end = (uint16_t)(pv_exit + 469);
}
/* Возврат долга шкалы (см. цикл сцены): сколько порций насоса отдаём за один
* кадр сцены и сколько их вообще имеет смысл копить. 1 порция — 11,7 мс;
* 128 порций — полторы секунды, дальше догонять уже нечего. */
@@ -870,6 +900,7 @@ static int intro_pv_animated(void)
jaffar_actor.visible = 0;
jaffar_actor.step = 0;
tick = 0;
pv_timing_init(); /* шкала под длительности НАШЕГО набора */
intro_skip_begin(&skip);
while (tick < PV_ANIM_TICKS) {
if (intro_skip_requested(&skip)) {
applications/SprPoP/src/pop_kid.c
+7 -20
View File
@@ -19,7 +19,6 @@
#include "pop_geom.h"
#include "pop_level.h" /* POP_LEVEL_LAST — level 15 исключён */
#include "pop_cutscene.h" /* POP_T60 — тики оригинала в кадры луча */
#include "pop_music_ticks.h" /* длина мелодии конца уровня */
#include <fcntl.h>
#include <unistd.h>
#include <sprinter_mem.h>
@@ -38,14 +37,6 @@ int8_t knock;
* оригинале, чтобы читы «следующий/предыдущий уровень» (levels_plan.md §4)
* легли сюда же без переделки. */
uint8_t pop_next_level;
/* СКОЛЬКО ЛОГИЧЕСКИХ КАДРОВ ЕЩЁ ДЕРЖАТЬ УРОВЕНЬ, пока играет мелодия конца.
* У оригинала (seg003:387, play_level_2) уровень не сменяется, пока
* `check_sound_playing()`: экран пройденного уровня живёт с анимацией
* факелов ровно столько, сколько звучит трек. У нас признак «звучит» —
* pop_music_busy(), но он ложен при ВЫКЛЮЧЕННОЙ музыке, а оригинал
* выдерживает паузу и молча. Поэтому здесь взводится счётчик по длине
* записи (gen/pop_music_ticks.h), а главный цикл ждёт большего из двух. */
uint8_t pop_endmus_left;
/* ---- Атласы Kid (прямая адресация image>>3) ------------------------ *
@@ -367,17 +358,13 @@ void play_seq(void)
else if (ev == 4) {
/* seg006:646. На четвёртом уровне уход за дверь — это
* встреча с тенью, и трек там свой; на 13-м (Джафар) и
* 15-м оригинал молчит. Вместе с треком взводим
* задержку смены уровня (см. pop_endmus_left): кадров
* = длина записи в тиках -> кадры луча -> делённое на
* длину логического кадра (4 кадра луча вне боя). */
if (pop_current_level == 4) {
pop_sfx_play(32);
pop_endmus_left = (uint8_t)(POP_T60(POP_MUS_TICKS_32) / 4);
} else if (pop_current_level != 13) {
pop_sfx_play(41);
pop_endmus_left = (uint8_t)(POP_T60(POP_MUS_TICKS_41) / 4);
}
* 15-м оригинал молчит. Держать уровень на экране,
* пока трек звучит, — забота главного цикла: он ждёт
* pop_music_active(), и своей задержки здесь больше
* нет (была по длине записи из gen/pop_music_ticks.h,
* из-за чего EXE зависел от набора музыки). */
if (pop_current_level == 4) pop_sfx_play(32);
else if (pop_current_level != 13) pop_sfx_play(41);
}
}
break;
applications/SprPoP/src/pop_kid.h
-1
View File
@@ -32,7 +32,6 @@ extern int8_t knock;
* там рестарт того же уровня; загрузка следующего — levels_plan.md. */
extern uint8_t pop_next_level;
/* Задержка смены уровня на время мелодии конца (см. pop_kid.c). */
extern uint8_t pop_endmus_left;
/* Загрузить npages атласов Kid (kid0..kid{npages-1}.atl). ДО initgraph.
* 0 — OK, -1 — ошибка. */
applications/SprPoP/src/pop_music.c
+110 -8
View File
@@ -13,14 +13,81 @@
#include <fcntl.h>
#include <unistd.h>
#include <sprinter_mem.h>
#include <string.h>
#include <sprite.h> /* gfx_w0_map/unmap — доступ к странице индекса */
#include "pop_music.h"
#include "pop_music_tbl.h"
#include "pop_sfx.h"
#include "pop_app.h" /* POP_APP_DEMO — в демке музыки нет */
#include "_pop_file.h"
uint8_t pop_mus_page[POP_MUS_PAGES];
/* --- ИНДЕКС НАБОРА ---------------------------------------------------- *
*
* Страница EMM с прочитанным mus.idx; 0 — индекса нет. В W2 от него
* остаются ровно эти два байта, сама таблица (228 Б) лежит в странице.
*
* Данные лежат со смещения POP_MUS_IDX_BASE, а не с начала страницы:
* gfx_w0_page_prepare пишет туда стабы прерываний (0x38 и 0x66), и с
* нуля они попали бы прямо в записи. Со смещением всё расходится, и
* страница подключается штатно — без запрета прерываний. */
static uint8_t mus_idx_blk;
static uint8_t mus_idx_page;
/* "MUS\mus.idx" — имя знает сам модуль (тот же приём, что в pop_arc.c:
* литерал лежит в rodata банка 9, и open() читает его, пока в W3 стоит
* этот банк). */
static const char mus_idx_path[] = "MUS\\mus.idx";
int8_t pop_music_index_load(void) __banked
{
uint8_t *w0 = (uint8_t *)POP_MUS_IDX_BASE;
uint8_t blk, page, ok;
int fd;
if (mus_idx_page) return 0;
POP_PATH_CALL(fd, open(mus_idx_path, O_RDONLY));
if (fd < 0) return -1;
blk = mem_alloc_pages(1);
if (!blk) { close(fd); return -1; }
page = mem_get_page(blk, 0);
if (!page ||
bank_read_page(fd, page, POP_MUS_IDX_BASE, POP_MUS_IDX_SIZE) < 0) {
close(fd);
mem_free_block(blk);
return -1;
}
close(fd);
gfx_w0_page_prepare(page); /* стабы лягут вне данных, см. BASE */
gfx_w0_map(page);
ok = (uint8_t)(memcmp(w0, "PMI1", 4) == 0 &&
w0[4] == POP_MUS_COUNT &&
w0[5] == POP_MUS_IDX_REC &&
w0[6] == 7 && /* log2(128) — блок насоса */
w0[7] == 1); /* u8 mono, CBL_FREQ_10K9 */
gfx_w0_unmap();
if (!ok) { mem_free_block(blk); return -1; }
mus_idx_blk = blk;
mus_idx_page = page;
return 0;
}
int8_t pop_music_info(uint8_t id, pop_mus_info_t *out) __banked
{
const uint8_t *rec;
const uint8_t *w0 = (const uint8_t *)POP_MUS_IDX_BASE;
out->blocks = 0;
out->ticks = 0;
if (!mus_idx_page || id >= POP_MUS_COUNT) return -1;
gfx_w0_map(mus_idx_page);
rec = w0 + POP_MUS_IDX_HDR + (uint16_t)id * POP_MUS_IDX_REC;
out->blocks = (uint16_t)(rec[0] | ((uint16_t)rec[1] << 8));
out->ticks = (uint16_t)(rec[2] | ((uint16_t)rec[3] << 8));
gfx_w0_unmap();
return out->blocks ? 0 : -1;
}
/* Два слота: играющий и подгружаемый. Своей таблицы страниц слот НЕ
* держит — её и так хранит блок EMM, и mem_get_page отдаёт номер по
* индексу. Резидентный pop_mus_page[] заполняется на pop_music_play, для
@@ -53,6 +120,9 @@ static uint8_t ld_next; /* следующая страница к
static uint8_t ld_half; /* 0 = впереди первая половина страницы */
static uint8_t ld_pages;
static uint8_t ld_id;
/* Длина трека из индекса, снятая при открытии: лезть в страницу индекса
* на каждом шаге загрузки незачем — она не меняется. */
static uint16_t ld_blocks;
static void slot_release(uint8_t n)
{
@@ -126,13 +196,17 @@ static void load_abort(void)
int8_t pop_music_load_begin(uint8_t id) __banked
{
char name[12];
pop_mus_info_t info;
uint8_t pages, n;
if (ring_on) pop_music_ring_stop(); /* потоковый трек и слоты не дружат */
if (ld_busy) load_abort();
if (id >= POP_MUS_COUNT) return -1;
pages = pop_mus_tbl[id].pages;
if (!pages || pages > POP_MUS_PAGES) return -1;
/* Длину и число страниц знает ИНДЕКС НАБОРА, а не EXE: у mt32 те же
* треки другой длины (docs/music_runtime_index_plan.md). */
if (pop_music_info(id, &info) != 0) return -1;
pages = pop_music_pages(info.blocks);
if (pages > POP_MUS_PAGES) return -1;
/* Грузим ВСЕГДА в не текущий слот: играющий трек читает свои страницы
* из прерывания, и отобрать их у него нельзя. */
@@ -152,6 +226,7 @@ int8_t pop_music_load_begin(uint8_t id) __banked
ld_half = 0;
ld_pages = pages;
ld_id = id;
ld_blocks = info.blocks;
return 0;
}
@@ -183,7 +258,7 @@ int8_t pop_music_load_step(void) __banked
close(ld_fd);
ld_busy = 0;
slot_pages[ld_slot] = ld_pages;
slot_blocks[ld_slot] = pop_mus_tbl[ld_id].blocks;
slot_blocks[ld_slot] = ld_blocks;
slot_id[ld_slot] = ld_id;
mus_ready = (uint8_t)(ld_slot + 1);
return 1;
@@ -229,7 +304,7 @@ int8_t pop_music_stream(uint8_t id) __banked
if (n != mus_cur) slot_release(mus_cur);
mus_cur = n;
slot_pages[n] = ld_pages;
slot_blocks[n] = pop_mus_tbl[id].blocks;
slot_blocks[n] = ld_blocks;
slot_id[n] = id;
pop_mus_id = id;
pop_mus_pg = 0;
@@ -283,9 +358,15 @@ void pop_music_ring_stop(void) __banked
int8_t pop_music_ring_start(uint8_t id) __banked
{
char name[12];
pop_mus_info_t info;
uint8_t i, page;
if (id >= POP_MUS_COUNT || !pop_mus_tbl[id].pages) return -1;
if (id >= POP_MUS_COUNT || pop_music_info(id, &info) != 0) return -1;
/* Потоковый трек НЕ ограничен POP_MUS_PAGES: он и не помещается в
* память целиком, ради того и кольцо. Предел здесь — восьмибитные
* счётчики страниц (у mt32 финальная тема на 82 страницы против 78
* у flac). */
if (pop_music_pages(info.blocks) > 255) return -1;
pop_music_free(); /* обычные слоты кольцу не нужны */
pop_music_ring_stop();
mus_name(name, id);
@@ -294,8 +375,8 @@ int8_t pop_music_ring_start(uint8_t id) __banked
ring_fd_open = 1;
ring_blk = mem_alloc_pages(RING_PAGES);
if (!ring_blk) { ring_close_file(); return -1; }
ring_file_pages = pop_mus_tbl[id].pages;
ring_total = pop_mus_tbl[id].blocks;
ring_file_pages = (uint8_t)pop_music_pages(info.blocks);
ring_total = info.blocks;
/* Заполняем кольцо целиком: старт с полным буфером даёт девять секунд
* форы, и первая же тяжёлая сцена финала не догонит насос. */
for (i = 0; i < RING_PAGES; i++) {
@@ -375,3 +456,24 @@ uint8_t pop_music_busy(void) __banked
{
return (uint8_t)(pop_mus_left != 0);
}
/* ТРЕК В РАБОТЕ — заявка лежит, идёт загрузка или он звучит.
*
* Одного pop_music_busy() там, где ждут КОНЦА мелодии, мало: между
* заявкой (pop_sfx_play кладёт pop_mus_req) и первым звуком проходит
* 190-230 мс — открытие файла и чтение первой полустраницы (замер и
* разбор — docs/sound_plan.md §9). В этой щели busy ещё ложен, и
* ожидание закончилось бы, не начавшись.
*
* Три признака подряд закрывают её без единой подобранной константы:
* pop_music_service обнуляет req и тут же взводит ld_busy в load_begin,
* а тот держится до самой записи pop_mus_left. Снаружи переход
* «запрошен -> грузится -> звучит» непрерывен, потому что между этими
* операторами главный цикл не выполняется.
*
* И наоборот: если трека нет или память кончилась, все три ложны сразу —
* ждать нечего, как и должно быть. */
uint8_t pop_music_active(void) __banked
{
return (uint8_t)(pop_mus_req || ld_busy || pop_mus_left);
}
applications/SprPoP/src/pop_music.h
+45
View File
@@ -28,6 +28,47 @@
* либо резать, либо стримить, и это отдельная задача. */
#define POP_MUS_PAGES 20
/* --- ИНДЕКС НАБОРА (MUS/mus.idx, формат PMI1) ------------------------- *
*
* Длины треков и длительности реплик приезжают С ДИСКА, а не из EXE: так
* набор записей (flac/mp3/ogg/mt32) меняется без перекомпиляции игры.
* Формат пишет tools/pop_idx.py, он же покрыт make test-tools.
*
* Индекс живёт в ОДНОЙ странице EMM, а не в W2: таблица на 57 записей —
* 228 байт, а свободной кучи в резиденте порядка двух сотен. Наружу
* указатель на EMM не выдаётся: pop_music_info копирует запись в буфер
* вызывающего, на короткое время подключая страницу в W0. */
#define POP_MUS_COUNT 57 /* пространство id оригинала, 0..56 */
#define POP_MUS_IDX_REC 4 /* blocks (u16) + ticks60 (u16) */
#define POP_MUS_IDX_HDR 16
#define POP_MUS_IDX_SIZE 512 /* сектор DSS */
/* Индекс кладётся в страницу СО СМЕЩЕНИЯ 0x100, а не с нуля. Причина в
* gfx_w0_page_prepare: он делает страницу безопасной в W0, записывая в
* неё переход на IRQ-восстановитель (0x38) и RETN для NMI (0x66). С
* нуля эти байты легли бы прямо в записи (id 10 и 21) и испортили
* индекс; со смещением 0x100 стабы и данные не пересекаются, и работает
* штатная защита от прерываний, а не запрет их. Тот же приём и по той
* же причине — в pop_config.c (CFG_BASE). */
#define POP_MUS_IDX_BASE 0x100
typedef struct {
uint16_t blocks; /* длина трека в порциях насоса по 128 байт */
uint16_t ticks; /* та же длина в тиках сцены (60 Гц оригинала) */
} pop_mus_info_t;
/* Поднять индекс (один раз за запуск). 0 — ок, -1 — нет файла либо он
* не той версии; во втором случае музыки не будет, но игра работает. */
int8_t pop_music_index_load(void) __banked;
/* Запись трека в буфер вызывающего. -1 — индекса нет, id вне диапазона
* или трека нет в наборе (тогда поля нулевые). */
int8_t pop_music_info(uint8_t id, pop_mus_info_t *out) __banked;
/* Сколько EMM-страниц занимает трек такой длины. Считается, а НЕ хранится
* в индексе: дублирование однажды разъедется с blocks. */
#define pop_music_pages(blocks) \
(uint16_t)(((blocks) >> 7) + (((blocks) & 127) != 0))
/* Номера треков — нумерация оригинала (SDLPoP data/music/names.txt). */
#define POP_MUS_INTRO 54 /* тема заставки, звучит на титрах */
#define POP_MUS_STORY_1 55 /* «In the absence of the Sultan...» */
@@ -102,4 +143,8 @@ void pop_music_ring_stop(void) __banked;
/* Трек ещё звучит? 0 — доиграл или не запускался. */
uint8_t pop_music_busy(void) __banked;
/* «Трек в работе»: заявка/загрузка/звучание. Для мест, где ждут КОНЦА
* мелодии, — busy там ложен в окне запуска (см. pop_music.c). */
uint8_t pop_music_active(void) __banked;
#endif /* POP_MUSIC_H */
applications/SprPoP/src/sprpop.c
+16 -9
View File
@@ -366,7 +366,6 @@ int main(void)
* девелоперская сборка может до title держать дворец LEVEL=11. */
if (pop_app_state == POP_APP_DEMO) {
pop_next_level = 0;
pop_endmus_left = 0;
pop_seamless = 0;
pop_checkpoint = 0;
if (pop_level_switch() != 0) {
@@ -787,14 +786,22 @@ int main(void)
* сколько звучит трек конца уровня; мы же уходили на смену
* уровня сразу и обрывали мелодию на первых нотах.
*
* «Звучит» проверяем двумя способами: pop_music_busy() пока
* трек играет и счётчик pop_endmus_left по длине записи (его
* взводит play_seq вместе с самим треком) — иначе с
* ВЫКЛЮЧЕННОЙ музыкой паузы не было бы вовсе, а оригинал
* выдерживает её и молча. */
if (pop_endmus_left) pop_endmus_left--;
if (!pop_endmus_left && !pop_music_busy() &&
pop_level_change(back) != 0) {
* «Звучит» — это pop_music_active(), а не busy: между заявкой
* на трек и первой нотой проходит 190-230 мс на открытие
* файла и чтение первой полустраницы, и в этой щели busy ещё
* ложен (замер — docs/sound_plan.md §9). Раньше щель
* закрывал счётчик по длине записи, но он же тянул за собой
* зависимость EXE от набора музыки и жёсткий делитель `/4`,
* враньё которого вылезало в быстрых режимах (там кадр 3
* луча, а не 4). Состояние «заявка/загрузка/звучание»
* закрывает щель без единой константы.
*
* ЗВУК ВЫКЛЮЧЕН — ПАУЗЫ НЕТ, и это тоже верно: pop_sfx_play
* не кладёт заявку при !pop_snd_ok, все три признака ложны, и
* уровень меняется сразу. Ровно так в оригинале, где трек
* ставится под `if (is_sound_on)` (seg006:651), а ожидание —
* `check_sound_playing()` (seg003:387). */
if (!pop_music_active() && pop_level_change(back) != 0) {
failed = 1; quit = 1; break;
}
}
applications/SprPoP/src/sprpop_cold.c
+4
View File
@@ -1157,6 +1157,10 @@ int pop_boot(void) __banked
pop_guard_load(); /* атласы стража (GUARD\\g0..g4) */
pop_shadow_load(); /* запечённый набор Тени — один раз на запуск */
pop_sfx_init(); /* звук: 8 страниц оцифровки (вывод пока молчит) */
/* Индекс музыкального набора — одна страница EMM. Без него музыки не
* будет (pop_music_info вернёт -1 на любой трек), но игра работает:
* это необязательный ресурс, как и сами треки. */
(void)pop_music_index_load();
pop_settings_apply(1); /* CFG -> speed/cheats/CBL */
if (pop_kid_load(KID_PAGES) != 0) { /* ВСЕ страницы: бег+стоп+разворот+присед+прыжок */
puts("kid atlas load failed");