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

swift/app/puzzle15.swift · 12662 字节 · 下载原文

▶ 在浏览器里试玩

// 数字华容道(15 格滑块拼图)—— 用 **Swift** 写的手机小游戏
// 15-puzzle — a small phone game written in **Swift**
//
// 玩法(与 `Examples/c/app/puzzle15.c` / `Examples/python/app/puzzle15.py` 同一套):
// Gameplay (same rules as `Examples/c/app/puzzle15.c` / `Examples/python/app/puzzle15.py`):
//   · 4×4 里 15 个数字 + 1 个空格;点空格**上下左右**的块,它就滑过去(斜着不算);
//   · 15 numbers plus one blank in a 4x4; tap a tile **orthogonally** next to the blank and it slides over;
//   · 排成 1..15 顺序即通关;通关后点屏幕(或按 ESC / R)重开。
//   · arranging 1..15 in order wins; after a win, tap the screen (or press ESC / R) for a new game.
//
// ◆ 打乱用的是「从解好的局面随机走 400 步合法步」⇒ **局面一定可解**。
// ◆ The shuffle is "400 random legal moves from the solved board" ⇒ **always solvable**.
//   随手随机交换有一半概率得到死局 —— 那种局面玩家怎么走都拼不回来。
//   Random swapping produces a dead board about half the time — the player can never solve it.
//
// ◆ Swift 前端的实测约束(写这个文件时逐条撞过,结论都来自真实编译/运行)
// ◆ Measured constraints of the Swift frontend (hit while writing this file; all from real builds/runs)
//
//   ① **状态只能放数组**,而且**整个程序只允许一个全局数组**(多开会互相踩内存)⇒ 全塞进 `A`。
//   ① **State lives in arrays only**, and a program may have **exactly one global array** (several
//      clobber each other) ⇒ everything is packed into `A`.
//   ② **常量写成 `main` 里的局部变量 / 无参函数**;模块级 `let` 不可靠。
//   ② **Constants are locals in `main` / zero-argument functions**; module-level `let` is unreliable.
//   ③ **颜色写成负数十进制**(十六进制字面量不可靠):`0xFF4A90D9` ⇒ `-11890471`。
//   ③ **Colors are negative decimals** (hex literals are unreliable): `0xFF4A90D9` => `-11890471`.
//   ④ **整数除法向零截断**(实测 `7/2=3`、`-7/2=-3`):点坐标先挡 `tx < ox` 再除。
//   ④ **Integer division truncates toward zero** (measured `7/2=3`, `-7/2=-3`): reject `tx < ox` before dividing.
//   ⑤ **函数名避开 `add`/`min`/`max`/`abs`/`pow`/`sum`**(库里的裸标签会静默顶掉)⇒ 全部带 `pz` 前缀。
//   ⑤ **Avoid `add`/`min`/`max`/`abs`/`pow`/`sum`** (bare library labels silently override) ⇒ every function is `pz`-prefixed.
//   ⑥ **`ui_msg_fetch_wait(ms)` 的返回值就是那条消息**(0 = 超时),不要再 fetch 一次。
//   ⑥ **`ui_msg_fetch_wait(ms)` returns the message itself** (0 = timeout); do not fetch again.
//   ⑦ **触摸坐标取 `ui_msg_get_a()` / `ui_msg_get_b()`**。
//   ⑦ **Touch coordinates come from `ui_msg_get_a()` / `ui_msg_get_b()`**.
//
// 数值的唯一真源仍是 `Lib/c/vml_ui.h`。
// The single source of truth for these numbers is still `Lib/c/vml_ui.h`.

#include <vml_ui.swift>
var A = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
// 状态表 —— **只用一个全局数组**(见文件头 ①),下标分区:
// State table — **one global array only** (see header ①), partitioned by index:
//   0..15   第 x*4+y 格里的数字(0 = 空格)
//   0..15   the number in the cell at x*4+y (0 = blank)
//   16=blank_x 17=blank_y 18=moves 19=won 20=seed
//   21=cell 22=ox 23=oy 24=w 25=h 26=lang 27=timerId 28=frames
//   29=lastcell 30=slides 是只给无头验收用的读数(最近点击的格号 / 实际滑动次数)
//   29=lastcell 30=slides are headless-verification readouts (last tapped cell / real slide count)
//   31=swapCount 同样是验收读数(洗牌期间走了多少步合法步)
//   31=swapCount is also a readout (how many legal moves the shuffle made)

// 16 位 LCG。**不要**照搬 C 的 32 位 LCG:这一支的整数会溢出,后半段恒为 0。
// 16-bit LCG. Do **not** copy C's 32-bit LCG: integers overflow here and the tail becomes all 0.
func pzRnd(n: Int) -> Int {
    A[20] = (A[20] * 1103 + 12345) % 32768
    return (A[20] / 256) % n
}

