add ROM autobanking and store highscores in banked RAM.

Makefile

 
 LCCFLAGS := -Wa-l -Wl-m -Wp-MMD
 LCCFLAGS += -I$(BUILD_DIR)/$(DATA_DIR)
-LCCFLAGS += -Wm"-yn Duality" -Wm-yc
+LCCFLAGS += -Wm"-yn Duality" -Wm-yt0x1A -Wm-yoA -Wm-ya16 -Wm-yc
+LCCFLAGS += -autobank -Wb-ext=.rel -Wb-v -Wf-bo255
 
 EMUFLAGS := $(BIN)
 
 
 $(BUILD_DIR)/%.o: %.c $(SPRITES)
 	@mkdir -p $(@D)
-	@echo Compiling $<
-	@$(LCC) $(LCCFLAGS) -c -o $@ $<
+	@echo Compiling Code $<
+	$(eval BAFLAG = $(shell echo "$<" | sed -n 's/.*\.ba\([0-9]\+\).*/\-Wf-ba\1/p'))
+	@$(LCC) $(LCCFLAGS) $(BAFLAG) -c -o $@ $<
 
 $(BUILD_DIR)/%.o: $(BUILD_DIR)/%.c $(SPRITES)
 	@mkdir -p $(@D)
-	@echo Compiling $<
+	@echo Compiling Asset $<
 	@$(LCC) $(LCCFLAGS) -c -o $@ $<
 
 $(BUILD_DIR)/%.o: %.s $(SPRITES)

src/game.c

 #define HEALTH_OFFSET_Y -16
 #define POWER_OFFSET_Y 16
 
