Update BazzBasic-AI-guide.md

BazzBasic-AI-guide.md

@@ -2,7 +2,7 @@
 name: bazzbasic
 description: "BazzBasic BASIC interpreter language reference. Use when writing, debugging, or explaining BazzBasic code (.bas files). Triggers on BazzBasic syntax, $ and # variable suffixes, SDL2 graphics in BASIC, SCREEN/DRAWSHAPE/LOADIMAGE commands, DEF FN functions, BazzBasic file I/O, sound commands, or any question about BazzBasic features. Always use this skill before writing any BazzBasic code."
 ---
- 
+
 # BazzBasic Language Reference
 **Version:** 1.5 | **Author:** Kristian Virtanen (EkBass) | **Platform:** Windows x64  
 **Homepage:** https://ekbass.github.io/BazzBasic/  
@@ -14,11 +14,11 @@ description: "BazzBasic BASIC interpreter language reference. Use when writing,
 **BazzBasic-AI-Guide:** https://huggingface.co/datasets/EkBass/BazzBasic_AI_Guide  
 **BazzBasic Beginner's Guide:** https://github.com/EkBass/BazzBasic-Beginners-Guide/releases  
 **Communities:** https://ekbass.github.io/BazzBasic/communities.html
- 
+
 ---
- 
-## ⚠\u{fe0f} Critical Rules — Read First
- 
+
+## ⚠️ Critical Rules — Read First
+
 | Rule | Detail |
 |------|--------|
 | Variables end with `$` | `name$`, `score$`, `x$` |
@@ -37,13 +37,13 @@ description: "BazzBasic BASIC interpreter language reference. Use when writing,
 | No integer-division operator | Use `INT(a / b)`, `FLOOR(a / b)`, or `CINT(a / b)` |
 | Errors halt the program | No `TRY`/`CATCH` or `ON ERROR` — line-numbered message printed |
 | No line-continuation char | Don't use `_`, `\`, or `&` — lexer continues automatically after operators or open `(` |
- 
+
 ---
- 
+
 ## 🚫 Common AI Mistakes (avoid these)
- 
+
 These are the patterns LLMs most often produce when extrapolating from QBASIC, FreeBASIC, or VB. None of them are valid BazzBasic.
- 
+
 ```basic
 ' ❌ WRONG                                ' ✓ CORRECT
 LET x = 5                                 LET x$ = 5
@@ -59,135 +59,137 @@ ISSET(arr$(0))   ' expecting error        ' returns 0 silently — ISSET only se
 LET x$ = a$ + _ ' VBA continuation        LET x$ = a$ +     ' just leave the operator
 LET x$ = a$ + \ ' Python continuation     LET x$ = a$ +     ' or open a paren — see Line Continuation
 ```
- 
+
 **Two more traps that don't fit the table:**
- 
+
 - Inside `DEF FN` you can read `#` constants from the outer scope but **not** `$` variables or global arrays. Pass values as parameters.
 - Arrays cannot be passed to a function directly, and a function cannot see global arrays. Serialize with `ASJSON()` and rebuild inside the function with `ASARRAY()` — see *Passing Arrays to Functions* below.
+
 ---
- 
+
 ## Minimal Valid Program
- 
+
 ```basic
 ' Suggested style to use [subs]
 [inits]                     ' [name] is a plain jump label, not a keyword — see Control Flow
     LET name$ = "World"
- 
+
 [main]
     PRINT "Hello, " + name$
 END
- 
+
 ' other subs after END'
 [sub:drawScreen]
 	' draw
 RETURN
 ```
- 
+
 Programs flow top to bottom. `[inits]` and `[main]` are organizational labels, not required syntax — the file would also run without them. `END` halts execution; place it at the end of the main flow so control doesn't fall through into subroutines or function definitions.
- 
+
 ---
- 
+
 ## When Generating BazzBasic Code
- 
+
 (Suffix and return-value rules are already covered in Critical Rules above — not repeated here.)
- 
+
 - Prefer `FSTRING` over long `+` concatenation chains for multi-variable strings
 - Place `DEF FN` definitions at the top of the file or via `INCLUDE`
 - Store every `LOADIMAGE` / `LOADSOUND` / `LOADSHAPE` handle as a `#` constant
 - In graphics mode, prefer `LINE (0,0)-(W,H), 0, BF` over `CLS`, and `DRAWSTRING` over `PRINT`
 - Wrap each frame's drawing in `SCREENLOCK ON` / `SCREENLOCK OFF`
 - If a feature isn't documented in this guide, say so rather than inventing one — BazzBasic does not silently inherit QBASIC, FreeBASIC, or VB conventions
+
 ---
- 
- 
+
+
 ## ABOUT
- 
+
 BazzBasic is built around one simple idea: starting programming should feel nice, even fun — the ease and small joyful moments of the classic BASICs of decades past, with a fresh, modern feel.
- 
+
 Over the years my own skills have grown and I've moved on to more versatile languages, but BASIC has always stayed fun for quick experiments — a simple adventure game, a lottery machine, a quiz, or just balls bouncing on the screen. BazzBasic was built with that in mind: a language that gets out of your way so curiosity can run free. And when you finish your first little game and crave something bigger, and eventually move on to another language — that's BazzBasic succeeding at exactly what it was meant to do.
- 
+
 To arouse your curiosity.
- 
+
 *EkBass*, author of BazzBasic
- 
+
 ---
- 
+
 ## Case sensitivity
 BazzBasic is not case-sensitive except with string contents.
 ```basic
 let blaa$ = "Hello"
 PriNT BLAA$ ' output: Hello
 ```
- 
+
 ---
- 
+
 ## Line Continuation
- 
+
 BazzBasic has **no line-continuation character**. Do not generate `_` (VBA), `\` (Python), or `&` (other dialects). The lexer figures out continuation automatically using two rules.
- 
+
 **Rule 1 — operator at end of line.** If a line ends in a token that cannot legally end an expression, the next line continues it:
- 
+
 ```basic
 LET total$ = price$ * count$ -
              discount$
- 
+
 IF score$ >= 0 AND
    score$ <= 100 THEN
     PRINT "Valid"
 END IF
