// 打砖块 —— 用 **C#** 写的手机游戏（不是 C）
// Breakout — a phone game written in **C#** (not C)
//
// 玩法：挡板在底下，球在场上弹。**拖动手指**（挡板跟着手指走）或方向键左右移动挡板，
// Gameplay: the paddle sits at the bottom and the ball bounces around the field. **Drag your
// 点一下（或空格/回车）发球。球打光一整片砖就过关（挡板与球都提速、砖块加多一行），
// finger** (the paddle follows it) or use the left/right arrows to move the paddle; tap (or
// 三条命打完就结束。球碰到挡板的哪个位置决定反弹角度 —— 打中间弹得直、打边缘弹得斜。
// Space/Enter) to serve. Clear every brick to advance a level (paddle and ball speed up, one
// more row of bricks); three lives, then it is over. Where the ball hits the paddle sets the
// bounce angle — the middle sends it straight back, the edges send it sideways.
//
// ## 为什么写得这么"平"
// ## Why it is written so "flat"
//
// C# 前端只支持一个子集（`Examples/csharp/g2048.cs` 的文件头列了完整名单），这里沿用同一套
// The C# front end supports only a subset (the full list is in `Examples/csharp/g2048.cs`'s header);
// 已被验证过的写法：一个类 + `static` 字段/方法 + 定长数组 + `while`/`if`/`switch`。
// this file sticks to the same verified constructs: one class, `static` fields/methods, fixed-length
// 全篇**整数**物理（1 像素/拍），不碰浮点 —— 与本仓其它例程同一取舍。
// arrays and `while`/`if`/`switch`. The physics is **all integers** (1 pixel per tick), no floating
// point — the same trade-off as the other examples in this repo.
//
// ## 音效按「一次事件一个音」
// ## Sound: one beep per event
//
// `ui_audio_beep` 是**单通道**的（后一个音掐掉前一个），所以这里给每种事件挑一个**不同音高**、
// `ui_audio_beep` is **single-channel** (a new tone cuts the previous one), so every event gets its own
// 而且一拍里最多发一个：砖块 880 / 挡板 440 / 丢命 131 / 过关 1047 / 结束 98。
// pitch and at most one beep per tick: brick 880 / paddle 440 / lost life 131 / level clear 1047 /
// game over 98.
//
// ## 每帧图元数
// ## Primitives per frame
//
// 砖块 42 + 墙 4 + 挡板 2 + 球 2 + HUD ≈ **60**，远在 400 之下。数值由**宿主自己**报
// 42 bricks + 4 walls + 2 paddle + 2 ball + HUD ≈ **60**, far below 400. The number comes from the
// （`ui_res_get_count(0)`，每个新高峰打印一行 `PRIMAX n`，见 `draw()`）。
// **host itself** (`ui_res_get_count(0)`; every new high water mark prints a `PRIMAX n` line — see `draw()`).
//
// 数值的唯一真源仍是 `Lib/c/vml_ui.h`。
// The single source of truth for these numbers is still `Lib/c/vml_ui.h`.

// 显式引用 UI 库：`ui_*` 的声明在 `Lib/csharp/VmlUi.cs`（tools/GenLib 生成，别手改）。
// Explicit reference to the UI library: `ui_*` is declared in `Lib/csharp/VmlUi.cs` (generated by tools/GenLib; don't hand-edit).
using Vml.Ui;

class Breakout
{
    // ── 消息类型（源：Lib/c/vml_ui.h）──
    // ── Message types (source: Lib/c/vml_ui.h) ──
    const int MSG_NONE = 0;
    const int MSG_KEYDOWN = 1;
    const int MSG_TOUCHDOWN = 6;
    const int MSG_TOUCHMOVE = 7;
    const int MSG_TOUCHUP = 8;
    const int MSG_TIMER = 9;
    const int MSG_WINDOWCLOSE = 10;
    const int MSG_WINDOWRESIZE = 11;

    // ── 键码 ──
    // ── Key codes ──
    const int KEY_ENTER = 13;
    const int KEY_ESCAPE = 27;
    const int KEY_SPACE = 32;
    const int KEY_LEFT = 37;
    const int KEY_UP = 38;
    const int KEY_RIGHT = 39;
    const int KEY_DOWN = 40;
    const int KEY_PAD_A = 65;

