← 都来码 / Dolaima← 例程索引javascript/app/maze.js▶ 在浏览器里试玩 原文

javascript/app/maze.js · 43162 字节 · 下载原文

▶ 在浏览器里试玩

// 迷宫寻路 —— 用 **JavaScript** 写的手机游戏(走格子 / 迷宫品类)
// Maze Runner -- a mobile game written in **JavaScript** (grid / maze genre)
//
// 玩法:程序随机挖一座迷宫(深度优先 + 显式栈),从左上角走到右下角,步数越少越好。
// Gameplay: the program carves a random maze (depth-first with an explicit stack); walk from the top-left to the bottom-right in as few steps as possible.
// 按 `H` 提示下一步(BFS 从出口算最短距离),走到出口弹出成绩单 + 排行榜。
// Press `H` for a hint (BFS from the exit computes shortest distances); reaching the exit pops a score card plus a leaderboard.
//
// ## 操作
// ## Controls
//
//   · 方向键 / WASD 走一步(撞墙有闷响,不扣分)
//   · Arrow keys / WASD take one step (a wall is a dull thud, no penalty)
//   · **点迷宫里的任意一格** —— 沿那条唯一的通路朝它走一步(手机上的主要操作方式)
//   · **Tapping any cell in the maze** -- walks one step toward it along the one route (the main way to play on a phone)
//   · `H` 提示 · `R` / 回车 换一座新迷宫 · `Esc` 退出
//   · `H` hint, `R` / Enter a new maze, `Esc` quit
//
// ## 为什么这个游戏**没有定时器**
// ## Why this game has **no timer**
//
// 它是回合制的:画面只在「走了一步 / 按了键」之后才变。
// It is turn-based: the picture only changes after "a step was taken / a key was pressed".
// 一座 11×15 的迷宫有 ≈190 段墙,每帧重画一遍是纯浪费(手机上每帧要几百次绘制调用)。
// An 11x15 maze has about 190 wall segments; redrawing every frame is pure waste (hundreds of draw calls per frame on a phone).
// ⇒ 没有 `ui_timer_set`,主循环就阻塞在 `ui_msg_fetch_wait(0)` 上;这与「真·实时游戏必须开定时器」不矛盾。
// => There is no `ui_timer_set`; the main loop simply blocks on `ui_msg_fetch_wait(0)`. That does not contradict "a real-time game must start a timer".
//
// ## 这一门前端的四条硬约束(全部实测,照抄 `typing_rain.js` 那份的写法)
// ## Four hard constraints of this frontend (all measured; the same discipline as `typing_rain.js`)
//
//   ① ~~**文件顶层的语句一条都不执行**(有 `function main()` 时入口标签就是 `main`)⇒ 全局状态全在 `newRound()`/`main()` 里赋值。~~
//   ① ~~**No top-level statement runs** (with `function main()` present the entry label *is* `main`) => global state is assigned inside `newRound()`/`main()`.~~
//      ✅ **已修好(2026-10-04 复验)**:顶层语句现在会跑(实测顶层 `console.log("TOP");` 先打出 `TOP`,`var G = 5;` 读回 5)。
//      ✅ **fixed (re-checked 2026-10-04)**: top-level statements now run (measured: a top-level `console.log("TOP");` prints `TOP`; a top-level `var G = 5;` reads back 5).
//      ⚠ **2026-10-13 补完**:2026-10-04 那次只修好了「顶层**没有**显式调 `main()`」这一种形状;
//         顶层写了 `main();` 的仍然红(`var K = 88;` 在 `main()` 里读回 0)—— 因为那时入口标签仍与用户
//         那个 `function main` 撞名。本次把入口换成顶层块**自己的**标签(`__js_toplevel`)⇒ 两种形状都对。
//      ⚠ **completed 2026-10-13**: the 2026-10-04 fix only covered programs whose top level does *not*
//         explicitly call `main()`; with a top-level `main();` the variable still read back 0, because the
//         entry label still collided with the user's `function main`. The entry is now the top-level block's
//         **own** label (`__js_toplevel`), so both shapes work.
//      ⇒ 本文件**照旧**把全局状态放 `newRound()`/`main()` 里赋值(能跑就别动;新写的代码不必再绕)。
//      => this file **still** assigns global state inside `newRound()`/`main()` (if it runs, leave it alone; newly written code need not work around it).
//   ② **函数里的 `var` 是全局标签,只有形参是真局部** ⇒ 每个函数用前缀命名自己的 `var`(`g*`、`dk*`…)。
//   ② **A `var` inside a function is a global label; only parameters are truly local** => every function prefixes its own `var` names (`g*`, `dk*`, ...).
//   ③ ~~**常量必须 `#define`**(`var C_X = …` 在文件级永远是 0;颜色 0 = alpha 全透明 = 黑屏)。~~
//   ③ ~~**Constants must be `#define`s** (a file-level `var C_X = …` is always 0; colour 0 = fully transparent = a black screen).~~
//      ~~⚠ 而且**未定义的名字不报错**:本轮把 `C_BLUE` 拼漏了,它被当成变量(= 0)编了过去,~~
//      ~~Warning: **an undefined name is not an error** either: `C_BLUE` was mistyped here and compiled as a variable (= 0),~~
//      ~~症状是结算里"转弯"那个数字**画了但全透明**(trace-draw 里 `str="4" 0x00000000`)。改一处拼写前先看颜色值。~~
//      ~~the symptom being a "turns" digit that **is drawn but fully transparent** (trace-draw shows `str="4" 0x00000000`). Check the colour value first when something is invisible.~~
//      ✅ **已修好(2026-10-04 复验)**:顶层 `var CTOP = -15724520` 画成 `0xFF101018`(不再 `0x00000000`);
//      ✅ **fixed (re-checked 2026-10-04)**: a top-level `var CTOP = -15724520` draws as `0xFF101018` (no longer `0x00000000`);
//        拼错的名字(`CMISPELLED`)现在报 `error: 未声明的变量 'CMISPELLED' [CodeGen_UndefinedVariable]`,编译失败。
//        a misspelt name (`CMISPELLED`) now reports `error: undeclared variable 'CMISPELLED' [CodeGen_UndefinedVariable]` and fails to compile.
//      ⇒ 本文件照旧全用 `#define`(能跑就别动;新写的代码可以用 `var`)。
//      => this file **still** uses `#define` throughout (if it runs, leave it alone; newly written code may use `var`).
//   ④ **`push` 不扩容、`s.length` 读串的前 4 字节** ⇒ 见下面两条各自的注释。
//   ④ **`push` never grows, and `s.length` reads a string's first four bytes** => see the comments on each below.
//
// ## 数组的定容与「长大」:`bigArr()`
// ## Fixed capacity, and how arrays "grow" here: `bigArr()`
//
// `arr_push` 只把长度 +1 再写一个元素,**没有容量字段**;字面量的容量就是它的格数。
// `arr_push` only increments the length and writes one element; **there is no capacity field**, so a literal's capacity is exactly its slot count.
// 迷宫要 165 格(11×15),写字面量太笨 ⇒ `bigArr()` 用 `a = a.concat(a)` **翻倍八次**造出容量 256 的数组。
// The maze needs 165 cells (11x15) and writing that literal is clumsy => `bigArr()` uses `a = a.concat(a)` **eight times** to build a 256-slot array.
// (`concat` 自己 malloc 一块正好的缓冲,所以这么长大的数组容量是**确定**的。)
// (`concat` mallocs an exactly sized buffer itself, so an array grown this way has a **definite** capacity.)
// 长度头在 `ptr+0`、元素 i 在 `ptr+4+4i`,**从 JS 侧写 `arr[0-1]` 就是写长度头** ⇒ 用它把数组清空。
// The length header is at `ptr+0` and element i at `ptr+4+4i`; **`arr[0-1]` from JS writes that header** => that is how the array is emptied.
//
// ## 跑法
// ## How to run
//   手机   vml run examples/javascript/maze.js
//   phone  vml run examples/javascript/maze.js
//   桌面   vmlcli Examples/javascript/maze.js --vml-home <vml根> --screen 395x578 --trace-draw /tmp/tr.txt
//   desktop vmlcli Examples/javascript/maze.js --vml-home <vml root> --screen 395x578 --trace-draw /tmp/tr.txt

