start adding gb printer support

.gitignore

@@ -5,3 +5,5 @@ compile_commands.json
 bear.cfg
 tmp
 *.sav
+gbe.ini
+*gb_print_*.bmp

Makefile

@@ -49,6 +49,7 @@ ROMU := $(GBDK_HOME)/bin/romusage
 GB_EMU := gearboy
 SGB_EMU := sameboy
 BGB_EMU := wine ~/bin/bgb/bgb.exe
+GBE_EMU := wine ~/bin/gbe/gbe_plus_qt.exe
 FLASHER := flashgbx
 
 LCCFLAGS := -Wa-l -Wl-m -Wp-MMD -Wf--opt-code-speed
@@ -56,9 +57,10 @@ LCCFLAGS += -I$(SRC_DIR) -I$(BUILD_DIR)/$(DATA_DIR)
 LCCFLAGS += -Wm"-yn Duality" -Wm-yt0x1B -Wm-yoA -Wm-ya1 -Wm-yc -Wm-ys
 LCCFLAGS += -autobank -Wb-ext=.rel -Wb-v -Wf-bo255
 
-GB_EMUFLAGS := $(BIN)
-SGB_EMUFLAGS := $(BIN)
+GB_EMUFLAGS := $(BUILD_DIR)/$(BIN)
+SGB_EMUFLAGS := $(BUILD_DIR)/$(BIN)
 BGB_EMUFLAGS := $(BUILD_DIR)/$(BIN)
+GBE_EMUFLAGS := $(BUILD_DIR)/$(BIN)
 
 ifndef GBDK_RELEASE
 	LCCFLAGS += -debug -DDEBUG -Wa-j -Wa-y -Wa-s -Wl-j -Wl-y -Wl-u -Wm-yS
@@ -76,7 +78,7 @@ $(info BUILD_TYPE is $(BUILD_TYPE))
 DEPS=$(OBJS:%.o=%.d)
 -include $(DEPS)
 
-.PHONY: all run sgb_run bgb_run flash clean compile_commands.json usage $(GIT)
+.PHONY: all run sgb_run bgb_run gbe_run flash clean compile_commands.json usage $(GIT)
 .PRECIOUS: $(BUILD_DIR)/$(DATA_DIR)/%.c $(BUILD_DIR)/$(DATA_DIR)/%.h
 
 all: $(BIN)
@@ -98,11 +100,11 @@ usage: $(BUILD_DIR)/$(BIN)
 	@echo Analyzing $<
 	@$(ROMU) $(BUILD_DIR)/$(BIN:%.gb=%.map)
 
-run: $(BIN)
+run: $(BUILD_DIR)/$(BIN)
 	@echo Emulating $<
 	@$(GB_EMU) $(GB_EMUFLAGS)
 
-sgb_run: $(BIN)
+sgb_run: $(BUILD_DIR)/$(BIN)
 	@echo Emulating $<
 	@$(SGB_EMU) $(SGB_EMUFLAGS)
 
@@ -110,6 +112,10 @@ bgb_run: $(BUILD_DIR)/$(BIN)
 	@echo Emulating $<
 	@$(BGB_EMU) $(BGB_EMUFLAGS)
 
+gbe_run: $(BUILD_DIR)/$(BIN)
+	@echo Emulating $<
+	@$(GBE_EMU) $(GBE_EMUFLAGS)
+
 flash: $(BIN)
 	@echo Flashing $<
 	@$(FLASHER) $(FLASHFLAGS) $<

src/config.h

@@ -21,7 +21,6 @@
 #define __CONFIG_H__
 
 #include <gbdk/platform.h>
-#include <gbdk/emu_debug.h>
 #include <stdint.h>
 
 #include "score.h"

src/game.c

@@ -395,6 +395,10 @@ int32_t game(void) NONBANKED {
             snd_music(SND_GAME);
         }
 
+        if (key_pressed(J_SELECT) && conf_get()->debug_flags) {
+            map_dbg_reset();
+        }
+
         map_move(spd_x, spd_y);
 
         uint8_t hiwater = SPR_NUM_START;

