c/app/tetris.c · 52906 字节 · 下载原文
/* tetris.c —— 俄罗斯方块（C 版），跑在手机端 VML 上
* tetris.c — Tetris (C version), running on VML on the mobile side
*
* 用到的都是现成的宿主接口（`vml_ui.h` 那套：窗体 / 绘图 / 消息队列 / 定时器），
* It uses only existing host interfaces (the `vml_ui.h` set: window / drawing / message queue / timer),
* 外加 v0.96.172 新加的**手感接口**（`ui_audio_beep` / `ui_vibrate_simple` / `ui_scr_set_keep_on` / `ui_store_*`）。
* plus the **feel interfaces** added in v0.96.172 (`ui_audio_beep` / `ui_vibrate_simple` / `ui_scr_set_keep_on` / `ui_store_*`).
* 布局全部按实际可用绘图区（syscall #566/#567）算，所以手机、平板、模拟器上都能铺满。
* The whole layout is computed from the actual available drawing area (syscall #566/#567), so it fills the screen on phones, tablets and emulators alike.
*
* 编译运行（手机 App 的 vml 工具）：
* Build and run (with the phone App's vml tool):
* vml run tetris.c
*
* 操作全部走**绘图窗口底部那排屏幕手柄**（方向键 + START/SELECT + X/Y/A/B），
* All controls go through **the row of on-screen gamepad buttons at the bottom of the drawing window** (arrows + START/SELECT + X/Y/A/B);
* 手柄按键就是 Win32 虚拟键值，接物理键盘也是同一套：
* the gamepad buttons are Win32 virtual key codes, so a physical keyboard uses the same set:
* ← → 左右移动（按住连发）
* ← → move left/right (hold to auto-repeat)
* ↓ 加速下落（按住连发）
* ↓ soft drop faster (hold to auto-repeat)
* ↑ / A / X 旋转
* ↑ / A / X rotate
* 空格 / B / Y 直落到底
* Space / B / Y hard drop to the bottom
* START 重开一局
* START restart a game
* SELECT 暂停 / 继续
* SELECT pause / resume
* 返回箭头 退出
* Back arrow quit
*
* ## 为什么不自己画手柄、也不判触摸（v0.96.173 去掉的）
* ## Why it neither draws its own gamepad nor handles touch (removed in v0.96.173)
*
* 上一版在窗口里自绘了一套十字键 + 旋转/直落/暂停/重开，靠触摸命中去判按键。
* The previous version drew its own D-pad + rotate/hard-drop/pause/restart inside the window and decided key presses by touch hit-testing.
* 那是**多此一举**：绘图窗口底部本来就有一排屏幕手柄（`DrawWindowPage`），
* That was **pointless**: the drawing window already has a row of on-screen gamepad buttons at the bottom (`DrawWindowPage`),
* 程序只要收 `VML_MSG_KEYDOWN` 就行。自绘那套的代价是实打实的 ——
* so the program only has to receive `VML_MSG_KEYDOWN`. The cost of the self-drawn version was real —
* 1. 要占掉约 140px 的窗口高度（棋盘就矮一截，手机上少两行）；
* 1. it took up about 140px of window height (the board got shorter, two rows fewer on a phone);
* 2. 几何要在"画"与"命中判定"两处各算一遍（本文件上一版专门写了段注释讲这件事），
* 2. the geometry had to be computed twice, once for "drawing" and once for "hit-testing" (the previous version of this file had a whole comment about that),
* 改个间距就会出现"看着在键上、点下去没反应"；
* so changing a spacing produced "it looks like it's on the key, but tapping does nothing";
* 3. 每个游戏各画一套，风格互不相同，用户还得重新学一遍；
* 3. every game drew its own set with a different look, and the user had to learn it all over again;
* 4. 触摸与按键两条输入路径并存，程序里两套状态（`held` 与键盘）容易不一致。
* 4. having both touch and key input paths meant two sets of state in the program (`held` and the keyboard) that easily disagreed.
* 现在**只认按键消息**，触摸消息一概不处理 —— 窗口就是一块显示区。
* Now it **honors key messages only** and ignores touch messages entirely — the window is just a display area.
*
* ## 三条 C 前端的硬约束（踩过才写的）
* ## Three hard constraints of the C frontend (written only after tripping over them)
*
* 1. ⚠ **`${}` 占位符只认局部变量**（`GenerateAsmStatement` 只查 `variables` 表）。
* 1. ⚠ **A `${}` placeholder only resolves local variables** (`GenerateAsmStatement` consults only the `variables` table).
* （**2026-10-04 复验仍成立**：`--vml` 打出来的汇编里，`${局部量}` 有装载指令、`${全局量}` 一条都没有。）
* (**still holds, re-checked 2026-10-04**: in the `--vml` disassembly, `${local}` gets a load instruction and `${global}` gets none.)
* 所以调 syscall 一律走 `vml_ui.h` 的包装函数 —— 它们的形参就是普通 C 形参，
* So always call syscalls through the wrapper functions in `vml_ui.h` — their parameters are ordinary C parameters and
* 安全；而**绝不能**自己写 `asm("SYSCALL #525, ${gx}, ...")` 去传全局变量，那会退化成 R12+0。
* are safe; **never** write `asm("SYSCALL #525, ${gx}, ...")` yourself to pass a global, since that degrades to R12+0.
* 2. **文件级全局变量是好的**（实测：`int b[BW * BH]` 这种全局数组读写都正确），
* 2. **File-level globals are fine** (measured: a global array like `int b[BW * BH]` reads and writes correctly),
* 所以游戏状态就放全局，不必像五子棋那样把棋盘当参数到处传 —— 那个写法是被
* so the game state just lives in globals; there is no need to pass the board around as a parameter the way gomoku does — that style came from
* "全局变量不能进 ${}"这条误推出来的，实际上只影响 asm，不影响普通读写。
* a wrong inference from "globals cannot go into ${}", which in fact only affects asm, not ordinary reads and writes.
* 但为了统一，本文件仍全部通过包装函数调 syscall。
* For consistency, though, this file still calls every syscall through the wrappers.
* 3. ~~⚠ **`#define` 不支持折行续行**（反斜杠续行会让词法器在下一行报"未知字符"）~~，
* 3. ~~⚠ **`#define` does not support line continuation** (a backslash continuation makes the lexer report "unknown character" on the next line)~~,
* 所以宏本身一行写完，多行说明另起一段块注释。
* so a macro must be written on one line, and multi-line explanations get their own block comment.
* ✅ **已修好（2026-10-04 复验）**：续行宏 `ADD(2,3)` = **5**、多行宏 = **42**、字符串续行 = **hello**。
* ✅ **fixed (re-checked 2026-10-04)**: continued macro `ADD(2,3)` = **5**, multi-line macro = **42**, continued string literal = **hello**.
*
* ## 存档为什么用「全局缓冲 + atoi」
* ## Why the high score uses a "global buffer + atoi"
*
* `ui_store_get(key, buf, cap)` 把字符串写进调用方给的缓冲区。这里把它读回来用的是
* `ui_store_get(key, buf, cap)` writes a string into the buffer the caller provides. Reading it back here uses
* `atoi`（最高分本来就是个数），缓冲区放在文件级全局 —— 这两条**不是硬约束，只是习惯**。
* `atoi` (the high score is a number anyway), and the buffer sits in a file-level global — neither is **a hard constraint, just a habit**.
*
* v0.96.173 时这里曾写着"缓冲区必须放全局、不能用下标读"，那是**误判**：真因是 C 前端
* In v0.96.173 this spot used to say "the buffer must be global and cannot be read by index"; that was **a misdiagnosis**: the real cause was that the C frontend
* 对**全局** `char` 数组的元素访问按 32 位读写（局部数组反而正常），症状是「长度对、内容不对」。
* accesses elements of a **global** `char` array with 32-bit reads and writes (local arrays were fine), giving "right length, wrong contents".
* 那条已在 v0.96.174 修掉（`patches/0004-c-global-array-elem-type.patch`），所以
* That was fixed in v0.96.174 (`patches/0004-c-global-array-elem-type.patch`), so
* `buf[0] == '1'` 现在也能直接读。留个记号在这里：**当时是用 `puts` 当判据才误判的**
* `buf[0] == '1'` now reads directly too. A note is left here on purpose: **the misdiagnosis came from using `puts` as the criterion**
* （本环境的 `puts` 在字面量多的程序里会串行），换成一个不经 stdio 的判据，六个格子一次就量清了。
* (in this environment `puts` serializes in programs with many literals); switching to a criterion that does not go through stdio cleared up all six cells in one pass.
*/
#include <vml_ui.h>
#include <stdlib.h>
#define BW 10 /* 棋盘宽（格） */
/* Board width (in cells). */
#define BH 20 /* 棋盘高（格） */
/* Board height (in cells). */
#define COL_BG 0xFF0E0E14
#define COL_BOARD 0xFF16161F
#define COL_FRAME 0xFF2A2A38
#define COL_GRID 0xFF21212C
#define COL_TEXT 0xFFEDEDF2
#define COL_DIM 0xFF8A8A99
#define COL_ACCENT 0xFF4ADE80
#define COL_WARN 0xFFF87171
#define COL_PANEL 0xFF1B1B26
#define COL_SHADE 0xCC000000
#define COL_GOLD 0xFFFACC15
/* 存档键（`ui_store_*` 会再加一层 `vml.` 前缀，与 App 自己的配置隔开） */
/* Save key (`ui_store_*` adds another `vml.` prefix, keeping it apart from the App's own config). */
#define KEY_HI "tetris.hi"
/* ── 游戏状态 ───────────────────────────────────────────── */
/* ── Game state ─────────────────────────────────────── */
int b[BW * BH]; /* 棋盘：0 = 空，否则 = 方块号 + 1。
* Board: 0 = empty, otherwise = piece number + 1.
* 维度写成**宏 × 宏**是故意的 —— 它原先会因为 C 前端不折常量表达式
* Writing the dimension as **macro × macro** is deliberate — it used to silently allocate
* 而静默只分配 1 个元素（编得过、跑起来数据全乱），v0.96.170 修掉了，
* only 1 element because the C frontend did not fold constant expressions (it built, but the data was all wrong at run time); v0.96.170 fixed it,
* 这行就是那个修复的现场回归（**2026-10-04 复验仍正常**：全局 `int b[BW*BH]` 读写正确）。
* and this line is that fix's on-the-spot regression (**re-checked 2026-10-04, still fine**: the global `int b[BW*BH]` reads and writes correctly). */
int pid; /* 当前方块 0..6 */
/* Current piece 0..6 */
int rot; /* 旋转 0..3 */
/* Rotation 0..3 */
int px; /* 4×4 包围盒左上角（棋盘格坐标） */
/* Top-left of the 4×4 bounding box (board-cell coordinates) */
int py;
int npid; /* 下一个方块 */
/* Next piece */
int score;
int best; /* 最高分（从存档里读出来，破纪录时写回去） */
/* High score (read from the save data, written back when a record is broken) */
int nlines;
int level;
int state; /* 0 = 运行 1 = 暂停 2 = 结束 */
/* 0 = running, 1 = paused, 2 = over */
int tid; /* 重力定时器 id（0 = 没有） */
/* Gravity timer id (0 = none) */
int rid; /* 长按连发定时器 id（0 = 没有） */
/* Hold-to-repeat timer id (0 = none) */
int held; /* 正在按住的方向键（1 左 2 右 3 下，0 = 没按） */
/* Direction key currently held (1 left, 2 right, 3 down; 0 = none) */
int rptLeft; /* 这次连发还剩几拍（见 hold_repeat 的"自限"说明） */
/* How many ticks are left in this repeat burst (see the "self-limiting" note in hold_repeat) */
int rptStuck; /* 连续几拍"按了但没动" */
/* How many ticks in a row were "pressed but nothing moved" */
int dropMs;
int acc; /* 重力墙钟欠账（毫秒）—— 按墙钟补步，用户 2026-10-04 口径 */
/* gravity wall-clock debt in ms -- steps are caught up from the wall clock (user's 2026-10-04 rule) */
int lastMs; /* 上次补步取的墙钟时刻（进主循环时初始化） */
/* wall-clock time of the last catch-up step (initialized when entering the main loop) */
/* ── 布局（main 里算一次，绘图全读它） ──────────────────── */
/* ── Layout (computed once in main) ───────── */
int g_lang; /* 界面语言：开局查一次（ui_scr_get_language 是 syscall，别每帧调） */
/* UI language: queried once at game start (ui_scr_get_language is a syscall, don't call it every frame) */
int sw;
int sh;
int cell; /* 格子边长 */
/* Cell side length */
int bx; /* 棋盘左上角 */
/* Board top-left corner */
int by;
int panelX; /* 右侧信息面板 */
/* Right-hand info panel */
int panelW;
/* 数字的中间缓冲（`draw_int` / `score_to_str` 用；全局 int 数组，实测可用） */
/* Scratch buffer for digits (used by `draw_int` / `score_to_str`; a global int array, measured to work) */
int digs[12];
int sdigs[12];
/* 存档缓冲：**必须是全局**（局部数组的地址传给函数是错的，见文件头） */
/* Save buffer: **must be global** (passing the address of a local array to a function is wrong; see the file header) */
char hibuf[16]; /* ui_store_get 读进来 */
/* read in by ui_store_get */
char hiout[16]; /* 自己逐位拼出去给 ui_store_set */
/* assembled digit by digit for ui_store_set */
/* ── 方块颜色 ───────────────────────────────────────────── */
/* ── Piece colors ───────────────────────────────────── */
int piece_color(int p) {
if (p == 0) return 0xFF22D3EE; /* I 青 */
/* I cyan */
if (p == 1) return 0xFFFACC15; /* O 黄 */
/* O yellow */
if (p == 2) return 0xFF4ADE80; /* S 绿 */
/* S green */
if (p == 3) return 0xFFF87171; /* Z 红 */
/* Z red */
if (p == 4) return 0xFFC084FC; /* T 紫 */
/* T purple */
if (p == 5) return 0xFFFB923C; /* L 橙 */
/* L orange */
return 0xFF60A5FA; /* J 蓝 */
/* J blue */
}
/* 同色高光（块面顶部那一条）。用查表而不是移位算 —— 免得依赖位运算的可用性。 */
/* A lighter shade of the same color (the strip at the top of a block face). A lookup table is used instead of shifting — so as not to rely on bit operations being available. */
int piece_light(int p) {
if (p == 0) return 0xFF7DE8F7;
if (p == 1) return 0xFFFDE68A;
if (p == 2) return 0xFF86EFAC;
if (p == 3) return 0xFFFCA5A5;
if (p == 4) return 0xFFD8B4FE;
if (p == 5) return 0xFFFDBA74;
return 0xFF93C5FD;
}
char* digit_str(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";
}
/* ── 手感：音效与震动 ───────────────────────────────────── */
/* ── Feel: sound and vibration ──────────────────── */
/* ── 音效：**用 ui_audio_beep 单音**（v0.96.509 统一换回来） ────────────
* ── Sound: **use the single-tone ui_audio_beep** (switched back uniformly in v0.96.509) ────────────
*
* ⚠⚠ 这些音一度走共享库的音序器（`ui_sfx_add`），**真机上破音**，换回来了。
* ⚠⚠ These sounds once went through the shared library's sequencer (`ui_sfx_add`) and **broke up on real hardware**, so they were switched back.
* 破音的是**这里配的音**（机制本身没问题）—— 那一版同时踩了两条：
* What broke up was **the sounds configured here** (the mechanism itself is fine) — that version tripped over two things at once:
* · **多个音叠着响**：消行是 1–4 个声部的和弦，多声部混音一叠加，音量顶到削波；
* · **several notes sounding together**: a line clear was a 1–4 voice chord, and summing that many voices pushed the volume into clipping;
* · **长音拖尾**：结束音末了一个 12 拍（一拍 33ms ≈ 400ms）的低音。
* · **a long tail**: the game-over sound ended on a 12-tick (one tick = 33ms ≈ 400ms) low note.
* `ui_audio_beep` 是**单通道**的（后一个音掐掉前一个）⇒ 一个事件永远只有一个音在响，
* `ui_audio_beep` is **single-channel** (a later note cuts off the earlier one) ⇒ one event never has more than one note sounding,
* **结构上不可能削波**。代价是没有和弦、没有音色。
* so clipping is **structurally impossible**. The price is no chords and no timbre.
*
* ⚠ 频率取整块的**首音**（哪个事件什么音是设计，不是机制），时长取整块时长、
* ⚠ The frequency is the **first note** of the block (which event gets which note is design, not mechanism), the duration is the block's duration
* 封顶 320ms。**结局类取两端**：升级/胜利取整块**最高音**、结束/失败取**最低音**
* capped at 320ms. **Outcome sounds take the two extremes**: level up / win take the block's **highest note**, game over / loss take the **lowest**
* —— 五子棋/象棋两版也是这么配的（赢 1320 / 输 240）。
* — the gomoku and chess versions are configured the same way (win 1320 / lose 240).
* 低音不低于 C3(131Hz) —— `vml_ui.h` 写着「手机外放在 200Hz 以下衰减很快…
* Low notes do not go below C3 (131Hz) — `vml_ui.h` says "a phone's speaker rolls off fast below 200Hz …
* C2 出来是"噗"一声闷响，玩家听着像没响」。
* a C2 comes out as a muffled puff and players think nothing played." */
/* 消行：**行数越多、音越高越长** —— 单音表达"这波赚了多少"只剩这一个杠杆。
* Line clear: **the more rows, the higher and longer the tone** — with a single tone this is the only lever for "how much did that batch earn".
* 音高对应原来和弦的第几个音（do / mi / sol / do 高八度）。
* The pitch matches the old chord's note index (do / mi / sol / do an octave up). */
void sfx_clear(int n) {
if (n >= 4) ui_audio_beep(1047, 320);
else if (n == 3) ui_audio_beep(784, 264);
else if (n == 2) ui_audio_beep(659, 198);
else ui_audio_beep(523, 132);
ui_vibrate_simple(28, 0);
}
/* 旋转：轻、短、不抢戏 —— 这是个高频动作，响一点就烦。 */
/* Rotate: light, short, unobtrusive — this is a high-frequency action, and anything louder gets annoying. */
void sfx_rotate(void) { ui_audio_beep(1047, 33); }
/* 自然落地：一声闷响（不震）。 */
/* Natural landing: one dull thud (no vibration). */
void sfx_land(void) { ui_audio_beep(165, 66); }
/* 硬降：**更低更长** —— 与自然落地必须分得出（玩家是主动砸的还是没赶上）。
* Hard drop: **lower and longer** — it must be told apart from a natural landing (did the player slam it, or just not get there in time?).
* ⚠ 原来两条同为 note 48，靠波形与时长分；波形没了 ⇒ 改用音高（硬降更沉）。
* ⚠ Both used to be note 48 and were distinguished by waveform and duration; with the waveform gone ⇒ pitch does it (hard drop is heavier). */
void sfx_harddrop(void) { ui_audio_beep(131, 99); }
/* 暂停 / 继续：一低一高，一听就知道是"停"还是"走"。 */
/* Pause / resume: one low and one high, so one listen tells "stop" from "go". */
void sfx_pause(void) { ui_audio_beep(523, 66); }
void sfx_resume(void) { ui_audio_beep(784, 66); }
/* 重开：一声干脆的起手音。 */
/* Restart: one crisp opening note. */
void sfx_restart(void) { ui_audio_beep(659, 99); }
/* 升级：**盖过消行音**（更高更长）—— 升级更值得听见。
* Level up: **drowns out the line-clear sound** (higher and longer) — a level up is more worth hearing.
* ⚠ 取整块的**最高音**（原来琶音的顶 96），否则与"四行消"撞成同一个数。
* ⚠ Takes the block's **highest note** (the top 96 of the old arpeggio), otherwise it would collide with "four-row clear" on the same number. */
void sfx_levelup(void) { ui_audio_beep(2093, 320); }
/* 结束：**低而长** —— 与"升级"正好是两端。 */
/* Game over: **low and long** — exactly the opposite end from "level up". */
void sfx_over(void) {
ui_audio_beep(131, 320);
ui_vibrate_simple(220, 0);
}
/* ── 方块几何 ───────────────────────────────────────────── */
/* ── Piece geometry ─────────────────────────────────── */
/* 某个方块某次旋转的**包围盒左上角**，打包成 minx*16 + miny。
* The **top-left corner of the bounding box** for a given piece and rotation, packed as minx*16 + miny.
*
* 为什么需要它：`ui_piece_get_cell` 的旋转是绕 4×4 包围盒中心转的，I 这种长条转完
* Why it is needed: `ui_piece_get_cell` rotates around the center of the 4×4 bounding box, so for a long bar like I the whole shape
* 整个形状会"跳一格"。做法是"旋转后把包围盒左上角对回原处"，看起来才稳。
* "jumps one cell" once it is rotated. The trick is to put the bounding box's top-left corner back where it was, which looks stable. */
int piece_min(int p, int r) {
int i;
int v;
int x;
int y;
int mx;
int my;
mx = 3;
my = 3;
i = 0;
while (i < 4) {
v = ui_piece_get_cell(p, r, i);
if (v >= 0) {
x = v / 16;
y = v % 16;
if (x < mx) mx = x;
if (y < my) my = y;
}
i = i + 1;
}
return mx * 16 + my;
}
/* 方块放在 (x0,y0) 时会不会撞墙 / 撞地 / 撞已有块。y<0 表示还在顶部之外（允许）。 */
/* Whether the piece placed at (x0,y0) would hit a wall / the floor / an existing block. y<0 means it is still above the top (allowed). */
int collide(int p, int r, int x0, int y0) {
int i;
int v;
int x;
int y;
i = 0;
while (i < 4) {
v = ui_piece_get_cell(p, r, i);
if (v >= 0) {
x = x0 + v / 16;
y = y0 + v % 16;
if (x < 0 || x >= BW) return 1;
if (y >= BH) return 1;
if (y >= 0 && b[y * BW + x] != 0) return 1;
}
i = i + 1;
}
return 0;
}
void set_speed(void) {
if (tid > 0) ui_timer_kill(tid);
dropMs = 620 - (level - 1) * 55;
if (dropMs < 110) dropMs = 110;
tid = ui_timer_set(dropMs, 0);
}
/* ── 存档：最高分 ───────────────────────────────────────── */
/* ── Save data: high score ────────────────────────── */
/* 把非负整数写成十进制字符串（**2026-10-04 复验仍成立**：C 前端的 `"a"+"b"` 字符串拼接实测得空串，逐位自己拼）。
* Writes a non-negative integer as a decimal string (string concatenation in the C frontend is unreliable, so it is assembled digit by digit).
* 顺序**必须从前到后**、最后补一个 0 —— 全局 char 数组的赋值是 32 位写，
* The order **must be front to back**, with a trailing 0 — assigning to a global char array is a 32-bit write,
* 正序写下来每个下标的低字节都是对的，末尾那个 0 顺手把后面几个字节一起清零。
* so writing in ascending order leaves the right low byte at every index, and that final 0 conveniently clears the bytes after it as well. */
void score_to_str(int v, char* dst) {
int n;
int t;
int i;
if (v < 0) v = 0;
n = 0;
t = v;
while (t > 0) {
sdigs[n] = t % 10;
t = t / 10;
n = n + 1;
}
if (n == 0) {
sdigs[0] = 0;
n = 1;
}
i = 0;
while (i < n) {
dst[i] = 48 + sdigs[n - 1 - i];
i = i + 1;
}
dst[n] = 0;
}
void load_best(void) {
best = 0;
if (ui_store_get(KEY_HI, hibuf, 16) >= 0) best = atoi(hibuf);
if (best < 0) best = 0;
}
void save_best(void) {
score_to_str(best, hiout);
ui_store_set(KEY_HI, hiout);
}
void submit_score(void) {
if (score > best) {
best = score;
save_best();
}
}
/* ── 游戏动作 ───────────────────────────────────────────── */
/* ── Game actions ───────────────────────────────────── */
void spawn(void) {
int m;
pid = npid;
rot = 0;
npid = ui_math_rand(7);
px = 3;
m = piece_min(pid, 0);
py = 0 - m % 16; /* 让形状最高的一行贴在第 0 行 */
/* Puts the shape's topmost row on row 0 */
if (collide(pid, rot, px, py) != 0) { /* 出生位就满了 = 结束 */
/* Spawning already collides = game over */
state = 2;
submit_score();
sfx_over();
}
}
/* 把当前方块写进棋盘、消行、算分。 */
/* Writes the current piece into the board, clears lines and scores. */
void lock_piece(void) {
int i;
int v;
int x;
int y;
int row;
int col;
int full;
int n;
int k;
int lv;
i = 0;
while (i < 4) {
v = ui_piece_get_cell(pid, rot, i);
if (v >= 0) {
x = px + v / 16;
y = py + v % 16;
if (y >= 0 && y < BH && x >= 0 && x < BW) b[y * BW + x] = pid + 1;
}
i = i + 1;
}
n = 0;
row = BH - 1;
while (row >= 0) {
full = 1;
col = 0;
while (col < BW) {
if (b[row * BW + col] == 0) full = 0;
col = col + 1;
}
if (full == 1) {
n = n + 1;
/* 本行以上整体下移一格；**row 不前进** —— 掉下来的那行还得再判一次 */
/* Shifts everything above this row down by one; **row does not advance** — the row that fell still has to be checked again */
k = row;
while (k > 0) {
col = 0;
while (col < BW) {
b[k * BW + col] = b[(k - 1) * BW + col];
col = col + 1;
}
k = k - 1;
}
col = 0;
while (col < BW) {
b[col] = 0;
col = col + 1;
}
} else {
row = row - 1;
}
}
if (n > 0) {
if (n == 1) score = score + 100 * level;
if (n == 2) score = score + 300 * level;
if (n == 3) score = score + 500 * level;
if (n >= 4) score = score + 800 * level;
nlines = nlines + n;
lv = nlines / 10 + 1;
if (lv > 12) lv = 12;
if (lv > level) {
level = lv;
sfx_levelup(); /* 升级盖过消行音：升级更值得听见 */
/* A level up drowns out the line-clear sound: a level up is more worth hearing */
ui_vibrate_simple(60, 0);
} else {
sfx_clear(n);
}
set_speed();
} else {
sfx_land(); /* 自然落地：一声闷响，不震 */
/* Natural landing: one dull thud, no vibration */
}
}
/* 下落一格；落不下去就锁定并出新方块。 */
/* Drops one cell; if it cannot drop, the piece is locked and a new one spawns. */
void step_down(void) {
if (collide(pid, rot, px, py + 1) == 0) {
py = py + 1;
} else {
lock_piece();
spawn();
}
}
/* 旋转（带踢墙：原位不行就往左右各试 1、2 格）。 */
/* Rotate (with wall kicks: if the original position fails, try 1 and then 2 cells to each side). */
void rotate_piece(void) {
int nr;
int om;
int nm;
int nx;
int ny;
nr = (rot + 1) % 4;
om = piece_min(pid, rot);
nm = piece_min(pid, nr);
nx = px + om / 16 - nm / 16;
ny = py + om % 16 - nm % 16;
sfx_rotate();
if (collide(pid, nr, nx, ny) == 0) {
rot = nr;
px = nx;
py = ny;
return;
}
if (collide(pid, nr, nx - 1, ny) == 0) {
rot = nr;
px = nx - 1;
py = ny;
return;
}
if (collide(pid, nr, nx + 1, ny) == 0) {
rot = nr;
px = nx + 1;
py = ny;
return;
}
if (collide(pid, nr, nx - 2, ny) == 0) {
rot = nr;
px = nx - 2;
py = ny;
return;
}
if (collide(pid, nr, nx + 2, ny) == 0) {
rot = nr;
px = nx + 2;
py = ny;
}
}
void hard_drop(void) {
int n;
n = 0;
while (collide(pid, rot, px, py + 1) == 0) {
py = py + 1;
n = n + 1;
}
score = score + n * 2;
sfx_harddrop(); /* 低频闷响 = "砸下去了" */
/* A low-frequency thud = "slammed it down" */
ui_vibrate_simple(22, 0);
lock_piece();
spawn();
}
void restart(void) {
int i;
i = 0;
while (i < BW * BH) {
b[i] = 0;
i = i + 1;
}
score = 0;
nlines = 0;
level = 1;
state = 0;
held = 0;
rptLeft = 0;
rptStuck = 0;
if (rid > 0) {
ui_timer_kill(rid);
rid = 0;
}
npid = ui_math_rand(7);
spawn();
set_speed();
sfx_restart();
}
/* ── 绘图 ───────────────────────────────────────────────── */
/* ── Drawing ──────────────────────────────────────────── */
/* 一个方块格：圆角实心 + 顶部一条高光。 */
/* One block cell: a filled rounded rectangle plus a highlight strip along the top. */
void draw_block(int x, int y, int p, int size) {
int pad;
int r;
int hi;
if (size < 6) {
ui_2d_rect(x, y, size, size, piece_color(p), 1, 0, 0);
return;
}
pad = size / 9;
if (pad < 1) pad = 1;
r = size / 5;
if (r < 2) r = 2;
hi = size / 6;
if (hi < 2) hi = 2;
ui_2d_rect(x + pad, y + pad, size - pad * 2, size - pad * 2, piece_color(p), 1, 0, r);
ui_2d_rect(x + pad + r, y + pad + hi, size - (pad + r) * 2, hi, piece_light(p), 1, 0, hi / 2);
}
/* 数字：**逐位画**，不拼字符串（**2026-10-04 复验仍成立**：`"AB" + "CD"` 实测得空串；而十个数字字面量就够了）。 */
/* Numbers: **drawn digit by digit**, with no string concatenation (that path is unreliable in this frontend, and ten digit literals are enough). */
void draw_int(int x, int y, int v, int size, int color) {
int n;
int i;
int t;
int half;
if (v < 0) v = 0;
n = 0;
t = v;
while (t > 0 || n == 0) {
digs[n] = t % 10;
t = t / 10;
n = n + 1;
}
half = size / 2;
if (half < 5) half = 5;
ui_text_set_font(size, VML_FONT_BOLD, color, VML_ANCHOR_LEFT);
i = n;
while (i > 0) {
i = i - 1;
ui_2d_text_cur(x + (n - 1 - i) * half, y, digit_str(digs[i]));
}
}
void draw_panel(void) {
int i;
int v;
int x;
int y;
int mini;
int pw;
int ty;
ui_2d_rect(panelX, by, panelW, BH * cell, COL_PANEL, 1, 0, 8);
x = panelX + panelW / 2;
ui_text_set_font(12, 0, COL_DIM, VML_ANCHOR_CENTER);
ui_2d_text_cur(x, by + 10, g_lang == 0 ? "下一个" : "Next");
mini = cell / 2;
if (mini < 7) mini = 7;
pw = mini * 4;
i = 0;
while (i < 4) {
v = ui_piece_get_cell(npid, 0, i);
if (v >= 0) {
y = v % 16;
draw_block(panelX + (panelW - pw) / 2 + (v / 16) * mini, by + 32 + y * mini, npid, mini);
}
i = i + 1;
}
ty = by + 32 + mini * 4 + 18;
ui_text_set_font(12, 0, COL_DIM, VML_ANCHOR_LEFT);
ui_2d_text_cur(panelX + 10, ty, g_lang == 0 ? "分数" : "Score");
draw_int(panelX + 10, ty + 16, score, 17, COL_TEXT);
ty = ty + 52;
ui_text_set_font(12, 0, COL_DIM, VML_ANCHOR_LEFT);
ui_2d_text_cur(panelX + 10, ty, g_lang == 0 ? "最高" : "Best");
draw_int(panelX + 10, ty + 16, best, 17, COL_GOLD);
ty = ty + 52;
ui_text_set_font(12, 0, COL_DIM, VML_ANCHOR_LEFT);
ui_2d_text_cur(panelX + 10, ty, g_lang == 0 ? "消行" : "Lines");
draw_int(panelX + 10, ty + 16, nlines, 17, COL_TEXT);
ty = ty + 52;
ui_text_set_font(12, 0, COL_DIM, VML_ANCHOR_LEFT);
ui_2d_text_cur(panelX + 10, ty, g_lang == 0 ? "等级" : "Level");
draw_int(panelX + 10, ty + 16, level, 17, COL_ACCENT);
}
/* 暂停 / 结束的遮罩 + 两行提示。提示文案要写**手柄上的键名** ——
* The pause / game-over overlay plus two lines of text. The wording must name **the keys on the gamepad** —
* 屏幕上已经没有自绘按键了，写"点「重开」"用户找不到那个东西。
* there are no self-drawn buttons on screen any more, so telling the user to "tap Restart" leaves them hunting for something that isn't there. */
void draw_overlay(void) {
int w;
int h;
int x;
int y;
char* s;
char* s2;
if (state == 0) return;
w = BW * cell - 16;
h = 84;
x = bx + 8;
y = by + (BH * cell - h) / 2;
ui_2d_rect(bx, by, BW * cell, BH * cell, COL_SHADE, 1, 0, 0);
ui_2d_rect(x, y, w, h, COL_PANEL, 1, 0, 10);
if (state == 2) {
s = g_lang == 0 ? "游戏结束" : "Game Over";
s2 = g_lang == 0 ? "按 START 再来一局" : "Press START to restart";
} else {
s = g_lang == 0 ? "已暂停" : "Paused";
s2 = g_lang == 0 ? "按 SELECT 继续" : "Press SELECT to resume";
}
ui_text_set_font(20, VML_FONT_BOLD, COL_WARN, VML_ANCHOR_CENTER);
ui_2d_text_cur(x + w / 2, y + 16, s);
ui_text_set_font(12, 0, COL_DIM, VML_ANCHOR_CENTER);
ui_2d_text_cur(x + w / 2, y + 52, s2);
}
void draw_all(void) {
int i;
int v;
int x;
int y;
ui_2d_clear(COL_BG);
/* 棋盘：外框 + 底 + 网格 */
/* Board: outer frame + background + grid */
ui_2d_rect(bx - 3, by - 3, BW * cell + 6, BH * cell + 6, COL_FRAME, 1, 0, 8);
ui_2d_rect(bx, by, BW * cell, BH * cell, COL_BOARD, 1, 0, 4);
i = 1;
while (i < BW) {
ui_2d_line(bx + i * cell, by + 1, bx + i * cell, by + BH * cell - 1, COL_GRID, 1);
i = i + 1;
}
i = 1;
while (i < BH) {
ui_2d_line(bx + 1, by + i * cell, bx + BW * cell - 1, by + i * cell, COL_GRID, 1);
i = i + 1;
}
/* 已落定的方块 */
/* Settled blocks */
i = 0;
while (i < BW * BH) {
v = b[i];
if (v != 0) {
x = i % BW;
y = i / BW;
draw_block(bx + x * cell, by + y * cell, v - 1, cell);
}
i = i + 1;
}
/* 当前方块（结束后不画） */
/* Current piece (not drawn once the game is over) */
if (state != 2) {
i = 0;
while (i < 4) {
v = ui_piece_get_cell(pid, rot, i);
if (v >= 0) {
x = px + v / 16;
y = py + v % 16;
if (y >= 0) draw_block(bx + x * cell, by + y * cell, pid, cell);
}
i = i + 1;
}
}
draw_panel();
draw_overlay();
ui_2d_present();
}
/* ── 动作派发 ───────────────────────────────────────────── */
/* ── Action dispatch ────────────────────────────────── */
/* 按一下某个键。返回 **画面是否需要重画** —— 每次重画都要把整幅场景光栅化一遍
* Presses one key. Returns **whether the frame needs repainting** — every repaint rasterizes the whole scene
* （手机上是几百毫秒），所以"撞墙没动""结束后乱按"这些情况必须直接跳过重画。
* (hundreds of milliseconds on a phone), so "hit a wall and did not move" and "random presses after game over" must skip the repaint outright. */
int press(int btn) {
if (btn == 7) {
restart();
return 1;
}
if (state == 2) return 0; /* 结束了：除「重开」外一律无反应 */
/* Game over: nothing responds except "restart" */
if (btn == 6) {
if (state == 0) {
state = 1;
if (tid > 0) ui_timer_kill(tid);
tid = 0;
sfx_pause();
} else {
state = 0;
set_speed();
sfx_resume();
}
return 1;
}
if (state != 0) return 0; /* 暂停中 */
/* paused */
if (btn == 1) {
if (collide(pid, rot, px - 1, py) != 0) return 0;
px = px - 1;
return 1;
}
if (btn == 2) {
if (collide(pid, rot, px + 1, py) != 0) return 0;
px = px + 1;
return 1;
}
if (btn == 3) {
step_down();
score = score + 1;
return 1;
}
if (btn == 4) {
rotate_piece();
return 1;
}
if (btn == 5) {
hard_drop();
return 1;
}
return 0;
}
/* 长按连发：左/右/下按住不放就每 130ms 再来一次。
* Hold-to-repeat: holding left/right/down repeats the action every 130ms.
*
* 靠 `VML_MSG_KEYUP` 收尾 —— 手柄按下发 KeyDown、抬手发 KeyUp（`DrawWindowPage`
* It is ended by `VML_MSG_KEYUP` — pressing the gamepad sends KeyDown and releasing sends KeyUp (`DrawWindowPage`
* 用 Button 的 Pressed/Released，不再是一按就 Down+Up 一起发）。但**不能把"一定会收到
* uses the Button's Pressed/Released, so a single press no longer fires Down+Up together). But **you must not assume that
* KeyUp"当成前提**：手指划出按键范围、系统吃掉 CANCEL、页面被切走，都可能让 KeyUp 永远不来，
* KeyUp will always arrive**: a finger sliding off the button, the system swallowing CANCEL, the page being switched away — any of these can keep KeyUp from ever coming,
* 而连发一旦跑起来就会一直跑（`ui_timer_set` 是重复定时器）。
* and once repeat starts running it keeps running (`ui_timer_set` is a repeating timer).
* 所以连发**自带三道刹车**，任何一道都不会让程序卡在"一直往左移"上：
* So auto-repeat **carries three brakes of its own**, and none of them lets the program get stuck "drifting left forever":
* 1. **换键即接管** —— 另一个方向键的 KeyDown 直接改写 `held`；
* 1. **a new key takes over** — a KeyDown from another arrow key rewrites `held` outright;
* 2. **按了没动两次就停** —— 已经贴墙了还按，说明再按也没意义；
* 2. **stop after two presses that moved nothing** — pressing while already against the wall means further presses are pointless;
* 3. **总拍数上限 40**（约 5 秒）—— 横穿整个棋盘只要 10 拍、竖到底最多 20 拍，
* 3. **a cap of 40 ticks in total** (about 5 seconds) — crossing the whole board takes only 10 ticks and dropping to the bottom 20,
* 40 拍远超任何真实操作，纯粹是丢 KeyUp 时的兜底。
* so 40 ticks far exceeds any real play and is purely a fallback for a lost KeyUp.
* 三道里前两道是"手感"，第三道是"安全网"；写游戏时**重复定时器都要有这么一道**。
* Of the three, the first two are "feel" and the third is a "safety net"; **every repeating timer in a game needs one of these**. */
void hold_repeat(int btn) {
if (held == btn) {
if (rid > 0) return; /* 同一键重复按下（系统重复键）：不重建定时器 */
/* the same key pressed again (system key repeat): do not rebuild the timer */
rid = ui_timer_set(130, 1);
return;
}
held = btn;
rptLeft = 40;
rptStuck = 0;
if (rid > 0) ui_timer_kill(rid);
rid = ui_timer_set(130, 1);
}
void release(void) {
held = 0;
rptLeft = 0;
rptStuck = 0;
if (rid > 0) {
ui_timer_kill(rid);
rid = 0;
}
}
/* 连发的一拍。返回画面是否要重画。 */
/* One tick of auto-repeat. Returns whether the screen needs repainting. */
int repeat_tick(void) {
if (held == 0 || state != 0) return 0;
rptLeft = rptLeft - 1;
if (press(held) != 0) {
rptStuck = 0;
if (rptLeft <= 0) release();
return 1;
}
rptStuck = rptStuck + 1;
if (rptStuck >= 2 || rptLeft <= 0) release();
return 0;
}
/* 键码 → 按钮码；0 = 这个键不做事。
* Key code → button code; 0 = this key does nothing.
* 手柄那几个键在 `VmlKeys` 里刻意映射成了自然键盘等价键（A/B/X/Y 就是字母键、
* The gamepad keys are deliberately mapped in `VmlKeys` to natural keyboard equivalents (A/B/X/Y are the letter keys,
* START=回车、SELECT=Shift），所以同一份程序接物理键盘也能玩。
* START=Enter, SELECT=Shift), so the same program is playable with a physical keyboard. */
int key_to_btn(int k) {
if (k == VML_KEY_LEFT) return 1;
if (k == VML_KEY_RIGHT) return 2;
if (k == VML_KEY_DOWN) return 3;
if (k == VML_KEY_UP) return 4;
if (k == VML_KEY_PAD_A) return 4;
if (k == VML_KEY_PAD_X) return 4;
if (k == VML_KEY_SPACE) return 5;
if (k == VML_KEY_PAD_B) return 5;
if (k == VML_KEY_PAD_Y) return 5;
if (k == VML_KEY_SELECT) return 6;
if (k == VML_KEY_PAUSE) return 6;
if (k == VML_KEY_ENTER) return 7;
return 0;
}
/* ── 主循环 ─────────────────────────────────────────────── */
/* ── Main loop ───────────────────────────────────────── */
int main(void) {
int msg[4];
int t;
int k;
int btn;
int reserveP;
int availH;
int availW;
int cw;
int chh;
ui_piece_init(); /* 形状表一次初始化（几何都在共享库里，各语言共用一份） */
/* Initialize the shape table once (the geometry lives in the shared library and is common to every language) */
/* **开窗传 `0, 0`（= 尺寸交给宿主），开窗之后再问可用绘图区** —— 窗口宽高就是画布的坐标空间，
* **Open with `0, 0` (let the host size it), then ask for the available drawing area afterwards** — the window's width and height are the canvas's coordinate space,
* 而**开窗之前**问到的只是估算（宿主那时还不知道页面留了多少），手机上会与真实画布不一样。
* and what you get **before** the open is only an estimate (the host does not yet know what the page reserves), which differs from the real canvas on a phone.
* 排版用的数若不是真实画布（按屏幕 744 排版 / 画布只有 360 宽）就会把内容画到画布外，实测就是"右边被切掉"。
* Laying out for a number that is not the real canvas (laying out for a 744-wide screen while the canvas is 360 wide) draws content outside the canvas; measured, that is exactly "the right side gets cut off". */
g_lang = ui_scr_get_language();
ui_win_open(g_lang == 0 ? "俄罗斯方块" : "Tetris", 0, 0);
sw = ui_scr_get_w();
sh = ui_scr_get_h();
if (sw <= 0) sw = 360;
if (sh <= 0) sh = 620;
/* 玩游戏时别熄屏 —— 一手不动盯着棋盘想下一步，屏幕自己黑了最扫兴。
* Don't let the screen sleep while playing — holding still with one hand while you think about the next move, only to have the screen go black on its own, is the most annoying thing.
* 退出时会关掉（见文件末尾），所以不会一直亮着。
* It is turned off on exit (see the end of the file), so it does not stay lit forever. */
ui_scr_set_keep_on(1);
/* ── 布局（只算这一处）──
* ── Layout (computed in this one place only) ──
*
* 手柄交给系统之后，整个窗口高度都归棋盘用（旧版要留 140px 画手柄）。
* With the gamepad handed over to the system, the whole window height goes to the board (the old version had to reserve 140px to draw the gamepad).
* `reserveP` 是右侧信息面板的宽度，窄屏收一点。
* `reserveP` is the width of the right-hand info panel, trimmed a little on narrow screens. */
reserveP = 88;
if (sw < 360) reserveP = 76;
availW = sw - reserveP - 24;
availH = sh - 16;
cw = availW / BW;
chh = availH / BH;
cell = cw;
if (chh < cell) cell = chh;
if (cell < 8) cell = 8;
bx = 8 + (availW - BW * cell) / 2;
if (bx < 6) bx = 6;
by = 8 + (availH - BH * cell) / 2;
if (by < 6) by = 6;
panelX = sw - reserveP - 8;
panelW = reserveP;
if (panelX < bx + BW * cell + 6) panelX = bx + BW * cell + 6;
/* ── 开局 ── */
/* ── Game start ── */
tid = 0;
rid = 0;
held = 0;
score = 0;
nlines = 0;
level = 1;
state = 0;
load_best();
npid = ui_math_rand(7);
spawn();
set_speed();
/* ⚠ 中文这条整句写在同一行里：跨行拼接时第二段会落在没有 `g_lang == 0` 的行上
⚠ The Chinese message is kept whole on one line: if it were split across lines, the second part would land on a line without `g_lang == 0`
（语言审计脚本按行认），而相邻字面量拼接本来就只是 C 的语法糖。
(the language audit script works line by line), and adjacent-literal concatenation is only C syntactic sugar anyway. */
if (g_lang == 0) ui_dlg_msg("俄罗斯方块", "用屏幕下方的游戏按键操作：方向键移动与旋转、A 旋转、B 直落，START 重开、SELECT 暂停。返回箭头退出。", VML_DLG_INFO);
else ui_dlg_msg("Tetris", "Use the on-screen gamepad: arrows to move/rotate, A rotate, B hard drop, START restart, SELECT pause. Back arrow to quit.", VML_DLG_INFO);
draw_all();
/* 墙钟起点：进主循环时取（不在模块级/全局初始化里调 syscall） */
/* wall-clock origin: sampled when entering the main loop (no syscall at module/global-init level) */
acc = 0;
lastMs = ui_time_get_ms();
while (ui_win_is_closed() == 0) {
/* 这一帧该落几格：**按墙钟欠账**（各平台定时器分辨率不同 ⇒ 不能拿"收到几拍"当时间）。
* how many drops this frame: **driven by the wall-clock deficit** (timer resolution differs per platform => never treat "ticks received" as time).
* 用户 2026-10-04 口径：所有游戏时钟取系统毫秒数。
* user's 2026-10-04 rule: all game clocks read system milliseconds. */
{
int now2 = ui_time_get_ms();
acc = acc + (now2 - lastMs);
lastMs = now2;
if (acc > dropMs * 8) acc = 0; /* 卡太久别一次补一大串（防瞬移） */
/* do not catch up in one huge burst after a long stall (prevents teleporting) */
if (state != 0) acc = 0; /* 暂停/结束不累积 */
/* no accumulation while paused/finished */
if (acc >= dropMs) {
while (acc >= dropMs) { acc = acc - dropMs; step_down(); }
draw_all();
}
}
t = ui_msg_wait(msg, 0);
if (t == 0) continue;
if (t == VML_MSG_WINDOWCLOSE) break;
if (t == VML_MSG_TIMER) {
if (msg[2] == 1) { /* tag 1 = 长按连发 */
/* tag 1 = hold-to-repeat */
if (repeat_tick() != 0) draw_all();
} else if (state != 0 && tid > 0) {
/* tag 0 = 重力定时器：**只负责唤醒**，真正的落格在上面按墙钟欠账走。
* tag 0 = gravity timer: **it only wakes the loop**; the real drop is caught up above from the wall clock.
* 结束/暂停时把重力停掉 —— 否则定时器会一直往队列里投消息，
* Stop gravity on game over / pause — otherwise the timer keeps posting messages into the queue,
* 主循环空转不说，暂停期间还白耗电。重开时 set_speed 会重建。
* which not only spins the main loop for nothing but also burns power while paused. set_speed rebuilds it on restart. */
ui_timer_kill(tid);
tid = 0;
}
continue;
}
if (t == VML_MSG_KEYUP) {
k = msg[1];
/* 只有"抬起的是当前按住的键"才结束连发；否则连发的节奏会被
* Only a KeyUp for the key currently held ends auto-repeat; otherwise the repeat rhythm would be
* 另一个方向键的抬起打断（屏幕上同时按两个键是很常见的）。
* interrupted by the release of the other arrow key (pressing two keys at once on screen is very common). */
if (held != 0 && key_to_btn(k) == held) release();
continue;
}
if (t == VML_MSG_KEYDOWN) {
k = msg[1];
if (k == VML_KEY_ESCAPE) break;
btn = key_to_btn(k);
if (btn == 0) continue;
if (press(btn) != 0) draw_all();
/* 连发只挂"能连续做的动作"，重开/暂停那种一次性键不挂 */
/* Auto-repeat is attached only to "actions that can be done continuously", not to one-shot keys like restart/pause */
if (btn == 1 || btn == 2 || btn == 3) hold_repeat(btn);
}
}
release();
if (tid > 0) ui_timer_kill(tid);
ui_scr_set_keep_on(0);
ui_win_close();
return 0;
}