    // ── 锚点 / 样式 / 竖对齐 ──
    // ── Anchors / styles / vertical alignment ──
    const int ANCHOR_LEFT = 0;
    const int ANCHOR_CENTER = 1;
    const int ANCHOR_RIGHT = 2;
    const int FONT_BOLD = 1;
    const int VANCHOR_MIDDLE = 1;

    // ── 语言 / 对话框 ──
    // ── Language / dialog ──
    const int LANG_ZH = 0;
    const int DLG_INFO = 0;

    // ── 窗口声明（开窗之前生效）──
    // ── Window declarations (take effect before the window opens) ──
    const int WIN_PORTRAIT = 0;
    const int WIN_NO_GAMEPAD = 0;

    // ── 规则常量 ──
    // ── Rule constants ──
    const int COLS = 7;
    const int MAXB = 42;                 // 6 行 × 7 列的上限
    // upper bound: 6 rows x 7 columns
    const int ROWS_MAX = 6;
    const int START_LIVES = 3;
    const int TICK_MS = 33;              // ≈30fps
    const int BALL_R = 6;
    const int PADDLE_H = 12;

    // ── 颜色（0xAARRGGBB 的十进制负数形式）──
    // ── Colors (the decimal-negative form of 0xAARRGGBB) ──
    const int BG = -15724520;            // 0xFF101018 底色
    // 0xFF101018 background
    const int WALL = -15263713;          // 0xFF17181F 墙
    // 0xFF17181F wall
    const int PADDLE_C = -11409298;      // 0xFF51E86E 挡板
    // 0xFF51E86E paddle
    const int BALL_C = -1;               // 0xFFFFFFFF 球
    // 0xFFFFFFFF ball
    const int HUD_C = -6643536;          // 0xFF9AA0B0 次要文字
    // 0xFF9AA0B0 secondary text
    const int WHITE = -1;
    const int ACCENT = -11409298;        // 0xFF51E86E
    const int DARKTXT = -15724520;

    // 砖块按行分色（越靠下越硬、颜色越暖）
    // Bricks are colored by row (lower rows are tougher and warmer)
    const int B0 = -11890471;            // 0xFF4A90D9
    const int B1 = -6962941;             // 0xFF95A5B3
    const int B2 = -2509750;             // 0xFFD9B44A
    const int B3 = -2069424;             // 0xFFE06C50
    const int B4 = -2523025;             // 0xFFD9534F
    const int B5 = -7623434;             // 0xFF8B5CF6

    // ── 状态 ──
    // ── State ──
    static int[] bAlive = new int[MAXB];
    static int[] bHp = new int[MAXB];
    static int sw;
    static int sh;
    static int lang;

    static int score;
    static int best;
    static int lives;
    static int level;
    static int rows;                     // 本关砖块行数
    // brick rows in this level
    static int left;                     // 还剩几块砖
    // bricks still standing
    static int state;                    // 0=待发球 1=进行中 2=过关横幅 3=结束
    // 0=awaiting serve 1=playing 2=level-cleared banner 3=over
    static int banner;                   // 横幅还剩几拍
    // how many ticks the banner still lasts
    static int frames;
    static int acc;                      // 运动墙钟欠账（毫秒）—— 按墙钟补步，用户 2026-10-04 口径
    // Motion wall-clock debt in ms — steps are caught up from the wall clock (user's 2026-10-04 rule)
    static int lastMs;                   // 上次补步取的墙钟时刻（进主循环时初始化）
    // wall-clock moment of the last catch-up (initialized on entering the main loop)

    // ── 几何（开窗时算一次；画与命中判定共用同一套数）──
    // ── Geometry (computed once at open; drawing and hit-testing share the same numbers) ──
    static int fl;
    static int fr;
    static int ft;
    static int fb;
    static int bw;
    static int bh;
    static int btop;
    static int pw;
    static int px;
    static int py;

    // ── 球（整数像素/拍）──
    // ── Ball (integer pixels per tick) ──
    static int bx;
    static int by;
    static int vx;
    static int vy;

    // ── 触摸 ──
    // ── Touch ──
    // ⚠ 挡板跟手用的是**轮询**（`ui_touch_fetch/ui_touch_get_x`），不是事件。
    // ⚠ The paddle follows the finger by **polling** (`ui_touch_fetch/ui_touch_get_x`), not by events.
    //   理由：拖动是"连续量、只关心最新位置"，而事件队列会积压（实测一次拖动能涨到上千条，
    //   Reason: a drag is a continuous quantity and only its newest position matters, while the event
    //   触摸于是要等半天才反应）。轮询读的是**宿主此刻的手指状态**，积压与否都不影响。
    //   queue piles up (measured: one drag can grow it to four figures, after which touch reacts
    //   sluggishly). Polling reads the host's **current** finger state and is immune to that.
    //   事件只用来**发起球**（那是离散语义，一次点击算一次）。
    //   Events are used only to **serve** (a discrete action: one tap counts once).
    static int lastPx;

