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

rust/app/g2048.rs · 12010 字节 · 下载原文

▶ 在浏览器里试玩

// 2048 —— 用 **Rust** 写的手机小游戏(合并 / 数字)
// 2048 — a small phone game written in **Rust** (merge / numbers)
//
// 玩法(与 `Examples/c/app/game2048.c` / `Examples/python/app/game2048.py` 同一套):
// Gameplay (same rules as the C / Python versions):
//   · 4×4 棋盘,方向键 / 点屏幕四边往一个方向滑;
//   · a 4x4 board; arrow keys / tapping one of the four screen edges slide everything that way;
//   · 相同数字相撞合成两倍、得分加上合成值,每滑一次冒一个新数字(10% 是 4);
//   · equal numbers merge and score the merged value; each slide spawns a new tile (4 with 10% odds);
//   · 到 2048 算赢(还能继续),没空格且四邻无相等算输;ESC / R 重开。
//   · reaching 2048 wins (you may keep playing); no empty cell and no adjacent equal pair loses; ESC / R restarts.
//
// ## 合并的**先后**容易写错
// ## The **merge order** is easy to get wrong
//
// 一次滑动里每个块只许合并一次(`4 4 4 4` 滑一次是 `8 8`,不是 `16`),所以从滑动方向的**最远端**往回收。
// Each tile may merge only once per slide (`4 4 4 4` becomes `8 8`, not `16`), so collapse from the far end.
//
// ## Rust 这一路的写法约束(见 `Examples/rust/app/snake.rs` 文件头)
// ## Style constraints on this Rust path (see the header of `Examples/rust/app/snake.rs`)
//
//   · **全部状态放 `main` 的局部变量**,循环一律 `while`;**循环变量在 `main` 顶部声明一次**;
//   · **all state lives in locals of `main`**, loops are always `while`; **loop variables are
//     declared once at the top of `main`**;
//   · **全程序只养一条 Vec**(第二处分配会盖掉先前的数据)⇒ 棋盘 16 格与两个行缓冲都挤在同一条里:
//   · **exactly one Vec per program** (a second allocation overwrites the first) => the 16-cell board
//     and the two line buffers share that one Vec:
//     0..15 棋盘,16..19 合并缓冲,20..23 原值快照;
//     0..15 board, 16..19 merge buffer, 20..23 old-values snapshot;
//   · 数字转字符串走库里的 `int_to_str`(共享静态缓冲,取一次立刻用掉);颜色写负数十进制。
//   · numbers go through the library's `int_to_str` (one shared static buffer; take and use it at once);
//     colours are negative decimals.
//
// 跑法 —— 手机:`vml run examples/rust/g2048.rs`
// How to run — on the phone: `vml run examples/rust/g2048.rs`
// 跑法 —— 桌面:`vmlcli Examples/rust/g2048.rs --screen 480x640 --frames /tmp/fr`
// How to run — on the desktop: `vmlcli Examples/rust/g2048.rs --screen 480x640 --frames /tmp/fr`

#include <vml_ui.rs>
use vml_ui::*;

