tweak text rendering and menu stuff

src/gbprinter.c

 #include <string.h>
 
 #include "input.h"
-#include "window.h"
+#include "text.h"
 #include "gbprinter.h"
 
 BANKREF(gbprinter)
     static char line_buff[11];
     strncpy(line_buff, s, 10);
     line_buff[10] = '\0';
-    win_str_center(line_buff, y_pos, 0);
+    str_center(line_buff, y_pos, 0);
 }
 
 enum PRN_STATUS gbprinter_screenshot(uint8_t win, uint8_t palette) BANKED {

src/obj.c

     }
 }
 
-static void obj_respawn(int8_t center_dist) {
-    for (uint8_t spr = SPR_LIGHT; spr <= SPR_SHOT_DARK; spr++) {
-        if (spr == SPR_SHOT) {
-            continue;
-        }
-        obj_respawn_type(spr, center_dist);
-    }
-}
-
 void obj_spawn(void) BANKED {
-    obj_respawn(INITIAL_DISTANCE);
+    obj_respawn_type(SPR_LIGHT, INITIAL_DISTANCE);
+    obj_respawn_type(SPR_DARK, INITIAL_DISTANCE);
+    obj_respawn_type(SPR_SHOT_LIGHT, INITIAL_DISTANCE);
+    obj_respawn_type(SPR_SHOT_DARK, INITIAL_DISTANCE);
 }
 
 enum OBJ_STATE obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y) BANKED {

src/strings.c

 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        string_spinner[] = "/-\\|";
 
 static const char * const strings[COUNT_STRINGS] = {
     string_top,            // STR_TOP
     string_printf_timer,   // STR_PRINTF_TIMER
     string_printf_stack,   // STR_PRINTF_STACK
     string_printf_fps,     // STR_PRINTF_FPS
+    string_spinner,        // STR_SPINNER
 };
 
 #define MAX_STR_LEN 32

src/strings.h

     STR_PRINTF_TIMER,
     STR_PRINTF_STACK,
     STR_PRINTF_FPS,
+    STR_SPINNER,
 
     COUNT_STRINGS
 };
 
+#define SPINNER_LENGTH 4
+
 const char *get_string(enum STRINGS s) BANKED;
 
 BANKREF_EXTERN(strings)

src/text.c

 #include "banks.h"
 #include "maps.h"
 #include "map_data.h"
+#include "window.h"
 #include "text.h"
 
 // TODO inverted score color not visible on DMG
             digit(c - '0', n, x_off, y_off, is_black);
         } else if ((c >= 'a') && (c <= 'z')) {
             character(c - 'a', n, x_off, y_off, is_black);
+        } else {
+            // TODO inverted color on DMG?
+            fill_win(x_off + (n * maps[FNT_TEXT_16].width), y_off,
+                     maps[FNT_TEXT_16].width, maps[FNT_TEXT_16].width,
+                     0, 0);
         }
     }
 }

src/window.c

     __endasm;
 }
 
-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 fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) BANKED {
+    if (_cpu == CGB_TYPE) {
+        VBK_REG = VBK_ATTRIBUTES;
+        fill_win_rect(x, y, w, h, attr);
+    }
+
     VBK_REG = VBK_TILES;
     fill_win_rect(x, y, w, h, tile);
 }
     static uint8_t prev = 0;
     if ((_cpu == CGB_TYPE) && (mp_connection_status != prev)) {
         prev = mp_connection_status;
-        char c = mp_connection_status & 0x1F;
-        str_ascii_l(&c, 1, 19, 0, 1);
+        char c = mp_connection_status % SPINNER_LENGTH;
+        str_ascii_l(&get_string(STR_SPINNER)[c], 1, 19, 0, 0);
     }
 }
 
     } END_ROM_BANK
 }
 
