/* chess.c —— 中国象棋（人机对战），跑在手机端 VML 上
 * chess.c -- Chinese chess (human vs computer), running on VML on mobile.
 *
 * 用法（手机 App 的 vml 工具）：  vml run examples/c/chess.c
 * Usage (with the mobile app's vml tool):  vml run examples/c/chess.c
 * 桌面（无 UI 号段，只能验编译与规则）：
 * Desktop (no UI syscall range -- only compilation and rules can be checked):
 *     vmlcli chess.c -I . --vml /tmp/chess.vml        # 只编译
 *     vmlcli chess.c -I . --vml /tmp/chess.vml        # compile only
 *     vmlcli .scratch/chessprobe/probe.c -I Examples/c   # 跑规则自测（见 .scratch/chessprobe）
 *     vmlcli .scratch/chessprobe/probe.c -I Examples/c   # run the rules self-test (see .scratch/chessprobe)
 *
 * 界面全部用绘图指令画出来（棋盘线、九宫斜线、楚河汉界、棋子圆 + 居中汉字），
 * The whole UI is drawn with drawing commands (board lines, palace diagonals, the river, piece circles + centred characters),
 * 不依赖任何图片与字体资源；尺寸按实际可用绘图区自适应。
 * with no image or font assets at all; sizes adapt to the actually available drawing area.
 *
 * ## 规则部分与界面部分是**分开的**
 * ## The rules half and the UI half are **separate**
 *
 * 上面那一半（`can_move` / `in_check` / `legal_move` / `gen_moves` / `has_legal` /
 * The upper half (`can_move` / `in_check` / `legal_move` / `gen_moves` / `has_legal` /
 * `ai_pick`）**没有一处开窗、画图或读输入**，因此可以在桌面被一个探针 `#include`
 * `ai_pick`) **never opens a window, draws, or reads input**, so a desktop probe can `#include`
 * 进来单测（`#ifndef CHESS_LIB_ONLY` 包住 main 就是为这个）—— 象棋的规则漏洞（蹩马腿、
 * it for unit tests (that is what wrapping main in `#ifndef CHESS_LIB_ONLY` is for) -- xiangqi rule holes (blocked horse leg,
 * 塞象眼、炮翻山、将帅照面）在手机上靠点屏幕是**测不完**的，必须有可跑的判据。
 * blocked elephant eye, cannon screen, facing kings) cannot be tested exhaustively by tapping a phone screen, so a runnable check is a must.
 * 判据里最硬的一条：**开局红方合法着法恰好 44 步**（象棋 perft(1) 的标准值），
 * The hardest check of all: **red has exactly 44 legal moves in the opening position** (the standard perft(1) value for xiangqi) --
 * 数不对就是走法生成器错了。
 * get that count wrong and the move generator is broken.
 *
 * ⚠ 唯一的例外是 `ai_pick` 末尾那句 `ui_math_rand(9)`（同分抖动）—— 它**不是**开窗/绘图，
 * ⚠ The only exception is the `ui_math_rand(9)` at the end of `ai_pick` (tie-break jitter) -- that is **not** window/draw code,
 *   落到 VM 的 `#50` 号 syscall 上，所以探针里照样调得动（实测：
 *   it lands on the VM's syscall `#50`, so the probe can still call it (measured:
 *   `.scratch/chessprobe/aiprobe.c` 直接调 `ai_pick` 断言它该不该吃白送的子）。
 *   `.scratch/chessprobe/aiprobe.c` calls `ai_pick` directly and asserts whether it should take a free piece).
 *   真要在没有 `ui_*` 号段的宿主上复用这一半，把那句换成常量即可。
 *   To reuse this half on a host without the `ui_*` syscall range, just replace that line with a constant.
 *
 * ## 为什么不用全局变量
 * ## Why no global variables
 *
 * 与 gomoku.c 同一条约束：`GenerateAsmStatement` 的 `${名}` 只查**局部**变量表，
 * Same constraint as gomoku.c: the `${name}` in `GenerateAsmStatement` only consults the **local** variable table,
 * 全局变量在 dataSection 里、查不到，会退化成 `R12+0`（**2026-10-04 复验仍成立**）。所以棋盘是 main 的局部数组、
 * a global lives in dataSection, is not found, and degrades to `R12+0` (**still holds, re-checked 2026-10-04**). So the board is a local array in main,
 * 靠参数传下去；调宿主一律走 `vml_ui.h` 的包装函数（形参是普通 C 参数，安全）。
 * passed down as a parameter; every host call goes through the `vml_ui.h` wrappers (plain C parameters, safe).
 *
 * ## 棋盘坐标
 * ## Board coordinates
 *
 * 9 列 × 10 行，扁平数组 `b[y * 9 + x]`。**y = 0 是黑方底线（屏幕上边）**，
 * 9 columns x 10 rows, flat array `b[y * 9 + x]`. **y = 0 is black's back rank (top of the screen)**,
 * y = 9 是红方底线（屏幕下边）。人是红方（在下），电脑是黑方（在上）。
 * y = 9 is red's back rank (bottom of the screen). The human is red (bottom), the computer is black (top).
 * 棋子编码 = `方 * 10 + 种类`：红 1..7、黑 11..17，0 = 空 —— 于是
 * Piece encoding = `side * 10 + kind`: red 1..7, black 11..17, 0 = empty -- so
 * `v / 10` 是方、`v % 10` 是种类，两个判断都是一次整除，没有负号参与。
 * `v / 10` is the side and `v % 10` is the kind; both tests are one integer division and no negative sign is involved.
 */

#include <vml_ui.h>

#define BW 9
#define BH 10
/* 数组维度一律写这个字面量：`int t[BW * BH]` 要求前端对宏表达式做常量折叠，不值得赌。
 * Array dimensions always use this literal: `int t[BW * BH]` would need the frontend to
 * ⚠ 注释**不能跨行**跟在 `#define` 同一行后面 —— 前端按行处理 `#define`，跨行的块注释
 * ⚠ A comment must NOT span lines after a `#define` on the same line -- the frontend handles `#define` line by line,
 *   会在换行处被截断，第二行（以 `*` 开头）就当成代码了，里面的全角标点直接报
 *   a multi-line block comment is cut at the newline, the second line (starting with `*`) is taken as code, and its
 *   「未知字符：，」。实测过（本文件 v1 就是这么红的）。
 *   full-width punctuation reports "unknown character". Measured -- version 1 of this file went red exactly this way. */
#define CELLS 90

/* 种类（v % 10） */
/* Kinds (v % 10) */
#define T_K 1   /* 帅 / 将 */
/* King / General */
#define T_A 2   /* 仕 / 士 */
/* Advisor */
#define T_B 3   /* 相 / 象 */
/* Elephant */
#define T_N 4   /* 马 */
/* Horse */
#define T_R 5   /* 车 */
/* Chariot */
#define T_C 6   /* 炮 */
/* Cannon */
#define T_P 7   /* 兵 / 卒 */
/* Pawn / Soldier */

/* 方（v / 10） */
/* Side (v / 10) */
#define S_RED 0
#define S_BLK 1

#define MAXM 240   /* 着法上限：合法着法远不到这里，纯粹防越界 */
/* Move cap: legal moves never come near it; this only guards against overrun */

/* 配色 */
/* Colors */
#define COL_BG      0xFF14100C
#define COL_BOARD   0xFFE9C88F
#define COL_LINE    0xFF6B4A22
#define COL_RED     0xFFB3261E
#define COL_BLACK   0xFF14100C
#define COL_PIECE   0xFFF8EEDC
#define COL_TEXT    0xFFEDEDF2
#define COL_DIM     0xFF8A8A93
#define COL_SEL     0xFF1B7F3B
#define COL_BTN     0xFF2A2A33
#define COL_BTN_TX  0xFFEDEDF2
#define COL_ACCENT  0xFFE8B23A

/* 界面语言：开局查一次（ui_scr_get_language 是 syscall，别每帧调）。
 * UI language: queried once at startup (`ui_scr_get_language` is a syscall, do not call it every frame).
 * chess.c 的规则层刻意没有全局状态（可在桌面单测），这里是唯一的例外 —— 它只影响界面文字。
 * The rules layer of chess.c deliberately has no global state (so it is desktop-testable); this is the only exception -- it affects UI text only. */
