add continue / save-game feature

docs/index.html

                 2: {},
                 3: {}
             };
-            EJS_onGameStart = function(e) {
-                setTimeout(function() {
-                    window.EJS_emulator.gameManager.simulateInput(0, 3, 1);
-                    setTimeout(function() {
-                        window.EJS_emulator.gameManager.simulateInput(0, 3, 0);
-                    }, 42);
-                }, 420);
-            };
             EJS_startButtonName = "Start Duality";
         </script>
         <script src="https://cdn.emulatorjs.org/stable/data/loader.js"></script>

src/config.ba0.c

         mem.config.dmg_bg_inv = 1;
 
         score_reset();
+
+        mem.state.in_progress = 0;
     }
 }
 

src/config.h

 #include <gbdk/platform.h>
 #include <stdint.h>
 
+#include "game.h"
 #include "score.h"
+#include "obj.h"
 
 enum debug_flag {
     DBG_NONE = 0,
 
-    DBG_MENU        = (1 << 0),
-    DBG_MARKER      = (1 << 1),
-    DBG_GOD_MODE    = (1 << 2),
-    DBG_NO_OBJ      = (1 << 3),
-    DBG_NO_FUEL     = (1 << 4),
-    DBG_FAST        = (1 << 5),
-    DBG_SHOW_FPS    = (1 << 6),
-    DBG_SHOW_FRAMES = (1 << 7),
-    DBG_SHOW_TIMER  = (1 << 8),
-    DBG_SHOW_STACK  = (1 << 9),
+    DBG_MENU        = (1U << 0),
+    DBG_MARKER      = (1U << 1),
+    DBG_GOD_MODE    = (1U << 2),
+    DBG_NO_OBJ      = (1U << 3),
+    DBG_NO_FUEL     = (1U << 4),
+    DBG_FAST        = (1U << 5),
+    DBG_SHOW_FPS    = (1U << 6),
+    DBG_SHOW_FRAMES = (1U << 7),
+    DBG_SHOW_TIMER  = (1U << 8),
+    DBG_SHOW_STACK  = (1U << 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 music_vol;
     uint8_t game_bg;
     uint8_t dmg_bg_inv;
 };
 
+struct state {
+    uint8_t in_progress;
+    struct game_state state_game;
+    struct obj_state state_obj;
+};
+
 void conf_init(void) BANKED;
 void conf_write_crc(void) BANKED;
 
 struct config_mem {
     struct config config;
     struct scores scores[SCORE_NUM * 2];
+    struct state state;
 
     uint32_t crc; // needs to be last
 };
 
 extern struct config_mem mem;
+
+#define conf_get()    (&mem.config)
 #define conf_scores() (mem.scores)
-#define conf_get() (&mem.config)
+#define conf_state()  (&mem.state)
 
 #endif // __CONFIG_H__

src/game.c

  */
 
 #include <gbdk/metasprites.h>
+#include <string.h>
 #include <rand.h>
 #include <stdint.h>
 
 #define SPEED_INC 1
 #define SPEED_DEC 1
 
-#define SPEED_MAX_ACC 23
-#define SPEED_MAX_ACC_DIAG 16
-#define SPEED_MAX_ACC_D_LO 9
-#define SPEED_MAX_ACC_D_HI 21
 #define SPEED_MAX_IDLE 16
 #define SPEED_MAX_DBG 256
 
 
 BANKREF(game)
 
+const int8_t table_shot_offsets[ROT_INVALID * 2] = {
+    0,                 -SHIP_OFF,         // 0.0
+    SHIP_OFF / 2 - 1,  -SHIP_OFF / 2 - 4, // 22.5
+    SHIP_OFF / 2 + 3,  -SHIP_OFF / 2 - 2, // 45.0
+    SHIP_OFF / 2 + 5,  -SHIP_OFF / 2 + 2, // 67.5
+    SHIP_OFF,          0,                 // 90.0
+    SHIP_OFF / 2 + 5,  SHIP_OFF / 2 + 0,  // 112.5
+    SHIP_OFF / 2 + 3,  SHIP_OFF / 2 + 2,  // 135.0
+    SHIP_OFF / 2 + 1,  SHIP_OFF / 2 + 4,  // 157.5
+    0,                 SHIP_OFF,          // 180.0
+    -SHIP_OFF / 2 + 2, SHIP_OFF / 2 + 3,  // 202.5
+    -SHIP_OFF / 2 - 3, SHIP_OFF / 2 + 2,  // 225.0
+    -SHIP_OFF / 2 - 5, SHIP_OFF / 2 - 1,  // 247.5
+    -SHIP_OFF,         0,                 // 270.0
+    -SHIP_OFF / 2 - 2, -SHIP_OFF / 2 + 2, // 292.5
+    -SHIP_OFF / 2 - 3, -SHIP_OFF / 2 - 2, // 315.0
+    -SHIP_OFF / 2 + 1, -SHIP_OFF / 2 - 4, // 337.5
+};
+
 enum ACCELERATION {
-    ACC_X = 1,
-    ACC_Y = 2,
-    ACC_R = 4,
+    ACC_X = (1U << 1),
+    ACC_Y = (1U << 2),
+    ACC_R = (1U << 3),
 };
 
-static int16_t spd_x = 0, spd_y = 0;
-static enum SPRITE_ROT rot = 0;
-static enum ACCELERATION acc = 0;
-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 fps_count = 0;
 static uint16_t prev_fps_start = 0;
-static uint8_t prev_fps = 0;
+
+struct game_state game_state;
+uint16_t frame_count = 0;
+uint8_t game_fps = 0;
 
 static void calc_fps(void) {
     frame_count++;
     uint16_t diff = timer_get() - prev_fps_start;
     if (diff >= TIMER_HZ) {
         prev_fps_start = timer_get();
-        prev_fps = fps_count;
+        game_fps = fps_count;
         fps_count = 0;
     }
 }
 
-uint8_t game_get_fps(void) BANKED {
-    return prev_fps;
-}
-
-uint16_t game_get_framecount(void) BANKED {
-    return frame_count;
-}
-
 static uint8_t pause_screen(void) {
     snd_music_off();
     snd_note_off();
         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);
+            uint8_t x_off = win_game_draw(game_state.score, 0);
+            move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off,
+                     MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
         }
 
         calc_fps();
 }
 
 void game_get_mp_state(void) BANKED {
-    static struct mp_player_state state;
+    static struct mp_player_state mps;
 
     // TODO pass own pos to mp
 
     // TODO scale?
-    state.spd_x = spd_x;
-    state.spd_y = spd_y;
+    mps.spd_x = game_state.spd_x;
+    mps.spd_y = game_state.spd_y;
 
-    state.rot = rot;
-    mp_new_state(&state);
+    mps.rot = game_state.rot;
+    mp_new_state(&mps);
 }
 
 void game_set_mp_player2(struct mp_player_state *state) BANKED {
 
 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];
