Sprinter-SDCC/applications/PoP/roomtest/pop_ui.c

/*
 * pop_ui.c — текст, палитровый fade и full-screen примитивы (FG5, банк 9).
 *
 * Шрифты извлечены из SDLPoP в FONT\FONT.ATL. Внутри map/unmap разрешены
 * лишь обращения к EMM/W0: всё, что ждёт кадр или трогает BIOS-палитру,
 * выполняется строго после unmap. Это общий контракт для menu/title/PV.
 */
#include <stdint.h>
#include <graphics.h>
#include <gfx.h>
#include <sprite.h>
#include "pop_bg.h"     /* POP_YOFF/POP_PLAYFIELD_H — граница игрового поля */
#include "pop_font.h"
#include "pop_arc.h"
#include "pop_ui.h"
#include "pop_status.h"

typedef struct {
    uint8_t base;
    uint8_t ascent;
    uint8_t space;
} pop_font_desc_t;

static const pop_font_desc_t font_desc[] = {
    { POP_FONT_SMALL_BASE, POP_FONT_SMALL_ASCENT, POP_FONT_SMALL_SPACE },
    { POP_FONT_BIG_BASE,   POP_FONT_BIG_ASCENT,   POP_FONT_BIG_SPACE }
};

static atlas_t font_at;
static uint8_t font_ready;

/* БУФЕР ПАЛИТРЫ ПО ФИКСИРОВАННОМУ АДРЕСУ 0x4000.  DSS занимает эти 256
 * байт только при загрузке программы, дальше они наши (код начинается с
 * 0x4100), и держать буфер здесь дешевле, чем класть 256 байт на стек в
 * каждом вызове — идея пользователя, 2026-08-25. */
__at (0x4000) uint8_t pop_pal_buf[256];

static uint8_t text_index(const pop_font_desc_t *font, uint8_t ch)
{
    if (ch < POP_FONT_FIRST || ch > POP_FONT_LAST) ch = '?';
    return (uint8_t)(font->base + ch - POP_FONT_FIRST);
}

int pop_ui_init(void) __banked
{
    if (font_ready) return 0;
    if (atlas_load(&font_at, "FONT\\font.atl") != 0) return -1;
    font_ready = 1;
    return 0;
}

void pop_ui_free(void) __banked
{
    if (!font_ready) return;
    atlas_free(&font_at);
    font_ready = 0;
}

uint8_t pop_ui_ready(void)
{
    return font_ready;
}

void pop_text_map(void)
{
    gfx_w0_map(font_at.page);
}

void pop_text_unmap(void)
{
    gfx_w0_unmap();
}

uint8_t pop_text_width_mapped(pop_text_font_t font, const char *s)
{
    const pop_font_desc_t *desc = &font_desc[font];
    uint8_t width = 0;

    while (*s) {
        const uint8_t *img = (const uint8_t *)atlas_image(&font_at,
                                      text_index(desc, (uint8_t)*s++));
        width = (uint8_t)(width + img[0] + desc->space);
    }
    return width ? (uint8_t)(width - desc->space) : 0;
}

void pop_text_draw_mapped(pop_text_font_t font, int x, int baseline,
                          const char *s)
{
    const pop_font_desc_t *desc = &font_desc[font];

    while (*s) {
        const uint8_t *img = (const uint8_t *)atlas_image(&font_at,
                                      text_index(desc, (uint8_t)*s++));
        /* Пробел не рисует НИ ОДНОГО пикселя: его глиф целиком 0xFF, а
         * текст всегда идёт прозрачным банком.  Блит при этом стоит те же
         * ~4,6 тыс. тактов, что и буква, поэтому в строке из полусотни
         * символов пропуск пробелов — самая дешёвая экономия, какая тут
         * есть (важно для статус-строк, они рисуются в игровом кадре).
         * У крупного пробела вдобавок высота 0: для accel это 256 строк,
         * и нулевой блит нельзя отдавать ядру даже noclip-вариантом. */
        if (img[2] && s[-1] != ' ') gfx_blit_noclip(x, baseline - desc->ascent, img);
        x += img[0] + desc->space;
    }
}

void pop_text_center_mapped(pop_text_font_t font, int center, int baseline,
                            const char *s)
{
    pop_text_draw_mapped(font, center - pop_text_width_mapped(font, s) / 2,
                         baseline, s);
}

void pop_text_right_mapped(pop_text_font_t font, int right, int baseline,
                           const char *s)
{
    pop_text_draw_mapped(font, right - pop_text_width_mapped(font, s),
                         baseline, s);
}

/* W0 свободно: snapshot кладём в зарезервированный хвост страницы шрифта.
 * 4 × 256 Б = ровно 1024 Б, [0x3C00,0x4000), и не пересекаются с атласом. */
