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

kotlin/app/g2048.kt · 10887 字节 · 下载原文

▶ 在浏览器里试玩

// 2048 —— 用 **Kotlin** 写的手机小游戏(合并 / 数字)
// 2048 — a small phone game written in **Kotlin** (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 of the slide direction.
//
// ## 这一份用到的 Kotlin 特性
// ## Kotlin features used here
//
//   · `const val` 颜色常量与**顶层 `var` 状态**;`IntArray(16)` 平铺棋盘;
//   · `const val` colour constants and **file-level `var` state**; a flat `IntArray(16)` board;
//   · **字符串模板**(`"$gtScore"`)画得分与格值;
//   · **string templates** (`"$gtScore"`) for the score and tile values.
//
// 跑法 —— 手机:`vml run examples/kotlin/g2048.kt`
// How to run — on the phone: `vml run examples/kotlin/g2048.kt`
// 跑法 —— 桌面:`vmlcli Examples/kotlin/g2048.kt --screen 480x640 --frames /tmp/fr`
// How to run — on the desktop: `vmlcli Examples/kotlin/g2048.kt --screen 480x640 --frames /tmp/fr`

// ── 显式引用:下面用到的 `ui_*` 来自共享库 vmlui.vml ──────────────────
// ── Explicit reference: the `ui_*` used below come from the shared library vmlui.vml ──
// ⚠ `.*` 必须有:`import vmlui`(无 `.*`)会被 `ExtractImports` 的正则**静默忽略**。
// ⚠ The `.*` is required: `import vmlui` (without `.*`) is silently ignored.
#include <vml_ui.kt>
import vmlui.*

const val GT_MAX_FRAMES = 20000

const val GT_BG = 0xFF101018
const val GT_EMPTY = 0xFF1A1A24
const val GT_TEXT = 0xFFE8E8F0
const val GT_DIM = 0xFF9AA0B0

// 状态(顶层 var,Kotlin 这一路可用)
// State (file-level vars; reliable on this Kotlin path)
var gtScore = 0
var gtWon = 0
var gtLost = 0
var gtSeed = 20261
var gtCell = 80
var gtOx = 20
var gtOy = 120
var gtW = 360
var gtH = 620
var gtLang = 0
var gtFrames = 0
// 矮屏(240x240 一类)用压缩排版
// Compact layout flag for short screens (240x240 etc.)
var gtCompact = 0

// 棋盘 16 格(4×4 平铺)+ 行缓冲
// Board: 16 slots (4x4 flat) + a line buffer
var gtBoard = IntArray(16)
var gtLine = IntArray(8)
var gtOld = IntArray(8)

fun gtTr(zh: String, en: String): String {
    if (gtLang == 0) return zh
    return en
}

fun gtRnd(n: Int): Int {
    gtSeed = (gtSeed * 1103 + 12345) % 32768
    return (gtSeed / 256) % n
}

fun gtLayout() {
    gtW = ui_scr_get_w()
    gtH = ui_scr_get_h()
    if (gtW <= 0) gtW = 360
    if (gtH <= 0) gtH = 620
    gtCompact = 0
    var top = 120
    var bottom = 60
    if (gtH < 420) {
        gtCompact = 1
        top = 64
        bottom = 40
    }
    // 棋盘同时受宽、高(扣掉顶部 HUD 与底部提示)约束
    // The board respects both width and height (minus the top HUD and the bottom hint)
    var side = gtW - 20
    var sideH = gtH - top - bottom
    if (sideH < side) side = sideH
    gtCell = side / 4
    if (gtCell < 6) gtCell = 6
    gtOx = (gtW - 4 * gtCell) / 2
    gtOy = top
}

fun gtSpawn() {
    var n = 0
    var i = 0
    while (i < 16) {
        if (gtBoard[i] == 0) n = n + 1
        i = i + 1
    }
    if (n == 0) { return }
    var pick = gtRnd(n)
    i = 0
    while (i < 16) {
        if (gtBoard[i] == 0) {
            if (pick == 0) {
                if (gtRnd(10) == 0) gtBoard[i] = 4
                else gtBoard[i] = 2
                i = 16
            } else {
                pick = pick - 1
            }
        }
        if (i < 16) i = i + 1
    }
}

