show frame and timer values in debug mode

src/game.c

 static uint16_t health = HEALTH_MAX;
 static uint16_t power = POWER_MAX;
 static int32_t score = 0;
+static uint16_t frame_count = 0;
 
 static uint8_t pause_screen(void) NONBANKED {
     snd_music_off();
     health = HEALTH_MAX;
     power = POWER_MAX;
     score = 0;
+    frame_count = 0;
 
     obj_init();
 
 
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
 
-        if (score != prev_score) {
+        if ((score != prev_score) || ((_cpu == CGB_TYPE) && (conf_get()->debug_flags))) {
             uint8_t x_off = win_game_draw(score);
             move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
         }
 
         vsync();
+        frame_count++;
     }
 
     return score;
 }
+
+uint16_t game_get_framecount(void) NONBANKED {
+    return frame_count;
+}

src/game.h

 void game_set_mp_shot(struct mp_shot_state *state);
 
 int32_t game(enum GAME_MODE mode);
+uint16_t game_get_framecount(void);
 
 BANKREF_EXTERN(game)
 

src/strings.c

 static const char string_score_printout[] = "Score Printout";
 static const char string_result[] = "Result:";
 static const char string_printf_error[] = "error: 0x%04x";
+static const char string_printf_frames[] = "Frames: %u";
+static const char string_printf_timer[] = "Timer: %u";
 
 static const char * const strings[COUNT_STRINGS] = {
     string_top,            // STR_TOP
     string_score_printout, // STR_SCORE_PRINTOUT
     string_result,         // STR_RESULT
     string_printf_error,   // STR_PRINTF_ERROR
+    string_printf_frames,  // STR_PRINTF_FRAMES,
+    string_printf_timer,   // STR_PRINTF_TIMER,
 };
 
 #define MAX_STR_LEN 32

src/strings.h

     STR_SCORE_PRINTOUT,
     STR_RESULT,
     STR_PRINTF_ERROR,
+    STR_PRINTF_FRAMES,
+    STR_PRINTF_TIMER,
 
     COUNT_STRINGS
 };

src/timer.c

     }
 }
 
-uint16_t timer_get(void) BANKED {
+uint16_t timer_get(void) NONBANKED {
     uint16_t r;
     CRITICAL {
         r = count;

src/timer.h

 #include <stdint.h>
 
 void timer_init(void) BANKED;
-uint16_t timer_get(void) BANKED;
+uint16_t timer_get(void);
 
 #endif // __TIMER_H__

src/window.c

 
 #include "banks.h"
 #include "config.h"
+#include "gb/hardware.h"
 #include "score.h"
 #include "text.h"
 #include "git.h"
 #include "gbprinter.h"
 #include "multiplayer.h"
 #include "strings.h"
+#include "timer.h"
+#include "game.h"
 #include "window.h"
 
 BANKREF(window)
 
+static char str_buff[128];
+
 static void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) {
     VBK_REG = VBK_ATTRIBUTES;
     fill_win_rect(x, y, w, h, attr);
 
 void win_score_clear(uint8_t is_black, uint8_t no_bg) BANKED {
     if (no_bg) {
-        fill_win(0, 0, DEVICE_SCREEN_WIDTH, DEVICE_SCREEN_HEIGHT, 1, 0x00);
+        fill_win(0, 0, DEVICE_SCREEN_WIDTH, DEVICE_SCREEN_HEIGHT, 1, BKGF_CGB_PAL0);
     } else {
         map_fill(MAP_TITLE, 0);
     }
 }
 
 void win_score_print(enum PRN_STATUS status) BANKED {
-    static char buff[128];
-
     if (_cpu == CGB_TYPE) {
         str_ascii(get_string(STR_GB_PRINTER), 0, 0, 0);
         str_ascii(get_string(STR_SCORE_PRINTOUT), 0, 1, 0);
         if (status == PRN_STATUS_OK) {
             str_ascii(get_string(STR_SUCCESS), 0, 8, 0);
         } else {
-            sprintf(buff, get_string(STR_PRINTF_ERROR), (uint16_t)status);
-            str_ascii(buff, 0, 5, 0);
+            sprintf(str_buff, get_string(STR_PRINTF_ERROR), (uint16_t)status);
+            str_ascii(str_buff, 0, 5, 0);
 
-            gbprinter_error(status, buff);
-            str_ascii_lines(buff, 6, 0);
+            gbprinter_error(status, str_buff);
+            str_ascii_lines(str_buff, 6, 0);
         }
     } else {
         str(get_string(STR_PRINTOUT), 0, 4, 0);
 }
 
 uint8_t win_game_draw(int32_t score) BANKED {
-    fill_win(0, 0, 10, 2, maps[FNT_ASCII_8].tile_offset, 0x81);
-
     uint8_t is_black = 0;
     if (score < 0) {
         score = -score;
         is_black = 1;
     }
 
-    return number(score, 0, 0, is_black);
+    if ((_cpu == CGB_TYPE) && (conf_get()->debug_flags)) {
+        // TODO hard-coded black bg tile
+        fill_win(0, 0, 20, 2, 0x80, BKGF_CGB_PAL3);
+
+        uint8_t x_off = number(score, 0, 0, is_black) >> 3;
+
+        sprintf(str_buff, get_string(STR_PRINTF_FRAMES), (uint16_t)game_get_framecount());
+        str_ascii(str_buff, x_off + 1, 0, 1);
+
+        sprintf(str_buff, get_string(STR_PRINTF_TIMER), (uint16_t)timer_get());
+        str_ascii(str_buff, x_off + 1, 1, 1);
+
+        return DEVICE_SCREEN_PX_WIDTH;
+    } else {
+        // TODO hard-coded black bg tile
+        fill_win(0, 0, 10, 2, 0x80, BKGF_CGB_PAL3);
+
+        return number(score, 0, 0, is_black);
+    }
 }