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

# =====================================================================
# ★★★ 可改配置：只改下面这几行，重新运行就能看到不同效果 ★★★
# =====================================================================
变量 挡板颜色 = 青色
变量 球颜色 = 黄色
变量 砖行1颜色 = 红色
变量 砖行2颜色 = 橙色
变量 砖行3颜色 = 黄色
变量 砖行4颜色 = 绿色
变量 砖行5颜色 = 蓝色
变量 砖行6颜色 = 紫色
变量 背景颜色 = 深灰
变量 挡板宽度 = 110
变量 挡板速度 = 26
变量 球速度X = 5
变量 球速度Y = 7
变量 初始生命 = 3
变量 砖块列数 = 7
变量 砖块行数 = 6
变量 音效开关 = 真
# =====================================================================

变量 窗口 = 空
变量 画布 = 空
变量 宽 = 600
变量 高 = 700
变量 挡板X = 245
变量 挡板Y = 650
变量 挡板高 = 16
变量 球X = 300
变量 球Y = 600
变量 球半径 = 9
变量 球VX = 5
变量 球VY = -7
变量 砖X = []
变量 砖Y = []
变量 砖W = []
变量 砖H = []
变量 砖色 = []
变量 粒子X = []
变量 粒子Y = []
变量 粒子VX = []
变量 粒子VY = []
变量 粒子寿命 = []
变量 粒子颜色 = []
变量 分数 = 0
变量 生命 = 3
变量 游戏结束 = 假
变量 游戏胜利 = 假
变量 计时 = 0

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

函数 天色(行号) {
    如果 (行号 == 0) {
        返回 砖行1颜色
    }
    如果 (行号 == 1) {
        返回 砖行2颜色
    }
    如果 (行号 == 2) {
        返回 砖行3颜色
    }
    如果 (行号 == 3) {
        返回 砖行4颜色
    }
    如果 (行号 == 4) {
        返回 砖行5颜色
    }
    返回 砖行6颜色
}

函数 建造砖块() {
    砖X = []
    砖Y = []
    砖W = []
    砖H = []
    砖色 = []
    变量 左 = 30
    变量 上 = 100
    变量 缝 = 6
    变量 砖宽 = 72
    变量 砖高 = 28
    变量 行 = 0
    当 (行 < 砖块行数) {
        变量 列 = 0
        当 (列 < 砖块列数) {
            列表追加(砖X, 左 + 列 * (砖宽 + 缝))
            列表追加(砖Y, 上 + 行 * (砖高 + 缝))
            列表追加(砖W, 砖宽)
            列表追加(砖H, 砖高)
            列表追加(砖色, 天色(行))
            列 = 列 + 1
        }
        行 = 行 + 1
    }
}

函数 重置球() {
    球X = 挡板X + 挡板宽度 / 2
    球Y = 挡板Y - 20
    球VX = 0
    球VY = 0 - 球速度Y
}

函数 初始化() {
    分数 = 0
    生命 = 初始生命
    游戏结束 = 假
    游戏胜利 = 假
    计时 = 0
    挡板X = (宽 - 挡板宽度) / 2
    粒子X = []
    粒子Y = []
    粒子VX = []
    粒子VY = []
    粒子寿命 = []
    粒子颜色 = []
    建造砖块()
    重置球()
    如果 (音效开关 == 真) {
        播放音效文件("资源/start.wav")
    }
}

函数 爆炸(中心X, 中心Y, 颜色) {
    变量 序号 = 0
    当 (序号 < 8) {
        列表追加(粒子X, 中心X)
        列表追加(粒子Y, 中心Y)
        列表追加(粒子VX, 随机整数(-6, 6))
        列表追加(粒子VY, 随机整数(-7, 2))
        列表追加(粒子寿命, 16)
        列表追加(粒子颜色, 颜色)
        序号 = 序号 + 1
    }
}

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

函数 更新球() {
    球X = 球X + 球VX
    球Y = 球Y + 球VY
    如果 (球X < 球半径) {
        球X = 球半径
        球VX = 球VX * -1
    }
    如果 (球X > 宽 - 球半径) {
        球X = 宽 - 球半径
        球VX = 球VX * -1
    }
    如果 (球Y < 球半径 + 84) {
        球Y = 球半径 + 84
        球VY = 球VY * -1
    }
    如果 (球Y + 球半径 >= 挡板Y 且 球Y + 球半径 <= 挡板Y + 挡板高 + 8 且 球VY > 0) {
        如果 (球X >= 挡板X - 10 且 球X <= 挡板X + 挡板宽度 + 10) {
            球VY = 0 - 球速度Y
            变量 偏移 = 球X - (挡板X + 挡板宽度 / 2)
            球VX = 球VX + 偏移 / 18
            如果 (球VX > 8) {
                球VX = 8
            }
            如果 (球VX < -8) {
                球VX = -8
            }
            如果 (音效开关 == 真) {
                播放音效文件("资源/move.wav")
            }
        }
    }
}