int g_lang;

/* ═══════════════════════ 规则（不碰 ui_*，可在桌面单测）═══════════════════════ */
/* ═══════════════════════ Rules (no ui_* calls, desktop-testable) ═══════════════════════ */

/* 象/相 不过河：红方只能待在 y>=5，黑方只能 y<=4 */
/* Elephant never crosses the river: red may only stay at y>=5, black only at y<=4 */
int elephant_side_ok(int y, int s) {
    if (s == S_RED) { if (y >= 5) return 1; return 0; }
    if (y <= 4) return 1;
    return 0;
}

/* 九宫：列恒为 3..5；红方行 7..9，黑方行 0..2 */
/* The palace: columns are always 3..5; rows 7..9 for red, rows 0..2 for black */
int in_palace(int x, int y, int s) {
    if (x < 3 || x > 5) return 0;
    if (s == S_RED) { if (y >= 7 && y <= 9) return 1; return 0; }
    if (y >= 0 && y <= 2) return 1;
    return 0;
}

/* 兵/卒 过河了吗：红方向前是 y 变小，过河即 y<=4；黑方相反 */
/* Has the pawn crossed the river? Red moves forward as y shrinks, so crossing means y<=4; black is the other way round */
int pawn_crossed(int y, int s) {
    if (s == S_RED) { if (y <= 4) return 1; return 0; }
    if (y >= 5) return 1;
    return 0;
}

/* (fx,fy)→(tx,ty) 之间夹着几个子（不含两端）。不同行不同列返回 -1。
 * How many pieces sit between (fx,fy) and (tx,ty) (exclusive)? Returns -1 when not on one row or column.
 * 车/炮 共用它 —— 炮"翻山"的炮架计数与车的"路径必须干净"是同一件事的两种用法。
 * Chariot and cannon share it -- counting screens for the cannon's "hop over" and requiring a clear path for the chariot are two uses of the same thing. */
int between_count(int* b, int fx, int fy, int tx, int ty) {
    int dx;
    int dy;
    int x;
    int y;
    int n;

    if (fx != tx && fy != ty) return -1;
    dx = 0;
    dy = 0;
    if (tx > fx) dx = 1;
    if (tx < fx) dx = -1;
    if (ty > fy) dy = 1;
    if (ty < fy) dy = -1;
    x = fx + dx;
    y = fy + dy;
    n = 0;
    while (x != tx || y != ty) {
        if (b[y * BW + x] != 0) n = n + 1;
        x = x + dx;
        y = y + dy;
    }
    return n;
}

/* 这步棋**符合该子的走法**吗（只看走法，不看走完会不会自己被将）。
 * Does this move **match the piece's movement rule** (movement only, ignoring whether it exposes your own king)?
 * 这是走法规则的**唯一实现**：走法生成本身也只管"落点候选"，成不成由它判。
 * This is the **single implementation** of the movement rules: move generation only proposes landing squares and this decides whether each is allowed. */
int can_move(int* b, int fx, int fy, int tx, int ty) {
    int v;
    int s;
    int tp;
    int dx;
    int dy;
    int ax;
    int ay;
    int n;
    int mid;

    if (fx < 0 || fx >= BW || fy < 0 || fy >= BH) return 0;
    if (tx < 0 || tx >= BW || ty < 0 || ty >= BH) return 0;
    if (fx == tx && fy == ty) return 0;

    v = b[fy * BW + fx];
    if (v == 0) return 0;
    s = v / 10;
    tp = v % 10;

    /* 目标点不能是自己的子 */
    /* The target square must not hold one of your own pieces */
    if (b[ty * BW + tx] != 0 && b[ty * BW + tx] / 10 == s) return 0;

    dx = tx - fx;
    dy = ty - fy;
    ax = dx;
    if (ax < 0) ax = 0 - ax;
    ay = dy;
    if (ay < 0) ay = 0 - ay;

    if (tp == T_R) {                       /* 车：直线、路径干净 */
        /* Chariot: straight line, clear path */
        if (dx != 0 && dy != 0) return 0;
        if (between_count(b, fx, fy, tx, ty) != 0) return 0;
        return 1;
    }
    if (tp == T_C) {                       /* 炮：不吃子时同车；吃子必须正好翻一个炮架 */
        /* Cannon: like the chariot when not capturing; to capture it must hop exactly one screen */
        if (dx != 0 && dy != 0) return 0;
        n = between_count(b, fx, fy, tx, ty);
        if (b[ty * BW + tx] == 0) { if (n == 0) return 1; return 0; }
        if (n == 1) return 1;
        return 0;
    }
    if (tp == T_N) {                       /* 马：走日 + **蹩马腿** */
        /* Horse: the "day" move + the **blocked horse leg** */
        if (!((ax == 1 && ay == 2) || (ax == 2 && ay == 1))) return 0;
        if (ax == 2) {
            mid = (fx + tx) / 2;           /* 先横着走两格 → 横方向的相邻格是腿 */
            /* Two squares horizontally first -> the adjacent square across is the leg */
            if (b[fy * BW + mid] != 0) return 0;
        } else {
            mid = (fy + ty) / 2;           /* 先竖着走两格 → 竖方向的相邻格是腿 */
            /* Two squares vertically first -> the adjacent square along is the leg */
            if (b[mid * BW + fx] != 0) return 0;
        }
        return 1;
    }
    if (tp == T_B) {                       /* 相/象：走田 + **塞象眼** + 不过河 */
        /* Elephant: the 2x2 move + the **blocked elephant eye** + never crossing the river */
        if (ax != 2 || ay != 2) return 0;
        if (elephant_side_ok(ty, s) == 0) return 0;
        if (b[((fy + ty) / 2) * BW + (fx + tx) / 2] != 0) return 0;
        return 1;
    }
    if (tp == T_A) {                       /* 仕/士：走斜一格，不出九宫 */
        /* Advisor: one square diagonally, never leaving the palace */
        if (ax != 1 || ay != 1) return 0;
        if (in_palace(tx, ty, s) == 0) return 0;
        return 1;
    }
    if (tp == T_K) {                       /* 帅/将：走直一格，不出九宫（照面规则在 in_check 里） */
        /* King: one square orthogonally, never leaving the palace (the facing rule lives in in_check) */
        if (ax + ay != 1) return 0;
        if (in_palace(tx, ty, s) == 0) return 0;
        return 1;
    }
    if (tp == T_P) {                       /* 兵/卒：只进不退；过河后才能横走 */
        /* Pawn: forward only, never back; it may step sideways only after crossing the river */
        if (s == S_RED) {
            if (dx == 0 && dy == -1) return 1;
            if (pawn_crossed(fy, s) == 1 && dy == 0 && ax == 1) return 1;
            return 0;
        }
        if (dx == 0 && dy == 1) return 1;
        if (pawn_crossed(fy, s) == 1 && dy == 0 && ax == 1) return 1;
        return 0;
    }
    return 0;
}

/* 两个帅/将是否**照面**（同一列且中间无子）—— 这是象棋特有的禁着：
 * Do the two kings **face each other** (same column, nothing in between)? That is a xiangqi-specific illegal move:
 * 谁走成照面就等于把帅送给对方吃，所以它必须算作"被将"。
 * walking into a facing position is handing your king over to be captured, so it must count as "in check". */
