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

c/app/sudoku.c · 17389 字节 · 下载原文

▶ 在浏览器里试玩

/* sudoku.c —— 《数独》9×9 触屏版(C 版),跑在手机端 VML 上
 * sudoku.c -- "Sudoku", a 9x9 touch game (C version) running on mobile VML
 *
 * 编译运行(手机 App 的 vml 工具):
 * Build and run (with the vml tool in the phone app):
 *     vml run examples/c/app/sudoku.c
 *
 * ## 玩法 / How to play
 *
 * 点格子选中,点底下一排 1-9 填数;「擦除」清空格子,「提示」填出选中格的正解,「新局」换一题。
 * Tap a cell to select it, then tap 1-9 on the keypad. Erase clears the cell, Hint fills the
 * selected cell from the solution, New game picks another puzzle.
 * 每行 / 每列 / 每个 3×3 宫内 1-9 不重复;填满且无冲突即通关(计时停止)。
 * Each row, column and 3x3 box must hold 1-9 once; a full grid with no conflict wins (timer stops).
 *
 * ## 为什么这样写(C 前端的三条硬约束,与 plane.c 相同)
 * ## Why it is written this way (three hard constraints of the C front end, same as plane.c)
 *
 * 1. ⚠ `${}` 只认局部变量 —— 本程序**不写 asm**,全部走 `vml_ui.h` 的包装函数。
 * 1. ⚠ `${}` only recognizes local variables -- this program writes **no asm** at all and goes
 *    entirely through the `vml_ui.h` wrapper functions.
 * 2. ⚠ 复合字面量 `(int[]){…}` 不支持 ⇒ 题库写成**具名全局数组**,每张表单独一段。
 * 2. ⚠ Compound literals `(int[]){...}` are unsupported => the puzzle tables are **named global arrays**,
 *    one table per declaration.
 * 3. 题库 = 3 道**唯一解**题(题目 + 答案成对);开局随机抽一题,再对 1-9 做一次随机置换 ——
 *    置换不破坏数独结构,于是 3 道题有 3×9! 张脸,且不必在虚拟机上现算题目。
 * 3. The puzzle set is 3 puzzles with **unique solutions** (puzzle + solution pairs); a game picks one at
 *    random and then applies a random permutation of the digits 1-9 -- which preserves the Sudoku
 *    structure, so 3 puzzles yield 3x9! faces without solving anything on the VM.
 */

#include <vml_ui.h>

#define N      9
#define CELLS  81
#define PUZZLES 3

/* ── 配色(0xAARRGGBB,alpha 在前)────────────────────────── */
/* -- Colors (0xAARRGGBB, alpha first) -- */

#define C_BG      0xFF10131A
#define C_HUD     0xFF171B24
#define C_BOARD   0xFF0B0E14
#define C_CELL_A  0xFF1B202B
#define C_CELL_B  0xFF202634
#define C_SEL     0xFF2F4E7A
#define C_SAME    0xFF26344A
#define C_LINE2   0xFF8FA3BF
#define C_GIVEN   0xFFE6EBF5
#define C_PLAYER  0xFF5EC8F0
#define C_HINT    0xFF7BE38A
#define C_BAD     0xFFFF6B6B
#define C_TEXT    0xFFE6EBF5
#define C_DIM     0xFF8B94A7
#define C_BTN     0xFF232938
#define C_BTN_HOT 0xFF31405C
#define C_ACCENT  0xFF4ADE80

/* ── 全局状态 ───────────────────────────────────────────── */
/* -- Global state -- */

int W, H;
int g_lang;

int val[CELLS];     /* 当前盘面(0 = 空) */
                    /* Current board (0 = empty) */
int giv[CELLS];     /* 1 = 题目给定,不可改 */
                    /* 1 = given by the puzzle, not editable */
int sol[CELLS];     /* 本局唯一解 */
                    /* The unique solution of this round */
int hint[CELLS];    /* 1 = 提示填出来的 */
                    /* 1 = filled by the hint button */

int sel;            /* 选中格下标(-1 = 没选) */
                    /* Selected cell index (-1 = none) */
int won;
int tick;
int t0;             /* 开局墙钟(毫秒) */
                    /* Wall clock at game start (ms) */
int frozenMs;       /* 通关后的用时 */
                    /* Elapsed time frozen at the win */

/* ── 题库(已验证唯一解;见文件头第 3 条)────────────────────── */
/* -- Puzzle set (solutions verified unique; see item 3 in the header) -- */