fn main() {
    let mut lang = ui_scr_get_language();
    let mut sw = 360;
    let mut sh = 620;
    let mut cell = 80;
    let mut ox = 20;
    let mut oy = 120;
    let mut score = 0;
    let mut won = 0;
    let mut lost = 0;
    let mut seed = 20261;
    let mut frames = 0;
    let mut i = 0;
    let mut k = 0;
    let mut d = 0;
    let mut j = 0;
    let mut n = 0;
    let mut out = 0;
    let mut pick = 0;
    let mut changed = 0;
    let mut t = 0;
    let mut tx = 0;
    let mut ty = 0;
    let mut done = 0;
    let mut tid = 0;

    let c_bg = -15724520;        // 0xFF101018
    let c_empty = -15066588;     // 0xFF1A1A24
    let c_text = -1513232;       // 0xFFE8E8F0
    let c_dim = -6643536;        // 0xFF9AA0B0

    // 一条 Vec:0..15 棋盘,16..19 合并缓冲,20..23 原值快照
    // One Vec: 0..15 board, 16..19 merge buffer, 20..23 old-values snapshot
    let mut b: Vec<i32> = vec![0];
    i = 0;
    while i < 24 {
        b.push(0);
        i = i + 1;
    }

    if lang == 0 { ui_win_open("2048", 0, 0); }
    else { ui_win_open("2048", 0, 0); }
    ui_scr_set_keep_on(1);

    sw = ui_scr_get_w();
    sh = ui_scr_get_h();
    if sw <= 0 { sw = 360; }
    if sh <= 0 { sh = 620; }
    let mut side = sw - 20;
    if sw >= sh - 140 { side = sh - 170; }
    cell = side / 4;
    if cell < 6 { cell = 6; }
    ox = (sw - 4 * cell) / 2;
    oy = 120;

    // 开局:两粒
    // Opening: two tiles
    i = 0;
    while i < 16 {
        b[i] = 0;
        i = i + 1;
    }
    score = 0;
    won = 0;
    lost = 0;
    seed = 20261;
    j = 0;
    while j < 2 {
        seed = (seed * 1103 + 12345) % 32768;
        pick = (seed / 256) % 16;
        while b[pick] != 0 {
            seed = (seed * 1103 + 12345) % 32768;
            pick = (seed / 256) % 16;
        }
        b[pick] = 2;
        j = j + 1;
    }

    tid = ui_timer_set(50, 0);

    while done == 0 {
        if ui_win_is_closed() != 0 { done = 1; }
        if done != 0 { break; }

        t = ui_msg_fetch_wait(0);
        if t == 10 { done = 1; }

        d = -1;
        if t == 1 {
            k = ui_msg_get_a();
            if k == 37 { d = 0; }
            if k == 39 { d = 1; }
            if k == 38 { d = 2; }
            if k == 40 { d = 3; }
            if k == 27 || k == 82 {
                i = 0;
                while i < 16 {
                    b[i] = 0;
                    i = i + 1;
                }
                score = 0;
                won = 0;
                lost = 0;
                seed = 20261;
                b[0] = 2;
                b[5] = 2;
            }
        }
        if t == 6 || t == 4 {
            tx = ui_msg_get_a();
            ty = ui_msg_get_b();
            let dl = tx;
            let dr = sw - tx;
            let dt = ty;
            let db = sh - ty;
            if dl <= dr && dl <= dt && dl <= db { d = 0; }
            else if dr <= dt && dr <= db { d = 1; }
            else if dt <= db { d = 2; }
            else { d = 3; }
        }

        if d >= 0 && lost == 0 {
            changed = 0;
            k = 0;
            while k < 4 {
                i = 0;
                while i < 4 {
                    if d == 0 { b[16 + i] = b[k * 4 + i]; }
                    if d == 1 { b[16 + i] = b[k * 4 + (3 - i)]; }
                    if d == 2 { b[16 + i] = b[i * 4 + k]; }
                    if d == 3 { b[16 + i] = b[(3 - i) * 4 + k]; }
                    b[20 + i] = b[16 + i];
                    i = i + 1;
                }
                // 收拢
                // Collapse
                n = 0;
                i = 0;
                while i < 4 {
                    if b[16 + i] != 0 {
                        b[16 + n] = b[16 + i];
                        n = n + 1;
                    }
                    i = i + 1;
                }
                i = n;
                while i < 4 {
                    b[16 + i] = 0;
                    i = i + 1;
                }
                // 合并
                // Merge
                out = 0;
                i = 0;
                while i < n {
                    if i + 1 < n && b[16 + i] == b[16 + i + 1] {
                        b[16 + out] = b[16 + i] * 2;
                        score = score + b[16 + i] * 2;
                        if b[16 + i] * 2 >= 2048 { won = 1; }
                        i = i + 2;
                    } else {
                        b[16 + out] = b[16 + i];
                        i = i + 1;
                    }
                    out = out + 1;
                }
                i = out;
                while i < 4 {
                    b[16 + i] = 0;
                    i = i + 1;
                }
                i = 0;
                while i < 4 {
                    if b[16 + i] != b[20 + i] { changed = 1; }
                    i = i + 1;
                }
                // 写回
                // Write back
                i = 0;
                while i < 4 {
                    if d == 0 { b[k * 4 + i] = b[16 + i]; }
                    if d == 1 { b[k * 4 + (3 - i)] = b[16 + i]; }
                    if d == 2 { b[i * 4 + k] = b[16 + i]; }
                    if d == 3 { b[(3 - i) * 4 + k] = b[16 + i]; }
                    i = i + 1;
                }
                k = k + 1;
            }
            if changed != 0 {
                // 冒一个新数字
                // Spawn one new tile
                n = 0;
                i = 0;
                while i < 16 {
                    if b[i] == 0 { n = n + 1; }
                    i = i + 1;
                }
                if n > 0 {
                    seed = (seed * 1103 + 12345) % 32768;
                    pick = (seed / 256) % n;
                    i = 0;
                    while i < 16 {
                        if b[i] == 0 {
                            if pick == 0 {
                                seed = (seed * 1103 + 12345) % 32768;
                                if (seed / 256) % 10 == 0 { b[i] = 4; }
                                else { b[i] = 2; }
                                i = 16;
                            } else {
                                pick = pick - 1;
                            }
                        }
                        if i < 16 { i = i + 1; }
                    }
                }
                // 还能不能走
                // Any move left?
                n = 0;
                i = 0;
                while i < 16 {
                    if b[i] == 0 { n = 1; }
                    i = i + 1;
                }
                i = 0;
                while i < 15 {
                    if i % 4 != 3 && b[i] == b[i + 1] { n = 1; }
                    if i + 4 < 16 && b[i] == b[i + 4] { n = 1; }
                    i = i + 1;
                }
                if n == 0 { lost = 1; }
            }
        }

        ui_2d_clear(c_bg);
        i = 0;
        while i < 16 {
            let px = ox + (i % 4) * cell;
            let py = oy + (i / 4) * cell;
            let v = b[i];
            if v == 0 {
                ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, c_empty, 1, 0, 6);
            } else {
                if v == 2 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -14013898, 1, 0, 6); }
                else if v == 4 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -12960184, 1, 0, 6); }
                else if v == 8 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -11890471, 1, 0, 6); }
                else if v == 16 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -11409298, 1, 0, 6); }
                else if v == 32 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -2509750, 1, 0, 6); }
                else if v == 64 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -2069424, 1, 0, 6); }
                else if v == 128 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -2069336, 1, 0, 6); }
                else if v == 256 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -6591248, 1, 0, 6); }
                else if v == 512 { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -11871802, 1, 0, 6); }
                else { ui_2d_rect(px + 2, py + 2, cell - 4, cell - 4, -4145088, 1, 0, 6); }
                let sz = cell / 3;
                ui_2d_text(px + cell / 2, py + cell / 2 + sz / 3, int_to_str(v), c_text, sz, 1);
            }
            i = i + 1;
        }

        ui_2d_text(10, 24, int_to_str(score), c_text, 18, 0);
        if lang == 0 { ui_2d_text(10, 48, "得分", c_dim, 10, 0); }
        else { ui_2d_text(10, 48, "score", c_dim, 10, 0); }

        if lost != 0 {
            if lang == 0 { ui_2d_text(sw / 2, oy + 4 * cell + 28, "没路可走了,ESC / R 重开", c_text, 14, 1); }
            else { ui_2d_text(sw / 2, oy + 4 * cell + 28, "No moves left - ESC / R to restart", c_text, 14, 1); }
        } else {
            if lang == 0 { ui_2d_text(sw / 2, oy + 4 * cell + 28, "方向键 / 点屏幕四边滑动", c_dim, 11, 1); }
            else { ui_2d_text(sw / 2, oy + 4 * cell + 28, "Arrows / tap a screen edge to slide", c_dim, 11, 1); }
        }
        ui_2d_present();

        frames = frames + 1;
        if frames >= 20000 { done = 1; }
    }

    ui_timer_kill(tid);
    ui_scr_set_keep_on(0);
    ui_win_close();
}