add settings and move with score to config in sram

src/config.ba0.c

+/*
+ * config.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 <stddef.h>
+#undef NULL
+
+#include "banks.h"
+#include "score.h"
+#include "config.h"
+
+struct config_mem {
+    struct config config;
+    struct scores scores[SCORE_NUM * 2];
+
+    uint32_t crc; // needs to be last
+};
+
+static struct config_mem mem;
+
+BANKREF(config)
+
+static uint32_t calc_crc(void) {
+    const uint8_t *d = (const uint8_t *)mem;
+
+    uint32_t c = 0xFFFFFFFF;
+    for (size_t i = 0; i < offsetof(struct config_mem, crc); 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;
+}
+
+void conf_init(void) BANKED {
+    ENABLE_RAM;
+    SWITCH_RAM(0);
+
+    if (calc_crc() != mem.crc) {
+        mem.config.debug_flags = 0;
+        mem.config.sfx_vol = 0x0F;
+        mem.config.music_vol = 0x07;
+        score_reset();
+    }
+}
+
+void conf_write_crc(void) BANKED {
+    mem.crc = calc_crc();
+}
+
+struct scores *conf_scores(void) BANKED {
+    return mem.scores;
+}
+
+struct config *conf_get(void) BANKED {
+    return &mem.config;
+}

src/config.h

+/*
+ * config.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 __CONFIG_H__
+#define __CONFIG_H__
+
+#include <gbdk/platform.h>
+#include <gbdk/emu_debug.h>
+#include <stdint.h>
+
+#include "score.h"
+
+enum debug_flag {
+    DBG_NONE = 0,
+
+    DBG_MENU = (1 << 0),
+    DBG_MARKER = (1 << 1),
+    DBG_GOD_MODE = (1 << 2),
+    DBG_CLEAR_SCORE = (1 << 3),
+    DBG_ZERO_SCORE = (1 << 4),
+};
+
+struct config {
+    enum debug_flag debug_flags;
+    uint8_t sfx_vol;
+    uint8_t music_vol;
+};
+
+void conf_init(void) BANKED;
+void conf_write_crc(void) BANKED;
+struct scores *conf_scores(void) BANKED;
+struct config *conf_get(void) BANKED;
+
+BANKREF_EXTERN(config)
+
+#endif // __CONFIG_H__

src/game.c

 #include <rand.h>
 #include <stdint.h>
 
+#include "config.h"
 #include "maps.h"
 #include "obj.h"
 #include "sprites.h"
 
         uint8_t hiwater = SPR_NUM_START;
 
-        if (debug_flags & DBG_MARKER) {
+        if (conf_get()->debug_flags & DBG_MARKER) {
             spr_draw(SPR_DEBUG, FLIP_NONE, 0, 0, 0, &hiwater);
             spr_draw(SPR_DEBUG_LARGE, FLIP_NONE, 0, 0, 0, &hiwater);
         }
 
         int16_t damage = obj_do(&spd_x, &spd_y, &score, &hiwater, 0);
         if (damage > 0) {
-            if (debug_flags & DBG_GOD_MODE) {
+            if (conf_get()->debug_flags & DBG_GOD_MODE) {
                 damage = 0;
             }
 

src/main.c

 #include <rand.h>
 
 #include "banks.h"
+#include "config.h"
 #include "maps.h"
 #include "obj.h"
 #include "sprites.h"
 #include "sample.h"
 #include "main.h"
 
-#ifdef DEBUG
-enum debug_flag debug_flags = DBG_MENU | DBG_MARKER;
-#else
-enum debug_flag debug_flags = 0;
-#endif
-
 uint8_t debug_menu_index = 0;
 uint8_t debug_special_value = 0;
 
     { .name = "music",    .flag = DBG_NONE,        .max = 3 }, // 2
     { .name = "sfx-test", .flag = DBG_NONE,        .max = 3 }, // 3
     { .name = "cl score", .flag = DBG_CLEAR_SCORE, .max = 1 }, // 4
+    { .name = "0 scores", .flag = DBG_ZERO_SCORE,  .max = 1 }, // 5
 };
 
 static void highscore(uint8_t is_black) NONBANKED {
 static void splash_win(void) NONBANKED {
     HIDE_WIN;
 
-    if (debug_flags & DBG_MENU) {
+    if (conf_get()->debug_flags & DBG_MENU) {
         win_debug();
         move_win(MINWNDPOSX, MINWNDPOSY);
     } else {
     DISPLAY_ON;
     enable_interrupts();
 
-    if (!(debug_flags & DBG_MENU)) {
+    if (!(conf_get()->debug_flags & DBG_MENU)) {
         snd_menu_music();
     }
 
     while (1) {
         key_read();
 
-        if (key_pressed(J_LEFT) && (!(debug_flags & DBG_MENU))) {
+        if (key_pressed(J_LEFT) && (!(conf_get()->debug_flags & DBG_MENU))) {
             highscore(1);
             splash_win();
-        } else if (key_pressed(J_RIGHT) && (!(debug_flags & DBG_MENU))) {
+        } else if (key_pressed(J_RIGHT) && (!(conf_get()->debug_flags & DBG_MENU))) {
             highscore(0);
             splash_win();
         } else if (key_pressed(J_SELECT)) {
             about_screen();
             splash_win();
         } else if (key_pressed(J_START)) {
-            if ((key_debug() == 0) && (!(debug_flags & DBG_MENU))) {
-                debug_flags |= DBG_MENU;
+            if ((key_debug() == 0) && (!(conf_get()->debug_flags & DBG_MENU))) {
+                conf_get()->debug_flags |= DBG_MENU;
                 snd_music_off();
                 snd_note_off();
+                conf_write_crc();
                 splash_win();
             } else {
                 break;
             }
         } else {
-            if (debug_flags & DBG_MENU) {
+            if (conf_get()->debug_flags & DBG_MENU) {
                 // do it here so you quickly see the flag going to 1 and back to 0
-                if (debug_flags & DBG_CLEAR_SCORE) {
+                if (conf_get()->debug_flags & DBG_CLEAR_SCORE) {
                     score_reset();
-                    debug_flags &= ~DBG_CLEAR_SCORE;
+                    conf_get()->debug_flags &= ~DBG_CLEAR_SCORE;
+                    conf_write_crc();
+                    splash_win();
+                }
+                if (conf_get()->debug_flags & DBG_ZERO_SCORE) {
+                    score_zero();
+                    conf_get()->debug_flags &= ~DBG_ZERO_SCORE;
+                    conf_write_crc();
                     splash_win();
                 }
 
                 } else if (key_pressed(J_LEFT)) {
                     START_ROM_BANK(BANK(main));
                         if (debug_entries[debug_menu_index].flag != DBG_NONE) {
-                            debug_flags ^= debug_entries[debug_menu_index].flag;
+                            conf_get()->debug_flags ^= debug_entries[debug_menu_index].flag;
+                            conf_write_crc();
                         } else {
                             if (debug_special_value > 0) {
                                 debug_special_value--;
                 } else if (key_pressed(J_RIGHT)) {
                     START_ROM_BANK(BANK(main));
                         if (debug_entries[debug_menu_index].flag != DBG_NONE) {
-                            debug_flags ^= debug_entries[debug_menu_index].flag;
+                            conf_get()->debug_flags ^= debug_entries[debug_menu_index].flag;
+                            conf_write_crc();
                         } else {
                             if (debug_special_value < debug_entries[debug_menu_index].max) {
                                 debug_special_value++;
                 } else if (key_pressed(J_A)) {
                     START_ROM_BANK(BANK(main));
                         if (debug_entries[debug_menu_index].flag != DBG_NONE) {
-                            debug_flags ^= debug_entries[debug_menu_index].flag;
+                            conf_get()->debug_flags ^= debug_entries[debug_menu_index].flag;
+                            conf_write_crc();
                         } else {
                             if (debug_special_value < debug_entries[debug_menu_index].max) {
                                 debug_special_value++;
                     END_ROM_BANK();
                     splash_win();
                 } else if (key_pressed(J_B)) {
-                    debug_flags &= ~DBG_MENU;
+                    conf_get()->debug_flags &= ~DBG_MENU;
                     debug_special_value = 0;
+                    conf_write_crc();
                     splash_win();
                     snd_menu_music();
                 }
 
         uint8_t hiwater = SPR_NUM_START;
 
-        if (!(debug_flags & DBG_MENU)) {
-            if (debug_flags & DBG_MARKER) {
+        if (!(conf_get()->debug_flags & DBG_MENU)) {
+            if (conf_get()->debug_flags & DBG_MARKER) {
                 spr_draw(SPR_DEBUG, FLIP_NONE, 0, -10, 0, &hiwater);
                 spr_draw(SPR_SHOT_LIGHT, FLIP_NONE, 0, -10, 0, &hiwater);
 
         cpu_fast();
     }
 
+    conf_init();
     timer_init();
     spr_init();
     snd_init();
     while (1) {
         int32_t score = game();
 
-        if ((!(debug_flags & DBG_GOD_MODE)) && (score != 0) && score_ranking(score)) {
+        if ((!(conf_get()->debug_flags & DBG_GOD_MODE)) && (score != 0) && score_ranking(score)) {
             uint16_t name = ask_name(score);
             struct scores s = { .name = name, .score = score };
             score_add(s);

src/main.h

 #include <gbdk/platform.h>
 #include <stdint.h>
 
-enum debug_flag {
-    DBG_NONE = 0,
-
-    DBG_MENU = (1 << 0),
-    DBG_MARKER = (1 << 1),
-    DBG_GOD_MODE = (1 << 2),
-    DBG_CLEAR_SCORE = (1 << 3),
-};
-
 #define DEBUG_ENTRY_NAME_LEN 8
 
 struct debug_entry {
 
 BANKREF_EXTERN(main)
 
-extern enum debug_flag debug_flags;
 extern uint8_t debug_menu_index;
 extern uint8_t debug_special_value;
 
-#define DEBUG_ENTRY_COUNT 5
+#define DEBUG_ENTRY_COUNT 6
 extern const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT];
 
 #endif // __MAIN_H__

src/maps.c

 #include <string.h>
 
 #include "banks.h"
+#include "config.h"
 #include "score.h"
 #include "title_map.h"
 #include "bg_map.h"
                     name_buff[n_len + 1] = '0';
                 }
             } else {
-                name_buff[n_len + 1] = (debug_flags & debug_entries[i].flag) ? '1' : '0';
+                name_buff[n_len + 1] = (conf_get()->debug_flags & debug_entries[i].flag) ? '1' : '0';
             }
             name_buff[n_len + 2] = '\0';
             n_len += 2;

src/score.ba0.c → src/score.c

 #include <string.h>
 
 #include "banks.h"
+#include "config.h"
 #include "score.h"
 
-static struct scores scores[SCORE_NUM * 2];
-static uint32_t scores_crc;
-
 BANKREF(score)
 
 #define NAME(a, b, c) (((uint16_t)(a - 'a') << 10) | ((uint16_t)(b - 'a') << 5) | (uint16_t)(c - 'a'))
     return (a << 10) | (b << 5) | c;
 }
 
-static uint32_t calc_crc(void) {
-    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) {
-    return (calc_crc() == scores_crc) ? 1 : 0;
-}
-
-static void score_init(void) NONBANKED {
-    START_ROM_BANK(BANK(score));
-        memcpy(scores, initial_scores, sizeof(scores));
-    END_ROM_BANK();
-}
-
 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) {
+            if (score > conf_scores()[i].score) {
                 return i;
             }
         }
     } else if (score < 0) {
         for (uint8_t i = (SCORE_NUM * 2) - 1; i >= 5; i--) {
-            if (score < scores[i].score) {
+            if (score < conf_scores()[i].score) {
                 return i;
             }
         }
 }
 
 uint8_t score_ranking(int32_t score) BANKED {
-    ENABLE_RAM;
-    SWITCH_RAM(0);
-
-    // 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;
-
-    DISABLE_RAM;
-    return r;
+    return (score_pos(score) < (SCORE_NUM * 2)) ? 1 : 0;
 }
 
 void score_add(struct scores score) BANKED {
-    ENABLE_RAM;
-    SWITCH_RAM(0);
-
-    // initialize score table when data is invalid
-    if (!check_crc()) {
-        score_init();
-        scores_crc = calc_crc();
-    }
-
     uint8_t new = score_pos(score.score);
     if (new < (SCORE_NUM * 2)) {
         // move old scores out of the way
         if ((score.score > 0) && (new < (SCORE_NUM - 1))) {
-            memmove(scores + new + 1, scores + new, sizeof(struct scores) * (SCORE_NUM - 1 - new));
+            memmove(conf_scores() + new + 1, conf_scores() + new, sizeof(struct scores) * (SCORE_NUM - 1 - new));
         } else if ((score.score < 0) && (new > SCORE_NUM)) {
-            memmove(scores + new - 1, scores + new, sizeof(struct scores) * (new - SCORE_NUM));
+            memmove(conf_scores() + new - 1, conf_scores() + new, sizeof(struct scores) * (new - SCORE_NUM));
         }
 
-        scores[new] = score;
-        scores_crc = calc_crc();
-    }
+        conf_scores()[new] = score;
+        conf_write_crc();
 
-    DISABLE_RAM;
+#ifdef DEBUG
+        EMU_printf("%s: add %li at %hu for %x\n",
+                   __func__, (int32_t)score.score,
+                   (uint8_t)new, (uint16_t)score.name);
+#endif // DEBUG
+    }
 }
 
 void score_highest(uint8_t off, struct scores *t) BANKED {
-    ENABLE_RAM;
-    SWITCH_RAM(0);
-
-    // initialize score table when data is invalid
-    if (!check_crc()) {
-        score_init();
-        scores_crc = calc_crc();
-    }
-
     if (off >= SCORE_NUM) {
         off = SCORE_NUM - 1;
     }
-    *t = scores[off];
-
-    DISABLE_RAM;
+    *t = conf_scores()[off];
 }
 
 void score_lowest(uint8_t off, struct scores *t) BANKED {
-    ENABLE_RAM;
-    SWITCH_RAM(0);
-
-    // initialize score table when data is invalid
-    if (!check_crc()) {
-        score_init();
-        scores_crc = calc_crc();
-    }
-
     if (off >= SCORE_NUM) {
         off = SCORE_NUM - 1;
     }
-    *t = scores[(SCORE_NUM * 2) - 1 - off];
+    *t = conf_scores()[(SCORE_NUM * 2) - 1 - off];
+}
 
-    DISABLE_RAM;
+void score_reset(void) NONBANKED {
+    START_ROM_BANK(BANK(score));
+        memcpy(conf_scores(), initial_scores, sizeof(struct scores) * SCORE_NUM * 2);
+    END_ROM_BANK();
+    conf_write_crc();
 }
 
-void score_reset(void) BANKED {
-    ENABLE_RAM;
-    SWITCH_RAM(0);
-    score_init();
-    scores_crc = calc_crc();
-    DISABLE_RAM;
+void score_zero(void) NONBANKED {
+    memset(conf_scores(), 0, sizeof(struct scores) * SCORE_NUM * 2);
+    conf_write_crc();
 }

src/score.h

 void score_add(struct scores score) BANKED;
 void score_highest(uint8_t off, struct scores *t) BANKED;
 void score_lowest(uint8_t off, struct scores *t) BANKED;
-void score_reset(void) BANKED;
+void score_reset(void);
+void score_zero(void);
 
 BANKREF_EXTERN(score)