add second configurable game background map, refactor text handling functions.

src/config.ba0.c

@@ -55,6 +55,13 @@ void conf_init(void) BANKED {
         mem.config.debug_flags = 0;
         mem.config.sfx_vol = 0x03;
         mem.config.music_vol = 0x07;
+
+        if (_cpu == CGB_TYPE) {
+            mem.config.game_bg = 0;
+        } else {
+            mem.config.game_bg = 1;
+        }
+
         score_reset();
     }
 }

src/config.h

@@ -44,6 +44,7 @@ struct config {
     enum debug_flag debug_flags;
     uint8_t sfx_vol;
     uint8_t music_vol;
+    uint8_t game_bg;
 };
 
 void conf_init(void) BANKED;

src/game.c

@@ -424,7 +424,8 @@ int32_t game(enum GAME_MODE mode) NONBANKED {
 
     disable_interrupts();
     DISPLAY_OFF;
-    map_game();
+    map_load(0);
+    map_fill(MAP_GAME_1 + conf_get()->game_bg, 1);
     SHOW_BKG;
     spr_init_pal();
     SHOW_SPRITES;
@@ -445,7 +446,6 @@ int32_t game(enum GAME_MODE mode) NONBANKED {
         }
     }
 
-    win_init(0);
     uint8_t x_off = win_game_draw(score);
     move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
 

src/gbprinter.c

@@ -34,7 +34,7 @@ BANKREF(gbprinter)
 #define PRN_TILE_WIDTH     20 // Width of the printed image in tiles
 #define PRN_MAGIC          0x3388
 #define PRN_MAGIC_DETECT   0x81 // magic reply from printer
-#define PRN_DETECT_TIMEOUT 10 // 1/6th second
+#define PRN_DETECT_TIMEOUT 20 // 1/3rd second
 #define PRN_BUSY_TIMEOUT   (2 * 60) // 2s
 #define PRN_PRINT_TIMEOUT  (20 * 60) // 20s
 