函数 检测砖块() {
    变量 序号 = 列表长度(砖X) - 1
    当 (序号 >= 0) {
        变量 左 = 列表查询(砖X, 序号)
        变量 上 = 列表查询(砖Y, 序号)
        变量 右 = 左 + 列表查询(砖W, 序号)
        变量 下 = 上 + 列表查询(砖H, 序号)
        变量 已撞 = 假
        如果 (球X + 球半径 > 左 且 球X - 球半径 < 右 且 球Y + 球半径 > 上 且 球Y - 球半径 < 下) {
            爆炸(左 + 列表查询(砖W, 序号) / 2, 上 + 列表查询(砖H, 序号) / 2, 列表查询(砖色, 序号))
            列表移除(砖X, 序号)
            列表移除(砖Y, 序号)
            列表移除(砖W, 序号)
            列表移除(砖H, 序号)
            列表移除(砖色, 序号)
            分数 = 分数 + 10
            球VY = 球VY * -1
            已撞 = 真
            如果 (音效开关 == 真) {
                播放音效文件("资源/clear.wav")
            }
        }
        如果 (已撞 == 真) {
            序号 = -1
        } 否则 {
            序号 = 序号 - 1
        }
    }
    如果 (列表长度(砖X) == 0) {
        游戏胜利 = 真
        如果 (音效开关 == 真) {
            播放音效文件("资源/gameover.wav")
        }
    }
}

函数 球出界() {
    如果 (球Y > 高 + 20) {
        生命 = 生命 - 1
        如果 (音效开关 == 真) {
            播放音效文件("资源/drop.wav")
        }
        如果 (生命 <= 0) {
            游戏结束 = 真
            如果 (音效开关 == 真) {
                播放音效文件("资源/gameover.wav")
            }
        } 否则 {
            重置球()
        }
    }
}

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

    变量 序号 = 0
    当 (序号 < 列表长度(砖X)) {
        变量 左 = 列表查询(砖X, 序号)
        变量 上 = 列表查询(砖Y, 序号)
        变量 砖宽 = 列表查询(砖W, 序号)
        变量 砖高 = 列表查询(砖H, 序号)
        变量 色 = 列表查询(砖色, 序号)
        画布.画矩形(左, 上, 砖宽, 砖高, 色, 色)
        画布.画矩形(左 + 4, 上 + 4, 砖宽 - 8, 4, 白色, 白色)
        画布.画矩形(左 + 4, 上 + 砖高 - 8, 砖宽 - 8, 4, 黑色, 黑色)
        序号 = 序号 + 1
    }

    画布.画矩形(挡板X, 挡板Y, 挡板宽度, 挡板高, 挡板颜色, 挡板颜色)
    画布.画矩形(挡板X + 8, 挡板Y + 3, 挡板宽度 - 16, 4, 白色, 白色)

    画圆块(球X, 球Y, 球半径, 球颜色)
    画布.画矩形(球X - 3, 球Y - 5, 5, 5, 白色, 白色)

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

    画布.画文本(20, 20, "分数: " + 文本(分数), 白色, 22)
    画布.画文本(20, 50, "生命: " + 文本(生命), 黄色, 18)
    画布.画文本(470, 20, "砖块: " + 文本(列表长度(砖X)), 青色, 18)
    画布.画文本(130, 676, "← → 移动　R 重开　ESC 退出", 白色, 14)

    如果 (游戏胜利 == 真) {
        画布.画矩形(90, 280, 420, 120, 黑色, 白色)
        画布.画文本(160, 304, "全部击碎！", 黄色, 32)
        画布.画文本(140, 356, "按 R 再来一局", 白色, 18)
    }
    如果 (游戏结束 == 真) {
        画布.画矩形(90, 280, 420, 120, 黑色, 白色)
        画布.画文本(160, 304, "游戏结束", 红色, 32)
        画布.画文本(140, 356, "按 R 重新开始", 白色, 18)
    }
}

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

函数 帧刷新() {
    如果 (游戏结束 == 假 且 游戏胜利 == 假) {
        计时 = 计时 + 1
        更新球()
        检测砖块()
        球出界()
        更新粒子()
        如果 (计时 > 120 且 列表长度(粒子X) > 40) {
            粒子X = []
            粒子Y = []
            粒子VX = []
            粒子VY = []
            粒子寿命 = []
            粒子颜色 = []
        }
    }
    请求重绘()
}

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