add debug flags and menu

src/game.c

 #include <rand.h>
 #include <stdint.h>
 
+#include "asm/types.h"
 #include "gb/gb.h"
 #include "maps.h"
 #include "obj.h"
 #include "sprites.h"
 #include "sound.h"
 #include "input.h"
+#include "main.h"
 #include "game.h"
 
 enum ACCELERATION {
 #define POWER_OFFSET_Y 16
 #define PAUSE_BLINK_FRAMES 32
 
-static uint8_t pause_screen(void) {
+static uint8_t pause_screen(void) NONBANKED {
     uint8_t n = 0;
 
     while (1) {
 
                 case ROT_45:
                     spd_y -= SPEED_INC;
-                    if (spd_y < -SPEED_MAX_ACC) spd_y = -SPEED_MAX_ACC;
+                    if (spd_y < -SPEED_MAX_ACC_DIAG) spd_y += SPEED_DEC;
                     acc |= ACC_Y;
                     spd_x += SPEED_INC;
-                    if (spd_x > SPEED_MAX_ACC) spd_x = SPEED_MAX_ACC;
+                    if (spd_x > SPEED_MAX_ACC_DIAG) spd_x -= SPEED_DEC;
                     acc |= ACC_X;
                     break;
 
 
                 case ROT_135:
                     spd_x += SPEED_INC;
-                    if (spd_x > SPEED_MAX_ACC) spd_x = SPEED_MAX_ACC;
+                    if (spd_x > SPEED_MAX_ACC_DIAG) spd_x -= SPEED_DEC;
                     acc |= ACC_X;
                     spd_y += SPEED_INC;
-                    if (spd_y > SPEED_MAX_ACC) spd_y = SPEED_MAX_ACC;
+                    if (spd_y > SPEED_MAX_ACC_DIAG) spd_y -= SPEED_DEC;
                     acc |= ACC_Y;
                     break;
 
 
                 case ROT_225:
                     spd_y += SPEED_INC;
-                    if (spd_y > SPEED_MAX_ACC) spd_y = SPEED_MAX_ACC;
+                    if (spd_y > SPEED_MAX_ACC_DIAG) spd_y -= SPEED_DEC;
                     acc |= ACC_Y;
                     spd_x -= SPEED_INC;
-                    if (spd_x < -SPEED_MAX_ACC) spd_x = -SPEED_MAX_ACC;
+                    if (spd_x < -SPEED_MAX_ACC_DIAG) spd_x += SPEED_DEC;
                     acc |= ACC_X;
                     break;
 
 
                 case ROT_315:
                     spd_x -= SPEED_INC;
-                    if (spd_x < -SPEED_MAX_ACC) spd_x = -SPEED_MAX_ACC;
+                    if (spd_x < -SPEED_MAX_ACC_DIAG) spd_x += SPEED_DEC;
                     acc |= ACC_X;
                     spd_y -= SPEED_INC;
-                    if (spd_y < -SPEED_MAX_ACC) spd_y = -SPEED_MAX_ACC;
+                    if (spd_y < -SPEED_MAX_ACC_DIAG) spd_y += SPEED_DEC;
                     acc |= ACC_Y;
                     break;
 
 
         uint8_t hiwater = SPR_NUM_START;
 
-#ifdef DEBUG
-        spr_draw(SPR_DEBUG, FLIP_NONE, 0, 0, 0, &hiwater);
-#endif
+        if (debug_flags & DBG_MARKER) {
+            spr_draw(SPR_DEBUG, FLIP_NONE, 0, 0, 0, &hiwater);
+        }
 
         if (redraw) {
             spr_ship(rot, acc & (ACC_X | ACC_Y), &hiwater);
         int32_t prev_score = score;
         int16_t damage = obj_do(&spd_x, &spd_y, &score, &hiwater);
         if (damage > 0) {
+            if (debug_flags & DBG_GOD_MODE) {
+                damage = 0;
+            }
+
             if (health > damage) {
                 health -= damage;
             } else if (health <= damage) {

src/game.h

 #define SPEED_DEC 1
 
 #define SPEED_MAX_ACC 23
+#define SPEED_MAX_ACC_DIAG 16
 #define SPEED_MAX_IDLE 16
 
 #define POS_SCALE_OBJS 5

src/input.c

 
 static uint8_t joyp = 0;
 static uint8_t old_joyp = 0;
+static int8_t debug_cnt = 0;
+
+BANKREF(input)
+
+static const uint8_t key_debug_sequence[] = {
+    J_UP, J_UP, J_DOWN, J_DOWN,
+    J_LEFT, J_RIGHT, J_LEFT, J_RIGHT,
+    J_B, J_A, /* J_START */
+};
+
+#define DEBUG_SEQUENCE_COUNT (sizeof(key_debug_sequence) / sizeof(key_debug_sequence[0]))
 
 void key_read(void) NONBANKED {
     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;
+        }
+    } else {
+        if (key_pressed(0xFF ^ J_START)) {
+            debug_cnt = 0;
+        }
+    }
 }
 
 uint8_t key_down(uint8_t key) NONBANKED {
 uint8_t key_pressed(uint8_t key) NONBANKED {
     return (joyp ^ old_joyp) & joyp & key;
 }
+
+int8_t key_debug(void) NONBANKED {
+    return DEBUG_SEQUENCE_COUNT - debug_cnt;
+}

src/input.h

 uint8_t key_down(uint8_t key);
 uint8_t key_pressed(uint8_t key);
 
+int8_t key_debug(void);
+
+BANKREF_EXTERN(input)
+
 #endif // __INPUT_H__

src/main.c

  * See <http://www.gnu.org/licenses/>.
  */
 
-#include <gbdk/platform.h>
 #include <gbdk/metasprites.h>
 #include <rand.h>
-#include <stdint.h>
 
 #include "asm/types.h"
 #include "gb/gb.h"
 #include "score.h"
 #include "sgb_border.h"
 #include "border_sgb.h"
+#include "main.h"
+
+#ifdef DEBUG
+enum debug_flag debug_flags = DBG_MENU;
+#else
+enum debug_flag debug_flags = 0;
+#endif
+
+uint8_t debug_menu_index = 0;
+
+BANKREF(main)
+
+const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT] = {
+    { .name = "menu", .flag = DBG_MENU },
+    { .name = "marker", .flag = DBG_MARKER },
+    { .name = "invuln", .flag = DBG_GOD_MODE },
+};
 
 static void highscore(uint8_t is_black) NONBANKED {
     HIDE_WIN;
 static void splash_win(void) NONBANKED {
     HIDE_WIN;
 
-    // initially show the top 1 scores
-    int32_t low = score_lowest(0).score;
-    int32_t high = score_highest(0).score;
+    if (debug_flags & DBG_MENU) {
+        win_debug();
+        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;
+
+        // only show on splash if they fit
+        if ((low >= -99999) && (high <= 99999)) {
+            win_splash_draw(-low, high);
+        }
 
-    // only show on splash if they fit
-    if ((low >= -99999) && (high <= 99999)) {
-        win_splash_draw(-low, high);
+        move_win(MINWNDPOSX, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
     }
 
-    move_win(MINWNDPOSX, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
     SHOW_WIN;
 }
 
         } else if (key_pressed(J_SELECT)) {
             about_screen();
             splash_win();
-        } else if (key_pressed(0xFF)) {
-            break;
+        } else if (key_pressed(J_START)) {
+            if ((key_debug() == 0) && (!(debug_flags & DBG_MENU))) {
+                debug_flags |= DBG_MENU;
+                splash_win();
+            } else {
+                break;
+            }
+        } else {
+            if (debug_flags & DBG_MENU) {
+                if (key_pressed(J_UP)) {
+                    if (debug_menu_index > 0) {
+                        debug_menu_index--;
+                    } else {
+                        debug_menu_index = DEBUG_ENTRY_COUNT - 1;
+                    }
+                    splash_win();
+                } else if (key_pressed(J_DOWN)) {
+                    if (debug_menu_index < (DEBUG_ENTRY_COUNT - 1)) {
+                        debug_menu_index++;
+                    } else {
+                        debug_menu_index = 0;
+                    }
+                    splash_win();
+                } else if (key_pressed(J_A)) {
+                    SWITCH_ROM(BANK(main));
+                    debug_flags ^= debug_entries[debug_menu_index].flag;
+                    splash_win();
+                }
+            }
         }
 
         uint8_t hiwater = SPR_NUM_START;
-        obj_draw(&hiwater);
+
+        if (!(debug_flags & DBG_MENU)) {
+            obj_draw(&hiwater);
+        }
+
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
 
         vsync();
     }
 }
 
-uint16_t ask_name(int32_t score) NONBANKED {
+static uint16_t ask_name(int32_t score) NONBANKED {
     disable_interrupts();
     DISPLAY_OFF;
     map_title();

src/main.h

+/*
+ * main.h
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
+ * Based on examples from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/blob/develop/gbdk-lib/examples/gb/rand/rand.c
+ *
+ * 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 __MAIN_H__
+#define __MAIN_H__
+
+#include <gbdk/platform.h>
+#include <stdint.h>
+
+enum debug_flag {
+    DBG_MENU = (1 << 0),
+    DBG_MARKER = (1 << 1),
+    DBG_GOD_MODE = (1 << 2),
+
+    DBG_FLAG_COUNT = 2
+};
+
+#define DEBUG_ENTRY_NAME_LEN 8
+
+struct debug_entry {
+    char name[DEBUG_ENTRY_NAME_LEN + 1];
+    enum debug_flag flag;
+};
+
+BANKREF_EXTERN(main)
+
+extern enum debug_flag debug_flags;
+extern uint8_t debug_menu_index;
+
+#define DEBUG_ENTRY_COUNT 3
+
+extern const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT];
+
+#endif // __MAIN_H__

src/maps.c

 #include "numbers_fnt.h"
 #include "text_fnt.h"
 #include "git.h"
+#include "main.h"
 #include "maps.h"
 
 #define MAX_DIGITS 7
     str(__TIME__, 4, 16, 0);
 }
 
+void win_debug(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("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;
+
+        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_debug(void);
 void win_name(int32_t score);
 void win_name_draw(uint16_t name, uint8_t is_black, uint8_t pos);
 uint8_t win_game_draw(int32_t score);

src/obj.c

 #define SCORE_SMALL 5
 #define SCORE_LARGE 10
 
+#define DESPAWN_RANGE (250 << POS_SCALE_OBJS)
+
 struct obj {
     uint8_t active;
     enum SPRITES sprite;
         // handle collision
         switch (objs[i].sprite) {
             case SPR_DARK:
+                if ((abs_off_x >= DESPAWN_RANGE) || (abs_off_y >= DESPAWN_RANGE)) {
+                    // TODO find new (random) position
+                    //objs[i].active = 0;
+                }
+
                 if ((abs_off_x <= GRAVITY_RANGE) && (abs_off_y <= GRAVITY_RANGE)) {
                     if (objs[i].off_x > 0) {
                         *spd_off_x += (GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
                 break;
 
             case SPR_LIGHT:
+                if ((abs_off_x >= DESPAWN_RANGE) || (abs_off_y >= DESPAWN_RANGE)) {
+                    // TODO find new (random) position
+                    //objs[i].active = 0;
+                }
+
                 if ((abs_off_x <= GRAVITY_RANGE) && (abs_off_y <= GRAVITY_RANGE)) {
                     if (objs[i].off_x > 0) {
                         *spd_off_x -= (GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
                 break;
 
             case SPR_SHOT_DARK:
+                if ((abs_off_x >= DESPAWN_RANGE) || (abs_off_y >= DESPAWN_RANGE)) {
+                    // TODO find new (random) position
+                    //objs[i].active = 0;
+                }
+
                 if ((abs_off_x <= PICKUP_SMALL_RANGE) && (abs_off_y <= PICKUP_SMALL_RANGE)) {
                     (*score) -= SCORE_SMALL;
                     objs[i].active = 0;
                 break;
 
             case SPR_SHOT_LIGHT:
+                if ((abs_off_x >= DESPAWN_RANGE) || (abs_off_y >= DESPAWN_RANGE)) {
+                    // TODO find new (random) position
+                    //objs[i].active = 0;
+                }
+
                 if ((abs_off_x <= PICKUP_SMALL_RANGE) && (abs_off_y <= PICKUP_SMALL_RANGE)) {
                     (*score) += SCORE_SMALL;
                     objs[i].active = 0;

src/score.ba0.c

 
 #define NAME(a, b, c) (((uint16_t)(a - 'a') << 10) | ((uint16_t)(b - 'a') << 5) | (uint16_t)(c - 'a'))
 
-const struct scores initial_scores[SCORE_NUM * 2] = {
+static const struct scores initial_scores[SCORE_NUM * 2] = {
     //{ .name = NAME('a', 'd', 'z'), .score = 10000 },
     //{ .name = NAME('c', 'a', 'n'), .score = 7500 },
     //{ .name = NAME('i', 'm', 'y'), .score = 5000 },