int pz0[CELLS] = {
    5,3,0, 0,7,0, 0,0,0,
    6,0,0, 1,9,5, 0,0,0,
    0,9,8, 0,0,0, 0,6,0,
    8,0,0, 0,6,0, 0,0,3,
    4,0,0, 8,0,3, 0,0,1,
    7,0,0, 0,2,0, 0,0,6,
    0,6,0, 0,0,0, 2,8,0,
    0,0,0, 4,1,9, 0,0,5,
    0,0,0, 0,8,0, 0,7,9
};
int so0[CELLS] = {
    5,3,4, 6,7,8, 9,1,2,
    6,7,2, 1,9,5, 3,4,8,
    1,9,8, 3,4,2, 5,6,7,
    8,5,9, 7,6,1, 4,2,3,
    4,2,6, 8,5,3, 7,9,1,
    7,1,3, 9,2,4, 8,5,6,
    9,6,1, 5,3,7, 2,8,4,
    2,8,7, 4,1,9, 6,3,5,
    3,4,5, 2,8,6, 1,7,9
};

int pz1[CELLS] = {
    0,0,0, 2,6,0, 7,0,1,
    6,8,0, 0,7,0, 0,9,0,
    1,9,0, 0,0,4, 5,0,0,
    8,2,0, 1,0,0, 0,4,0,
    0,0,4, 6,0,2, 9,0,0,
    0,5,0, 0,0,3, 0,2,8,
    0,0,9, 3,0,0, 0,7,4,
    0,4,0, 0,5,0, 0,3,6,
    7,0,3, 0,1,8, 0,0,0
};
int so1[CELLS] = {
    4,3,5, 2,6,9, 7,8,1,
    6,8,2, 5,7,1, 4,9,3,
    1,9,7, 8,3,4, 5,6,2,
    8,2,6, 1,9,5, 3,4,7,
    3,7,4, 6,8,2, 9,1,5,
    9,5,1, 7,4,3, 6,2,8,
    5,1,9, 3,2,6, 8,7,4,
    2,4,8, 9,5,7, 1,3,6,
    7,6,3, 4,1,8, 2,5,9
};

int pz2[CELLS] = {
    2,0,0, 0,8,0, 3,0,0,
    0,6,0, 0,7,0, 0,8,4,
    0,3,0, 5,0,0, 2,0,9,
    0,0,0, 1,0,5, 4,0,8,
    0,0,0, 0,0,0, 0,0,0,
    4,0,2, 7,0,6, 0,0,0,
    3,0,1, 0,0,7, 0,4,0,
    7,2,0, 0,4,0, 0,6,0,
    0,0,4, 0,1,0, 0,0,3
};
int so2[CELLS] = {
    2,4,5, 9,8,1, 3,7,6,
    1,6,9, 2,7,3, 5,8,4,
    8,3,7, 5,6,4, 2,1,9,
    9,7,6, 1,2,5, 4,3,8,
    5,1,3, 4,9,8, 6,2,7,
    4,8,2, 7,3,6, 9,5,1,
    3,9,1, 6,5,7, 8,4,2,
    7,2,8, 3,4,9, 1,6,5,
    6,5,4, 8,1,2, 7,9,3
};

/* ── 小工具 ─────────────────────────────────────────────── */
/* -- Small helpers -- */

/* 整数 → 十进制串(不用 sprintf:格式化那条路在本环境踩过坑)。 */
/* Integer -> decimal string (no sprintf: the formatting path has bitten this environment before). */
char g_buf[24];
char* fmt_int(int v, char* buf)
{
    int n = 0, i = 0;
    if (v < 0) { buf[n] = '-'; n = n + 1; v = -v; }
    if (v == 0) { buf[n] = '0'; n = n + 1; }
    else {
        char t[12];
        i = 0;
        while (v > 0 && i < 11) { t[i] = (char)('0' + v % 10); i = i + 1; v = v / 10; }
        while (i > 0) { i = i - 1; buf[n] = t[i]; n = n + 1; }
    }
    buf[n] = 0;
    return buf;
}