@@ -125,21 +125,34 @@ static uint8_t printer_check_cancel(void) {
 }
 
 static enum PRN_STATUS printer_wait(uint16_t timeout, uint8_t mask, uint8_t value) {
-    enum PRN_STATUS error;
+    enum PRN_STATUS error = PRN_STATUS_OK;
 
     while (1) {
+#ifdef DEBUG
+        error = (error & 0xF000) | printer_send_command(PRN_CMD_STATUS, NULL, 0);
+#else
         error = printer_send_command(PRN_CMD_STATUS, NULL, 0);
+#endif // DEBUG
         if ((error & mask) == value) {
             break;
         }
 
+#ifdef DEBUG
+        EMU_printf("%s: 0x%04x\n",  __func__, (uint16_t)error);
+
+        uint8_t n = (error & 0xF000) >> 12;
+        n = (n + 1) & 0x000F;
+        error = (error & 0x0FFF) | (n << 12);
+#endif // DEBUG
+
         if (printer_check_cancel()) {
             printer_send_command(PRN_CMD_BREAK, NULL, 0);
-            return PRN_STATUS_CANCELLED;
+            error |= PRN_STATUS_CANCELLED;
         }
 
-        if (timeout-- == 0) {
-            return PRN_STATUS_TIMEOUT;
+        timeout--;
+        if (timeout == 0) {
+            error |= PRN_STATUS_TIMEOUT;
         }
 
         if (error & PRN_STATUS_MASK_ERRORS) {

src/gbprinter.h

@@ -56,7 +56,7 @@ enum PRN_STATUS {
 enum PRN_STATUS gbprinter_detect(void) BANKED;
 enum PRN_STATUS gbprinter_screenshot(uint8_t win, uint8_t palette) BANKED;
 
-uint8_t gbprinter_error(enum PRN_STATUS status, char *buff);
+uint8_t gbprinter_error(enum PRN_STATUS status, char *buff) BANKED;
 
 BANKREF_EXTERN(gbprinter)
 BANKREF_EXTERN(gbprinter_error)

src/gbprinter_error.c

@@ -49,23 +49,21 @@ static const char * const error_strings[ERROR_BITS] = {
     str_cancel, str_timeout, str_magic,
 };
 
-uint8_t gbprinter_error(enum PRN_STATUS status, char *buff) NONBANKED {
+uint8_t gbprinter_error(enum PRN_STATUS status, char *buff) BANKED {
     if (status == PRN_STATUS_OK) {
         sprintf(buff, "ok");
         return 2;
     }
 
     uint8_t n = 0;
-    START_ROM_BANK(BANK(gbprinter_error)) {
-        for (uint8_t i = 0; i < ERROR_BITS; i++) {
-            if (status & (1 << i)) {
-                if (n != 0) {
-                    buff[n++] = '\n';
-                }
-                strcpy(buff + n, error_strings[i]);
-                n += strlen(error_strings[i]);
+    for (uint8_t i = 0; i < ERROR_BITS; i++) {
+        if (status & (1 << i)) {
+            if (n != 0) {
+                buff[n++] = '\n';
             }
+            strcpy(buff + n, error_strings[i]);
+            n += strlen(error_strings[i]);
         }
-    } END_ROM_BANK
+    }
     return n;
 }

src/main.c

@@ -53,6 +53,7 @@ BANKREF(main)
 const struct conf_entry conf_entries[CONF_ENTRY_COUNT] = {
     //{ .name = "sfx-vol",  .var = &mem.config.sfx_vol,   .max = 3 },
     { .name = "musi-vol", .var = &mem.config.music_vol, .max = 15 },
+    { .name = "game-map", .var = &mem.config.game_bg,   .max = 1 },
 };
 
 const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT] = {
@@ -303,7 +304,8 @@ static void splash(void) NONBANKED {
 
     disable_interrupts();
     DISPLAY_OFF;
-    map_title();
+    map_load(1);
+    map_fill(MAP_TITLE, 1);
     SHOW_BKG;
     spr_init_pal();
     SHOW_SPRITES;
@@ -316,7 +318,6 @@ static void splash(void) NONBANKED {
     obj_add(SPR_LIGHT, 42, -42, 0, 0);
     obj_add(SPR_DARK, -42, -42, 0, 0);
 
-    win_init(1);
     splash_win();
 
     DISPLAY_ON;
@@ -492,7 +493,8 @@ static uint16_t ask_name(int32_t score) NONBANKED {
 
     disable_interrupts();
     DISPLAY_OFF;
-    map_title();
+    map_load(1);
+    map_fill(MAP_TITLE, 0);
     SHOW_BKG;
     spr_init_pal();
     SHOW_SPRITES;
@@ -500,7 +502,6 @@ static uint16_t ask_name(int32_t score) NONBANKED {
 
     hide_sprites_range(SPR_NUM_START, MAX_HARDWARE_SPRITES);
 
-    win_init(1);
     win_name(score);
 
     move_win(MINWNDPOSX, MINWNDPOSY);

src/main.h

@@ -39,7 +39,7 @@ struct debug_entry {
 
 BANKREF_EXTERN(main)
 
-#define CONF_ENTRY_COUNT 1
+#define CONF_ENTRY_COUNT 2
 extern const struct conf_entry conf_entries[CONF_ENTRY_COUNT];
 
 extern uint8_t debug_menu_index;

src/map_data.c

@@ -0,0 +1,179 @@
+/*
+ * map_data.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 <assert.h>
+
+#include "map_data.h"
+
+#include "title_map.h"
+#include "bg_map.h"
+#include "bg2_map.h"
+#include "numbers_fnt16.h"
+#include "text_fnt16.h"
+#include "vincent_fnt8.h"
+
+BANKREF(map_data)
+
+/*
+ * BCP0: Title map
+ * BCP1: Game map 1
+ * BCP2: Game map 2
+ * BCP3: Text Font 16
+ * BCP4: Text Font 16 inverted
+ * BCP5: Num Font 16 (same as 3)
+ * BCP6: Font Ascii 8
+ * BCP7: (unused)
+ *
+ * Explosion uses OCP0 to OCP3 at end of game.
+ * Pause is flipped in-place for animating the pause screen colors.
+ */
+
+const palette_color_t num_pal_inv[INV_PALETTE_COUNT * 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)
+};
+
+// currently this assumption is hard-coded
+static_assert(bg_map_WIDTH == 256, "bg_map needs to be 256x256");
+static_assert(bg_map_HEIGHT == 256, "bg_map needs to be 256x256");
+static_assert(bg2_map_WIDTH == 256, "bg2_map needs to be 256x256");
+static_assert(bg2_map_HEIGHT == 256, "bg2_map needs to be 256x256");
+
+struct maps maps[MAP_COUNT] = {
+    { // MAP_TITLE
+        .width = title_map_WIDTH / title_map_TILE_W,
+        .height = title_map_HEIGHT / title_map_TILE_H,
+        .map = title_map_map,
+        .tiles = title_map_tiles,
+        .palettes = title_map_palettes,
+        .palette_count = title_map_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL0,
+        .map_count = sizeof(title_map_map),
+        .tile_count = title_map_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = BG_COPY_NONE,
+        .bank = BANK(title_map),
+        .load = BG_LOAD_SPLASH,
+    },
+    { // MAP_GAME_1
+        .width = bg_map_WIDTH / bg_map_TILE_W,
+        .height = bg_map_HEIGHT / bg_map_TILE_H,
+        .map = bg_map_map,
+        .tiles = bg_map_tiles,
+        .palettes = bg_map_palettes,
+        .palette_count = bg_map_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL1,
+        .map_count = sizeof(bg_map_map),
+        .tile_count = bg_map_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = BG_COPY_NONE,
+        .bank = BANK(bg_map),
+        .load = BG_LOAD_GAME,
+    },
+    { // MAP_GAME_2
+        .width = bg2_map_WIDTH / bg2_map_TILE_W,
+        .height = bg2_map_HEIGHT / bg2_map_TILE_H,
+        .map = bg2_map_map,
+        .tiles = bg2_map_tiles,
+        .palettes = bg2_map_palettes,
+        .palette_count = bg2_map_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL2,
+        .map_count = sizeof(bg2_map_map),
+        .tile_count = bg2_map_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = BG_COPY_NONE,
+        .bank = BANK(bg2_map),
+        .load = BG_LOAD_GAME,
+    },
+    { // FNT_TEXT_16
+        .width = text_fnt16_WIDTH / text_fnt16_TILE_W,
+        .height = text_fnt16_HEIGHT / text_fnt16_TILE_H,
+        .map = text_fnt16_map,
+        .tiles = text_fnt16_tiles,
+        .palettes = text_fnt16_palettes,
+        .palette_count = text_fnt16_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL3,
+        .map_count = sizeof(text_fnt16_map),
+        .tile_count = text_fnt16_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = BG_COPY_NONE,
+        .bank = BANK(text_fnt16),
+        .load = BG_LOAD_SPLASH,
+    },
+    { // FNT_TEXT_16_INV
+        .width = text_fnt16_WIDTH / text_fnt16_TILE_W,
+        .height = text_fnt16_HEIGHT / text_fnt16_TILE_H,
+        .map = text_fnt16_map,
+        .tiles = text_fnt16_tiles,
+        .palettes = num_pal_inv,
+        .palette_count = INV_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL4,
+        .map_count = sizeof(text_fnt16_map),
+        .tile_count = text_fnt16_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = FNT_TEXT_16,
+        .bank = BANK(text_fnt16),
+        .load = BG_LOAD_SPLASH,
+    },
+    { // FNT_NUM_16
+        .width = numbers_fnt16_WIDTH / numbers_fnt16_TILE_W,
+        .height = numbers_fnt16_HEIGHT / numbers_fnt16_TILE_H,
+        .map = numbers_fnt16_map,
+        .tiles = numbers_fnt16_tiles,
+        .palettes = numbers_fnt16_palettes,
+        .palette_count = numbers_fnt16_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL5,
+        .map_count = sizeof(numbers_fnt16_map),
+        .tile_count = numbers_fnt16_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = BG_COPY_NONE,
+        .bank = BANK(numbers_fnt16),
+        .load = BG_LOAD_ALL,
+    },
+    { // FNT_NUM_16_INV
+        .width = numbers_fnt16_WIDTH / numbers_fnt16_TILE_W,
+        .height = numbers_fnt16_HEIGHT / numbers_fnt16_TILE_H,
+        .map = numbers_fnt16_map,
+        .tiles = numbers_fnt16_tiles,
+        .palettes = NULL,
+        .palette_count = INV_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL4,
+        .map_count = sizeof(numbers_fnt16_map),
+        .tile_count = numbers_fnt16_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = FNT_NUM_16,
+        .bank = BANK(numbers_fnt16),
+        .load = BG_LOAD_ALL,
+    },
+    { // FNT_ASCII_8
+        .width = vincent_fnt8_WIDTH / vincent_fnt8_TILE_W,
+        .height = vincent_fnt8_HEIGHT / vincent_fnt8_TILE_H,
+        .map = vincent_fnt8_map,
+        .tiles = vincent_fnt8_tiles,
+        .palettes = vincent_fnt8_palettes,
+        .palette_count = vincent_fnt8_PALETTE_COUNT,
+        .palette_index = BKGF_CGB_PAL6,
+        .map_count = sizeof(vincent_fnt8_map),
+        .tile_count = vincent_fnt8_TILE_COUNT,
+        .tile_offset = BG_TILE_NUM_START,
+        .tile_copy = BG_COPY_NONE,
+        .bank = BANK(vincent_fnt8),
+        .load = BG_LOAD_SPLASH | BG_LOAD_GBC_ONLY,
+    },
+};

src/map_data.h

@@ -0,0 +1,61 @@
+/*
+ * map_data.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 __MAP__DATA_H__
+#define __MAP__DATA_H__
+
+#include <gbdk/platform.h>
+#include <stdint.h>
+
+#include "maps.h"
+
+// background tiles are loaded into VRAM starting at tile number 0
+#define BG_TILE_NUM_START 0
+
+#define BG_COPY_NONE 0xFF
+
+#define BG_LOAD_GAME     (0 << 0)
+#define BG_LOAD_SPLASH   (1 << 0)
+#define BG_LOAD_ALL      (1 << 6)
+#define BG_LOAD_GBC_ONLY (1 << 7)
+
+struct maps {
+    uint8_t width;
+    uint8_t height;
+    const uint8_t * map;
+    const uint8_t * tiles;
+    const palette_color_t * palettes;
+    uint8_t palette_count;
+    uint8_t palette_index;
+    uint16_t map_count;
+    uint8_t tile_count;
+    uint8_t tile_offset;
+    uint8_t tile_copy;
+    uint8_t bank;
+    uint8_t load;
+};
+
+extern struct maps maps[MAP_COUNT];
+
+BANKREF_EXTERN(map_data)
+
+#define INV_PALETTE_COUNT 1
+extern const palette_color_t num_pal_inv[INV_PALETTE_COUNT * 4];
+
+#endif // __MAP__DATA_H__

src/maps.c

@@ -20,23 +20,21 @@
  * See <http://www.gnu.org/licenses/>.
  */
 
-#include <assert.h>
-
 #include "banks.h"
-#include "title_map.h"
-#include "bg_map.h"
+#include "gb/gb.h"
 #include "util.h"
+#include "map_data.h"
 #include "maps.h"
 
-// currently this assumption is hard-coded
-static_assert(bg_map_WIDTH == 256, "bg_map needs to be 256x256");
-static_assert(bg_map_HEIGHT == 256, "bg_map needs to be 256x256");
-
 #define POS_SCALE_BG 6
 
+// current unscaled ship position
+static uint16_t abs_x, abs_y;
+
 // define this to disable mirrored map scaling support
 #define WRAP_BG // TODO
 
+#ifndef WRAP_BG
 #define bg_map_mapWidth (bg_map_WIDTH / bg_map_TILE_W)
 #define bg_map_mapHeight (bg_map_HEIGHT / bg_map_TILE_H)
 
@@ -48,43 +46,90 @@ static_assert(bg_map_HEIGHT == 256, "bg_map needs to be 256x256");
 #define MAP_FLIP_Y (0x40 | 0x02)
 #define MAP_FLIP_XY (MAP_FLIP_X | MAP_FLIP_Y)
 
-// current unscaled ship position
-static uint16_t abs_x, abs_y;
-
 // current and old positions of the camera in pixels
 static uint16_t old_camera_x, old_camera_y;
 
 // current and old position of the map in tiles
 static uint8_t old_map_pos_x, old_map_pos_y;
+#endif // ! WRAP_BG
+
+BANKREF(maps)
+
+static void map_load_helper(uint8_t i) NONBANKED {
+    START_ROM_BANK(maps[i].bank) {
+        if (maps[i].tile_copy == BG_COPY_NONE) {
+            set_bkg_data(maps[i].tile_offset, maps[i].tile_count, maps[i].tiles);
+        }
+    } END_ROM_BANK
+
+    uint8_t bank = maps[i].bank;
+    if (maps[i].palettes == num_pal_inv) {
+        bank = BANK(map_data);
+    }
+
+    START_ROM_BANK_2(bank) {
+        if (maps[i].palettes != NULL) {
+            set_bkg_palette(maps[i].palette_index, maps[i].palette_count, maps[i].palettes);
+        }
+    } END_ROM_BANK
+}
 
-void map_title(void) NONBANKED {
-    START_ROM_BANK(BANK(title_map)) {
-        set_bkg_palette(OAMF_CGB_PAL0, title_map_PALETTE_COUNT, title_map_palettes);
-        set_bkg_data(0, title_map_TILE_COUNT, title_map_tiles);
+void map_load(uint8_t is_splash) BANKED {
+    uint8_t off = BG_TILE_NUM_START;
+    uint8_t off_gbc = BG_TILE_NUM_START;
+
+    for (uint8_t i = 0; i < MAP_COUNT; i++) {
+        if (!(maps[i].load & BG_LOAD_ALL)) {
+            if (is_splash) {
+                if (!(maps[i].load & BG_LOAD_SPLASH)) {
+                    continue;
+                }
+            } else {
+                if (maps[i].load & BG_LOAD_SPLASH) {
+                    continue;
+                }
+            }
+        }
 
-        if (title_map_MAP_ATTRIBUTES != NULL) {
-            set_bkg_attributes(0, 0,
-                               title_map_WIDTH / title_map_TILE_W,
-                               title_map_HEIGHT / title_map_TILE_H,
-                               title_map_MAP_ATTRIBUTES);
+        if (_cpu != CGB_TYPE) {
+            if (maps[i].load & BG_LOAD_GBC_ONLY) {
+                continue;
+            }
+        }
+
+        if (maps[i].tile_copy == BG_COPY_NONE) {
+            if (maps[i].load & BG_LOAD_GBC_ONLY) {
+                VBK_REG = VBK_BANK_1;
+                maps[i].tile_offset = off_gbc;
+                off_gbc += maps[i].tile_count;
+            } else {
+                maps[i].tile_offset = off;
+                off += maps[i].tile_count;
+            }
         } else {
-            VBK_REG = VBK_ATTRIBUTES;
-            fill_bkg_rect(0, 0,
-                          title_map_WIDTH / title_map_TILE_W,
-                          title_map_HEIGHT / title_map_TILE_H,
-                          0x00);
-            VBK_REG = VBK_TILES;
+            maps[i].tile_offset = maps[maps[i].tile_copy].tile_offset;
         }
 
-        set_bkg_tiles(0, 0,
-                      title_map_WIDTH / title_map_TILE_W,
-                      title_map_HEIGHT / title_map_TILE_H,
-                      title_map_map);
+        map_load_helper(i);
+    }
+}
+
+void map_fill(enum MAPS map, uint8_t bkg) NONBANKED {
+    START_ROM_BANK(maps[map].bank) {
+        VBK_REG = VBK_ATTRIBUTES;
+        bkg ? fill_bkg_rect(0, 0, maps[map].width, maps[map].height, maps[map].palette_index)
+            : fill_win_rect(0, 0, maps[map].width, maps[map].height, maps[map].palette_index);
+
+        VBK_REG = VBK_TILES;
+        bkg ? set_bkg_based_tiles(0, 0, maps[map].width, maps[map].height, maps[map].map, maps[map].tile_offset)
+            : set_win_based_tiles(0, 0, maps[map].width, maps[map].height, maps[map].map, maps[map].tile_offset);
     } END_ROM_BANK
 
-    move_bkg(0, 0);
+    bkg ? move_bkg(0, 0)
+        : move_win(MINWNDPOSX, MINWNDPOSY);
 }
 
+#ifndef WRAP_BG
 static inline void set_bkg_sub_attr(uint8_t x, uint8_t y,
                                     uint8_t w, uint8_t h,
                                     const uint8_t *attr,
@@ -109,48 +154,31 @@ static inline void set_bkg_sub(uint8_t x, uint8_t y,
         set_bkg_sub_attr(x, y, w, h, attr, attr_val, map_w);
     } END_ROM_BANK
 }
+#endif // ! WRAP_BG
 
+// TODO
+#ifndef WRAP_BG
 void map_game(void) NONBANKED {
     START_ROM_BANK(BANK(bg_map)) {
-        set_bkg_palette(OAMF_CGB_PAL0, bg_map_PALETTE_COUNT, bg_map_palettes);
-        set_bkg_data(0, bg_map_TILE_COUNT, bg_map_tiles);
+        abs_x = 0;
+        abs_y = 0;
+        old_camera_x = 0;
+        old_camera_y = 0;
+        old_map_pos_x = 0;
+        old_map_pos_y = 0;
+
+        move_bkg(0, 0);
+
+        // Draw the initial map view for the whole screen
+        set_bkg_sub(0, 0,
+                    MIN(DEVICE_SCREEN_WIDTH + 1u, bg_map_mapWidth),
+                    MIN(DEVICE_SCREEN_HEIGHT + 1u, bg_map_mapHeight),
+                    bg_map_map, bg_map_MAP_ATTRIBUTES, MAP_FLIP_NONE, bg_map_mapWidth);
     } END_ROM_BANK
-
-#ifdef WRAP_BG
-
-        if (bg_map_MAP_ATTRIBUTES != NULL) {
-            set_bkg_attributes(0, 0,
-                               bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H,
-                               bg_map_MAP_ATTRIBUTES);
-        } else {
-            VBK_REG = VBK_ATTRIBUTES;
-            fill_bkg_rect(0, 0,
-                          bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H,
-                          0x00);
-            VBK_REG = VBK_TILES;
-        }
-        set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
-
-#else // WRAP_BG
-
-    abs_x = 0;
-    abs_y = 0;
-    old_camera_x = 0;
-    old_camera_y = 0;
-    old_map_pos_x = 0;
-    old_map_pos_y = 0;
-
-    move_bkg(0, 0);
-
-    // Draw the initial map view for the whole screen
-    set_bkg_sub(0, 0,
-                MIN(DEVICE_SCREEN_WIDTH + 1u, bg_map_mapWidth),
-                MIN(DEVICE_SCREEN_HEIGHT + 1u, bg_map_mapHeight),
-                bg_map_map, bg_map_MAP_ATTRIBUTES, MAP_FLIP_NONE, bg_map_mapWidth);
-
-#endif // WRAP_BG
 }
+#endif // ! WRAP_BG
 
+#ifndef WRAP_BG
 static inline void set(uint8_t dst_x, uint8_t dst_y,
                        uint8_t src_x, uint8_t src_y,
                        uint8_t attr) {
@@ -159,6 +187,7 @@ static inline void set(uint8_t dst_x, uint8_t dst_y,
         set_bkg_attribute_xy(dst_x, dst_y, attr);
     } END_ROM_BANK
 }
+#endif // ! WRAP_BG
 
 void map_dbg_reset(void) NONBANKED {
 #ifndef WRAP_BG

src/maps.h

@@ -20,13 +20,31 @@
 #ifndef __MAPS_H__
 #define __MAPS_H__
 
+#include <gbdk/platform.h>
 #include <stdint.h>
 
-void map_title(void);
+enum MAPS {
+    MAP_TITLE = 0,
+    MAP_GAME_1,
+    MAP_GAME_2,
 
-void map_game(void);
+    FNT_TEXT_16,
+    FNT_TEXT_16_INV,
+
+    FNT_NUM_16,
+    FNT_NUM_16_INV,
+
+    FNT_ASCII_8,
+
+    MAP_COUNT
+};
+
+void map_load(uint8_t is_splash) BANKED;
+void map_fill(enum MAPS map, uint8_t bkg);
 void map_move(int16_t delta_x, int16_t delta_y);
 
 void map_dbg_reset(void);
 
+BANKREF_EXTERN(maps)
+
 #endif // __MAPS_H__

src/sprite_data.c

@@ -32,7 +32,7 @@
 #include "debug_marker.h"
 #include "debug_marker_spr32.h"
 
-BANKREF(power_palettes)
+BANKREF(sprite_data)
 
 /*
  * OCP0: Rocketship (1)

src/sprite_data.h

@@ -20,8 +20,8 @@
  * See <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __SPRITE__DATA_H
-#define __SPRITE__DATA_H
+#ifndef __SPRITE__DATA_H__
+#define __SPRITE__DATA_H__
 
 #include <gbdk/platform.h>
 #include <gbdk/metasprites.h>
@@ -54,7 +54,7 @@ struct sprites {
 
 extern struct sprites metasprites[SPRITE_COUNT];
 
-BANKREF_EXTERN(power_palettes)
+BANKREF_EXTERN(sprite_data)
 extern const palette_color_t power_palettes[4];
 
-#endif // __SPRITE__DATA_H
+#endif // __SPRITE__DATA_H__

src/sprites.c

@@ -42,7 +42,7 @@ void spr_init_pal(void) NONBANKED {
     for (uint8_t i = 0; i < SPRITE_COUNT; i++) {
         uint8_t bank = metasprites[i].bank;
         if (metasprites[i].pa == power_palettes) {
-            bank = BANK(power_palettes);
+            bank = BANK(sprite_data);
         }
 
         START_ROM_BANK(bank) {

src/strings.c

@@ -0,0 +1,89 @@
+/*
+ * strings.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 <string.h>
+
+#include "banks.h"
+#include "strings.h"
+
+BANKREF(strings)
+
+static const char string_top[] = "top";
+static const char string_score[] = "score";
+static const char string_black[] = "black";
+static const char string_white[] = "white";
+static const char string_enter[] = "enter";
+static const char string_name[] = "name";
+static const char string_start_ok[] = "start ok";
+static const char string_conf_menu[] = "Conf Menu";
+static const char string_debug_menu[] = "Debug Menu";
+static const char string_duality[] = "Duality";
+static const char string_xythobuz[] = "xythobuz";
+static const char string_git[] = "Git Commit Hash:";
+static const char string_build_date[] = "Build Date:";
+static const char string_date[] = __DATE__;
+static const char string_time[] = __TIME__;
+static const char string_mp_tx[] = "MP Tx:";
+static const char string_wait[] = "Wait";
+static const char string_visit[] = "Visit:";
+static const char string_url[] = "https://xythobuz.de";
+static const char string_printout[] = "printout";
+static const char string_success[] = "success";
+static const char string_error[] = "error";
+static const char string_gb_printer[] = "GB Printer";
+static const char string_score_printout[] = "Score Printout";
+static const char string_result[] = "Result:";
+static const char string_printf_error[] = "error: 0x%04x";
+
+static const char * const strings[COUNT_STRINGS] = {
+    string_top,            // STR_TOP
+    string_score,          // STR_SCORE
+    string_black,          // STR_BLACK
+    string_white,          // STR_WHITE
+    string_enter,          // STR_ENTER
+    string_name,           // STR_NAME
+    string_start_ok,       // STR_START_OK
+    string_conf_menu,      // STR_CONF_MENU
+    string_debug_menu,     // STR_DEBUG_MENU
+    string_duality,        // STR_DUALITY
+    string_xythobuz,       // STR_XYTHOBUZ
+    string_git,            // STR_GIT
+    string_build_date,     // STR_BUILD_DATE
+    string_date,           // STR_DATE
+    string_time,           // STR_TIME
+    string_mp_tx,          // STR_MP_TX
+    string_wait,           // STR_WAIT
+    string_visit,          // STR_VISIT
+    string_url,            // STR_URL
+    string_printout,       // STR_PRINTOUT
+    string_success,        // STR_SUCCESS
+    string_error,          // STR_ERROR
+    string_gb_printer,     // STR_GB_PRINTER
+    string_score_printout, // STR_SCORE_PRINTOUT
+    string_result,         // STR_RESULT
+    string_printf_error,   // STR_PRINTF_ERROR
+};
+
+#define MAX_STR_LEN 32
+static char str_buff[MAX_STR_LEN + 1];
+
+const char *get_string(enum STRINGS s) BANKED {
+    strncpy(str_buff, strings[s], MAX_STR_LEN);
+    return str_buff;
+}

src/strings.h

@@ -0,0 +1,60 @@
+/*
+ * strings.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 __STRINGS_H__
+#define __STRINGS_H__
+
+#include <gbdk/platform.h>
+
+enum STRINGS {
+    STR_TOP = 0,
+    STR_SCORE,
+    STR_BLACK,
+    STR_WHITE,
+    STR_ENTER,
+    STR_NAME,
+    STR_START_OK,
+    STR_CONF_MENU,
+    STR_DEBUG_MENU,
+    STR_DUALITY,
+    STR_XYTHOBUZ,
+    STR_GIT,
+    STR_BUILD_DATE,
+    STR_DATE,
+    STR_TIME,
+    STR_MP_TX,
+    STR_WAIT,
+    STR_VISIT,
+    STR_URL,
+    STR_PRINTOUT,
+    STR_SUCCESS,
+    STR_ERROR,
+    STR_GB_PRINTER,
+    STR_SCORE_PRINTOUT,
+    STR_RESULT,
+    STR_PRINTF_ERROR,
+
+    COUNT_STRINGS
+};
+
+const char *get_string(enum STRINGS s) BANKED;
+
+BANKREF_EXTERN(strings)
+
+#endif // __STRINGS_H__

src/text.c

@@ -0,0 +1,216 @@
+/*
+ * text.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 <gbdk/platform.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "banks.h"
+#include "maps.h"
+#include "map_data.h"
+#include "text.h"
+
+// TODO inverted score color not visible on DMG
+// TODO 8x8 font only available on GBC
+
+#define TEXT_PALETTE_WHITE BKGF_CGB_PAL3
+#define TEXT_PALETTE_BLACK BKGF_CGB_PAL4
+
+#define TEXT_ATTR_WHITE    (BKGF_PRI | TEXT_PALETTE_WHITE)
+#define TEXT_ATTR_BLACK    (BKGF_PRI | TEXT_PALETTE_BLACK)
+
+#define ASCI_ATTR_DARK     (BKGF_PRI | BKGF_BANK1 | BKGF_CGB_PAL6) // TODO?
+#define ASCI_ATTR_LIGHT    (BKGF_PRI | BKGF_BANK1 | BKGF_CGB_PAL5) // TODO?
+
+BANKREF(text)
+
+static void digit(uint8_t val, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t is_black);
+
+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, uint8_t tile_bank,
+                          const uint8_t *attributes, uint8_t attr_bank) NONBANKED {
+    if (attributes != NULL) {
+        START_ROM_BANK(attr_bank) {
+            VBK_REG = VBK_ATTRIBUTES;
+            set_win_tiles(x, y, w, h, attributes);
+        } END_ROM_BANK
+    } else {
+        VBK_REG = VBK_ATTRIBUTES;
+        fill_win_rect(x, y, w, h, 0x00);
+    }
+
+    START_ROM_BANK(tile_bank) {
+        VBK_REG = VBK_TILES;
+        set_win_based_tiles(x, y, w, h, tiles, base_tile);
+    } END_ROM_BANK
+}
+
+static void set_win_based_attr(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
+                               const uint8_t *tiles, uint8_t base_tile, uint8_t tile_bank,
+                               const uint8_t attr) NONBANKED {
+    VBK_REG = VBK_ATTRIBUTES;
+    fill_win_rect(x, y, w, h, attr);
+
+    START_ROM_BANK(tile_bank) {
+        VBK_REG = VBK_TILES;
+        set_win_based_tiles(x, y, w, h, tiles, base_tile);
+    } END_ROM_BANK
+}
+
+// ----------------------------------------------------------------------------
+// Characters 16x16 (for menus)
+// ----------------------------------------------------------------------------
+
+static void character(uint8_t c, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
+    uint8_t off = c * maps[FNT_TEXT_16].width;
+
+    set_win_based_attr(x_off + (pos * maps[FNT_TEXT_16].width), y_off,
+                       maps[FNT_TEXT_16].width, 1,
+                       maps[FNT_TEXT_16].map + off,
+                       maps[FNT_TEXT_16].tile_offset,
+                       maps[FNT_TEXT_16].bank, is_black ? TEXT_ATTR_BLACK : TEXT_ATTR_WHITE);
+
+    set_win_based_attr(x_off + (pos * maps[FNT_TEXT_16].width), y_off + 1,
+                       maps[FNT_TEXT_16].width, 1,
+                       maps[FNT_TEXT_16].map + off + (maps[FNT_TEXT_16].map_count / 2),
+                       maps[FNT_TEXT_16].tile_offset,
+                       maps[FNT_TEXT_16].bank, is_black ? TEXT_ATTR_BLACK : TEXT_ATTR_WHITE);
+}
+
+void str3(uint16_t name, uint8_t x_off, uint8_t y_off,
+          uint8_t is_black_a, uint8_t is_black_b, uint8_t is_black_c) BANKED {
+    character((name >> 10) & 0x1F, 0, x_off, y_off, is_black_a);
+    character((name >>  5) & 0x1F, 1, x_off, y_off, is_black_b);
+    character((name >>  0) & 0x1F, 2, x_off, y_off, is_black_c);
+}
+
+void str_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off, uint8_t is_black) BANKED {
+    for (uint8_t n = 0; (*s) && (n < TEXT_LINE_WIDTH) && (n < len); n++) {
+        char c = *(s++);
+        if ((c >= 'A') && (c <= 'Z')) {
+            c = c - 'A' + 'a';
+        }
+        if ((c >= '0') && (c <= '9')) {
+            digit(c - '0', n, x_off, y_off, is_black);
+        } else if ((c >= 'a') && (c <= 'z')) {
+            character(c - 'a', n, x_off, y_off, is_black);
+        }
+    }
+}
+
+void str(const char *s, uint8_t x_off, uint8_t y_off, uint8_t is_black) BANKED {
+    str_l(s, 0xFF, x_off, y_off, is_black);
+}
+
+void str_center(const char *s, uint8_t y_off, uint8_t is_black) BANKED {
+    uint8_t n = strlen(s);
+    if (n > TEXT_LINE_WIDTH) n = TEXT_LINE_WIDTH;
+    str(s, TEXT_LINE_WIDTH - n, y_off, is_black);
+}
+
+void str_lines(const char *s, uint8_t y_off, uint8_t is_black) BANKED {
+    if (strlen(s) > 10) {
+        str(s, 0, y_off, is_black);
+        str_center(s + 10, y_off + 2, is_black);
+    } else {
+        str_center(s, y_off, is_black);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Numbers 16x16 (for scores)
+// ----------------------------------------------------------------------------
+
+static void digit(uint8_t val, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
+    uint8_t off = val * maps[FNT_NUM_16].width;
+
+    set_win_based_attr(x_off + (pos * maps[FNT_NUM_16].width), y_off,
+                       maps[FNT_NUM_16].width, 1,
+                       maps[FNT_NUM_16].map + off,
+                       maps[FNT_NUM_16].tile_offset,
+                       maps[FNT_NUM_16].bank, is_black ? TEXT_ATTR_BLACK : TEXT_ATTR_WHITE);
+
+    set_win_based_attr(x_off + (pos * maps[FNT_NUM_16].width), y_off + 1,
+                       maps[FNT_NUM_16].width, 1,
+                       maps[FNT_NUM_16].map + off + (maps[FNT_NUM_16].map_count / 2),
+                       maps[FNT_NUM_16].tile_offset,
+                       maps[FNT_NUM_16].bank, is_black ? TEXT_ATTR_BLACK : TEXT_ATTR_WHITE);
+}
+
+uint8_t number(int32_t score, uint8_t x_off, uint8_t y_off, uint8_t is_black) BANKED {
+    // TODO can not set numbers larger than int16 max?!
+    //score = 32767 + 1; // wtf?!
+
+    uint8_t len = 0;
+    uint8_t digits[MAX_DIGITS];
+    do {
+        digits[len++] = score % 10L;
+        score = score / 10L;
+        if (len >= MAX_DIGITS) {
+            break;
+        }
+    } while (score > 0);
+
+    // if the number was too large for our buffer don't draw anything
+    if (score > 0) {
+        return 0;
+    }
+
+    uint8_t off = (x_off == 0xFF) ? (TEXT_LINE_WIDTH - len)
+               : ((x_off == 0xFE) ? ((TEXT_LINE_WIDTH * 2) - (len * 2)) : x_off);
+    for (uint8_t i = 0; i < len; i++) {
+        digit(digits[len - i - 1], i, off, y_off, is_black);
+    }
+
+    return 8 * len * 2;
+}
+
+// ----------------------------------------------------------------------------
+// GBC-only ASCII 8x8 font (for detailed / debug output)
+// ----------------------------------------------------------------------------
+
+static void char_ascii(uint8_t c, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t light) {
+    set_win_based_attr(x_off + pos, y_off, 1, 1,
+                       maps[FNT_ASCII_8].map + c, 0,
+                       maps[FNT_ASCII_8].bank, light ? ASCI_ATTR_LIGHT : ASCI_ATTR_DARK);
+}
+
+void str_ascii_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off, uint8_t light) BANKED {
+    for (uint8_t n = 0; (*s) && (n < (2 * TEXT_LINE_WIDTH)) && (n < len); n++) {
+        char c = *(s++);
+        char_ascii(c, n, x_off, y_off, light);
+    }
+}
+
+void str_ascii(const char *s, uint8_t x_off, uint8_t y_off, uint8_t light) BANKED {
+    str_ascii_l(s, 0xFF, x_off, y_off, light);
+}
+
+void str_ascii_lines(const char *s, uint8_t y_off, uint8_t light) BANKED {
+    const char *nl = s;
+    uint8_t lines = 0;
+    do {
+        // find next newline
+        while (*nl && (*nl != '\n')) nl++;
+        str_ascii_l(s, nl - s, 0, y_off + lines, light);
+        lines++;
+        if (*nl) nl++;
+        s = nl;
+    } while (*nl);
+}

src/text.h

@@ -0,0 +1,55 @@
+/*
+ * text.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 __TEXT_H__
+#define __TEXT_H__
+
+#include <gbdk/platform.h>
+
+#define MAX_DIGITS 7
+#define TEXT_LINE_WIDTH 10
+
+// ----------------------------------------------------------------------------
+// Characters 16x16 (for menus)
+// ----------------------------------------------------------------------------
+
+void str3(uint16_t name, uint8_t x_off, uint8_t y_off,
+          uint8_t is_black_a, uint8_t is_black_b, uint8_t is_black_c) BANKED;
+void str_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off, uint8_t is_black) BANKED;
+void str(const char *s, uint8_t x_off, uint8_t y_off, uint8_t is_black) BANKED;
+void str_center(const char *s, uint8_t y_off, uint8_t is_black) BANKED;
+void str_lines(const char *s, uint8_t y_off, uint8_t is_black) BANKED;
+
+// ----------------------------------------------------------------------------
+// Numbers 16x16 (for scores)
+// ----------------------------------------------------------------------------
+
+uint8_t number(int32_t score, uint8_t x_off, uint8_t y_off, uint8_t is_black) BANKED;
+
+// ----------------------------------------------------------------------------
+// GBC-only ASCII 8x8 font (for detailed / debug output)
+// ----------------------------------------------------------------------------
+
+void str_ascii_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off, uint8_t light) BANKED;
+void str_ascii(const char *s, uint8_t x_off, uint8_t y_off, uint8_t light) BANKED;
+void str_ascii_lines(const char *s, uint8_t y_off, uint8_t light) BANKED;
+
+BANKREF_EXTERN(text)
+
+#endif // __TEXT_H__

src/window.c

@@ -17,234 +17,25 @@
  * See <http://www.gnu.org/licenses/>.
  */
 
-#include <gbdk/platform.h>
 #include <string.h>
 #include <stdio.h>
 #include <assert.h>
 
 #include "banks.h"
 #include "config.h"
-#include "gb/hardware.h"
 #include "score.h"
-#include "title_map.h"
-#include "bg_map.h"
-#include "numbers_fnt16.h"
-#include "text_fnt16.h"
-#include "vincent_fnt8.h"
+#include "text.h"
 #include "git.h"
 #include "main.h"
+#include "maps.h"
+#include "map_data.h"
 #include "gbprinter.h"
 #include "multiplayer.h"
+#include "strings.h"
 #include "window.h"
 
-#define MAX_DIGITS 7
-#define LINE_WIDTH 10
-
-// TODO inverted score color not visible on DMG
-// TODO 8x8 font only available on GBC
-
 BANKREF(window)
 
-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)
-};
-
-static uint8_t fnt_off = 0;
-
-void win_init(uint8_t is_splash) NONBANKED {
-    fnt_off = is_splash ? title_map_TILE_COUNT : bg_map_TILE_COUNT;
-
-    START_ROM_BANK(BANK(numbers_fnt16)) {
-        set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT,
-                        numbers_fnt16_PALETTE_COUNT, numbers_fnt16_palettes);
-        set_win_data(fnt_off, numbers_fnt16_TILE_COUNT, numbers_fnt16_tiles);
-    } END_ROM_BANK
-
-    START_ROM_BANK_2(BANK(window)) {
-        set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + numbers_fnt16_PALETTE_COUNT,
-                        numbers_fnt16_PALETTE_COUNT, num_pal_inv);
-    } END_ROM_BANK
-
-    if (is_splash) {
-        START_ROM_BANK_2(BANK(text_fnt16)) {
-            set_win_data(fnt_off + numbers_fnt16_TILE_COUNT,
-                         text_fnt16_TILE_COUNT, text_fnt16_tiles);
-        } END_ROM_BANK
-
-        if (_cpu == CGB_TYPE) {
-            VBK_REG = VBK_BANK_1;
-            START_ROM_BANK_2(BANK(vincent_fnt8)) {
-                set_win_data(0, vincent_fnt8_TILE_COUNT, vincent_fnt8_tiles);
-                set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + (2 * numbers_fnt16_PALETTE_COUNT),
-                                vincent_fnt8_PALETTE_COUNT, vincent_fnt8_palettes);
-            } END_ROM_BANK
-        }
-    }
-}
-
-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, uint8_t tile_bank,
-                          const uint8_t *attributes, uint8_t attr_bank) NONBANKED {
-    if (attributes != NULL) {
-        START_ROM_BANK(attr_bank) {
-            VBK_REG = VBK_ATTRIBUTES;
-            set_win_tiles(x, y, w, h, attributes);
-        } END_ROM_BANK
-    } else {
-        VBK_REG = VBK_ATTRIBUTES;
-        fill_win_rect(x, y, w, h, 0x00);
-    }
-
-    START_ROM_BANK(tile_bank) {
-        VBK_REG = VBK_TILES;
-        set_win_based_tiles(x, y, w, h, tiles, base_tile);
-    } END_ROM_BANK
-}
-
-static void set_win_based_attr(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
-                               const uint8_t *tiles, uint8_t base_tile, uint8_t tile_bank,
-                               const uint8_t attr) NONBANKED {
-    VBK_REG = VBK_ATTRIBUTES;
-    fill_win_rect(x, y, w, h, attr);
-
-    START_ROM_BANK(tile_bank) {
-        VBK_REG = VBK_TILES;
-        set_win_based_tiles(x, y, w, h, tiles, base_tile);
-    } END_ROM_BANK
-}
-
-static void character(uint8_t c, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
-    uint8_t off = c * text_fnt16_WIDTH / text_fnt16_TILE_W;
-
-    set_win_based_attr(x_off + (pos * text_fnt16_WIDTH / text_fnt16_TILE_W), y_off,
-                       text_fnt16_WIDTH / text_fnt16_TILE_W, 1,
-                       text_fnt16_map + off, fnt_off + numbers_fnt16_TILE_COUNT,
-                       BANK(text_fnt16), is_black ? 0x82 : 0x81);
-
-    set_win_based_attr(x_off + (pos * text_fnt16_WIDTH / text_fnt16_TILE_W), y_off + 1,
-                       text_fnt16_WIDTH / text_fnt16_TILE_W, 1,
-                       text_fnt16_map + off + (sizeof(text_fnt16_map) / 2), fnt_off + numbers_fnt16_TILE_COUNT,
-                       BANK(text_fnt16), is_black ? 0x82 : 0x81);
-}
-
-static void char_ascii(uint8_t c, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t light) {
-    set_win_based_attr(x_off + pos, y_off, 1, 1,
-                       vincent_fnt8_map + c, 0,
-                       BANK(vincent_fnt8), light ? 0x88 : 0x8B);
-}
-
-static void str3(uint16_t name, uint8_t x_off, uint8_t y_off,
-                 uint8_t is_black_a, uint8_t is_black_b, uint8_t is_black_c) {
-    character((name >> 10) & 0x1F, 0, x_off, y_off, is_black_a);
-    character((name >>  5) & 0x1F, 1, x_off, y_off, is_black_b);
-    character((name >>  0) & 0x1F, 2, x_off, y_off, is_black_c);
-}
-
-static void digit(uint8_t val, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
-    uint8_t off = val * numbers_fnt16_WIDTH / numbers_fnt16_TILE_W;
-
-    set_win_based_attr(x_off + (pos * numbers_fnt16_WIDTH / numbers_fnt16_TILE_W), y_off,
-                       numbers_fnt16_WIDTH / numbers_fnt16_TILE_W, 1,
-                       numbers_fnt16_map + off, fnt_off,
-                       BANK(numbers_fnt16), is_black ? 0x82 : 0x81);
-
-    set_win_based_attr(x_off + (pos * numbers_fnt16_WIDTH / numbers_fnt16_TILE_W), y_off + 1,
-                       numbers_fnt16_WIDTH / numbers_fnt16_TILE_W, 1,
-                       numbers_fnt16_map + off + (sizeof(numbers_fnt16_map) / 2), fnt_off,
-                       BANK(numbers_fnt16), is_black ? 0x82 : 0x81);
-}
-
-static void str_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
-    for (uint8_t n = 0; (*s) && (n < LINE_WIDTH) && (n < len); n++) {
-        char c = *(s++);
-        if ((c >= 'A') && (c <= 'Z')) {
-            c = c - 'A' + 'a';
-        }
-        if ((c >= '0') && (c <= '9')) {
-            digit(c - '0', n, x_off, y_off, is_black);
-        } else if ((c >= 'a') && (c <= 'z')) {
-            character(c - 'a', n, x_off, y_off, is_black);
-        }
-    }
-}
-
-static void str(const char *s, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
-    str_l(s, 0xFF, x_off, y_off, is_black);
-}
-
-static void str_ascii_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off, uint8_t light) {
-    for (uint8_t n = 0; (*s) && (n < (2 * LINE_WIDTH)) && (n < len); n++) {
-        char c = *(s++);
-        char_ascii(c, n, x_off, y_off, light);
-    }
-}
-
-static void str_ascii(const char *s, uint8_t x_off, uint8_t y_off, uint8_t light) {
-    str_ascii_l(s, 0xFF, x_off, y_off, light);
-}
-
-static void str_center(const char *s, uint8_t y_off, uint8_t is_black) {
-    uint8_t n = strlen(s);
-    if (n > LINE_WIDTH) n = LINE_WIDTH;
-    str(s, LINE_WIDTH - n, y_off, is_black);
-}
-
-void win_str_center(const char *s, uint8_t y_off, uint8_t is_black) NONBANKED {
-    START_ROM_BANK(BANK(window)) {
-        str_center(s, y_off, is_black);
-    } END_ROM_BANK
-}
-
-static void str_lines(const char *s, uint8_t y_off, uint8_t is_black) {
-    if (strlen(s) > 10) {
-        str(s, 0, y_off, is_black);
-        str_center(s + 10, y_off + 2, is_black);
-    } else {
-        str_center(s, y_off, is_black);
-    }
-}
-
-static void str_ascii_lines(const char *s, uint8_t y_off, uint8_t light) {
-    const char *nl = s;
-    uint8_t lines = 0;
-    do {
-        // find next newline
-        while (*nl && (*nl != '\n')) nl++;
-        str_ascii_l(s, nl - s, 0, y_off + lines, light);
-        lines++;
-        if (*nl) nl++;
-        s = nl;
-    } while (*nl);
-}
-
-static uint8_t 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 len = 0;
-    uint8_t digits[MAX_DIGITS];
-    do {
-        digits[len++] = score % 10L;
-        score = score / 10L;
-        if (len >= MAX_DIGITS) {
-            break;
-        }
-    } while (score > 0);
-
-    // if the number was too large for our buffer don't draw anything
-    if (score > 0) {
-        return 0;
-    }
-
-    uint8_t off = (x_off == 0xFF) ? (LINE_WIDTH - len) : ((x_off == 0xFE) ? ((LINE_WIDTH * 2) - (len * 2)) : x_off);
-    for (uint8_t i = 0; i < len; i++) {
-        digit(digits[len - i - 1], i, off, y_off, is_black);
-    }
-
-    return 8 * len * 2;
-}
-
 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);
@@ -253,17 +44,15 @@ static void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, u
 }
 
 void win_splash_draw(int32_t lowest, int32_t highest) BANKED {
-    set_win_based(0, 0,
-                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
-                  title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
+    map_fill(MAP_TITLE, 0);
 
     // only show on splash if they fit
     if ((lowest <= 99999) && (highest <= 99999)) {
         number(lowest, 0, DEVICE_SCREEN_HEIGHT - 4, 1);
         number(highest, 0xFE, DEVICE_SCREEN_HEIGHT - 4, 0);
 
-        str("top", 0, DEVICE_SCREEN_HEIGHT - 2, 1);
-        str("score", 10, DEVICE_SCREEN_HEIGHT - 2, 0);
+        str(get_string(STR_TOP), 0, DEVICE_SCREEN_HEIGHT - 2, 1);
+        str(get_string(STR_SCORE), 10, DEVICE_SCREEN_HEIGHT - 2, 0);
     }
 }
 
@@ -280,13 +69,11 @@ void win_score_clear(uint8_t is_black, uint8_t no_bg) BANKED {
     if (no_bg) {
         fill_win(0, 0, DEVICE_SCREEN_WIDTH, DEVICE_SCREEN_HEIGHT, 1, 0x00);
     } else {
-        set_win_based(0, 0,
-                      title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
-                      title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
+        map_fill(MAP_TITLE, 0);
     }
 
     if (is_black < 2) {
-        str_center(is_black ? "black" : "white", 1, is_black);
+        str_center(is_black ? get_string(STR_BLACK) : get_string(STR_WHITE), 1, is_black);
     }
 }
 
@@ -299,25 +86,25 @@ void win_score_print(enum PRN_STATUS status) BANKED {
     static char buff[128];
 
     if (_cpu == CGB_TYPE) {
-        str_ascii("GB Printer", 0, 0, 0);
-        str_ascii("Score Printout", 0, 1, 0);
-        str_ascii("Result:", 0, 3, 0);
+        str_ascii(get_string(STR_GB_PRINTER), 0, 0, 0);
+        str_ascii(get_string(STR_SCORE_PRINTOUT), 0, 1, 0);
+        str_ascii(get_string(STR_RESULT), 0, 3, 0);
 
         if (status == PRN_STATUS_OK) {
-            str_ascii("success", 0, 8, 0);
+            str_ascii(get_string(STR_SUCCESS), 0, 8, 0);
         } else {
-            sprintf(buff, "error: 0x%04x", (uint16_t)status);
+            sprintf(buff, get_string(STR_PRINTF_ERROR), (uint16_t)status);
             str_ascii(buff, 0, 5, 0);
 
             gbprinter_error(status, buff);
             str_ascii_lines(buff, 6, 0);
         }
     } else {
-        str("printout", 0, 4, 0);
+        str(get_string(STR_PRINTOUT), 0, 4, 0);
         if (status == PRN_STATUS_OK) {
-            str("success", 0, 8, 0);
+            str(get_string(STR_SUCCESS), 0, 8, 0);
         } else {
-            str("error", 0, 8, 1);
+            str(get_string(STR_ERROR), 0, 8, 1);
             number(status, 11, 8, 1);
         }
     }
@@ -325,42 +112,47 @@ void win_score_print(enum PRN_STATUS status) BANKED {
 
 static void get_git(char *line_buff) NONBANKED {
     START_ROM_BANK(BANK(git)) {
-        strncpy(line_buff, git_version, 2 * LINE_WIDTH);
+        strncpy(line_buff, git_version, 2 * TEXT_LINE_WIDTH);
+    } END_ROM_BANK
+}
+
+void win_str_center(const char *s, uint8_t y_off, uint8_t is_black) NONBANKED {
+    START_ROM_BANK(BANK(text)) {
+        str_center(s, y_off, is_black);
     } END_ROM_BANK
 }
 
 void win_about(void) BANKED {
-    set_win_based(0, 0,
-                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
-                  title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
+    map_fill(MAP_TITLE, 0);
 
-    str_center("Duality", 0, 1);
-    str_center("xythobuz", 2, 1);
+    str_center(get_string(STR_DUALITY), 0, 1);
+    str_center(get_string(STR_XYTHOBUZ), 2, 1);
 
-    char line_buff[2 * LINE_WIDTH + 1] = {0};
+    char line_buff[2 * TEXT_LINE_WIDTH + 1] = {0};
     get_git(line_buff);
 
     if (_cpu == CGB_TYPE) {
-        str_ascii("Git Commit Hash:", 0, 6, 0);
+        str_ascii(get_string(STR_GIT), 0, 6, 0);
         str_ascii(line_buff, 0, 7, 0);
 
-        str_ascii("Build Date:", 0, 10, 0);
-        str_ascii(__DATE__, 0, 11, 0);
-        str_ascii(__TIME__, 0, 12, 0);
+        str_ascii(get_string(STR_BUILD_DATE), 0, 10, 0);
+        str_ascii(get_string(STR_DATE), 0, 11, 0);
+        str_ascii(get_string(STR_TIME), 0, 12, 0);
 
-        str_ascii("MP Tx:", 14, 11, 1);
-        str_ascii("Wait", 14, 12, 1);
+        str_ascii(get_string(STR_MP_TX), 14, 11, 1);
+        str_ascii(get_string(STR_WAIT), 14, 12, 1);
 
-        str_ascii("Visit:", 0, 15, 0);
-        str_ascii("https://xythobuz.de", 0, 16, 0);
+        str_ascii(get_string(STR_VISIT), 0, 15, 0);
+        str_ascii(get_string(STR_URL), 0, 16, 0);
     } else {
         str_lines(line_buff, 7, 0);
 
-        str_l(&__DATE__[7], 4,           0, 14, 1); // year (4)
-        str_l(&__DATE__[0], 3, (4 * 2) + 1, 14, 1); // month (3)
-        str_l(&__DATE__[4], 2, (7 * 2) + 2, 14, 1); // day (2)
+        const char *date = get_string(STR_DATE);
+        str_l(&date[7], 4,           0, 14, 1); // year (4)
+        str_l(&date[0], 3, (4 * 2) + 1, 14, 1); // month (3)
+        str_l(&date[4], 2, (7 * 2) + 2, 14, 1); // day (2)
 
-        str(__TIME__, 4, 16, 0);
+        str(get_string(STR_TIME), 4, 16, 0);
     }
 }
 
@@ -396,19 +188,17 @@ static uint8_t get_debug(char *name_buff, uint8_t i) NONBANKED {
 }
 
 void win_debug(void) BANKED {
-    set_win_based(0, 0,
-                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
-                  title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
+    map_fill(MAP_TITLE, 0);
 
     // TODO prettier pagination
     uint8_t off = (10 - (DEBUG_ENTRY_COUNT - debug_menu_index)) / 2;
 
-    str_center("Debug Menu", 0, 0);
+    str_center(get_string(STR_DEBUG_MENU), 0, 0);
 
     for (uint8_t i = debug_menu_index; (i < DEBUG_ENTRY_COUNT) && (i < (7 + debug_menu_index)); i++) {
         char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
         uint8_t n_len = get_debug(name_buff, i);
-        str(name_buff, (LINE_WIDTH - n_len) * 2, ((i - debug_menu_index) * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
+        str(name_buff, (TEXT_LINE_WIDTH - n_len) * 2, ((i - debug_menu_index) * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
     }
 }
 
@@ -431,46 +221,42 @@ static uint8_t get_conf(char *name_buff, uint8_t i) NONBANKED {
 }
 
 void win_conf(void) BANKED {
-    set_win_based(0, 0,
-                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
-                  title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
+    map_fill(MAP_TITLE, 0);
 
     // TODO paging when more options added
     static_assert(CONF_ENTRY_COUNT <= 7, "too many conf menu entries");
     uint8_t off = (10 - CONF_ENTRY_COUNT) / 2;
 
-    str_center("Conf Menu", 0, 0);
+    str_center(get_string(STR_CONF_MENU), 0, 0);
 
     for (uint8_t i = 0; (i < CONF_ENTRY_COUNT) && (i < 7); i++) {
         char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
         uint8_t n_len = get_conf(name_buff, i);
-        str(name_buff, (LINE_WIDTH - n_len) * 2, (i * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
+        str(name_buff, (TEXT_LINE_WIDTH - n_len) * 2, (i * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
     }
 }
 
 void win_name(int32_t score) BANKED {
-    set_win_based(0, 0,
-                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
-                  title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
+    map_fill(MAP_TITLE, 0);
 
-    str_center("score", 1, score < 0);
+    str_center(get_string(STR_SCORE), 1, score < 0);
     number(score < 0 ? -score : score, 0xFF, 3, score < 0);
 
-    str_center("enter", 6, score < 0);
-    str_center("name", 8, score < 0);
+    str_center(get_string(STR_ENTER), 6, score < 0);
+    str_center(get_string(STR_NAME), 8, score < 0);
 
-    str_center("start ok", 16, score < 0);
+    str_center(get_string(STR_START_OK), 16, score < 0);
 }
 
 void win_name_draw(uint16_t name, uint8_t is_black, uint8_t pos) BANKED {
-    str3(name, LINE_WIDTH - 3, 12,
+    str3(name, TEXT_LINE_WIDTH - 3, 12,
          (pos == 0) ? !is_black : is_black,
          (pos == 1) ? !is_black : is_black,
          (pos == 2) ? !is_black : is_black);
 }
 
 uint8_t win_game_draw(int32_t score) BANKED {
-    fill_win(0, 0, 10, 2, fnt_off + numbers_fnt16_TILE_COUNT, 0x81);
+    fill_win(0, 0, 10, 2, maps[FNT_ASCII_8].tile_offset, 0x81);
 
     uint8_t is_black = 0;
     if (score < 0) {

src/window.h

@@ -26,7 +26,6 @@
 #include "score.h"
 #include "gbprinter.h"
 
-void win_init(uint8_t is_splash);
 void win_splash_draw(int32_t lowest, int32_t highest) BANKED;
 void win_splash_mp(void) BANKED;
 void win_score_clear(uint8_t is_black, uint8_t no_bg) BANKED;