start work on mirroring background on scroll (still disabled)

src/config.h

     DBG_MENU = (1 << 0),
     DBG_MARKER = (1 << 1),
     DBG_GOD_MODE = (1 << 2),
-    DBG_CLEAR_SCORE = (1 << 3),
-    DBG_ZERO_SCORE = (1 << 4),
+    DBG_NO_OBJ = (1 << 3),
+
+    DBG_CLEAR_SCORE = (1 << 6),
+    DBG_ZERO_SCORE = (1 << 7),
 };
 
 struct config {

src/game.c

 #define SPEED_MAX_ACC_DIAG 16
 #define SPEED_MAX_IDLE 16
 
-#define POS_SCALE_BG 6
-#define POS_MASK_BG 0x3FFF
-
 #define POWER_MAX 0x1FF
 #define POWER_SHIFT 1
 
     SHOW_SPRITES;
     SPRITES_8x8;
 
-    int16_t pos_x = 0;
-    int16_t pos_y = 0;
     int16_t spd_x = 0;
     int16_t spd_y = 0;
     enum SPRITE_ROT rot = 0;
     int32_t score = 0;
 
     obj_init();
-    obj_spawn();
+
+    if (!(conf_get()->debug_flags & DBG_NO_OBJ)) {
+        obj_spawn();
+    }
 
     win_init(0);
     uint8_t x_off = win_game_draw(score);
             snd_music(SND_GAME);
         }
 
-        pos_x = (pos_x + spd_x) & POS_MASK_BG;
-        pos_y = (pos_y + spd_y) & POS_MASK_BG;
-        move_bkg(pos_x >> POS_SCALE_BG, pos_y >> POS_SCALE_BG);
+        map_move(spd_x, spd_y);
 
         uint8_t hiwater = SPR_NUM_START;