- 
+
 LET counter$ +=
     step$
 ```
- 
+
 Tokens that trigger this: `+ - * / % = <> < <= > >= AND OR += -= *= /= ,`
- 
+
 > `%` IS a real binary modulo operator (`a % b`, same precedence as `*`/`/`, same result as `MOD(a, b)`) and DOES trigger continuation like the other arithmetic operators above.
 > `MOD` is a separate thing — a function `MOD(a, b)` — not a binary operator, so it does NOT trigger continuation (a `)` at line end never continues).
- 
+
 **Rule 2 — open paren.** Anything inside an unmatched `(` keeps reading until the matching `)`:
- 
+
 ```basic
 LET dist$ = DISTANCE(
     x1$, y1$,
     x2$, y2$
 )
 ```
- 
+
 Both rules combine:
- 
+
 ```basic
 LET total$ = (
     base$ +
     tax$
 )
 ```
- 
+
 **Trap for AI generators.** Do NOT emit a trailing `_`, `\`, `&`, or any other continuation marker — they are not BazzBasic syntax and will produce parse errors. Just leave the operator at the end of the line, or open a paren.
- 
+
 ---
- 
+
 ## Variables & Constants
 Variables and constants must be declared with LET before they can be used.  
 BazzBasic variables are not typed, but work the same way as in JavaScript, for example.  
 A variable needs the suffix $ which often is linked as STRING in traditional basic variants.  
- 
+
 Variables require suffix "$". Constants require suffix "#".
 The suffix does not define data type — only "#" indicates immutability.
 ```basic
 LET a$                      ' Declare variable without value
 LET b$, c$, d$				' Multiple variable declarations without value
 LET e$, f$ = "foo", g$ = 10	' Multiple variable declaration, e$ stays empty, f$ and g$ gets values
- 
+
 LET name$ = "Alice"         ' String variable
 LET score$ = 0              ' Numeric variable
- 
+
 LET PI# = 3.14159           ' Constant (immutable)
 LET TITLE# = "My Game"      ' String constant
 ```
- 
+
 **Compound assignment operators** (variables only — **not** allowed with `#` constants):
- 
+
 ```basic
 LET x$ = 1
 x$ += 5     ' add
@@ -197,15 +199,15 @@ x$ /= 4     ' divide
 LET s$ = "Hello"
 s$ += " World"  ' string concatenation
 ```
- 
+
 **Scope:** All main-code variables share one scope (IF, FOR, and WHILE do NOT create new scope).  
 Main-code variables ($) and arrays are NOT accessible inside DEF FN.  
 `DEF FN` functions are fully isolated — only global constants (`#`) accessible inside.
- 
+
 **Comparison:** `"123" = 123` is TRUE (cross-type), but keep types consistent for speed.
- 
+
 ---
- 
+
 ### Built-in Constants
 - **Boolean:** `TRUE` (`1`), `FALSE` (`0`) — plain numbers, not a separate type. `IF x$ = 1` and `IF x$ = TRUE` are identical.
 - **Math:** `PI#`, `HPI#` (π/2 = 90°), `QPI#` (π/4 = 45°), `TAU#` (2π = 360°), `EULER#` (e) — `#` suffix required
@@ -213,40 +215,41 @@ Main-code variables ($) and arrays are NOT accessible inside DEF FN.
 - **Version:** `BBVER#` (returns current version of BazzBasic, ie: "1.5")
 - **Keyboard:** `KEY_ESC#`, `KEY_ENTER#`, `KEY_SPACE#`, `KEY_UP#`, `KEY_DOWN#`, `KEY_LEFT#`, `KEY_RIGHT#`, `KEY_F1#`…`KEY_F12#`, `KEY_A#`…`KEY_Z#`, `KEY_0#`…`KEY_9#`, `KEY_NUMPAD0#`…`KEY_NUMPAD9#`, `KEY_NUMPAD_PLUS#`/`_MINUS#`/`_MUL#`/`_DIV#`/`_DOT#`, `KEY_LSHIFT#`, `KEY_LCTRL#`, etc. — see *Keyboard Input*
 - **Gamepad:** buttons `PAD_A#`…`PAD_Y#`, `PAD_UP#`/`_DOWN#`/`_LEFT#`/`_RIGHT#`, `PAD_LB#`, `PAD_RB#`, `PAD_START#`, `PAD_BACK#` etc.; axes `PAD_LX#`, `PAD_LY#`, `PAD_RX#`, `PAD_RY#`, `PAD_LT#`, `PAD_RT#` — see *Gamepad*
+
 ---
- 
+
 ## Arrays
 BazzBasic arrays are fully dynamic and support numeric, string, or mixed indexing.  
- 
- 
+
+
 ```basic
 DIM scores$                         ' Declare (required before use)
 DIM a$, b$, c$                      ' Multiple
 scores$(0) = 95                     ' Numeric indices are 0-based.
 scores$("name") = "Alice"           ' String keys are associative, insertion-ordered.
 matrix$(0, 1) = "A2"                ' Multi-dimensional
- 
+
 DIM sounds$
     sounds$("guns", "shotgun_shoot")    = "shoot_shotgun.wav"
     sounds$("guns", "shotgun_reload")   = "reload_shotgun.wav"
     sounds$("guns", "ak47_shoot")       = "shoot_ak47.wav"
     sounds$("guns", "ak47_reload")      = "reload_ak47.wav"
     sounds$("food", "ham_eat")          = "eat_ham.wav"
- 
+
 PRINT LEN(sounds$())        ' 5 - total elements across both "guns" and "food" groups
 PRINT ROWCOUNT(sounds$())   ' 2, "guns" & "food"
- 
+
 DIM car$
     car$("manufacturer") = "Ford"
     car$("engine")       = "1.6 Eco"
     car$("color")        = "Blue"
- 
+
 FOR i$ = 0 TO LEN(car$()) - 1        ' Iterate an associative array: LEN + ARRKEY
     LET key$ = ARRKEY(car$(), i$)    ' No FOREACH in BazzBasic - this is the idiom
     PRINT key$; " = "; car$(key$)
 NEXT i$
 ```
- 
+
 | Function/Command | Description |
 |-----------------|-------------|
 | `LEN(arr$())` | Total element count (LEN counts all nested elements across all dimensions) |
