// 贪吃蛇 —— 用 **Swift** 写的手机游戏
// Snake — a phone game written in **Swift**
//
// ✅ **状态：跑通了**（v0.96.189）。逐像素量出来的判据：蛇头 316 像素（1 格）、
// ✅ **Status: it runs** (v0.96.189). Criteria measured pixel by pixel: snake head 316 pixels (1 cell),
//   蛇身 632（2 格）、食物 316（1 格）—— **三个数都是精确的整格**；
//   snake body 632 (2 cells), food 316 (1 cell) — **all three numbers are exactly whole cells**;
//   棋盘格图元数 180（= 20×18 的一半，说明交替也对了）。
//   and the board-cell primitive count is 180 (= half of 20×18, showing the alternating pattern is right too).
//
// ## 卡了四轮的那个 bug：**括号表达式恒等于 0**（patch 0011）
// ## The bug that blocked it for four rounds: **parenthesized expressions are identically 0** (patch 0011)
//
// 症状极具误导性：`A[16 + (k) * 2]` 六次写入**全落到同一个槽**，换成纯常量下标
// The symptom is extremely misleading: six writes to `A[16 + (k) * 2]` **all landed in the same slot**, while plain constant indices
// `A[16]…A[21]` 就全对 ⇒ 看起来像"算式下标不能复用"。
// `A[16]…A[21]` were all correct ⇒ it looked like "computed indices cannot be reused".
// 真因是代码生成的 `GenerateExpression` 里**没有 `ParenthesizedExpression` 分支**，
// The real cause is that code generation's `GenerateExpression` **has no `ParenthesizedExpression` branch**,
// 落进 `default:` 被静默编成 `move R0 #0` —— **`(任意表达式)` 恒等于 0**，
// so it fell into `default:` and was silently compiled to `move R0 #0` — **`(any expression)` is identically 0**,
// 于是下标恒为 `16 + 0 * 2 = 16`。同一个洞还让 `(c + r) % 2 == 0` 的棋盘格从来没对过。
// leaving the index always `16 + 0 * 2 = 16`. The same hole also meant the `(c + r) % 2 == 0` checkerboard was never right.
//
// **判定这个结论的手段是读生成的汇编**（`vmlhost asm`），不是看现象猜 ——
// **The way this conclusion was reached is reading the generated assembly** (`vmlhost asm`), not guessing from symptoms —
// 那里一眼就能看到 `(k)` 被编成了 `move R0 #0`。同类洞 C# / JavaScript 也有（同一版修掉）。
// there you can see at a glance that `(k)` was compiled to `move R0 #0`. C# / JavaScript had the same hole (fixed in the same release).
// 修法之外还把 `default:` 从"静默发 0"改成**硬报错**：这类"编译全绿、跑起来错"的故障
// Besides the fix, `default:` was changed from "silently emit 0" to a **hard error**: this class of "compiles clean, wrong at run time" fault
// 正是最该编不过的那一种。
// is exactly the kind that most deserves not to compile.
//
// ✅ 2026-10-04 复验：上面两条**都仍成立**。
// ✅ Re-checked 2026-10-04: **both still hold**.
//    ① `(任意表达式)` 已不再恒等于 0 —— 实测 `ui_2d_line(16 + (k) * 2, …)`（k=5）落在 **x=26**（不是 16）。
//    (1) `(any expression)` is no longer identically 0 -- measured `ui_2d_line(16 + (k) * 2, …)` (k=5) lands at **x=26** (not 16).
//    ② `default:` 仍是硬报错（`CodeGenerator.GenerateExpression` 末尾 `throw CodeGenerationException`；
//    (2) `default:` is still a hard error (the `throw CodeGenerationException` at the end of `CodeGenerator.GenerateExpression`;
//       15 个表达式类型现在各有分支，正常源码走不到那里）。
//       all 15 expression types now have their own branch, so normal source never reaches it).
//
// 更早的两条阻塞点也已在 patch 0011 里：
// Two earlier blockers were also in patch 0011:
//     ① 全局数组初始化曾是死代码（定义了 func main 时顶层块不执行）；
//     ① global array initialization used to be dead code (the top-level block does not execute when `func main` is defined);
//     ② **函数的局部变量漏进全局数据段**、同名互相踩。
//     ② **a function's locals leaked into the global data segment** and same-named ones clobbered each other.
//   全 22 个前端的结论与根因：`docs/前端游戏能力评估.md`。
//   Conclusions and root causes across all 22 frontends: the frontend game-capability assessment doc under `docs/`.
//
// ## 为什么是 Swift
// ## Why Swift
//
// 手机那套 UI（开窗 / 绘图 / 输入 / 定时器）的实现是 C 写的
// The phone UI (window / drawing / input / timers) is implemented in C
// （`Lib/shared/src/vmlui.c` → `Lib/shared/vmlui.vml`），由 `vmltool.config.xml` 的
// (`Lib/shared/src/vmlui.c` → `Lib/shared/vmlui.vml`) and hooked to each frontend by
// `<Language ... Libs="vmlui.vml">` 挂给各前端。把 22 个前端逐个过筛（编译出图 / 循环 /
// `<Language ... Libs="vmlui.vml">` in `vmltool.config.xml`. After screening all 22 frontends one by one (compiles and draws / loops /
// 数组 / 函数 / 参数传递）之后，**Swift 是干净通过的那一门**：
// arrays / functions / argument passing), **Swift is the one that passes cleanly**:
//
//   ✔ 直接 `call` 到包装标签，且实参**逆序压栈**（包装读 `[R12+12]` = 最后压的那个）
//   ✔ `call`s the wrapper labels directly, with arguments **pushed in reverse order** (the wrapper reads `[R12+12]` = the last one pushed)
//   ✔ 循环 / 分支 / 数组读写 / 带参函数与返回值
//   ✔ loops / branches / array reads and writes / functions with arguments and return values
//   ✔ 定时器 + `ui_msg_fetch_wait` 收消息（游戏心跳）
//   ✔ timers + `ui_msg_fetch_wait` receiving messages (the game heartbeat)
//
// 其它语言的结论见 `docs/前端游戏能力评估.md`（Go/Pascal 条件跳转跳寄存器、JavaScript
// For other languages' conclusions see the frontend game-capability assessment doc under `docs/` (Go/Pascal conditional jumps to registers, JavaScript
// 把未知函数当变量 + 正序压栈、C# 参数槽串了…）。**没有一门是"差不多就行"的** ——
// treating unknown functions as variables + pushing in forward order, C#'s argument slots crossing…). **No frontend is "good enough"** —
// 这类毛病的表现都是"编译全绿、跑起来不对"。
// this class of fault always shows as "compiles clean, wrong at run time".
//
// ## 两条写法上的约束（都是实测出来的，不是偏好）
// ## Two style constraints (both measured, not preferences)
//
// ① **状态一律放数组**：这几门前端的**模块级标量**（`var n = 5`）读出来是垃圾
// ① **All state goes in arrays**: the **module-level scalars** of these frontends (`var n = 5`) read back as garbage
//    （在 C# 上是把标签**地址**当成了值）。数组是堆上的，读写都可靠。
//    (in C# the label **address** was taken as the value). Arrays live on the heap, so reads and writes are reliable.
// ② **常量写成 `main` 里的局部变量**：同理，模块级 `let` 也不可靠。
// ② **Constants are written as locals in `main`**: by the same reasoning, a module-level `let` is not reliable either.
//
// 数值的唯一真源仍是 `Lib/c/vml_ui.h`。
// The single source of truth for these numbers is still `Lib/c/vml_ui.h`.

