lua/app/g2048.lua · 29342 字节 · 下载原文
-- 2048 —— 用 **Lua** 写的手机游戏
-- 2048 — a phone game written in **Lua**
--
-- 规则：四方向滑动，同值方块相撞就合并成双倍并加分。
-- Rules: slide in one of four directions; equal tiles that collide merge into their double and score.
-- 每滑一次补一块新方块（90% 是 2、10% 是 4）。
-- Every slide spawns one new tile (90% a 2, 10% a 4).
-- 合出 2048 算赢；棋盘满且四个方向都动不了算输。
-- Reaching 2048 wins; a full board with no legal move in any direction loses.
-- 操作：方向键 / WASD 滑动 · 触摸**滑动** · 回车或 R 重开 · ESC 退出。
-- Controls: arrows / WASD to slide · swipe by touch · Enter or R restarts · ESC exits.
--
-- ◆ 这份例程在练什么
-- ◆ What this example exercises
--
-- 这是本目录里第一个**回合制**的游戏（`snake.lua` 是定时器驱动的实时游戏、`life.lua` 是纯状态机）。
-- This is the first **turn-based** game in this directory (`snake.lua` is timer-driven and real time,
-- `life.lua` is a pure state machine).
-- 一次输入触发一次整体重排：「取一条线 → 压紧 → 合并 → 写回」四步对 4 行 / 4 列各做一遍。
-- One input triggers one full rearrangement: "extract a line → compact → merge → write back", run once per row
-- and once per column.
-- 逻辑全在**多参函数**里：`merge4(v1,v2,v3,v4)` 收 4 个格子，`line_cell(dir,i,k)` 算格子下标。
-- The logic lives in **multi-argument functions**: `merge4(v1,v2,v3,v4)` takes four cells and
-- `line_cell(dir,i,k)` computes a cell index.
--
-- ◆ 本语言的五条**实测约束**（与 `snake.lua` 同一套，都在这份里躲开了）
-- ◆ Five **measured constraints** of this language (the same set as `snake.lua` — all avoided here)
--
-- · **顶层 `local` 在函数里读不到**（野地址 ⇒ 内存错误），函数也看不见外层函数的局部。
-- · **A top-level `local` is invisible inside a function** (wild address ⇒ memory fault), and a function
-- cannot see the enclosing function's locals either.
-- 所以状态与逻辑**一律顶层全局**。
-- So all state and logic are **top-level globals**.
-- · **空表 `{}` 只有 8 个键位**：`capacity = 字段数 + max(8, 字段数/2 + 4)`，**写满后新键被静默丢弃**。
-- · **An empty `{}` holds only 8 keys**: `capacity = fields + max(8, fields/2 + 4)`, and **new keys are
-- silently dropped once it is full**.
-- 实测：`A = {}` 连写 90 个下标只留下 8 个；`C = {16 个 0}` 留下 28 个。
-- Measured: `A = {}` — 8 of 90 indices survive; `C = {16 zeros}` — 28.
-- ✅ 2026-10-04 复验仍成立（重测：`{}` 连写 90 个 ⇒ `#A` = 8、`{16 个 0}` ⇒ 28）。
-- ✅ Still true as of 2026-10-04 (re-measured: `{}` + 90 writes => `#A` = 8; `{16 zeros}` => 28).
-- ⇒ 棋盘是 `{16 个 0}`（容量 28），临时线是 `{0,0,0,0}`（容量 12），**都按容量建表**。
-- ⇒ The board is `{16 zeros}` (capacity 28) and the scratch lines are `{0,0,0,0}` (capacity 12).
-- · 别写 `t[#t + 1] = v`（内联 `#` 当下标）：实测写 3 次只剩 1 个元素，要先 `local n = #t`。
-- · Do not write `t[#t + 1] = v` (inline `#` as a subscript): measured, three writes leave one element —
-- take `local n = #t` first.
-- · `and` / `or` 求的是布尔 0/1（见 `life.lua`）⇒ 一律 `if/else`。
-- · `and` / `or` evaluate to boolean 0/1 (see `life.lua`) ⇒ always use `if/else`.
-- `tostring` / `pairs` 的路没通，数字要画出来就自己画点阵（`draw_number`，见下）。
-- `tostring` / `pairs` are not wired up, so numbers are drawn with our own dot-matrix renderer.
-- · **表字面量没有 GC**：每帧 `{}` 会一直攒着 ⇒ 临时数组**建一次、反复覆盖**（`LINE` / `LINE2`）。
-- · **Table literals are never collected**: a `{}` per frame keeps piling up ⇒ scratch arrays are created
-- once and overwritten in place (`LINE` / `LINE2`).
-- ── 显式引用 UI 库的声明文件 ────────────────────────────────────────────────
-- Explicit reference to the UI library's declaration file.
-- `Lib/lua/vml_ui.lua` 由 `GenLib -n -c vmlui -l lua` 从 `Lib/shared/src/vmlui.c` 生成（155 个 `ui_*`）。
-- `Lib/lua/vml_ui.lua` is produced by `GenLib -n -c vmlui -l lua` from `Lib/shared/src/vmlui.c` (155 `ui_*`).
-- **不要手写、也不要手改生成物**（要改就改生成器 `tools/GenLib`）。
-- Never hand-write it and never edit the generated file (change the generator `tools/GenLib` instead).
-- ⚠ 这条 `require` 对 Lua 是**文档级**引用：本前端按名字解析库函数，删掉它照样编得过、跑得对。
-- ⚠ For Lua this `require` is a **documentation-level** reference: the front end resolves library
-- functions by name, so removing it still compiles and runs.
-- 实测结论与命令见 `docs/UI库导入约定.md` 的「lua 实测结论」一节。
-- Measured results and the exact commands are in the UI-library import convention doc (Lua section).
require("vml_ui")
-- ── 顶层全局：常量、点阵字体、棋盘与一局的状态 ──────────────────────────────
-- ── Top-level globals: constants, the dot-matrix font, the board and the state of one round ──
-- 棋盘边长（4×4）
-- board side (4x4)
N = 4
-- 合出它就通关
-- reaching this value wins the round
TARGET = 2048
FONT = {31599, 29850, 29671, 31207, 18925, 31183, 31695, 18727, 31727, 31215}
-- 数字 0..9 的 15 位点阵掩码（位序 = 行*3 + 列）
-- 15-bit dot-matrix masks for 0..9 (bit index = row*3 + col)
BIT = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384}
-- 棋盘：**按 16 个字段建表**拿到 28 个键位（空表 `{}` 只有 8 个，写到第 9 格起会被静默丢掉；2026-10-04 复验仍成立）
-- The board: **built with 16 fields** so it gets 28 key slots (a bare `{}` has 8, and writes past the eighth are
-- silently dropped; still true as of 2026-10-04)
BOARD = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-- 两条复用的临时线（容量 12）：**建一次、反复覆盖**，因为本平台没有 GC，逐次 `{}` 会一直攒着
-- Two reused scratch lines (capacity 12): created once and overwritten, because there is no GC here and a fresh
-- `{}` per move would pile up
LINE = {0, 0, 0, 0}
LINE2 = {0, 0, 0, 0}
SCORE = 0
-- 0 进行 / 1 结束 / 2 通关
-- round state: 0 playing / 1 over / 2 won
STATE = 0
-- 盘面上最大的方块（HUD 上画出来，不用 tostring）
-- the largest tile on the board (drawn in the HUD; no tostring here)
MAXTILE = 0
-- merge4 的四个输出格（本前端不做多返回值，结果落在全局）
-- the four outputs of merge4 (no multiple return values here, so they land in globals)
M1 = 0
M2 = 0
M3 = 0
M4 = 0
-- 这一步有没有真的动过（动了才补新块、才重画）
-- did this slide really move anything (only then spawn a tile and redraw)
MOVED = 0
-- 这一步合并拿到的分（一次滑动里累加，滑完一次性记进 SCORE）
-- score gained by merges this slide (accumulated per line, added to SCORE once at the end)
GAIN = 0
W = 360
CELL = 80
OX = 8
OY = 96
-- 界面文字：开局按 `ui_scr_get_language()` 选一次（见 main）
-- UI strings: chosen once from `ui_scr_get_language()` at startup (see main)
T_TITLE = "2048"
T_SCORE = "SCORE"
T_MAX = "MAX"
T_OVER = "NO MOVES LEFT"
T_WIN = "YOU WIN!"
T_AGAIN = "Enter = restart"
T_HELP = "Swipe or use the arrow keys"
-- 画一个 3×5 点阵数字：`d` 是数字、`px` 是一格边长、`color` 是真彩色
-- Draw one 3×5 dot-matrix digit: `d` the digit, `px` the cell side, `color` a truecolor value
function draw_digit(x, y, d, px, color)
if d < 0 then
d = 0
end
if d > 9 then
d = 9
end
local mask = FONT[d + 1]
local r = 0
while r < 5 do
local c = 0
while c < 3 do
-- 位序与生成掩码时一致：idx = 行*3 + 列；掩码表 1 基 ⇒ +1
-- Same bit order as the masks were generated with: idx = row*3 + col; the table is 1-based ⇒ +1
if mask / BIT[r * 3 + c + 1] % 2 == 1 then
ui_2d_rect(x + c * px, y + r * px, px, px, color, 1, 0, 0)
end
c = c + 1
end
r = r + 1
end
end
-- 数字的宽度（格）：每位 4 格（3 格字形 + 1 格间距），最后一位不算间距
-- Width of a number in cells: four cells per digit (three glyph + one gap), the last digit has no gap
function num_w(v)
local digits = 1
local n = v
while n >= 10 do
n = n / 10
digits = digits + 1
end
return digits * 4 - 1
end
-- 画一个非负整数并**居中**在 (cx, cy)：先用 num_w 量宽度，再算左上角
-- Draw a non-negative integer **centred** at (cx, cy): measure with num_w first, then compute the top-left corner
function draw_number_centered(cx, cy, v, px, color)
if v < 0 then
v = 0
end
if v > 999999 then
v = 999999
end
local wcells = num_w(v)
local x = cx - wcells * px / 2
local y = cy - 5 * px / 2
local digits = 1
local n = v
while n >= 10 do
n = n / 10
digits = digits + 1
end
local i = digits
local rest = v
while i >= 1 do
local d = rest % 10
rest = rest / 10
draw_digit(x + (i - 1) * px * 4, y, d, px, color)
i = i - 1
end
end
-- 左对齐画一个非负整数（HUD 用）
-- Draw a non-negative integer left-aligned (used by the HUD)
function draw_number(x, y, v, px, color)
if v < 0 then
v = 0
end
if v > 999999 then
v = 999999
end
local digits = 1
local n = v
while n >= 10 do
n = n / 10
digits = digits + 1
end
local i = digits
local rest = v
while i >= 1 do
local d = rest % 10
rest = rest / 10
draw_digit(x + (i - 1) * px * 4, y, d, px, color)
i = i - 1
end
end
-- 字符串宽度（方法调用形态：`s:len()` ⇒ `string.len(s)`，实测可用；它数的是**字节**）
-- String width (the method-call form: `s:len()` ⇒ `string.len(s)`, measured working; it counts **bytes**)
function text_w(s)
return s:len()
end
-- 方块配色：按数值回一个真彩色（0 表示空格，用底色）
-- Tile color: one truecolor per value (0 = empty, drawn with the board color)
function tile_color(v)
if v == 0 then
-- 0xFF1F2422 空格
-- 0xFF1F2422 empty cell
return -14736350
end
if v == 2 then
return -13684674 -- 0xFF2F303E
end
if v == 4 then
return -12631730 -- 0xFF3F414E
end
if v == 8 then
return -2069424 -- 0xFFE06C50
end
if v == 16 then
return -2056112 -- 0xFFE0A050
end
if v == 32 then
return -2509750 -- 0xFFD9B44A
end
if v == 64 then
return -11483016 -- 0xFF50C878
end
if v == 128 then
return -11890471 -- 0xFF4A90D9
end
if v == 256 then
return -8823591 -- 0xFF795CD9
end
if v == 512 then
return -2532194 -- 0xFFD95C9E
end
if v == 1024 then
return -11409298 -- 0xFF51E86E
end
-- 0xFFFFE060 2048 及以上
-- 0xFFFFE060 2048 and above
return -8096
end
-- 数字在方块上的颜色：亮底用深字、暗底用亮字（对比度是能看清的前提）
-- Digit color on a tile: dark text on light tiles, light text on dark tiles (contrast is what makes it readable)
function tile_ink(v)
if v >= 8 then
-- 0xFF101018 深字（亮底）
-- 0xFF101018 dark ink on bright tiles
return -15724520
end
-- 0xFFE8E8F0 亮字（暗底）
-- 0xFFE8E8F0 light ink on dark tiles
return -1513232
end
-- 格子下标：`dir` 方向、第 `i` 条线、线上第 `k` 格（`k` 从「靠前」那一侧数）
-- Cell index: direction `dir`, line `i`, position `k` along that line (k counted from the leading side)
-- 下标 = 行*4 + 列 + 1（本前端的表是 1 基的）
-- Index = row*4 + col + 1 (tables here are 1-based)
-- 0 上 / 1 左 / 2 下 / 3 右（与滑动方向同名，见 do_move）
-- 0 up / 1 left / 2 down / 3 right (named after the slide direction, see do_move)
function line_cell(dir, i, k)
if dir == 1 then
-- 左：第 i 行，从左数第 k 个
-- left: row i, the k-th cell counting from the left
return i * N + k + 1
end
if dir == 3 then
-- 右：同一行，从右数第 k 个
-- right: the same row, the k-th cell counting from the right
return i * N + (N - 1 - k) + 1
end
if dir == 0 then
-- 上：第 i 列，从上往下第 k 个
-- up: column i, the k-th cell counting from the top
return k * N + i + 1
end
-- 下：同一列，从下往上第 k 个
-- down: the same column, the k-th cell counting from the bottom
return (N - 1 - k) * N + i + 1
end
-- 一条线（4 个格子的值）压紧 + 合并，结果写进全局 M1..M4、得分增量写进 GAIN、动过没有写进 MOVED。
-- Compact and merge one line (four cell values); the result goes into M1..M4, the score gain into GAIN,
-- and whether anything moved into MOVED.
-- 多参函数形态：4 个格子直接当形参传进来，不建临时表。
-- The multi-argument form: the four cells come in as parameters, so no temporary table is built.
function merge4(v1, v2, v3, v4)
-- ① 压紧：把非 0 的往前提（`LINE[n] = v` 覆盖的是**已有下标**，不碰容量）
-- ① Compact: move non-zero values forward (`LINE[n] = v` overwrites an existing index, capacity untouched)
local n = 0
if v1 ~= 0 then
n = n + 1
LINE[n] = v1
end
if v2 ~= 0 then
n = n + 1
LINE[n] = v2
end
if v3 ~= 0 then
n = n + 1
LINE[n] = v3
end
if v4 ~= 0 then
n = n + 1
LINE[n] = v4
end
-- ② 合并：相邻同值合成双倍，加一次分（一次滑动里同一块只能合一次 —— 靠跳过被吃掉的那格实现）
-- ② Merge: adjacent equal values double and score once (a tile merges only once per slide — done by skipping
-- the swallowed cell)
local m = 0
local i = 1
while i <= n do
local v = LINE[i]
if i < n and LINE[i + 1] == v then
v = v * 2
GAIN = GAIN + v
i = i + 1
end
m = m + 1
LINE2[m] = v
i = i + 1
end
-- ③ 补 0 到 4 格
-- ③ Pad back to four cells
while m < 4 do
m = m + 1
LINE2[m] = 0
end
M1 = LINE2[1]
M2 = LINE2[2]
M3 = LINE2[3]
M4 = LINE2[4]
-- ④ 有没有动过（写回前比一次；`MOVED` 决定要不要补新块）
-- ④ Did anything move? (compared before writing back; `MOVED` decides whether a new tile spawns)
if M1 ~= v1 or M2 ~= v2 or M3 ~= v3 or M4 ~= v4 then
MOVED = 1
end
end
-- 找个空格放新方块：随机试 200 次，试不出来（棋盘快满了）就线性扫
-- Pick an empty cell for the new tile: 200 random tries, then a linear scan when the board is nearly full
function spawn_tile()
local total = N * N
local slot = -1
local tries = 0
while tries < 200 do
local idx = ui_math_rand(total) + 1
if BOARD[idx] == 0 then
slot = idx
-- `break` 在本前端是好的（见 demo_ui.lua 的说明）
-- `break` works on this front end (see the note in demo_ui.lua)
break
end
tries = tries + 1
end
if slot < 0 then
local j = 1
while j <= total do
if BOARD[j] == 0 then
slot = j
break
end
j = j + 1
end
end
if slot < 0 then
return 0
end
-- 90% 出 2、10% 出 4
-- 90% of the time a 2, 10% of the time a 4
local r = ui_math_rand(10)
if r == 0 then
BOARD[slot] = 4
else
BOARD[slot] = 2
end
return 1
end
-- 重开一局：清盘、放两块、分数与状态复位
-- Restart: clear the board, place two tiles, reset score and state
function reset_game()
local i = 1
while i <= N * N do
BOARD[i] = 0
i = i + 1
end
SCORE = 0
STATE = 0
MAXTILE = 0
GAIN = 0
spawn_tile()
spawn_tile()
-- ⚠ MAXTILE 要在这里就填一次：它原本只在 `do_move` 末尾算，于是开局 HUD 上会一直挂着 0。
-- ⚠ MAXTILE is also filled here: it used to be computed only at the end of `do_move`, so the HUD showed 0
-- at the start even though two 2s were already on the board.
MAXTILE = max_tile()
end
-- 还能不能动：有空格就能动；没有空格就看有没有相邻同值
-- Is any move still possible: an empty cell means yes; otherwise look for an adjacent equal pair
function any_move_possible()
local i = 1
while i <= N * N do
if BOARD[i] == 0 then
return 1
end
i = i + 1
end
local r = 0
while r < N do
local c = 0
while c < N do
local v = BOARD[r * N + c + 1]
if c + 1 < N and BOARD[r * N + c + 2] == v then
return 1
end
if r + 1 < N and BOARD[(r + 1) * N + c + 1] == v then
return 1
end
c = c + 1
end
r = r + 1
end
return 0
end
-- 盘面上最大的方块（HUD 画它 —— 离 2048 还有多远一眼看得出）
-- The largest tile on the board (drawn in the HUD — how far 2048 is, at a glance)
function max_tile()
local best = 0
local i = 1
while i <= N * N do
if BOARD[i] > best then
best = BOARD[i]
end
i = i + 1
end
return best
end
-- 往 `dir` 滑一次：4 条线各跑一遍 merge4，然后写回、补块、判胜负
-- Slide once toward `dir`: run merge4 over the four lines, write back, spawn, and test win/lose
-- 返回 1 表示这一步改了盘面（喂给主循环的「要不要重画」）
-- Returns 1 when the move changed the board (fed to the main loop's "should we redraw")
function do_move(dir)
MOVED = 0
GAIN = 0
local i = 0
while i < N do
local a = BOARD[line_cell(dir, i, 0)]
local b = BOARD[line_cell(dir, i, 1)]
local c = BOARD[line_cell(dir, i, 2)]
local d = BOARD[line_cell(dir, i, 3)]
merge4(a, b, c, d)
-- 写回时**必须按同一个方向顺序**放（左/上从 `k=0` 起，右/下也按「靠前」那一侧起）
-- The write-back **must use the same directional order** (left/up start at `k=0`; right/down also start
-- from their leading side)
BOARD[line_cell(dir, i, 0)] = M1
BOARD[line_cell(dir, i, 1)] = M2
BOARD[line_cell(dir, i, 2)] = M3
BOARD[line_cell(dir, i, 3)] = M4
i = i + 1
end
if MOVED == 0 then
-- ⚠ 滑不动也要判一次胜负：正常情况下「无路可走」是在**上一次成功移动补完新块之后**
-- ⚠ A blocked slide still has to test win/lose: normally "no moves left" is caught right below by
-- 立刻被下面的 `any_move_possible()` 抓到的，但那种"先卡住、再按键"的顺序也要兜住 ——
-- `any_move_possible()` after the spawn that follows the previous successful move, but the
-- 否则玩家会看到"按键只响一声、游戏永远不结束"（实测：塞一个满盘四向皆堵的盘面，
-- "already stuck, then press a key" order must be covered too — otherwise the player sees a beep and a
-- 按左键只会一直响 196，横幅永远不出来）
-- game that never ends (measured: with a full board stuck in all four directions, pressing left only
-- beeps 196 forever and the banner never appears)
if any_move_possible() == 0 then
STATE = 1
ui_audio_beep(131, 320)
return 1
end
-- 滑不动：一声很低的"闷"提示（不是错误，不打断节奏）
-- blocked slide: one low thud (not an error, it does not break the rhythm)
ui_audio_beep(196, 40)
return 0
end
SCORE = SCORE + GAIN
if GAIN > 0 then
-- 合并成功：清亮的一声（得分多少由画面说话）
-- a merge happened: one bright tone (the picture tells you how much it scored)
ui_audio_beep(523, 60)
end
spawn_tile()
MAXTILE = max_tile()
if MAXTILE >= TARGET then
STATE = 2
-- 通关：最高音 + 最长
-- won: highest and longest tone
ui_audio_beep(1047, 320)
return 1
end
if any_move_possible() == 0 then
STATE = 1
-- 走投无路：最低音 + 最长（§4.5「输取最低」）
-- no moves left: lowest and longest tone (4.5: take the lowest for a loss)
ui_audio_beep(131, 320)
end
return 1
end
-- 画一整帧
-- Draw one whole frame
function draw()
local cell = CELL
local ox = OX
local oy = OY
local gap = 6
ui_2d_clear(-15724520) -- 0xFF101018
-- 标题 + 与标题等宽的下划线（宽度由 `s:len()` 数出来 —— 方法调用那条路）
-- Title plus an underline as wide as the title (width from `s:len()` — the method-call path)
ui_2d_text(ox, 8, T_TITLE, -1513232, 20, VML_ANCHOR_LEFT)
ui_2d_rect(ox, 34, text_w(T_TITLE) * 4, 3, -2069424, 1, 0, 0)
-- HUD：得分 / 最大方块（都走点阵渲染器）
-- HUD: score / largest tile (both through the dot-matrix renderer)
ui_2d_text(W - ox - 150, 8, T_SCORE, -6643536, 11, VML_ANCHOR_LEFT)
draw_number(W - ox - 150, 22, SCORE, 3, -2509750)
ui_2d_text(W - ox - 60, 8, T_MAX, -6643536, 11, VML_ANCHOR_LEFT)
draw_number(W - ox - 60, 22, MAXTILE, 3, -11409298)
-- 棋盘底
-- Board floor
ui_2d_rect(ox - gap, oy - gap, cell * N + gap * 2, cell * N + gap * 2, -14079702, 1, 0, 8)
-- 16 个格子
-- The sixteen cells
local r = 0
while r < N do
local c = 0
while c < N do
local v = BOARD[r * N + c + 1]
local x = ox + c * cell
local y = oy + r * cell
ui_2d_rect(x + gap / 2, y + gap / 2, cell - gap, cell - gap, tile_color(v), 1, 0, 6)
if v ~= 0 then
-- 位数多（≥ 4 位）时把字缩小一档，免得顶出格子
-- Values with four or more digits use a smaller step so they do not overflow the tile
local px = 5
if v >= 1024 then
px = 4
end
if v >= 16384 then
px = 3
end
draw_number_centered(x + cell / 2 + 2, y + cell / 2, v, px, tile_ink(v))
end
c = c + 1
end
r = r + 1
end
-- 结束 / 通关的横幅（都伴随音效，见 do_move）
-- The over / won banner (each comes with a sound — see do_move)
if STATE ~= 0 then
local cy = oy + cell * N / 2
ui_2d_rect(ox - gap, cy - 58, cell * N + gap * 2, 116, -14736350, 1, 0, 8)
if STATE == 2 then
ui_2d_text(W / 2, cy - 40, T_WIN, -11409298, 22, VML_ANCHOR_CENTER)
else
ui_2d_text(W / 2, cy - 40, T_OVER, -2069424, 20, VML_ANCHOR_CENTER)
end
ui_2d_text(W / 2, cy - 6, T_AGAIN, -1513232, 13, VML_ANCHOR_CENTER)
draw_number_centered(W / 2, cy + 34, SCORE, 4, -2509750)
end
ui_2d_text(W / 2, oy + cell * N + 20, T_HELP, -6643536, 12, VML_ANCHOR_CENTER)
ui_2d_present()
end
function main()
-- 界面语言：开局问一次宿主要中文还是英文（0=中文 1=英文），之后整局按它分支。
-- UI language: ask the host once (0=Chinese 1=English), then branch on it for the whole session.
-- ⚠ 别在每帧里调（一次 syscall），也**不能**用 `and/or` 选串（见文件头）。
-- ⚠ Not per frame (it is a syscall), and do not pick strings with `and/or` (see the header).
local lang = ui_scr_get_language()
if lang == 0 then T_SCORE = "得分" end
if lang == 0 then T_MAX = "最大" end
if lang == 0 then T_OVER = "走不动了" end
if lang == 0 then T_WIN = "合出 2048！" end
if lang == 0 then T_AGAIN = "回车 = 重开" end
if lang == 0 then T_HELP = "滑动屏幕 / 方向键移动" end
-- 开窗时传 0：尺寸交给宿主（用真实可用区）。**开窗之后**再问一次真实画布 —— 开窗前问到的只是估算值。
-- Pass 0 when opening: the size is the host's to decide (the real usable area). Ask the **real** canvas only after the window is open -- before that the host can only estimate.
ui_win_open("2048", 0, 0)
ui_scr_set_keep_on(1)
local w = ui_scr_get_w()
local h = ui_scr_get_h()
if w <= 0 then
w = 360
end
if h <= 0 then
h = 620
end
W = w
-- 棋盘边长按「按宽」「按高」两个上界的小者算（手机可用绘图区实测约 395×578）
-- The board side is the smaller of the width and height bounds (the measured phone drawing area is ~395×578)
local cell = (w - 24) / N
local avail = h - 200
if avail / N < cell then
cell = avail / N
end
if cell < 20 then
cell = 20
end
CELL = cell
OX = (w - cell * N) / 2
OY = 96
reset_game()
local quit = 0
local need_draw = 1
-- 按下的位置（触摸滑动要用「按下 → 抬起」的位移判方向）
-- where the press started (a swipe needs the press-to-release displacement to pick a direction)
local td_x = 0
local td_y = 0
while ui_win_is_closed() == 0 and quit == 0 do
-- 先画后等：只在盘面真会变时才画
-- Draw before waiting, and only when the board really changes
if need_draw ~= 0 then
draw()
need_draw = 0
end
local t = ui_msg_fetch_wait(0)
if t == 10 then
quit = 1
end
if t == 1 then
local k = ui_msg_get_a()
if k == 27 then
quit = 1
end
-- 回车 / R
-- Enter or R
if k == 13 or k == 82 then
reset_game()
ui_audio_beep(660, 70)
need_draw = 1
end
if STATE == 0 then
if k == 38 or k == 87 then need_draw = do_move(0) end
if k == 37 or k == 65 then need_draw = do_move(1) end
if k == 40 or k == 83 then need_draw = do_move(2) end
if k == 39 or k == 68 then need_draw = do_move(3) end
end
end
-- 触摸：按下时记位置、抬起时按位移的主轴判方向（真正的"滑动"，不是点击）
-- Touch: record the press, then on release use the dominant axis of the displacement (a real swipe, not a tap)
if t == 6 then
td_x = ui_msg_get_a()
td_y = ui_msg_get_b()
end
if t == 8 then
local ux = ui_msg_get_a()
local uy = ui_msg_get_b()
local dx = ux - td_x
local dy = uy - td_y
local adx = dx
local ady = dy
if adx < 0 then adx = 0 - adx end
if ady < 0 then ady = 0 - ady end
-- 位移太小当点击处理（免得误触就把盘面搅了）
-- Too small a displacement is treated as a tap (so an accidental touch does not scramble the board)
if adx > 24 or ady > 24 then
if STATE == 0 then
if adx > ady then
if dx > 0 then need_draw = do_move(3) else need_draw = do_move(1) end
else
if dy > 0 then need_draw = do_move(2) else need_draw = do_move(0) end
end
end
end
end
end
ui_scr_set_keep_on(0)
ui_sfx_panic()
ui_win_close()
end
main()