@@ -256,17 +259,17 @@ NEXT i$
 | `DELKEY arr$(key)` | Remove one element |
 | `DELARRAY arr$` | Remove entire array (can re-DIM after) |
 | `JOIN dest$, src1$, src2$` | Merge two arrays; `src2$` keys overwrite `src1$`. Use empty `src1$` as `COPYARRAY`. |
- 
+
 **JOIN** Matching keys from src2$ overwrite src1$ at the same level
- 
+
 **Always check with `HASKEY` before reading uninitialized elements.**
- 
+
 > `DIM arr$ = value` (single value, not `key=value` text) stores it at `arr$(0)` — NOT as a scalar. `DIM x$ = 5` does not make `x$` printable as a plain number; it makes `x$(0)` equal `5`. If a scalar is what you want, use `LET`, not `DIM`.
- 
+
 ---
- 
+
 ## Control Flow
- 
+
 ```basic
 ' Block IF
 IF score$ >= 90 THEN
@@ -276,34 +279,34 @@ ELSEIF score$ >= 80 THEN
 ELSE
     PRINT "F"
 END IF                      ' ENDIF also works
- 
+
 ' One-line IF
 IF lives$ = 0 THEN GOTO [game_over]
 IF key$ = KEY_ESC# THEN GOTO [menu] ELSE GOTO [play]
- 
+
 ' FOR (auto-declares variable)
 FOR i$ = 1 TO 10 STEP 2 : PRINT i$ : NEXT
 FOR i$ = 10 TO 1 STEP -1 : PRINT i$ : NEXT
- 
+
 ' WHILE
 WHILE x$ < 100
     x$ = x$ * 2
 WEND
- 
+
 ' Labels, GOTO, GOSUB
 [start]
     GOSUB [sub:init]
 	' Avoid jumping into the middle of logical blocks (e.g. inside IF/WHILE)
     GOTO [start]
- 
+
 [sub:init]
     LET x$ = 0
 RETURN
- 
+
 ' Dynamic jump (variable must contain "[label]" with brackets)
 LET target$ = "[menu]"
 GOTO target$
- 
+
 ' Other
 SLEEP 2000                  ' Pause for milliseconds
 END                         ' Terminate program
@@ -311,9 +314,9 @@ END                         ' Terminate program
 **Note:** Labels are case-insensitive and may contain almost any printable character.
 Whitespace is trimmed. Everything between "[" and "]" is treated as the label name.
 ---
- 
+
 ## I/O
- 
+
 | Command | Description |
 |---------|-------------|
 | `PRINT expr; expr` | `;` = no space, `,` = tab |
@@ -328,31 +331,32 @@ Whitespace is trimmed. Everything between "[" and "]" is treated as the label na
 | `COLOR fg, bg` | Text colors (0–15 palette) |
 | `SHELL("cmd")` | Run shell command, returns output |
 | `SHELL("cmd", ms)` | With timeout in ms (default 5000) |
- 
+
 ' ; prints without spacing
 ' , prints tab separation
 ' Both can be mixed in a single PRINT statement
 ' INPUT splits on whitespace and comma; quoted strings are treated as single values
- 
+
 **Escape sequences in strings:** `\"` `\n` `\t` `\\`