static void snapshot_chunk(uint8_t chunk, uint8_t *buf, uint8_t store)
{
    uint16_t i;
    uint8_t *slot;

    gfx_w0_map(font_at.page);
    slot = (uint8_t *)(POP_FONT_SNAPSHOT_OFF + (uint16_t)chunk * 256u);
    for (i = 0; i < 256; i++) {
        if (store) slot[i] = buf[i];
        else       buf[i] = slot[i];
    }
    gfx_w0_unmap();
}

/* Снимок палитры целиком: дробить на мелкие порции больше не нужно —
 * причина скрежета была не в длительности BIOS-вызова, а в том, какое окно
 * он под себя забирал (см. pop_pal_buf выше). */

void pop_ui_palette_snapshot(void) __banked
{
    uint8_t chunk;

    if (!font_ready) return;
    for (chunk = 0; chunk < 4; chunk++) {
        gfx_pal_get(0, (uint8_t)(chunk << 6), 64, pop_pal_buf);
        snapshot_chunk(chunk, pop_pal_buf, 1);
    }
}

/* Из одного исходного снимка приготовить обе экранные палитры. Умножения
 * нет: шкала 1/4, 1/2, 3/4 на 8-битном значении не должна тащить делитель
 * в постоянно вызываемый (во время fade) путь. */
/* ВОСЕМЬ СТУПЕНЕЙ, а не четыре.  Fade у оригинала идёт 64 шагами по два
 * тика — 2,13 с плавного затухания; наши четыре ступени укладывались в
 * доли секунды и выглядели как моргание, а растянуть их по времени значило
 * получить четыре заметных скачка яркости.  Восемь ступеней собираются
 * пáрой сдвигов каждая (умножения на Z80 не нужно), а по времени их
 * распределяет вызывающий (pop_ui_fade_*).
 *
 * dim_step: 0 — исходная, 8 — чёрная. */
static uint8_t dim_value(uint8_t v, uint8_t step)
{
    switch (step) {
    case 1:  return (uint8_t)(v - (v >> 3));              /* 7/8 */
    case 2:  return (uint8_t)((v >> 1) + (v >> 2));       /* 3/4 */
    case 3:  return (uint8_t)((v >> 1) + (v >> 3));       /* 5/8 */
    case 4:  return (uint8_t)(v >> 1);                    /* 1/2 */
    case 5:  return (uint8_t)((v >> 2) + (v >> 3));       /* 3/8 */
    case 6:  return (uint8_t)(v >> 2);                    /* 1/4 */
    case 7:  return (uint8_t)(v >> 3);                    /* 1/8 */
    default: return 0;                                    /* 8 и выше */
    }
}

void pop_ui_palette_dim(uint8_t dim_step, uint8_t keep_ui) __banked
{
    uint8_t chunk, i, start;
    uint8_t *buf = pop_pal_buf;

    if (!font_ready) return;
    if (dim_step > POP_PAL_DIM_BLACK) dim_step = POP_PAL_DIM_BLACK;
    for (chunk = 0; chunk < 4; chunk++) {
        start = (uint8_t)(chunk << 6);
        snapshot_chunk(chunk, buf, 0);
        if (dim_step) {
            for (i = 0; i < 64; i++) {
                uint8_t idx = (uint8_t)(start + i);
                uint16_t p = (uint16_t)i * 4u;
                if (keep_ui && idx >= 0x37 && idx <= 0x3F) continue;
                buf[p]     = dim_value(buf[p], dim_step);
                buf[p + 1] = dim_value(buf[p + 1], dim_step);
                buf[p + 2] = dim_value(buf[p + 2], dim_step);
            }
        }
        gfx_pal_load(0, start, 64, buf);
        gfx_pal_load(1, start, 64, buf);
    }
}

void pop_ui_palette_restore(void) __banked
{
    pop_ui_palette_dim(0, 0);
}

void pop_ui_palette_black(void) __banked
{
    uint8_t chunk;
    uint16_t i;
    uint8_t *black = pop_pal_buf;

    /* BIOS принимает максимум 64 записи за вызов; одним буфером покрываем
     * все четыре четверти палитры, не занимая постоянную память. */
    for (i = 0; i < sizeof(black); i++) black[i] = 0;
    for (chunk = 0; chunk < 4; chunk++) {
        uint8_t start = (uint8_t)(chunk << 6);
        gfx_pal_load(0, start, 64, black);
        gfx_pal_load(1, start, 64, black);
    }
}

void pop_ui_fade_out(uint8_t steps) __banked
{
    uint8_t i;
    if (!steps) return;
    pop_ui_palette_snapshot();
    for (i = 1; i <= steps; i++) {
        uint8_t step = (uint8_t)((uint16_t)i * POP_PAL_DIM_BLACK / steps);
        pop_ui_palette_dim(step, 0);
        gfx_wait_vsync();
    }
}

void pop_ui_fade_in(uint8_t steps) __banked
{
    uint8_t i;
    if (!steps) { pop_ui_palette_restore(); return; }
    for (i = steps; i > 0; i--) {
        uint8_t step = (uint8_t)((uint16_t)(i - 1) * POP_PAL_DIM_BLACK / steps);
        pop_ui_palette_dim(step, 0);
        gfx_wait_vsync();
    }
}