func pzLayout() {
    var w = ui_scr_get_w()
    var h = ui_scr_get_h()
    if w <= 0 { w = 360 }
    if h <= 0 { h = 620 }
    A[24] = w
    A[25] = h
    var side = 0
    if w < h - 140 { side = w - 20 } else { side = h - 170 }
    var cell = side / 4
    if cell < 6 { cell = 6 }
    A[21] = cell
    A[22] = (w - 4 * cell) / 2
    A[23] = 110
}

func pzSwap(ax: Int, ay: Int, bx: Int, by: Int) {
    var t = A[ax * 4 + ay]
    A[ax * 4 + ay] = A[bx * 4 + by]
    A[bx * 4 + by] = t
}

// 随机走一步合法步:在空格的四邻里挑一个(越界就这一步算空走)
// Take one random legal move: pick one of the blank's four neighbours (out of bounds = a wasted step)
func pzSlideRandom() -> Int {
    var k = pzRnd(4)
    var dx = 0
    var dy = 0
    if k == 0 { dx = 1 }
    else if k == 1 { dx = -1 }
    else if k == 2 { dy = 1 }
    else { dy = -1 }
    var nx = A[16] + dx
    var ny = A[17] + dy
    if nx < 0 || ny < 0 || nx >= 4 || ny >= 4 { return 0 }
    pzSwap(A[16], A[17], nx, ny)
    A[16] = nx
    A[17] = ny
    A[30] = A[30] + 1
    return 1
}

func pzNewGame() {
    var v = 1
    var x = 0
    while x < 4 {
        var y = 0
        while y < 4 {
            A[x * 4 + y] = v
            v = v + 1
            y = y + 1
        }
        x = x + 1
    }
    A[15] = 0
    A[16] = 3
    A[17] = 3
    A[30] = 0
    var i = 0
    while i < 400 {
        pzSlideRandom()
        i = i + 1
    }
    A[31] = A[30]
    A[18] = 0
    A[19] = 0
    A[29] = -1
}

func pzCheckWin() -> Int {
    var v = 1
    var x = 0
    while x < 4 {
        var y = 0
        while y < 4 {
            if x == 3 && y == 3 {
                if A[x * 4 + y] == 0 { return 1 }
                return 0
            }
            if A[x * 4 + y] != v { return 0 }
            v = v + 1
            y = y + 1
        }
        x = x + 1
    }
    return 1
}

func pzDraw() {
    ui_2d_clear(-15724520)   // 0xFF101018
    var cell = A[21]
    var ox = A[22]
    var oy = A[23]
    var x = 0
    while x < 4 {
        var y = 0
        while y < 4 {
            var px = ox + x * cell
            var py = oy + y * cell
            var v = A[x * 4 + y]
            if v == 0 {
                ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -15329762, 1, 0, 6)   // 0xFF16161E
            } else {
                // 排好的那些用亮蓝、还没回去的用暗蓝 —— 一眼看出差多少
                // Tiles in place are bright blue, the rest dark blue — see the deficit at a glance
                var c = -12947544   // 0xFF3A6FA8
                if (v - 1) % 4 == x && (v - 1) / 4 == y { c = -11890471 }   // 0xFF4A90D9
                ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, c, 1, 0, 8)
                ui_2d_text(px + cell / 2, py + cell / 2 + cell / 8, int_to_str(v), -1513232, cell / 2, VML_ANCHOR_CENTER)
            }
            y = y + 1
        }
        x = x + 1
    }

    // HUD:步数(左上)
    // HUD: move count (top-left)
    ui_2d_text(10, 24, int_to_str(A[18]), -1513232, 18, VML_ANCHOR_LEFT)   // 0xFFE8E8F0
    if A[26] == 0 { ui_2d_text(10, 46, "步数", -6643536, 11, VML_ANCHOR_LEFT) }
    else { ui_2d_text(10, 46, "moves", -6643536, 11, VML_ANCHOR_LEFT) }

    // 底部提示
    // Bottom hint
    var msgY = A[23] + 4 * A[21] + 30
    if A[19] == 1 {
        if A[26] == 0 { ui_2d_text(A[24] / 2, msgY, "拼好了!点一下再来", -1513232, 15, VML_ANCHOR_CENTER) }
        else { ui_2d_text(A[24] / 2, msgY, "Solved! Tap for a new one", -1513232, 15, VML_ANCHOR_CENTER) }
    } else {
        if A[26] == 0 { ui_2d_text(A[24] / 2, msgY, "点空格旁边的块", -6643536, 12, VML_ANCHOR_CENTER) }
        else { ui_2d_text(A[24] / 2, msgY, "Tap a tile next to the blank", -6643536, 12, VML_ANCHOR_CENTER) }
    }
    ui_2d_present()
}

