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

# =====================================================================
# ★★★ 可改配置：只改下面这几行，重新运行就能看到不同效果 ★★★
# =====================================================================
变量 篮筐颜色 = 橙色
变量 苹果颜色 = 红色
变量 橘子颜色 = 橙色
变量 葡萄颜色 = 紫色
变量 星星颜色 = 黄色
变量 炸弹颜色 = 黑色
变量 背景颜色 = 深灰
变量 篮筐宽度 = 112
变量 篮筐速度 = 30
变量 水果基础速度 = 5
变量 生成间隔 = 22
变量 初始生命 = 3
变量 星空数量 = 40
变量 音效开关 = 真
# =====================================================================

变量 窗口 = 空
变量 画布 = 空
变量 宽 = 520
变量 高 = 700
变量 篮筐X = 204
变量 篮筐Y = 630
变量 篮筐高 = 24
变量 果X = []
变量 果Y = []
变量 果速度 = []
变量 果类型 = []
变量 果半径 = []
变量 星X = []
变量 星Y = []
变量 粒子X = []
变量 粒子Y = []
变量 粒子颜色 = []
变量 粒子寿命 = []
变量 分数 = 0
变量 生命 = 3
变量 连击 = 0
变量 最高连击 = 0
变量 计时 = 0
变量 游戏结束 = 假

函数 果颜色(类型) {
    如果 (类型 == 1) {
        返回 苹果颜色
    }
    如果 (类型 == 2) {
        返回 橘子颜色
    }
    如果 (类型 == 3) {
        返回 葡萄颜色
    }
    如果 (类型 == 4) {
        返回 星星颜色
    }
    返回 炸弹颜色
}

函数 果分值(类型) {
    如果 (类型 == 4) {
        返回 30
    }
    如果 (类型 == 5) {
        返回 0
    }
    返回 10
}

函数 画圆块(中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, 颜色, 颜色)
}

函数 初始化() {
    分数 = 0
    生命 = 初始生命
    连击 = 0
    最高连击 = 0
    计时 = 0
    游戏结束 = 假
    篮筐X = (宽 - 篮筐宽度) / 2
    果X = []
    果Y = []
    果速度 = []
    果类型 = []
    果半径 = []
    粒子X = []
    粒子Y = []
    粒子颜色 = []
    粒子寿命 = []
    星X = []
    星Y = []
    变量 序号 = 0
    当 (序号 < 星空数量) {
        列表追加(星X, 随机整数(8, 512))
        列表追加(星Y, 随机整数(8, 420))
        序号 = 序号 + 1
    }
    如果 (音效开关 == 真) {
        播放音效文件("资源/start.wav")
    }
}

函数 生成水果() {
    如果 (计时 % 生成间隔 != 0) {
        返回
    }
    如果 (列表长度(果X) >= 9) {
        返回
    }
    变量 类型 = 随机整数(1, 5)
    变量 半径 = 14
    如果 (类型 == 3) {
        半径 = 11
    }
    如果 (类型 == 4) {
        半径 = 10
    }
    如果 (类型 == 5) {
        半径 = 13
    }
    列表追加(果X, 随机整数(30, 490))
    列表追加(果Y, -20)
    列表追加(果速度, 水果基础速度 + 随机整数(0, 4))
    列表追加(果类型, 类型)
    列表追加(果半径, 半径)
}

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

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

函数 更新水果() {
    变量 新X = []
    变量 新Y = []
    变量 新速度 = []
    变量 新类型 = []
    变量 新半径 = []
    变量 序号 = 0
    当 (序号 < 列表长度(果X)) {
        变量 紫X = 列表查询(果X, 序号)
        变量 紫Y = 列表查询(果Y, 序号) + 列表查询(果速度, 序号)
        变量 类型 = 列表查询(果类型, 序号)
        变量 半径 = 列表查询(果半径, 序号)
        变量 已接 = 假
        如果 (紫Y + 半径 >= 篮筐Y 且 紫Y - 半径 <= 篮筐Y + 篮筐高) {
            如果 (紫X >= 篮筐X - 半径 且 紫X <= 篮筐X + 篮筐宽度 + 半径) {
                已接 = 真
                如果 (类型 == 5) {
                    生命 = 生命 - 1
                    连击 = 0
                    爆炸(紫X, 紫Y, 炸弹颜色)
                    如果 (音效开关 == 真) {
                        播放音效文件("资源/gameover.wav")
                    }
                    如果 (生命 <= 0) {
                        游戏结束 = 真
                    }
                } 否则 {
                    连击 = 连击 + 1
                    如果 (连击 > 最高连击) {
                        最高连击 = 连击
                    }
                    分数 = 分数 + 果分值(类型)
                    爆炸(紫X, 紫Y, 果颜色(类型))
                    如果 (音效开关 == 真) {
                        播放音效文件("资源/clear.wav")
                    }
                }
            }
        }
        如果 (已接 == 假 且 紫Y < 高 + 30) {
            列表追加(新X, 紫X)
            列表追加(新Y, 紫Y)
            列表追加(新速度, 列表查询(果速度, 序号))
            列表追加(新类型, 类型)
            列表追加(新半径, 半径)
        } 否则 {
            如果 (已接 == 假 且 类型 != 5) {
                连击 = 0
            }
        }
        序号 = 序号 + 1
    }
    果X = 新X
    果Y = 新Y
    果速度 = 新速度
    果类型 = 新类型
    果半径 = 新半径
}