-
         status(health >> HEALTH_SHIFT, power >> POWER_SHIFT, &hiwater);
 
         if (conf_get()->debug_flags & DBG_MARKER) {
 
         spr_ship(rot, acc & (ACC_X | ACC_Y), &hiwater);
 
-        int16_t damage = obj_do(&spd_x, &spd_y, &score, &hiwater, 0);
+        int16_t damage = obj_do(&spd_x, &spd_y, &score, &hiwater,
+                                (conf_get()->debug_flags & DBG_NO_OBJ) ? 1 : 0);
         if (damage > 0) {
             if (conf_get()->debug_flags & DBG_GOD_MODE) {
                 damage = 0;

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 = 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
+    { .name = "no-spawn", .flag = DBG_NO_OBJ,      .max = 1 }, // 2
+    { .name = "music",    .flag = DBG_NONE,        .max = SND_COUNT }, // 3
+    { .name = "sfx-test", .flag = DBG_NONE,        .max = SFX_COUNT }, // 4
+    { .name = "cl score", .flag = DBG_CLEAR_SCORE, .max = 1 }, // 5
+    { .name = "0 scores", .flag = DBG_ZERO_SCORE,  .max = 1 }, // 6
 };
 
 static void highscore(uint8_t is_black) NONBANKED {
     disable_interrupts();
     DISPLAY_OFF;
     map_title();
-    move_bkg(0, 0);
     SHOW_BKG;
     spr_init_pal();
     SHOW_SPRITES;
                     snd_music(SND_MENU);
                 }
 
-                if (switch_special && (debug_menu_index == 2)) {
+                if (switch_special && (debug_menu_index == 3)) {
                     snd_music_off();
                     if (debug_special_value > 0) {
                         snd_music(debug_special_value - 1);
                     }
                     snd_note_off();
-                } else if ((switch_special || (!sample_running())) && (debug_menu_index == 3)) {
+                } else if ((switch_special || (!sample_running())) && (debug_menu_index == 4)) {
                     if (debug_special_value > 0) {
                         sample_play(debug_special_value - 1);
                     }
     disable_interrupts();
     DISPLAY_OFF;
     map_title();
-    move_bkg(0, 0);
     SHOW_BKG;
     spr_init_pal();
     SHOW_SPRITES;

src/main.h

 extern uint8_t debug_menu_index;
 extern uint8_t debug_special_value;
 
-#define DEBUG_ENTRY_COUNT 6
+#define DEBUG_ENTRY_COUNT 7
 extern const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT];
 
 #endif // __MAIN_H__

src/maps.c

 #include "banks.h"
 #include "title_map.h"
 #include "bg_map.h"
+#include "util.h"
 #include "maps.h"
 
+#define POS_SCALE_BG 6
+
+// define this to disable mirrored map scaling support
+#define WRAP_BG // TODO
+
+#define bg_map_mapWidth (bg_map_WIDTH / bg_map_TILE_W)
+#define bg_map_mapHeight (bg_map_HEIGHT / bg_map_TILE_H)
+
+#define camera_max_x ((bg_map_mapWidth - DEVICE_SCREEN_WIDTH) * 8)
+#define camera_max_y ((bg_map_mapHeight - DEVICE_SCREEN_HEIGHT) * 8)
+
+#define set_bkg_sub_attr(x, y, w, h, attr, map_w) \
+    if (attr)                                     \
+        set_bkg_submap_attributes(x, y, w, h, attr, map_w)
+
+#define set_bkg_sub(x, y, w, h, map, attr, map_w) \
+    set_bkg_submap(x, y, w, h, map, map_w);       \
+    set_bkg_sub_attr(x, y, w, h, attr, map_w)
+
+// current unscaled ship position
+static uint16_t abs_x, abs_y;
+
+// current and old positions of the camera in pixels
+static uint16_t camera_x, camera_y, old_camera_x, old_camera_y;
+
+// current and old position of the map in tiles
+static uint8_t map_pos_x, map_pos_y, old_map_pos_x, old_map_pos_y;
+
 void map_title(void) NONBANKED {
     START_ROM_BANK(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);
+
         if (title_map_MAP_ATTRIBUTES != NULL) {
             set_bkg_attributes(0, 0,
-                               title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
+                               title_map_WIDTH / title_map_TILE_W,
+                               title_map_HEIGHT / title_map_TILE_H,
                                title_map_MAP_ATTRIBUTES);
         } else {
             VBK_REG = VBK_ATTRIBUTES;
             fill_bkg_rect(0, 0,
-                          title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
+                          title_map_WIDTH / title_map_TILE_W,
+                          title_map_HEIGHT / title_map_TILE_H,
                           0x00);
             VBK_REG = VBK_TILES;
         }
-        set_bkg_tiles(0, 0, title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H, title_map_map);
+
+        set_bkg_tiles(0, 0,
+                      title_map_WIDTH / title_map_TILE_W,
+                      title_map_HEIGHT / title_map_TILE_H,
+                      title_map_map);
+
     END_ROM_BANK();
+
+    move_bkg(0, 0);
 }
 
 void map_game(void) NONBANKED {
     START_ROM_BANK(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);
+
+#ifdef WRAP_BG
+
         if (bg_map_MAP_ATTRIBUTES != NULL) {
             set_bkg_attributes(0, 0,
                                bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H,
             VBK_REG = VBK_TILES;
         }
         set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
+
+#else // WRAP_BG
+
+        abs_x = 0;
+        abs_y = 0;
+
+        // Initial camera position in pixels set here.
+        camera_x = 0;
+        camera_y = 0;
+
+        // Enforce map limits on initial camera position
+        if (camera_x > camera_max_x) camera_x = camera_max_x;
+        if (camera_y > camera_max_y) camera_y = camera_max_y;
+        old_camera_x = camera_x; old_camera_y = camera_y;
+
+        map_pos_x = camera_x >> 3;
+        map_pos_y = camera_y >> 3;
+        old_map_pos_x = old_map_pos_y = 255;
+
+        move_bkg(camera_x, camera_y);
+
+        // Draw the initial map view for the whole screen
+        set_bkg_sub(map_pos_x, map_pos_y,
+                    MIN(DEVICE_SCREEN_WIDTH + 1u, bg_map_mapWidth - map_pos_x),
+                    MIN(DEVICE_SCREEN_HEIGHT + 1u, bg_map_mapHeight - map_pos_y),
+                    bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
+
+#endif // WRAP_BG
+
     END_ROM_BANK();
 }
+
+void map_move(int16_t delta_x, int16_t delta_y) NONBANKED {
+    abs_x += delta_x;
+    abs_y += delta_y;
+
+    camera_x = abs_x >> POS_SCALE_BG;
+    camera_y = abs_y >> POS_SCALE_BG;
+
+    // update hardware scroll position
+    move_bkg(camera_x, camera_y);
+
+#ifndef WRAP_BG
+
+    map_pos_y = (uint8_t)(camera_y >> 3u);
+    map_pos_x = (uint8_t)(camera_x >> 3u);
+
+    START_ROM_BANK(BANK(bg_map));
+
+        // up or down
+        if (map_pos_y != old_map_pos_y) {
+            if (camera_y < old_camera_y) {
+                set_bkg_sub(map_pos_x, map_pos_y,
+                            MIN(DEVICE_SCREEN_WIDTH + 1, bg_map_mapWidth-map_pos_x), 1,
+                            bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
+            } else if ((bg_map_mapHeight - DEVICE_SCREEN_HEIGHT) > map_pos_y) {
+                set_bkg_sub(map_pos_x, map_pos_y + DEVICE_SCREEN_HEIGHT,
+                            MIN(DEVICE_SCREEN_WIDTH + 1, bg_map_mapWidth-map_pos_x), 1,
+                            bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
+            }
+            old_map_pos_y = map_pos_y;
+        }
+
+        // left or right
+        if (map_pos_x != old_map_pos_x) {
+            if (camera_x < old_camera_x) {
+                set_bkg_sub(map_pos_x, map_pos_y,
+                            1, MIN(DEVICE_SCREEN_HEIGHT + 1, bg_map_mapHeight - map_pos_y),
+                            bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
+            } else if ((bg_map_mapWidth - DEVICE_SCREEN_WIDTH) > map_pos_x) {
+                set_bkg_sub(map_pos_x + DEVICE_SCREEN_WIDTH, map_pos_y,
+                            1, MIN(DEVICE_SCREEN_HEIGHT + 1, bg_map_mapHeight - map_pos_y),
+                            bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
+            }
+            old_map_pos_x = map_pos_x;
+        }
+
+    END_ROM_BANK();
+
+    // set old camera position to current camera position
+    old_camera_x = camera_x;
+    old_camera_y = camera_y;
+
+#endif // ! WRAP_BG
+}

src/maps.h

 #ifndef __MAPS_H__
 #define __MAPS_H__
 
+#include <stdint.h>
+
 void map_title(void);
+
 void map_game(void);
+void map_move(int16_t delta_x, int16_t delta_y);
 
 #endif // __MAPS_H__

src/sound.c

 #include "banks.h"
 #include "config.h"
 #include "timer.h"
+#include "util.h"
 #include "sound_menu.h"
 #include "sound_game.h"
 #include "sound_over.h"
 };
 
 #define CALL_FREQ_HZ 256
-#define MIN(x, y) ((x < y) ? x : y)
-#define MAX(x, y) ((x > y) ? x : y)
 
 static void play_note(enum notes note) NONBANKED {
     if (note < SILENCE) {

src/util.h

+/*
+ * util.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 __UTIL_H__
+#define __UTIL_H__
+
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+#define MAX(x, y) (((x) > (y)) ? (x) : (y))
+
+#endif // __UTIL_H__

src/window.c

 
 #include <gbdk/platform.h>
 #include <string.h>
+#include <assert.h>
 
 #include "banks.h"
 #include "config.h"
                   title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
 
     // TODO paging when more options added
+    static_assert(DEBUG_ENTRY_COUNT <= 8, "too many debug menu entries");
     uint8_t off = (10 - DEBUG_ENTRY_COUNT) / 2;
 
     str_center("Debug Menu", 0, 0);
 
-    for (uint8_t i = 0; (i < DEBUG_ENTRY_COUNT) && (i < 7); i++) {
+    for (uint8_t i = 0; (i < DEBUG_ENTRY_COUNT) && (i < 8); i++) {
         char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
         uint8_t n_len = get_debug(name_buff, i);
         str(name_buff, (LINE_WIDTH - n_len) * 2, (i * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
                   title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
 
     // TODO paging when more options added
+    static_assert(CONF_ENTRY_COUNT <= 8, "too many conf menu entries");
     uint8_t off = (10 - CONF_ENTRY_COUNT) / 2;
 
     str_center("Conf Menu", 0, 0);
 
-    for (uint8_t i = 0; (i < CONF_ENTRY_COUNT) && (i < 7); i++) {
+    for (uint8_t i = 0; (i < CONF_ENTRY_COUNT) && (i < 8); i++) {
         char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
         uint8_t n_len = get_conf(name_buff, i);
         str(name_buff, (LINE_WIDTH - n_len) * 2, (i * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);