some dmg optimizations

src/config.ba0.c

 
     if (calc_crc() != mem.crc) {
         mem.config.debug_flags = 0;
-        mem.config.sfx_vol = 0x03;
+        //mem.config.sfx_vol = 0x03;
         mem.config.music_vol = 0x07;
 
         if (_cpu == CGB_TYPE) {
             mem.config.game_bg = 1;
         }
 
+        mem.config.dmg_bg_inv = 1;
+
         score_reset();
     }
 }

src/config.h

     DBG_NO_OBJ      = (1 << 3),
     DBG_NO_FUEL     = (1 << 4),
     DBG_FAST        = (1 << 5),
-    DBG_SHOW_FRAMES = (1 << 6),
-    DBG_SHOW_TIMER  = (1 << 7),
-    DBG_SHOW_STACK  = (1 << 8),
+    DBG_SHOW_FPS    = (1 << 6),
+    DBG_SHOW_FRAMES = (1 << 7),
+    DBG_SHOW_TIMER  = (1 << 8),
+    DBG_SHOW_STACK  = (1 << 9),
 };
 
+#define DBG_OUT_ON (DBG_SHOW_FPS | DBG_SHOW_FRAMES | DBG_SHOW_TIMER | DBG_SHOW_STACK)
+
 struct config {
     enum debug_flag debug_flags;
-    uint8_t sfx_vol;
+    //uint8_t sfx_vol;
     uint8_t music_vol;
     uint8_t game_bg;
+    uint8_t dmg_bg_inv;
 };
 
 void conf_init(void) BANKED;

src/game.c

  * See <http://www.gnu.org/licenses/>.
  */
 
-#include <gbdk/platform.h>
 #include <gbdk/metasprites.h>
 #include <rand.h>
 #include <stdint.h>
 #include "multiplayer.h"
 #include "table_speed_shot.h"
 #include "table_speed_move.h"
+#include "timer.h"
 #include "game.h"
 
 #define BAR_OFFSET_X (4 - 80)
 static int32_t score = 0;
 static uint16_t frame_count = 0;
 
-static uint8_t pause_screen(void) NONBANKED {
+static uint8_t pause_screen(void) {
     snd_music_off();
     snd_note_off();
 
         spr_draw(SPR_PAUSE, FLIP_NONE, 0, 0, (n < (PAUSE_BLINK_FRAMES / 2)) ? 0 : 1, &hiwater);
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
 
+        if ((_cpu == CGB_TYPE) && (conf_get()->debug_flags & DBG_OUT_ON)) {
+            uint8_t x_off = win_game_draw(score, 0);
+            move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
+        }
+
         vsync();
     }
 
     return 0;
 }
 