// UI 库声明:**一条显式引用**(本前端实测为**文档级** —— 删掉照样编过、画面一样,见文件尾的说明)。
// UI library declarations: **one explicit reference** (measured as **documentation-level** here -- deleting it still compiles and draws the same; see the note at the end of this file).
#include <vml_ui.js>

// 颜色:~~必须 `#define`~~(✅ **2026-10-04 复验:写 `var` 也不会变 0 了**,实测顶层 `var CTOP = -15724520` 画成 `0xFF101018`;
// Colours: ~~must be `#define`s~~ (✅ **re-checked 2026-10-04: a `var` no longer becomes 0**; measured: a top-level `var CTOP = -15724520` draws as `0xFF101018`;
//   本文件照旧全用 `#define`,能跑就别动;新写的代码可以用 `var`),负数十进制 = 0xAARRGGBB。
//   this file **still** uses `#define` throughout, if it runs leave it alone; newly written code may use `var`); negative decimals equal 0xAARRGGBB.
#define C_BG -15724520
// 0xFF101018 background
#define C_WALL -11890471
// 0xFF4A90D9 wall
#define C_BLUE -11890471
// 0xFF4A90D9 blue (the turn counter)
#define C_DIM -15066588
// 0xFF1A1A24 dim panel
#define C_TEXT -6643536
// 0xFF9AA0B0 body text
#define C_GREEN -11409298
// 0xFF51E86E player
#define C_GOLD -2509750
// 0xFFD9B44A exit
#define C_RED -45747
// 0xFFFF4D4D red
#define C_MARK -8096
// 0xFFFFE060 hint marker
#define C_TRAIL -13669574
// 0xFF2F6B3A trail

// 墙的四个方向位(一个格子的墙用一个位掩码表示)。
// The four wall bits (one cell's walls are one bitmask).
#define N_BIT 1
// north bit
#define E_BIT 2
// east bit
#define S_BIT 4
// south bit
#define W_BIT 8
// west bit

// ── 全局状态(**全部在 newRound()/main() 里赋值** —— 见约束 ①)──
// -- Global state (**all assigned in newRound()/main()** -- see constraint (1)) --
var GW = 0;
// canvas width
var GH = 0;
// canvas height
var GLANG = 0;
// 0 = Chinese
var GCOLS = 0;
// maze columns (**assigned in main()** -- a file-level 11 would be 0 and the first `/ GCOLS` would divide by zero)
var GROWS = 0;
// maze rows (assigned in main() for the same reason)
var GCELL = 0;
// cell size in pixels
var GX0 = 0;
// maze origin x
var GY0 = 0;
// maze origin y
var GPU = 0;
// player column
var GPV = 0;
// player row
var GSTEPS = 0;
// steps taken
var GBEST = 0;
// optimal step count (BFS)
var GLIMIT = 0;
// step limit for this maze (3x the optimal); going past it loses the round
var GOVER = 0;
var GWIN = 0;
var GQUIT = 0;
var GTIER = 0;
// difficulty tier index
var GHU = -1;
// hint column (-1 = none)
var GHV = -1;
var GTURNS = 0;
// turn count
var GSCFAIL = 0;
var MAZE = 0;
var DIST = 0;
var DIST2 = 0;
// distance to a tapped cell (tap-to-walk)
var QUE = 0;
var PATH = 0;
var DIRS = 0;
var LED = 0;
var G_LSZ = 13;
var G_NSZ = 20;
var G_ISZ = 12;
var G_HY = 24;
var G_IY = 30;
var CAND = 0;
var MULT = 0;
var DOTSX = 0;
var DOTSY = 0;

// 容量 256 的数组:**直接写字面量**(256 个 0),再 `[0-1]=0` 清空长度。
// A 256-slot array: **a direct literal** of 256 zeros, then `[0-1]=0` empties its length.
// ⚠ 原来那套 `a = a.concat(a)` 翻倍八次造出来的数组,在本前端**清空长度之后 `push` 是空转**
// (实测 `arr[-1]=0` 后 `push` 165 次,`length` 仍是 0,迷宫因此画不出墙);字面量数组没这个问题。
// ⚠ Arrays made by `a = a.concat(a)` cannot be `push()`ed after the length header is cleared
// in this frontend (measured: 165 pushes after `arr[-1]=0` left `length` at 0, so the maze drew
// no walls at all); literal arrays do not have this problem.
function bigArr() {
    var b1a = [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,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,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];
    b1a[0 - 1] = 0;
    return b1a;
}

// 容量 4 / 8 的小数组。
// Small arrays of capacity 4 and 8.
function z4() { var z4a = [0, 0, 0, 0]; z4a[0 - 1] = 0; return z4a; }
// four-slot factory
function z8() { var z8a = [0, 0, 0, 0, 0, 0, 0, 0]; z8a[0 - 1] = 0; return z8a; }
// eight-slot factory