int kings_face(int* b) {
    int rk;
    int bk;
    int i;
    int x;
    int y;
    int y1;
    int y2;
    int t;
    int cnt;

    rk = -1;
    bk = -1;
    for (i = 0; i < BW * BH; i = i + 1) {
        if (b[i] == S_RED * 10 + T_K) rk = i;
        if (b[i] == S_BLK * 10 + T_K) bk = i;
    }
    if (rk < 0 || bk < 0) return 0;
    if (rk % BW != bk % BW) return 0;
    x = rk % BW;
    /* ⚠ 两个帅**谁在谁的上面不定**：红在下（y 大）、黑在上（y 小），所以红帅的下标
     * ⚠ Which king is above the other is **not fixed**: red is at the bottom (larger y), black at the top
     *   **大于**黑将。这里必须比较后取小/大 —— 直接 `y = rk/BW + 1; while (y < bk/BW)`
     *   (smaller y), so red's king has the **larger** index. You must compare and take the smaller/larger --
     *   会在初始局面下**一次都不进循环**（10 < 0 为假），于是把"两个王之间塞满了子"
     *   writing `y = rk/BW + 1; while (y < bk/BW)` directly makes the loop **never run once** in the initial
     *   误判成"照面" ⇒ 任何着法走完都算自己被将 ⇒ 全部着法非法、开局 44 步变 0 步。
     *   position (10 < 0 is false), so "pieces fill the space between the kings" is misread as "they face each
     *   这个错是探针的 perft 判据抓出来的（规则自测存在的意义）。
     *   other" => every move leaves you in check => all moves illegal and the 44 opening moves become 0.
     *   The probe's perft check caught this error -- that is why the rules self-test exists. */
    y1 = rk / BW;
    y2 = bk / BW;
    if (y1 > y2) {
        t = y1;
        y1 = y2;
        y2 = t;
    }
    cnt = 0;
    y = y1 + 1;
    while (y < y2) {
        if (b[y * BW + x] != 0) cnt = cnt + 1;
        y = y + 1;
    }
    if (cnt == 0) return 1;
    return 0;
}

/* 试一个落点：在盘内且 can_move 通过就记进 out，返回新的个数。
 * Try one landing square: if it is on the board and can_move allows it, record it in out and return the new count.
 * 走法生成全靠它 —— 于是"生成"与"判定"共用 can_move 这一份规则。
 * Move generation relies entirely on it -- so generation and validation share the one copy of the rules in can_move. */
int try_to(int* b, int fx, int fy, int tx, int ty, int* out, int n) {
    if (tx < 0 || tx >= BW || ty < 0 || ty >= BH) return n;
    if (can_move(b, fx, fy, tx, ty) == 0) return n;
    out[n] = (fy * BW + fx) * 100 + (ty * BW + tx);
    return n + 1;
}

/* 车/炮 沿 (dx,dy) 一条射线上的着法。is_cannon=1 时按"翻一个炮架吃第一个子"办。 */
/* Chariot/cannon moves along the ray (dx,dy). With is_cannon=1 it works as "hop one screen and take the first piece". */
int ray_moves(int* b, int s, int fx, int fy, int dx, int dy, int is_cannon, int* out, int n) {
    int x;
    int y;
    int v;
    int screen;

    x = fx + dx;
    y = fy + dy;
    screen = 0;
    while (x >= 0 && x < BW && y >= 0 && y < BH) {
        v = b[y * BW + x];
        if (v == 0) {
            if (screen == 0) {
                out[n] = (fy * BW + fx) * 100 + (y * BW + x);
                n = n + 1;
            }
        } else {
            if (screen == 0) {
                if (v / 10 != s) {          /* 车吃到子；炮此时只是搭上炮架 */
                    /* The chariot captures; for the cannon this is merely resting on a screen */
                    if (is_cannon == 0) {
                        out[n] = (fy * BW + fx) * 100 + (y * BW + x);
                        n = n + 1;
                    }
                }
                if (is_cannon == 0) return n;
                screen = 1;
            } else {
                if (v / 10 != s) {          /* 炮翻过炮架，吃它后面第一个子 */
                    /* The cannon hops the screen and takes the first piece behind it */
                    out[n] = (fy * BW + fx) * 100 + (y * BW + x);
                    n = n + 1;
                }
                return n;
            }
        }
        x = x + dx;
        y = y + dy;
    }
    return n;
}

/* 生成 s 方**全部走法**（只看走法，不看走完是否自己被将）。返回条数。 */
/* Generate **all moves** for side s (movement only, ignoring whether they leave you in check). Returns the count. */
int gen_moves(int* b, int s, int* out) {
    int i;
    int n;
    int fx;
    int fy;
    int tp;

    n = 0;
    for (i = 0; i < BW * BH; i = i + 1) {
        if (b[i] == 0) continue;
        if (b[i] / 10 != s) continue;
        fx = i % BW;
        fy = i / BW;
        tp = b[i] % 10;

        if (tp == T_R) {
            n = ray_moves(b, s, fx, fy, 1, 0, 0, out, n);
            n = ray_moves(b, s, fx, fy, -1, 0, 0, out, n);
            n = ray_moves(b, s, fx, fy, 0, 1, 0, out, n);
            n = ray_moves(b, s, fx, fy, 0, -1, 0, out, n);
        } else if (tp == T_C) {
            n = ray_moves(b, s, fx, fy, 1, 0, 1, out, n);
            n = ray_moves(b, s, fx, fy, -1, 0, 1, out, n);
            n = ray_moves(b, s, fx, fy, 0, 1, 1, out, n);
            n = ray_moves(b, s, fx, fy, 0, -1, 1, out, n);
        } else if (tp == T_N) {
            n = try_to(b, fx, fy, fx + 1, fy - 2, out, n);
            n = try_to(b, fx, fy, fx - 1, fy - 2, out, n);
            n = try_to(b, fx, fy, fx + 2, fy - 1, out, n);
            n = try_to(b, fx, fy, fx - 2, fy - 1, out, n);
            n = try_to(b, fx, fy, fx + 1, fy + 2, out, n);
            n = try_to(b, fx, fy, fx - 1, fy + 2, out, n);
            n = try_to(b, fx, fy, fx + 2, fy + 1, out, n);
            n = try_to(b, fx, fy, fx - 2, fy + 1, out, n);
        } else if (tp == T_B) {
            n = try_to(b, fx, fy, fx + 2, fy - 2, out, n);
            n = try_to(b, fx, fy, fx - 2, fy - 2, out, n);
            n = try_to(b, fx, fy, fx + 2, fy + 2, out, n);
            n = try_to(b, fx, fy, fx - 2, fy + 2, out, n);
        } else if (tp == T_A) {
            n = try_to(b, fx, fy, fx + 1, fy - 1, out, n);
            n = try_to(b, fx, fy, fx - 1, fy - 1, out, n);
            n = try_to(b, fx, fy, fx + 1, fy + 1, out, n);
            n = try_to(b, fx, fy, fx - 1, fy + 1, out, n);
        } else if (tp == T_K) {
            n = try_to(b, fx, fy, fx + 1, fy, out, n);
            n = try_to(b, fx, fy, fx - 1, fy, out, n);
            n = try_to(b, fx, fy, fx, fy + 1, out, n);
            n = try_to(b, fx, fy, fx, fy - 1, out, n);
        } else if (tp == T_P) {
            if (s == S_RED) n = try_to(b, fx, fy, fx, fy - 1, out, n);
            else n = try_to(b, fx, fy, fx, fy + 1, out, n);
            if (pawn_crossed(fy, s) == 1) {
                n = try_to(b, fx, fy, fx + 1, fy, out, n);
                n = try_to(b, fx, fy, fx - 1, fy, out, n);
            }
        }
        if (n >= MAXM - 8) return n;       /* 上限保护：宁可少列也不要越界 */
        /* Cap guard: list fewer moves rather than overrun the array */
    }
    return n;
}

/* s 方被将军吗（含将帅照面）。
 * Is side s in check (facing kings included)?
 *
 * 判据是**"对方有没有哪一步能落到我的帅上"** —— 直接复用 gen_moves，
 * The test is **"does the opponent have any move that lands on my king"** -- reusing gen_moves directly,
 * 不另写一套"从帅的位置反推谁在攻击我"的反向代码。反向那份要点名车/炮/马的
 * rather than writing a second, reverse set of code that works back from the king's square to who attacks it. The reverse
 * 攻击几何（马的腿还得反着判），同一套规则写两遍必然漂移；而这里代价只是
 * version would have to spell out chariot/cannon/horse attack geometry (and judge the horse leg backwards), and writing
 * 一次走法生成（几十条），换来"走法规则只有一份"。
 * the same rules twice is bound to drift; here the cost is just one move generation (a few dozen moves) for a single copy of the rules. */
