# 九艾斯 2D 扫雷 · 原生 9S
# 绵阳九艾斯科技有限公司 版权所有 (c) 2026
# 运行: 九S虚拟机.exe 扫雷.9s

# =====================================================================
# ★★★ 可改配置：只改下面这几行，重新运行就能看到不同效果 ★★★
# =====================================================================
变量 已开颜色 = 白色
变量 未开颜色 = 浅灰
变量 网格颜色 = 深灰
变量 光标颜色 = 黄色
变量 地雷颜色 = 红色
变量 旗子颜色 = 绿色
变量 背景颜色 = 黑色
变量 雷数 = 10
变量 格子数 = 9
变量 音效开关 = 真
# =====================================================================

变量 窗口 = 空
变量 画布 = 空
变量 宽 = 560
变量 高 = 680
变量 格 = 54
变量 左偏移 = 37
变量 上偏移 = 100
变量 光标X = 0
变量 光标Y = 0
变量 矿 = []
变量 已开 = []
变量 失败 = 假
变量 胜利 = 假
变量 首次 = 真
变量 已开数 = 0
变量 计时 = 0
变量 提示 = ""

函数 画圆块(中X, 中Y, 半径, 颜色) {
    画布.画矩形(中X - 半径, 中Y - 半径 / 2, 半径 * 2, 半径, 颜色, 颜色)
    画布.画矩形(中X - 半径 / 2, 中Y - 半径, 半径, 半径 * 2, 颜色, 颜色)
    画布.画矩形(中X - 半径 + 4, 中Y - 半径 + 4, 半径 * 2 - 8, 半径 * 2 - 8, 颜色, 颜色)
}

函数 序号(横, 纵) {
    返回 纵 * 格子数 + 横
}

函数 是雷(横, 纵) {
    变量 序 = 序号(横, 纵)
    变量 找 = 0
    当 (找 < 列表长度(矿)) {
        如果 (列表查询(矿, 找) == 序) {
            返回 真
        }
        找 = 找 + 1
    }
    返回 假
}

函数 邻居雷数(横, 纵) {
    变量 数 = 0
    变量 纵差 = -1
    当 (纵差 <= 1) {
        变量 横差 = -1
        当 (横差 <= 1) {
            变量 新横 = 横 + 横差
            变量 新纵 = 纵 + 纵差
            如果 (横差 != 0 或 纵差 != 0) {
                如果 (新横 >= 0 且 新横 < 格子数 且 新纵 >= 0 且 新纵 < 格子数) {
                    如果 (是雷(新横, 新纵) == 真) {
                        数 = 数 + 1
                    }
                }
            }
            横差 = 横差 + 1
        }
        纵差 = 纵差 + 1
    }
    返回 数
}

函数 布雷() {
    矿 = []
    已开 = []
    变量 总 = 格子数 * 格子数
    变量 序 = 0
    当 (序 < 总) {
        列表追加(已开, 0)
        序 = 序 + 1
    }
    变量 放了 = 0
    当 (放了 < 雷数) {
        变量 横 = 随机整数(0, 格子数 - 1)
        变量 纵 = 随机整数(0, 格子数 - 1)
        变量 安全 = 假
        如果 (横 >= 光标X - 1 且 横 <= 光标X + 1 且 纵 >= 光标Y - 1 且 纵 <= 光标Y + 1) {
            安全 = 真
        }
        如果 (安全 == 假 且 是雷(横, 纵) == 假) {
            列表追加(矿, 序号(横, 纵))
            放了 = 放了 + 1
        }
    }
}

函数 初始化() {
    光标X = 0
    光标Y = 0
    矿 = []
    已开 = []
    失败 = 假
    胜利 = 假
    首次 = 真
    已开数 = 0
    计时 = 0
    提示 = ""
    变量 序 = 0
    当 (序 < 格子数 * 格子数) {
        列表追加(已开, 0)
        序 = 序 + 1
    }
    如果 (音效开关 == 真) {
        播放音效文件("资源/start.wav")
    }
}