/* 用时 "m:ss" 写进 buf。 */
/* Write the elapsed time as "m:ss" into buf. */
void fmt_time(int ms, char* buf)
{
    int s = ms / 1000;
    int m = s / 60;
    char t[12];
    fmt_int(m, buf);
    t[0] = 0;
    fmt_int(s - m * 60, t);
    {
        int n = 0, i = 0;
        while (buf[n] != 0) n = n + 1;
        buf[n] = ':'; n = n + 1;
        if (s - m * 60 < 10) { buf[n] = '0'; n = n + 1; }
        i = 0;
        while (t[i] != 0) { buf[n] = t[i]; i = i + 1; n = n + 1; }
        buf[n] = 0;
    }
}

/* 该格与同行/列/宫里的同值重复? */
/* Does this cell duplicate its value in its row, column or box? */
int clash(int idx)
{
    int v = val[idx];
    int r, c, i, br, bc;
    if (v == 0) return 0;
    r = idx / N; c = idx - r * N;
    for (i = 0; i < N; i++) {
        if (i != c && val[r * N + i] == v) return 1;
        if (i != r && val[i * N + c] == v) return 1;
    }
    br = (r / 3) * 3; bc = (c / 3) * 3;
    for (i = 0; i < 9; i++) {
        int rr = br + i / 3;
        int cc = bc + i - (i / 3) * 3;
        if ((rr != r || cc != c) && val[rr * N + cc] == v) return 1;
    }
    return 0;
}

/* 全部填满且无冲突。 */
/* Fully filled with no conflict. */
int is_win(void)
{
    int i;
    for (i = 0; i < CELLS; i++) {
        if (val[i] == 0) return 0;
        if (clash(i)) return 0;
    }
    return 1;
}

/* ── 开新局 ─────────────────────────────────────────────── */
/* -- New game -- */

int perm[10];   /* 数字置换:d -> perm[d](0 不用) */
                /* Digit permutation: d -> perm[d] (0 unused) */

void new_game(void)
{
    int i, k, d, src;
    for (i = 1; i <= 9; i++) perm[i] = i;
    for (i = 9; i >= 2; i--) {
        int j = 1 + ui_math_rand(i);
        int t = perm[i]; perm[i] = perm[j]; perm[j] = t;
    }

    k = ui_math_rand(PUZZLES);
    for (i = 0; i < CELLS; i++) {
        src = 0;
        if (k == 0) src = pz0[i];
        else if (k == 1) src = pz1[i];
        else src = pz2[i];
        giv[i] = (src != 0) ? 1 : 0;
        val[i] = (src != 0) ? perm[src] : 0;
        hint[i] = 0;

        src = 0;
        if (k == 0) src = so0[i];
        else if (k == 1) src = so1[i];
        else src = so2[i];
        sol[i] = perm[src];
    }

    sel = -1; won = 0; tick = 0;
    t0 = ui_time_get_ms(); frozenMs = 0;
}

/* ── 渲染 ───────────────────────────────────────────────── */
/* -- Rendering -- */

/* 一套几何(绘制与命中**共用**,别再各算一遍 —— 小屏上两套公式分家就是点不中) */
/* One geometry shared by drawing and hit testing (two copies drift apart on small screens). */
static int G_hud, G_bx, G_by, G_side, G_kh, G_ky, G_by2, G_bh;

static void geo(void)
{
    int small;
    int kh;
    int bh;
    int gap;
    int avail;
    int side;

    small = (H < 420 || W < 360);
    G_hud = small ? 30 : 64;
    kh = small ? 28 : 56;
    bh = small ? 26 : 48;
    gap = small ? 6 : 14;
    avail = H - G_hud - 8 - kh - gap - bh - gap - 8;
    side = W - 24;
    if (side > avail) side = avail;
    if (side < 54) side = 54;
    side = (side / N) * N;
    G_side = side;
    G_bx = (W - side) / 2;
    G_by = G_hud + 8 + (avail - side) / 2;
    if (G_by < G_hud + 4) G_by = G_hud + 4;
    G_kh = kh;
    G_ky = G_by + side + gap;
    G_bh = bh;
    G_by2 = G_ky + kh + (small ? 4 : 12);
    if (G_by2 + bh > H - 8) G_by2 = H - 8 - bh;
}

void draw_key(int x, int y, int w, int h, char* label, int hot)
{
    int fs = h * 45 / 100;
    if (fs < 10) fs = 10;
    if (fs > 22) fs = 22;
    ui_2d_rect(x, y, w, h, hot ? C_BTN_HOT : C_BTN, 1, 0, 10);
    ui_2d_text_v(x + w / 2, y + h / 2, label, C_TEXT, fs,
                 VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, VML_FONT_BOLD);
}