int in_check(int* b, int s) {
    int i;
    int k;
    int op;
    int m[MAXM];
    int n;
    int j;

    if (kings_face(b) == 1) return 1;
    k = -1;
    for (i = 0; i < BW * BH; i = i + 1) {
        if (b[i] == s * 10 + T_K) { k = i; break; }
    }
    if (k < 0) return 0;                    /* 帅已被吃（不该走到这儿） */
    /* The king is already captured (we should never get here) */
    op = 1 - s;
    n = gen_moves(b, op, m);
    for (j = 0; j < n; j = j + 1) {
        if (m[j] % 100 == k) return 1;
    }
    return 0;
}

/* 走一步并在副本上试算：符合走法 **且** 走完自己不被将 = 合法。 */
/* Play a move on a copy and try it: matches the movement rule **and** does not leave you in check = legal. */
int legal_move(int* b, int fx, int fy, int tx, int ty) {
    int s;
    int t[CELLS];
    int i;

    if (can_move(b, fx, fy, tx, ty) == 0) return 0;
    s = b[fy * BW + fx] / 10;
    for (i = 0; i < BW * BH; i = i + 1) t[i] = b[i];
    t[ty * BW + tx] = t[fy * BW + fx];
    t[fy * BW + fx] = 0;
    if (in_check(t, s) == 1) return 0;
    return 1;
}

/* s 方还有没有合法着法（= 判断将死 / 困毙）。象棋里**困毙也算输**，与国象不同。 */
/* Does side s still have a legal move (= checkmate / stalemate detection)? In xiangqi **stalemate is also a loss**, unlike international chess. */
int has_legal(int* b, int s) {
    int m[MAXM];
    int n;
    int i;
    int f;
    int t;

    n = gen_moves(b, s, m);
    for (i = 0; i < n; i = i + 1) {
        f = m[i] / 100;
        t = m[i] % 100;
        if (legal_move(b, f % BW, f / BW, t % BW, t / BW) == 1) return 1;
    }
    return 0;
}

/* 合法着法条数 —— 单测用（开局应为 44）。 */
/* Number of legal moves -- for unit tests (it should be 44 in the opening position). */
int count_legal(int* b, int s) {
    int m[MAXM];
    int n;
    int i;
    int f;
    int t;
    int c;

    c = 0;
    n = gen_moves(b, s, m);
    for (i = 0; i < n; i = i + 1) {
        f = m[i] / 100;
        t = m[i] % 100;
        if (legal_move(b, f % BW, f / BW, t % BW, t / BW) == 1) c = c + 1;
    }
    return c;
}

/* 子力价值（帅极大，保证"被吃帅"永远是最坏局面） */
/* Piece values (the king is huge, so "losing the king" is always the worst position) */
int piece_value(int tp) {
    if (tp == T_K) return 10000;
    if (tp == T_R) return 900;
    if (tp == T_C) return 450;
    if (tp == T_N) return 400;
    if (tp == T_B) return 200;
    if (tp == T_A) return 200;
    if (tp == T_P) return 100;
    return 0;
}

int material(int* b, int s) {
    int i;
    int sum;

    sum = 0;
    for (i = 0; i < BW * BH; i = i + 1) {
        if (b[i] == 0) continue;
        if (b[i] / 10 != s) continue;
        sum = sum + piece_value(b[i] % 10);
    }
    return sum;
}

/* 局面小项：兵过河往前走值钱，车/炮占中路值一点 —— 只用来打破同分僵局。
 * Small positional bonus: a pawn that has crossed and pushes forward is worth a little, a chariot/cannon on the
 * ⚠ 收的是**动子**的种类（不是落点上那个子）—— 落点上是敌方子，拿它判"我的兵过河了"
 * ⚠ central file a little too -- it only exists to break ties. The parameter is the kind of the **moving** piece
 *   是张冠李戴；这个参数是调用方把起点上的子取出来传进来的。
 *   (not the piece on the landing square): the landing square holds an enemy piece, so using it to test "my pawn
 *   crossed the river" would be mixing up two different things; the caller takes the piece from the origin and passes it in. */
int pos_bonus(int moverTp, int fromY, int tx, int ty, int s) {
    int sc;
    int d;

    sc = 0;
    if (fromY != ty) sc = sc + 2;           /* 动子比不动子略好 */
    /* Moving a piece is slightly better than not moving one */
    if (moverTp == T_P) {
        if (s == S_RED && ty <= 4) sc = sc + 12;    /* 红兵过河 */
        /* A red pawn that has crossed the river */
        if (s == S_BLK && ty >= 5) sc = sc + 12;
    }
    d = tx - 4;
    if (d < 0) d = 0 - d;
    if (moverTp == T_R || moverTp == T_C) sc = sc + (4 - d) * 2;
    return sc;
}

/* 电脑选一步。返回 from*100+to；无棋可走返回 -1。
 * The computer picks a move. Returns from*100+to, or -1 when there is nothing to play.
 *
 * 深度 = **1 层 + 回吃**：对每个候选着法，算走完之后的子力差，再减掉对方
 * Depth = **1 ply + recapture**: for each candidate move, score the material difference after it, then subtract
 * 立刻能吃回的最大价值 —— 这样它不会白送子，也会吃白送的子。
 * the largest value the opponent can immediately take back -- so it neither gives pieces away nor refuses free ones.
 * 只在**将军**时才额外做一次"对方还有没有棋"（将死判断），因为那一步最贵；
 * Only when the move gives **check** does it additionally ask "does the opponent still have a move" (mate detection),
 * 于是 CPU 代价大致是"候选数 × 一次走法生成"，手机上零点几秒量级。
 * because that step is the most expensive; so the CPU cost is roughly "candidates x one move generation", a fraction of a second on a phone.
 * 同分之间用 ui_math_rand 抖一下，否则每局走得一模一样。
 * Ties are jittered with ui_math_rand, otherwise every game would play out identically. */
int ai_pick(int* b, int me) {
    int m[MAXM];
    int om[MAXM];
    int n;
    int on;
    int i;
    int j;
    int f;
    int t;
    int fx;
    int fy;
    int tx;
    int ty;
    int trial[CELLS];
    int k;
    int sc;
    int best;
    int bm;
    int opp;
    int worst;

    opp = 1 - me;
    best = -9999999;
    bm = -1;
    n = gen_moves(b, me, m);
    for (i = 0; i < n; i = i + 1) {
        f = m[i] / 100;
        t = m[i] % 100;
        fx = f % BW;
        fy = f / BW;
        tx = t % BW;
        ty = t / BW;
        if (legal_move(b, fx, fy, tx, ty) == 0) continue;

        for (k = 0; k < BW * BH; k = k + 1) trial[k] = b[k];
        trial[ty * BW + tx] = trial[fy * BW + fx];
        trial[fy * BW + fx] = 0;

        sc = material(trial, me) - material(trial, opp);
        sc = sc + pos_bonus(b[fy * BW + fx] % 10, fy, tx, ty, me);

        if (in_check(trial, opp) == 1) {
            sc = sc + 40;                       /* 将军本身有收益 */
            /* Giving check is itself worth something */
            if (has_legal(trial, opp) == 0) return m[i];   /* 将死 / 困毙：立刻走 */
            /* Checkmate / stalemate: play it right now */
        }

        /* 对方能吃回多少 —— **只算"吃我这一步落的这个子"**。
         * How much can the opponent take back -- counting **only "capturing the piece I just landed"**.
         *
         * 原来是"对方在这个**新局面**里最好的一口"（在整盘上找最大的吃），
         * It used to be "the opponent's best bite in this **new position**" (the largest capture anywhere on the board),
         * 那会把**与我这一步无关**的既有威胁一并算进来：开局时红炮正照着黑马
         * which pulled in pre-existing threats **unrelated to my move**: in the opening a red cannon bears down on a black horse
         * （隔着黑炮当炮架），于是"随便走一步"和"炮打马"都要扣掉那 400 ——
         * (with a black cannon as the screen), so "any random move" and "cannon takes horse" both lost that 400 --
         * 两者都扣 = 等于没扣，两台候选剩下的差别就只有"炮打马多赚 400"，
         * both lost it, which cancels out, and the only difference left between the two candidates was "cannon takes horse gains 400",
         * 电脑于是**见马就换炮**（拿 450 的炮去吃 400 的马，白亏 50），
         * so the computer **traded its cannon for any horse it saw** (a 450 cannon for a 400 horse, a net loss of 50),
         * 正好与它上面那句注释"不会白送子"相反。实测（`.scratch/chessprobe/aiscore.c`
         * the exact opposite of the comment above it, "never gives pieces away". Measured (`.scratch/chessprobe/aiscore.c`
         * 把 44 个候选的评分逐项打出来）：26 个"随便走"全是 −358 上下，
         * printed the score of all 44 candidates one by one): the 26 "random" moves were all around -358,
         * 而两处"炮打马"是 −1 —— 于是每一步都挑炮打马。桌面上头一局就是这么开的。
         * while the two "cannon takes horse" moves were -1 -- so it picked cannon-takes-horse every single time. The first desktop game opened exactly that way.
         *
         * 判据收在**落点**上才是那个"吃**回**"：对方能不能吃掉我刚落的这个子。
         * Narrowing the test to the **landing square** is what makes it a real "**re**capture": can the opponent take the piece I just moved there?
         * 于是"把子送进对方嘴里"被扣分（本意），而"我这步与那口无关的旧账"不再重复计。
         * So "feeding a piece to the opponent" is penalised (the intent), while "old debts unrelated to this move" are no longer counted twice. */
        worst = 0;
        on = gen_moves(trial, opp, om);
        for (j = 0; j < on; j = j + 1) {
            if (om[j] % 100 != ty * BW + tx) continue;   /* 落点以外的吃子与我这一步无关 */
            /* Captures elsewhere have nothing to do with this move */
            f = om[j] / 100;
            if (legal_move(trial, f % BW, f / BW, tx, ty) == 0) continue;
            worst = piece_value(trial[ty * BW + tx] % 10);   /* 送掉的就是刚走的这个子 */
            /* What is given away is exactly the piece just moved */
            break;
        }
        sc = sc - worst * 9 / 10;
        sc = sc + ui_math_rand(9);                   /* 同分抖动，免得每局一样 */
        /* Tie-break jitter so that no two games look the same */
        if (sc > best) {
            best = sc;
            bm = m[i];
        }
    }
    return bm;
}