    // ── 事件文本（**每回合只拼一次**，不在逐帧路径上）──
    // ── Event text (**built once per event**, never on the per-frame path) ──
    // ⚠ 字符串的 `+` 是**真拼接**（v0.96.592 修的，用的是共享库的 strcat），但它**每次都
    // ⚠ The string `+` really is a **concatenation** now (fixed in v0.96.592, built on the shared
    //   要 alloc 一块**不回收**的内存** ⇒ 放进 `draw()` 里就是每帧漏几块。这里的规矩是：
    //    library's strcat), but **every one of them allocs a block that is never freed** ⇒ putting
    //    **逐帧要显示的数走 `drawNum`（逐位画、零分配），要拼的话就在事件里拼一次存进字段**。
    //    it inside `draw()` would leak a few blocks per frame. The rule here: **numbers drawn every
    //    frame go through `drawNum` (digit by digit, zero allocation); anything that needs
    //    concatenation is built once, in the event, and kept in a field.**
    static string bannerText;
    static string overText;
    static string liveText;

    static int primMax;

    static string T(string zh, string en)
    {
        if (lang == LANG_ZH) return zh;
        return en;
    }

    static string digitText(int d)
    {
        if (d == 0) return "0";
        if (d == 1) return "1";
        if (d == 2) return "2";
        if (d == 3) return "3";
        if (d == 4) return "4";
        if (d == 5) return "5";
        if (d == 6) return "6";
        if (d == 7) return "7";
        if (d == 8) return "8";
        return "9";
    }

    static int numDigits(int v)
    {
        if (v < 10) return 1;
        if (v < 100) return 2;
        if (v < 1000) return 3;
        if (v < 10000) return 4;
        if (v < 100000) return 5;
        return 6;
    }

    static int pow10(int n)
    {
        if (n <= 0) return 1;
        if (n == 1) return 10;
        if (n == 2) return 100;
        if (n == 3) return 1000;
        if (n == 4) return 10000;
        return 100000;
    }

    // 逐位画一个数（不拼字符串、不分配内存）。anchor：0=左 1=中 2=右
    // Draw a number digit by digit (no string building, no allocation). anchor: 0=left 1=centre 2=right
    static void drawNum(int x, int y, int v, int color, int size, int anchor)
    {
        int n = numDigits(v);
        int dw = size * 14 / 25;             // 字宽实测值，见 g2048.cs 的文件头
        // measured glyph width, see the file header of g2048.cs
        int w = n * dw;
        int startX = x;
        if (anchor == ANCHOR_CENTER) startX = x - w / 2;
        if (anchor == ANCHOR_RIGHT) startX = x - w;
        int q = v;
        if (q < 0) q = 0;
        int i = 0;
        while (i < n)
        {
            int d = (q / pow10(n - 1 - i)) % 10;
            ui_2d_text(startX + i * dw, y, digitText(d), color, size, ANCHOR_LEFT);
            i = i + 1;
        }
    }

    static int brickColor(int r)
    {
        if (r == 0) return B0;
        if (r == 1) return B1;
        if (r == 2) return B2;
        if (r == 3) return B3;
        if (r == 4) return B4;
        return B5;
    }

    static int brickX(int i)
    {
        return fl + (i % COLS) * bw;
    }

    static int brickY(int i)
    {
        return btop + (i / COLS) * bh;
    }

    // ════════════════════════════════════════════════════════════════════
    // 版面
    // Layout
    // ════════════════════════════════════════════════════════════════════
    static void layout()
    {
        int pad = sw / 24;
        if (pad < 6) pad = 6;
        fl = pad;
        fr = sw - pad;
        ft = 78;
        fb = sh - 74;
        bw = (fr - fl) / COLS;
        bh = 20;
        btop = ft + 10;
        pw = sw / 4;
        if (pw < 64) pw = 64;
        if (pw > fr - fl) pw = fr - fl;
        py = fb - 26;
        if (px < fl) px = fl;
        if (px + pw > fr) px = fr - pw;
    }