void draw(void)
{
    int bx, by, side, cell, i, r, c, v, col;
    int kw, kh, ky, kx, bw, bh, by2, ms;
    char tb[32];

    ui_2d_clear(C_BG);

    /* 棋盘几何:绘制和命中读同一份全局(见 geo()) */
    geo();
    bx = G_bx; by = G_by; side = G_side;
    cell = side / N;

    /* HUD */
    ui_2d_rect(0, 0, W, G_hud, C_HUD, 1, 0, 0);
    ui_2d_text_v(16, G_hud / 2, g_lang == 0 ? "数独" : "Sudoku", C_TEXT, G_hud < 40 ? 15 : 24,
                 VML_ANCHOR_LEFT, VML_VANCHOR_MIDDLE, VML_FONT_BOLD);
    if (won) ms = frozenMs; else ms = ui_time_get_ms() - t0;
    fmt_time(ms, tb);
    ui_2d_text_v(W - 16, G_hud / 2, tb, C_ACCENT, G_hud < 40 ? 13 : 20,
                 VML_ANCHOR_RIGHT, VML_VANCHOR_MIDDLE, VML_FONT_BOLD);

    /* 棋盘底 + 格子 */
    /* Board background + cells */
    ui_2d_rect(bx - 3, by - 3, side + 6, side + 6, C_LINE2, 1, 0, 6);
    ui_2d_rect(bx, by, side, side, C_BOARD, 1, 0, 0);
    for (i = 0; i < CELLS; i++) {
        r = i / N; c = i - r * N;
        v = val[i];
        col = ((r / 3 + c / 3) % 2 == 0) ? C_CELL_A : C_CELL_B;
        if (i == sel) col = C_SEL;
        else if (sel >= 0 && v != 0 && val[sel] != 0 && v == val[sel]) col = C_SAME;
        ui_2d_rect(bx + c * cell + 1, by + r * cell + 1, cell - 2, cell - 2, col, 1, 0, 2);
        if (v != 0) {
            if (clash(i)) col = C_BAD;
            else if (giv[i]) col = C_GIVEN;
            else if (hint[i]) col = C_HINT;
            else col = C_PLAYER;
            fmt_int(v, tb);
            ui_2d_text_v(bx + c * cell + cell / 2, by + r * cell + cell / 2, tb, col,
                         cell * 5 / 9, VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE,
                         giv[i] ? VML_FONT_BOLD : 0);
        }
    }

    /* 宫线:3×3 粗线,其余细线 */
    /* Box lines: thick every 3rd, thin elsewhere */
    for (i = 0; i <= N; i++) {
        int x = bx + i * cell;
        int y = by + i * cell;
        int lw = (i % 3 == 0) ? 3 : 1;
        int lc = (i % 3 == 0) ? 0xFF5B6B85 : 0xFF2C3446;
        ui_2d_line(x, by, x, by + side, lc, lw);
        ui_2d_line(bx, y, bx + side, y, lc, lw);
    }

    /* 键盘:1-9 一排 */
    /* Keypad: one row of 1-9 */
    kx = 12;
    kw = (W - 24) / 9;
    kh = G_kh;
    ky = G_ky;
    for (i = 1; i <= 9; i++) {
        fmt_int(i, tb);
        draw_key(kx + (i - 1) * kw, ky, kw - 4, kh, tb, 0);
    }

    /* 底部三键:擦除 / 提示 / 新局 */
    /* Bottom row: erase / hint / new game */
    bw = (W - 24) / 3;
    bh = G_bh;
    by2 = G_by2;
    draw_key(12, by2, bw - 6, bh, g_lang == 0 ? "擦除" : "Erase", 0);
    draw_key(12 + bw, by2, bw - 6, bh, g_lang == 0 ? "提示" : "Hint", 0);
    draw_key(12 + bw * 2, by2, bw - 6, bh, g_lang == 0 ? "新局" : "New", 0);

    /* 通关横幅 */
    /* Win banner */
    if (won) {
        ui_2d_rect(0, H / 2 - 52, W, 104, 0xCC0B1220, 1, 0, 0);
        ui_2d_text_v(W / 2, H / 2 - 18, g_lang == 0 ? "通关!" : "Solved!",
                     C_ACCENT, 32, VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, VML_FONT_BOLD);
        fmt_time(frozenMs, tb);
        ui_2d_text_v(W / 2, H / 2 + 22, tb, C_TEXT, 20,
                     VML_ANCHOR_CENTER, VML_VANCHOR_MIDDLE, 0);
    }
}