函数 翻开(横, 纵) {
    变量 序 = 序号(横, 纵)
    如果 (列表查询(已开, 序) == 1) {
        返回
    }
    如果 (是雷(横, 纵) == 真) {
        已开[序] = 1
        失败 = 真
        提示 = "踩到地雷，按 R 重开"
        如果 (音效开关 == 真) {
            播放音效文件("资源/gameover.wav")
        }
        返回
    }
    变量 队 = []
    列表追加(队, 序)
    当 (列表长度(队) > 0) {
        变量 当前 = 列表查询(队, 0)
        列表移除(队, 0)
        如果 (列表查询(已开, 当前) == 0) {
            已开[当前] = 1
            已开数 = 已开数 + 1
            变量 当横 = 当前 % 格子数
            变量 当纵 = 取整(当前 / 格子数)
            如果 (邻居雷数(当横, 当纵) == 0) {
                变量 纵差 = -1
                当 (纵差 <= 1) {
                    变量 横差 = -1
                    当 (横差 <= 1) {
                        变量 新横 = 当横 + 横差
                        变量 新纵 = 当纵 + 纵差
                        如果 (新横 >= 0 且 新横 < 格子数 且 新纵 >= 0 且 新纵 < 格子数) {
                            变量 新序 = 序号(新横, 新纵)
                            如果 (列表查询(已开, 新序) == 0 且 是雷(新横, 新纵) == 假) {
                                列表追加(队, 新序)
                            }
                        }
                        横差 = 横差 + 1
                    }
                    纵差 = 纵差 + 1
                }
            }
        }
    }
    如果 (已开数 >= 格子数 * 格子数 - 雷数) {
        胜利 = 真
        提示 = "全部排雷完成！"
        如果 (音效开关 == 真) {
            播放音效文件("资源/gameover.wav")
        }
    } 否则 {
        如果 (音效开关 == 真) {
            播放音效文件("资源/move.wav")
        }
    }
}

函数 数字颜色(数) {
    如果 (数 == 1) {
        返回 蓝色
    }
    如果 (数 == 2) {
        返回 绿色
    }
    如果 (数 == 3) {
        返回 红色
    }
    如果 (数 == 4) {
        返回 紫色
    }
    如果 (数 == 5) {
        返回 橙色
    }
    返回 青色
}

函数 绘制雷(中X, 中Y, 半径) {
    画圆块(中X, 中Y, 半径, 地雷颜色)
    画布.画矩形(中X - 2, 中Y - 半径 - 6, 4, 12, 地雷颜色, 地雷颜色)
    画布.画矩形(中X - 半径 - 6, 中Y - 2, 12, 4, 地雷颜色, 地雷颜色)
    画布.画矩形(中X - 6, 中Y - 6, 5, 5, 白色, 白色)
}

