add conf screen for sfx and music volume

src/config.ba0.c

 
 #include "banks.h"
 #include "score.h"
+#include "sample.h"
+#include "sound.h"
 #include "config.h"
 
 struct config_mem {
         mem.config.music_vol = 0x07;
         score_reset();
     }
+
+    snd_vol_sfx = mem.config.sfx_vol;
+    snd_vol_music = mem.config.music_vol;
 }
 
 void conf_write_crc(void) BANKED {

src/main.c

 
 BANKREF(main)
 
+const struct conf_entry conf_entries[CONF_ENTRY_COUNT] = {
+    { .name = "sfx-vol",  .var = &snd_vol_sfx,   .max = 0x0F }, // 0
+    { .name = "musi-vol", .var = &snd_vol_music, .max = 0x0F }, // 1
+};
+
 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
     }
 }
 
+static void conf_screen(void) NONBANKED {
+    HIDE_WIN;
+
+    move_win(MINWNDPOSX, MINWNDPOSY);
+    hide_sprites_range(SPR_NUM_START, MAX_HARDWARE_SPRITES);
+    win_conf();
+
+    SHOW_WIN;
+
+    debug_menu_index = 0;
+
+    while (1) {
+        key_read();
+
+        if (key_pressed(J_SELECT)) {
+            about_screen();
+            break;
+        } else if (key_pressed(J_UP)) {
+            if (debug_menu_index > 0) {
+                debug_menu_index--;
+            } else {
+                debug_menu_index = CONF_ENTRY_COUNT - 1;
+            }
+            win_conf();
+        } else if (key_pressed(J_DOWN)) {
+            if (debug_menu_index < (CONF_ENTRY_COUNT - 1)) {
+                debug_menu_index++;
+            } else {
+                debug_menu_index = 0;
+            }
+            win_conf();
+        } else if (key_pressed(J_LEFT)) {
+            START_ROM_BANK(BANK(main));
+                if (*conf_entries[debug_menu_index].var > 0) {
+                    (*conf_entries[debug_menu_index].var)--;
+                } else {
+                    *conf_entries[debug_menu_index].var = conf_entries[debug_menu_index].max;
+                }
+                conf_get()->music_vol = snd_vol_music;
+                conf_get()->sfx_vol = snd_vol_sfx;
+                conf_write_crc();
+            END_ROM_BANK();
+            win_conf();
+        } else if (key_pressed(J_RIGHT)) {
+            START_ROM_BANK(BANK(main));
+                if (*conf_entries[debug_menu_index].var < conf_entries[debug_menu_index].max) {
+                    (*conf_entries[debug_menu_index].var)++;
+                } else {
+                    *conf_entries[debug_menu_index].var = 0;
+                }
+                conf_get()->music_vol = snd_vol_music;
+                conf_get()->sfx_vol = snd_vol_sfx;
+                conf_write_crc();
+            END_ROM_BANK();
+            win_conf();
+        } else if (key_pressed(J_A) || key_pressed(J_B) || key_pressed(J_START)) {
+            break;
+        }
+
+        vsync();
+    }
+
+    debug_menu_index = 0;
+}
+
 static void splash_win(void) NONBANKED {
     HIDE_WIN;
 
             highscore(0);
             splash_win();
         } else if (key_pressed(J_SELECT)) {
-            about_screen();
+            conf_screen();
             splash_win();
         } else if (key_pressed(J_START)) {
             if ((key_debug() == 0) && (!(conf_get()->debug_flags & DBG_MENU))) {
                         snd_music(debug_special_value - 1);
                     }
                     snd_note_off();
-                } else if (switch_special && (debug_menu_index == 3)) {
+                } else if ((switch_special || (!sample_running())) && (debug_menu_index == 3)) {
                     if (debug_special_value > 0) {
                         sample_play(debug_special_value - 1);
                     }

src/main.h

 #include <gbdk/platform.h>
 #include <stdint.h>
 
-#define DEBUG_ENTRY_NAME_LEN 8
+#define ENTRY_NAME_LEN 8
+
+struct conf_entry {
+    char name[ENTRY_NAME_LEN + 1];
+    uint8_t *var;
+    uint8_t max;
+};
 
 struct debug_entry {
-    char name[DEBUG_ENTRY_NAME_LEN + 1];
+    char name[ENTRY_NAME_LEN + 1];
     enum debug_flag flag;
     uint8_t max;
 };
 
 BANKREF_EXTERN(main)
 
+#define CONF_ENTRY_COUNT 2
+extern const struct conf_entry conf_entries[CONF_ENTRY_COUNT];
+
 extern uint8_t debug_menu_index;
 extern uint8_t debug_special_value;
 

src/maps.c

     str_center("Debug Menu", 0, 0);
 
     for (uint8_t i = 0; (i < DEBUG_ENTRY_COUNT) && (i < 7); i++) {
-        char name_buff[DEBUG_ENTRY_NAME_LEN + 2 + 1] = {0};
+        char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
 
         START_ROM_BANK(BANK(main));
-            strncpy(name_buff, debug_entries[i].name, DEBUG_ENTRY_NAME_LEN + 1);
+            strncpy(name_buff, debug_entries[i].name, ENTRY_NAME_LEN + 1);
 
             uint8_t n_len = strlen(name_buff);
             name_buff[n_len] = ' ';
     }
 }
 
