#include <vml_ui.r>
# 扫雷 —— 用 **R** 写的手机小游戏（网格推理）
# Minesweeper -- a small phone game written in **R**
#
# 玩法：9×9 共 10 颗雷；点格子翻开，数字是周围 8 格的雷数；翻到 0 会
# 连锁展开；顶部按钮切到「插旗」模式再点就是标雷；把所有非雷格子
# 翻开即通关，踩到雷就结束；ESC 重开。
#
# 跑法 —— 手机：vml run examples/r/minesweeper.r
# 跑法 —— 桌面：vmlcli Examples/r/minesweeper.r --screen 480x640 --frames /tmp/fr

c_bg <- -15724520
c_txt <- -1513232
c_dim <- -6643536
c_ok <- -11409298
c_no <- -2069424
c_cover <- -14013902
c_open <- -15066590
c_flag <- -2516442

count_adj <- function(cx, cy) {
    n <- 0
    dx <- -1
    while (dx <= 1) {
        dy <- -1
        while (dy <= 1) {
            if (dx != 0 || dy != 0) {
                nx <- cx + dx
                ny <- cy + dy
                if (nx >= 0) {
                    if (ny >= 0) {
                        if (nx < 9) {
                            if (ny < 9) {
                                idx <- nx * 9 + ny + 1
                                if (mine[idx] == 1) { n <- n + 1 }
                            }
                        }
                    }
                }
            }
            dy <- dy + 1
        }
        dx <- dx + 1
    }
    return(n)
}

k <- ui_win_open("扫雷", 0, 0)
k <- ui_scr_set_keep_on(1)
w <- ui_scr_get_w()
h <- ui_scr_get_h()
if (w <= 0) { w <- 360 }
if (h <= 0) { h <- 620 }

# 布局按画布现算：字号随 min(W,H) 缩放，9×9 棋盘吃掉中间剩余高度。
mn <- w
if (h < mn) { mn <- h }
scn <- as.integer(mn * 100 / 360)
if (scn < 55) { scn <- 55 }
if (scn > 240) { scn <- 240 }
pad <- as.integer(mn / 20)
if (pad < 6) { pad <- 6 }
if (pad > 24) { pad <- 24 }
f_small <- as.integer(11 * scn / 100)
if (f_small < 8) { f_small <- 8 }
f_btn <- as.integer(12 * scn / 100)
if (f_btn < 8) { f_btn <- 8 }
f_num <- as.integer(15 * scn / 100)
if (f_num < 8) { f_num <- 8 }
f_stat <- as.integer(14 * scn / 100)
if (f_stat < 8) { f_stat <- 8 }
status_y <- pad + as.integer(f_small / 2)
btn_y <- pad + f_small + as.integer(pad / 2)
btn_h <- f_btn + pad
if (btn_h < 22) { btn_h <- 22 }
btn_w <- as.integer(w * 46 / 100)
if (btn_w < 70) { btn_w <- 70 }
if (btn_w > 240) { btn_w <- 240 }
gtop <- btn_y + btn_h + pad
avail <- h - gtop - pad
cellw <- as.integer((w - 2 * pad) / 9)
ch2 <- as.integer(avail / 9)
if (ch2 < cellw) { cellw <- ch2 }
if (cellw < 6) { cellw <- 6 }
ox <- as.integer((w - cellw * 9) / 2)
oy <- gtop
dg <- as.integer(f_num * 6 / 10)
if (dg < 4) { dg <- 4 }
frames <- 0
opened <- 0
dead <- 0
won <- 0
flagm <- 0
seed <- 1234

mine <- rep(0, 81)
opn <- rep(0, 81)
flag <- rep(0, 81)
nbr <- rep(0, 81)
qx <- rep(0, 81)
qy <- rep(0, 81)

mpos <- c(3, 12, 21, 30, 39, 48, 57, 66, 75, 84)
i <- 1
while (i <= 10) {
    mi <- mpos[i]
    mine[mi] <- 1
    i <- i + 1
}
tid <- ui_timer_set(80, 0)