// 数字 → 单字符串(本前端没有可用的 intToStr;只能 if 链返回字面量)。
// Digit -> one-character string (no usable intToStr here; an if-chain returning literals is the only way).
function digitStr(pd) {
    if (pd == 0) { return "0"; }
    if (pd == 1) { return "1"; }
    if (pd == 2) { return "2"; }
    if (pd == 3) { return "3"; }
    if (pd == 4) { return "4"; }
    if (pd == 5) { return "5"; }
    if (pd == 6) { return "6"; }
    if (pd == 7) { return "7"; }
    if (pd == 8) { return "8"; }
    return "9";
}

// ⚠ 本前端**没有整除**:`/` 返回浮点(`GW`/`GH` 也是宿主返回的浮点)。
// 浮点一旦参与坐标/下标运算,传给 ui_2d_rect/circle 的就是浮点位模式 —— 画面上表现为
// 天文数字般的坐标(实测 rect 的 x=-836861952)。所有「几何/下标」的除法一律走这个助手。
// ⚠ No integer division here: `/` yields a float (even the host's `GW`/`GH` come back as floats).
// Once a float feeds a coordinate/index, ui_2d_rect/circle receives its raw bit pattern, which
// shows up as astronomical coordinates (measured x=-836861952). Route every geometric/index
// division through this helper.
function mzDiv(pa, pb) {
    if (pb <= 0) { return 0; }
    var mzq = 0;
    var mzr = pa;
    if (mzr < 0) { mzr = 0 - mzr; }
    while (mzr >= pb) { mzr = mzr - pb; mzq = mzq + 1; }
    if (pa < 0) { return 0 - mzq; }
    return mzq;
}

// 画非负整数(逐位查表;字号 20 的一位推进量实测 = 10px,见 typing_rain.js 的同名说明)。
// Draw a non-negative integer (one table lookup per digit; at size 20 a digit advances 10 px, measured -- same helper as in typing_rain.js).
function drawNum(dnx, dny, dnv, dncol, dnsz) {
    var dnnd = 1;
    var dnt = dnv;
    while (dnt >= 10) { dnt = mzDiv(dnt, 10); dnnd = dnnd + 1; }
    var dnpx = dnx;
    var dnk = dnnd;
    while (dnk > 0) {
        dnk = dnk - 1;
        var dnpw = 1;
        var dnq = 0;
        while (dnq < dnk) { dnpw = dnpw * 10; dnq = dnq + 1; }
        ui_2d_text(dnpx, dny, digitStr(mzDiv(dnv, dnpw) % 10), dncol, dnsz, 0);
        dnpx = dnpx + mzDiv(dnsz, 2);
    }
}

// 格心 x / y(画玩家、路点、提示框共用同一套算式)。
// Cell centre x / y (the player, the trail dots and the hint box all use the same formula).
function cellX(pcx) { return GX0 + pcx * GCELL + mzDiv(GCELL, 2); }
// cell centre x
function cellY(pcy) { return GY0 + pcy * GCELL + mzDiv(GCELL, 2); }

// 生成迷宫:递归回溯(递归用**显式栈** —— 本前端没有可靠的深递归)。
// Carve the maze: recursive backtracker (recursion replaced by an **explicit stack** -- deep recursion is not reliable here).
// 这里的 `DIST` 暂且当「访问标记」(1 = 进过),`QUE` 当栈;`solveDist()` 随后会把它整个重写成 BFS 距离。
// Here `DIST` temporarily serves as the "visited" flag (1 = visited) and `QUE` as the stack; `solveDist()` then rewrites it entirely as BFS distances.
// 候选邻格先用 `filter` 收一遍(`filter` 在本游戏里的正当用处),空 ⇒ 回溯。
// The candidate neighbours are narrowed with `filter` (`filter`'s legitimate job in this game); empty => backtrack.
function genMaze() {
    var gnn = GCOLS * GROWS;
    MAZE[0 - 1] = 0;
    var gi = 0;
    // 15 = 四面都是墙
    // 15 = walls on all four sides
    while (gi < gnn) { MAZE.push(15); gi = gi + 1; }

    QUE[0 - 1] = 0;
    DIST[0 - 1] = 0;
    var gj = 0;
    // DIST:-1 = 还没进过迷宫
    // DIST: -1 = not carved into the maze yet
    while (gj < gnn) { DIST.push(0 - 1); gj = gj + 1; }

    QUE.push(0);
    DIST[0] = 1;
    while (QUE.length > 0) {
        var gcur = QUE[QUE.length - 1];
        var gcc = gcur % GCOLS;
        var gcr = mzDiv(gcur, GCOLS);
        // 四个方向里**在界内**的邻格先收齐,再用 filter 去掉已访问的
        // Collect the **in-bounds** neighbours of all four directions first, then drop the visited ones with filter
        CAND[0 - 1] = 0;
        if (gcr > 0) { CAND.push(gcur - GCOLS); }
        if (gcc < GCOLS - 1) { CAND.push(gcur + 1); }
        if (gcr < GROWS - 1) { CAND.push(gcur + GCOLS); }
        if (gcc > 0) { CAND.push(gcur - 1); }
        var gopen = CAND.filter(function (gcq) { return DIST[gcq] < 0; });
        if (gopen.length == 0) {
            QUE.pop();
        } else {
            var gpick = gopen[ui_math_rand(gopen.length)];
            // 拆掉两格之间的那面墙(`& ~bit` 清位)
            // Knock out the wall between the two cells (clear a bit with `& ~bit`)
            if (gpick == gcur - GCOLS) { MAZE[gcur] = MAZE[gcur] & (0 - 2); MAZE[gpick] = MAZE[gpick] & (0 - 5); }
            if (gpick == gcur + 1) { MAZE[gcur] = MAZE[gcur] & (0 - 3); MAZE[gpick] = MAZE[gpick] & (0 - 9); }
            if (gpick == gcur + GCOLS) { MAZE[gcur] = MAZE[gcur] & (0 - 5); MAZE[gpick] = MAZE[gpick] & (0 - 2); }
            if (gpick == gcur - 1) { MAZE[gcur] = MAZE[gcur] & (0 - 9); MAZE[gpick] = MAZE[gpick] & (0 - 3); }
            QUE.push(gpick);
            DIST[gpick] = 1;
        }
    }
    // 额外拆几面墙(档位越高越多)—— 迷宫就有了环路,不再是唯一解
    // Knock out a few extra walls (more at higher tiers) -- the maze gains loops, so the route is no longer unique
    var gk = 0;
    var gwant = GTIER * 3;
    while (gk < gwant) {
        var gcell = ui_math_rand(gnn);
        var gd = ui_math_rand(4);
        var gcc2 = gcell % GCOLS;
        var gcr2 = mzDiv(gcell, GCOLS);
        if (gd == 0 && gcr2 > 0) { MAZE[gcell] = MAZE[gcell] & (0 - 2); MAZE[gcell - GCOLS] = MAZE[gcell - GCOLS] & (0 - 5); }
        if (gd == 1 && gcc2 < GCOLS - 1) { MAZE[gcell] = MAZE[gcell] & (0 - 3); MAZE[gcell + 1] = MAZE[gcell + 1] & (0 - 9); }
        if (gd == 2 && gcr2 < GROWS - 1) { MAZE[gcell] = MAZE[gcell] & (0 - 5); MAZE[gcell + GCOLS] = MAZE[gcell + GCOLS] & (0 - 2); }
        if (gd == 3 && gcc2 > 0) { MAZE[gcell] = MAZE[gcell] & (0 - 9); MAZE[gcell - 1] = MAZE[gcell - 1] & (0 - 3); }
        gk = gk + 1;
    }
}