+void win_conf(void) NONBANKED {
+    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));
+
+    // TODO paging when more options added
+
+    str_center("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};
+
+        START_ROM_BANK(BANK(main));
+            strncpy(name_buff, conf_entries[i].name, ENTRY_NAME_LEN + 1);
+
+            uint8_t n_len = strlen(name_buff);
+            name_buff[n_len] = ' ';
+            if (*conf_entries[i].var < 10) {
+                name_buff[n_len + 1] = *conf_entries[i].var + '0';
+            } else {
+                name_buff[n_len + 1] = *conf_entries[i].var - 10 + 'A';
+            }
+            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);
+    }
+}
+
 void win_name(int32_t score) NONBANKED {
     set_win_based(0, 0,
                   title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,

src/maps.h

 void win_score_clear(uint8_t is_black);
 void win_score_draw(struct scores score, uint8_t off, uint8_t is_black);
 void win_about(void);
+void win_conf(void);
 void win_debug(void);
 void win_name(int32_t score);
 void win_name_draw(uint16_t name, uint8_t is_black, uint8_t pos);

src/sample.c

 static volatile uint8_t play_bank = 1;
 static volatile const uint8_t *play_sample = 0;
 static volatile uint16_t play_length = 0;
+static volatile uint8_t playing = 0;
+
+uint8_t snd_vol_sfx = 0x00;
 
 struct sfxs {
     uint8_t bank;
         play_bank = sfxs[sfx].bank;
         play_sample = sfxs[sfx].smp;
         play_length = sfxs[sfx].len;
+        playing = 1;
     }
 }
 
+uint8_t sample_running(void) BANKED {
+    return playing;
+}
+
 void sample_isr(void) NONBANKED NAKED {
     __asm
     ld hl, #_play_length    ; something left to play?
     ld a, (hl+)
     or (hl)
-    ret z
+    jp z, done
 
     ld hl, #_play_sample
     ld a, (hl+)
     ldh (_NR30_REG), a
     ld a, #0xFE             ; length of wave
     ldh (_NR31_REG), a
-    ld a, #0x20             ; volume
+    ld a, (_snd_vol_sfx)    ; volume
+    swap a                  ; shift vol to upper bits
     ldh (_NR32_REG), a
     xor a                   ; low freq bits are zero
     ldh (_NR33_REG), a
     sbc #0
     ld (hl), a
     ret
+
+done:
+    ld a, #0
+    ld (_playing), a
+    ret z
     __endasm;
 }

src/sample.h

 };
 
 void sample_play(enum SFXS sfx) BANKED;
+uint8_t sample_running(void) BANKED;
 
 void sample_isr(void);
 
 BANKREF_EXTERN(sample)
 
+extern uint8_t snd_vol_sfx;
+
 #endif // __SAMPLE_H__

src/sound.c

 static volatile uint16_t off = 0;
 static volatile uint16_t last_t = 0;
 
+uint8_t snd_vol_music = 0x00;
+
 struct snds {
     uint8_t bank;
     struct music const * snd;
         END_ROM_BANK();
 
         NR11_REG = 0x80 | 0x3F; // 50% duty, shortest initial length
-        NR12_REG = 0x70; // half volume, no change
+        NR12_REG = (snd_vol_music << 4) | 0x00; // given volume, no change
         NR13_REG = freq & 0xFF; // given frequency
         NR14_REG = 0x80 | ((freq >> 8) & 0x07); // trigger, upper freq bits
     } else {
         NR11_REG = 0x80 | 0x3F; // 50% duty, shortest initial length
-        NR12_REG = 0x10; // 'lowest' volume without pop, no change
+        NR12_REG = 0x00; // silence
         NR13_REG = 0x00; // lowest frequency
         NR14_REG = 0x80 | 0x40 | 0x00; // trigger, enable length, upper freq bits
     }
         END_ROM_BANK();
 
         NR21_REG = 0x80 | 0x3F; // 50% duty, shortest initial length
-        NR22_REG = 0x70; // half volume, no change
+        NR22_REG = (snd_vol_music << 4) | 0x00; // given volume, no change
         NR23_REG = freq & 0xFF; // given frequency
         NR24_REG = 0x80 | ((freq >> 8) & 0x07); // trigger, upper freq bits
     } else {
         NR21_REG = 0x80 | 0x3F; // 50% duty, shortest initial length
-        NR22_REG = 0x10; // 'lowest' volume without pop, no change
+        NR22_REG = 0x00; // silence
         NR23_REG = 0x00; // lowest frequency
         NR24_REG = 0x80 | 0x40 | 0x00; // trigger, enable length, upper freq bits
     }

src/sound.h

 
 BANKREF_EXTERN(sound)
 
+extern uint8_t snd_vol_music;
+
 #endif // __SOUND_H__