while (frames < 4000) {
    k <- ui_2d_clear(c_bg)
    if (flagm == 0) {
        k <- ui_2d_rect(pad, btn_y, btn_w, btn_h, c_cover, 1, 0, 8)
        k <- ui_2d_text(pad + as.integer((btn_w - 4 * f_btn) / 2), btn_y + as.integer(btn_h / 2), "翻开模式", c_txt, f_btn, 0)
    } else {
        k <- ui_2d_rect(pad, btn_y, btn_w, btn_h, c_flag, 1, 0, 8)
        k <- ui_2d_text(pad + as.integer((btn_w - 4 * f_btn) / 2), btn_y + as.integer(btn_h / 2), "插旗模式", c_bg, f_btn, 0)
    }
    k <- ui_2d_text(w - pad - as.integer(f_stat * 12 / 10), btn_y + as.integer(btn_h / 2), sprintf("%d", opened), c_dim, f_stat, 0)

    x <- 0
    while (x < 9) {
        y <- 0
        while (y < 9) {
            idx <- x * 9 + y + 1
            px <- ox + x * cellw
            py <- oy + y * cellw
            if (opn[idx] == 1) {
                if (mine[idx] == 1) {
                    k <- ui_2d_rect(px + 1, py + 1, cellw - 2, cellw - 2, c_no, 1, 0, 2)
                } else {
                    k <- ui_2d_rect(px + 1, py + 1, cellw - 2, cellw - 2, c_open, 1, 0, 2)
                    if (nbr[idx] > 0) {
                        k <- ui_2d_text(px + as.integer((cellw - dg) / 2), py + as.integer(cellw / 2), sprintf("%d", nbr[idx]), c_txt, f_num, 0)
                    }
                }
            } else {
                k <- ui_2d_rect(px + 1, py + 1, cellw - 2, cellw - 2, c_cover, 1, 0, 2)
                if (flag[idx] == 1) {
                    k <- ui_2d_circle(px + as.integer(cellw / 2), py + as.integer(cellw / 2), as.integer(cellw / 4), c_flag, 1, 0)
                }
            }
            y <- y + 1
        }
        x <- x + 1
    }

    if (dead == 1) {
        k <- ui_2d_text(pad, status_y, "踩雷了，ESC 重来", c_no, f_small, 0)
    } else if (won == 1) {
        k <- ui_2d_text(pad, status_y, "扫清了！ESC 再来", c_ok, f_small, 0)
    } else {
        k <- ui_2d_text(pad, status_y, "点格子翻开 / 点顶部按钮插旗", c_dim, f_small, 0)
    }
    k <- ui_2d_present()

    msg <- ui_msg_fetch_wait(0)
    if (msg == 10) { frames <- 4000 }
    if (msg == 6) {
        ax <- ui_msg_get_a()
        ay <- ui_msg_get_b()
        if (ax >= pad) {
            if (ax <= pad + btn_w) {
                if (ay >= btn_y) {
                    if (ay <= btn_y + btn_h) {
                        if (flagm == 0) { flagm <- 1 } else { flagm <- 0 }
                    } else {
                        ax <- -1
                    }
                } else {
                    ax <- -1
                }
            }
        }
        if (ax >= ox) {
            if (ay >= oy) {
                x <- as.integer((ax - ox) / cellw)
                y <- as.integer((ay - oy) / cellw)
                if (x < 9) {
                    if (y < 9) {
                        if (dead == 0) {
                            if (won == 0) {
                                idx <- x * 9 + y + 1
                                if (flagm == 1) {
                                    if (opn[idx] == 0) {
                                        if (flag[idx] == 1) { flag[idx] <- 0 } else { flag[idx] <- 1 }
                                    }
                                } else {
                                    if (opn[idx] == 0) {
                                        if (flag[idx] == 0) {
                                            qx[1] <- x
                                            qy[1] <- y
                                            head <- 1
                                            tail <- 1
                                            while (head <= tail) {
                                                cx <- qx[head]
                                                cy <- qy[head]
                                                head <- head + 1
                                                idx <- cx * 9 + cy + 1
                                                if (opn[idx] == 0) {
                                                    opn[idx] <- 1
                                                    opened <- opened + 1
                                                    if (mine[idx] == 1) {
                                                        dead <- 1
                                                        head <- tail + 2
                                                    } else {
                                                        nb <- count_adj(cx, cy)
                                                        nbr[idx] <- nb
                                                        if (nb == 0) {
                                                            dx <- -1
                                                            while (dx <= 1) {
                                                                dy <- -1
                                                                while (dy <= 1) {
                                                                    if (dx != 0 || dy != 0) {
                                                                        nx <- cx + dx
                                                                        ny <- cy + dy
                                                                        if (nx >= 0) {
                                                                            if (ny >= 0) {
                                                                                if (nx < 9) {
                                                                                    if (ny < 9) {
                                                                                        if (tail < 81) {
                                                                                            nidx <- nx * 9 + ny + 1
                                                                                            if (opn[nidx] == 0) {
                                                                                                tail <- tail + 1
                                                                                                qx[tail] <- nx
                                                                                                qy[tail] <- ny
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    dy <- dy + 1
                                                                }
                                                                dx <- dx + 1
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            if (opened >= 71) { won <- 1 }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    if (msg == 1) {
        key <- ui_msg_get_a()
        if (key == 27) {
            mine <- rep(0, 81)
            opn <- rep(0, 81)
            flag <- rep(0, 81)
            nbr <- rep(0, 81)
            i <- 1
            while (i <= 10) {
                mi <- mpos[i]
                mine[mi] <- 1
                i <- i + 1
            }
            opened <- 0; dead <- 0; won <- 0; flagm <- 0; frames <- 0
        }
    }
    if (msg == 9) { frames <- frames + 1 }
}

k <- ui_timer_kill(tid)
k <- ui_scr_set_keep_on(0)
k <- ui_win_close()
