refactor music and sfx functions

src/game.c

 static void show_explosion(uint16_t power) NONBANKED {
     snd_music_off();
     snd_note_off();
-    sample_play_explosion_ship();
+    sample_play(SFX_EXPL_SHIP);
 
     for (uint8_t n = 0; n < (4 * 4 * 4); n++) {
         uint8_t hiwater = SPR_NUM_START;
     DISPLAY_ON;
     enable_interrupts();
 
-    snd_game_music();
+    snd_music(SND_GAME);
 
     while(1) {
         key_read();
             }
 
             if (ret == OBJ_ADDED) {
-                sample_play_shoot();
+                sample_play(SFX_SHOT);
 
                 if (score > 0) {
                     score--;
             }
 
             // restart bg music
-            snd_game_music();
+            snd_music(SND_GAME);
 
             // re-draw ship sprite
             redraw = 1;

src/main.c

 const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT] = {
     { .name = "marker",   .flag = DBG_MARKER,      .max = 1 }, // 0
     { .name = "invuln",   .flag = DBG_GOD_MODE,    .max = 1 }, // 1
-    { .name = "music",    .flag = DBG_NONE,        .max = 3 }, // 2
-    { .name = "sfx-test", .flag = DBG_NONE,        .max = 3 }, // 3
+    { .name = "music",    .flag = DBG_NONE,        .max = SND_COUNT }, // 2
+    { .name = "sfx-test", .flag = DBG_NONE,        .max = SFX_COUNT }, // 3
     { .name = "cl score", .flag = DBG_CLEAR_SCORE, .max = 1 }, // 4
     { .name = "0 scores", .flag = DBG_ZERO_SCORE,  .max = 1 }, // 5
 };
             spr_draw(SPR_SHIP, FLIP_NONE, -4, -42 - 1, 4, hiwater);
             if (frame == 0) {
                 obj_add(SPR_SHOT, SHIP_OFF, -42, SHOT_SPEED, 0);
-                sample_play_shoot();
+                sample_play(SFX_SHOT);
             }
             break;
 
             spr_draw(SPR_SHIP, FLIP_X, 4, -42, 4, hiwater);
             if (frame == 0) {
                 obj_add(SPR_SHOT, -SHIP_OFF, -42, -SHOT_SPEED, 0);
-                sample_play_shoot();
+                sample_play(SFX_SHOT);
             }
             break;
     }
     enable_interrupts();
 
     if (!(conf_get()->debug_flags & DBG_MENU)) {
-        snd_menu_music();
+        snd_music(SND_MENU);
     }
 
     while (1) {
                     debug_special_value = 0;
                     conf_write_crc();
                     splash_win();
-                    snd_menu_music();
+                    snd_music(SND_MENU);
                 }
 
                 if (switch_special && (debug_menu_index == 2)) {
-                    switch (debug_special_value) {
-                        case 0:
-                            snd_music_off();
-                            snd_note_off();
-                            break;
-
-                        case 1:
-                            snd_menu_music();
-                            snd_note_off();
-                            break;
-
-                        case 2:
-                            snd_game_music();
-                            snd_note_off();
-                            break;
-
-                        case 3:
-                            snd_gameover_music();
-                            snd_note_off();
-                            break;
-
-                        default:
-                            break;
+                    snd_music_off();
+                    if (debug_special_value > 0) {
+                        snd_music(debug_special_value - 1);
                     }
+                    snd_note_off();
                 } else if (switch_special && (debug_menu_index == 3)) {
-                    switch (debug_special_value) {
-                        case 1:
-                            sample_play_shoot();
-                            break;
-
-                        case 2:
-                            sample_play_explosion_orbs();
-                            break;
-
-                        case 3:
-                            sample_play_explosion_ship();
-                            break;
-
-                        default:
-                            break;
+                    if (debug_special_value > 0) {
+                        sample_play(debug_special_value - 1);
                     }
                 }
             }
     DISPLAY_ON;
     enable_interrupts();
 
-    snd_gameover_music();
+    snd_music(SND_GAMEOVER);
 
     char name[3] = { 'a', 'a', 'a' };
     uint8_t pos = 0;

src/obj.c

 
                     if ((abs(objs[i].off_x - objs[j].off_x) <= SHOT_RANGE)
                             && (abs(objs[i].off_y - objs[j].off_y) <= SHOT_RANGE)) {
-                        sample_play_explosion_orbs();
+                        sample_play(SFX_EXPL_ORB);
 
                         objs[j].active = 0;
 

src/sample.c

 #include "sfx_expl_ship.h"
 #include "sample.h"
 
+BANKREF(sample)
+
 static volatile uint8_t play_bank = 1;
 static volatile const uint8_t *play_sample = 0;
 static volatile uint16_t play_length = 0;
 
-void sample_play_shoot(void) NONBANKED {
-    CRITICAL {
-        play_bank = BANK(sfx_shoot);
-        play_sample = sfx_shoot;
-        play_length = sfx_shoot_SIZE >> 4;
+struct sfxs {
+    uint8_t bank;
+    uint8_t * const smp;
+    uint16_t len;
+};
+
+static const struct sfxs sfxs[SFX_COUNT] = {
+    { .bank = BANK(sfx_shoot),     .smp = sfx_shoot,     .len = sfx_shoot_SIZE >> 4 },     // SFX_SHOT
+    { .bank = BANK(sfx_expl_orb),  .smp = sfx_expl_orb,  .len = sfx_expl_orb_SIZE >> 4 },  // SFX_EXPL_ORB
+    { .bank = BANK(sfx_expl_ship), .smp = sfx_expl_ship, .len = sfx_expl_ship_SIZE >> 4 }, // SFX_EXPL_SHIP
+};
+
+void sample_play(enum SFXS sfx) BANKED {
+    if (sfx >= SFX_COUNT) {
+        return;
     }
-}
-
-void sample_play_explosion_orbs(void) NONBANKED {
-    CRITICAL {
-        play_bank = BANK(sfx_expl_orb);
-        play_sample = sfx_expl_orb;
-        play_length = sfx_expl_orb_SIZE >> 4;
-    }
-}
 
-void sample_play_explosion_ship(void) NONBANKED {
     CRITICAL {
-        play_bank = BANK(sfx_expl_ship);
-        play_sample = sfx_expl_ship;
-        play_length = sfx_expl_ship_SIZE >> 4;
+        play_bank = sfxs[sfx].bank;
+        play_sample = sfxs[sfx].smp;
+        play_length = sfxs[sfx].len;
     }
 }
 

src/sample.h

 #ifndef __SAMPLE_H__
 #define __SAMPLE_H__
 
-void sample_play_shoot(void);
-void sample_play_explosion_orbs(void);
-void sample_play_explosion_ship(void);
+#include <gbdk/platform.h>
+
+enum SFXS {
+    SFX_SHOT = 0,
+    SFX_EXPL_ORB,
+    SFX_EXPL_SHIP,
+
+    SFX_COUNT
+};
+
+void sample_play(enum SFXS sfx) BANKED;
+
 void sample_isr(void);
 
+BANKREF_EXTERN(sample)
+
 #endif // __SAMPLE_H__

src/sound.c

     1985, 1988, 1992, 1995, 1998, 2001, 2004, 2006, 2009, 2011, 2013, 2015  // 60 .. 71
 };
 
-static struct music const * music = NULL;
-static uint8_t bank;
-static uint16_t off = 0;
-static uint16_t last_t = 0;
+static volatile struct music const * music = NULL;
+static volatile uint8_t bank;
+static volatile uint16_t off = 0;
+static volatile uint16_t last_t = 0;
+
+struct snds {
+    uint8_t bank;
+    struct music const * snd;
+};
+
+static const struct snds snds[SND_COUNT] = {
+    { .bank = BANK(sound_menu), .snd = &music_menu }, // SND_MENU
+    { .bank = BANK(sound_game), .snd = &music_game }, // SND_GAME
+    { .bank = BANK(sound_over), .snd = &music_over }, // SND_GAMEOVER
+};
 
 static void play_note(enum notes note) NONBANKED {
     if (note < SILENCE) {
 static void play_note2(enum notes note) NONBANKED {
     if (note < SILENCE) {
         START_ROM_BANK(BANK(sound));
-        uint16_t freq = frequencies[note];
+            uint16_t freq = frequencies[note];
         END_ROM_BANK();
 
         NR21_REG = 0x80 | 0x3F; // 50% duty, shortest initial length
     play_note2(SILENCE);
 }
 
-void snd_menu_music(void) BANKED {
-    CRITICAL {
-        music = &music_menu;
-        bank = BANK(sound_menu);
-        off = 0;
-        last_t = timer_get();
-    }
-}
-
-void snd_game_music(void) BANKED {
-    CRITICAL {
-        music = &music_game;
-        bank = BANK(sound_game);
-        off = 0;
-        last_t = timer_get();
+void snd_music(enum SOUNDS snd) BANKED {
+    if (snd >= SND_COUNT) {
+        return;
     }
-}
 
-void snd_gameover_music(void) BANKED {
     CRITICAL {
-        music = &music_over;
-        bank = BANK(sound_over);
+        music = snds[snd].snd;
+        bank = snds[snd].bank;
         off = 0;
         last_t = timer_get();
     }

src/sound.h

     uint16_t repeat;
 };
 
-void snd_init(void) BANKED;
+enum SOUNDS {
+    SND_MENU = 0,
+    SND_GAME,
+    SND_GAMEOVER,
+
+    SND_COUNT
+};
 
+void snd_init(void) BANKED;
 void snd_music_off(void) BANKED;
 void snd_note_off(void) BANKED;
-void snd_menu_music(void) BANKED;
-void snd_game_music(void) BANKED;
-void snd_gameover_music(void) BANKED;
+void snd_music(enum SOUNDS snd) BANKED;
+
 void snd_play(void);
 
 BANKREF_EXTERN(sound)

src/sprites.c

 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 {
+    if (sprite >= SPRITE_COUNT) {
+        return;
+    }
+
     START_ROM_BANK(metasprites[sprite].bank);
 
     if (frame >= metasprites[sprite].ms_n) {