// BFS:从 `psrc` 往所有格算最短步数,写进 `parr`(-1 = 到不了 / 没访问过)。
// BFS: shortest step count from `psrc` to every cell, written into `parr` (-1 = unreachable / not visited).
// 队列用 `QUE`(push 入队、下标出队)。**数组可以当形参传**(形参是真局部),
// The queue is `QUE` (push to enqueue, an index to dequeue). **An array can be passed as a parameter** (parameters are truly local),
// 所以 `DIST`(到出口的距离,提示用)与 `DIST2`(到任意格的距离,点哪走哪用)共用这一份实现。
// so `DIST` (distance to the exit, for hints) and `DIST2` (distance to an arbitrary cell, for tap-to-walk) share this one implementation.
function bfsFrom(psrc, parr) {
    var bn = GCOLS * GROWS;
    parr[0 - 1] = 0;
    var bi = 0;
    while (bi < bn) { parr.push(0 - 1); bi = bi + 1; }
    QUE[0 - 1] = 0;
    parr[psrc] = 0;
    QUE.push(psrc);
    var bhead = 0;
    while (bhead < QUE.length) {
        var bcur = QUE[bhead];
        bhead = bhead + 1;
        var bd = parr[bcur];
        var bw = MAZE[bcur];
        var bcc = bcur % GCOLS;
        var bcr = mzDiv(bcur, GCOLS);
        if ((bw & N_BIT) == 0 && bcr > 0) { pushDist(parr, bcur - GCOLS, bd + 1); }
        if ((bw & E_BIT) == 0 && bcc < GCOLS - 1) { pushDist(parr, bcur + 1, bd + 1); }
        if ((bw & S_BIT) == 0 && bcr < GROWS - 1) { pushDist(parr, bcur + GCOLS, bd + 1); }
        if ((bw & W_BIT) == 0 && bcc > 0) { pushDist(parr, bcur - 1, bd + 1); }
    }
}
// 入队一个邻格(没访问过才入)。
// Enqueue a neighbour (only if it has not been reached yet).
function pushDist(parr, ppc, ppd) {
    if (parr[ppc] < 0) {
        parr[ppc] = ppd;
        QUE.push(ppc);
    }
}

// 朝 `ptar` 走一步:从目标格 BFS 一遍,挑一个「恰好近一步」的邻居(有唯一解就是唯一的那条路)。
// Take one step toward `ptar`: BFS from the target cell and pick the neighbour exactly one step closer (unique in a perfect maze).
// 这就是手机上的主要操作 —— 点任意一格都沿**那条唯一的通路**朝它挪一步,而不是"点哪跳哪"。
// This is the main mobile gesture: tapping any cell walks one step along **the one route** toward it, instead of teleporting there.
function stepToward(ptar) {
    bfsFrom(ptar, DIST2);
    var here = GPV * GCOLS + GPU;
    if (DIST2[here] <= 0) { return 0; }
    var hw = MAZE[here];
    var hcc = here % GCOLS;
    var hcr = mzDiv(here, GCOLS);
    if ((hw & N_BIT) == 0 && hcr > 0 && DIST2[here - GCOLS] == DIST2[here] - 1) { return tryMove(0); }
    if ((hw & E_BIT) == 0 && hcc < GCOLS - 1 && DIST2[here + 1] == DIST2[here] - 1) { return tryMove(1); }
    if ((hw & S_BIT) == 0 && hcr < GROWS - 1 && DIST2[here + GCOLS] == DIST2[here] - 1) { return tryMove(2); }
    if ((hw & W_BIT) == 0 && hcc > 0 && DIST2[here - 1] == DIST2[here] - 1) { return tryMove(3); }
    return 0;
}

// 走一步。dir: 0=北 1=东 2=南 3=西。撞墙只响一声闷的,不动。
// Take one step. dir: 0=north 1=east 2=south 3=west. A wall only thuds; nothing moves.
function tryMove(pdir) {
    if (GOVER != 0) { return 0; }
    var tw = MAZE[GPV * GCOLS + GPU];
    var tmv = 0;
    if (pdir == 0) { if ((tw & N_BIT) == 0 && GPV > 0) { GPV = GPV - 1; tmv = 1; } }
    if (pdir == 1) { if ((tw & E_BIT) == 0 && GPU < GCOLS - 1) { GPU = GPU + 1; tmv = 1; } }
    if (pdir == 2) { if ((tw & S_BIT) == 0 && GPV < GROWS - 1) { GPV = GPV + 1; tmv = 1; } }
    if (pdir == 3) { if ((tw & W_BIT) == 0 && GPU > 0) { GPU = GPU - 1; tmv = 1; } }
    if (tmv == 0) { ui_audio_beep(220, 70); return 0; }
    GSTEPS = GSTEPS + 1;
    if (DIRS.length < 250) { DIRS.push(pdir); }
    if (PATH.length < 250) { PATH.push(GPV * GCOLS + GPU); }
    ui_audio_beep(660, 50);
    if (GPU == GCOLS - 1 && GPV == GROWS - 1) { winGame(); return 1; }
    // 步数上限 = 最优步数的 3 倍:绕太久算输(有胜就得有负 —— 而且输的音高与赢差两个八度)。
    // Step limit = 3x the optimal count: wandering too long is a loss (a win needs a loss to go with it -- and the tones are two octaves apart).
    if (GSTEPS > GLIMIT) {
        GOVER = 1; GWIN = 0;
        countTurns();
        ui_audio_beep(131, 320);
    }
    return 1;
}

