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

# =====================================================================
# ★★★ 可改配置：只改下面这几行，重新运行就能看到不同效果 ★★★
# =====================================================================
变量 墙颜色 = 蓝色
变量 墙顶颜色 = 青色
变量 玩家颜色 = 青色
变量 星星颜色 = 黄色
变量 出口颜色 = 绿色
变量 地面颜色 = 深灰
变量 玩家速度 = 4
变量 星星数量 = 5
变量 音效开关 = 真
# =====================================================================

变量 窗口 = 空
变量 画布 = 空
变量 宽 = 560
变量 高 = 680
变量 玩家X = 60
变量 玩家Y = 110
变量 玩家半径 = 12
变量 墙X = []
变量 墙Y = []
变量 墙W = []
变量 墙H = []
变量 星X = []
变量 星Y = []
变量 星已取 = []
变量 粒子X = []
变量 粒子Y = []
变量 粒子寿命 = []
变量 粒子颜色 = []
变量 分数 = 0
变量 已收集 = 0
变量 计时 = 0
变量 胜利 = 假
变量 提示 = ""
变量 提示寿命 = 0

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

函数 画星星(中X, 中Y, 大小, 颜色) {
    画布.画矩形(中X - 大小 / 3, 中Y - 大小, 大小 * 2 / 3, 大小 * 2, 颜色, 颜色)
    画布.画矩形(中X - 大小, 中Y - 大小 / 3, 大小 * 2, 大小 * 2 / 3, 颜色, 颜色)
}

函数 加墙(左, 上, 砖宽, 砖高) {
    列表追加(墙X, 左)
    列表追加(墙Y, 上)
    列表追加(墙W, 砖宽)
    列表追加(墙H, 砖高)
}

函数 建造迷宫() {
    墙X = []
    墙Y = []
    墙W = []
    墙H = []
    加墙(0, 60, 560, 20)
    加墙(0, 60, 20, 620)
    加墙(0, 660, 560, 20)
    加墙(540, 60, 20, 460)
    加墙(540, 580, 20, 100)

    加墙(20, 180, 280, 20)
    加墙(400, 180, 140, 20)
    加墙(320, 200, 20, 160)
    加墙(140, 340, 180, 20)
    加墙(20, 280, 100, 20)
    加墙(140, 200, 20, 140)
    加墙(460, 200, 20, 100)

    加墙(20, 440, 140, 20)
    加墙(240, 440, 20, 140)
    加墙(400, 360, 20, 200)
    加墙(420, 440, 100, 20)

    加墙(20, 560, 200, 20)
    加墙(300, 560, 120, 20)
    加墙(200, 480, 20, 80)
    加墙(480, 300, 60, 20)
}

函数 初始化() {
    玩家X = 60
    玩家Y = 110
    分数 = 0
    已收集 = 0
    计时 = 0
    胜利 = 假
    提示 = ""
    提示寿命 = 0
    粒子X = []
    粒子Y = []
    粒子寿命 = []
    粒子颜色 = []
    星X = []
    星Y = []
    星已取 = []
    建造迷宫()
    列表追加(星X, 470)
    列表追加(星Y, 120)
    列表追加(星已取, 假)
    列表追加(星X, 80)
    列表追加(星Y, 240)
    列表追加(星已取, 假)
    列表追加(星X, 260)
    列表追加(星Y, 300)
    列表追加(星已取, 假)
    列表追加(星X, 460)
    列表追加(星Y, 500)
    列表追加(星已取, 假)
    列表追加(星X, 80)
    列表追加(星Y, 610)
    列表追加(星已取, 假)
    如果 (音效开关 == 真) {
        播放音效文件("资源/start.wav")
    }
}

函数 撞墙(目标X, 目标Y) {
    变量 左 = 目标X - 玩家半径
    变量 右 = 目标X + 玩家半径
    变量 上 = 目标Y - 玩家半径
    变量 下 = 目标Y + 玩家半径
    变量 序号 = 0
    当 (序号 < 列表长度(墙X)) {
        变量 墙左 = 列表查询(墙X, 序号)
        变量 墙上 = 列表查询(墙Y, 序号)
        变量 墙右 = 墙左 + 列表查询(墙W, 序号)
        变量 墙下 = 墙上 + 列表查询(墙H, 序号)
        如果 (右 > 墙左 且 左 < 墙右 且 下 > 墙上 且 上 < 墙下) {
            返回 真
        }
        序号 = 序号 + 1
    }
    返回 假
}

函数 移动玩家(横, 纵) {
    变量 新X = 玩家X + 横
    变量 新Y = 玩家Y + 纵
    如果 (撞墙(新X, 玩家Y) == 假) {
        玩家X = 新X
    }
    如果 (撞墙(玩家X, 新Y) == 假) {
        玩家Y = 新Y
    }
}

函数 飘字(文字, 颜色) {
    提示 = 文字
    提示寿命 = 80
}

函数 爆炸(中心X, 中心Y, 颜色) {
    变量 序号 = 0
    当 (序号 < 12) {
        列表追加(粒子X, 中心X)
        列表追加(粒子Y, 中心Y)
        列表追加(粒子寿命, 22)
        列表追加(粒子颜色, 颜色)
        序号 = 序号 + 1
    }
}

函数 更新粒子() {
    变量 新X = []
    变量 新Y = []
    变量 新寿命 = []
    变量 新颜色 = []
    变量 序号 = 0
    当 (序号 < 列表长度(粒子X)) {
        变量 余命 = 列表查询(粒子寿命, 序号) - 1
        如果 (余命 > 0) {
            列表追加(新X, 列表查询(粒子X, 序号) + 随机整数(-5, 5))
            列表追加(新Y, 列表查询(粒子Y, 序号) + 随机整数(-5, 5))
            列表追加(新寿命, 余命)
            列表追加(新颜色, 列表查询(粒子颜色, 序号))
        }
        序号 = 序号 + 1
    }
    粒子X = 新X
    粒子Y = 新Y
    粒子寿命 = 新寿命
    粒子颜色 = 新颜色
}