#include <vml_ui.swift>
var A = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
// ⚠ **只用一个数组**。实测：同一程序里开多个全局数组（S / SEGX / SEGY）会互相踩内存 ——
// ⚠ **Use only one array**. Measured: opening several global arrays (S / SEGX / SEGY) in one program makes them clobber each other's memory —
// 症状是蛇只画出一节、HUD 文字错位（写蛇身把状态槽冲了）。一个数组不自我别名，绕开它。
//   0=head 1=len 2=dx 3=dy 4=fx 5=fy 6=score 7=best
//   8=alive 9=paused 10=stepMs 11=cell 12=ox 13=oy 14=sw 15=sh
//   16+2i=第 i 节 x，16+2i+1=第 i 节 y
//   16+2i=x of segment i, 16+2i+1=y of segment i
//   110=界面语言（0=中文 1=英文）—— 数组刻意留到 112 个，就是给这个槽用的
//   110=UI language (0=Chinese 1=English) — the array is deliberately sized to 112 just for this slot
//   （按上面 ① 的实测，语言码**不能**用模块级标量存：读出来是垃圾）
//   (per the measurement in ① above, the language code **cannot** be stored in a module-level scalar: it reads back as garbage)
func segx(i: Int) -> Int { return 16 + i * 2 }
func segy(i: Int) -> Int { return 17 + i * 2 }