/* ── 入口 ───────────────────────────────────────────────── */
/* -- Entry point -- */

int main(void)
{
    int m[4];
    int t;
    /* ⚠ 一次物理点击 = TOUCHDOWN + MOUSEDOWN 两条(MAUI 实测);两条都处理会重复执行一次动作
       (比如「新局」连换两题)。记住触摸坐标,紧跟其后同坐标的 MOUSEDOWN 丢掉。 */
    int lastX = -1, lastY = -1, sawTouch = 0;
    int bx, by, side, cell, kw, kh, ky, kx, bw, bh, by2;
    int hitBoard, hitKey, hitBottom;

    g_lang = ui_scr_get_language();
    /* 触屏游戏:不要手柄区(多点地方画盘面),锁竖屏 —— 与 plane.c 同一口径 */
    /* Touch game: no gamepad area (more room for the board), locked to portrait -- same as plane.c */
    ui_win_open_ex(g_lang == 0 ? "数独" : "Sudoku", 0, 0, VML_WIN_PORTRAIT, VML_WIN_NO_GAMEPAD);
    W = ui_scr_get_w();
    H = ui_scr_get_h();
    ui_scr_set_keep_on(1);

    new_game();

    while (ui_win_is_closed() == 0) {
        /* 布局每帧重算;**与 draw 共用 geo()**,不再各算一遍 */
        geo();
        bx = G_bx; by = G_by; side = G_side; cell = side / N;
        kx = 12; kw = (W - 24) / 9; kh = G_kh; ky = G_ky;
        bw = (W - 24) / 3; bh = G_bh; by2 = G_by2;

        draw();
        ui_2d_present();

        t = ui_msg_wait(m, 100);
        if (t == VML_MSG_WINDOWCLOSE) break;
        if (t == VML_MSG_TOUCHDOWN) { lastX = m[1]; lastY = m[2]; sawTouch = 1; }
        else if (t == VML_MSG_MOUSEDOWN)
        {
            if (sawTouch && m[1] == lastX && m[2] == lastY) { sawTouch = 0; continue; }
        }
        else continue;

        hitBoard = 0; hitKey = 0; hitBottom = 0;
        if (m[1] >= bx && m[1] < bx + side && m[2] >= by && m[2] < by + side)
            hitBoard = 1;
        else if (m[2] >= ky && m[2] < ky + kh && m[1] >= kx && m[1] < kx + kw * 9)
            hitKey = 1;
        else if (m[2] >= by2 && m[2] < by2 + bh)
            hitBottom = 1;

        if (won) {
            if (hitBottom) { new_game(); }
            continue;
        }

        if (hitBoard) {
            int c = (m[1] - bx) / cell;
            int r = (m[2] - by) / cell;
            sel = r * N + c;
            ui_audio_beep(880, 40);
        } else if (hitKey) {
            int d = (m[1] - kx) / kw + 1;
            if (d < 1) d = 1;
            if (d > 9) d = 9;
            if (sel >= 0 && !giv[sel]) {
                val[sel] = d;
                hint[sel] = 0;
                ui_audio_beep(660, 45);
                if (is_win()) {
                    won = 1;
                    frozenMs = ui_time_get_ms() - t0;
                    ui_audio_beep(1047, 260);
                    ui_vibrate_simple(120, 2);
                }
            }
        } else if (hitBottom) {
            int which = (m[1] - 12) / bw;
            if (which < 0) which = 0;
            if (which > 2) which = 2;
            if (which == 0) {                       /* 擦除 / Erase */
                if (sel >= 0 && !giv[sel]) { val[sel] = 0; hint[sel] = 0; ui_audio_beep(440, 40); }
            } else if (which == 1) {                /* 提示 / Hint */
                if (sel >= 0 && !giv[sel] && val[sel] != sol[sel]) {
                    val[sel] = sol[sel];
                    hint[sel] = 1;
                    ui_audio_beep(784, 60);
                    if (is_win()) {
                        won = 1;
                        frozenMs = ui_time_get_ms() - t0;
                        ui_audio_beep(1047, 260);
                        ui_vibrate_simple(120, 2);
                    }
                }
            } else {                                /* 新局 / New game */
                new_game();
                ui_audio_beep(523, 80);
            }
        }
        tick = tick + 1;
    }

    ui_scr_set_keep_on(0);
    return 0;
}