// 到达出口:算成绩、进排行榜、放最高音。
// Reached the exit: score it, record it in the leaderboard, and play the highest tone.
function winGame() {
    GWIN = 1; GOVER = 1;
    ui_audio_beep(1319, 320);
    if (LED.length < 8) { LED.push(GSTEPS); }
    countTurns();
}

// 转弯次数:用 forEach 扫一遍方向序列(回调里改的是全局的 GTURNS)。
// Turn count: one forEach sweep over the direction sequence (the callback writes the global GTURNS).
// 胜负两条路都要算(输的那局也想看得见"绕了多少")。
// Both outcomes compute it (even a lost round wants to show how much wandering happened).
function countTurns() {
    var tnprev = -1;
    GTURNS = 0;
    DIRS.forEach(function (tdir) {
        if (tnprev >= 0 && tdir != tnprev) { GTURNS = GTURNS + 1; }
        tnprev = tdir;
    });
}

// 走到出口时「路线里有没有重复踩过的格子」—— 用 indexOf 判某个格子在 PATH 里是不是首次出现。
// Whether the route revisited a cell -- `indexOf` tells if a cell appears for the first time at this position.
// 迷宫里绕回头很常见,这个数就是"走得绕不绕"的一个侧面判据(成绩单上不画,收尾时打给无头验证)。
// Doubling back is common in a maze, so this counts how winding the route was (not drawn on the card; printed for headless checks).
function countRevisit() {
    var crn = 0;
    var cri = 0;
    while (cri < PATH.length) {
        if (PATH.indexOf(PATH[cri]) != cri) { crn = crn + 1; }
        cri = cri + 1;
    }
    return crn;
}

// 开一局新的:清状态 → 挖迷宫 → 算最短距离。
// Start a new round: clear the state, carve a maze, compute the shortest distances.
function newRound() {
    GPU = 0; GPV = 0; GSTEPS = 0; GOVER = 0; GWIN = 0; GHU = -1; GHV = -1; GTURNS = 0;
    PATH[0 - 1] = 0;
    DIRS[0 - 1] = 0;
    PATH.push(0);
    genMaze();
    // DIST = 每格到出口的最短步数
    // DIST = fewest steps from each cell to the exit
    bfsFrom((GROWS - 1) * GCOLS + (GCOLS - 1), DIST);
    GBEST = DIST[0];
    GLIMIT = GBEST * 3;
}

// 按 H:给下一步的提示(挑一个「离出口恰好近一步」的邻居,BFS 距离已经算好了)。
// Press H: hint the next step (pick the neighbour that is exactly one step closer to the exit, using the BFS distances).
function doHint() {
    if (GOVER != 0) { return; }
    var hcell = GPV * GCOLS + GPU;
    var hd = DIST[hcell];
    GHU = -1; GHV = -1;
    if (hd <= 0) { return; }
    var hw = MAZE[hcell];
    var hcc = hcell % GCOLS;
    var hcr = mzDiv(hcell, GCOLS);
    if ((hw & N_BIT) == 0 && hcr > 0 && DIST[hcell - GCOLS] == hd - 1) { GHU = hcc; GHV = hcr - 1; }
    if (GHU < 0 && (hw & E_BIT) == 0 && hcc < GCOLS - 1 && DIST[hcell + 1] == hd - 1) { GHU = hcc + 1; GHV = hcr; }
    if (GHU < 0 && (hw & S_BIT) == 0 && hcr < GROWS - 1 && DIST[hcell + GCOLS] == hd - 1) { GHU = hcc; GHV = hcr + 1; }
    if (GHU < 0 && (hw & W_BIT) == 0 && hcc > 0 && DIST[hcell - 1] == hd - 1) { GHU = hcc - 1; GHV = hcr; }
    ui_audio_beep(880, 70);
}

// 按键。
// Key handling.
function keyDown(pk) {
    if (pk == 27) { GQUIT = 1; return; }
    if (GOVER != 0) {
        if (pk == 13 || pk == 82) { newRound(); }
        return;
    }
    if (pk == 13 || pk == 82) { newRound(); return; }
    if (pk == 72) { doHint(); return; }
    if (pk == 38 || pk == 87) { tryMove(0); return; }
    if (pk == 39 || pk == 68) { tryMove(1); return; }
    if (pk == 40 || pk == 83) { tryMove(2); return; }
    if (pk == 37 || pk == 65) { tryMove(3); return; }
}

// 点屏幕:点迷宫里的**任意一格**都朝它走一步(贴着的那格就是普通的一步);点 HUD 行 = 提示。
// Tap: any cell inside the maze takes one step toward it (an adjacent cell is simply one plain step); tapping the HUD row hints.
function touchAt(ptx, pty) {
    if (GOVER != 0) { newRound(); return; }
    if (pty < GY0) {
        doHint();
        return;
    }
    var tcc = mzDiv(ptx - GX0, GCELL);
    var tcr = mzDiv(pty - GY0, GCELL);
    if (tcc < 0 || tcr < 0 || tcc >= GCOLS || tcr >= GROWS) { return; }
    stepToward(tcr * GCOLS + tcc);
}

// 画迷宫:每格只画**北墙与西墙**,再补最后一列 / 最后一行的外墙 —— 一座 11×15 的迷宫约 190 条线。
// Draw the maze: per cell only the **north and west walls**, plus the outer walls of the last column / row -- about 190 lines for an 11x15 maze.
function drawMaze() {
    var dkr = 0;
    while (dkr < GROWS) {
        var dkc = 0;
        while (dkc < GCOLS) {
            var dkv = MAZE[dkr * GCOLS + dkc];
            var dkx = GX0 + dkc * GCELL;
            var dky = GY0 + dkr * GCELL;
            if ((dkv & N_BIT) != 0) { ui_2d_line(dkx, dky, dkx + GCELL, dky, C_WALL, 2); }
            if ((dkv & W_BIT) != 0) { ui_2d_line(dkx, dky, dkx, dky + GCELL, C_WALL, 2); }
            if (dkc == GCOLS - 1 && (dkv & E_BIT) != 0) { ui_2d_line(dkx + GCELL, dky, dkx + GCELL, dky + GCELL, C_WALL, 2); }
            if (dkr == GROWS - 1 && (dkv & S_BIT) != 0) { ui_2d_line(dkx, dky + GCELL, dkx + GCELL, dky + GCELL, C_WALL, 2); }
            dkc = dkc + 1;
        }
        dkr = dkr + 1;
    }
}