/* 开局摆子。红在下（y=9 底线）、黑在上（y=0 底线），与棋盘画法一致。 */
/* Set up the opening position. Red at the bottom (back rank y=9), black at the top (back rank y=0), matching how the board is drawn. */
void init_board(int* b) {
    int i;

    for (i = 0; i < BW * BH; i = i + 1) b[i] = 0;
    /* 黑方（上） */
    /* Black (top) */
    b[0 * BW + 0] = S_BLK * 10 + T_R;
    b[0 * BW + 1] = S_BLK * 10 + T_N;
    b[0 * BW + 2] = S_BLK * 10 + T_B;
    b[0 * BW + 3] = S_BLK * 10 + T_A;
    b[0 * BW + 4] = S_BLK * 10 + T_K;
    b[0 * BW + 5] = S_BLK * 10 + T_A;
    b[0 * BW + 6] = S_BLK * 10 + T_B;
    b[0 * BW + 7] = S_BLK * 10 + T_N;
    b[0 * BW + 8] = S_BLK * 10 + T_R;
    b[2 * BW + 1] = S_BLK * 10 + T_C;
    b[2 * BW + 7] = S_BLK * 10 + T_C;
    b[3 * BW + 0] = S_BLK * 10 + T_P;
    b[3 * BW + 2] = S_BLK * 10 + T_P;
    b[3 * BW + 4] = S_BLK * 10 + T_P;
    b[3 * BW + 6] = S_BLK * 10 + T_P;
    b[3 * BW + 8] = S_BLK * 10 + T_P;
    /* 红方（下） */
    /* Red (bottom) */
    b[9 * BW + 0] = S_RED * 10 + T_R;
    b[9 * BW + 1] = S_RED * 10 + T_N;
    b[9 * BW + 2] = S_RED * 10 + T_B;
    b[9 * BW + 3] = S_RED * 10 + T_A;
    b[9 * BW + 4] = S_RED * 10 + T_K;
    b[9 * BW + 5] = S_RED * 10 + T_A;
    b[9 * BW + 6] = S_RED * 10 + T_B;
    b[9 * BW + 7] = S_RED * 10 + T_N;
    b[9 * BW + 8] = S_RED * 10 + T_R;
    b[7 * BW + 1] = S_RED * 10 + T_C;
    b[7 * BW + 7] = S_RED * 10 + T_C;
    b[6 * BW + 0] = S_RED * 10 + T_P;
    b[6 * BW + 2] = S_RED * 10 + T_P;
    b[6 * BW + 4] = S_RED * 10 + T_P;
    b[6 * BW + 6] = S_RED * 10 + T_P;
    b[6 * BW + 8] = S_RED * 10 + T_P;
}

/* ═══════════════════════ 界面 ═══════════════════════ */
/* ═══════════════════════ UI (interface) ═══════════════════════ */

/* ⚠ 英文用**单字母**（K/A/B/N/R/C/P，国际象棋习惯），红黑同一字母 —— 两边靠**墨色**
 * ⚠ English uses **single letters** (K/A/B/N/R/C/P, international-chess convention) and red and black share the same
   区分（红子 COL_RED、黑子 COL_BLACK），这正是通行做法，而且棋子格只有 cell*3/5 那么宽，
 * letter -- the two sides are told apart by **ink colour** (red pieces COL_RED, black pieces COL_BLACK). That is the
   写全称（"General"/"Advisor"…）会撑破格子。
 * usual approach, and the piece cell is only cell*3/5 wide, so full names ("General"/"Advisor"...) would burst the cell. */
char* name_of(int v) {
    int tp;

    tp = v % 10;
    if (v / 10 == S_RED) {
        if (tp == T_K) return g_lang == 0 ? "帅" : "K";
        if (tp == T_A) return g_lang == 0 ? "仕" : "A";
        if (tp == T_B) return g_lang == 0 ? "相" : "B";
        if (tp == T_N) return g_lang == 0 ? "马" : "N";
        if (tp == T_R) return g_lang == 0 ? "车" : "R";
        if (tp == T_C) return g_lang == 0 ? "炮" : "C";
        return g_lang == 0 ? "兵" : "P";
    }
    if (tp == T_K) return g_lang == 0 ? "将" : "K";
    if (tp == T_A) return g_lang == 0 ? "士" : "A";
    if (tp == T_B) return g_lang == 0 ? "象" : "B";
    if (tp == T_N) return g_lang == 0 ? "马" : "N";
    if (tp == T_R) return g_lang == 0 ? "车" : "R";
    if (tp == T_C) return g_lang == 0 ? "炮" : "C";
    return g_lang == 0 ? "卒" : "P";
}

/* 像素 → 行列号；越界返回 -1（与 gomoku 的 hit_col 同一套取整）。 */
/* Pixel -> line index; returns -1 when out of range (the same rounding as gomoku's hit_col). */
int hit_line(int p, int base, int cell) {
    int c;

    c = (p - base + cell / 2) / cell;
    if (c < 0) return -1;
    return c;
}

/* 画棋盘 + 棋子 + 选中/可走点 + 顶部状态行。**不调 ui_2d_present** ——
 * Draw the board + pieces + selection/legal targets + the top status line. **Does not call ui_2d_present** --
 * 底部的按钮由 main 画（按钮矩形是 main 算的，画与命中判定必须同一份数据）。
 * the bottom buttons are drawn by main (main computes the rectangles, and drawing and hit-testing must share the same data). */