-static void status(uint8_t health, uint8_t power, uint8_t *hiwater) NONBANKED {
+static void status(uint8_t health, uint8_t power, uint8_t *hiwater) {
     if (health > 0) {
         switch (health >> 6) {
             case 3:
     }
 }
 
-static void show_explosion(uint16_t power) NONBANKED {
+static void show_explosion(uint16_t power) {
     snd_music_off();
     snd_note_off();
     sample_play(SFX_EXPL_SHIP);
     }
 }
 
-void game_get_mp_state(void) NONBANKED {
+void game_get_mp_state(void) BANKED {
     static struct mp_player_state state;
 
     // TODO pass own pos to mp
     mp_new_state(&state);
 }
 
-void game_set_mp_player2(struct mp_player_state *state) NONBANKED {
+void game_set_mp_player2(struct mp_player_state *state) BANKED {
     // TODO update p2 pos
 }
 
-void game_set_mp_shot(struct mp_shot_state *state) NONBANKED {
+void game_set_mp_shot(struct mp_shot_state *state) BANKED {
     // TODO add shot
 }
 
-static inline void get_max_spd(int16_t *max_spd_x, int16_t *max_spd_y) NONBANKED {
+static void get_max_spd(int16_t *max_spd_x, int16_t *max_spd_y) NONBANKED {
     START_ROM_BANK(BANK(table_speed_move)) {
         *max_spd_x = table_speed_move[(rot * table_speed_move_WIDTH) + 0];
         *max_spd_y = -table_speed_move[(rot * table_speed_move_WIDTH) + 1];
     } END_ROM_BANK;
 }
 
-static inline void handle_acceleration(void) NONBANKED {
-    int16_t max_spd_x;
-    int16_t max_spd_y;
-    get_max_spd(&max_spd_x, &max_spd_y);
-
-    if (conf_get()->debug_flags & DBG_FAST) {
-        if (max_spd_x > 0) {
-            max_spd_x = SPEED_MAX_DBG;
-        } else if (max_spd_x < 0) {
-            max_spd_x = -SPEED_MAX_DBG;
-        }
-
-        if (max_spd_y > 0) {
-            max_spd_y = SPEED_MAX_DBG;
-        } else if (max_spd_y < 0) {
-            max_spd_y = -SPEED_MAX_DBG;
-        }
-    }
-
-    if (max_spd_x != 0) {
-        if (max_spd_x > 0) {
-            spd_x += SPEED_INC;
-            if (spd_x > max_spd_x) {
-                spd_x = max_spd_x;
-            }
-        } else {
-            spd_x -= SPEED_INC;
-            if (spd_x < max_spd_x) {
-                spd_x = max_spd_x;
-            }
-        }
+static void get_shot_spd(int16_t *shot_spd_x, int16_t *shot_spd_y) NONBANKED {
+    START_ROM_BANK(BANK(table_speed_shot)) {
+        *shot_spd_x = table_speed_shot[(rot * table_speed_move_WIDTH) + 0];
+        *shot_spd_y = -table_speed_shot[(rot * table_speed_move_WIDTH) + 1];
+    } END_ROM_BANK;
+}
 
-        acc |= ACC_X;
+static uint8_t fps_count = 0;
+static uint16_t prev_fps_start = 0;
+static uint8_t prev_fps = 0;
+
+static inline void calc_fps(void) {
+    fps_count++;
+    uint16_t diff = timer_get() - prev_fps_start;
+    if (diff >= TIMER_HZ) {
+        prev_fps_start = timer_get();
+        prev_fps = fps_count;
+        fps_count = 0;
     }
+}
 
-    if (max_spd_y != 0) {
-        if (max_spd_y > 0) {
-            spd_y += SPEED_INC;
-            if (spd_y > max_spd_y) {
-                spd_y = max_spd_y;
-            }
-        } else {
-            spd_y -= SPEED_INC;
-            if (spd_y < max_spd_y) {
-                spd_y = max_spd_y;
-            }
-        }
+uint8_t game_get_fps(void) BANKED {
+    return prev_fps;
+}
 
-        acc |= ACC_Y;
-    }
+uint16_t game_get_framecount(void) BANKED {
+    return frame_count;
 }
 
-int32_t game(enum GAME_MODE mode) NONBANKED {
+int32_t game(enum GAME_MODE mode) BANKED {
     snd_music_off();
     snd_note_off();
 
         }
 
         if (key_down(J_A) && (power > 0)) {
-            handle_acceleration();
+            int16_t max_spd_x;
+            int16_t max_spd_y;
+            get_max_spd(&max_spd_x, &max_spd_y);
+
+            if (conf_get()->debug_flags & DBG_FAST) {
+                if (max_spd_x > 0) {
+                    max_spd_x = SPEED_MAX_DBG;
+                } else if (max_spd_x < 0) {
+                    max_spd_x = -SPEED_MAX_DBG;
+                }
+
+                if (max_spd_y > 0) {
+                    max_spd_y = SPEED_MAX_DBG;
+                } else if (max_spd_y < 0) {
+                    max_spd_y = -SPEED_MAX_DBG;
+                }
+            }
+
+            if (max_spd_x != 0) {
+                if (max_spd_x > 0) {
+                    spd_x += SPEED_INC;
+                    if (spd_x > max_spd_x) {
+                        spd_x = max_spd_x;
+                    }
+                } else {
+                    spd_x -= SPEED_INC;
+                    if (spd_x < max_spd_x) {
+                        spd_x = max_spd_x;
+                    }
+                }
+
+                acc |= ACC_X;
+            }
+
+            if (max_spd_y != 0) {
+                if (max_spd_y > 0) {
+                    spd_y += SPEED_INC;
+                    if (spd_y > max_spd_y) {
+                        spd_y = max_spd_y;
+                    }
+                } else {
+                    spd_y -= SPEED_INC;
+                    if (spd_y < max_spd_y) {
+                        spd_y = max_spd_y;
+                    }
+                }
+
+                acc |= ACC_Y;
+            }
 
             if (!(conf_get()->debug_flags & DBG_NO_FUEL)) {
                 if (power >= POWER_DEC) {
         if (key_pressed(J_B)) {
             int16_t shot_spd_x;
             int16_t shot_spd_y;
-            START_ROM_BANK(BANK(table_speed_shot)) {
-                shot_spd_x = spd_x + table_speed_shot[(rot * table_speed_shot_WIDTH) + 0];
-                shot_spd_y = spd_y - table_speed_shot[(rot * table_speed_shot_WIDTH) + 1];
-            } END_ROM_BANK;
+            get_shot_spd(&shot_spd_x, &shot_spd_y);
+            shot_spd_x += spd_x;
+            shot_spd_y += spd_y;
 
             // TODO ugly hard-coded offsets?!
             int16_t shot_pos_x = 0, shot_pos_y = 0;
 
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
 
-        if ((score != prev_score) || ((_cpu == CGB_TYPE)
-                && (conf_get()->debug_flags & (DBG_SHOW_FRAMES | DBG_SHOW_TIMER | DBG_SHOW_STACK)))) {
+        if ((score != prev_score)
+                || ((_cpu == CGB_TYPE) && (conf_get()->debug_flags & DBG_OUT_ON))) {
             uint8_t x_off = win_game_draw(score, 0);
             move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
         }
 
-        vsync();
+        calc_fps();
         frame_count++;
+
+        vsync();
     }
 
     return score;
 }
-
-uint16_t game_get_framecount(void) NONBANKED {
-    return frame_count;
-}

src/game.h

 #ifndef __GAME_H__
 #define __GAME_H__
 
+#include <gbdk/platform.h>
 #include <stdint.h>
 #include "multiplayer.h"
 
     GM_MULTI,
 };
 
-void game_get_mp_state(void);
-void game_set_mp_player2(struct mp_player_state *state);
-void game_set_mp_shot(struct mp_shot_state *state);
+void game_get_mp_state(void) BANKED;
+void game_set_mp_player2(struct mp_player_state *state) BANKED;
+void game_set_mp_shot(struct mp_shot_state *state) BANKED;
 
-int32_t game(enum GAME_MODE mode);
-uint16_t game_get_framecount(void);
+uint8_t game_get_fps(void) BANKED;
+uint16_t game_get_framecount(void) BANKED;
+int32_t game(enum GAME_MODE mode) BANKED;
 
 BANKREF_EXTERN(game)
 

src/main.c

 
 static uint8_t anim_frame = 0;
 static uint8_t anim_state = 0;
+static enum HW_TYPE hw_type = HW_UNKNOWN;
 
 BANKREF(main)
 
 const struct conf_entry conf_entries[CONF_ENTRY_COUNT] = {
-    //{ .name = "sfx-vol",  .var = &mem.config.sfx_vol,   .max = 3 },
-    { .name = "musi-vol", .var = &mem.config.music_vol, .max = 15 },
-    { .name = "game-map", .var = &mem.config.game_bg,   .max = 1 },
+  //{ .name = "sfx-vol",  .var = &mem.config.sfx_vol,    .max = 3,  .type = HW_ALL },
+    { .name = "musi-vol", .var = &mem.config.music_vol,  .max = 15, .type = HW_ALL },
+    { .name = "game-map", .var = &mem.config.game_bg,    .max = 1,  .type = HW_ALL },
+    { .name = "invt-map", .var = &mem.config.dmg_bg_inv, .max = 1,  .type = HW_DMG },
 };
 
 const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT] = {
     { .name = "no-spawn", .flag = DBG_NO_OBJ,      .max = 1         }, // 2
     { .name = "no-fuel",  .flag = DBG_NO_FUEL,     .max = 1         }, // 3
     { .name = "fastmove", .flag = DBG_FAST,        .max = 1         }, // 4
-    { .name = "s-frames", .flag = DBG_SHOW_FRAMES, .max = 1         }, // 5
-    { .name = "s-timer",  .flag = DBG_SHOW_TIMER,  .max = 1         }, // 6
-    { .name = "s-stack",  .flag = DBG_SHOW_STACK,  .max = 1         }, // 7
+    { .name = "show-fps", .flag = DBG_SHOW_FPS,    .max = 1         }, // 5
+    { .name = "s-frames", .flag = DBG_SHOW_FRAMES, .max = 1         }, // 6
+    { .name = "sh-timer", .flag = DBG_SHOW_TIMER,  .max = 1         }, // 7
+    { .name = "sh-stack", .flag = DBG_SHOW_STACK,  .max = 1         }, // 8
 
     // keep at end
-    { .name = "music",    .flag = DBG_NONE,        .max = SND_COUNT }, // 8
-    { .name = "sfx-test", .flag = DBG_NONE,        .max = SFX_COUNT }, // 9
-    { .name = "cl score", .flag = DBG_NONE,        .max = 1         }, // 10
-    { .name = "0 scores", .flag = DBG_NONE,        .max = 1         }, // 11
+    { .name = "music",    .flag = DBG_NONE,        .max = SND_COUNT }, // 9
+    { .name = "sfx-test", .flag = DBG_NONE,        .max = SFX_COUNT }, // 10
+    { .name = "cl score", .flag = DBG_NONE,        .max = 1         }, // 11
+    { .name = "0 scores", .flag = DBG_NONE,        .max = 1         }, // 12
 };
 
 #define DEBUG_MENU_MUSIC_INDEX (DEBUG_ENTRY_COUNT - 4)
 #define DEBUG_MENU_CLEAR_INDEX (DEBUG_ENTRY_COUNT - 2)
 #define DEBUG_MENU_ZERO_INDEX  (DEBUG_ENTRY_COUNT - 1)
 
+enum HW_TYPE get_hw(void) BANKED {
+    return hw_type;
+}
+
 static void list_scores(uint8_t is_black) {
     for (uint8_t i = 0; i < SCORE_NUM; i++) {
         struct scores score;
             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;
-            }
+            do {
+                if (debug_menu_index > 0) {
+                    debug_menu_index--;
+                } else {
+                    debug_menu_index = CONF_ENTRY_COUNT - 1;
+                }
+            } while ((conf_entries[debug_menu_index].type != HW_ALL)
+                    && (conf_entries[debug_menu_index].type != hw_type));
             win_conf();
         } else if (key_pressed(J_DOWN)) {
-            if (debug_menu_index < (CONF_ENTRY_COUNT - 1)) {
-                debug_menu_index++;
-            } else {
-                debug_menu_index = 0;
-            }
+            do {
+                if (debug_menu_index < (CONF_ENTRY_COUNT - 1)) {
+                    debug_menu_index++;
+                } else {
+                    debug_menu_index = 0;
+                }
+            } while ((conf_entries[debug_menu_index].type != HW_ALL)
+                    && (conf_entries[debug_menu_index].type != hw_type));
             win_conf();
         } else if (key_pressed(J_LEFT)) {
             if (*conf_entries[debug_menu_index].var > 0) {
 
     DISPLAY_ON;
 
+    if (!sgb_check()) {
+        hw_type = (_cpu == CGB_TYPE) ? HW_GBC : HW_DMG;
+        DISPLAY_OFF;
+        return;
+    } else {
+        hw_type = HW_SGB;
+    }
+
     START_ROM_BANK(BANK(border_sgb)) {
         set_sgb_border((const uint8_t *)border_sgb_tiles, sizeof(border_sgb_tiles),
                        (const uint8_t *)border_sgb_map, sizeof(border_sgb_map),

src/main.h

 #include <stdint.h>
 
 #define ENTRY_NAME_LEN 8
+#define CONF_ENTRY_COUNT 3
+#define DEBUG_ENTRY_COUNT 13
+
+enum HW_TYPE {
+    HW_DMG = 0,
+    HW_SGB,
+    HW_GBC,
+
+    HW_UNKNOWN,
+    HW_ALL = HW_UNKNOWN,
+};
 
 struct conf_entry {
     char name[ENTRY_NAME_LEN + 1];
     uint8_t *var;
     uint8_t max;
+    enum HW_TYPE type;
 };
 
 struct debug_entry {
     uint8_t max;
 };
 
+enum HW_TYPE get_hw(void) BANKED;
+
 BANKREF_EXTERN(main)
 
-#define CONF_ENTRY_COUNT 2
 extern const struct conf_entry conf_entries[CONF_ENTRY_COUNT];
+extern const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT];
 
 extern uint8_t debug_menu_index;
 extern uint8_t debug_special_value;
 
-#define DEBUG_ENTRY_COUNT 12
-extern const struct debug_entry debug_entries[DEBUG_ENTRY_COUNT];
-
 #endif // __MAIN_H__

src/maps.c

  */
 
 #include "banks.h"
-#include "gb/cgb.h"
-#include "gb/gb.h"
+#include "config.h"
 #include "util.h"
 #include "map_data.h"
 #include "maps.h"
         }
     } END_ROM_BANK
 
-    uint8_t bank = maps[i].bank;
-    if (maps[i].palettes == num_pal_inv) {
-        bank = BANK(map_data);
-    }
-
-    START_ROM_BANK_2(bank) {
-        if (maps[i].palettes != NULL) {
-            set_bkg_palette(maps[i].palette_index, maps[i].palette_count, maps[i].palettes);
+    if (_cpu == CGB_TYPE) {
+        uint8_t bank = maps[i].bank;
+        if (maps[i].palettes == num_pal_inv) {
+            bank = BANK(map_data);
         }
-    } END_ROM_BANK
+
+        START_ROM_BANK_2(bank) {
+            if (maps[i].palettes != NULL) {
+                set_bkg_palette(maps[i].palette_index, maps[i].palette_count, maps[i].palettes);
+            }
+        } END_ROM_BANK
+    }
 }
 
 void map_load(uint8_t is_splash) BANKED {
         map_load_helper(i);
     }
 
-    if (is_splash) {
+    if (is_splash || (conf_get()->dmg_bg_inv == 0)) {
         BGP_REG = 0b11100100;
     } else {
         // invert BGP for DMG in-game
 
 void map_fill(enum MAPS map, uint8_t bkg) NONBANKED {
     START_ROM_BANK(maps[map].bank) {
-        VBK_REG = VBK_ATTRIBUTES;
-        bkg ? fill_bkg_rect(0, 0, maps[map].width, maps[map].height, maps[map].palette_index)
-            : fill_win_rect(0, 0, maps[map].width, maps[map].height, maps[map].palette_index);
+        if (_cpu == CGB_TYPE) {
+            VBK_REG = VBK_ATTRIBUTES;
+            bkg ? fill_bkg_rect(0, 0, maps[map].width, maps[map].height, maps[map].palette_index)
+                : fill_win_rect(0, 0, maps[map].width, maps[map].height, maps[map].palette_index);
+        }
 
         VBK_REG = VBK_TILES;
         bkg ? set_bkg_based_tiles(0, 0, maps[map].width, maps[map].height, maps[map].map, maps[map].tile_offset)

src/sample.c

     if (sfx >= SFX_COUNT) {
         return;
     }
+
+    /*
     if (conf_get()->sfx_vol == 0) {
         return;
     }
+    */
 
     CRITICAL {
         play_bank = sfxs[sfx].bank;
 
     NR30_REG = 0x80; // turn DAC on
     NR31_REG = 0xFE; // length of wave, 2nd shortest
-    NR32_REG = (4 - conf_get()->sfx_vol) << 5;
+    NR32_REG = (4 - /*conf_get()->sfx_vol*/0x03) << 5;
     NR33_REG = 0x00; // low freq bits are zero
     NR34_REG = 0xC7; // start, no loop, high freq bits are 111
     NR51_REG = 0xFF; // turn all channels on

src/sgb_border.c

 void set_sgb_border(const uint8_t *tiledata, size_t tiledata_size,
                     const uint8_t *tilemap, size_t tilemap_size,
                     const uint8_t *palette, size_t palette_size) NONBANKED {
-    if (!sgb_check()) {
-        return;
-    }
-
     unsigned char map_buf[20];
     memset(map_buf, 0, sizeof(map_buf));
 

src/sprites.c

 }
 
 void spr_init_pal(void) NONBANKED {
+    if (_cpu != CGB_TYPE) {
+        return;
+    }
+
     for (uint8_t i = 0; i < SPRITE_COUNT; i++) {
         uint8_t bank = metasprites[i].bank;
         if (metasprites[i].pa == power_palettes) {
 
     uint8_t pa_off = 0;
 
-    if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD) {
-        uint8_t pa_i = frame;
-        if (pa_i >= metasprites[sprite].pa_n) {
-            pa_i = 0;
-        }
+    if (_cpu == CGB_TYPE) {
+        if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD) {
+            uint8_t pa_i = frame;
+            if (pa_i >= metasprites[sprite].pa_n) {
+                pa_i = 0;
+            }
 
-        set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS) + pa_i, 1, metasprites[sprite].pa + (pa_i * 4));
-    } else if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD_IP) {
-        pa_off = frame;
-        if (pa_off >= metasprites[sprite].pa_n) {
-            pa_off = 0;
-        }
+            set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS) + pa_i, 1, metasprites[sprite].pa + (pa_i * 4));
+        } else if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD_IP) {
+            pa_off = frame;
+            if (pa_off >= metasprites[sprite].pa_n) {
+                pa_off = 0;
+            }
 
-        set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS), 1, metasprites[sprite].pa + (pa_off * 4));
+            set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS), 1, metasprites[sprite].pa + (pa_off * 4));
+        }
     }
 
     switch (flip) {

src/strings.c

 static const char           string_date[] = __DATE__;
 static const char           string_time[] = __TIME__;
 static const char          string_mp_tx[] = "MP Tx:";
-static const char           string_wait[] = "Wait";
+static const char           string_wait[] = "Wait ";
 static const char          string_visit[] = "Visit:";
 static const char            string_url[] = "https://xythobuz.de";
 static const char       string_printout[] = "printout";
 static const char  string_printf_frames[] = "Frames: 0x%x";
 static const char   string_printf_timer[] = " Timer: 0x%x";
 static const char   string_printf_stack[] = " Stack: 0x%x";
+static const char     string_printf_fps[] = "   FPS: %hd";
 
 static const char * const strings[COUNT_STRINGS] = {
     string_top,            // STR_TOP
     string_printf_frames,  // STR_PRINTF_FRAMES
     string_printf_timer,   // STR_PRINTF_TIMER
     string_printf_stack,   // STR_PRINTF_STACK
+    string_printf_fps,     // STR_PRINTF_FPS
 };
 
 #define MAX_STR_LEN 32

src/strings.h

     STR_PRINTF_FRAMES,
     STR_PRINTF_TIMER,
     STR_PRINTF_STACK,
+    STR_PRINTF_FPS,
 
     COUNT_STRINGS
 };

src/text.c

 #include "text.h"
 
 // TODO inverted score color not visible on DMG
-// TODO 8x8 font only available on GBC
+// TODO selected menu entry not visible on DMG
 
 #define TEXT_PALETTE_WHITE BKGF_CGB_PAL3
 #define TEXT_PALETTE_BLACK BKGF_CGB_PAL4
 #define TEXT_ATTR_WHITE    (BKGF_PRI | TEXT_PALETTE_WHITE)
 #define TEXT_ATTR_BLACK    (BKGF_PRI | TEXT_PALETTE_BLACK)
 
-#define ASCI_ATTR_DARK     (BKGF_PRI | BKGF_BANK1 | BKGF_CGB_PAL6) // TODO?
-#define ASCI_ATTR_LIGHT    (BKGF_PRI | BKGF_BANK1 | BKGF_CGB_PAL5) // TODO?
+#define ASCI_ATTR_DARK     (BKGF_PRI | BKGF_BANK1 | BKGF_CGB_PAL6)
+#define ASCI_ATTR_LIGHT    (BKGF_PRI | BKGF_BANK1 | BKGF_CGB_PAL5)
 
 BANKREF(text)
 
 static void set_win_based(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
                           const uint8_t *tiles, uint8_t base_tile, uint8_t tile_bank,
                           const uint8_t *attributes, uint8_t attr_bank) NONBANKED {
-    if (attributes != NULL) {
-        START_ROM_BANK(attr_bank) {
+    if (_cpu == CGB_TYPE) {
+        if (attributes != NULL) {
+            START_ROM_BANK(attr_bank) {
+                VBK_REG = VBK_ATTRIBUTES;
+                set_win_tiles(x, y, w, h, attributes);
+            } END_ROM_BANK
+        } else {
             VBK_REG = VBK_ATTRIBUTES;
-            set_win_tiles(x, y, w, h, attributes);
-        } END_ROM_BANK
-    } else {
-        VBK_REG = VBK_ATTRIBUTES;
-        fill_win_rect(x, y, w, h, 0x00);
+            fill_win_rect(x, y, w, h, 0x00);
+        }
     }
 
     START_ROM_BANK(tile_bank) {
 static void set_win_based_attr(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
                                const uint8_t *tiles, uint8_t base_tile, uint8_t tile_bank,
                                const uint8_t attr) NONBANKED {
-    VBK_REG = VBK_ATTRIBUTES;
-    fill_win_rect(x, y, w, h, attr);
+    if (_cpu == CGB_TYPE) {
+        VBK_REG = VBK_ATTRIBUTES;
+        fill_win_rect(x, y, w, h, attr);
+    }
 
     START_ROM_BANK(tile_bank) {
         VBK_REG = VBK_TILES;

src/timer.h

 #include <gbdk/platform.h>
 #include <stdint.h>
 
+#define TIMER_HZ (256 * 4)
+
 void timer_init(void) BANKED;
 uint16_t timer_get(void);
 

src/window.c

 
     str_center(get_string(STR_DEBUG_MENU), 0, 0);
 
-    for (uint8_t i = debug_menu_index; (i < DEBUG_ENTRY_COUNT) && (i < (7 + debug_menu_index)); i++) {
+    for (uint8_t i = debug_menu_index; (i < DEBUG_ENTRY_COUNT) && (i < (8 + debug_menu_index)); i++) {
         char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
         uint8_t n_len = get_debug(name_buff, i);
         str(name_buff, (TEXT_LINE_WIDTH - n_len) * 2, ((i - debug_menu_index) * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
     }
 }
 
+static uint8_t is_conf_hw(uint8_t i) NONBANKED {
+    uint8_t r;
+    START_ROM_BANK(BANK(main)) {
+        r = (conf_entries[i].type == HW_ALL) || (conf_entries[i].type == get_hw());
+    } END_ROM_BANK
+    return r;
+}
+
 static uint8_t get_conf(char *name_buff, uint8_t i) NONBANKED {
     uint8_t n_len;
     START_ROM_BANK(BANK(main)) {
 void win_conf(void) BANKED {
     map_fill(MAP_TITLE, 0);
 
-    // TODO paging when more options added
+    // TODO paging when more options added?!
     static_assert(CONF_ENTRY_COUNT <= 7, "too many conf menu entries");
-    uint8_t off = (10 - CONF_ENTRY_COUNT) / 2;
+    uint8_t off = ((10 - CONF_ENTRY_COUNT) / 2) + 3;
 
     str_center(get_string(STR_CONF_MENU), 0, 0);
 
     for (uint8_t i = 0; (i < CONF_ENTRY_COUNT) && (i < 7); i++) {
+        if (!is_conf_hw(i)) {
+            continue;
+        }
+
         char name_buff[ENTRY_NAME_LEN + 2 + 1] = {0};
         uint8_t n_len = get_conf(name_buff, i);
-        str(name_buff, (TEXT_LINE_WIDTH - n_len) * 2, (i * 2) + 3 + off, (debug_menu_index == i) ? 1 : 0);
+        str(name_buff, (TEXT_LINE_WIDTH - n_len) * 2, off, (debug_menu_index == i) ? 1 : 0);
+
+        off += 2;
     }
 }
 
         is_black = 1;
     }
 
+    // TODO support one debug value on DMG
     if ((_cpu == CGB_TYPE)
-            && (conf_get()->debug_flags & (DBG_SHOW_FRAMES | DBG_SHOW_TIMER | DBG_SHOW_STACK))) {
+            && (conf_get()->debug_flags & DBG_OUT_ON)) {
         static int32_t prev_score = 0;
         if (initial || (score != prev_score)) {
             prev_score = score;
         uint8_t x_off = number(score, 0, 0, is_black) >> 3;
         uint8_t y_off = 0;
 
+        // TODO only re-draw when value has changed!
+
+        if (conf_get()->debug_flags & DBG_SHOW_FPS) {
+            sprintf(str_buff, get_string(STR_PRINTF_FPS), (uint8_t)game_get_fps());
+            str_ascii(str_buff, x_off, y_off, 1);
+            y_off++;
+        }
+
         if (conf_get()->debug_flags & DBG_SHOW_FRAMES) {
             sprintf(str_buff, get_string(STR_PRINTF_FRAMES), (uint16_t)game_get_framecount());
             str_ascii(str_buff, x_off, y_off, 1);

util/palette.py

+#!/usr/bin/env python3
+
+colors = [
+#    (8, 24, 32),
+#    (52, 104, 86),
+#    (136, 192, 112),
+#    (224, 248, 208),
+    (15, 56, 15),
+    (48, 98, 48),
+    (139, 172, 15),
+    (155, 188, 15),
+]
+
+def convert(c):
+    return (round(c[0] / 8), round(c[1] / 4), round(c[2]/ 8))
+
+for c in colors:
+    print(f"{c} -> {convert(c)}")