// 画一帧(只在「走了一步 / 按键 / 开了新局」之后调用)。
// Draw one frame (only after "a step / a key / a new round").
function drawAll() {
    ui_2d_clear(C_BG);

    // HUD:步数 / 最优 / 档位 / 最佳
    // HUD: steps / optimal / tier / best
    // HUD 三列按屏宽均分(240 屏上原来写死的 224/264 两列直接出界)。
    // Three HUD columns split the width evenly (the hardcoded 224/264 columns fell off a 240-px canvas).
    var mhCol = mzDiv(GW, 3);
    ui_2d_text(8, G_HY, GLANG == 0 ? "步数" : "Steps", C_TEXT, G_LSZ, 0);
    drawNum(8 + 2 * G_LSZ + 8, G_HY, GSTEPS, C_GREEN, G_NSZ);
    ui_2d_text(8 + mhCol, G_HY, GLANG == 0 ? "最优" : "Best", C_TEXT, G_LSZ, 0);
    drawNum(8 + mhCol + 2 * G_LSZ + 8, G_HY, GBEST, C_GOLD, G_NSZ);
    ui_2d_text(8 + 2 * mhCol, G_HY, GLANG == 0 ? "上限" : "Limit", C_TEXT, G_LSZ, 0);
    drawNum(8 + 2 * mhCol + 2 * G_LSZ + 8, G_HY, GLIMIT, C_RED, G_NSZ);
    if (GW < 420) {
        ui_2d_text(8, G_IY, GLANG == 0 ? "点格子走一步 · H 提示 · R 换迷宫" : "Tap a cell; H hint; R new maze", C_TEXT, G_ISZ, 0);
    } else {
        ui_2d_text(8, G_IY, GLANG == 0 ? "走到右下角;H 提示 / R 换迷宫 / 点任意格朝它走一步" : "Reach the bottom-right; H hint / R new maze / tap a cell to walk toward it", C_TEXT, G_ISZ, 0);
    }

    drawMaze();

    // 走过的路:小方点(PATH 里第 i 个格子)
    // The trail: small squares (the i-th cell in PATH)
    var dai = 0;
    while (dai < PATH.length) {
        var dac = PATH[dai] % GCOLS;
        var dar = mzDiv(PATH[dai], GCOLS);
        ui_2d_rect(cellX(dac) - 3, cellY(dar) - 3, 6, 6, C_TRAIL, 1, 0, 2);
        dai = dai + 1;
    }

    // 出口 + 玩家 + 提示
    // Exit + player + hint
    ui_2d_rect(cellX(GCOLS - 1) - mzDiv(GCELL, 3), cellY(GROWS - 1) - mzDiv(GCELL, 3), mzDiv(GCELL * 2, 3), mzDiv(GCELL * 2, 3), C_GOLD, 1, 0, 4);
    ui_2d_circle(cellX(GPU), cellY(GPV), mzDiv(GCELL, 3), C_GREEN, 1, 0);
    if (GHU >= 0 && GOVER == 0) {
        ui_2d_rect(cellX(GHU) - mzDiv(GCELL, 3), cellY(GHV) - mzDiv(GCELL, 3), mzDiv(GCELL * 2, 3), mzDiv(GCELL * 2, 3), C_MARK, 0, 3, 4);
    }

    // 自检失败红条(正常时什么都不画)
    // Self-check failure bar (nothing is drawn when everything passes)
    if (GSCFAIL > 0) {
        ui_2d_rect(0, GH - 6, GSCFAIL * 20, 6, C_RED, 1, 0, 0);
    }

    // 成绩单
    // Score card
    if (GOVER != 0) {
        var mhCx = mzDiv(GW, 2);
        var mhCy = mzDiv(GH, 2);
        ui_2d_rect(16, mhCy - 84, GW - 32, 168, C_DIM, 1, 0, 10);
        if (GWIN != 0) {
            ui_2d_text(mhCx, mhCy - 72, GLANG == 0 ? "走出迷宫!" : "ESCAPED!", C_GREEN, 22, 1);
        }
        if (GWIN == 0) {
            ui_2d_text(mhCx, mhCy - 72, GLANG == 0 ? "走过头了" : "GAME OVER", C_RED, 22, 1);
        }
        ui_2d_text(mhCx - 66, mhCy - 40, GLANG == 0 ? "步数" : "Steps", C_TEXT, 13, 0);
        drawNum(mhCx - 26, mhCy - 42, GSTEPS, C_GREEN, 18);
        ui_2d_text(mhCx + 14, mhCy - 40, GLANG == 0 ? "最优" : "Best", C_TEXT, 13, 0);
        drawNum(mhCx + 54, mhCy - 42, GBEST, C_GOLD, 18);
        ui_2d_text(mhCx - 66, mhCy - 14, GLANG == 0 ? "上限" : "Limit", C_TEXT, 13, 0);
        drawNum(mhCx - 26, mhCy - 16, GLIMIT, C_RED, 18);
        ui_2d_text(mhCx + 14, mhCy - 14, GLANG == 0 ? "转弯" : "Turns", C_TEXT, 13, 0);
        drawNum(mhCx + 54, mhCy - 16, GTURNS, C_BLUE, 18);
        // 排行榜:sort 升序(步数少的在前),reverse 之后取前 3(slice)
        // Leaderboard: sort ascending (fewest steps first), reverse, then take the top 3 (slice)
        var dls = LED.sort();
        dls.reverse();
        var dtop = dls.slice(0, 3);
        ui_2d_text(mhCx - 66, mhCy + 12, GLANG == 0 ? "排行" : "Top", C_TEXT, 13, 0);
        var dli = 0;
        while (dli < dtop.length) {
            drawNum(mhCx - 26 + dli * 44, mhCy + 10, dtop[dli], C_MARK, 18);
            dli = dli + 1;
        }
        if (GW < 420) {
            ui_2d_text(mhCx, mhCy + 44, GLANG == 0 ? "回车 / 点屏幕 换新迷宫" : "Enter / tap for a new maze", C_MARK, 13, 1);
        } else {
            ui_2d_text(mhCx, mhCy + 44, GLANG == 0 ? "按回车 / 点屏幕 换一座新迷宫" : "Enter / tap for a new maze", C_MARK, 13, 1);
        }
    }
    ui_2d_present();
}