void draw_board(int* b, int bx, int by, int cell, int sel, char* status) {
    int i;
    int x;
    int y;
    int cx;
    int cy;
    int r;
    int v;
    int s;
    int ink;
    int ring;
    int ds;
    int dx;
    int dy;

    ui_2d_clear(COL_BG);

    /* 木盘底 */
    /* The wooden board slab */
    ui_2d_rect(bx - cell * 3 / 5, by - cell * 3 / 5,
            cell * 8 + cell * 6 / 5, cell * 9 + cell * 6 / 5,
            COL_BOARD, 1, 0, 6);

    /* 横线 10 条（贯通） */
    /* 10 horizontal lines (running all the way across) */
    for (y = 0; y < BH; y = y + 1) {
        ui_2d_line(bx, by + y * cell, bx + 8 * cell, by + y * cell, COL_LINE, 1);
    }
    /* 竖线 9 条：最外两条贯通，里面的在河界处断开 */
    /* 9 vertical lines: the two outermost run all the way, the inner ones break at the river */
    for (x = 0; x < BW; x = x + 1) {
        if (x == 0 || x == BW - 1) {
            ui_2d_line(bx + x * cell, by, bx + x * cell, by + 9 * cell, COL_LINE, 1);
        } else {
            ui_2d_line(bx + x * cell, by, bx + x * cell, by + 4 * cell, COL_LINE, 1);
            ui_2d_line(bx + x * cell, by + 5 * cell, bx + x * cell, by + 9 * cell, COL_LINE, 1);
        }
    }
    /* 两座九宫的斜线 */
    /* The diagonals of the two palaces */
    ui_2d_line(bx + 3 * cell, by, bx + 5 * cell, by + 2 * cell, COL_LINE, 1);
    ui_2d_line(bx + 5 * cell, by, bx + 3 * cell, by + 2 * cell, COL_LINE, 1);
    ui_2d_line(bx + 3 * cell, by + 7 * cell, bx + 5 * cell, by + 9 * cell, COL_LINE, 1);
    ui_2d_line(bx + 5 * cell, by + 7 * cell, bx + 3 * cell, by + 9 * cell, COL_LINE, 1);

    /* 楚河汉界（写在两段竖线的空档里，竖排读着别扭，横排即可） */
    /* The river "Chu He Han Jie" (written in the gap between the two broken vertical lines; vertical text reads awkwardly, horizontal is fine) */
    /* ⚠ 英文只能给 "Chu"/"Han"（楚河/汉界的专名）—— 河界那一格只有 1 cell 宽（约 35px），
     * ⚠ The English can only be "Chu"/"Han" (the proper names) -- that cell is only 1 cell wide (about 35px),
       而 "RIVER"/"BORDER" 在 cell*2/5 的字号下正好占满乃至溢出。
     * and "RIVER"/"BORDER" at the cell*2/5 font size would exactly fill it or overflow. */
    ui_2d_text_v(bx + 2 * cell, by + 4 * cell + cell / 2, g_lang == 0 ? "楚河" : "Chu", COL_LINE,
              cell * 2 / 5, VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, 0);
    ui_2d_text_v(bx + 6 * cell, by + 4 * cell + cell / 2, g_lang == 0 ? "汉界" : "Han", COL_LINE,
              cell * 2 / 5, VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, 0);

    /* 棋子 */
    /* Pieces */
    r = cell * 2 / 5;
    if (r < 5) r = 5;
    for (i = 0; i < BW * BH; i = i + 1) {
        v = b[i];
        if (v == 0) continue;
        cx = bx + (i % BW) * cell;
        cy = by + (i / BW) * cell;
        s = v / 10;
        if (s == S_RED) { ink = COL_RED; ring = COL_RED; }
        else { ink = COL_BLACK; ring = COL_BLACK; }
        ui_2d_circle(cx, cy, r, ring, 0, 2);          /* 外圈 */
        /* Outer ring */
        ui_2d_circle(cx, cy, r - 2, COL_PIECE, 1, 0); /* 内底 */
        /* Inner fill */
        ui_2d_text_v(cx, cy, name_of(v), ink, cell * 3 / 5,
                  VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, VML_FONT_BOLD);
        /* 最后一步的落点画个小圈，方便看清电脑刚走哪儿 */
        /* Draw a small ring on the last move's landing square so you can see where the computer just moved */
        if (i == sel && sel >= 0) ui_2d_circle(cx, cy, r + 3, COL_SEL, 0, 2);
    }

    /* 选中子的可走点（**现算**，不另存一份 —— 画出来的点与真正可行的点必然一致） */
    /* Legal targets of the selected piece (**computed on the spot**, never cached -- the dots drawn and the actually legal targets can never disagree) */
    if (sel >= 0) {
        x = sel % BW;
        y = sel / BW;
        for (i = 0; i < BW * BH; i = i + 1) {
            dx = i % BW;
            dy = i / BW;
            if (legal_move(b, x, y, dx, dy) == 0) continue;
            ds = cell / 8;
            if (ds < 3) ds = 3;
            if (b[i] != 0) ui_2d_circle(bx + dx * cell, by + dy * cell, r, COL_SEL, 0, 3);
            else ui_2d_circle(bx + dx * cell, by + dy * cell, ds, COL_SEL, 1, 0);
        }
    }

    /* 顶部状态行 */
    /* The top status line */
    ui_2d_text_v(bx, 6, status, COL_TEXT, 15, VML_ANCHOR_LEFT, VML_VANCHOR_TOP, VML_FONT_BOLD);
}

/* btns = {重开x,y,w,h, 悔棋x,y,w,h} —— 画与命中判定读同一个数组，不各算一遍。 */
/* btns = {restart x,y,w,h, undo x,y,w,h} -- drawing and hit-testing read the same array instead of each computing its own. */
void draw_buttons(int* btns) {
    int i;
    int x;

    i = 0;
    while (i < 2) {
        x = i * 4;
        ui_2d_rect(btns[x], btns[x + 1], btns[x + 2], btns[x + 3], COL_BTN, 1, 0, 8);
        if (i == 0) {
            ui_2d_text_v(btns[x] + btns[x + 2] / 2, btns[x + 1] + btns[x + 3] / 2,
                      g_lang == 0 ? "重开" : "Restart",
                      COL_BTN_TX, 16, VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, 0);
        } else {
            ui_2d_text_v(btns[x] + btns[x + 2] / 2, btns[x + 1] + btns[x + 3] / 2,
                      g_lang == 0 ? "悔棋" : "Undo",
                      COL_BTN_TX, 16, VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, 0);
        }
        i = i + 1;
    }
}

int pt_in(int px, int py, int x, int y, int w, int h) {
    if (px < x || px > x + w) return 0;
    if (py < y || py > y + h) return 0;
    return 1;
}

/* ═══════════════════════ 主程序 ═══════════════════════ */
/* ═══════════════════════ Main program ═══════════════════════ */

#ifndef CHESS_LIB_ONLY

/* ── 音效：**用 ui_audio_beep 单音**（v0.96.508 换回来） ──────────────
 * ── Sound: **single-tone ui_audio_beep** (switched back in v0.96.508) ──────────────
 *
 * ⚠⚠ 这里一度改用共享库的音序器（`ui_sfx_add`），**真机上破音**，换回来了。
 * ⚠⚠ This once used the shared library's sequencer (`ui_sfx_add`) and **broke up on a real device**, so it was switched back.
 *   原因不是音序器本身，是**这里配的音**：
 *   The cause was not the sequencer itself but **the sounds configured here**:
 *     · 将军 / 赢 / 输 三组都是**多个音叠着响**（将军 2 声部、胜负各 3 声部），
 *     · the check / win / lose groups all **sounded several notes at once** (2 voices for check, 3 each for win and lose)
 *       音量还开到了 90–95 —— 多声部一叠加就顶到**削波**；
 *       with the volume up at 90-95 -- stacked voices pushed straight into **clipping**;
 *     · `sfx_lose` 的末音是 `45`(A2 = **110Hz**)，而 `vml_ui.h` 里白纸黑字
 *     · the last note of `sfx_lose` was `45` (A2 = **110Hz**), and `vml_ui.h` says in plain words
 *       写着「低音别写太低…手机外放在 200Hz 以下衰减很快，C2 出来是"噗"一声闷响，
 *       "do not write bass too low ... a phone speaker rolls off fast below 200Hz, so C2 comes out as a dull thump,
 *       **玩家听着像没响**」。这一条正是冲着这类写法写的。
 *       **the player hears it as silence**". That note was written exactly for this kind of code.
 *
 *   `ui_audio_beep` 是**单通道**的（后一个音掐掉前一个）⇒ 一个事件永远只有一个音在响，
 *   `ui_audio_beep` is **single-channel** (a new tone cuts the previous one) => one event never has more than one tone sounding,
 *   **结构上不可能削波**。连锁反应的代价也不大：将军/胜负本来就是"一声提示"，
 *   **so clipping is structurally impossible**. The knock-on cost is small: check and win/lose are "one cue" anyway
 *   不需要和弦。
 *   and need no chord.
 *
 * ⚠ 频率沿用换音序器之前那一版（v0.96.490 之前就在用的），**别随手调** ——
 * ⚠ The frequencies are the ones from before the sequencer switch (already in use before v0.96.490) -- **do not tweak them casually**;
 *   调了要真机听。分得清"谁走的"靠的是音区：
 *   if you change them, listen on a real device. Telling "whose move it was" apart relies on the pitch range:
 *   选子 760 / 你走子 880 / 电脑走子 560 / 悔棋成 700 / 悔棋不成 300 /
 *   pick 760 / your move 880 / computer move 560 / undo ok 700 / undo rejected 300 /
 *   新局 900 / 将军 1200 / 赢 1320 长 / 输 240 长。
 *   new game 900 / check 1200 / win 1320 long / lose 240 long. */