函数 绘制界面() {
    画布.清屏()
    画布.画矩形(0, 0, 宽, 高, 背景颜色, 背景颜色)
    画布.画矩形(0, 86, 宽, 3, 青色, 青色)

    变量 纵 = 0
    当 (纵 < 格子数) {
        变量 横 = 0
        当 (横 < 格子数) {
            变量 左 = 左偏移 + 横 * 格
            变量 上 = 上偏移 + 纵 * 格
            变量 序 = 序号(横, 纵)
            变量 开着 = 列表查询(已开, 序)
            如果 (开着 == 1) {
                画布.画矩形(左, 上, 格 - 2, 格 - 2, 已开颜色, 已开颜色)
                如果 (是雷(横, 纵) == 真) {
                    绘制雷(左 + 格 / 2, 上 + 格 / 2, 14)
                } 否则 {
                    变量 数 = 邻居雷数(横, 纵)
                    如果 (数 > 0) {
                        画布.画文本(左 + 16, 上 + 12, 文本(数), 数字颜色(数), 26)
                    }
                }
            } 否则 {
                画布.画矩形(左, 上, 格 - 2, 格 - 2, 未开颜色, 未开颜色)
                画布.画矩形(左 + 2, 上 + 2, 格 - 6, 4, 浅灰, 浅灰)
                画布.画矩形(左 + 2, 上 + 2, 4, 格 - 6, 浅灰, 浅灰)
            }
            画布.画矩形(左 + 格 - 4, 上, 2, 格 - 2, 网格颜色, 网格颜色)
            画布.画矩形(左, 上 + 格 - 4, 格 - 2, 2, 网格颜色, 网格颜色)
            横 = 横 + 1
        }
        纵 = 纵 + 1
    }

    变量 光标左 = 左偏移 + 光标X * 格
    变量 光标上 = 上偏移 + 光标Y * 格
    画布.画矩形(光标左 - 3, 光标上 - 3, 格 + 4, 4, 光标颜色, 光标颜色)
    画布.画矩形(光标左 - 3, 光标上 + 格 - 1, 格 + 4, 4, 光标颜色, 光标颜色)
    画布.画矩形(光标左 - 3, 光标上 - 3, 4, 格 + 4, 光标颜色, 光标颜色)
    画布.画矩形(光标左 + 格 - 1, 光标上 - 3, 4, 格 + 4, 光标颜色, 光标颜色)

    画布.画文本(20, 18, "扫雷 · 9×9 · " + 文本(雷数) + " 颗雷", 白色, 24)
    画布.画文本(20, 52, "剩余安全格: " + 文本(格子数 * 格子数 - 雷数 - 已开数), 黄色, 18)
    画布.画文本(390, 20, "时间: " + 文本(取整(计时 / 60)) + " 秒", 青色, 16)
    画布.画文本(80, 606, 提示, 白色, 14)
    画布.画文本(80, 630, "方向键选格　空格翻开　R 重开　ESC 退出", 白色, 12)

    如果 (胜利 == 真) {
        画布.画矩形(90, 300, 380, 100, 黑色, 白色)
        画布.画文本(150, 322, "排雷成功！", 绿色, 32)
        画布.画文本(160, 366, "按 R 再来一局", 白色, 18)
    }
    如果 (失败 == 真) {
        画布.画矩形(90, 300, 380, 100, 黑色, 白色)
        画布.画文本(150, 322, "踩到地雷！", 红色, 32)
        画布.画文本(160, 366, "按 R 重新开始", 白色, 18)
    }
}

函数 按键处理(键码) {
    如果 (失败 == 假 且 胜利 == 假) {
        如果 (键码 == 键_左) {
            光标X = 光标X - 1
            如果 (光标X < 0) {
                光标X = 0
            }
        }
        如果 (键码 == 键_右) {
            光标X = 光标X + 1
            如果 (光标X >= 格子数) {
                光标X = 格子数 - 1
            }
        }
        如果 (键码 == 键_上) {
            光标Y = 光标Y - 1
            如果 (光标Y < 0) {
                光标Y = 0
            }
        }
        如果 (键码 == 键_下) {
            光标Y = 光标Y + 1
            如果 (光标Y >= 格子数) {
                光标Y = 格子数 - 1
            }
        }
        如果 (键码 == 键_空格) {
            如果 (首次 == 真) {
                首次 = 假
                布雷()
            }
            翻开(光标X, 光标Y)
        }
    }
    如果 (键码 == 键_R) {
        初始化()
    }
    如果 (键码 == 键_退出) {
        关闭窗口()
        返回
    }
    请求重绘()
}

函数 帧刷新() {
    如果 (失败 == 假 且 胜利 == 假) {
        计时 = 计时 + 1
    }
    请求重绘()
}

初始化()
窗口 = 创建窗口("九艾斯扫雷 · 可改配置", 宽, 高)
画布 = 九S画布(窗口)
设置绘制函数(绘制界面)
设置按键函数(按键处理)
设置定时器(30, 帧刷新)
显示窗口()
请求重绘()
启动消息循环()