func cw() -> Int { return 20 }
func ch() -> Int { return 18 }
func maxseg() -> Int { return 40 }

func cellColorBody() -> Int { return -11409298 }   // 0xFF51E86E
func cellColorHead() -> Int { return -63488 }      // 0xFFFF0800
func cellColorFood() -> Int { return -131246 }     // 0xFFFDFF52
func cellColorGrid() -> Int { return -15263713 }   // 0xFF17181F
func colorBg() -> Int { return -15724520 }         // 0xFF101018
func colorText() -> Int { return -6643536 }        // 0xFF9AA0B0

func numToStr(v: Int) -> String {
    if v == 0 { return "0" }
    var s = ""
    var n = v
    if n < 0 { n = 0 - n }
    while n > 0 {
        var d = n % 10
        if d == 0 { s = "0" + s }
        else if d == 1 { s = "1" + s }
        else if d == 2 { s = "2" + s }
        else if d == 3 { s = "3" + s }
        else if d == 4 { s = "4" + s }
        else if d == 5 { s = "5" + s }
        else if d == 6 { s = "6" + s }
        else if d == 7 { s = "7" + s }
        else if d == 8 { s = "8" + s }
        else { s = "9" + s }
        n = n / 10
    }
    if v < 0 { s = "-" + s }
    return s
}

func occupied(c: Int, r: Int) -> Int {
    var i = 0
    while i < A[1] {
        var k = A[0] - i
        while k < 0 { k = k + maxseg() }
        if A[16 + (k) * 2] == c && A[17 + (k) * 2] == r { return 1 }
        i = i + 1
    }
    return 0
}

func placeFood() {
    var tries = 0
    while tries < 500 {
        var c = ui_math_rand(cw())
        var r = ui_math_rand(ch())
        if occupied(c, r) == 0 {
            A[4] = c
            A[5] = r
            return
        }
        tries = tries + 1
    }
    A[4] = 0
    A[5] = 0
}

func drawCell(c: Int, r: Int, color: Int) {
    ui_2d_rect(A[12] + c * A[11], A[13] + r * A[11], A[11] - 1, A[11] - 1, color, 1, 0, 2)
}

func draw() {
    ui_2d_clear(colorBg())
    var c = 0
    while c < cw() {
        var r = 0
        while r < ch() {
            if (c + r) % 2 == 0 { drawCell(c, r, cellColorGrid()) }
            r = r + 1
        }
        c = c + 1
    }
    drawCell(A[4], A[5], cellColorFood())
    var i = 0
    while i < A[1] {
        var k = A[0] - i
        while k < 0 { k = k + maxseg() }
        if i == 0 { drawCell(A[16 + (k) * 2], A[17 + (k) * 2], cellColorHead()) }
        else { drawCell(A[16 + (k) * 2], A[17 + (k) * 2], cellColorBody()) }
        i = i + 1
    }
    // 界面语言（0=中文 1=英文）：从状态表里取个局部量 —— 模块级标量读出来是垃圾（见文件头 ①）。
    // UI language (0=Chinese 1=English): pull it from the state table into a local — a module-level scalar reads back as garbage (see header ①).
    var lang = A[110]
    // ui_2d_text 的 y 是文字**底边** ⇒ 顶部 HUD 要留出字高，否则 240x240 上被裁掉上半截
    // ui_2d_text's y is the text **bottom**, so the top HUD needs room for its own height;
    // otherwise the upper half is cut off on 240x240.
    ui_2d_text(8, 22, lang == 0 ? "得分" : "Score", colorText(), 13, VML_ANCHOR_LEFT)
    ui_2d_text(56, 22, numToStr(A[6]), -1, 15, VML_ANCHOR_LEFT)
    ui_2d_text(A[14] / 2, 22, lang == 0 ? "最高" : "Best", colorText(), 13, VML_ANCHOR_CENTER)
    ui_2d_text(A[14] / 2 + 44, 22, numToStr(A[7]), -1, 15, VML_ANCHOR_LEFT)
    if A[9] != 0 { ui_2d_text(A[14] / 2, A[15] / 2, lang == 0 ? "暂停（SELECT 继续）" : "Paused (SELECT)", cellColorFood(), 16, VML_ANCHOR_CENTER) }
    ui_2d_present()
}