+        *max_spd_x = table_speed_move[(game_state.rot * table_speed_move_WIDTH) + 0];
+        *max_spd_y = -table_speed_move[(game_state.rot * table_speed_move_WIDTH) + 1];
     } END_ROM_BANK;
 }
 
 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];
+        *shot_spd_x = table_speed_shot[(game_state.rot * table_speed_move_WIDTH) + 0];
+        *shot_spd_y = -table_speed_shot[(game_state.rot * table_speed_move_WIDTH) + 1];
     } END_ROM_BANK;
 }
 
-int32_t game(enum GAME_MODE mode) BANKED {
+void game_init(void) BANKED {
+    game_state.spd_x = 0;
+    game_state.spd_y = 0;
+    game_state.rot = 0;
+    game_state.health = HEALTH_MAX;
+    game_state.power = POWER_MAX;
+    game_state.score = 0;
+    memset(&obj_state, 0, sizeof(struct obj_state));
+}
+
+uint8_t game(enum GAME_MODE mode) BANKED {
     snd_music_off();
     snd_note_off();
 
     SHOW_SPRITES;
     SPRITES_8x8;
 
-    spd_x = 0;
-    spd_y = 0;
-    rot = 0;
-    health = HEALTH_MAX;
-    power = POWER_MAX;
-    score = 0;
     frame_count = 0;
-
-    obj_init();
+    fps_count = 0;
+    prev_fps_start = 0;
 
     if (mode == GM_SINGLE) {
         if (!(conf_get()->debug_flags & DBG_NO_OBJ)) {
         }
     }
 
-    uint8_t x_off = win_game_draw(score, 1);
-    move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
+    uint8_t x_off = win_game_draw(game_state.score, 1);
+    move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off,
+             MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
 
     SHOW_WIN;
     DISPLAY_ON;
 
     snd_music(SND_GAME);
 
+    uint8_t return_value = 0xFF;
     while(1) {
         key_read();
 
             mp_handle();
         }
 
-        acc = 0;
-        int32_t prev_score = score;
+        enum ACCELERATION acc = 0;
+        int32_t prev_score = game_state.score;
 
         if (key_pressed(J_LEFT)) {
-            rot = (rot - 1) & (ROT_INVALID - 1);
+            game_state.rot = (game_state.rot - 1) & (ROT_INVALID - 1);
             acc |= ACC_R;
         } else if (key_pressed(J_RIGHT)) {
-            rot = (rot + 1) & (ROT_INVALID - 1);
+            game_state.rot = (game_state.rot + 1) & (ROT_INVALID - 1);
             acc |= ACC_R;
         }
 
-        if (key_down(J_A) && (power > 0)) {
+        if (key_down(J_A) && (game_state.power > 0)) {
             int16_t max_spd_x;
             int16_t max_spd_y;
             get_max_spd(&max_spd_x, &max_spd_y);
 
             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;
+                    game_state.spd_x += SPEED_INC;
+                    if (game_state.spd_x > max_spd_x) {
+                        game_state.spd_x = max_spd_x;
                     }
                 } else {
-                    spd_x -= SPEED_INC;
-                    if (spd_x < max_spd_x) {
-                        spd_x = max_spd_x;
+                    game_state.spd_x -= SPEED_INC;
+                    if (game_state.spd_x < max_spd_x) {
+                        game_state.spd_x = max_spd_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;
+                    game_state.spd_y += SPEED_INC;
+                    if (game_state.spd_y > max_spd_y) {
+                        game_state.spd_y = max_spd_y;
                     }
                 } else {
-                    spd_y -= SPEED_INC;
-                    if (spd_y < max_spd_y) {
-                        spd_y = max_spd_y;
+                    game_state.spd_y -= SPEED_INC;
+                    if (game_state.spd_y < max_spd_y) {
+                        game_state.spd_y = max_spd_y;
                     }
                 }
 
             }
 
             if (!(conf_get()->debug_flags & DBG_NO_FUEL)) {
-                if (power >= POWER_DEC) {
-                    power -= POWER_DEC;
+                if (game_state.power >= POWER_DEC) {
+                    game_state.power -= POWER_DEC;
                 } else {
-                    power = 0;
+                    game_state.power = 0;
                 }
             }
-        } else if (!key_down(J_A) && (power < POWER_MAX)) {
-            if (power <= (POWER_MAX - POWER_INC)) {
-                power += POWER_INC;
+        } else if (!key_down(J_A) && (game_state.power < POWER_MAX)) {
+            if (game_state.power <= (POWER_MAX - POWER_INC)) {
+                game_state.power += POWER_INC;
             } else {
-                power = POWER_MAX;
+                game_state.power = POWER_MAX;
             }
         }
 
         // adjust speed down when not moving
         if (!(acc & ACC_X)) {
-            if (spd_x != 0) {
+            if (game_state.spd_x != 0) {
                 if (!(conf_get()->debug_flags & DBG_FAST)) {
-                    if (spd_x > SPEED_MAX_IDLE) spd_x -= SPEED_DEC;
-                    else if (spd_x < -SPEED_MAX_IDLE) spd_x += SPEED_DEC;
+                    if (game_state.spd_x > SPEED_MAX_IDLE) game_state.spd_x -= SPEED_DEC;
+                    else if (game_state.spd_x < -SPEED_MAX_IDLE) game_state.spd_x += SPEED_DEC;
                 } else {
-                    spd_x = 0;
+                    game_state.spd_x = 0;
                 }
             }
         }
         if (!(acc & ACC_Y)) {
-            if (spd_y != 0) {
+            if (game_state.spd_y != 0) {
                 if (!(conf_get()->debug_flags & DBG_FAST)) {
-                    if (spd_y > SPEED_MAX_IDLE) spd_y -= SPEED_DEC;
-                    else if (spd_y < -SPEED_MAX_IDLE) spd_y += SPEED_DEC;
+                    if (game_state.spd_y > SPEED_MAX_IDLE) game_state.spd_y -= SPEED_DEC;
+                    else if (game_state.spd_y < -SPEED_MAX_IDLE) game_state.spd_y += SPEED_DEC;
                 } else {
-                    spd_y = 0;
+                    game_state.spd_y = 0;
                 }
             }
         }
             int16_t shot_spd_x;
             int16_t shot_spd_y;
             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;
-            switch (rot) {
-                case ROT_0:
-                    shot_pos_x = 0;
-                    shot_pos_y = -SHIP_OFF;
-                    break;
-
-                case ROT_22_5:
-                    shot_pos_x = SHIP_OFF / 2 - 1;
-                    shot_pos_y = -SHIP_OFF / 2 - 4;
-                    break;
-
-                case ROT_45:
-                    shot_pos_x = SHIP_OFF / 2 + 3;
-                    shot_pos_y = -SHIP_OFF / 2 - 2;
-                    break;
-
-                case ROT_67_5:
-                    shot_pos_x = SHIP_OFF / 2 + 5;
-                    shot_pos_y = -SHIP_OFF / 2 + 2;
-                    break;
-
-                case ROT_90:
-                    shot_pos_x = SHIP_OFF;
-                    shot_pos_y = 0;
-                    break;
-
-                case ROT_112_5:
-                    shot_pos_x = SHIP_OFF / 2 + 5;
-                    shot_pos_y = SHIP_OFF / 2 + 0;
-                    break;
-
-                case ROT_135:
-                    shot_pos_x = SHIP_OFF / 2 + 3;
-                    shot_pos_y = SHIP_OFF / 2 + 2;
-                    break;
-
-                case ROT_157_5:
-                    shot_pos_x = SHIP_OFF / 2 + 1;
-                    shot_pos_y = SHIP_OFF / 2 + 4;
-                    break;
-
-                case ROT_180:
-                    shot_pos_x = 0;
-                    shot_pos_y = SHIP_OFF;
-                    break;
-
-                case ROT_202_5:
-                    shot_pos_x = -SHIP_OFF / 2 + 2;
-                    shot_pos_y = SHIP_OFF / 2 + 3;
-                    break;
-
-                case ROT_225:
-                    shot_pos_x = -SHIP_OFF / 2 - 3;
-                    shot_pos_y = SHIP_OFF / 2 + 2;
-                    break;
-
-                case ROT_247_5:
-                    shot_pos_x = -SHIP_OFF / 2 - 5;
-                    shot_pos_y = SHIP_OFF / 2 - 1;
-                    break;
-
-                case ROT_270:
-                    shot_pos_x = -SHIP_OFF;
-                    shot_pos_y = 0;
-                    break;
-
-                case ROT_292_5:
-                    shot_pos_x = -SHIP_OFF / 2 - 2;
-                    shot_pos_y = -SHIP_OFF / 2 + 2;
-                    break;
-
-                case ROT_315:
-                    shot_pos_x = -SHIP_OFF / 2 - 3;
-                    shot_pos_y = -SHIP_OFF / 2 - 2;
-                    break;
-
-                case ROT_337_5:
-                    shot_pos_x = -SHIP_OFF / 2 + 1;
-                    shot_pos_y = -SHIP_OFF / 2 - 4;
-                    break;
-            }
+            shot_spd_x += game_state.spd_x;
+            shot_spd_y += game_state.spd_y;
+
+            int16_t shot_pos_x = table_shot_offsets[(game_state.rot * 2) + 0];
+            int16_t shot_pos_y = table_shot_offsets[(game_state.rot * 2) + 1];
 
             int8_t ret = obj_add(SPR_SHOT,
                                  shot_pos_x, shot_pos_y,
                 sample_play(SFX_SHOT);
 
                 if (mode == GM_SINGLE) {
-                    if (score > 0) {
-                        score--;
+                    if (game_state.score > 0) {
+                        game_state.score--;
                     }
                 } else {
                     static struct mp_shot_state state;
 
         if (key_pressed(J_START)) {
             if (pause_screen()) {
+                return_value = 1;
                 break;
             }
 
             map_dbg_reset();
         }
 
-        map_move(spd_x, spd_y);
+        map_move(game_state.spd_x, game_state.spd_y);
 
         uint8_t hiwater = SPR_NUM_START;
-        status(health >> HEALTH_SHIFT, power >> POWER_SHIFT, &hiwater);
+        status(game_state.health >> HEALTH_SHIFT, game_state.power >> POWER_SHIFT, &hiwater);
 
         if (conf_get()->debug_flags & DBG_MARKER) {
             spr_draw(SPR_DEBUG, FLIP_NONE, 0, 0, 0, &hiwater);
             spr_draw(SPR_DEBUG_LARGE, FLIP_NONE, 0, 0, 0, &hiwater);
         }
 
-        spr_ship(rot, acc & (ACC_X | ACC_Y), &hiwater);
+        spr_ship(game_state.rot, acc & (ACC_X | ACC_Y), &hiwater);
 
-        int16_t damage = obj_do(&spd_x, &spd_y, &score, &hiwater,
+        int16_t damage = obj_do(&game_state.spd_x, &game_state.spd_y, &game_state.score, &hiwater,
                                 (conf_get()->debug_flags & DBG_NO_OBJ) ? 1 : 0);
         if (damage > 0) {
             if (conf_get()->debug_flags & DBG_GOD_MODE) {
                 damage = 0;
             }
 
-            if (health > damage) {
-                health -= damage;
+            if (game_state.health > damage) {
+                game_state.health -= damage;
                 if ((!sample_running()) && (sample_last() != SFX_DAMAGE)) {
                     sample_play(SFX_DAMAGE);
                 }
-            } else if (health <= damage) {
-                health = 0;
-                show_explosion(power);
+            } else if (game_state.health <= damage) {
+                game_state.health = 0;
+                show_explosion(game_state.power);
+                return_value = 0;
                 break;
             }
-        } else if ((damage < 0) && (health < HEALTH_MAX)) {
+        } else if ((damage < 0) && (game_state.health < HEALTH_MAX)) {
             if ((!sample_running()) && (sample_last() != SFX_HEAL)) {
                 sample_play(SFX_HEAL);
             }
 
-            health += -damage;
-            if (health > HEALTH_MAX) {
-                health = HEALTH_MAX;
+            game_state.health += -damage;
+            if (game_state.health > HEALTH_MAX) {
+                game_state.health = HEALTH_MAX;
             }
         } else if (damage == 0) {
             sample_last_reset();
 
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
 
-        if ((score != prev_score)
+        if ((game_state.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);
+            uint8_t x_off = win_game_draw(game_state.score, 0);
+            move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off,
+                     MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
         }
 
         calc_fps();
         vsync();
     }
 
-    return score;
+    return return_value;
 }

src/game.h

 
 #include <gbdk/platform.h>
 #include <stdint.h>
+
 #include "multiplayer.h"
+#include "sprites.h"
 
 #define HEALTH_MAX 0x1FF
 #define HEALTH_SHIFT 1
 #define SHOT_SPEED 42 //23
 #define MAX_TRAVEL 64 //128
 
-#define SHOT_SPEED_DIAG 30
-#define SHOT_SPEED_D_HI 39
-#define SHOT_SPEED_D_LO 16
-
 enum GAME_MODE {
     GM_SINGLE = 0,
     GM_MULTI,
 };
 
+struct game_state {
+    int16_t spd_x;
+    int16_t spd_y;
+    enum SPRITE_ROT rot;
+    uint16_t health;
+    uint16_t power;
+    int32_t score;
+};
+
 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;
 
-uint8_t game_get_fps(void) BANKED;
-uint16_t game_get_framecount(void) BANKED;
-int32_t game(enum GAME_MODE mode) BANKED;
+void game_init(void) BANKED;
+uint8_t game(enum GAME_MODE mode) BANKED;
+
+extern struct game_state game_state;
+extern uint16_t frame_count;
+extern uint8_t game_fps;
 
 BANKREF_EXTERN(game)
 

src/main.c

  */
 
 #include <gbdk/metasprites.h>
+#include <string.h>
 #include <rand.h>
 
 #include "banks.h"
 #include "config.h"
+#include "gb/gb.h"
 #include "gb/hardware.h"
 #include "maps.h"
 #include "obj.h"
 static void conf_screen(void) {
     HIDE_WIN;
 
+    uint8_t changed = 0;
     debug_menu_index = 0;
 
     move_win(MINWNDPOSX, MINWNDPOSY);
         key_read();
 
         if (key_pressed(J_SELECT)) {
+            if (changed) {
+                conf_write_crc();
+                changed = 0;
+            }
             about_screen();
             break;
         } else if (key_pressed(J_UP)) {
             } else {
                 *conf_entries[debug_menu_index].var = conf_entries[debug_menu_index].max;
             }
-            conf_write_crc();
             win_conf();
+            changed = 1;
         } else if (key_pressed(J_RIGHT)) {
             if (*conf_entries[debug_menu_index].var < conf_entries[debug_menu_index].max) {
                 (*conf_entries[debug_menu_index].var)++;
             } else {
                 *conf_entries[debug_menu_index].var = 0;
             }
-            conf_write_crc();
             win_conf();
+            changed = 1;
         } else if (key_pressed(J_A) || key_pressed(J_B) || key_pressed(J_START)) {
             break;
         }
         vsync();
     }
 
+    if (changed) {
+        conf_write_crc();
+    }
+
     debug_menu_index = 0;
 }
 
     anim_frame = 0;
     anim_state = 0;
 
-    obj_init();
+    memset(&obj_state, 0, sizeof(struct obj_state));
     obj_add(SPR_LIGHT, 42, -42, 0, 0);
     obj_add(SPR_DARK, -42, -42, 0, 0);
 
     return convert_name(name[0], name[1], name[2]);
 }
 
+uint8_t ask_continue(void) BANKED {
+    HIDE_WIN;
+
+    uint8_t r = 0;
+
+    move_win(MINWNDPOSX, MINWNDPOSY);
+    hide_sprites_range(SPR_NUM_START, MAX_HARDWARE_SPRITES);
+    win_continue();
+
+    SHOW_WIN;
+
+    while (1) {
+        key_read();
+
+        if (key_pressed(J_A)) {
+            r = 1;
+            break;
+        } else if (key_pressed(J_B)) {
+            r = 0;
+            break;
+        }
+
+        vsync();
+    }
+
+    return r;
+}
+
 static void sgb_init(void) NONBANKED {
     // Wait 4 frames
     // For SGB on PAL SNES this delay is required on startup, otherwise borders don't show up
         cpu_fast();
     }
 
+    DISPLAY_OFF;
+    map_load(1);
+    map_fill(MAP_TITLE, 1);
+    SHOW_BKG;
+    DISPLAY_ON;
+
     conf_init();
     timer_init();
     spr_init();
     initarand(seed);
 
     while (1) {
-        int32_t score = game(GM_SINGLE);
+        if (conf_state()->in_progress && ask_continue()) {
+            game_state = conf_state()->state_game;
+            obj_state = conf_state()->state_obj;
+        } else {
+            game_init();
+        }
 
-        if ((!(conf_get()->debug_flags)) && (score != 0) && score_ranking(score)) {
-            uint16_t name = ask_name(score);
-            struct scores s = { .name = name, .score = score };
-            score_add(s);
+        if (game(GM_SINGLE)) {
+            // game was exited via pause menu
+            conf_state()->in_progress = 1;
+            conf_state()->state_game = game_state;
+            conf_state()->state_obj = obj_state;
+            conf_write_crc();
+        } else {
+            // game ended with player death
+            conf_state()->in_progress = 0;
+            conf_write_crc();
+
+            if ((!(conf_get()->debug_flags))
+                    && (game_state.score != 0)
+                    && score_ranking(game_state.score)) {
+                uint16_t name = ask_name(game_state.score);
+                struct scores s = { .name = name, .score = game_state.score };
+                score_add(s);
+            }
         }
 
         splash();

src/map_data.h

 // background tiles are loaded into VRAM starting at tile number 0
 #define BG_TILE_NUM_START 0
 
-#define BG_COPY_NONE 0xFF
+#define BG_COPY_NONE 0xFFU
 
-#define BG_LOAD_GAME     (0 << 0)
-#define BG_LOAD_SPLASH   (1 << 0)
-#define BG_LOAD_ALL      (1 << 6)
-#define BG_LOAD_GBC_ONLY (1 << 7)
+#define BG_LOAD_GAME     (0U << 0)
+#define BG_LOAD_SPLASH   (1U << 0)
+#define BG_LOAD_ALL      (1U << 6)
+#define BG_LOAD_GBC_ONLY (1U << 7)
 
 struct maps {
     uint8_t width;

src/obj.c

  */
 
 #include <stdint.h>
-#include <string.h>
 #include <stdlib.h>
 #include <rand.h>
 
 #include "sample.h"
 #include "obj.h"
 
-/*
- * sprite budget:
- *
- * fixed:
- * status bars: 8
- * ship + thruster: 7
- * --> 15 fixed
- *
- * hardware tiles: 40 - 15 = 25
- *
- * dynamic:
- * shot / small: 1
- * expl: 4
- * light: 4
- * dark: 4
- * --> 2x dark & 2x light & 1x expl = 20
- * --> 2x shot & 4x small = 6
- * --> 20 + 6 = 26
- *
- * TODO we will sometimes have glitches
- * 1 sprite tile too much
- */
-#define MAX_DARK 2
-#define MAX_LIGHT 2
-#define MAX_SHOT 2
-#define MAX_SHOT_DARK 2
-#define MAX_SHOT_LIGHT 2
-#define MAX_OBJ ((4 * MAX_DARK) + (4 * MAX_LIGHT) + MAX_SHOT + MAX_SHOT_DARK + MAX_SHOT_LIGHT)
-
 #define POS_SCALE_OBJS 5
 #define POS_OBJS_MAX (INT16_MAX >> (8 - POS_SCALE_OBJS))
 #define POS_OBJS_MIN (-(INT16_MAX >> (8 - POS_SCALE_OBJS)) - 1)
 
 #define CHECK_COL_AT_SHOTS
 
-struct obj {
-    uint8_t active;
-    enum SPRITES sprite;
-    int16_t off_x, off_y;
-    int16_t spd_x, spd_y;
-    uint8_t travel;
-    uint8_t frame;
-    uint8_t frame_index;
-    uint8_t frame_count;
-    uint8_t frame_duration;
-};
-
-static struct obj objs[MAX_OBJ];
-static uint8_t obj_cnt[SPRITE_COUNT];
+struct obj_state obj_state;
 
 static const uint8_t obj_max[SPRITE_COUNT] = {
     1, // SPR_SHIP
     1, // SPR_DEBUG_LARGE
 };
 
-void obj_init(void) BANKED {
-    memset(objs, 0, sizeof(objs));
-    memset(obj_cnt, 0, sizeof(obj_cnt));
-}
-
 static uint8_t is_too_close(int8_t x, int8_t y, int8_t center_dist) {
     if ((abs(x) < center_dist) && (abs(y) < center_dist)) {
         return 1;
     }
 
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
-        if (!objs[i].active) {
+        if (!obj_state.objs[i].active) {
             continue;
         }
 
-        int dst_x = abs((objs[i].off_x >> POS_SCALE_OBJS) - x);
-        int dst_y = abs((objs[i].off_y >> POS_SCALE_OBJS) - y);
+        int dst_x = abs((obj_state.objs[i].off_x >> POS_SCALE_OBJS) - x);
+        int dst_y = abs((obj_state.objs[i].off_y >> POS_SCALE_OBJS) - y);
 
         if ((dst_x < PLACEMENT_DISTANCE) && (dst_y < PLACEMENT_DISTANCE)) {
             return 1;
 }
 
 static void obj_respawn_type(enum SPRITES spr, int8_t center_dist) {
-    while (obj_cnt[spr] < obj_max[spr]) {
+    while (obj_state.obj_cnt[spr] < obj_max[spr]) {
         int8_t x, y;
         generate_coords(&x, &y, center_dist);
         obj_add(spr, x, y, 0, 0);
 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 {
     uint8_t next = 0xFF;
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
-        if (!objs[i].active) {
+        if (!obj_state.objs[i].active) {
             next = i;
             break;
         }
         return OBJ_LIST_FULL;
     }
 
-    if (obj_cnt[sprite] >= obj_max[sprite]) {
+    if (obj_state.obj_cnt[sprite] >= obj_max[sprite]) {
         return OBJ_TYPE_FULL;
     }
 
-    obj_cnt[sprite]++;
+    obj_state.obj_cnt[sprite]++;
 
-    objs[next].active = 1;
-    objs[next].sprite = sprite;
-    objs[next].off_x = off_x << POS_SCALE_OBJS;
-    objs[next].off_y = off_y << POS_SCALE_OBJS;
-    objs[next].spd_x = spd_x;
-    objs[next].spd_y = spd_y;
-    objs[next].travel = 0;
-    objs[next].frame = 0;
-    objs[next].frame_index = 0;
-    objs[next].frame_count = 1;
-    objs[next].frame_duration = 0;
+    obj_state.objs[next].active = 1;
+    obj_state.objs[next].sprite = sprite;
+    obj_state.objs[next].off_x = off_x << POS_SCALE_OBJS;
+    obj_state.objs[next].off_y = off_y << POS_SCALE_OBJS;
+    obj_state.objs[next].spd_x = spd_x;
+    obj_state.objs[next].spd_y = spd_y;
+    obj_state.objs[next].travel = 0;
+    obj_state.objs[next].frame = 0;
+    obj_state.objs[next].frame_index = 0;
+    obj_state.objs[next].frame_count = 1;
+    obj_state.objs[next].frame_duration = 0;
 
     return OBJ_ADDED;
 }
 
 static uint8_t handle_shot_col(uint8_t shot, uint8_t orb, int32_t *score, uint8_t is_splash) {
-    if ((abs(objs[shot].off_x - objs[orb].off_x) <= SHOT_RANGE)
-            && (abs(objs[shot].off_y - objs[orb].off_y) <= SHOT_RANGE)) {
+    if ((abs(obj_state.objs[shot].off_x - obj_state.objs[orb].off_x) <= SHOT_RANGE)
+            && (abs(obj_state.objs[shot].off_y - obj_state.objs[orb].off_y) <= SHOT_RANGE)) {
         sample_play(SFX_EXPL_ORB);
 
-        objs[orb].active = 0;
+        obj_state.objs[orb].active = 0;
 
-        obj_cnt[objs[shot].sprite]--;
-        obj_cnt[objs[orb].sprite]--;
+        obj_state.obj_cnt[obj_state.objs[shot].sprite]--;
+        obj_state.obj_cnt[obj_state.objs[orb].sprite]--;
 
-        objs[shot].sprite = SPR_EXPL;
-        objs[shot].travel = 0;
-        objs[shot].frame = 0;
-        objs[shot].frame_index = 0;
-        objs[shot].frame_count = 4;
-        objs[shot].frame_duration = 4;
-        obj_cnt[SPR_EXPL]++;
+        obj_state.objs[shot].sprite = SPR_EXPL;
+        obj_state.objs[shot].travel = 0;
+        obj_state.objs[shot].frame = 0;
+        obj_state.objs[shot].frame_index = 0;
+        obj_state.objs[shot].frame_count = 4;
+        obj_state.objs[shot].frame_duration = 4;
+        obj_state.obj_cnt[SPR_EXPL]++;
 
         // move explosion to center of orb instead of shot
-        objs[shot].off_x = objs[orb].off_x;
-        objs[shot].off_y = objs[orb].off_y;
+        obj_state.objs[shot].off_x = obj_state.objs[orb].off_x;
+        obj_state.objs[shot].off_y = obj_state.objs[orb].off_y;
 
         // also would look kinda cool with shot speed still applied?
-        objs[shot].spd_x = 0;
-        objs[shot].spd_y = 0;
+        obj_state.objs[shot].spd_x = 0;
+        obj_state.objs[shot].spd_y = 0;
 
         if (!is_splash) {
-            obj_respawn_type(objs[orb].sprite, RESPAWN_DISTANCE);
+            obj_respawn_type(obj_state.objs[orb].sprite, RESPAWN_DISTANCE);
         }
 
-        if (objs[orb].sprite == SPR_LIGHT) {
+        if (obj_state.objs[orb].sprite == SPR_LIGHT) {
             (*score) += SCORE_LARGE;
         } else {
             (*score) -= SCORE_LARGE;
     int16_t spd_y = *spd_off_y;
 
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
-        if (!objs[i].active) {
+        if (!obj_state.objs[i].active) {
             continue;
         }
 
         // move objects by their speed and compensate for movement of the background / ship
-        objs[i].off_x = objs[i].off_x + objs[i].spd_x - spd_x;
-        objs[i].off_y = objs[i].off_y + objs[i].spd_y - spd_y;
+        obj_state.objs[i].off_x = obj_state.objs[i].off_x + obj_state.objs[i].spd_x - spd_x;
+        obj_state.objs[i].off_y = obj_state.objs[i].off_y + obj_state.objs[i].spd_y - spd_y;
 
-        if (objs[i].off_x > POS_OBJS_MAX) {
-            objs[i].off_x -= POS_OBJS_MAX - POS_OBJS_MIN + 1;
-        } else if (objs[i].off_x < POS_OBJS_MIN) {
-            objs[i].off_x += POS_OBJS_MAX - POS_OBJS_MIN + 1;
+        if (obj_state.objs[i].off_x > POS_OBJS_MAX) {
+            obj_state.objs[i].off_x -= POS_OBJS_MAX - POS_OBJS_MIN + 1;
+        } else if (obj_state.objs[i].off_x < POS_OBJS_MIN) {
+            obj_state.objs[i].off_x += POS_OBJS_MAX - POS_OBJS_MIN + 1;
         }
-        if (objs[i].off_y > POS_OBJS_MAX) {
-            objs[i].off_y -= POS_OBJS_MAX - POS_OBJS_MIN + 1;
-        } else if (objs[i].off_y < POS_OBJS_MIN) {
-            objs[i].off_y += POS_OBJS_MAX - POS_OBJS_MIN + 1;
+        if (obj_state.objs[i].off_y > POS_OBJS_MAX) {
+            obj_state.objs[i].off_y -= POS_OBJS_MAX - POS_OBJS_MIN + 1;
+        } else if (obj_state.objs[i].off_y < POS_OBJS_MIN) {
+            obj_state.objs[i].off_y += POS_OBJS_MAX - POS_OBJS_MIN + 1;
         }
 
         // only update travel time if we're actually moving
-        if ((objs[i].spd_x != 0) || (objs[i].spd_y != 0)) {
-            objs[i].travel += 1;
+        if ((obj_state.objs[i].spd_x != 0) || (obj_state.objs[i].spd_y != 0)) {
+            obj_state.objs[i].travel += 1;
         }
 
         // remove objects that have traveled for too long
-        if (objs[i].travel >= MAX_TRAVEL) {
-            objs[i].active = 0;
-            obj_cnt[objs[i].sprite]--;
+        if (obj_state.objs[i].travel >= MAX_TRAVEL) {
+            obj_state.objs[i].active = 0;
+            obj_state.obj_cnt[obj_state.objs[i].sprite]--;
             continue;
         }
 
-        int abs_off_x = abs(objs[i].off_x);
-        int abs_off_y = abs(objs[i].off_y);
+        int abs_off_x = abs(obj_state.objs[i].off_x);
+        int abs_off_y = abs(obj_state.objs[i].off_y);
 
         // handle collision
-        switch (objs[i].sprite) {
+        switch (obj_state.objs[i].sprite) {
             case SPR_DARK:
 #ifdef DESPAWN_RANGE
                 if ((abs_off_x >= DESPAWN_RANGE) || (abs_off_y >= DESPAWN_RANGE)) {
 #endif // DESPAWN_RANGE
 
                 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;
-                    } else if (objs[i].off_x < 0) {
-                        *spd_off_x += (-GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
+                    if (obj_state.objs[i].off_x > 0) {
+                        *spd_off_x += (GRAVITY_RANGE - obj_state.objs[i].off_x) >> GRAVITY_SHIFT;
+                    } else if (obj_state.objs[i].off_x < 0) {
+                        *spd_off_x += (-GRAVITY_RANGE - obj_state.objs[i].off_x) >> GRAVITY_SHIFT;
                     }
-                    if (objs[i].off_y > 0) {
-                        *spd_off_y += (GRAVITY_RANGE - objs[i].off_y) >> GRAVITY_SHIFT;
-                    } else if (objs[i].off_y < 0) {
-                        *spd_off_y += (-GRAVITY_RANGE - objs[i].off_y) >> GRAVITY_SHIFT;
+                    if (obj_state.objs[i].off_y > 0) {
+                        *spd_off_y += (GRAVITY_RANGE - obj_state.objs[i].off_y) >> GRAVITY_SHIFT;
+                    } else if (obj_state.objs[i].off_y < 0) {
+                        *spd_off_y += (-GRAVITY_RANGE - obj_state.objs[i].off_y) >> GRAVITY_SHIFT;
                     }
                 }
 
 #endif // DESPAWN_RANGE
 
                 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;
-                    } else if (objs[i].off_x < 0) {
-                        *spd_off_x -= (-GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
+                    if (obj_state.objs[i].off_x > 0) {
+                        *spd_off_x -= (GRAVITY_RANGE - obj_state.objs[i].off_x) >> GRAVITY_SHIFT;
+                    } else if (obj_state.objs[i].off_x < 0) {
+                        *spd_off_x -= (-GRAVITY_RANGE - obj_state.objs[i].off_x) >> GRAVITY_SHIFT;
                     }
-                    if (objs[i].off_y > 0) {
-                        *spd_off_y -= (GRAVITY_RANGE - objs[i].off_y) >> GRAVITY_SHIFT;
-                    } else if (objs[i].off_y < 0) {
-                        *spd_off_y -= (-GRAVITY_RANGE - objs[i].off_y) >> GRAVITY_SHIFT;
+                    if (obj_state.objs[i].off_y > 0) {
+                        *spd_off_y -= (GRAVITY_RANGE - obj_state.objs[i].off_y) >> GRAVITY_SHIFT;
+                    } else if (obj_state.objs[i].off_y < 0) {
+                        *spd_off_y -= (-GRAVITY_RANGE - obj_state.objs[i].off_y) >> GRAVITY_SHIFT;
                     }
                 }
 
 
                 if ((abs_off_x <= PICKUP_SMALL_RANGE) && (abs_off_y <= PICKUP_SMALL_RANGE)) {
                     (*score) -= SCORE_SMALL;
-                    objs[i].active = 0;
-                    obj_cnt[SPR_SHOT_DARK]--;
+                    obj_state.objs[i].active = 0;
+                    obj_state.obj_cnt[SPR_SHOT_DARK]--;
                     obj_respawn_type(SPR_SHOT_DARK, RESPAWN_DISTANCE);
                 }
                 break;
 
                 if ((abs_off_x <= PICKUP_SMALL_RANGE) && (abs_off_y <= PICKUP_SMALL_RANGE)) {
                     (*score) += SCORE_SMALL;
-                    objs[i].active = 0;
-                    obj_cnt[SPR_SHOT_LIGHT]--;
+                    obj_state.objs[i].active = 0;
+                    obj_state.obj_cnt[SPR_SHOT_LIGHT]--;
                     obj_respawn_type(SPR_SHOT_LIGHT, RESPAWN_DISTANCE);
                 }
                 break;
 #ifdef CHECK_COL_AT_SHOTS
             case SPR_SHOT:
                 for (uint8_t orb = 0; orb < MAX_OBJ; orb++) {
-                    if ((!objs[orb].active)
-                            || ((objs[orb].sprite != SPR_LIGHT) && (objs[orb].sprite != SPR_DARK))) {
+                    if ((!obj_state.objs[orb].active)
+                            || ((obj_state.objs[orb].sprite != SPR_LIGHT)
+                                && (obj_state.objs[orb].sprite != SPR_DARK))) {
                         continue;
                     }
 
                 break;
         }
 
-        if (!objs[i].active) {
+        if (!obj_state.objs[i].active) {
             continue;
         }
 
-        spr_draw(objs[i].sprite, FLIP_NONE, objs[i].off_x >> POS_SCALE_OBJS, objs[i].off_y >> POS_SCALE_OBJS, objs[i].frame_index, hiwater);
-
-        objs[i].frame++;
-        if (objs[i].frame >= objs[i].frame_duration) {
-            objs[i].frame = 0;
-            objs[i].frame_index++;
-            if (objs[i].frame_index >= objs[i].frame_count) {
-                objs[i].frame_index = 0;
-
-                if (objs[i].sprite == SPR_EXPL) {
-                    objs[i].active = 0;
-                    obj_cnt[SPR_EXPL]--;
+        spr_draw(obj_state.objs[i].sprite, FLIP_NONE,
+                 obj_state.objs[i].off_x >> POS_SCALE_OBJS,
+                 obj_state.objs[i].off_y >> POS_SCALE_OBJS,
+                 obj_state.objs[i].frame_index, hiwater);
+
+        obj_state.objs[i].frame++;
+        if (obj_state.objs[i].frame >= obj_state.objs[i].frame_duration) {
+            obj_state.objs[i].frame = 0;
+            obj_state.objs[i].frame_index++;
+            if (obj_state.objs[i].frame_index >= obj_state.objs[i].frame_count) {
+                obj_state.objs[i].frame_index = 0;
+
+                if (obj_state.objs[i].sprite == SPR_EXPL) {
+                    obj_state.objs[i].active = 0;
+                    obj_state.obj_cnt[SPR_EXPL]--;
                 }
             }
         }

src/obj.h

 
 #include "sprites.h"
 
+/*
+ * sprite budget:
+ *
+ * fixed:
+ * status bars: 8
+ * ship + thruster: 7
+ * --> 15 fixed
+ *
+ * hardware tiles: 40 - 15 = 25
+ *
+ * dynamic:
+ * shot / small: 1
+ * expl: 4
+ * light: 4
+ * dark: 4
+ * --> 2x dark & 2x light & 1x expl = 20
+ * --> 2x shot & 4x small = 6
+ * --> 20 + 6 = 26
+ *
+ * TODO we will sometimes have glitches
+ * 1 sprite tile too much
+ */
+#define MAX_DARK 2
+#define MAX_LIGHT 2
+#define MAX_SHOT 2
+#define MAX_SHOT_DARK 2
+#define MAX_SHOT_LIGHT 2
+#define MAX_OBJ ((4 * MAX_DARK) + (4 * MAX_LIGHT) + MAX_SHOT + MAX_SHOT_DARK + MAX_SHOT_LIGHT)
+
+struct obj {
+    uint8_t active;
+    enum SPRITES sprite;
+    int16_t off_x, off_y;
+    int16_t spd_x, spd_y;
+    uint8_t travel;
+    uint8_t frame;
+    uint8_t frame_index;
+    uint8_t frame_count;
+    uint8_t frame_duration;
+};
+
+struct obj_state {
+    struct obj objs[MAX_OBJ];
+    uint8_t obj_cnt[SPRITE_COUNT];
+};
+
 enum OBJ_STATE {
     OBJ_ADDED = 0,
     OBJ_LIST_FULL,
     OBJ_TYPE_FULL,
 };
 
-void obj_init(void) BANKED;
 void obj_spawn(void) BANKED;
-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;
-int16_t obj_do(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score, uint8_t *hiwater, uint8_t is_splash) BANKED;
+
+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;
+
+int16_t obj_do(int16_t *spd_off_x, int16_t *spd_off_y,
+               int32_t *score, uint8_t *hiwater, uint8_t is_splash) BANKED;
+
+extern struct obj_state obj_state;
 
 #endif // __OBJ_H__

src/strings.c

 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        string_game_in[] = "Game in";
+static const char       string_progress[] = "Progress";
+static const char     string_a_continue[] = "A Continue";
+static const char     string_b_new_game[] = "B New Game";
 
 static const char * const strings[COUNT_STRINGS] = {
     string_top,            // STR_TOP
     string_printf_stack,   // STR_PRINTF_STACK
     string_printf_fps,     // STR_PRINTF_FPS
     string_spinner,        // STR_SPINNER
+    string_game_in,        // STR_GAME_IN
+    string_progress,       // STR_PROGRESS
+    string_a_continue,     // STR_A_CONTINUE
+    string_b_new_game,     // STR_B_NEW_GAME
 };
 
 #define MAX_STR_LEN 32

src/strings.h

     STR_PRINTF_STACK,
     STR_PRINTF_FPS,
     STR_SPINNER,
+    STR_GAME_IN,
+    STR_PROGRESS,
+    STR_A_CONTINUE,
+    STR_B_NEW_GAME,
 
     COUNT_STRINGS
 };

src/timer.c

 #include "sound.h"
 #include "timer.h"
 
+#define DMG_TMA_VAL (0x100UL -  64UL) // 16.384kHz /  64 = 256Hz
+#define CGB_TMA_VAL (0x100UL - 128UL) // 32.768kHz / 128 = 256Hz
+
 static uint16_t count = 0;
 
 static void timer_isr(void) NONBANKED {
     sample_isr();
     snd_play();
-    count += 4;
+    count++;
 }
 
 void timer_init(void) BANKED {
     CRITICAL {
         count = 0;
         add_TIM(timer_isr);
-        if (_cpu == CGB_TYPE) {
-            TMA_REG = 0x100 - 128; // 32.768kHz / 128 = 256Hz
-        } else {
-            TMA_REG = 0x100 - 64; // 16.384kHz / 64 = 256Hz
-        }
+        TMA_REG = (_cpu == CGB_TYPE) ? CGB_TMA_VAL : DMG_TMA_VAL;
         TAC_REG = TACF_16KHZ | TACF_START;
 
         set_interrupts(TIM_IFLAG | VBL_IFLAG);
     CRITICAL {
         r = count;
     }
-    return r;
+    return r << 2;
 }

src/window.c

          (pos == 2) ? !is_black : is_black);
 }
 
+void win_continue(void) BANKED {
+    map_fill(MAP_TITLE, 0);
+
+    str_center(get_string(STR_GAME_IN), 1, 0);
+    str_center(get_string(STR_PROGRESS), 3, 0);
+
+    str_center(get_string(STR_A_CONTINUE), 13, 1);
+    str_center(get_string(STR_B_NEW_GAME), 15, 1);
+}
+
 uint8_t win_game_draw(int32_t score, uint8_t initial) BANKED {
     uint8_t is_black = 0;
     if (score < 0) {
 
         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) || redraw) {
-                prev_fps = fps;
-                sprintf(str_buff, get_string(STR_PRINTF_FPS), (uint8_t)fps);
+            if ((game_fps != prev_fps) || redraw) {
+                prev_fps = game_fps;
+                sprintf(str_buff, get_string(STR_PRINTF_FPS), (uint8_t)game_fps);
                 str_ascii(str_buff, x_off, y_off, 1);
             }
             y_off++;
 
         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) || redraw) {
-                prev_framecount = framecount;
-                sprintf(str_buff, get_string(STR_PRINTF_FRAMES), (uint16_t)framecount);
+            if ((frame_count != prev_framecount) || redraw) {
+                prev_framecount = frame_count;
+                sprintf(str_buff, get_string(STR_PRINTF_FRAMES), (uint16_t)frame_count);
                 str_ascii(str_buff, x_off, y_off, 1);
             }
             y_off++;

src/window.h

 void win_debug(void) BANKED;
 void win_name(int32_t score) BANKED;
 void win_name_draw(uint16_t name, uint8_t is_black, uint8_t pos) BANKED;
+void win_continue(void) BANKED;
 uint8_t win_game_draw(int32_t score, uint8_t initial) BANKED;
 
 void fill_win(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t tile, uint8_t attr) BANKED;