函数 检测收集() {
    变量 序号 = 0
    当 (序号 < 列表长度(星X)) {
        如果 (列表查询(星已取, 序号) == 假) {
            变量 差X = 玩家X - 列表查询(星X, 序号)
            变量 差Y = 玩家Y - 列表查询(星Y, 序号)
            如果 (差X > -26 且 差X < 26 且 差Y > -26 且 差Y < 26) {
                星已取[序号] = 真
                已收集 = 已收集 + 1
                分数 = 分数 + 20
                爆炸(列表查询(星X, 序号), 列表查询(星Y, 序号), 星星颜色)
                如果 (音效开关 == 真) {
                    播放音效文件("资源/clear.wav")
                }
                飘字("收集到第 " + 文本(已收集) + " 颗星", 星星颜色)
            }
        }
        序号 = 序号 + 1
    }

    如果 (玩家X > 520 且 玩家Y > 510 且 玩家Y < 590) {
        如果 (已收集 >= 星星数量) {
            胜利 = 真
            如果 (音效开关 == 真) {
                播放音效文件("资源/gameover.wav")
            }
        } 否则 {
            飘字("出口未开：还差 " + 文本(星星数量 - 已收集) + " 颗星", 红色)
        }
    }
}

函数 绘制界面() {
    画布.清屏()
    画布.画矩形(0, 0, 宽, 高, 地面颜色, 地面颜色)
    画布.画矩形(0, 0, 宽, 60, 黑色, 黑色)

    变量 序号 = 0
    当 (序号 < 列表长度(墙X)) {
        变量 左 = 列表查询(墙X, 序号)
        变量 上 = 列表查询(墙Y, 序号)
        变量 砖宽 = 列表查询(墙W, 序号)
        变量 砖高 = 列表查询(墙H, 序号)
        画布.画矩形(左, 上, 砖宽, 砖高, 墙颜色, 墙颜色)
        如果 (砖高 <= 24) {
            画布.画矩形(左 + 2, 上 + 2, 砖宽 - 4, 4, 墙顶颜色, 墙顶颜色)
        } 否则 {
            画布.画矩形(左 + 2, 上 + 2, 4, 砖高 - 4, 墙顶颜色, 墙顶颜色)
        }
        序号 = 序号 + 1
    }

    变量 出口色 = 红色
    如果 (已收集 >= 星星数量) {
        出口色 = 出口颜色
    }
    画布.画矩形(540, 520, 20, 60, 出口色, 出口色)
    画布.画文本(498, 536, "出口", 出口色, 14)

    序号 = 0
    当 (序号 < 列表长度(星X)) {
        变量 星X值 = 列表查询(星X, 序号)
        变量 星Y值 = 列表查询(星Y, 序号)
        如果 (列表查询(星已取, 序号) == 假) {
            变量 呼吸 = 取整(正弦(计时 * 0.08) * 3)
            画星星(星X值, 星Y值, 12 + 呼吸, 星星颜色)
        }
        序号 = 序号 + 1
    }

    序号 = 0
    当 (序号 < 列表长度(粒子X)) {
        画圆块(列表查询(粒子X, 序号), 列表查询(粒子Y, 序号), 取整(列表查询(粒子寿命, 序号) / 4), 列表查询(粒子颜色, 序号))
        序号 = 序号 + 1
    }

    画圆块(玩家X, 玩家Y, 玩家半径, 玩家颜色)
    画布.画矩形(玩家X - 6, 玩家Y - 6, 4, 4, 白色, 白色)
    画布.画矩形(玩家X + 2, 玩家Y - 6, 4, 4, 白色, 白色)

    画布.画文本(20, 16, "星星: " + 文本(已收集) + " / " + 文本(星星数量), 白色, 22)
    画布.画文本(220, 18, "分数: " + 文本(分数), 黄色, 18)
    画布.画文本(370, 20, "时间: " + 文本(取整(计时 / 60)) + " 秒", 青色, 16)
    画布.画文本(120, 626, "方向键移动　R 重开　ESC 退出", 白色, 13)

    如果 (提示寿命 > 0) {
        画布.画文本(150, 596, 提示, 黄色, 18)
    }

    如果 (胜利 == 真) {
        画布.画矩形(80, 270, 400, 130, 黑色, 白色)
        画布.画文本(150, 294, "通关成功！", 绿色, 34)
        画布.画文本(160, 350, "按 R 再走一次", 白色, 18)
    }
}

函数 按键处理(键码) {
    如果 (键码 == 键_左) {
        移动玩家(0 - 玩家速度, 0)
    }
    如果 (键码 == 键_右) {
        移动玩家(玩家速度, 0)
    }
    如果 (键码 == 键_上) {
        移动玩家(0, 0 - 玩家速度)
    }
    如果 (键码 == 键_下) {
        移动玩家(0, 玩家速度)
    }
    如果 (键码 == 键_R) {
        初始化()
    }
    如果 (键码 == 键_退出) {
        关闭窗口()
        返回
    }
    请求重绘()
}

函数 帧刷新() {
    如果 (胜利 == 假) {
        计时 = 计时 + 1
        检测收集()
        更新粒子()
        如果 (提示寿命 > 0) {
            提示寿命 = 提示寿命 - 1
        }
    }
    请求重绘()
}

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