func reset() {
    A[1] = 3        // 长度
    // length
    A[0] = 2        // 头下标
    // head index
    A[16 + (0) * 2] = 8; A[17 + (0) * 2] = 8
    A[16 + (1) * 2] = 7; A[17 + (1) * 2] = 8
    A[16 + (2) * 2] = 6; A[17 + (2) * 2] = 8
    A[2] = 1; A[3] = 0
    A[6] = 0
    A[8] = 1
    A[9] = 0
    A[10] = 170
    placeFood()
}

func gameOver() {
    A[8] = 0
    // 音效：单音 ui_audio_beep；**结局音取最低音**（吃到 1047 / 撞到 131，差得开）
    // Sound: single-tone ui_audio_beep; **the ending tone takes the lowest note** (1047 on eating / 131 on a crash — far enough apart)
    //   v0.96.509 从音序器换回来 —— 那一版多声部叠加 / 长音在真机上破音
    //   switched back from the sequencer in v0.96.509 — that version's multi-voice stacking / long notes broke up on real devices
    ui_audio_beep(131, 320)
    draw()
    var lang = A[110]
    if ui_dlg_msg(lang == 0 ? "贪吃蛇" : "Snake", lang == 0 ? "撞到了，这一局结束。\n再来一局？（选「否」退出）" : "You crashed. Round over.\nPlay again? (choose 'No' to quit)", VML_DLG_INFO) != 0 { ui_win_close(); return }
    reset()
}

func step() -> Int {
    if A[8] == 0 || A[9] != 0 { return 0 }
    var nc = A[16 + (A[0]) * 2] + A[2]
    var nr = A[17 + (A[0]) * 2] + A[3]
    if nc < 0 || nc >= cw() || nr < 0 || nr >= ch() {
        gameOver()
        return 1
    }
    var i = 0
    while i < A[1] - 1 {
        var k = A[0] - i
        while k < 0 { k = k + maxseg() }
        if A[16 + (k) * 2] == nc && A[17 + (k) * 2] == nr {
            gameOver()
            return 1
        }
        i = i + 1
    }
    var eat = 0
    if nc == A[4] && nr == A[5] { eat = 1 }
    A[0] = A[0] + 1
    if A[0] >= maxseg() { A[0] = 0 }
    A[16 + (A[0]) * 2] = nc
    A[17 + (A[0]) * 2] = nr
    if eat != 0 {
        if A[1] < maxseg() { A[1] = A[1] + 1 }
        A[6] = A[6] + 10
        if A[6] > A[7] { A[7] = A[6] }
        if A[10] > 70 { A[10] = A[10] - 6 }
        // 音效：单音 ui_audio_beep（吃到食物：一声高而短的「叮」）
        // Sound: single-tone ui_audio_beep (eating food: a short, high "ding")
        ui_audio_beep(1047, 165)
        placeFood()
    }
    return 1
}

func turn(nx: Int, ny: Int) {
    if nx + A[2] == 0 && ny + A[3] == 0 { return }
    A[2] = nx
    A[3] = ny
}