-void win_str_center(const char *s, uint8_t y_off, uint8_t is_black) NONBANKED {
-    START_ROM_BANK(BANK(text)) {
-        str_center(s, y_off, is_black);
-    } END_ROM_BANK
-}
-
 void win_about(void) BANKED {
     map_fill(MAP_TITLE, 0);
 
     static uint8_t prev = 0;
     if ((_cpu == CGB_TYPE) && (mp_connection_status != prev)) {
         prev = mp_connection_status;
-        char c = mp_connection_status & 0x7F;
-        str_ascii_l(&c, 1, 19, 12, 1);
+        uint8_t c = mp_connection_status % SPINNER_LENGTH;
+        str_ascii_l(&get_string(STR_SPINNER)[c], 1, 19, 12, 1);
     }
 }
 
 void win_debug(void) BANKED {
     map_fill(MAP_TITLE, 0);
 
-    // TODO prettier pagination
-    uint8_t off = (10 - (DEBUG_ENTRY_COUNT - debug_menu_index)) / 2;
-
     str_center(get_string(STR_DEBUG_MENU), 0, 0);
 
-    for (uint8_t i = debug_menu_index; (i < DEBUG_ENTRY_COUNT) && (i < (8 + debug_menu_index)); i++) {
+    for (uint8_t i = debug_menu_index; 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);
+        uint8_t n_len = get_debug(name_buff, i % DEBUG_ENTRY_COUNT);
+        str(name_buff, (TEXT_LINE_WIDTH - n_len) * 2, ((i - debug_menu_index) * 2) + 3, (debug_menu_index == i) ? 1 : 0);
     }
 }
 
 
     // TODO support one debug value on DMG
     if ((_cpu == CGB_TYPE) && (conf_get()->debug_flags & DBG_OUT_ON)) {
+        uint8_t redraw = 0;
+
         static int32_t prev_score = 0;
         if (initial || (score != prev_score)) {
             prev_score = score;
+            redraw = 1;
 
             // TODO hard-coded black bg tile
             fill_win(0, 0, 20, 2, 0x80, BKGF_CGB_PAL3);
         if ((conf_get()->debug_flags & DBG_SHOW_FPS) && (y_off < 2)) {
             static uint8_t prev_fps = 0;
             uint8_t fps = game_get_fps();
-            if (fps != prev_fps) {
+            if ((fps != prev_fps) || redraw) {
                 prev_fps = fps;
                 sprintf(str_buff, get_string(STR_PRINTF_FPS), (uint8_t)fps);
                 str_ascii(str_buff, x_off, y_off, 1);
         if ((conf_get()->debug_flags & DBG_SHOW_FRAMES) && (y_off < 2)) {
             static uint16_t prev_framecount = 0;
             uint16_t framecount = game_get_framecount();
-            if (framecount != prev_framecount) {
+            if ((framecount != prev_framecount) || redraw) {
                 prev_framecount = framecount;
                 sprintf(str_buff, get_string(STR_PRINTF_FRAMES), (uint16_t)framecount);
                 str_ascii(str_buff, x_off, y_off, 1);
         if ((conf_get()->debug_flags & DBG_SHOW_TIMER) && (y_off < 2)) {
             static uint16_t prev_timer = 0;
             uint16_t timer = timer_get();
-            if (timer != prev_timer) {
+            if ((timer != prev_timer) || redraw) {
                 sprintf(str_buff, get_string(STR_PRINTF_TIMER), (uint16_t)timer);
                 str_ascii(str_buff, x_off, y_off, 1);
             }
         if ((conf_get()->debug_flags & DBG_SHOW_STACK) && (y_off < 2)) {
             static uint16_t prev_stack_pointer = 0;
             get_sp();
-            if (stack_pointer != prev_stack_pointer) {
+            if ((stack_pointer != prev_stack_pointer) || redraw) {
                 prev_stack_pointer = stack_pointer;
                 sprintf(str_buff, get_string(STR_PRINTF_STACK), (uint16_t)stack_pointer);
                 str_ascii(str_buff, x_off, y_off, 1);

src/window.h

 void win_name_draw(uint16_t name, uint8_t is_black, uint8_t pos) BANKED;
 uint8_t win_game_draw(int32_t score, uint8_t initial) BANKED;
 
-void win_str_center(const char *s, uint8_t y_off, uint8_t is_black);
+void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) BANKED;
 
 BANKREF_EXTERN(window)