函数 绘制水果(类型, 紫X, 紫Y, 半径, 颜色) {
    如果 (类型 == 5) {
        画圆块(紫X, 紫Y, 半径, 炸弹颜色)
        画布.画矩形(紫X - 2, 紫Y - 半径 - 8, 4, 8, 橙色, 橙色)
        画圆块(紫X + 3, 紫Y - 半径 - 9, 3, 黄色)
        画布.画矩形(紫X - 5, 紫Y - 5, 5, 5, 白色, 白色)
    } 否则 {
        如果 (类型 == 4) {
            画星星(紫X, 紫Y, 半径, 颜色)
        } 否则 {
            画圆块(紫X, 紫Y, 半径, 颜色)
        }
        画布.画矩形(紫X - 6, 紫Y - 6, 5, 5, 白色, 白色)
        如果 (类型 == 4) {
            画布.画矩形(紫X - 2, 紫Y - 半径 - 6, 4, 6, 绿色, 绿色)
        } 否则 {
            画布.画矩形(紫X + 2, 紫Y - 半径 - 4, 4, 6, 绿色, 绿色)
        }
    }
}

函数 绘制界面() {
    画布.清屏()
    画布.画矩形(0, 0, 宽, 高, 背景颜色, 背景颜色)
    画布.画矩形(0, 0, 宽, 120, 黑色, 黑色)
    画布.画矩形(0, 520, 宽, 180, 绿色, 绿色)

    变量 序号 = 0
    当 (序号 < 列表长度(星X)) {
        画布.画矩形(列表查询(星X, 序号), 列表查询(星Y, 序号), 4, 4, 白色, 白色)
        序号 = 序号 + 1
    }

    画圆块(450, 200, 24, 黄色)
    画圆块(460, 192, 10, 背景颜色)

    序号 = 0
    当 (序号 < 列表长度(果X)) {
        绘制水果(列表查询(果类型, 序号), 列表查询(果X, 序号), 列表查询(果Y, 序号), 列表查询(果半径, 序号), 果颜色(列表查询(果类型, 序号)))
        序号 = 序号 + 1
    }

    画布.画矩形(篮筐X, 篮筐Y, 篮筐宽度, 篮筐高, 篮筐颜色, 篮筐颜色)
    画布.画矩形(篮筐X + 6, 篮筐Y + 6, 篮筐宽度 - 12, 4, 黄色, 黄色)
    画布.画矩形(篮筐X + 4, 篮筐Y + 篮筐高, 篮筐宽度 - 8, 8, 橙色, 橙色)
    画布.画矩形(篮筐X + 16, 篮筐Y + 3, 3, 篮筐高 - 6, 黑色, 黑色)
    画布.画矩形(篮筐X + 50, 篮筐Y + 3, 3, 篮筐高 - 6, 黑色, 黑色)
    画布.画矩形(篮筐X + 84, 篮筐Y + 3, 3, 篮筐高 - 6, 黑色, 黑色)

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

    画布.画矩形(0, 0, 宽, 120, 黑色, 黑色)
    画布.画文本(20, 18, "分数: " + 文本(分数), 白色, 24)
    画布.画文本(20, 50, "生命: " + 文本(生命), 黄色, 18)
    画布.画文本(20, 78, "连击: " + 文本(连击) + "　最高: " + 文本(最高连击), 青色, 16)
    画布.画文本(130, 648, "← → 移动篮筐　R 重开　ESC 退出", 白色, 13)

    如果 (游戏结束 == 真) {
        画布.画矩形(70, 300, 380, 120, 黑色, 白色)
        画布.画文本(130, 324, "游戏结束", 红色, 32)
        画布.画文本(110, 376, "按 R 重新开始", 白色, 18)
    }
}

函数 按键处理(键码) {
    如果 (键码 == 键_左) {
        篮筐X = 篮筐X - 篮筐速度
    }
    如果 (键码 == 键_右) {
        篮筐X = 篮筐X + 篮筐速度
    }
    如果 (篮筐X < 0) {
        篮筐X = 0
    }
    如果 (篮筐X > 宽 - 篮筐宽度) {
        篮筐X = 宽 - 篮筐宽度
    }
    如果 (键码 == 键_R) {
        初始化()
    }
    如果 (键码 == 键_退出) {
        关闭窗口()
        返回
    }
    请求重绘()
}

函数 帧刷新() {
    如果 (游戏结束 == 假) {
        计时 = 计时 + 1
        生成水果()
        更新水果()
        更新粒子()
    }
    请求重绘()
}

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