Demo Stage Plasma

/* Coded By JD(2026) */
#error "Reference listing only — not provided as build-ready source."
#include "demo_stage_plasma.h"

#include "game_graphics.h"

#include <math.h>
#include <stddef.h>
#include <stdbool.h>

// Segment 13 -- full-screen demo-scene plasma beneath Demo's normal PET ticker.
// Smaller blocks make the moving plasma surface smoother but increase the number
// of RGB565 fills per frame; keep this at least 1 pixel.
#define DEMO_STAGE_THIRTEEN_BLOCK_SIZE 2
// Each cyclic ramp must be odd: the centre entry is the full base colour, while
// both endpoints are black. More steps soften the colour changes between cells.
#define DEMO_STAGE_THIRTEEN_GRADIENT_STEPS 33U
#define DEMO_STAGE_THIRTEEN_GRADIENT_PEAK (DEMO_STAGE_THIRTEEN_GRADIENT_STEPS / 2U)
// Values below 1.0 leave black faster, thickening coloured bands while keeping
// black only at each true trough. Raise toward 1.0 for more dark space.
#define DEMO_STAGE_THIRTEEN_GRADIENT_GAMMA 0.50f
#define DEMO_STAGE_THIRTEEN_SINE_TABLE_SIZE 256U
// Each wave advances by one lookup-table position at its own interval. Lower
// values make that wave move faster; differing values stop one obvious loop.
#define DEMO_STAGE_THIRTEEN_WAVE_ONE_MS 12U
#define DEMO_STAGE_THIRTEEN_WAVE_TWO_MS 17U
#define DEMO_STAGE_THIRTEEN_WAVE_THREE_MS 22U
#define DEMO_STAGE_THIRTEEN_WAVE_FOUR_MS 28U
#define DEMO_STAGE_THIRTEEN_PI 3.14159265f

// The palettes are generated dark-to-bright-to-dark, so the four-wave sum
// produces moving highlights rather than a hard colour wrap. B cycles them.
typedef struct {
    const uint16_t *colours;
    size_t colour_count;
} demo_plasma_palette_t;

static uint16_t demo_plasma_red_colours[DEMO_STAGE_THIRTEEN_GRADIENT_STEPS];
static uint16_t demo_plasma_blue_colours[DEMO_STAGE_THIRTEEN_GRADIENT_STEPS];
static uint16_t demo_plasma_green_colours[DEMO_STAGE_THIRTEEN_GRADIENT_STEPS];

#define DEMO_PLASMA_RED_PALETTE_INDEX 0U
static const demo_plasma_palette_t demo_plasma_palettes[] = {
    { demo_plasma_red_colours, sizeof(demo_plasma_red_colours) / sizeof(demo_plasma_red_colours[0]) },
    { demo_plasma_blue_colours, sizeof(demo_plasma_blue_colours) / sizeof(demo_plasma_blue_colours[0]) },
    { demo_plasma_green_colours, sizeof(demo_plasma_green_colours) / sizeof(demo_plasma_green_colours[0]) },
};
#define DEMO_PLASMA_PALETTE_COUNT (sizeof(demo_plasma_palettes) / sizeof(demo_plasma_palettes[0]))

static int8_t stage_thirteen_sine_table[DEMO_STAGE_THIRTEEN_SINE_TABLE_SIZE];
static bool stage_thirteen_sine_table_ready;
static bool stage_thirteen_palettes_ready;
static size_t plasma_palette_index;
static uint32_t stage_thirteen_effect_elapsed_ms;

static void buildStageThirteenSineTable(void)
{
    if (stage_thirteen_sine_table_ready) return;
    for (unsigned index = 0U; index < DEMO_STAGE_THIRTEEN_SINE_TABLE_SIZE; ++index) {
        const float radians = (float)index * 2.0f * DEMO_STAGE_THIRTEEN_PI /
                              (float)DEMO_STAGE_THIRTEEN_SINE_TABLE_SIZE;
        stage_thirteen_sine_table[index] = (int8_t)lroundf(sinf(radians) * 127.0f);
    }
    stage_thirteen_sine_table_ready = true;
}