    // ════════════════════════════════════════════════════════════════════
    // 关卡
    // Levels
    // ════════════════════════════════════════════════════════════════════
    static void buildLevel()
    {
        rows = 3 + level;
        if (rows > ROWS_MAX) rows = ROWS_MAX;
        int n = rows * COLS;
        int i = 0;
        while (i < MAXB)
        {
            bAlive[i] = 0;
            bHp[i] = 0;
            i = i + 1;
        }
        i = 0;
        while (i < n)
        {
            bAlive[i] = 1;
            // 最下面一行要打两下（越往下越硬）
            // The bottom row takes two hits (lower rows are tougher)
            if (i / COLS == rows - 1 && level > 0) bHp[i] = 2;
            else bHp[i] = 1;
            i = i + 1;
        }
        left = n;
    }

    static int ballSpeed()
    {
        int s = 6 + level;
        if (s > 12) s = 12;
        return s;
    }

    static void serve()
    {
        state = 0;
        px = (fl + fr) / 2 - pw / 2;
        bx = px + pw / 2;
        by = py - BALL_R - 1;
        vx = 3;
        vy = 0 - ballSpeed();
        println_str("SERVE");
    }

    static void launch()
    {
        if (state != 0) return;
        state = 1;
        ui_audio_beep(660, 60);
        println_str("LAUNCH");
    }

    static void newGame()
    {
        score = 0;
        lives = START_LIVES;
        level = 0;
        banner = 0;
        bannerText = "";
        buildLevel();
        serve();
        println_str("NEWGAME");
    }

    static void levelClear()
    {
        level = level + 1;
        buildLevel();
        // 过关横幅**在这里拼一次**（不在 draw 里拼 —— 那样每帧都要 alloc）
        // The level banner is **built here, once** (not inside draw — that would alloc every frame)
        bannerText = T("过关！第 ", "LEVEL CLEAR!  Lv ") + (level + 1);
        banner = 34;
        state = 2;
        ui_audio_beep(1047, 200);
        println_str("LEVELCLEAR");
        print_str("LEVEL ");
        println_int(level + 1);
    }

    static void loseLife()
    {
        lives = lives - 1;
        print_str("LIFE ");
        println_int(lives);
        ui_audio_beep(131, 320);
        if (lives <= 0)
        {
            state = 3;
            // 结束语也**拼一次**存起来
            // The closing line is likewise built once and kept
            overText = T("三条命打完了 · 得分 ", "Out of lives  ·  score ") + score;
            println_str("OVER");
            draw();
            int a = ui_dlg_msg(T("打砖块", "Breakout"),
                               T("三条命打完了。\n再来一局？", "Out of lives.\nPlay again?"),
                               DLG_INFO);
            if (a != 0) { ui_win_close(); }
            newGame();
            return;
        }
        serve();
    }