-static void status(uint8_t health, uint8_t power, uint8_t *hiwater) {
+static void status(uint8_t health, uint8_t power, uint8_t *hiwater) NONBANKED {
     if (health > 0) {
         switch (health >> 6) {
             case 3:
     }
 }
 
-int32_t game(void) {
+int32_t game(void) NONBANKED {
     disable_interrupts();
     DISPLAY_OFF;
     map_game();
     obj_add(SPR_SHOT_DARK, -32, -32, 0, 0);
 
     win_game_draw(score);
-    move_win(MINWNDPOSX + 0, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
+    move_win(MINWNDPOSX, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
 
     SHOW_WIN;
     DISPLAY_ON;

src/input.c

 static uint8_t joyp = 0;
 static uint8_t old_joyp = 0;
 
-void key_read(void) {
+void key_read(void) NONBANKED {
     old_joyp = joyp;
     joyp = joypad();
 }
 
-uint8_t key_down(uint8_t key) {
+uint8_t key_down(uint8_t key) NONBANKED {
     return joyp & key;
 }
 
-uint8_t key_pressed(uint8_t key) {
+uint8_t key_pressed(uint8_t key) NONBANKED {
     return (joyp ^ old_joyp) & joyp & key;
 }

src/main.c

 #include "game.h"
 #include "score.h"
 
-static void highscore(uint8_t is_black) {
+static void highscore(uint8_t is_black) NONBANKED {
     HIDE_WIN;
 
     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);
+        int32_t score = is_black ? -score_lowest(i).score : score_highest(i).score;
         win_score_draw(score, i, is_black);
     }
 
     }
 }
 
-static void splash_win(void) {
+static void splash_win(void) NONBANKED {
     HIDE_WIN;
 
     // initially show the top 1 scores
-    int32_t low = score_lowest(0);
-    int32_t high = score_highest(0);
+    int32_t low = score_lowest(0).score;
+    int32_t high = score_highest(0).score;
 
     // only show on splash if they fit
     if ((low >= -99999) && (high <= 99999)) {
     SHOW_WIN;
 }
 
-static void splash(void) {
+static void splash(void) NONBANKED {
     disable_interrupts();
     DISPLAY_OFF;
     map_title();
     }
 }
 
-void main(void) {
+void main(void) NONBANKED {
     spr_init();
     snd_init();
     win_init();
 
     while (1) {
         int32_t score = game();
-        score_add(score);
+
+        // TODO ask for name of player
+        struct scores s = { .name = 0x00, .score = score };
+        score_add(s);
+
         splash();
     }
 }

src/maps.c

     RGB8(  0,  0,  0), RGB8(  0,  0,  0), RGB8(248,252,248), RGB8(  0,  0,  0)
 };
 
-void map_title(void) {
+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);
 }
 
-void map_game(void) {
+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);
 }
 
-void win_init(void) {
+void win_init(void) NONBANKED {
+    SWITCH_ROM(BANK(numbers));
     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) {
+                          const uint8_t *tiles, uint8_t base_tile, const uint8_t *attributes) NONBANKED {
     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 y_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) NONBANKED {
+    SWITCH_ROM(BANK(numbers));
     uint8_t off = val * numbers_WIDTH / numbers_TILE_W;
 
     set_win_based(x_off + (digit * numbers_WIDTH / numbers_TILE_W), y_off,
                   (is_black ? num_attr_2 : num_attr_1) + off);
 }
 
-static void number(int32_t score, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
+static void number(int32_t score, uint8_t x_off, uint8_t y_off, uint8_t is_black) NONBANKED {
     // TODO can not set numbers larger than int16 max?!
     //score = 32767 + 1; // wtf?!
 
     }
 }
 
-static void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) {
+static void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) NONBANKED {
     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) {
+void win_splash_draw(int32_t lowest, int32_t highest) NONBANKED {
     // 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(highest, 0xFE, 0, 0);
 }
 
-void win_score_clear(void) {
+void win_score_clear(void) NONBANKED {
+    SWITCH_ROM(BANK(title_map));
     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) {
+void win_score_draw(int32_t score, uint8_t off, uint8_t is_black) NONBANKED {
     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);
+void win_game_draw(int32_t score) NONBANKED {
+    fill_win(0, 0, 20, 2, (uint8_t)bg_map_TILE_COUNT + (uint8_t)numbers_TILE_COUNT, 0x81);
 
     uint8_t is_black = 0;
     if (score < 0) {

src/obj.c

 
 static struct obj objs[MAX_OBJ];
 
-void obj_init(void) {
+void obj_init(void) NONBANKED {
     memset(objs, 0, sizeof(objs));
 }
 
-static uint8_t cnt_sprite(enum SPRITES sprite) {
+static uint8_t cnt_sprite(enum SPRITES sprite) NONBANKED {
     uint8_t cnt = 0;
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
         if (!objs[i].active) {
     return cnt;
 }
 
-enum OBJ_STATE obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y) {
+enum OBJ_STATE obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y) NONBANKED {
     uint8_t obj_cnt = 0xFF;
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
         if (!objs[i].active) {
 #define PICKUP_SMALL_RANGE (10 << POS_SCALE_OBJS)
 #define PICKUP_LARGE_RANGE (16 << POS_SCALE_OBJS)
 
-int16_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score) {
+int16_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score) NONBANKED {
     int16_t damage = 0;
 
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
     return damage;
 }
 
-void obj_draw(int16_t spd_x, int16_t spd_y, uint8_t *hiwater) {
+void obj_draw(int16_t spd_x, int16_t spd_y, uint8_t *hiwater) NONBANKED {
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
         if (!objs[i].active) {
             continue;

src/score.ba0.c

+/*
+ * score.ba0.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 "score.h"
+
+static struct scores scores[SCORE_NUM * 2];
+static uint32_t scores_crc;
+
+static uint16_t convert_name(char a, char b, char c) {
+    // convert to lowercase
+    if ((a >= 'A') && (a <= 'Z')) a = a - 'A' + 'a';
+    if ((b >= 'A') && (b <= 'Z')) b = b - 'A' + 'a';
+    if ((c >= 'A') && (c <= 'Z')) c = c - 'A' + 'a';
+
+    // skip invalid characters
+    if ((a < 'a') || (a > 'z')) a = 'x';
+    if ((b < 'a') || (b > 'z')) b = 'x';
+    if ((c < 'a') || (c > 'z')) c = 'x';
+
+    // zero offset in alphabet
+    a -= 'a';
+    b -= 'a';
+    c -= 'a';
+
+    return (a << 10) | (b << 5) | c;
+}
+
+static uint32_t calc_crc(void) NONBANKED {
+    const uint8_t *d = (const uint8_t *)scores;
+
+    uint32_t c = 0xFFFFFFFF;
+    for (size_t i = 0; i < sizeof(scores); i++) {
+        // adapted from "Hacker's Delight"
+        c ^= d[i];
+        for (size_t j = 0; j < 8; j++) {
+            uint32_t mask = -(c & 1);
+            c = (c >> 1) ^ (0xEDB88320 & mask);
+        }
+    }
+
+    return ~c;
+}
+
+static uint8_t check_crc(void) NONBANKED {
+    return (calc_crc() == scores_crc) ? 1 : 0;
+}
+
+static void score_init(void) NONBANKED {
+    // TODO
+    scores[0].name = convert_name('a', 'b', 'c');
+    scores[0].score = 10000;
+
+    scores[1].name = convert_name('a', 'b', 'c');
+    scores[1].score = 8000;
+
+    scores[2].name = convert_name('a', 'b', 'c');
+    scores[2].score = 6000;
+
+    scores[3].name = convert_name('a', 'b', 'c');
+    scores[3].score = 4000;
+
+    scores[4].name = convert_name('a', 'b', 'c');
+    scores[4].score = 2000;
+
+    scores[5].name = convert_name('a', 'b', 'c');
+    scores[5].score = -2000;
+
+    scores[6].name = convert_name('a', 'b', 'c');
+    scores[6].score = -4000;
+
+    scores[7].name = convert_name('a', 'b', 'c');
+    scores[7].score = -6000;
+
+    scores[8].name = convert_name('a', 'b', 'c');
+    scores[8].score = -8000;
+
+    scores[9].name = convert_name('a', 'b', 'c');
+    scores[9].score = -10000;
+
+    scores_crc = calc_crc();
+}
+
+void score_add(struct scores score) NONBANKED {
+    ENABLE_RAM;
+    SWITCH_RAM(0);
+
+    // initialize score table when data is invalid
+    if (!check_crc()) {
+        score_init();
+    }
+
+    // TODO
+
+    DISABLE_RAM;
+}
+
+struct scores score_highest(uint8_t off) NONBANKED {
+    ENABLE_RAM;
+    SWITCH_RAM(0);
+
+    // initialize score table when data is invalid
+    if (!check_crc()) {
+        score_init();
+    }
+
+    if (off >= SCORE_NUM) {
+        off = SCORE_NUM - 1;
+    }
+    struct scores r = scores[off];
+
+    DISABLE_RAM;
+    return r;
+}
+
+struct scores score_lowest(uint8_t off) NONBANKED {
+    ENABLE_RAM;
+    SWITCH_RAM(0);
+
+    // initialize score table when data is invalid
+    if (!check_crc()) {
+        score_init();
+    }
+
+    if (off >= SCORE_NUM) {
+        off = SCORE_NUM - 1;
+    }
+    struct scores r = scores[(SCORE_NUM * 2) - 1 - off];
+
+    DISABLE_RAM;
+    return r;
+}

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

 
 #define SCORE_NUM 5
 
-void score_add(int32_t score);
-int32_t score_highest(uint8_t off);
-int32_t score_lowest(uint8_t off);
+struct scores {
+    uint16_t name;
+    int32_t score;
+};
+
+void score_add(struct scores score);
+struct scores score_highest(uint8_t off);
+struct scores score_lowest(uint8_t off);
 
 #endif // __SCORE_H__

src/sound.c

 
 #include "sound.h"
 
-void snd_init(void) {
+void snd_init(void) NONBANKED {
     NR52_REG = 0x80; // sound on
     NR51_REG = 0xFF; // all channels on left and right
 
 #endif
 }
 
-void snd_noise(void) {
+void snd_noise(void) NONBANKED {
     NR41_REG = 0x2F; // length timer, higher value is shorter time (up to 0x3F)
     NR42_REG = 0xF0; // initially full volume, no volume changes over time
     NR43_REG = 0x11; // frequency distribution

src/sprite_data.c

         .pa = rockshp_0_palettes,
         .pa_i = OAMF_CGB_PAL0,
         .cnt = rockshp_0_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(rockshp_0),
     },
     { // SPR_SHIP_90
         .ms = rockshp_90_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL0,
         .cnt = rockshp_90_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(rockshp_90),
     },
     { // SPR_THRUST_0
         .ms = thrust_0_metasprites,
         .pa = thrust_0_palettes,
         .pa_i = OAMF_CGB_PAL1,
         .cnt = thrust_0_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(thrust_0),
     },
     { // SPR_THRUST_90
         .ms = thrust_90_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL1,
         .cnt = thrust_90_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(thrust_90),
     },
     { // SPR_LIGHT
         .ms = light_metasprites,
         .pa = light_palettes,
         .pa_i = OAMF_CGB_PAL2,
         .cnt = light_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(light),
     },
     { // SPR_DARK
         .ms = dark_metasprites,
         .pa = dark_palettes,
         .pa_i = OAMF_CGB_PAL3,
         .cnt = dark_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(dark),
     },
     { // SPR_SHOT
         .ms = shoot_metasprites,
         .pa = shoot_palettes,
         .pa_i = OAMF_CGB_PAL4,
         .cnt = shoot_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(shoot),
     },
     { // SPR_SHOT_LIGHT
         .ms = shoot_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL2,
         .cnt = shoot_TILE_COUNT,
-        .off = SPR_SHOT
+        .off = SPR_SHOT,
+        .bank = BANK(shoot),
     },
     { // SPR_SHOT_DARK
         .ms = shoot_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL3,
         .cnt = shoot_TILE_COUNT,
-        .off = SPR_SHOT
+        .off = SPR_SHOT,
+        .bank = BANK(shoot),
     },
     { // SPR_HEALTH_1
         .ms = bar_1_metasprites,
         .pa = bar_1_palettes,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_1_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_1),
     },
     { // SPR_HEALTH_2
         .ms = bar_2_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_2_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_2),
     },
     { // SPR_HEALTH_3
         .ms = bar_3_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_3_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_3),
     },
     { // SPR_HEALTH_4
         .ms = bar_4_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_4_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_4),
     },
     { // SPR_HEALTH_5
         .ms = bar_5_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_5_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_5),
     },
     { // SPR_HEALTH_6
         .ms = bar_6_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_6_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_6),
     },
     { // SPR_HEALTH_7
         .ms = bar_7_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_7_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_7),
     },
     { // SPR_HEALTH_8
         .ms = bar_8_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL5,
         .cnt = bar_8_TILE_COUNT,
-        .off = TILE_NUM_START
+        .off = TILE_NUM_START,
+        .bank = BANK(bar_8),
     },
     { // SPR_POWER_1
         .ms = bar_1_metasprites,
         .pa = power_palettes,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_1_TILE_COUNT,
-        .off = SPR_HEALTH_1
+        .off = SPR_HEALTH_1,
+        .bank = BANK(bar_1),
     },
     { // SPR_POWER_2
         .ms = bar_2_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_2_TILE_COUNT,
-        .off = SPR_HEALTH_2
+        .off = SPR_HEALTH_2,
+        .bank = BANK(bar_2),
     },
     { // SPR_POWER_3
         .ms = bar_3_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_3_TILE_COUNT,
-        .off = SPR_HEALTH_3
+        .off = SPR_HEALTH_3,
+        .bank = BANK(bar_3),
     },
     { // SPR_POWER_4
         .ms = bar_4_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_4_TILE_COUNT,
-        .off = SPR_HEALTH_4
+        .off = SPR_HEALTH_4,
+        .bank = BANK(bar_4),
     },
     { // SPR_POWER_5
         .ms = bar_5_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_5_TILE_COUNT,
-        .off = SPR_HEALTH_5
+        .off = SPR_HEALTH_5,
+        .bank = BANK(bar_5),
     },
     { // SPR_POWER_6
         .ms = bar_6_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_6_TILE_COUNT,
-        .off = SPR_HEALTH_6
+        .off = SPR_HEALTH_6,
+        .bank = BANK(bar_6),
     },
     { // SPR_POWER_7
         .ms = bar_7_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_7_TILE_COUNT,
-        .off = SPR_HEALTH_7
+        .off = SPR_HEALTH_7,
+        .bank = BANK(bar_7),
     },
     { // SPR_POWER_8
         .ms = bar_8_metasprites,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL6,
         .cnt = bar_8_TILE_COUNT,
-        .off = SPR_HEALTH_8
+        .off = SPR_HEALTH_8,
+        .bank = BANK(bar_8),
     }
 };

src/sprite_data.h

     uint8_t pa_i;
     uint8_t cnt;
     uint8_t off;
+    uint8_t bank;
 };
 
 extern struct sprites metasprites[SPRITE_COUNT];

src/sprites.c

 
 #include "sprite_data.h"
 
-void spr_init(void) {
+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].pa != NULL) {
             set_sprite_palette(metasprites[i].pa_i, 1, metasprites[i].pa);
         }
     }
 }
 
-void spr_draw(enum SPRITES sprite, enum SPRITE_FLIP flip, int8_t x_off, int8_t y_off, uint8_t frame, uint8_t *hiwater) {
+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);
+
     switch (flip) {
         case FLIP_Y:
             *hiwater += move_metasprite_flipy(
     }
 }
 
-void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater) {
+void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater) NONBANKED {
     switch (rot) {
         case ROT_0:
             spr_draw(SPR_SHIP_0, FLIP_NONE, 0, 0, 0, hiwater);