func main() {
    // 常量（源：Lib/c/vml_ui.h）—— 只能放局部变量，见文件头 ②
    // Constants (source: Lib/c/vml_ui.h) — locals only, see header ②
    var KEY_ENTER = 13
    var KEY_SELECT = 16
    var KEY_ESCAPE = 27
    var KEY_LEFT = 37
    var KEY_UP = 38
    var KEY_RIGHT = 39
    var KEY_DOWN = 40
    var MSG_TIMER = 9
    var MSG_KEYDOWN = 1
    var MSG_CLOSE = 10

    // 界面语言：开局问一次宿主要中文还是英文（0=中文 1=英文），存进 A[110]（见 draw）。
    // UI language: ask the host once at the start whether it wants Chinese or English (0=Chinese 1=English) and store it in A[110] (see draw).
    // ⚠ 别在每帧里调 —— 那是一次 syscall。
    // ⚠ Don't call it in every frame — that's a syscall.
    A[110] = ui_scr_get_language()
    var lang = A[110]
    // 开窗：尺寸传 0 ⇒ 交给宿主给真实可用区（开窗**之前**问到的只是估算值）
    // Opening: pass size 0 ⇒ the host supplies the real available area (a **pre-open** read is only an estimate)
    ui_win_open(lang == 0 ? "贪吃蛇" : "Snake", 0, 0)

    // 尺寸先落到局部再存进状态表 —— **实测**：把 `A[14] = ui_scr_get_w()` 直接喂给
    // The size lands in a local first and is then stored into the state table — **measured**: feeding `A[14] = ui_scr_get_w()` straight into
    // `ui_win_open` 会开出一个 60×64 的小窗（编译全绿、只有出图才看得出来）；
    // `ui_win_open` opens a tiny 60×64 window (compiles clean; only visible once it draws);
    // 经一道局部变量就正常。这类"某个位置读全局就是不行"的坑，各前端都不一样，
    // passing through a local makes it normal. This kind of "reading a global in one particular spot just doesn't work" pitfall differs per frontend,
    // 唯一的办法是**出图看**，不能靠推断。
    // and the only way is to **draw it and look**, not to reason it out.
    // 尺寸：开窗**之后**再问一次 —— 这时 `ui_scr_get_w/h` 给的是实测画布（真值）
    // Size: re-read **after** the open — `ui_scr_get_w/h` now report the measured canvas (the real value)
    var w = ui_scr_get_w()
    var h = ui_scr_get_h()
    if w <= 0 { w = 360 }
    if h <= 0 { h = 620 }
    A[14] = w
    A[15] = h

    // 版面算一次，画与判定共用
    // The layout is computed once and shared by drawing and hit-testing
    var byw = A[14] - 8
    var byh = A[15] - 46
    A[11] = byw / cw()
    if byh / ch() < A[11] { A[11] = byh / ch() }
    if A[11] < 4 { A[11] = 4 }
    A[12] = (A[14] - A[11] * cw()) / 2
    A[13] = 40

    ui_scr_set_keep_on(1)
    reset()
    draw()

    var tid = ui_timer_set(A[10], 0)
    var curMs = A[10]
    var acc = 0                     // 运动墙钟欠账（毫秒）—— 按墙钟补步，用户 2026-10-04 口径
                                    // Motion wall-clock debt in ms — step by wall clock (user rule, 2026-10-04)
    var lastMs = ui_time_get_ms()   // 上次补步取的墙钟时刻（墙钟起点，进主循环时取）
                                    // Wall-clock time of the last step (taken when entering the main loop)

    while ui_win_is_closed() == 0 {

        var t = ui_msg_fetch_wait(0)

        // 这一帧该走几步：**按墙钟欠账**（各平台定时器分辨率不同 ⇒ 不能拿"收到几拍"当时间）。
        // How many steps this frame: **by wall-clock debt** (timer resolution differs per platform, so
        // 用户 2026-10-04 口径：所有游戏时钟取系统毫秒数。
        // "how many ticks arrived" is not a measure of time).
        // User rule of 2026-10-04: every game clock reads system milliseconds.
        var nowMs = ui_time_get_ms()
        acc = acc + (nowMs - lastMs)
        lastMs = nowMs
        if acc > A[10] * 8 { acc = 0 }      // 卡太久别一次补一大串（防瞬移）
                                        // Do not catch up in one huge burst after a long stall (anti-teleport)
        while acc >= A[10] {
            acc = acc - A[10]
            if step() != 0 { draw() }
        }

        if t == 0 { continue }
        if t == MSG_CLOSE { break }
        if t == MSG_TIMER {
            // 定时器**只负责唤醒**（推进在上面按墙钟欠账走）
            // The timer **only wakes us up** — the advance happens above, by wall-clock debt
            if A[10] != curMs {
                ui_timer_kill(tid)
                curMs = A[10]
                tid = ui_timer_set(curMs, 0)
            }
            continue
        }
        if t == MSG_KEYDOWN {
            var k = ui_msg_get_a()
            if k == KEY_ESCAPE { break }
            else if k == KEY_LEFT { turn(-1, 0) }
            else if k == KEY_RIGHT { turn(1, 0) }
            else if k == KEY_UP { turn(0, -1) }
            else if k == KEY_DOWN { turn(0, 1) }
            else if k == KEY_ENTER { reset(); draw() }
            else if k == KEY_SELECT {
                if A[9] != 0 { A[9] = 0 } else { A[9] = 1 }
                draw()
            }
        }
    }

    ui_timer_kill(tid)
    ui_scr_set_keep_on(0)
    ui_win_close()
}
