add macro to restore previous bank when switching rom banks. score no longer crashes but shows garbage.

src/banks.h

+/*
+ * banks.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 __BANKS_H__
+#define __BANKS_H__
+
+#define START_ROM_BANK_2(x) __previous__bank = CURRENT_BANK; SWITCH_ROM(x)
+#define START_ROM_BANK(x) uint8_t START_ROM_BANK_2(x)
+#define END_ROM_BANK() SWITCH_ROM(__previous__bank)
+
+#endif // __BANKS_H__

src/input.c

 
 #include <gbdk/platform.h>
 
+#include "banks.h"
 #include "input.h"
 
 static uint8_t joyp = 0;
     old_joyp = joyp;
     joyp = joypad();
 
-    SWITCH_ROM(BANK(input));
     if (debug_cnt < DEBUG_SEQUENCE_COUNT) {
-        if (key_pressed(key_debug_sequence[debug_cnt])) {
-            debug_cnt++;
-        } else if (key_pressed(0xFF)) {
-            debug_cnt = 0;
-        }
+        START_ROM_BANK(BANK(input));
+            if (key_pressed(key_debug_sequence[debug_cnt])) {
+                debug_cnt++;
+            } else if (key_pressed(0xFF)) {
+                debug_cnt = 0;
+            }
+        END_ROM_BANK();
     } else {
         if (key_pressed(0xFF ^ J_START)) {
             debug_cnt = 0;

src/main.c

 #include <rand.h>
 
 #include "asm/types.h"
+#include "banks.h"
 #include "gb/gb.h"
 #include "maps.h"
 #include "obj.h"
         move_win(MINWNDPOSX, MINWNDPOSY);
     } else {
         // initially show the top 1 scores
-        //int32_t low = score_lowest(0).score;
-        //int32_t high = score_highest(0).score;
-        //win_splash_draw(-low, high);
+        int32_t low = score_lowest(0).score;
+        int32_t high = score_highest(0).score;
+        win_splash_draw(-low, high);
 
         move_win(MINWNDPOSX, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - (8 * 4));
     }
                     }
                     splash_win();
                 } else if (key_pressed(J_A)) {
-                    SWITCH_ROM(BANK(main));
-                    debug_flags ^= debug_entries[debug_menu_index].flag;
+                    START_ROM_BANK(BANK(main));
+                        debug_flags ^= debug_entries[debug_menu_index].flag;
+                    END_ROM_BANK();
                     splash_win();
                 } else if (key_pressed(J_B)) {
                     debug_flags &= ~DBG_MENU;
 
     DISPLAY_ON;
 
-    SWITCH_ROM(BANK(border_sgb));
-
-    set_sgb_border((const uint8_t *)border_sgb_tiles, sizeof(border_sgb_tiles),
-                   (const uint8_t *)border_sgb_map, sizeof(border_sgb_map),
-                   (const uint8_t *)border_sgb_palettes, sizeof(border_sgb_palettes));
+    START_ROM_BANK(BANK(border_sgb));
+        set_sgb_border((const uint8_t *)border_sgb_tiles, sizeof(border_sgb_tiles),
+                       (const uint8_t *)border_sgb_map, sizeof(border_sgb_map),
+                       (const uint8_t *)border_sgb_palettes, sizeof(border_sgb_palettes));
+    END_ROM_BANK();
 
     DISPLAY_OFF;
-
 }
 
 void main(void) NONBANKED {

src/maps.c

 
 #include <gbdk/platform.h>
 #include <string.h>
-#include "gb/gb.h"
+
+#include "banks.h"
 #include "score.h"
 #include "title_map.h"
 #include "bg_map.h"
 static uint8_t fnt_off = 0;
 
 void map_title(void) NONBANKED {
-    SWITCH_ROM(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);
-    set_bkg_attributes(0, 0, title_map_MAP_ATTRIBUTES_WIDTH, title_map_MAP_ATTRIBUTES_HEIGHT, title_map_MAP_ATTRIBUTES);
-    set_bkg_tiles(0, 0, title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H, title_map_map);
+    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);
+        set_bkg_attributes(0, 0, title_map_MAP_ATTRIBUTES_WIDTH, title_map_MAP_ATTRIBUTES_HEIGHT, title_map_MAP_ATTRIBUTES);
+        set_bkg_tiles(0, 0, title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H, title_map_map);
+    END_ROM_BANK();
 }
 
 void map_game(void) NONBANKED {
-    SWITCH_ROM(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);
-    set_bkg_attributes(0, 0, bg_map_MAP_ATTRIBUTES_WIDTH, bg_map_MAP_ATTRIBUTES_HEIGHT, bg_map_MAP_ATTRIBUTES);
-    set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
+    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);
+        set_bkg_attributes(0, 0, bg_map_MAP_ATTRIBUTES_WIDTH, bg_map_MAP_ATTRIBUTES_HEIGHT, bg_map_MAP_ATTRIBUTES);
+        set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
+    END_ROM_BANK();
 }
 
 void win_init(uint8_t is_splash) NONBANKED {
     fnt_off = is_splash ? title_map_TILE_COUNT : bg_map_TILE_COUNT;
 
-    SWITCH_ROM(BANK(numbers_fnt));
-    set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT, numbers_fnt_PALETTE_COUNT, numbers_fnt_palettes);
-    set_win_data(fnt_off, numbers_fnt_TILE_COUNT, numbers_fnt_tiles);
+    START_ROM_BANK(BANK(numbers_fnt));
+        set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT, numbers_fnt_PALETTE_COUNT, numbers_fnt_palettes);
+        set_win_data(fnt_off, numbers_fnt_TILE_COUNT, numbers_fnt_tiles);
+    END_ROM_BANK();
 
-    SWITCH_ROM(BANK(maps));
-    set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + numbers_fnt_PALETTE_COUNT, numbers_fnt_PALETTE_COUNT, num_pal_inv);
+    START_ROM_BANK_2(BANK(maps));
+        set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + numbers_fnt_PALETTE_COUNT, numbers_fnt_PALETTE_COUNT, num_pal_inv);
+    END_ROM_BANK();
 
     if (is_splash) {
-        SWITCH_ROM(BANK(text_fnt));
-        set_win_data(fnt_off + numbers_fnt_TILE_COUNT, text_fnt_TILE_COUNT, text_fnt_tiles);
+        START_ROM_BANK_2(BANK(text_fnt));
+            set_win_data(fnt_off + numbers_fnt_TILE_COUNT, text_fnt_TILE_COUNT, text_fnt_tiles);
+        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 {
-    SWITCH_ROM(attr_bank);
-    VBK_REG = VBK_ATTRIBUTES;
-    set_win_tiles(x, y, w, h, attributes);
-
-    SWITCH_ROM(tile_bank);
-    VBK_REG = VBK_TILES;
-    set_win_based_tiles(x, y, w, h, tiles, base_tile);
+    START_ROM_BANK(attr_bank);
+        VBK_REG = VBK_ATTRIBUTES;
+        set_win_tiles(x, y, w, h, attributes);
+    END_ROM_BANK();
+
+    START_ROM_BANK_2(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) NONBANKED {
     str_center("Duality", 0, 1);
     str_center("xythobuz", 2, 1);
 
-    SWITCH_ROM(BANK(git));
     char line_buff[2 * LINE_WIDTH + 1] = {0};
-    strncpy(line_buff, git_version, 2 * LINE_WIDTH);
+
+    START_ROM_BANK(BANK(git));
+        strncpy(line_buff, git_version, 2 * LINE_WIDTH);
+    END_ROM_BANK();
 
     str_lines(line_buff, 7, 0);
 
 
     str_center("Debug Menu", 0, 0);
 
-    char name_buff[DEBUG_ENTRY_NAME_LEN + 2 + 1] = {0};
     for (uint8_t i = 0; (i < DEBUG_ENTRY_COUNT) && (i < 7); i++) {
-        SWITCH_ROM(BANK(main));
-        strncpy(name_buff, debug_entries[i].name, DEBUG_ENTRY_NAME_LEN + 1);
-
-        uint8_t n_len = strlen(name_buff);
-        name_buff[n_len] = ' ';
-        name_buff[n_len + 1] = (debug_flags & debug_entries[i].flag) ? '1' : '0';
-        name_buff[n_len + 2] = '\0';
-        n_len += 2;
+        char name_buff[DEBUG_ENTRY_NAME_LEN + 2 + 1] = {0};
+
+        START_ROM_BANK(BANK(main));
+            strncpy(name_buff, debug_entries[i].name, DEBUG_ENTRY_NAME_LEN + 1);
+
+            uint8_t n_len = strlen(name_buff);
+            name_buff[n_len] = ' ';
+            name_buff[n_len + 1] = (debug_flags & debug_entries[i].flag) ? '1' : '0';
+            name_buff[n_len + 2] = '\0';
+            n_len += 2;
+        END_ROM_BANK();
 
         str(name_buff, (LINE_WIDTH - n_len) * 2, (i * 2) + 3, (debug_menu_index == i) ? 1 : 0);
     }

src/score.ba0.c

 
 #include <string.h>
 
+#include "banks.h"
 #include "score.h"
 
 static struct scores scores[SCORE_NUM * 2];
     return (a << 10) | (b << 5) | c;
 }
 
-static uint32_t calc_crc(void) BANKED {
+static uint32_t calc_crc(void) {
     const uint8_t *d = (const uint8_t *)scores;
 
     uint32_t c = 0xFFFFFFFF;
     return ~c;
 }
 
-static uint8_t check_crc(void) BANKED {
+static uint8_t check_crc(void) {
     return (calc_crc() == scores_crc) ? 1 : 0;
 }
 
 static void score_init(void) NONBANKED {
-    SWITCH_ROM(BANK(score));
-    memcpy(scores, initial_scores, sizeof(scores));
-    scores_crc = calc_crc();
+    START_ROM_BANK(BANK(score));
+        memcpy(scores, initial_scores, sizeof(scores));
+    END_ROM_BANK();
 }
 
-static uint8_t score_pos(int32_t score) BANKED {
+static uint8_t score_pos(int32_t score) {
     if (score > 0) {
         for (uint8_t i = 0; i < SCORE_NUM; i++) {
             if (score > scores[i].score) {
     // initialize score table when data is invalid
     if (!check_crc()) {
         score_init();
+        scores_crc = calc_crc();
     }
 
     uint8_t r = (score_pos(score) < (SCORE_NUM * 2)) ? 1 : 0;
     // initialize score table when data is invalid
     if (!check_crc()) {
         score_init();
+        scores_crc = calc_crc();
     }
 
     uint8_t new = score_pos(score.score);
     // initialize score table when data is invalid
     if (!check_crc()) {
         score_init();
+        scores_crc = calc_crc();
     }
 
     if (off >= SCORE_NUM) {
     // initialize score table when data is invalid
     if (!check_crc()) {
         score_init();
+        scores_crc = calc_crc();
     }
 
     if (off >= SCORE_NUM) {
     ENABLE_RAM;
     SWITCH_RAM(0);
     score_init();
+    scores_crc = calc_crc();
     DISABLE_RAM;
 }

src/sprites.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include "banks.h"
 #include "sprite_data.h"
 
 void spr_init(void) NONBANKED {
     uint8_t off = TILE_NUM_START;
     for (uint8_t i = 0; i < SPRITE_COUNT; i++) {
-        SWITCH_ROM(metasprites[i].bank);
-
-        if (metasprites[i].off == TILE_NUM_START) {
-            metasprites[i].off = off;
-            off += metasprites[i].cnt;
-            set_sprite_data(metasprites[i].off, metasprites[i].cnt, metasprites[i].ti);
-        } else {
-            metasprites[i].off = metasprites[metasprites[i].off].off;
-        }
+        START_ROM_BANK(metasprites[i].bank);
+            if (metasprites[i].off == TILE_NUM_START) {
+                metasprites[i].off = off;
+                off += metasprites[i].cnt;
+                set_sprite_data(metasprites[i].off, metasprites[i].cnt, metasprites[i].ti);
+            } else {
+                metasprites[i].off = metasprites[metasprites[i].off].off;
+            }
+        END_ROM_BANK();
     }
 }
 
 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) {
-            SWITCH_ROM(BANK(power_palettes));
-        } else {
-            SWITCH_ROM(metasprites[i].bank);
+            bank = BANK(power_palettes);
         }
 
-        if ((metasprites[i].pa != NULL) && ((metasprites[i].pa_i & PALETTE_ALL_FLAGS) == PALETTE_PRELOAD)) {
-            set_sprite_palette(metasprites[i].pa_i, metasprites[i].pa_n, metasprites[i].pa);
-        }
+        START_ROM_BANK(bank);
+            if ((metasprites[i].pa != NULL) && ((metasprites[i].pa_i & PALETTE_ALL_FLAGS) == PALETTE_PRELOAD)) {
+                set_sprite_palette(metasprites[i].pa_i, metasprites[i].pa_n, metasprites[i].pa);
+            }
+        END_ROM_BANK();
     }
 }
 
 void spr_draw(enum SPRITES sprite, enum SPRITE_FLIP flip,
               int8_t x_off, int8_t y_off, uint8_t frame,
               uint8_t *hiwater) NONBANKED {
-    SWITCH_ROM(metasprites[sprite].bank);
+    START_ROM_BANK(metasprites[sprite].bank);
 
     if (frame >= metasprites[sprite].ms_n) {
         frame = 0;
                     DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
             break;
     }
+
+    END_ROM_BANK();
 }
 
 void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater) NONBANKED {