    // ════════════════════════════════════════════════════════════════════
    // 绘制
    // Drawing
    // ════════════════════════════════════════════════════════════════════
    static void draw()
    {
        ui_2d_clear(BG);

        // ── 场地边框（三条墙 + 底边）──
        // ── Field frame (three walls + the bottom edge) ──
        ui_2d_rect(fl - 4, ft - 4, (fr - fl) + 8, 4, WALL, 1, 0, 0);
        ui_2d_rect(fl - 4, ft - 4, 4, (fb - ft) + 8, WALL, 1, 0, 0);
        ui_2d_rect(fr, ft - 4, 4, (fb - ft) + 8, WALL, 1, 0, 0);
        ui_2d_rect(fl - 4, fb, (fr - fl) + 8, 4, WALL, 1, 0, 0);

        // ── 砖块 ──
        // ── Bricks ──
        int i = 0;
        while (i < rows * COLS)
        {
            if (bAlive[i] != 0)
            {
                int c = brickColor(i / COLS);
                ui_2d_rect(brickX(i) + 1, brickY(i) + 1, bw - 3, bh - 3, c, 1, 0, 3);
                if (bHp[i] > 1) ui_2d_rect(brickX(i) + 5, brickY(i) + bh / 2 - 1, bw - 11, 3, WHITE, 1, 0, 0);
            }
            i = i + 1;
        }

        // ── 挡板 + 球 ──
        // ── Paddle + ball ──
        ui_2d_rect(px, py, pw, PADDLE_H, PADDLE_C, 1, 0, 5);
        ui_2d_rect(px + 3, py + 3, pw - 6, 3, WHITE, 1, 0, 2);
        ui_2d_circle(bx, by, BALL_R, BALL_C, 1, 0);
        ui_2d_circle(bx, by, BALL_R + 3, ACCENT, 0, 1);

        // ── HUD ──
        // ── HUD ──
        ui_2d_text(fl, 26, T("打砖块", "Breakout"), WHITE, 17, ANCHOR_LEFT);
        ui_2d_text(fl, 56, T("得分", "Score"), HUD_C, 11, ANCHOR_LEFT);
        drawNum(fl + 40, 56, score, ACCENT, 15, ANCHOR_LEFT);
        ui_2d_text(sw / 2 + 10, 56, T("关卡", "Level"), HUD_C, 11, ANCHOR_LEFT);
        drawNum(sw / 2 + 50, 56, level + 1, WHITE, 15, ANCHOR_LEFT);
        // 「命」这两个字摆在**那排圆点的左边**（右对齐在圆点左边一点）——
        // The two "lives" glyphs sit **to the left of the dot row** (right-aligned just left of the dots) -
        // 直接右对齐到 `fr` 会与圆点叠在一起（实测第一版就是这样）。
        // right-aligning straight to `fr` would overlap the dots (that is what the first version did).
        int h = 0;
        ui_2d_text(fr - lives * 16 - 6, 56, T("命", "Lives"), HUD_C, 11, ANCHOR_RIGHT);
        while (h < lives)
        {
            ui_2d_circle(fr - 12 - h * 16, 51, 5, ACCENT, 1, 0);
            h = h + 1;
        }

        // ── 底部提示 / 结束语 ──
        // ── Bottom hint / closing line ──
        if (state == 3)
        {
            ui_2d_text(sw / 2, sh - 46, overText, WHITE, 13, ANCHOR_CENTER);
        }
        else if (state == 0)
        {
            ui_2d_text(sw / 2, sh - 46, T("拖动屏幕移动挡板，点一下发球", "Drag to move the paddle, tap to serve"),
                    ACCENT, 13, ANCHOR_CENTER);
        }
        else
        {
            ui_2d_text(sw / 2, sh - 46, T("拖动屏幕（或方向键）移动挡板", "Drag (or use the arrows) to move the paddle"),
                    HUD_C, 12, ANCHOR_CENTER);
        }

        // ── 过关横幅 ──
        // ── Level-clear banner ──
        if (banner > 0)
        {
            int bwd = fr - fl - 30;
            ui_2d_rect(fl + 15, fb / 2 - 34, bwd, 68, -16777216, 1, 0, 12);
            ui_2d_text_v(sw / 2, fb / 2, bannerText, ACCENT, 18, ANCHOR_CENTER, VANCHOR_MIDDLE, FONT_BOLD);
        }

        // 每帧图元数（宿主侧真值）—— **只在新高时打印**，被超时杀掉的运行也留得下数
        // Primitives per frame (the host's own count) — printed **only when it grows**, so a run
        // killed by the timeout still leaves the number behind
        int np = ui_res_get_count(0);
        if (np > primMax)
        {
            primMax = np;
            print_str("PRIMAX ");
            println_int(primMax);
        }

        ui_2d_present();
    }

    // ════════════════════════════════════════════════════════════════════
    // 物理（整数像素/拍）
    // Physics (integer pixels per tick)
    // ════════════════════════════════════════════════════════════════════
    static void movePaddle(int x)
    {
        int nx = x - pw / 2;
        if (nx < fl) nx = fl;
        if (nx + pw > fr) nx = fr - pw;
        if (nx != px)
        {
            // `Math.Abs` **走的是前端新增的“标准方法 → 库标签”映射**（共享库的 `abs`，
            // `Math.Abs` **goes through the frontend's new "standard method -> library label" mapping** (the shared `abs`,
            // 与手写 `if (d < 0) d = 0 - d;` 等价 —— v0.96.592 修）。
            // equivalent to a hand-written `if (d < 0) d = 0 - d;` - fixed in v0.96.592).
            int d = Math.Abs(nx - px);
            px = nx;
            if (d >= 12)
            {
                // 跟随日志（只在真的动了一截时打，免得刷屏）
                // Follow log (printed only on a real move, to avoid flooding)
                print_str("PADDLE ");
                println_int(px);
                lastPx = px;
            }
        }
        if (state == 0)
        {
            bx = px + pw / 2;
            by = py - BALL_R - 1;
        }
    }

