fix(gfx): honour newlines that land at column 0

basic-gfx swallowed a CR/LF reaching col 0 (guard if(gfx_x!=0)), so
leading \n, \n\n, and bare-PRINT spacing produced no blank line, unlike
the terminal interpreter and the transpiler C runtime which honour every
newline. Same .bas spaced differently under gfx vs PET/native-C.

Add gfx_just_wrapped: set only when an eager 40-col wrap left the cursor
at col 0 with no glyph since; cleared by glyph/newline/HOME/CLS. CR/LF
now advances unless that flag is set, so a full-line wrap still absorbs
its trailing newline while every other col-0 newline advances. gfx now
matches terminal + compiled targets. 40-col eager wrap unchanged.

Author: omiq

CHANGELOG.md

@@ -1,5 +1,31 @@
 ## Changelog
 
+### gfx PRINT: stop swallowing newlines that land at column 0 (2026-06-22)
+
+`basic-gfx` (and the raylib/canvas WASM builds, which share
+`gfx_apply_control_code`) treated a `CR`/`LF` reaching column 0 as a no-op. The
+guard was `if (gfx_x != 0) gfx_newline();`, meant to absorb the duplicate
+newline a full 40-column line produces (the eager wrap already moved the cursor
+down, so a trailing `\n` would double-space). But `gfx_x == 0` can't tell that
+wrap case from a `\n` that legitimately starts a blank line — a leading `\n` in
+a literal, an embedded `\n\n`, or a `\n` right after a prior explicit newline.
+All of those were eaten, so `print "A\n\nB"` rendered `A` / `B` with no gap.
+
+The terminal interpreter (`OUTC('\n')`) and the transpiler C runtime
+(`rgc_pstr` → unconditional `rgc_nl`) both honour every `\n`, so the same source
+gained blank lines on PET / native-C / terminal targets but lost them under
+gfx — e.g. Space Battles' short+long range scan packed tight in `basic-gfx`
+while the compiled builds spaced it out.
+
+Fix: a `gfx_just_wrapped` flag, set only when an eager auto-wrap left the cursor
+at column 0 with no glyph placed since, cleared by any glyph, explicit newline,
+HOME, or CLS. The CR/LF handler now advances unless that flag is set, so a
+full-line wrap still absorbs its trailing newline while every other column-0
+`\n`/`\r` advances — matching the terminal and transpiler runtimes. gfx output
+now lines up with PET / native-C for the same `.bas`. The 40-column eager-wrap
+behaviour (vs terminal's 80 / `-nowrap`) is unchanged; keep portable PRINT lines
+≤ 40 chars.
+
 ### Transpiler backends extracted to a private repo (2026-06-17)
 
 The two source-to-source transpiler backends left this repo. The **C** backend

basic.c

@@ -2772,6 +2772,12 @@ static inline int gfx_cols(void) {
 }
 static int gfx_x = 0;
 static int gfx_y = 0;
+/* Set only when an eager auto-wrap (a glyph filling the last column) left the
+ * cursor at col 0 with no glyph placed since. Lets a CR/LF that immediately
+ * follows a full line absorb into the wrap instead of double-spacing, while a
+ * \n/\r arriving at col 0 by any other means (leading \n, \n\n, a prior
+ * explicit newline) still advances — matching terminal + transpiler runtimes. */
+static int gfx_just_wrapped = 0;
 static uint8_t gfx_fg = 14;      /* default light blue */
 static uint8_t gfx_bg = 6;       /* default blue background */
 static int gfx_reverse = 0;
@@ -2851,6 +2857,7 @@ static void gfx_scroll_up(void)
 
 static void gfx_newline(void)
 {
+    gfx_just_wrapped = 0;
     gfx_x = 0;
     gfx_y++;
     if (gfx_y >= GFX_ROWS) {
@@ -2905,6 +2912,7 @@ static void gfx_clear_screen(void)
     gfx_x = 0;
     gfx_y = 0;
     print_col = 0;
+    gfx_just_wrapped = 0;
 }
 
 static int gfx_apply_control_code(unsigned char code)
@@ -2928,14 +2936,18 @@ static int gfx_apply_control_code(unsigned char code)
         return 1;
     case 13: /* CR */
     case 10: /* LF */
-        /* Avoid double newline: gfx_put_byte already wraps at col 40, so when
-         * the viewer sends CR after wrapping, we're already at col 0. */
-        if (gfx_x != 0) gfx_newline();
+        /* Absorb a CR/LF that lands right after an eager wrap of a full line
+         * (gfx_put_byte already advanced past col 40) so it doesn't double-
+         * space. A \n/\r reaching col 0 any other way still advances, matching
+         * the terminal and transpiler-C runtimes (leading \n, \n\n, etc.). */
+        if (gfx_x != 0 || !gfx_just_wrapped) gfx_newline();
+        gfx_just_wrapped = 0;
         return 1;
     case 19: /* HOME */
         gfx_x = 0;
         gfx_y = 0;
         print_col = 0;
+        gfx_just_wrapped = 0;
         return 1;
     case 147: /* CLR */
         gfx_clear_screen();
@@ -3183,9 +3195,11 @@ static void gfx_put_byte(unsigned char b)
 
     gfx_x++;
     if (gfx_x >= gfx_cols()) {
-        gfx_newline();
+        gfx_newline();         /* clears gfx_just_wrapped */
+        gfx_just_wrapped = 1;  /* this newline came from a full line */
     } else {
         print_col = gfx_x;
+        gfx_just_wrapped = 0;
     }
 }