- 
+
 **SHELL + SQLite.** SQLite (the `sqlite3` CLI tool) is the recommended way to add a real database to a BazzBasic script — see the *SQLite Database* page in the manual for the full guide. Three things to remember when generating SHELL commands that wrap SQL:
 - Always append `2>&1` to the command, or SQL errors disappear silently.
 - Use `\"` (BazzBasic escape) to wrap the SQL for the OS shell: `SHELL("sqlite3 db.sqlite \"SELECT * FROM users\" 2>&1")`.
 - In paths use `/` or `\\` — never a single `\`.
+
 ### Keyboard Input
 | Function | Returns | Notes |
 |----------|---------|-------|
 | `INKEY` | Key value or 0 | Non-blocking |
 | `KEYDOWN(key#)` | TRUE/FALSE | Held-key detection; KEYDOWN only works in graphics mode |
 | `WAITKEY(key#, ...)` | Key value | Blocks until key pressed; `WAITKEY()` = any key |
- 
+
 **Keyboard layouts.** Letters (`KEY_A#`…`KEY_Z#`), digits, arrows, Space/Enter/Esc, F-keys,
 numpad and modifiers are the same on every keyboard layout — use these for controls.
 Main-keyboard punctuation (`+ - = , . /` etc. and their `KEY_*#` constants) depends on the
 layout: never bind controls to `ASC("+")` or `ASC("-")`. Use letters or
 `KEY_NUMPAD_PLUS#` / `KEY_NUMPAD_MINUS#` instead.
- 
+
 - Letters always return uppercase codes (`"a"` and `"A"` → `KEY_A#`), in both graphics and console mode.
 - `KEYDOWN` follows the key *label* on the current layout, same as `INKEY`: `KEYDOWN(KEY_A#)` is the key that types "a" (on AZERTY that is a different physical key than on QWERTY). If no key types a punctuation character without modifiers (e.g. "=" on a Finnish keyboard), `KEYDOWN` of that constant is always FALSE.
 - Numpad: `KEY_NUMPAD0#`…`KEY_NUMPAD9#`, `KEY_NUMPAD_PLUS#`, `KEY_NUMPAD_MINUS#`,
@@ -367,13 +371,13 @@ layout: never bind controls to `ASC("+")` or `ASC("-")`. Use letters or
 `MOUSELEFT`, MOUSERIGHT, MOUSEMIDDLE — return 1 if pressed, 0 otherwise  
 `MOUSEHIDE` — hide the mouse cursor (graphics screen only)  
 `MOUSESHOW` — restore the mouse cursor (graphics screen only)
- 
+
 ### Gamepad (console AND graphics mode) — added in v1.5
- 
+
 > **DISCLAIMER:** BazzBasic version 1.5 has been tested with only one PS4-compatible Bluetooth controller. Therefore, for the time being, I cannot guarantee that GamePad support will work with all different types of controllers.
- 
+
 When a user reports a pad not being detected, wrong button mapping or odd axis values, keep this in mind: it may be an untested-controller issue rather than a bug in their code.
- 
+
 | Function | Returns | Notes |
 |----------|---------|-------|
 | `GAMEPADS()` | Number of connected pads | Parentheses optional |
@@ -381,7 +385,7 @@ When a user reports a pad not being detected, wrong button mapping or odd axis v
 | `PADAXIS(pad, axis)` | Number | Sticks -1.0…1.0, triggers 0.0…1.0, built-in dead zone |
 | `PADNAME(pad)` | String | e.g. `"PS4 Controller"`, `""` if not connected |
 | `PADRUMBLE pad, strength, ms` | — (statement) | strength 0.0…1.0, non-blocking, parentheses optional |
- 
+
 - Pad index is **0-based**, max 8 pads. A pad keeps its number while connected (stable slots, not re-packed on disconnect).
 - **No `SCREEN` needed** — unlike `KEYDOWN`/mouse, gamepad functions work in console programs too.
 - **Disconnected pad = no input, never an error:** `PADBUTTON` → FALSE, `PADAXIS` → 0, `PADNAME` → `""`. Do not generate guard code like `IF GAMEPADS() > 0 THEN` around every read; use `GAMEPADS()` only to show a "connect a pad" message.
@@ -394,14 +398,15 @@ When a user reports a pad not being detected, wrong button mapping or odd axis v
 - Stick as digital direction: `IF PADAXIS(0, PAD_LX#) < -0.5 THEN ...`
 - Typical game input = pad OR keyboard: `IF PADBUTTON(0, PAD_LEFT#) OR KEYDOWN(KEY_LEFT#) THEN dx$ = -1`
 - Many third-party pads identify as PS4/Xbox controllers — normal, mapping still correct.
+
 ### Console Read
 Returns numeric or character depending on type parameter  
 `GETCONSOLE(row, col, type)` — type: 0=char (ASCII), 1=fg color, 2=bg color
- 
+
 ---
- 
+
 ## User-Defined Functions
- 
+
 ```basic
 ' Define BEFORE calling. Name must end with $.
 DEF FN Clamp$(val$, lo$, hi$)
@@ -409,12 +414,12 @@ DEF FN Clamp$(val$, lo$, hi$)
     IF val$ > hi$ THEN RETURN hi$
     RETURN val$
 END DEF
- 
+
 PRINT FN Clamp$(5, 1, 10)          ' ✓ OK — return value used
 LET v$ = FN Clamp$(15, 0, 10)     ' ✓ OK
 FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
 ```
- 
+
 - Isolated scope: no access to global `$` variables or global arrays, only global constants (`#`). Using a global array inside a function is an error: `Global array G$ is not visible inside DEF FN - pass it as a parameter with ASJSON() and rebuild it with ASARRAY()`
 - **Arrays inside functions:** `DIM` inside a function always creates a **fresh, empty, local** array on every call (and on every recursion level). Local arrays do not survive between calls:
   ```basic
@@ -432,10 +437,11 @@ FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
 - Supports recursion — uses the real call stack, so extremely deep recursion (thousands of levels) can overflow it. GOSUB/RETURN uses a separate, heap-based stack with no such limit.
 - Arrays as parameters not allowed. Use ASJSON to make array as JSON-string to pass it.
 - Use `INCLUDE` to load functions from separate files if many
+
 ---
- 
+
 ## String Functions
- 
+
 | Function | Description |
 |----------|-------------|
 | `ASC(s$)` | ASCII code of first char |
@@ -458,30 +464,30 @@ FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
 | `VAL(s$)` | String to number |
 | `SHA256(s$)` | SHA256 hash (64-char hex) |
 | `BASE64ENCODE(s$)` / `BASE64DECODE(s$)` | Base64 encode/decode |
- 
+
 > `SRAND(n)` with `n < 0` throws an unhandled arithmetic error (`n = 0` is safe, returns `""`). Never pass an unvalidated or negative length.
 > ```basic
 > PRINT SRAND(-1)
 > ' Error: Arithmetic operation resulted in an overflow.
 > ```
- 
+
 ---
- 
+
 ## FSTRING — String Interpolation
- 
+
 `FSTRING(template$)` substitutes `{{-name-}}` placeholders inside a template string with the value of variables, constants, or array elements. Preferred over long `+` concatenation chains.
- 
+
 ```basic
 LET name$ = "Krisu"
 LET LEVEL# = 5
 PRINT FSTRING("Hello {{-name$-}}, level {{-LEVEL#-}}")
 ' Output: Hello Krisu, level 5
 ```
- 
+
 The triple-character markers `{{-` and `-}}` are deliberately unusual so they will not collide with normal text. There is no escape syntax — literal `{{-...-}}` in the template is always parsed as a placeholder.
- 
+
 ### Placeholder forms
- 
+
 | Form | Resolves to |
 |------|-------------|
 | `{{-var$-}}` | Value of variable `var$` |
@@ -491,40 +497,42 @@ The triple-character markers `{{-` and `-}}` are deliberately unusual so they wi
 | `{{-arr$(KEY#)-}}` | Array element at index taken from constant `KEY#` |
 | `{{-arr$(name)-}}` | Array element at literal string key `"name"` (no quotes inside FSTRING) |
 | `{{-arr$(0, i$)-}}` | Multidimensional element, mixed literal and variable indices |
- 
+
 ### Index resolution rule (array access)
- 
+
 For each comma-separated index, FSTRING looks at the last character:
- 
+
 1. Ends with `$` or `#` → variable / constant lookup. Halts if undefined.
 2. Parses as a number (`0`, `1.5`, `-3`) → numeric index. `arr$(01)` and `arr$(1.0)` both resolve to key `1`.
 3. Otherwise → literal string key. This is what lets `{{-player$(name)-}}` read what was stored with `player$("name") = ...`.
+
 ### Notes
- 
+
 - Whitespace inside placeholders is trimmed: `{{- name$ -}}` ≡ `{{-name$-}}`.
 - Built-in constants work too (`{{-PI#-}}`, `{{-EULER#-}}`, `{{-arr$(KEY_A#)-}}`) — checked before user variables, same order as normal expressions. (In v1.4c they failed with "undefined variable".)
 - Numbers auto-stringify — no `STR()` needed for numeric variables, constants, or array elements.
 - FSTRING returns a value; you must use it (`LET`, `PRINT`, pass to function). Calling it as a bare statement is an error.
 - Errors halt the program with a line-numbered message: undefined variable, missing closing `-}}`, empty placeholder `{{--}}`, malformed array access, uninitialized array element.
+
 ### Not supported (intentional)
- 
+
 No arithmetic, function calls, nested lookups, or quoted string literals inside placeholders. Pre-compute into a variable and reference that:
- 
+
 ```basic
 ' ❌ WRONG
 PRINT FSTRING("Total: {{-a$ + 5-}}")
 PRINT FSTRING("Name: {{-UCASE(name$)-}}")
 PRINT FSTRING("{{-arr$(arr2$(0))-}}")
- 
+
 ' ✓ RIGHT
 LET total$ = a$ + 5
 LET upper$ = UCASE(name$)
 LET k$     = arr2$(0)
 PRINT FSTRING("Total: {{-total$-}}, Name: {{-upper$-}}, Item: {{-arr$(k$)-}}")
 ```
- 
+
 ### Common AI mistakes with FSTRING
- 
+
 ```basic
 ' ❌ WRONG                                  ' ✓ CORRECT
 FSTRING("Hi {{name$}}")                     FSTRING("Hi {{-name$-}}")
@@ -532,43 +540,43 @@ FSTRING("Hi {-name$-}")                     FSTRING("Hi {{-name$-}}")
 FSTRING("Hi {{-name-}}")    ' array key     FSTRING("Hi {{-name$-}}")
 FSTRING("Hi {{-name$-}}")   ' as stmt       LET s$ = FSTRING("Hi {{-name$-}}")
 ```
- 
+
 Inside a placeholder, `name` (no suffix) is treated as a literal string key for an array lookup, **not** as a reference to variable `name$`. Always include the suffix.
- 
+
 ### Full working example
- 
+
 ```basic
 DIM player$
     player$("name")  = "Krisu"
     player$("class") = "Bass"
     player$("level") = 99
- 
+
 DIM grid$
     grid$(0, 0) = "X"
     grid$(0, 1) = "O"
     grid$(1, 0) = "."
     grid$(1, 1) = "X"
- 
+
 LET row$ = 1
 LET PI# = 3.14
- 
+
 PRINT FSTRING("{{-player$(name)-}} the {{-player$(class)-}}, lvl {{-player$(level)-}}")
 PRINT FSTRING("Row {{-row$-}}: [{{-grid$(row$, 0)-}}{{-grid$(row$, 1)-}}]")
 PRINT FSTRING("Pi is roughly {{-PI#-}}")
 END
 ```
- 
+
 Output:
 ```
 Krisu the Bass, lvl 99
 Row 1: [.X]
 Pi is roughly 3.14
 ```
- 
+
 ---
- 
+
 ## Math Functions
- 
+
 | Function | Description |
 |----------|-------------|
 | `ABS(n)` | Absolute value |
@@ -596,19 +604,19 @@ Pi is roughly 3.14
 | `ROUND(n)` | Rounds to nearest integer, half rounds away from zero (`0.5→1`, `-0.5→-1`) — NOT banker's rounding |
 | `SGN(n)` | Sign: -1, 0, or 1 |
 | `SQR(n)` | Square root |
- 
+
 **Math constants:** `PI#`, `HPI#` (PI/2), `QPI#` (PI/4), `TAU#` (PI*2), `EULER#`
- 
+
 ---
- 
+
 ## Variable Functions
- 
+
 | Function | Description |
 |----------|-------------|
 | `ISSET(name)` | `1` if the named variable (`$`) or constant (`#`) is declared, `0` otherwise. Argument is **not evaluated** — `ISSET(undef$)` safely returns `0`. |
- 
+
 `ISSET` is the only language-introspection function and it has tight rules:
- 
+
 - **Scalars only.** Variables (`$`) and constants (`#`). Arrays and array elements are stored separately — `ISSET(arr$)` and `ISSET(arr$(0))` always return `0`, never an error.
 - **Bare name only.** No expressions, no string literals, no numbers. These all error with "invalid parameter":
   ```basic
@@ -624,18 +632,19 @@ Pi is roughly 3.14
   PRINT ISSET(A#)  ' 0
   ```
 - **`LET name$` (no value) still counts as set.** `LET` always registers the variable; the value just defaults to empty string for `$` and zero for numeric. `ISSET` reports declaration, not "has a meaningful value".
+
 Typical use is guarding optional setup:
- 
+
 ```basic
 IF NOT ISSET(playerName$) THEN
     LET playerName$ = "Anonymous"
 END IF
 ```
- 
+
 ---
- 
+
 ## Graphics
- 
+
 ```basic
 SCREEN 12                           ' 640×480 VGA
 SCREEN 0, 800, 600                  ' Custom size
@@ -643,7 +652,7 @@ SCREEN 0, 1024, 768, "My Game"      ' Custom size + title
 FULLSCREEN TRUE                     ' Borderless fullscreen (graphics only)
 FULLSCREEN FALSE                    ' Windowed
 ```
- 
+
 | Mode | Resolution |
 |------|-----------|
 | 1 | 320×200 |
@@ -652,7 +661,7 @@ FULLSCREEN FALSE                    ' Windowed
 | 9 | 640×350 |
 | 12 | 640×480 ← recommended |
 | 13 | 320×200 |
- 
+
 ### Drawing Primitives
 ```basic
 PSET (x, y), color							' Pixel
@@ -665,13 +674,13 @@ PAINT (x, y), fillColor, borderColor       	' Flood fill
 LET c$ = POINT(x, y)                       	' Read pixel color
 LET col$ = RGB(r, g, b)                    	' Create color (0–255 each)
 ```
- 
+
 **Color values:** Every drawing primitive (`PSET`, `LINE`, `CIRCLE`, `PAINT`, `DRAWSTRING`, `LOADSHAPE`) accepts a `color` parameter that is either a palette index 0–15 or an `RGB(r, g, b)` value — mix freely. The `COLOR` text command is the exception: it accepts palette indices 0–15 only, so `COLOR RGB(...)` does **not** work.
- 
+
 **Palette (0–15):** 0=Black, 1=Blue, 2=Green, 3=Cyan, 4=Red, 5=Magenta, 6=Brown, 7=Lt Gray, 8=Dk Gray, 9=Lt Blue, 10=Lt Green, 11=Lt Cyan, 12=Lt Red, 13=Lt Magenta, 14=Yellow, 15=White
- 
+
 > Do **not** hand-construct packed RGB integers (e.g. `16711680`). `RGB()` tags its return value internally so it can be told apart from a palette index; a raw integer lacks that tag and will be misread as a palette index. Always use `RGB(r, g, b)`.
- 
+
 ### Screen Control
 ```basic
 SCREENLOCK ON                       ' Buffer drawing (start frame)
@@ -682,7 +691,7 @@ CLS                                 ' Clear screen
 ' Use CLS only with console, in graphics screen its slow
 ' With graphics screen, prefer LINE BF
 ```
- 
+
 ### Shapes & Images
 ```basic
 ' Create shape
@@ -691,12 +700,12 @@ CLS                                 ' Clear screen
 LET RECT# = LOADSHAPE("RECTANGLE", w, h, color)  ' or "CIRCLE", "TRIANGLE"
 LET IMG_PLAYER# = LOADIMAGE("player.png")         ' PNG (alpha) or BMP
 LET IMG_REMOTE# = LOADIMAGE("https://example.com/a.png") ' Download + load
- 
+
 ' Sprite sheet — sprites indexed 0-based
 DIM sprites$
 LOADSHEET sprites$, 128, 128, "sheet.png"        ' tileW, tileH, file
 MOVESHAPE sprites$(0), x, y                      ' sprites$(0) = first sprite
- 
+
 ' Transform
 ' NOTE: anchor point differs by type — LOADSHAPE primitives (RECTANGLE/CIRCLE/TRIANGLE)
 ' are center-anchored; LOADIMAGE images are top-left-anchored.
@@ -707,32 +716,32 @@ DRAWSHAPE RECT#                     ' Render to buffer
 SHOWSHAPE RECT# / HIDESHAPE RECT#   ' Toggle visibility
 REMOVESHAPE RECT#                   ' Free memory (always clean up)
 ```
- 
- 
+
+
 ---
- 
+
 ### Text Rendering (SDL2_ttf.dll required)
 #### DRAWSTRING & LOADFONT
- 
- 
+
+
 ```basic
 ' Default font: Arial, 16px
 DRAWSTRING "Hello!", 100, 200, RGB(255, 255, 255)
- 
+
 ' Load alternative font — becomes the new default
 LOADFONT "comic.ttf", 24
 DRAWSTRING "Hello!", 100, 200, RGB(255, 255, 255)
- 
+
 ' Reset to Arial, 16px
 LOADFONT
 ```
- 
+
 `DRAWSTRING x, y` positions the top-left of the text. Requires `SDL2_ttf.dll` in the same directory as the interpreter. Prefer this over PRINT, which makes graphic screen easily blinking. Default font size is **16px** — not 20px.
- 
+
 ---
- 
+
 ## Sound
- 
+
 ```basic
 ' LOADSOUND returns a stable integer handle — SDL2 manages the resource.
 ' The handle never changes; store it in a constant to protect it from accidental reassignment.
@@ -743,13 +752,13 @@ SOUNDREPEAT(SND_JUMP#)                 ' Loop continuously
 SOUNDSTOP(SND_JUMP#)                   ' Stop specific sound
 SOUNDSTOPALL                            ' Stop all sounds
 ```
- 
+
 Load all sounds at startup. Call `SOUNDSTOPALL` before `END`.
- 
+
 ---
- 
+
 ## File I/O
- 
+
 ```basic
 LET data$ = FileRead("file.txt")        ' Read as string
 DIM cfg$ : LET cfg$ = FileRead("settings.txt")  ' Read as key=value array
@@ -760,48 +769,48 @@ FILEDELETE "temp.dat"                   ' Delete file
 DIM files$
 LET n$ = FILELIST(files$, "levels", "*.txt")  ' File names into files$(0..n-1), returns n
 ```
- 
+
 **FILELIST:** `FILELIST(arr$, folder$ [, pattern$])` lists files only (no folders, not recursive), names only (no paths), sorted alphabetically ignoring case. The array is cleared first. `pattern$` supports `*` and `?`, default all files. Hidden/system files are skipped. Missing folder → returns `0`. To open a listed file, prepend the folder: `FILEREAD("levels/" + files$(i$))`. Added after v1.4c.
- 
+
 **key=value parsing:** When `FileRead` assigns to a `DIM`'d array, lines `key=value` become `arr$("key")`. Lines starting with `#` are comments. Perfect for `.env` files.
- 
+
 ```basic
 DIM env$
 LET env$ = FileRead(".env")
 LET API_KEY# = env$("OPENAI_API_KEY")
 ```
- 
+
 **Paths:** Use `/` or `\\` — never single `\` (it's an escape char). Relative paths are from `PRG_ROOT#`.
 `PRG_ROOT#` already ends with a directory separator — concatenate directly, don't add your own `/`:
 ```basic
 LET path$ = PRG_ROOT# + "data.txt"
 ```
 **FileWrite with array** saves in key=value format (round-trips with FileRead).
- 
+
 ---
- 
+
 ## Network
- 
+
 ```basic
 LET res$ = HTTPGET("https://api.example.com/data")
 LET res$ = HTTPPOST("https://api.example.com/submit", "{""key"":""val""}")
- 
+
 ' With headers (optional)
 DIM headers$
 headers$("Authorization") = "Bearer mytoken"
 headers$("Content-Type") = "application/json"
 LET res$ = HTTPGET("https://api.example.com/data", headers$)
 LET res$ = HTTPPOST("https://api.example.com/data", body$, headers$)
- 
+
 ' With timeout in seconds (optional, comes AFTER headers; default 30, 0 = no limit)
 LET res$ = HTTPGET("https://api.example.com/data", headers$, 60)
 LET res$ = HTTPPOST("http://localhost:11434/v1/chat/completions", body$, headers$, 120)
 ```
- 
+
 ### Local HTTP server (LISTEN)
- 
+
 BazzBasic can also receive requests as a local-only HTTP server, typically used as glue between a static HTML page and a BazzBasic script on the same machine.
- 
+
 ```basic
 STARTLISTEN 8080                       ' bind 127.0.0.1:8080, no admin needed
 STARTLISTEN 8080, 5000                 ' optional timeout in ms
@@ -809,9 +818,9 @@ LET body$ = GETREQUEST()               ' POST/PUT/PATCH body, or GET query strin
 SENDRESPONSE "{""status"":""ok""}"     ' must be called or browser hangs
 STOPLISTEN
 ```
- 
+
 Important rules:
- 
+
 - **Always pair `GETREQUEST()` with `SENDRESPONSE`.** The browser is waiting on the response. Forgetting `SENDRESPONSE` makes the page hang.
 - **Bound to `127.0.0.1` only.** This is local glue, not a real web server. Do not generate code that tries to expose this on the LAN or internet.
 - **Body or query string, not full request.** `GETREQUEST()` returns just the POST body (or the GET query string without `?`). Headers, method, and URL path are NOT exposed in this version. If you need structured data, parse the body with `ASARRAY(body$)`.
@@ -819,48 +828,49 @@ Important rules:
 - **CORS is automatic.** Every response carries `Access-Control-Allow-Origin: *`. No need to set it manually.
 - **One listener at a time.** Calling `STARTLISTEN` while one is already active is an error. Call `STOPLISTEN` first.
 - **Always 200 OK, always `text/plain`.** Custom status codes and content types are not supported in this version. To return JSON, just put JSON text in the body — browser-side `response.json()` still works.
+
 Typical receive-and-process pattern:
- 
+
 ```basic
 STARTLISTEN 8080
 PRINT "Waiting for browser..."
- 
+
 LET json$ = GETREQUEST()
 DIM data$
 LET data$ = ASARRAY(json$)
- 
+
 PRINT "Got name: " + data$("name")
- 
+
 SENDRESPONSE "{""status"":""ok""}"
 STOPLISTEN
 END
 ```
- 
+
 ---
- 
+
 ## Arrays & JSON
- 
+
 Nested JSON maps to comma-separated keys: `data$("player,name")`, `data$("skills,0")`
- 
+
 ```basic
 ' Array → JSON string
 LET json$ = ASJSON(arr$)
- 
+
 ' JSON string → array (returns element count)
 DIM data$
 LET count$ = ASARRAY(data$, json$)
- 
+
 ' Load/save JSON files
 LOADJSON arr$, "file.json"
 SAVEJSON arr$, "file.json"
 ```
- 
+
 ---
- 
+
 ## Fast Trigonometry
- 
+
 ~20× faster than `SIN(RAD(x))`, 1-degree precision. Uses ~5.6 KB memory.
- 
+
 ```basic
 FastTrig(TRUE)                      ' Enable lookup tables (must call first)
 LET x$ = FastCos(45)               ' Degrees, auto-normalized 0–359
@@ -868,25 +878,25 @@ LET y$ = FastSin(90)
 LET r$ = FastRad(180)              ' Deg→rad (no FastTrig needed)
 FastTrig(FALSE)                     ' Free memory
 ```
- 
+
 Use for raycasting, sprite rotation, particle systems, any high-freq trig.
- 
+
 ---
- 
+
 ## Date & Time
- 
+
 ```basic
 LET t$ = TIME()                    ' Current time, default format "HH:mm:ss" -> "15:21:22"
 LET t2$ = TIME("dd.MM.yyyy")       ' .NET DateTime format string -> "04.09.2026"
 LET t3$ = TIME("dddd")             ' -> "Friday"
- 
+
 LET start$ = TICKS                 ' Milliseconds since program start
 ' ... later in a loop ...
 LET elapsed$ = TICKS - start$      ' Delta time — use for frame-independent movement
 ```
- 
+
 `TICKS` is the standard way to do frame-independent (delta-time) movement in a game loop — prefer it over counting fixed `SLEEP` increments.
- 
+
 ```basic
 ' ✅ Preferred: frame-independent movement
 LET lastTick$ = TICKS
@@ -896,77 +906,79 @@ WHILE running$
     x$ = x$ + speed$ * delta$ / 16   ' normalize to ~60 FPS baseline
     GOSUB [sub:draw]
 WEND
- 
+
 ' ❌ Avoid: fixed SLEEP without delta — speed varies with actual frame rate
 SLEEP 16
 x$ = x$ + speed$
 ```
- 
+
 ---
- 
+
 ## Command-Line Arguments
- 
+
 ```basic
 ' bazzbasic.exe myprog.bas arg1 arg2
 PRINT ARGCOUNT         ' number of args (2 in this example)
 PRINT ARGS(0)          ' first arg  → "arg1"
 PRINT ARGS(1)          ' second arg → "arg2"
 ```
- 
+
 `ARGCOUNT` and `ARGS(n)` are 0-based; ARGS does not include the interpreter or script name.
- 
+
 ---
- 
+
 ## Libraries & INCLUDE
- 
+
 ```basic
 INCLUDE "helpers.bas"               ' Insert source at this point
 INCLUDE "MathLib.bb"                ' Load compiled library
- 
+
 ' Compile library (functions only — no loose code)
 ' bazzbasic.exe -lib MathLib.bas  →  MathLib.bb
 ' Function names auto-prefixed: MATHLIB_functionname$
 PRINT FN MATHLIB_add$(5, 3)
 ```
- 
+
 Library functions can read main-program constants (`#`). `.bb` files are version-locked.
- 
+
 - **No extension fallback.** `INCLUDE "helpers"` does NOT try `helpers.bas` automatically — give the exact filename, extension included.
 - **Path resolution order:** relative to the *including file's own directory* first, then relative to the program's base path.
 - **Circular includes are detected** and halt with `Circular INCLUDE detected: <file>`.
+
 ---
- 
+
 ## Passing Arrays to Functions
- 
+
 Arrays cannot be passed directly to `DEF FN` functions, but a clean workaround exists using JSON serialization. Convert the array to a JSON string with `ASJSON`, pass the string as a parameter, then deserialize inside the function with `ASARRAY`. This is the accepted pattern in BazzBasic v1.2+.
- 
+
 ```basic
 DEF FN ProcessPlayer$(data$)
     DIM arr$
     LET count$ = ASARRAY(arr$, data$)
     RETURN arr$("name") + " score:" + arr$("score")
 END DEF
- 
+
 [inits]
     DIM player$
     player$("name") = "Alice"
     player$("score") = 9999
     player$("address,city") = "New York"
- 
+
 [main]
     LET json$ = ASJSON(player$)
     PRINT FN ProcessPlayer$(json$)
 END
 ```
- 
+
 **Notes:**
 - The function receives a full independent copy — changes inside do not affect the original array
 - Nested keys work normally: `arr$("address,city")` etc.
 - Overhead is similar to copying an array manually; acceptable for most use cases
+
 ---
- 
+
 ## Program Structure
- 
+
 ```basic
 ' ---- 1. FUNCTIONS (or INCLUDE "functions.bas/bb") ----
 DEF FN Clamp$(v$, lo$, hi$)
@@ -974,20 +986,20 @@ DEF FN Clamp$(v$, lo$, hi$)
     IF v$ > hi$ THEN RETURN hi$
     RETURN v$
 END DEF
- 
+
 ' ---- 2. INIT (declare ALL constants & variables here, not inside loops) ----
 ' Performance: variables declared outside loops avoid repeated existence checks.
 [inits]
 	LET SCREEN_W# = 640
 	LET SCREEN_H# = 480
 	LET MAX_SPEED# = 5
- 
+
     SCREEN 0, SCREEN_W#, SCREEN_H#, "My Game"
- 
+
     LET x$ = 320
     LET y$ = 240
     LET running$ = TRUE
- 
+
 ' ---- 3. MAIN LOOP ----
 [main]
     WHILE running$
@@ -998,13 +1010,13 @@ END DEF
     WEND
     SOUNDSTOPALL
 END ' place at the end of main program so BazzBasic wont fall to subs in runtime
- 
+
 ' ---- 4. SUBROUTINES (or INCLUDE "subs.bas") ----
 [sub:update]
     IF KEYDOWN(KEY_LEFT#)  THEN x$ = x$ - MAX_SPEED#
     IF KEYDOWN(KEY_RIGHT#) THEN x$ = x$ + MAX_SPEED#
 RETURN
- 
+
 [sub:draw]
     SCREENLOCK ON
     LINE (0,0)-(SCREEN_W#, SCREEN_H#), 0, BF
@@ -1012,28 +1024,30 @@ RETURN
     SCREENLOCK OFF
 RETURN
 ```
- 
+
 **Key conventions:**
 - Variables: `camelCase$` | Constants: `UPPER_SNAKE_CASE#` | Functions: `PascalCase$`
 - Labels: `[gameLoop]` for jump targets, `[sub:name]` for subroutines
 - Image/sound/shape IDs are stable integer handles — **always** store as constants: `LET MY_IMG# = LOADIMAGE("x.png")` — never use `$` variables for these
 - Group many IDs → use arrays: `DIM sprites$` / `sprites$("player") = LOADIMAGE(...)` — but prefer named constants when count is small
+
 ---
- 
+
 ## Performance Tips
- 
+
 - `LINE (0,0)-(W,H), 0, BF` to clear — much faster than `CLS`
 - Always wrap draw code in `SCREENLOCK ON` / `SCREENLOCK OFF`
 - Store `RGB()` results in constants/variables — don't call RGB in hot loops
 - Declare all variables in `[inits]`, not inside loops or subroutines
 - Use `FastTrig` for any loop calling trig hundreds of times per frame
 - `SLEEP 16` in game loop → ~60 FPS
+
 ---
- 
+
 ## Known Limitations
- 
+
 Things to be aware of — most are deliberate design decisions, a few are practical constraints.
- 
+
 - **No line numbers.** Never supported, never will be.
 - **Platform: Windows x64 only.** Linux and macOS are not supported. Browser/Android are not feasible — the runtime depends on SDL2 via P/Invoke.
 - **Arrays cannot be passed to functions.** Use the `ASJSON` / `ASARRAY` round-trip pattern. The function receives an independent copy.
@@ -1044,10 +1058,11 @@ Things to be aware of — most are deliberate design decisions, a few are practi
 - **No integer-division operator.** Use `INT(a / b)`, `FLOOR(a / b)`, or `CINT(a / b)` depending on the rounding behavior you need.
 - **Compiled `.bb` libraries are version-locked** to the BazzBasic build that produced them. Recompile after upgrading the interpreter.
 - **`DEF FN` definitions must precede their first call** in source order. Forward references don't resolve.
+
 ---
- 
+
 ## IDE Features
- 
+
 ### Menus
 | Menu | Items |
 |------|-------|
@@ -1057,27 +1072,29 @@ Things to be aware of — most are deliberate design decisions, a few are practi
 | **View** | Light Mode, Dark Mode (experimental; choice saved to `%AppData%\BazzBasic\ide.json`) |
 | **Run** | Run Program (F5), Compile as Exe, Compile as Library (.bb) |
 | **Help** | About, Online Manual, Beginner's Guide, Rosetta Code, Check for Updates |
- 
+
 **Version note:** In v1.4c and older, Find and Replace are under **Edit**, there is no Undo/Redo/Cut/Copy/Paste menu (the shortcuts still work in the editor), there is no View menu or Dark Mode, and Help has no Online Manual or Rosetta Code links. If a user says Find is under Edit, they have an older build.
- 
+
 ### New File Template
 When the IDE opens with no file (or a new file), this template is auto-inserted:
 ```basic
 ' BazzBasic version {ver_num}
 ' https://ekbass.github.io/BazzBasic/
 ```
- 
+
 ### Beginner's Guide
 - **IDE:** Menu → **Help** → **Beginner's Guide** — opens `https://github.com/EkBass/BazzBasic-Beginners-Guide/releases` in default browser
 - **CLI:** `bazzbasic.exe -guide` or `bazzbasic.exe -help` — prints URL to terminal
+
 ### Online Manual and Rosetta Code
 - **IDE:** Menu → **Help** → **Online Manual** — opens `https://ekbass.github.io/BazzBasic/manual/#/` in default browser
 - **IDE:** Menu → **Help** → **Rosetta Code** — opens `https://rosettacode.org/wiki/Category:BazzBasic` in default browser
 - No CLI equivalents
+
 ### Check for Updates
 - **IDE:** Menu → **Help** → **Check for Updates...** — IDE reports if a newer version is available
 - **CLI:** `bazzbasic.exe -checkupdates`
+
 ### Compile via IDE
 - **Menu → Run → Compile as Exe** — compiles open file to standalone `.exe` (auto-saves first)
-- **Menu → Run → Compile as Library (.bb)** — compiles open file as reusable `.bb` library (auto-saves first)
-
+- **Menu → Run → Compile as Library (.bb)** — compiles open file as reusable `.bb` library (auto-saves first)