    static void tick()
    {
        frames = frames + 1;
        if (banner > 0) banner = banner - 1;
        if (state == 2 && banner == 0)
        {
            state = 0;
            serve();
        }

        // 触摸：**轮询**手指此刻在哪（拖动只关心最新位置，见 `lastPx` 上面的说明）
        // Touch: **poll** where the finger is right now (a drag only cares about the newest position,
        // see the note above `lastPx`)
        if (ui_touch_fetch(0) != 0 && ui_touch_is_down() != 0) movePaddle(ui_touch_get_x());

        // 键盘兜底：按住方向键持续移动（`ui_key_is_down` 是"此刻按着没"）
        // Keyboard fallback: hold an arrow to keep moving (`ui_key_is_down` is "is it held right now")
        if (ui_key_is_down(KEY_LEFT) != 0) movePaddle(px - 9 + pw / 2);
        if (ui_key_is_down(KEY_RIGHT) != 0) movePaddle(px + 9 + pw / 2);

        if (state != 1) return;

        bx = bx + vx;
        by = by + vy;

        // 左右墙
        // Side walls
        if (bx - BALL_R < fl)
        {
            bx = fl + BALL_R;
            vx = 0 - vx;
            ui_audio_beep(330, 30);
            println_str("WALLX");
        }
        if (bx + BALL_R > fr)
        {
            bx = fr - BALL_R;
            vx = 0 - vx;
            ui_audio_beep(330, 30);
            println_str("WALLX");
        }
        // 顶
        // Top
        if (by - BALL_R < ft)
        {
            by = ft + BALL_R;
            vy = 0 - vy;
            ui_audio_beep(330, 30);
            println_str("WALLY");
        }

        // ── 挡板 ──
        // ── Paddle ──
        if (vy > 0 && by + BALL_R >= py && by - BALL_R <= py + PADDLE_H &&
            bx + BALL_R >= px && bx - BALL_R <= px + pw)
        {
            by = py - BALL_R;
            // 打在挡板哪一段决定反弹的横速度：中间直、边缘斜
            // Where the ball lands on the paddle sets its horizontal speed: middle straight, edges angled
            int mid = px + pw / 2;
            int off = bx - mid;
            int span = pw / 2;
            if (span < 1) span = 1;
            int nvx = off * 5 / span;            // −5..+5
            if (nvx > 4) nvx = 4;
            if (nvx < -4) nvx = -4;
            if (nvx == 0) nvx = 1;               // 永不垂直（垂直会变成死循环弹不出去）
            // never vertical (vertical becomes an endless bounce and can never escape)
            vx = nvx;
            vy = 0 - ballSpeed();
            ui_audio_beep(440, 45);
            print_str("PADDLEHIT ");
            println_int(off);
        }

        // ── 砖块 ──
        // ── Bricks ──
        int i = 0;
        while (i < rows * COLS)
        {
            if (bAlive[i] != 0)
            {
                int rx = brickX(i);
                int ry = brickY(i);
                if (bx + BALL_R > rx && bx - BALL_R < rx + bw - 2 &&
                    by + BALL_R > ry && by - BALL_R < ry + bh - 2)
                {
                    // 穿入较浅的那个轴才是要反射的轴
                    // The axis with the shallower penetration is the one to reflect
                    int ox = (rx + bw - 2) - (bx - BALL_R);
                    int t2 = (bx + BALL_R) - rx;
                    if (t2 < ox) ox = t2;
                    int oy = (ry + bh - 2) - (by - BALL_R);
                    int t3 = (by + BALL_R) - ry;
                    if (t3 < oy) oy = t3;
                    if (ox < oy) { vx = 0 - vx; bx = bx + vx; }
                    else { vy = 0 - vy; by = by + vy; }

                    bHp[i] = bHp[i] - 1;
                    if (bHp[i] <= 0)
                    {
                        bAlive[i] = 0;
                        left = left - 1;
                    }
                    score = score + 10;
                    if (score > best) best = score;
                    ui_audio_beep(880, 35);
                    print_str("BRICK ");
                    print_int(i);
                    print_str(" LEFT ");
                    println_int(left);
                    if (left == 0) { levelClear(); return; }
                    return;                          // 一拍最多处理一块砖（防一次穿多块）
                    // one brick per tick at most (stops the ball passing through several)
                }
            }
            i = i + 1;
        }

        // 掉底
        // Fell past the bottom
        if (by - BALL_R > fb)
        {
            loseLife();
        }
    }