static void buildStageThirteenGradient(uint16_t *colours, uint8_t red, uint8_t green,
                                       uint8_t blue)
{
    for (unsigned index = 0U; index < DEMO_STAGE_THIRTEEN_GRADIENT_STEPS; ++index) {
        const unsigned distance = index <= DEMO_STAGE_THIRTEEN_GRADIENT_PEAK ?
            index : DEMO_STAGE_THIRTEEN_GRADIENT_STEPS - 1U - index;
        const float fraction = (float)distance / (float)DEMO_STAGE_THIRTEEN_GRADIENT_PEAK;
        const unsigned intensity = (unsigned)lroundf(powf(fraction,
            DEMO_STAGE_THIRTEEN_GRADIENT_GAMMA) * 255.0f);
        colours[index] = RGB565((unsigned)red * intensity / 255U,
                                (unsigned)green * intensity / 255U,
                                (unsigned)blue * intensity / 255U);
    }
}

static void buildStageThirteenPalettes(void)
{
    if (stage_thirteen_palettes_ready) return;
    buildStageThirteenGradient(demo_plasma_red_colours, 255U, 0U, 0U);
    buildStageThirteenGradient(demo_plasma_blue_colours, 0U, 80U, 255U);
    buildStageThirteenGradient(demo_plasma_green_colours, 0U, 255U, 32U);
    stage_thirteen_palettes_ready = true;
}

void demoStagePlasmaInitialize(void)
{
    buildStageThirteenSineTable();
    buildStageThirteenPalettes();
}

void demoStagePlasmaStart(void)
{
    demoStagePlasmaInitialize();
    stage_thirteen_effect_elapsed_ms = 0U;
    plasma_palette_index = DEMO_PLASMA_RED_PALETTE_INDEX;
}

void demoStagePlasmaNextPalette(void)
{
    plasma_palette_index = (plasma_palette_index + 1U) % DEMO_PLASMA_PALETTE_COUNT;
}

void demoStagePlasmaUpdate(uint32_t elapsed_ms)
{
    stage_thirteen_effect_elapsed_ms += elapsed_ms;
}

void demoStagePlasmaDraw(uint16_t *frame)
{
    const int block_size = DEMO_STAGE_THIRTEEN_BLOCK_SIZE;
    const demo_plasma_palette_t *palette = &demo_plasma_palettes[plasma_palette_index];
    const int palette_count = (int)palette->colour_count;
    const unsigned phase_one = stage_thirteen_effect_elapsed_ms /
                               DEMO_STAGE_THIRTEEN_WAVE_ONE_MS;
    const unsigned phase_two = stage_thirteen_effect_elapsed_ms /
                               DEMO_STAGE_THIRTEEN_WAVE_TWO_MS;
    const unsigned phase_three = stage_thirteen_effect_elapsed_ms /
                                 DEMO_STAGE_THIRTEEN_WAVE_THREE_MS;
    const unsigned phase_four = stage_thirteen_effect_elapsed_ms /
                                DEMO_STAGE_THIRTEEN_WAVE_FOUR_MS;

    for (int y = 0; y < LCD_HEIGHT; y += block_size) {
        for (int x = 0; x < LCD_WIDTH; x += block_size) {
            const unsigned cell_x = (unsigned)(x / block_size);
            const unsigned cell_y = (unsigned)(y / block_size);
            const int plasma_value =
                stage_thirteen_sine_table[(cell_x * 5U + phase_one) & 255U] +
                stage_thirteen_sine_table[(cell_y * 7U + phase_two) & 255U] +
                stage_thirteen_sine_table[((cell_x + cell_y) * 4U + phase_three) & 255U] +
                stage_thirteen_sine_table[(cell_x * 3U + cell_y * 6U + phase_four) & 255U];
            // Four waves range from -508 to 508; convert that to a palette index.
            const int palette_index = (plasma_value + 508) * palette_count / 1017;
            const int visible_width = x + block_size <= LCD_WIDTH ? block_size : LCD_WIDTH - x;
            const int visible_height = y + block_size <= LCD_HEIGHT ? block_size : LCD_HEIGHT - y;
            fill_rect(frame, x, y, visible_width, visible_height,
                      palette->colours[palette_index]);
        }
    }
}