fun gtNewGame() {
    var i = 0
    while (i < 16) {
        gtBoard[i] = 0
        i = i + 1
    }
    gtScore = 0
    gtWon = 0
    gtLost = 0
    gtFrames = 0
    gtSpawn()
    gtSpawn()
}

fun gtReadLine(d: Int, k: Int) {
    var i = 0
    while (i < 4) {
        if (d == 0) gtLine[i] = gtBoard[k * 4 + i]
        else if (d == 1) gtLine[i] = gtBoard[k * 4 + (3 - i)]
        else if (d == 2) gtLine[i] = gtBoard[i * 4 + k]
        else gtLine[i] = gtBoard[(3 - i) * 4 + k]
        i = i + 1
    }
}

fun gtWriteLine(d: Int, k: Int) {
    var i = 0
    while (i < 4) {
        if (d == 0) gtBoard[k * 4 + i] = gtLine[i]
        else if (d == 1) gtBoard[k * 4 + (3 - i)] = gtLine[i]
        else if (d == 2) gtBoard[i * 4 + k] = gtLine[i]
        else gtBoard[(3 - i) * 4 + k] = gtLine[i]
        i = i + 1
    }
}

// 滑一次:从远端收拢 + 每个块只合并一次;有变化返回 1
// Slide once: collapse from the far end and merge each tile at most once; returns 1 on change
fun gtSlide(d: Int): Int {
    var changed = 0
    var k = 0
    while (k < 4) {
        gtReadLine(d, k)
        var i = 0
        while (i < 4) {
            gtOld[i] = gtLine[i]
            i = i + 1
        }
        var n = 0
        i = 0
        while (i < 4) {
            if (gtLine[i] != 0) {
                gtLine[n] = gtLine[i]
                n = n + 1
            }
            i = i + 1
        }
        i = n
        while (i < 4) {
            gtLine[i] = 0
            i = i + 1
        }
        var out = 0
        i = 0
        while (i < n) {
            if (i + 1 < n && gtLine[i] == gtLine[i + 1]) {
                gtLine[out] = gtLine[i] * 2
                gtScore = gtScore + gtLine[i] * 2
                if (gtLine[i] * 2 >= 2048) gtWon = 1
                i = i + 2
            } else {
                gtLine[out] = gtLine[i]
                i = i + 1
            }
            out = out + 1
        }
        i = out
        while (i < 4) {
            gtLine[i] = 0
            i = i + 1
        }
        i = 0
        while (i < 4) {
            if (gtLine[i] != gtOld[i]) changed = 1
            i = i + 1
        }
        gtWriteLine(d, k)
        k = k + 1
    }
    return changed
}

fun gtCanMove(): Int {
    var i = 0
    while (i < 16) {
        if (gtBoard[i] == 0) return 1
        i = i + 1
    }
    var x = 0
    while (x < 4) {
        var y = 0
        while (y < 4) {
            if (x + 1 < 4 && gtBoard[x * 4 + y] == gtBoard[(x + 1) * 4 + y]) return 1
            if (y + 1 < 4 && gtBoard[x * 4 + y] == gtBoard[x * 4 + y + 1]) return 1
            y = y + 1
        }
        x = x + 1
    }
    return 0
}

fun gtTileColor(v: Int): Int {
    if (v == 0) return GT_EMPTY
    if (v == 2) return 0xFF2A2A36
    if (v == 4) return 0xFF3A3A48
    if (v == 8) return 0xFF4A90D9
    if (v == 16) return 0xFF51E86E
    if (v == 32) return 0xFFD9B44A
    if (v == 64) return 0xFFE06C50
    if (v == 128) return 0xFFE06CA8
    if (v == 256) return 0xFF9B6CF0
    if (v == 512) return 0xFF4AD9C6
    if (v == 1024) return 0xFF6C7BF0
    return 0xFFC0C040
}