void sfx_pick(void)   { ui_audio_beep(760, 20); }
void sfx_move(void)   { ui_audio_beep(880, 25); }
void sfx_aimove(void) { ui_audio_beep(560, 25); }

/* 悔棋：成不成一听就知道（成了清亮、没得悔低闷）。 */
/* Undo: you hear at once whether it worked (clear when it did, dull when there was nothing to undo). */
void sfx_undo_ok(void) { ui_audio_beep(700, 40); }
void sfx_undo_no(void) { ui_audio_beep(300, 60); }

void sfx_newgame(void) { ui_audio_beep(900, 70); }

/* 将军：**必须让玩家立刻知道**的事 —— 比周围所有音都高、都长。 */
/* Check: something the player **must know immediately** -- higher and longer than every sound around it. */
void sfx_check(void) { ui_audio_beep(1200, 90); }

/* 赢：高、长，明亮；输：低、长。**两个方向，不会听错。** */
/* Win: high and long, bright; lose: low and long. **Two opposite directions, impossible to mishear.** */
void sfx_win(void) {
    ui_audio_beep(1320, 320);
    ui_vibrate_simple(60, 0);
}
void sfx_lose(void) {
    ui_audio_beep(240, 420);
    ui_vibrate_simple(220, 0);
}

int main(void) {
    int b[CELLS];
    int msg[4];
    int btns[8];
    int sw;
    int sh;
    int cell;
    int bx;
    int by;
    int t;
    int x;
    int y;
    int col;
    int row;
    int idx;
    int sel;
    int t0;
    int r;
    int i;
    int f;
    int tt;
    int over;          /* 0 进行中 / 1 人胜 / 2 电脑胜 / 3 和棋（理论上有） */
    /* 0 in progress / 1 human wins / 2 computer wins / 3 draw (in theory) */
    int turn;          /* 当前该谁走：S_RED / S_BLK */
    /* Whose turn it is: S_RED / S_BLK */
    int aiFrom;
    int aiTo;
    int hf[4];         /* 悔棋栈：最近 4 个半回合（人/电脑各 2） */
    /* Undo stack: the last 4 half-moves (2 each for human and computer) */
    int ht[4];
    int hc[4];
    int hn;
    char* status;

    init_board(b);

    /* 竖屏 + 不要手柄区：棋盘是竖着看的，全程触摸，手柄一个都用不上 */
    /* Portrait + no gamepad area: the board is read vertically and everything is touch, so the gamepad is of no use at all */
    g_lang = ui_scr_get_language();
    ui_win_open_ex(g_lang == 0 ? "象棋" : "Chess", 0, 0, VML_WIN_PORTRAIT, VML_WIN_NO_GAMEPAD);
    sw = ui_scr_get_w();
    sh = ui_scr_get_h();
    if (sw <= 0) sw = 380;
    if (sh <= 0) sh = 700;
    ui_scr_set_keep_on(1);

    /* 布局：顶部一行状态、底部一行按钮，中间给棋盘。宽高**分开算**再取小者 */
    /* Layout: one status line at the top, one button row at the bottom, the board in between. Width and height are **computed separately** and the smaller wins */
    cell = sw / 11;
    if ((sh - 110) / 12 < cell) cell = (sh - 110) / 12;
    if (cell < 8) cell = 8;
    bx = (sw - 8 * cell) / 2;
    by = 30 + (sh - 110 - 9 * cell) / 2;
    if (by < 30) by = 30;

    /* 两个按钮并排居中放在底部 */
    /* The two buttons sit side by side, centred, at the bottom */
    btns[2] = sw / 3;
    btns[3] = 40;
    btns[0] = sw / 2 - btns[2] - 6;
    btns[1] = sh - btns[3] - 10;
    btns[6] = btns[2];
    btns[7] = btns[3];
    btns[4] = sw / 2 + 6;
    btns[5] = btns[1];

    sel = -1;
    over = 0;
    turn = S_RED;
    hn = 0;
    /* ⚠ 顶部状态行是**左对齐、不折行**的一条（`ui_2d_text_v(bx, 6, …)`，字号 15）——
     * ⚠ The top status line is a single **left-aligned, non-wrapping** line (`ui_2d_text_v(bx, 6, ...)`, font size 15) --
       可用宽度约 sw − bx ≈ 338px，英文最长的 "Computer has no move. Red wins"（30 字符
     * the usable width is about sw - bx ~ 338px, and the longest English string, "Computer has no move. Red wins" (30 characters
       ≈ 225px）也在里面。再加词就会溢出，别再往这些串上添字。
     * ~ 225px), already fits. Add more words and it overflows, so do not put more text on these strings. */
    status = g_lang == 0 ? "你执红先行，点自己的子再点落点" : "You are red — tap a piece";

    t0 = ui_dlg_msg(g_lang == 0 ? "象棋" : "Chess",
                    g_lang == 0 ? "你执红先行。点亮自己的棋子，再点亮要去的点；底部可悔棋。"
                                : "You are red and move first. Tap your piece, then tap where it goes. Undo is at the bottom.",
                    VML_DLG_INFO);

    draw_board(b, bx, by, cell, sel, status);
    draw_buttons(btns);
    ui_2d_present();

    while (ui_win_is_closed() == 0) {
        t = ui_msg_wait(msg, 0);
        if (t == 0) continue;
        if (t == VML_MSG_WINDOWCLOSE) break;

        /* ⚠ **只认 TOUCHDOWN，绝不把 MOUSEDOWN 一起认** —— 这一条是本程序"完全下不了"的根因。
         * ⚠ **Accept TOUCHDOWN only, never MOUSEDOWN as well** -- this was the root cause of the program being "completely unplayable".
         *
         * 手机上一个物理点按会投出**两条**消息：先一条触摸、紧跟一条**坐标相同**的鼠标
         * One physical tap on a phone posts **two** messages: first a touch, then immediately a mouse event with the **same
         * （`DrawWindowPage.PostTouch` 里那个 `calls.PostInput(MouseDown…)` 在
         *  coordinates** (the `calls.PostInput(MouseDown...)` in `DrawWindowPage.PostTouch` sits **outside**
         *  `if (wantTouch)` **之外**，凡是图形窗口两族都发；`VmlUi.SuppressTouch` 只对
         *  `if (wantTouch)`, so every graphics window gets both families; `VmlUi.SuppressTouch` only suppresses
         *  电脑屏窗口抑制触摸）。桌面脚手架下我按 `touchdown`+`mousedown` 成对投进去复现了：
         *  touch for computer-screen windows). On the desktop harness I reproduced it by posting `touchdown` + `mousedown` as a pair:
         * 一次点按只听到 760 那一声（选中），选中位随即被抹掉 —— 因为第二次进到
         * one tap produced only the 760 beep (selection), and the selection was immediately wiped -- because the second event reached
         * `else if (idx == sel) sel = -1;` 那条分支，把刚选中的子**取消**掉了。
         * the `else if (idx == sel) sel = -1;` branch and **deselected** the piece just chosen.
         *
         * 五子棋同样是"两族都认"，却看不出来：它落子后 `if (b[idx] != EMPTY) continue;`
         * Gomoku accepts both families too and never showed it: after placing a stone its `if (b[idx] != EMPTY) continue;`
         * 天然幂等，重复那一下是空操作。**本程序是"先选子、再点落点"的两步状态机，
         * is naturally idempotent, so the repeat is a no-op. **This program is a two-step state machine ("pick a piece, then tap the
         * 对同一个点重复输入不幂等**，于是「点自己的子」永远只闪一下、根本选不中。
         * destination"), so repeating input on the same square is not idempotent** -- which is why "tap your own piece" only ever flashed and never selected.
         *
         * 鼠标那条不认即可 —— 它已经被这次 `ui_msg_wait` 取走，不会留在队列里变成下一次点按。
         * Simply not accepting the mouse one is enough -- this `ui_msg_wait` has already consumed it, so it cannot stay in the queue and become the next tap.
         * 约定与 `calc.c` 一致（它也只认 TOUCHDOWN），`vml_ui.h` 头部的示例同样如此。
         * The convention matches `calc.c` (which also accepts TOUCHDOWN only) and the example at the top of `vml_ui.h`. */
        if (t != VML_MSG_TOUCHDOWN) continue;

        x = msg[1];
        y = msg[2];

        /* 按钮 */
        /* Buttons */
        if (pt_in(x, y, btns[4], btns[5], btns[6], btns[7]) == 1) {
            if (hn >= 2 && over == 0) {
                /* 悔一个整回合（电脑 + 人）—— 只退一半的话又轮不到人走，等于白给。
                 * Undo one whole turn (computer + human) -- rewinding only half would leave it the computer's turn again, which is useless.
                 * 恢复顺序**不能反**：先把子从落点搬回起点，再把落点还原成"原来被吃的那个子"
                 * The restore order **must not be reversed**: first move the piece from the landing square back to the origin, then restore the landing
                 * （没吃就是 0 = 空）。反过来的话读到的落点已经被自己覆盖了。
                 * square to "whatever piece was captured there" (0 = empty if nothing was). Reversed, the landing square you read has already been overwritten by your own piece. */
                i = 0;
                while (i < 2) {
                    hn = hn - 1;
                    b[hf[hn]] = b[ht[hn]];
                    b[ht[hn]] = hc[hn];
                    i = i + 1;
                }
                sel = -1;
                turn = S_RED;
                status = g_lang == 0 ? "已悔一步，该你走" : "Undone. Your move";
                sfx_undo_ok();
            } else {
                sfx_undo_no();
            }
            draw_board(b, bx, by, cell, sel, status);
            draw_buttons(btns);
            ui_2d_present();
            continue;
        }
        if (pt_in(x, y, btns[0], btns[1], btns[2], btns[3]) == 1) {
            init_board(b);
            sel = -1;
            over = 0;
            turn = S_RED;
            hn = 0;
            status = g_lang == 0 ? "新的一局，你执红先行" : "New game. You are red";
            sfx_newgame();
            ui_msg_clear();
            draw_board(b, bx, by, cell, sel, status);
            draw_buttons(btns);
            ui_2d_present();
            continue;
        }

        if (over != 0) continue;

        /* 棋盘 */
        /* The board */
        col = hit_line(x, bx, cell);
        row = hit_line(y, by, cell);
        if (col < 0 || col >= BW || row < 0 || row >= BH) { sel = -1; }
        else {
            idx = row * BW + col;
            if (turn != S_RED) {
                /* 电脑在走，忽略触摸 */
                /* The computer is moving, ignore touch */
            } else if (sel < 0) {
                if (b[idx] != 0 && b[idx] / 10 == S_RED) {
                    sel = idx;
                    sfx_pick();
                }
            } else if (idx == sel) {
                sel = -1;
            } else if (b[idx] != 0 && b[idx] / 10 == S_RED) {
                sel = idx;
                sfx_pick();
            } else if (legal_move(b, sel % BW, sel / BW, col, row) == 1) {
                /* 人走子 */
                /* The human plays a move */
                f = sel;
                tt = idx;
                if (hn >= 4) {
                    /* 栈满：整体前移一位（只留最近 4 个半回合，够悔两次） */
                    /* Stack full: shift everything along by one (keep only the last 4 half-moves, enough for two undos) */
                    i = 0;
                    while (i < 3) {
                        hf[i] = hf[i + 1];
                        ht[i] = ht[i + 1];
                        hc[i] = hc[i + 1];
                        i = i + 1;
                    }
                    hn = 3;
                }
                hf[hn] = f;
                ht[hn] = tt;
                hc[hn] = b[tt];
                hn = hn + 1;
                b[tt] = b[f];
                b[f] = 0;
                sel = -1;
                turn = S_BLK;
                sfx_move();
                ui_vibrate_simple(15, 0);

                if (in_check(b, S_BLK) == 1) sfx_check();
                if (has_legal(b, S_BLK) == 0) {
                    over = 1;
                    status = g_lang == 0 ? "将死！红方胜" : "Checkmate! Red wins";
                } else {
                    status = g_lang == 0 ? "电脑思考中…" : "Computer thinking...";
                    draw_board(b, bx, by, cell, sel, status);
                    draw_buttons(btns);
                    ui_2d_present();

                    /* 电脑走 */
                    /* The computer's move */
                    r = ai_pick(b, S_BLK);
                    if (r < 0) {
                        over = 1;
                        status = g_lang == 0 ? "电脑无棋可走，红方胜" : "Computer has no move. Red wins";
                    } else {
                        aiFrom = r / 100;
                        aiTo = r % 100;
                        if (hn >= 4) {
                            i = 0;
                            while (i < 3) {
                                hf[i] = hf[i + 1];
                                ht[i] = ht[i + 1];
                                hc[i] = hc[i + 1];
                                i = i + 1;
                            }
                            hn = 3;
                        }
                        hf[hn] = aiFrom;
                        ht[hn] = aiTo;
                        hc[hn] = b[aiTo];
                        hn = hn + 1;
                        b[aiTo] = b[aiFrom];
                        b[aiFrom] = 0;
                        sfx_aimove();
                        turn = S_RED;

                        if (in_check(b, S_RED) == 1) {
                            sfx_check();
                            ui_vibrate_simple(30, 0);
                            status = g_lang == 0 ? "将军！该你走" : "Check! Your move";
                        } else {
                            status = g_lang == 0 ? "该你走" : "Your move";
                        }
                        if (has_legal(b, S_RED) == 0) {
                            over = 2;
                            status = g_lang == 0 ? "你被将死了，电脑胜" : "Checkmate. Computer wins";
                        }
                    }
                }
            } else {
                sel = -1;
            }
        }

        draw_board(b, bx, by, cell, sel, status);
        draw_buttons(btns);
        ui_2d_present();

        /* 一局结束：收在**这一处**（人将死电脑 / 电脑将死人 / 无棋可走都汇到这里）——
         * End of a game: it all converges **here** (human mates computer / computer mates human / no move available) --
         * 先让终局画面留在屏上，再出声弹框问要不要再来。
         * leave the final position on screen first, then play a sound and ask whether to play again. */
        if (over != 0) {
            if (over == 1) {
                sfx_win();
                r = ui_dlg_msg(g_lang == 0 ? "象棋" : "Chess",
                               g_lang == 0 ? "恭喜，你赢了！再来一局？" : "You win! Play again?",
                               VML_DLG_QUESTION);
            } else {
                sfx_lose();
                r = ui_dlg_msg(g_lang == 0 ? "象棋" : "Chess",
                               g_lang == 0 ? "电脑赢了。再来一局？" : "Computer wins. Play again?",
                               VML_DLG_QUESTION);
            }
            if (r == 1) break;                 /* 弹框失败(-1)也当"再来"，别把局面卡死 */
            /* A failed dialog (-1) also counts as "play again" -- do not leave the position stuck */
            init_board(b);
            sel = -1;
            over = 0;
            turn = S_RED;
            hn = 0;
            status = g_lang == 0 ? "新的一局，你执红先行" : "New game. You are red";
            ui_msg_clear();
            sfx_newgame();
            draw_board(b, bx, by, cell, sel, status);
            draw_buttons(btns);
            ui_2d_present();
        }
    }

    ui_scr_set_keep_on(0);
    ui_timer_set(120, 0);
    t = ui_msg_wait(msg, 400);
    ui_win_close();
    return 0;
}

#endif /* CHESS_LIB_ONLY */