    // ════════════════════════════════════════════════════════════════════
    // 入口
    // Entry point
    // ════════════════════════════════════════════════════════════════════
    static void Main()
    {
        lang = ui_scr_get_language();
        // 开窗：尺寸传 0 ⇒ 交给宿主给真实可用区（开窗**之前**问到的只是估算值）
        // Opening: pass size 0 ⇒ the host supplies the real available area (a **pre-open** read is only an estimate)
        ui_win_open_ex(T("打砖块", "Breakout"), 0, 0, WIN_PORTRAIT, WIN_NO_GAMEPAD);
        ui_scr_set_keep_on(1);

        // 尺寸：开窗**之后**再问一次 —— 这时 `ui_scr_get_w/h` 给的是实测画布（真值）
        // Size: re-read **after** the open — `ui_scr_get_w/h` now report the measured canvas (the real value)
        sw = ui_scr_get_w();
        sh = ui_scr_get_h();
        if (sw <= 0) sw = 411;
        if (sh <= 0) sh = 726;
        layout();
        newGame();
        draw();

        int tid = ui_timer_set(TICK_MS, 0);
        acc = 0;
        lastMs = ui_time_get_ms();   // 墙钟起点：进主循环时取（不在模块级/全局初始化里调 syscall）
        // Wall-clock origin: taken when entering the main loop (no syscall at module level or in a global initializer)
        while (ui_win_is_closed() == 0)
        {
            int t = ui_msg_fetch_wait(TICK_MS);

            // 这一帧该走几步：**按墙钟欠账**（各平台定时器分辨率不同 ⇒ 不能拿"收到几拍"当时间）。
            // 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.
            int now2 = ui_time_get_ms();
            acc = acc + (now2 - lastMs);
            lastMs = now2;
            if (acc > TICK_MS * 8) acc = 0;  // 卡太久别一次补一大串（防瞬移）
            // Do not catch up in one huge burst after a long stall (anti-teleport)
            if (acc >= TICK_MS)
            {
                while (acc >= TICK_MS) { acc = acc - TICK_MS; tick(); }
                draw();
            }

            if (t == MSG_NONE) continue;
            if (t == MSG_WINDOWCLOSE) break;
            if (t == MSG_WINDOWRESIZE)
            {
                sw = ui_msg_get_a();
                sh = ui_msg_get_b();
                if (sw <= 0) sw = 411;
                if (sh <= 0) sh = 726;
                layout();
                draw();
                continue;
            }
            if (t == MSG_TIMER)
            {
                // 定时器**只负责唤醒**（推进在上面按墙钟欠账走）
                // The timer **only wakes us up** — the advance happens above, by wall-clock debt
                continue;
            }
            if (t == MSG_TOUCHDOWN)
            {
                launch();
                draw();
                continue;
            }
            if (t == MSG_TOUCHMOVE)
            {
                // 位置靠轮询拿（见 `lastPx` 上面的说明），这类消息本身没有价值
                // the position is polled instead (see the note above `lastPx`); this kind of message carries no value in itself
                // ⇒ 直接丢掉，免得队列只涨不落（`ui_msg_drop(1)` = 丢掉"触摸"这一类）
                // The position comes from polling (see the note above `lastPx`), so these messages carry
                // nothing ⇒ drop them, so the queue cannot grow without bound (`ui_msg_drop(1)` drops
                // the "touch" kind)
                ui_msg_drop(1);
                continue;
            }
            if (t == MSG_TOUCHUP) continue;
            if (t == MSG_KEYDOWN)
            {
                int k = ui_msg_get_a();
                if (k == KEY_ESCAPE) break;
                if (k == KEY_SPACE || k == KEY_ENTER || k == KEY_PAD_A)
                {
                    if (state == 3) newGame();
                    else launch();
                    draw();
                }
                else if (k == KEY_LEFT) { movePaddle(px - 18 + pw / 2); draw(); }
                else if (k == KEY_RIGHT) { movePaddle(px + 18 + pw / 2); draw(); }
                continue;
            }
        }

        ui_timer_kill(tid);
        ui_scr_set_keep_on(0);
        ui_win_close();
        print_str("PRIMAX-FINAL ");
        println_int(primMax);
        println_str("breakout: done");
    }
}