// 自检:把本轮修好的那批方法逐条断言一遍,打「序号*10+通过」。开窗之前跑。
// Self-check: assert every method fixed this round, printing `index*10 + passed`. Runs before the window opens.
function selfcheck() {
    var scf = 0;
    var sci = 0;
    var scs = "Maze Runner";
    if (scs.startsWith("Maze") == 1) { sci = sci + 1; } else { scf = scf + 1; }
    if (scs.startsWith("Runner") == 0) { sci = sci + 1; } else { scf = scf + 1; }
    if (scs.endsWith("Runner") == 1) { sci = sci + 1; } else { scf = scf + 1; }
    if (scs.charAt(0) == 77 && scs.charAt(10) == 114) { sci = sci + 1; } else { scf = scf + 1; }
    if (scs.charAt(99) == 0) { sci = sci + 1; } else { scf = scf + 1; }
    var scu = "north";
    var scu2 = scu.toUpperCase();
    // ⚠ `toUpperCase` **返回新串、原串不变**(清单 BUG-11 修好之后)。
    //   这条从前写的是 `scu.charAt(4) == 72`('H')—— 那是在**利用**"原地改"这个缺陷;
    //   现在改成断言正确的 ECMAScript 语义:新串第 4 位是 'H'、原串第 0 位仍是 'n'。
    if (scu2.charAt(4) == 72 && scu.charAt(0) == 110) { sci = sci + 1; } else { scf = scf + 1; }
    var sct = "  wall  ";
    var sct2 = sct.trim();
    if (sct2.charAt(0) == 119 && sct2.charAt(4) == 0) { sci = sci + 1; } else { scf = scf + 1; }
    var scp = "3";
    var scp2 = scp.padStart(2, "0");
    if (scp2.charAt(0) == 48 && scp2.charAt(1) == 51) { sci = sci + 1; } else { scf = scf + 1; }
    var scq = "3";
    var scq2 = scq.padEnd(2, ".");
    if (scq2.charAt(0) == 51 && scq2.charAt(1) == 46) { sci = sci + 1; } else { scf = scf + 1; }
    var scv = "n,e,s,w";
    var scv2 = scv.split(",");
    if (scv2.length == 4) { sci = sci + 1; } else { scf = scf + 1; }
    // bigArr:concat 翻倍八次必须正好 256 格
    // bigArr: eight concat doublings must land on exactly 256 slots
    var scb = [0];
    var scb2 = scb.concat(scb);
    var scb3 = scb2.concat(scb2);
    var scb4 = scb3.concat(scb3);
    var scb5 = scb4.concat(scb4);
    var scb6 = scb5.concat(scb5);
    var scb7 = scb6.concat(scb6);
    var scb8 = scb7.concat(scb7);
    var scb9 = scb8.concat(scb8);
    if (scb9[0 - 1] == 256) { sci = sci + 1; } else { scf = scf + 1; }
    // 定容数组 + push/pop/indexOf/includes
    // Fixed-capacity array + push/pop/indexOf/includes
    var sca = z8();
    sca.push(7); sca.push(8); sca.push(9);
    if (sca.length == 3 && sca[1] == 8) { sci = sci + 1; } else { scf = scf + 1; }
    if (sca.indexOf(9) == 2 && sca.indexOf(99) == -1) { sci = sci + 1; } else { scf = scf + 1; }
    if (sca.includes(7) == 1 && sca.includes(99) == 0) { sci = sci + 1; } else { scf = scf + 1; }
    if (sca.pop() == 9 && sca.length == 2) { sci = sci + 1; } else { scf = scf + 1; }
    // sort / reverse / slice / concat / join
    var scc = z8();
    scc.push(31); scc.push(11); scc.push(21);
    var scc2 = scc.sort();
    if (scc2[0] == 11 && scc2[2] == 31) { sci = sci + 1; } else { scf = scf + 1; }
    var scc3 = scc.reverse();
    if (scc3[0] == 31 && scc3[2] == 11) { sci = sci + 1; } else { scf = scf + 1; }
    var scd = scc.slice(1, 3);
    if (scd.length == 2 && scd[0] == 21) { sci = sci + 1; } else { scf = scf + 1; }
    var sce1 = z4(); sce1.push(1); sce1.push(2);
    var sce2 = z4(); sce2.push(3); sce2.push(4); sce2.push(5);
    var sce3 = sce1.concat(sce2);
    if (sce3.length == 5 && sce3[4] == 5) { sci = sci + 1; } else { scf = scf + 1; }
    var scj = z4(); scj.push(4); scj.push(5);
    var scjs = scj.join("/");
    if (scjs.charAt(0) == 52 && scjs.charAt(1) == 47) { sci = sci + 1; } else { scf = scf + 1; }
    // forEach / map / filter(曾经拿数组指针当上界)
    // forEach / map / filter (they used to treat the array pointer as the upper bound)
    var scn = 0;
    var scg = z4(); scg.push(2); scg.push(4); scg.push(6);
    scg.forEach(function (scx) { scn = scn + scx; });
    if (scn == 12) { sci = sci + 1; } else { scf = scf + 1; }
    // ⚠ 回调里**不用 `/`**:JS 的 `/` 恒为浮点除法(清单 BUG-07 修好后 `6/2` 是 3.0,
    //   而本前端把无小数的整数存成 32 位整数、`scm[2] == 3` 比的是位模式)—— 改成 `* 2`。
    var scm = scg.map(function (scy) { return scy * 2; });
    if (scm.length == 3 && scm[2] == 12) { sci = sci + 1; } else { scf = scf + 1; }
    var scfl = scg.filter(function (scz) { return scz > 2; });
    if (scfl.length == 2 && scfl[0] == 4) { sci = sci + 1; } else { scf = scf + 1; }
    // parseFloat:正浮点的位模式按整数比大小 = 数值同序(本前端没有浮点算术,只能这样比)
    // parseFloat: for positive floats the bit pattern compares as an integer in numeric order (no float arithmetic here, so this is the only comparison available)
    if (parseFloat("0.5") < parseFloat("1.0")) { sci = sci + 1; } else { scf = scf + 1; }
    if (parseFloat("1.75") > parseFloat("1.5")) { sci = sci + 1; } else { scf = scf + 1; }
    // 位运算(画墙 / 拆墙全靠它)
    // Bit operations (all the wall handling depends on them)
    if ((12 & 10) == 8 && ((12 & N_BIT) == 0) == 1) { sci = sci + 1; } else { scf = scf + 1; }
    if ((15 & (0 - 2)) == 14 && (14 & E_BIT) == 2) { sci = sci + 1; } else { scf = scf + 1; }

    // 两个数分开打:`sci*10+标志` 那种编码在标志为 0 时和"上一档 +1"是同一个数(踩过)。
    // Print the two numbers separately: the `sci*10+flag` encoding collides with "one tier up" when the flag is 0 (this was hit for real).
    console.log("selfcheck checks=", sci, "fails=", scf);
    GSCFAIL = scf;
}