fun gtNumSize(v: Int): Int {
    if (v >= 1000) return gtCell / 4
    if (v >= 100) return gtCell / 3
    return gtCell / 2
}

fun gtDraw() {
    ui_2d_clear(GT_BG)

    var x = 0
    while (x < 4) {
        var y = 0
        while (y < 4) {
            var v = gtBoard[x * 4 + y]
            var px = gtOx + x * gtCell
            var py = gtOy + y * gtCell
            ui_2d_rect(px + 2, py + 2, gtCell - 4, gtCell - 4, gtTileColor(v), 1, 0, 6)
            if (v != 0) {
                ui_2d_text(px + gtCell / 2, py + gtCell / 2 + gtNumSize(v) / 3,
                    "$v", GT_TEXT, gtNumSize(v), VML_ANCHOR_CENTER)
            }
            y = y + 1
        }
        x = x + 1
    }

    ui_2d_text(10, 24, "$gtScore", GT_TEXT, 18, VML_ANCHOR_LEFT)
    ui_2d_text(10, 48, gtTr("得分", "score"), GT_DIM, 10, VML_ANCHOR_LEFT)

    if (gtWon != 0) {
        ui_2d_text(gtW / 2, 24, gtTr("2048 达成!还能继续", "2048! keep going"), 0xFFD9B44A, 14, VML_ANCHOR_CENTER)
    }
    // 矮屏把提示行贴紧棋盘、字号缩小
    // On short screens the hint hugs the board with a smaller font
    var hintDy = 28
    var hintFs = 11
    var lostFs = 14
    if (gtCompact == 1) { hintDy = 16; hintFs = 10; lostFs = 11 }
    if (gtLost != 0) {
        ui_2d_text(gtW / 2, gtOy + 4 * gtCell + hintDy, gtTr("没路可走了,ESC / R 重开", "No moves left - ESC / R to restart"),
            GT_TEXT, lostFs, VML_ANCHOR_CENTER)
    } else if (gtWon == 0) {
        ui_2d_text(gtW / 2, gtOy + 4 * gtCell + hintDy, gtTr("方向键 / 点屏幕四边滑动", "Arrows / tap a screen edge to slide"),
            GT_DIM, hintFs, VML_ANCHOR_CENTER)
    }
    ui_2d_present()
}

fun gtMove(d: Int) {
    if (gtLost != 0) { return }
    var changed = gtSlide(d)
    if (changed != 0) {
        gtSpawn()
        if (gtCanMove() == 0) gtLost = 1
    }
}

fun main() {
    gtLang = ui_scr_get_language()
    ui_win_open(gtTr("2048", "2048"), 0, 0)
    ui_scr_set_keep_on(1)

    gtLayout()
    gtNewGame()
    gtDraw()

    var tid = ui_timer_set(50, 1)
    var done = 0
    while (done == 0 && ui_win_is_closed() == 0) {
        var t = ui_msg_fetch_wait(50)
        if (t == 10) { break }

        if (t == 1) {
            var k = ui_msg_get_a()
            if (k == 27 || k == 82) { gtNewGame() }
            else if (k == 37) { gtMove(0) }
            else if (k == 39) { gtMove(1) }
            else if (k == 38) { gtMove(2) }
            else if (k == 40) { gtMove(3) }
            gtDraw()
            continue
        }

        if (t == 6 || t == 4) {
            var tx = ui_msg_get_a()
            var ty = ui_msg_get_b()
            var dl = tx
            var dr = gtW - tx
            var dt = ty
            var db = gtH - ty
            if (dl <= dr && dl <= dt && dl <= db) { gtMove(0) }
            else if (dr <= dt && dr <= db) { gtMove(1) }
            else if (dt <= db) { gtMove(2) }
            else { gtMove(3) }
            gtDraw()
            continue
        }

        if (t == 11) { gtLayout(); gtDraw(); continue }

        if (t == 9) {
            gtFrames = gtFrames + 1
            if (gtFrames >= GT_MAX_FRAMES) done = 1
            gtDraw()
            continue
        }
    }

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