src/gbprinter.c

@@ -0,0 +1,366 @@
+/*
+ * gbprinter.c
+ * Duality
+ *
+ * Based on the gbprinter example from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/tree/develop/gbdk-lib/examples/gb/gbprinter
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
+ * 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/>.
+ */
+
+#include <gbdk/platform.h>
+#include <gbdk/emu_debug.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "input.h"
+#include "gbprinter.h"
+
+BANKREF(gbprinter)
+
+/** Width of the printed image in tiles
+*/
+#define PRN_TILE_WIDTH          20
+
+#define PRN_LOW(A) ((A) & 0xFF)
+#define PRN_HIGH(A) ((A) >> 8)
+
+/** 0x88,0x33 are mandatory first bytes to initialise a communication with printer
+ *   Any command sequence begins by these
+ */
+#define PRN_MAGIC               0x3388
+#define PRN_LE(A)               PRN_LOW(A),PRN_HIGH(A)
+
+/** magic number that is sent in the reply packet by the printer before the status byte
+ */
+#define PRN_MAGIC_DETECT        0x81
+
+/** INIT command is mandatory to initialize communication protocol with the printer
+ *   Two consecutive linked commands must never be more than 150 ms apart except the INIT command which is valid at least 10 seconds
+ */
+#define PRN_CMD_INIT            0x01
+
+/** PRINT command
+ *   Contains the palette, margins, number of prints and printing intensity
+ */
+#define PRN_CMD_PRINT           0x02
+
+/** DATA command
+ *   Can be any length between 0 and 640 bytes.
+ *   DATA command with lenght 0 triggers PRN_STATUS_FULL and is mandatory before print command
+ */
+#define PRN_CMD_DATA            0x04
+
+/** BREAK command
+ *   Not very usefull but exists (see Game Boy Programming Manual)
+ */
+#define PRN_CMD_BREAK           0x08
+
+/** STATUS command
+ *   Used to check status bits
+ *   Maybe be used alone before an INIT command to check physical connection with printer
+ *   Resets PRN_STATUS_UNTRAN
+ */
+#define PRN_CMD_STATUS          0x0F
+
+/** Palette format: the bits, grouped two by two, give the printing color of the encoded pixel value
+ *   for the default palette 0xE4 = 0b11100100 = [3 2 1 0]
+ *   Any value is valid, which means that 1 to 4 color images are possible
+ *   0x00 acts the same as 0xE4 for the printer
+ */
+#define PRN_PALETTE_NORMAL      0b11100100u
+#define PRN_PALETTE_INV         0b00011011u
+
+/** Don't use margins
+ */
+#define PRN_NO_MARGINS          0x00
+
+/** Exposure: 0x40 is default value, values from 0x80 to 0xFF act as 0x40
+ *   Determines the time used by the printer head to heat the thermal paper
+ */
+#define PRN_EXPOSURE_LIGHT      0x00
+#define PRN_EXPOSURE_DEFAULT    0x40
+#define PRN_EXPOSURE_DARK       0x7F
+
+/** Battery too low
+ */
+#define PRN_STATUS_LOWBAT       0x80
+
+/** Error not specified according to the Game Boy Programming manual
+ */
+#define PRN_STATUS_ER2          0x40
+
+/** Paper jam  (abnormal motor operation)
+ */
+#define PRN_STATUS_ER1          0x20
+
+/** Packet error (but not checksum error)
+ */
+#define PRN_STATUS_ER0          0x10
+
+/** Unprocessed data present in printer memory
+ *   Allows to verify that printer got some data in memory with correct checksum
+ *   is resetted by STATUS command
+ */
+#define PRN_STATUS_UNTRAN       0x08
+
+/** status data ready, mandatory to allow printing
+ *   is triggered by DATA command with lenght 0
+ */
+#define PRN_STATUS_FULL         0x04
+
+/** Message sent by the printer while physically printing
+ */
+#define PRN_STATUS_BUSY         0x02
+
+/** The received packet has a ckecksum error
+ */
+#define PRN_STATUS_SUM          0x01
+
+#define PRN_STATUS_MASK_ERRORS  0xF0
+#define PRN_STATUS_MASK_ANY     0xFF
+
+#define PRN_SECONDS(A)          ((A)*60)
+
+#define PRN_MAX_PROGRESS        8
+
+#define PRN_STATUS_CANCELLED    PRN_STATUS_ER2
+
+#define REINIT_SEIKO
+
+#define START_TRANSFER          0x81
+#define PRN_BUSY_TIMEOUT        PRN_SECONDS(2)
+#define PRN_COMPLETION_TIMEOUT  PRN_SECONDS(20)
+#define PRN_SEIKO_RESET_TIMEOUT 10
+
+#define PRN_FINAL_MARGIN        0x03
+
+typedef struct start_print_pkt_s {
+    uint16_t magic;
+    uint16_t command;
+    uint16_t length;
+    uint8_t print;
+    uint8_t margins;
+    uint8_t palette;
+    uint8_t exposure;
+    uint16_t crc;
+    uint16_t trail;
+} start_print_pkt_t;
+
+static const uint8_t PRN_PKT_INIT[] = {
+    PRN_LE(PRN_MAGIC), PRN_LE(PRN_CMD_INIT),   PRN_LE(0), PRN_LE(0x01), PRN_LE(0)
+};
+
+static const uint8_t PRN_PKT_STATUS[] = {
+    PRN_LE(PRN_MAGIC), PRN_LE(PRN_CMD_STATUS), PRN_LE(0), PRN_LE(0x0F), PRN_LE(0)
+};
+
+static const uint8_t PRN_PKT_EOF[] = {
+    PRN_LE(PRN_MAGIC), PRN_LE(PRN_CMD_DATA),   PRN_LE(0), PRN_LE(0x04), PRN_LE(0)
+};
+
+static const uint8_t PRN_PKT_CANCEL[] = {
+    PRN_LE(PRN_MAGIC), PRN_LE(PRN_CMD_BREAK),  PRN_LE(0), PRN_LE(0x01), PRN_LE(0)
+};
+
+static start_print_pkt_t PRN_PKT_START = {
+    .magic = PRN_MAGIC, .command = PRN_CMD_PRINT,
+    .length = 4, .print = TRUE,
+    .margins = 0, .palette = PRN_PALETTE_NORMAL, .exposure = PRN_EXPOSURE_DARK,
+    .crc = 0, .trail = 0
+};
+
+static uint16_t printer_status;
+static uint8_t printer_tile_num;
+
+static inline void gbprinter_set_print_params(uint8_t margins, uint8_t palette, uint8_t exposure) {
+    PRN_PKT_START.crc = ((PRN_CMD_PRINT + 0x04u + 0x01u)
+            + (PRN_PKT_START.margins = margins)
+            + (PRN_PKT_START.palette = palette)
+            + (PRN_PKT_START.exposure = exposure));
+}
+
+static uint8_t printer_send_receive(uint8_t b) {
+    SB_REG = b;
+    SC_REG = START_TRANSFER;
+    while (SC_REG & 0x80);
+    return SB_REG;
+}
+
+static uint8_t printer_send_byte(uint8_t b) {
+    return (uint8_t)(printer_status = ((printer_status << 8) | printer_send_receive(b)));
+}
+
+static uint8_t printer_send_command(const uint8_t *command, uint8_t length) {
+    uint8_t index = 0;
+    while (index++ < length) printer_send_byte(*command++);
+    return ((uint8_t)(printer_status >> 8) == PRN_MAGIC_DETECT) ? (uint8_t)printer_status : PRN_STATUS_MASK_ERRORS;
+}
+
+#define PRINTER_SEND_COMMAND(CMD) printer_send_command((const uint8_t *)&(CMD), sizeof(CMD))
+
+static uint8_t printer_print_tile(const uint8_t *tiledata) {
+    static const uint8_t PRINT_TILE[] = { 0x88,0x33,0x04,0x00,0x80,0x02 };
+    static uint16_t printer_CRC;
+    if (printer_tile_num == 0) {
+        const uint8_t * data = PRINT_TILE;
+        for (uint8_t i = sizeof(PRINT_TILE); i != 0; i--) printer_send_receive(*data++);
+        printer_CRC = 0x04 + 0x80 + 0x02;
+    }
+    for(uint8_t i = 0x10; i != 0; i--, tiledata++) {
+        printer_CRC += *tiledata;
+        printer_send_receive(*tiledata);
+    }
+    if (++printer_tile_num == 40) {
+        printer_send_receive((uint8_t)printer_CRC);
+        printer_send_receive((uint8_t)(printer_CRC >> 8));
+        printer_send_receive(0x00);
+        printer_send_receive(0x00);
+        printer_CRC = printer_tile_num = 0;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static inline void printer_init(void) {
+    printer_tile_num = 0;
+    PRINTER_SEND_COMMAND(PRN_PKT_INIT);
+}
+
+uint8_t printer_check_cancel(void) {
+    key_read();
+    return key_pressed(J_B);
+}
+
+static uint8_t printer_wait(uint16_t timeout, uint8_t mask, uint8_t value) {
+    uint8_t error;
+    while (((error = PRINTER_SEND_COMMAND(PRN_PKT_STATUS)) & mask) != value) {
+        if (printer_check_cancel()) {
+            PRINTER_SEND_COMMAND(PRN_PKT_CANCEL);
+            return PRN_STATUS_CANCELLED;
+        }
+        if (timeout-- == 0) return PRN_STATUS_MASK_ERRORS;
+        if (error & PRN_STATUS_MASK_ERRORS) break;
+        vsync();
+    }
+    return error;
+}
+
+uint8_t gbprinter_detect(uint8_t delay) BANKED {
+    printer_init();
+    uint8_t r = printer_wait(delay, PRN_STATUS_MASK_ANY, PRN_STATUS_OK);
+#ifdef DEBUG
+    EMU_printf("%s: %hu\n",  __func__, (uint8_t)r);
+#endif // DEBUG
+    return r;
+}
+
+uint8_t gbprinter_print_image(const uint8_t *image_map, const uint8_t *image,
+                              int8_t pos_x, uint8_t width, uint8_t height) BANKED {
+    uint8_t tile_data[16];
+    uint8_t rows = ((height + 1) >> 1) << 1;
+    uint8_t pkt_count = 0;
+
+    if ((rows >> 1) == 0) return PRN_STATUS_OK;
+
+    printer_tile_num = 0;
+
+    for (uint8_t y = 0; y < rows; y++) {
+        for (int16_t x = 0; x < PRN_TILE_WIDTH; x++) {
+#ifdef DEBUG
+            EMU_printf("%s: %hu %i\n",  __func__, (uint8_t)y, (int16_t)x);
+#endif // DEBUG
+
+            // overlay the picture tile if in range
+            if ((y < height) && (x >= pos_x) && (x < (pos_x + width))) {
+                uint8_t tile = image_map[(y * width) + (x - pos_x)];
+                memcpy(tile_data, image + ((uint16_t)tile << 4), sizeof(tile_data));
+            } else {
+                memset(tile_data, 0, sizeof(tile_data));
+            }
+
+            // print the resulting tile
+            if (printer_print_tile(tile_data)) {
+                pkt_count++;
+
+                if (printer_check_cancel()) {
+                    PRINTER_SEND_COMMAND(PRN_PKT_CANCEL);
+                    return PRN_STATUS_CANCELLED;
+                }
+            }
+
+            if (pkt_count == 9) {
+                pkt_count = 0;
+                PRINTER_SEND_COMMAND(PRN_PKT_EOF);
+
+                // setup margin if last packet
+                gbprinter_set_print_params((y == (rows - 1)) ? PRN_FINAL_MARGIN : PRN_NO_MARGINS,
+                                           PRN_PALETTE_NORMAL, PRN_EXPOSURE_DARK);
+
+                PRINTER_SEND_COMMAND(PRN_PKT_START);
+
+                // query printer status
+                uint8_t error = printer_wait(PRN_BUSY_TIMEOUT, PRN_STATUS_BUSY, PRN_STATUS_BUSY);
+                if (error & PRN_STATUS_MASK_ERRORS) {
+                    return error;
+                }
+
+                error = printer_wait(PRN_COMPLETION_TIMEOUT, PRN_STATUS_BUSY, 0);
+                if (error & PRN_STATUS_MASK_ERRORS) {
+                    return error;
+                }
+
+#ifdef REINIT_SEIKO
+                // reinit printer (required by Seiko?)
+                if (y < (rows - 1)) {
+                    PRINTER_SEND_COMMAND(PRN_PKT_INIT);
+                    error = printer_wait(PRN_SEIKO_RESET_TIMEOUT, PRN_STATUS_MASK_ANY, PRN_STATUS_OK);
+                    if (error) {
+                        return error;
+                    }
+                }
+#endif
+            }
+        }
+    }
+
+    if (pkt_count) {
+        PRINTER_SEND_COMMAND(PRN_PKT_EOF);
+
+        // setup printing if required
+        gbprinter_set_print_params(PRN_FINAL_MARGIN, PRN_PALETTE_NORMAL, PRN_EXPOSURE_DARK);
+        PRINTER_SEND_COMMAND(PRN_PKT_START);
+
+        // query printer status
+        uint8_t error = printer_wait(PRN_BUSY_TIMEOUT, PRN_STATUS_BUSY, PRN_STATUS_BUSY);
+        if (error & PRN_STATUS_MASK_ERRORS) {
+            return error;
+        }
+
+        error = printer_wait(PRN_COMPLETION_TIMEOUT, PRN_STATUS_BUSY, 0);
+        if (error & PRN_STATUS_MASK_ERRORS) {
+            return error;
+        }
+    }
+
+    return PRINTER_SEND_COMMAND(PRN_PKT_STATUS);
+}
+
+uint8_t gbprinter_screenshot(void) BANKED {
+    return gbprinter_print_image(
+        (const uint8_t *)0x9C00, (const uint8_t *)0x8800,
+        0,
+        DEVICE_SCREEN_WIDTH, DEVICE_SCREEN_HEIGHT);
+}

src/gbprinter.h

@@ -0,0 +1,41 @@
+/*
+ * gbprinter.h
+ * Duality
+ *
+ * Based on the gbprinter example from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/tree/develop/gbdk-lib/examples/gb/gbprinter
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
+ * 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 __GBPRINTER_H_INCLUDE__
+#define __GBPRINTER_H_INCLUDE__
+
+#include <gbdk/platform.h>
+#include <stdint.h>
+
+#define PRN_STATUS_OK           0x00
+#define PRINTER_DETECT_TIMEOUT  10
+
+uint8_t gbprinter_detect(uint8_t delay) BANKED;
+uint8_t gbprinter_print_image(const uint8_t *image_map, const uint8_t *image,
+                              int8_t pos_x, uint8_t width, uint8_t height) BANKED;
+uint8_t gbprinter_screenshot(void) BANKED;
+uint8_t gbprinter_error(uint8_t status, char *buff);
+
+BANKREF_EXTERN(gbprinter)
+BANKREF_EXTERN(gbprinter_error)
+
+#endif // __GBPRINTER_H_INCLUDE__

src/gbprinter_error.c

@@ -0,0 +1,65 @@
+/*
+ * gbprinter_error.c
+ * Duality
+ *
+ * Based on the gbprinter example from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/tree/develop/gbdk-lib/examples/gb/gbprinter
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
+ * 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/>.
+ */
+
+#include <gbdk/platform.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "banks.h"
+#include "gbprinter.h"
+
+BANKREF(gbprinter_error)
+
+static const char str_lowbat[] = "battery too low";
+static const char str_er2[] = "unknown error";
+static const char str_er1[] = "paper jam";
+static const char str_er0[] = "packet error";
+static const char str_untran[] = "unprocessed";
+static const char str_full[] = "data full";
+static const char str_busy[] = "printer busy";
+static const char str_sum[] = "checksum error";
+
+static const char * const error_strings[8] = {
+    str_sum, str_busy, str_full, str_untran,
+    str_er0, str_er1, str_er2, str_lowbat
+};
+
+uint8_t gbprinter_error(uint8_t status, char *buff) NONBANKED {
+    if (status == PRN_STATUS_OK) {
+        sprintf(buff, "ok");
+        return 2;
+    }
+
+    uint8_t n = 0;
+    START_ROM_BANK(BANK(gbprinter_error)) {
+        for (uint8_t i = 0; i < 8; i++) {
+            if (status & (1 << i)) {
+                if (n != 0) {
+                    buff[n++] = '\n';
+                }
+                strcpy(buff + n, error_strings[i]);
+                n += strlen(error_strings[i]);
+            }
+        }
+    } END_ROM_BANK
+    return n;
+}

src/main.c

@@ -38,6 +38,7 @@
 #include "timer.h"
 #include "sample.h"
 #include "window.h"
+#include "gbprinter.h"
 #include "main.h"
 
 uint8_t debug_menu_index = 0;
@@ -82,6 +83,21 @@ static void highscore(uint8_t is_black) NONBANKED {
 
         if (key_pressed(J_A) || key_pressed(J_B)) {
             break;
+        } else if (key_pressed(J_SELECT)) {
+            uint8_t status = gbprinter_detect(PRINTER_DETECT_TIMEOUT);
+            if (status == PRN_STATUS_OK) {
+                status = gbprinter_screenshot();
+            }
+
+            win_score_clear(2);
+            win_score_print(status);
+            while (1) {
+                key_read();
+                if (key_pressed(0xFF)) break;
+                vsync();
+            }
+
+            break;
         }
 
         vsync();

src/maps.c

@@ -44,8 +44,8 @@ static_assert(bg_map_HEIGHT == 256, "bg_map needs to be 256x256");
 #define camera_max_y ((bg_map_mapHeight - DEVICE_SCREEN_HEIGHT) * 8)
 
 #define MAP_FLIP_NONE 0x00
-#define MAP_FLIP_X (0x20)// | 0x01)
-#define MAP_FLIP_Y (0x40)// | 0x02)
+#define MAP_FLIP_X (0x20 | 0x01)
+#define MAP_FLIP_Y (0x40 | 0x02)
 #define MAP_FLIP_XY (MAP_FLIP_X | MAP_FLIP_Y)
 
 // current unscaled ship position
@@ -162,6 +162,25 @@ static inline void set(uint8_t dst_x, uint8_t dst_y,
     } END_ROM_BANK
 }
 
+void map_dbg_reset(void) NONBANKED {
+    uint16_t camera_x = abs_x >> POS_SCALE_BG;
+    uint16_t camera_y = abs_y >> POS_SCALE_BG;
+    uint8_t map_pos_x = camera_x >> 3;
+    uint8_t map_pos_y = camera_y >> 3;
+    for (uint8_t x = 0; x < DEVICE_SCREEN_WIDTH; x++) {
+        for (uint8_t y = 0; y < DEVICE_SCREEN_HEIGHT; y++) {
+            uint8_t is_flipped_x = ((camera_x >> 3) + x) & 0x10;
+            uint8_t is_flipped_y = ((camera_y >> 3) + y) & 0x10;
+            uint8_t attr = is_flipped_y ? (is_flipped_x ? MAP_FLIP_XY : MAP_FLIP_Y)
+                                        : (is_flipped_x ? MAP_FLIP_X : MAP_FLIP_NONE);
+            set(x, y,
+                is_flipped_x ? bg_map_mapWidth - map_pos_x : map_pos_x,
+                is_flipped_y ? bg_map_mapHeight - map_pos_y : map_pos_y,
+                attr);
+        }
+    }
+}
+
 void map_move(int16_t delta_x, int16_t delta_y) NONBANKED {
     abs_x += delta_x;
     abs_y += delta_y;
@@ -176,10 +195,10 @@ void map_move(int16_t delta_x, int16_t delta_y) NONBANKED {
     uint8_t map_pos_x = camera_x >> 3;
     uint8_t map_pos_y = camera_y >> 3;
 
-    uint8_t is_flipped_x_left = (camera_x >> 4) & 0x01;
-    uint8_t is_flipped_x_right = ((camera_x >> 4) + DEVICE_SCREEN_WIDTH) & 0x01;
-    uint8_t is_flipped_y_top = (camera_y >> 4) & 0x01;
-    uint8_t is_flipped_y_bottom = ((camera_y >> 4) + DEVICE_SCREEN_HEIGHT) & 0x01;
+    uint8_t is_flipped_x_left = (camera_x >> 3) & 0x10;
+    uint8_t is_flipped_x_right = ((camera_x >> 3) + DEVICE_SCREEN_WIDTH) & 0x10;
+    uint8_t is_flipped_y_top = (camera_y >> 3) & 0x10;
+    uint8_t is_flipped_y_bottom = ((camera_y >> 3) + DEVICE_SCREEN_HEIGHT) & 0x10;
 
     if (map_pos_x != old_map_pos_x) {
         old_map_pos_x = map_pos_x;
@@ -197,11 +216,13 @@ void map_move(int16_t delta_x, int16_t delta_y) NONBANKED {
                         bg_map_map, bg_map_MAP_ATTRIBUTES, MAP_FLIP_NONE, bg_map_mapWidth);
             */
             for (uint8_t i = 0; i < DEVICE_SCREEN_HEIGHT; i++) {
-                uint8_t is_flipped_y = i & 0x01;
-                set(map_pos_x + DEVICE_SCREEN_WIDTH, map_pos_y,
+                uint8_t is_flipped_y = (map_pos_y + i) & 0x04;
+                uint8_t attr = is_flipped_y ? (is_flipped_x_right ? MAP_FLIP_XY : MAP_FLIP_Y)
+                                            : (is_flipped_x_right ? MAP_FLIP_X : MAP_FLIP_NONE);
+                set(map_pos_x + DEVICE_SCREEN_WIDTH, map_pos_y + i,
                     is_flipped_x_right ? bg_map_mapWidth - map_pos_x : map_pos_x,
                     is_flipped_y ? bg_map_mapHeight - map_pos_y : map_pos_y,
-                    is_flipped_y ? (is_flipped_x_right ? MAP_FLIP_XY : MAP_FLIP_Y) : (is_flipped_x_right ? MAP_FLIP_X : MAP_FLIP_NONE));
+                    attr);
             }
         }
     }

src/maps.h

@@ -27,4 +27,6 @@ void map_title(void);
 void map_game(void);
 void map_move(int16_t delta_x, int16_t delta_y);
 
+void map_dbg_reset(void);
+
 #endif // __MAPS_H__

src/score.c

@@ -17,6 +17,7 @@
  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <gbdk/emu_debug.h>
 #include <string.h>
 
 #include "banks.h"

src/sgb_border.c

@@ -1,3 +1,8 @@
+/*
+ * From the sgb_border example from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/tree/develop/gbdk-lib/examples/gb/sgb_border
+ */
+
 #include "sgb_border.h"
 
 #include <gb/gb.h>

src/sgb_border.h

@@ -1,3 +1,8 @@
+/*
+ * From the sgb_border example from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/tree/develop/gbdk-lib/examples/gb/sgb_border
+ */
+
 #ifndef __SGB_BORDER_H_INCLUDE
 #define __SGB_BORDER_H_INCLUDE
 

src/window.c

@@ -19,6 +19,7 @@
 
 #include <gbdk/platform.h>
 #include <string.h>
+#include <stdio.h>
 #include <assert.h>
 
 #include "banks.h"
@@ -31,6 +32,7 @@
 #include "vincent_fnt8.h"
 #include "git.h"
 #include "main.h"
+#include "gbprinter.h"
 #include "window.h"
 
 #define MAX_DIGITS 7
@@ -169,13 +171,17 @@ static void str(const char *s, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
     str_l(s, 0xFF, x_off, y_off, is_black);
 }
 
-static void str_ascii(const char *s, uint8_t x_off, uint8_t y_off) {
-    for (uint8_t n = 0; (*s) && (n < (2 * LINE_WIDTH)); n++) {
+static void str_ascii_l(const char *s, uint8_t len, uint8_t x_off, uint8_t y_off) {
+    for (uint8_t n = 0; (*s) && (n < (2 * LINE_WIDTH)) && (n < len); n++) {
         char c = *(s++);
         char_ascii(c, n, x_off, y_off);
     }
 }
 
+static void str_ascii(const char *s, uint8_t x_off, uint8_t y_off) {
+    str_ascii_l(s, 0xFF, x_off, y_off);
+}
+
 static void str_center(const char *s, uint8_t y_off, uint8_t is_black) {
     uint8_t n = strlen(s);
     if (n > LINE_WIDTH) n = LINE_WIDTH;
@@ -191,6 +197,19 @@ static void str_lines(const char *s, uint8_t y_off, uint8_t is_black) {
     }
 }
 
+static void str_ascii_lines(const char *s, uint8_t y_off) {
+    const char *nl = s;
+    uint8_t lines = 0;
+    do {
+        // find next newline
+        while (*nl && (*nl != '\n')) nl++;
+        str_ascii_l(s, nl - s, 0, y_off + lines);
+        lines++;
+        if (*nl) nl++;
+        s = nl;
+    } while (*nl);
+}
+
 static uint8_t number(int32_t score, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
     // TODO can not set numbers larger than int16 max?!
     //score = 32767 + 1; // wtf?!
@@ -245,7 +264,9 @@ void win_score_clear(uint8_t is_black) BANKED {
                   title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
                   title_map_map, 0, BANK(title_map), title_map_MAP_ATTRIBUTES, BANK(title_map));
 
-    str_center(is_black ? "black" : "white", 1, is_black);
+    if (is_black < 2) {
+        str_center(is_black ? "black" : "white", 1, is_black);
+    }
 }
 
 void win_score_draw(struct scores score, uint8_t off, uint8_t is_black) BANKED {
@@ -253,6 +274,34 @@ void win_score_draw(struct scores score, uint8_t off, uint8_t is_black) BANKED {
     number(is_black ? -score.score : score.score, 7, 4 + off * 3, is_black);
 }
 
+void win_score_print(uint8_t status) BANKED {
+    static char buff[128];
+
+    if (_cpu == CGB_TYPE) {
+        str_ascii("GB Printer", 0, 2);
+        str_ascii("Score Printout", 0, 3);
+        str_ascii("Result:", 0, 6);
+
+        if (status == PRN_STATUS_OK) {
+            str_ascii("success", 0, 7);
+        } else {
+            sprintf(buff, "error: %d", status);
+            str_ascii(buff, 0, 7);
+        }
+
+        gbprinter_error(status, buff);
+        str_ascii_lines(buff, 9);
+    } else {
+        str("printout", 0, 4, 0);
+        if (status == PRN_STATUS_OK) {
+            str("success", 0, 8, 0);
+        } else {
+            str("error", 0, 8, 1);
+            number(status, 11, 8, 1);
+        }
+    }
+}
+
 static void get_git(char *line_buff) NONBANKED {
     START_ROM_BANK(BANK(git)) {
         strncpy(line_buff, git_version, 2 * LINE_WIDTH);

src/window.h

@@ -28,6 +28,7 @@ void win_init(uint8_t is_splash);
 void win_splash_draw(int32_t lowest, int32_t highest) BANKED;
 void win_score_clear(uint8_t is_black) BANKED;
 void win_score_draw(struct scores score, uint8_t off, uint8_t is_black) BANKED;
+void win_score_print(uint8_t status) BANKED;
 void win_about(void) BANKED;
 void win_conf(void) BANKED;
 void win_debug(void) BANKED;