// 入口。
// Entry point.
function main() {
    selfcheck();

    GLANG = ui_scr_get_language();
    // ⚠ 写在文件级会变成 0 —— 见文件头约束 ①
    // Warning: a file-level assignment would become 0 -- see constraint (1) in the header
    GCOLS = 11;
    GROWS = 15;

    // 难度档位表:split → map(parseFloat)。
    // Difficulty tier table: split -> map(parseFloat).
    // ⚠ `parseFloat` 返回的是**单精度浮点的位模式**(本前端没有浮点算术),
    // Note: `parseFloat` returns the **bit pattern of a single-precision float** (there is no float arithmetic here),
    //   但**正浮点的位模式按整数比大小与数值同序** ⇒ 排序 / 比较是可靠的,`MULT[k] < MULT[k+1]` 就是真的递增。
    //   but **for positive floats the bit pattern compares as an integer in numeric order** => sorting and comparing are reliable, and `MULT[k] < MULT[k+1]` really does mean increasing.
    //   游戏只用它**定档数**(`MULT.length`)与**校验表是递增的**(不递增就红),档位索引本身是整数。
    //   The game only uses it for the **tier count** (`MULT.length`) and to **check the table really increases** (otherwise it goes red); the tier index itself is an integer.
    var mnsp = "1.0,1.15,1.3,1.5";
    var mnparts = mnsp.split(",");
    MULT = mnparts.map(function (mns) { return parseFloat(mns); });
    var mni = 1;
    while (mni < MULT.length) {
        if (MULT[mni] <= MULT[mni - 1]) { GSCFAIL = GSCFAIL + 1; }
        mni = mni + 1;
    }
    // 起始档位(1 = 第二档,多拆 3 面墙)
    // Starting tier (1 = the second one, three extra walls knocked out)
    GTIER = 1;

    MAZE = bigArr();
    // 到出口的距离(提示 / 最优步数)
    // Distance to the exit (for hints and the optimal step count)
    DIST = bigArr();
    // 到"点中的那一格"的距离(点哪走哪)
    // Distance to the tapped cell (for tap-to-walk)
    DIST2 = bigArr();
    QUE = bigArr();
    PATH = bigArr();
    DIRS = bigArr();
    DOTSX = bigArr();
    DOTSY = bigArr();
    LED = z8();
    CAND = z4();

    // 开窗时传 0:尺寸交给宿主(用真实可用区)。**开窗之后**再问一次真实画布 —— 开窗前问到的只是估算值。
    // Open with 0: the host decides the size (the real usable area). Ask the **real** canvas only after the window is open -- before that the host can only estimate.
    ui_win_open(GLANG == 0 ? "迷宫寻路" : "Maze Runner", 0, 0);
    ui_scr_set_keep_on(1);

    // 宿主返回的宽高是浮点;先归一成整数,否则下面每一个坐标都会带浮点位模式。
    // The host returns its width/height as floats; normalise them to integers first,
    // otherwise every coordinate downstream carries a raw float bit pattern.
    GW = mzDiv(ui_scr_get_w(), 1);
    if (GW <= 0) { GW = 360; }
    GH = mzDiv(ui_scr_get_h(), 1);
    if (GH <= 0) { GH = 620; }

    // HUD 字号随屏宽缩放;顶部两行(数字 + 说明)占的高度先算出来,再给迷宫分剩余高度。
    // HUD fonts scale with the width; the two top lines reserve their height first,
    // and the maze takes what is left.
    G_LSZ = mzDiv(GW, 28);
    if (G_LSZ < 11) { G_LSZ = 11; }
    if (G_LSZ > 20) { G_LSZ = 20; }
    G_NSZ = G_LSZ + 7;
    G_ISZ = G_LSZ;
    // 文本的 y 是基线 ⇒ HUD 的基线至少要留一个最大字号的高度。
    // Text y is the baseline => the HUD baseline must leave at least one (largest) font height.
    G_HY = G_NSZ + 4;
    G_IY = G_HY + G_ISZ + 8;
    GY0 = G_IY + 10;

    // 格子边长:宽高两个上界取小者(只按宽算的话竖屏底下会切出去)。
    // Cell size: the smaller of the two upper bounds (using width alone would cut the bottom off in portrait).
    GCELL = mzDiv(GW - 16, GCOLS);
    var mnh = mzDiv(GH - GY0 - 8, GROWS);
    if (mnh < GCELL) { GCELL = mnh; }
    if (GCELL < 4) { GCELL = 4; }
    GX0 = mzDiv(GW - GCOLS * GCELL, 2);

    newRound();

    drawAll();

    while (ui_win_is_closed() == 0) {
        var mnt = ui_msg_fetch_wait(0);
        if (mnt == 10) { break; }
        if (mnt == 1) { keyDown(ui_msg_get_a()); if (GQUIT != 0) { break; } drawAll(); }
        if (mnt == 6) { touchAt(ui_msg_get_a(), ui_msg_get_b()); drawAll(); }
    }

    ui_scr_set_keep_on(0);
    ui_win_close();

    // 收尾:留几个确定性判据(真正的判据看 --trace-draw)。
    // Wrap-up: a few deterministic values (the real evidence is --trace-draw).
    // 最终路线用 map 把格子下标变成屏幕坐标(结算画面之外的第二种用法)。
    // The final route maps cell indices to screen coordinates with `map` (a second use beyond the score card).
    DOTSX[0 - 1] = 0;
    DOTSY[0 - 1] = 0;
    var mnm = PATH.map(function (mnc) { return GX0 + (mnc % GCOLS) * GCELL + mzDiv(GCELL, 2); });
    DOTSX = mnm;
    DOTSY = PATH.map(function (mnc2) { return GY0 + mzDiv(mnc2, GCOLS) * GCELL + mzDiv(GCELL, 2); });
    console.log("maze scfail=", GSCFAIL, " steps=", GSTEPS, " best=", GBEST, " tier=", GTIER, " win=", GWIN, " turns=", GTURNS, " revisit=", countRevisit());
    console.log("maze cells=", GCOLS * GROWS, " pathlen=", PATH.length, " dots=", DOTSX.length, " led=", LED.length);
    print("maze route=");
    print(DIRS.join(","));
    println("");
}