extend splash, add high-score screens, but not yet functional.

src/game.c

     obj_add(SPR_SHOT_LIGHT, 32, 32, 0, 0);
     obj_add(SPR_SHOT_DARK, -32, -32, 0, 0);
 
-    win_game_load();
     win_game_draw(score);
     move_win(MINWNDPOSX + 0, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
     SHOW_WIN;

src/main.c

 #include "sound.h"
 #include "input.h"
 #include "game.h"
+#include "score.h"
+
+static void highscore(uint8_t is_black) {
+    hide_sprites_range(SPR_NUM_START, MAX_HARDWARE_SPRITES);
+    win_score_clear();
+
+    for (uint8_t i = 0; i < SCORE_NUM; i++) {
+        int32_t score = is_black ? -score_lowest(i) : score_highest(i);
+        win_score_draw(score, i, is_black);
+    }
+
+    move_win(MINWNDPOSX + 0, MINWNDPOSY);
+
+    while (1) {
+        key_read();
+
+        if (key_pressed(J_A) || key_pressed(J_B)) {
+            break;
+        }
+
+        vsync();
+    }
+}
+
+static void splash_win(void) {
+    // initially show the top 1 scores
+    int32_t low = score_lowest(0);
+    int32_t high = score_highest(0);
+
+    // only show on splash if they fit
+    if ((low >= -99999) && (high <= 99999)) {
+        win_splash_draw(-low, high);
+    }
+
+    move_win(MINWNDPOSX + 0, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
+    SHOW_WIN;
+}
 
 static void splash(void) {
     disable_interrupts();
     obj_add(SPR_LIGHT, 42, -42, 0, 0);
     obj_add(SPR_DARK, -42, -42, 0, 0);
 
-    while(1) {
+    splash_win();
+
+    while (1) {
         key_read();
-        if (key_down(0xFF)) {
+
+        if (key_pressed(J_LEFT)) {
+            highscore(1);
+            splash_win();
+        } else if (key_pressed(J_RIGHT)) {
+            highscore(0);
+            splash_win();
+        } else if (key_pressed(0xFF)) {
             break;
         }
 
 void main(void) {
     spr_init();
     snd_init();
+    win_init();
 
-#ifndef DEBUG
     splash();
-#endif // DEBUG
 
     uint16_t seed = DIV_REG;
     waitpadup();
 
     while (1) {
         int32_t score = game();
-        // TODO
+        score_add(score);
+        splash();
     }
 }

src/maps.c

 
 #include "maps.h"
 
+#include "gb/gb.h"
 #include "title_map.h"
 #include "bg_map.h"
 #include "numbers.h"
     0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
     0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
 };
+
 const palette_color_t num_pal_inv[4] = {
   //RGB8(  0,  0,  0), RGB8(248,252,248), RGB8(  0,  0,  0), RGB8(  0,  0,  0)
     RGB8(  0,  0,  0), RGB8(  0,  0,  0), RGB8(248,252,248), RGB8(  0,  0,  0)
     set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
 }
 
-inline void set_win_based(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const uint8_t *tiles, uint8_t base_tile, const uint8_t *attributes)
-{
+void win_init(void) {
+    set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT, numbers_PALETTE_COUNT, numbers_palettes);
+    set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + 1, numbers_PALETTE_COUNT, num_pal_inv);
+    set_win_data(bg_map_TILE_COUNT, numbers_TILE_COUNT, numbers_tiles);
+}
+
+static void set_win_based(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
+                          const uint8_t *tiles, uint8_t base_tile, const uint8_t *attributes) {
     VBK_REG = VBK_ATTRIBUTES;
     set_win_tiles(x, y, w, h, attributes);
     VBK_REG = VBK_TILES;
     set_win_based_tiles(x, y, w, h, tiles, base_tile);
 }
 
-static void digit(uint8_t val, uint8_t digit, uint8_t x_off, uint8_t is_black) {
+static void digit(uint8_t val, uint8_t digit, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
     uint8_t off = val * numbers_WIDTH / numbers_TILE_W;
 
-    set_win_based(x_off + (digit * numbers_WIDTH / numbers_TILE_W), 0,
+    set_win_based(x_off + (digit * numbers_WIDTH / numbers_TILE_W), y_off,
                   numbers_WIDTH / numbers_TILE_W, 1,
                   numbers_map + off, bg_map_TILE_COUNT,
                   (is_black ? num_attr_2 : num_attr_1) + off);
 
-    set_win_based(x_off + (digit * numbers_WIDTH / numbers_TILE_W), 1,
+    set_win_based(x_off + (digit * numbers_WIDTH / numbers_TILE_W), y_off + 1,
                   numbers_WIDTH / numbers_TILE_W, 1,
                   numbers_map + off + (sizeof(numbers_map) / 2), bg_map_TILE_COUNT,
                   (is_black ? num_attr_2 : num_attr_1) + off);
 }
 
-
-void win_game_load(void) {
-    set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT, numbers_PALETTE_COUNT, numbers_palettes);
-    set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + 1, numbers_PALETTE_COUNT, num_pal_inv);
-    set_win_data(bg_map_TILE_COUNT, numbers_TILE_COUNT, numbers_tiles);
-}
-
-void win_game_draw(int32_t score) {
+static void number(int32_t score, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
     // TODO can not set numbers larger than int16 max?!
     //score = 32767 + 1; // wtf?!
 
-    uint8_t is_black = 0;
-    if (score < 0) {
-        score = -score;
-        is_black = 1;
-    }
-
     uint8_t len = 0;
     uint8_t digits[MAX_DIGITS];
     do {
         return;
     }
 
+    uint8_t off = (x_off == 0xFF) ? (10 - len) : ((x_off == 0xFE) ? (20 - (len * 2)) : x_off);
     for (uint8_t i = 0; i < len; i++) {
-        digit(digits[len - i - 1], i, 10 - len, is_black);
+        digit(digits[len - i - 1], i, off, y_off, is_black);
+    }
+}
+
+static void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) {
+    VBK_REG = VBK_ATTRIBUTES;
+    fill_win_rect(x, y, w, h, attr);
+    VBK_REG = VBK_TILES;
+    fill_win_rect(x, y, w, h, tile);
+}
+
+void win_splash_draw(int32_t lowest, int32_t highest) {
+    // reuse full black and white tiles at 0 and 1 from splash bg
+    fill_win(0, 0, 10, 2, 0, 0x00);
+    fill_win(10, 0, 10, 2, 1, 0x00);
+
+    number(lowest, 0, 0, 1);
+    number(highest, 0xFE, 0, 0);
+}
+
+void win_score_clear(void) {
+    set_win_based(0, 0,
+                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
+                  title_map_map, 0, title_map_MAP_ATTRIBUTES);
+}
+
+void win_score_draw(int32_t score, uint8_t off, uint8_t is_black) {
+    number(off, 1, 4 + off * 3, is_black);
+    number(score, 5, 4 + off * 3, is_black);
+}
+
+void win_game_draw(int32_t score) {
+    fill_win(0, 0, 20, 2, bg_map_TILE_COUNT + numbers_TILE_COUNT, 0x81);
+
+    uint8_t is_black = 0;
+    if (score < 0) {
+        score = -score;
+        is_black = 1;
     }
+
+    number(score, 0xFF, 0, is_black);
 }

src/maps.h

 
 void map_title(void);
 void map_game(void);
-void win_game_load(void);
+
+void win_init(void);
+void win_splash_draw(int32_t lowest, int32_t highest);
+void win_score_clear(void);
+void win_score_draw(int32_t score, uint8_t off, uint8_t is_black);
 void win_game_draw(int32_t score);
 
 #endif // __MAPS_H__

src/score.c

+/*
+ * score.c
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include "score.h"
+
+void score_add(int32_t score) {
+
+}
+
+int32_t score_highest(uint8_t off) {
+    return 8888 - off;
+}
+
+int32_t score_lowest(uint8_t off) {
+    return -(9999 - off);
+}

src/score.h

+/*
+ * score.h
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SCORE_H__
+#define __SCORE_H__
+
+#include <stdint.h>
+
+#define SCORE_NUM 5
+
+void score_add(int32_t score);
+int32_t score_highest(uint8_t off);
+int32_t score_lowest(uint8_t off);
+
+#endif // __SCORE_H__