uint8_t pop_screen_begin(void) __banked
{
    uint8_t page = (uint8_t)(gfx_get_visible_page() ^ 1);
    gfx_set_draw_page(page);
    gfx_set_bank(GFX_BANK_NORMAL);
    return page;
}

void pop_screen_fill(uint8_t color) __banked
{
    setfillstyle(SOLID_FILL, color);
    bar(0, 0, GFX_WIDTH - 1, GFX_HEIGHT - 1);
}

/* Экран под ИГРУ: вне поля — цвет POP_COL_OUTSIDE, внутри — цвет 0.
 *
 * Зачем два разных чёрных.  Вспышки (молния Джафара, урон, зелья) сделаны
 * подменой ЦВЕТА 0 всей палитры — как в оригинале.  Пока борта и полоса HP
 * тоже были нулём, мигал весь экран целиком, вместе с рамкой и жизнями.
 * Красим всё, что вне поля 320x192, отдельным индексом, а в палитре держим
 * его чёрным (pop_pal_outside_apply): картинка та же, но вспышка достаёт
 * только игровую область.  Идея пользователя, 2026-08-25.
 *
 * Индексы 1..15 у нас свободны: атласы кладут либо 0xFF (прозрачность),
 * либо PAL_BASE+v (0x40 и выше), шрифт — 0x3F. */
void pop_screen_fill_game(void) __banked
{
    setfillstyle(SOLID_FILL, POP_COL_OUTSIDE);
    bar(0, 0, GFX_WIDTH - 1, GFX_HEIGHT - 1);
    setfillstyle(SOLID_FILL, BLACK);
    bar(0, POP_YOFF, GFX_WIDTH - 1, POP_CLIP_BOTTOM - 1);
    /* Заливка съела и обе служебные полосы — они ВНЕ игрового поля.
     * Инвалидируем здесь, а не у вызывающих: точек заливки несколько
     * (старт игры, смена уровня), и пропустить одну из них — ровно тот
     * баг, из-за которого строка исчезала при переходе между комнатами. */
    pop_status_invalidate();
}

/* Только ИГРОВОЕ ПОЛЕ, без бортов.  Вход в комнату перерисовывает лишь
 * его: борта от комнаты к комнате не меняются, а всё, что на них живёт —
 * полоса HP, статус-строка, отладочная строка — обязано вход пережить.
 * Заодно это на четверть меньше заливки (192 строки вместо 256). */
void pop_screen_fill_field(void) __banked
{
    setfillstyle(SOLID_FILL, BLACK);
    bar(0, POP_YOFF, GFX_WIDTH - 1, POP_CLIP_BOTTOM - 1);
}

void pop_screen_present(uint8_t page) __banked
{
    gfx_wait_vsync();
    gfx_set_visible_page(page);
}

/* Нарисовать одну полосу и отпустить её страницу.  Общая часть обоих
 * загрузчиков ниже: они отличаются только тем, откуда взялся атлас. */
static int strip_blit(atlas_t *at, int x, int *y)
{
    const uint8_t *img;

    gfx_w0_map(at->page);
    img = (const uint8_t *)atlas_image(at, 0);
    /* gfx_blit_noclip ограничен шириной uint8 и обрезает 320px. */
    gfx_blit(x, *y, img);
    *y += img[2];
    gfx_w0_unmap();
    atlas_free(at);
    return 0;
}

/* Полноэкранные изображения не помещаются одним getimage в EMM-страницу.
 * Общий загрузчик полос держит лишь одну страницу и не трогает page flip:
 * caller уже собрал скрытую страницу и сам решает, когда её показать. */
int pop_screen_blit_atlas_strips(const char * const *parts,
                                 uint8_t count, int x, int y) __banked
{
    uint8_t part;

    gfx_set_bank(GFX_BANK_NORMAL);
    for (part = 0; part < count; part++) {
        atlas_t at;

        if (atlas_load(&at, parts[part]) != 0) return -1;
        strip_blit(&at, x, &y);
    }
    return 0;
}

/* То же самое, но полосы лежат подряд в АРХИВЕ (заставка, story, PV): один
 * `open` на весь экран вместо пяти — при цене открытия 51,4 мс против
 * 32,6 мс на чтение это больше половины времени показа. */
int pop_screen_blit_atlas_arc(pop_arc_t *arc, const uint8_t *tbl,
                              uint8_t base, uint8_t count,
                              int x, int y) __banked
{
    uint8_t part;

    gfx_set_bank(GFX_BANK_NORMAL);
    for (part = 0; part < count; part++) {
        atlas_t at;

        if (pop_arc_atlas(arc, tbl, (uint8_t)(base + part), &at) != 0)
            return -1;
        strip_blit(&at, x, &y);
    }
    return 0;
}