func pzTap(tx: Int, ty: Int) {
    A[29] = -1
    if A[19] == 1 { pzNewGame(); return }
    var cell = A[21]
    // ⚠ 先挡左上(负坐标再除会被向零截断成 0 格)—— 见文件头 ④
    // ⚠ Reject the top-left side first (negative coordinates truncate to cell 0) — see header ④
    if tx < A[22] || ty < A[23] { return }
    var x = (tx - A[22]) / cell
    var y = (ty - A[23]) / cell
    if x >= 4 || y >= 4 { return }
    A[29] = x * 4 + y
    // 只认上下左右相邻的(斜着不算)
    // Only orthogonal neighbours count (diagonals do not)
    var adjacent = 0
    if x == A[16] && (y == A[17] - 1 || y == A[17] + 1) { adjacent = 1 }
    if y == A[17] && (x == A[16] - 1 || x == A[16] + 1) { adjacent = 1 }
    if adjacent == 1 {
        pzSwap(A[16], A[17], x, y)
        A[16] = x
        A[17] = y
        A[18] = A[18] + 1
        A[19] = pzCheckWin()
    }
}

func main() {
    var MSG_KEYDOWN = 1
    var MSG_MOUSEDOWN = 4
    var MSG_TOUCHDOWN = 6
    var MSG_TIMER = 9
    var MSG_CLOSE = 10
    var MSG_RESIZE = 11
    var KEY_ESCAPE = 27
    var KEY_ENTER = 13
    var KEY_R = 82

    // 界面语言只问一次(syscall),存进状态表(模块级标量读出来是垃圾)
    // Ask for the UI language once (a syscall) and store it in the state table
    A[26] = ui_scr_get_language()
    var lang = A[26]

    // 竖屏 + 不要屏幕手柄区;尺寸传 0 = 交给宿主给真实可用区
    // Portrait + no on-screen gamepad; size 0 = let the host supply the real available area
    ui_win_open_ex(lang == 0 ? "数字华容道" : "15-puzzle", 0, 0, VML_WIN_PORTRAIT, VML_WIN_NO_GAMEPAD)

    // 开窗**之后**再问尺寸 —— 这时给的是实测画布
    // Re-read the size **after** opening — this is the measured canvas
    pzLayout()
    A[20] = 20266
    pzNewGame()
    ui_scr_set_keep_on(1)
    pzDraw()

    // 定时器 120 ms 一拍、**重复**(tag = 1):这个游戏没有计时,定时器只负责重画
    // Timer: 120 ms per tick, **repeating** (tag = 1); the game has no clock, the timer only repaints
    A[27] = ui_timer_set(120, 1)

    while ui_win_is_closed() == 0 {
        // ⚠ 返回值就是那条消息;再 fetch 一次会把定时器消息丢掉(见文件头 ⑥)
        // ⚠ The return value IS the message; fetching again would drop timer messages (header ⑥)
        var t = ui_msg_fetch_wait(120)
        if t == 0 { continue }

        if t == MSG_CLOSE { break }

        if t == MSG_TIMER {
            A[28] = A[28] + 1
            pzDraw()
            continue
        }

        if t == MSG_TOUCHDOWN || t == MSG_MOUSEDOWN {
            // 坐标只从消息里取(见文件头 ⑦)
            // Coordinates come only from the message (header ⑦)
            pzTap(ui_msg_get_a(), ui_msg_get_b())
            pzDraw()
            continue
        }

        if t == MSG_RESIZE {
            pzLayout()
            pzDraw()
            continue
        }

        if t == MSG_KEYDOWN {
            var k = ui_msg_get_a()
            if k == KEY_ESCAPE || k == KEY_R || k == KEY_ENTER {
                pzNewGame()
                pzDraw()
            }
            continue
        }
    }

    ui_timer_kill(A[27])
    ui_scr_set_keep_on(0)
    ui_win_close()

    // 无头验收读数(一行一个数,避开 int_to_str 共用静态缓冲的坑)
    // Headless acceptance readouts (one number per line, avoiding int_to_str's shared static buffer)
    println("swpuzzle: moves=" + int_to_str(A[18]))
    println("swpuzzle: blankx=" + int_to_str(A[16]))
    println("swpuzzle: blanky=" + int_to_str(A[17]))
    println("swpuzzle: won=" + int_to_str(A[19]))
    println("swpuzzle: slides=" + int_to_str(A[30]))
    println("swpuzzle: lastcell=" + int_to_str(A[29]))
    println("swpuzzle: frames=" + int_to_str(A[28]))
    println("swpuzzle: done")
}