# 九艾斯 3D 躲避陨石 · 原生 9S + 4D 虚拟机
# 绵阳九艾斯科技有限公司 版权所有 (c) 2026
# 运行: 九S虚拟机(4D).exe 躲避陨石3D.9s

常量 颜色_白 = 16777215
常量 颜色_红 = 255
常量 颜色_绿 = 65280
常量 颜色_蓝 = 16711680
常量 颜色_黄 = 65535
常量 颜色_青 = 16776960
常量 颜色_橙 = 42495
常量 颜色_紫 = 16711935
常量 颜色_深灰 = 8421504
常量 颜色_黑 = 0
常量 颜色_暗蓝 = 4202528

# =====================================================================
# ★★★ 可改配置：只改下面这几行，重新运行就能看到不同 3D 效果 ★★★
# =====================================================================
变量 玩家颜色 = 颜色_青
变量 陨石颜色 = 颜色_橙
变量 爆炸颜色 = 颜色_黄
变量 星空颜色 = 颜色_白
变量 玩家速度 = 26
变量 陨石基础速度 = 18
变量 生成间隔 = 18
变量 初始生命 = 5
变量 相机距离 = 900
变量 最大陨石数 = 8
变量 难度增长 = 200
变量 音效开关 = 真
# =====================================================================

变量 窗口 = 空
变量 场景 = 0
变量 机身ID = 0
变量 左翼ID = 0
变量 右翼ID = 0
变量 座舱ID = 0
变量 引擎左ID = 0
变量 引擎右ID = 0
变量 玩家X = 0
变量 玩家Y = 20
变量 玩家Z = -260
变量 星星ID = []
变量 星星X = []
变量 星星Y = []
变量 星星Z = []
变量 星星速度 = []
变量 陨石ID = []
变量 陨石X = []
变量 陨石Y = []
变量 陨石Z = []
变量 陨石半径 = []
变量 陨石速度 = []
变量 粒子ID = []
变量 粒子X = []
变量 粒子Y = []
变量 粒子Z = []
变量 粒子VX = []
变量 粒子VY = []
变量 粒子寿命 = []
变量 分数 = 0
变量 生命 = 5
变量 计时 = 0
变量 游戏结束 = 假

函数 清空列表() {
    陨石ID = []
    陨石X = []
    陨石Y = []
    陨石Z = []
    陨石半径 = []
    陨石速度 = []
    粒子ID = []
    粒子X = []
    粒子Y = []
    粒子Z = []
    粒子VX = []
    粒子VY = []
    粒子寿命 = []
}

函数 清理动态物体() {
    变量 序号 = 列表长度(陨石ID) - 1
    当 (序号 >= 0) {
        删除3D物体(场景, 列表查询(陨石ID, 序号))
        序号 = 序号 - 1
    }
    序号 = 列表长度(粒子ID) - 1
    当 (序号 >= 0) {
        删除3D物体(场景, 列表查询(粒子ID, 序号))
        序号 = 序号 - 1
    }
}

函数 创建场景() {
    如果 (场景 != 0) {
        返回
    }
    场景 = 创建3D场景(1400)
    设置3D相机(场景, 0, 70, 0 - 相机距离)
    设置相机注视(场景, 0, 20, 300)
    设置3D光源(场景, 0.4, -0.8, -0.3, 0.75)
    设置泛光(0)
    设置环境光遮蔽(0)
    设置色彩校正(1, 1.2, 1.08, -0.02)
    设置画质档位(0)
    设置渲染质量(2)

    变量 格X = -600
    当 (格X <= 600) {
        变量 格ID = 添加立方体(场景, 格X, -150, 300, 3, 2, 1900, 颜色_暗蓝)
        设置塑料材质(场景, 格ID, 颜色_暗蓝)
        设置3D物体材质(场景, 格ID, 颜色_暗蓝, 0.0, 8, 1.0, 0.0, 0.3, 0.25)
        格X = 格X + 300
    }
    变量 格Z = -400
    当 (格Z <= 1000) {
        变量 横ID = 添加立方体(场景, 0, -150, 格Z, 1300, 2, 3, 颜色_暗蓝)
        设置塑料材质(场景, 横ID, 颜色_暗蓝)
        设置3D物体材质(场景, 横ID, 颜色_暗蓝, 0.0, 8, 1.0, 0.0, 0.3, 0.25)
        格Z = 格Z + 280
    }

    机身ID = 添加立方体(场景, 0, 10, -280, 46, 18, 76, 玩家颜色)
    左翼ID = 添加立方体(场景, -40, 8, -270, 56, 8, 38, 玩家颜色)
    右翼ID = 添加立方体(场景, 40, 8, -270, 56, 8, 38, 玩家颜色)
    座舱ID = 添加立方体(场景, 0, 22, -248, 20, 12, 16, 颜色_白)
    引擎左ID = 添加粒子(场景, -16, 10, -238, 8, 颜色_青)
    引擎右ID = 添加粒子(场景, 16, 10, -238, 8, 颜色_青)
    设置金属材质(场景, 机身ID, 玩家颜色)
    设置金属材质(场景, 左翼ID, 玩家颜色)
    设置金属材质(场景, 右翼ID, 玩家颜色)
    设置气泡材质(场景, 座舱ID, 颜色_白)
    设置3D物体材质(场景, 座舱ID, 颜色_白, 0.9, 32, 0.85, 0.2, 0.4, 0.4)
    设置气泡材质(场景, 引擎左ID, 颜色_青)
    设置气泡材质(场景, 引擎右ID, 颜色_青)
    设置3D物体材质(场景, 引擎左ID, 颜色_青, 0.0, 8, 1.0, 0.0, 0.2, 0.95)
    设置3D物体材质(场景, 引擎右ID, 颜色_青, 0.0, 8, 1.0, 0.0, 0.2, 0.95)

    变量 序号 = 0
    当 (序号 < 18) {
        变量 星X = 随机整数(-700, 700)
        变量 星Y = 随机整数(-120, 300)
        变量 星Z = 随机整数(-400, 1100)
        变量 星ID = 添加立方体(场景, 星X, 星Y, 星Z, 4, 4, 4, 星空颜色)
        设置气泡材质(场景, 星ID, 星空颜色)
        设置3D物体材质(场景, 星ID, 星空颜色, 0.0, 8, 1.0, 0.0, 0.2, 0.9)
        列表追加(星星ID, 星ID)
        列表追加(星星X, 星X)
        列表追加(星星Y, 星Y)
        列表追加(星星Z, 星Z)
        列表追加(星星速度, 随机整数(10, 40))
        序号 = 序号 + 1
    }
}

函数 初始化() {
    清理动态物体()
    清空列表()
    分数 = 0
    生命 = 初始生命
    计时 = 0
    游戏结束 = 假
    玩家X = 0
    玩家Y = 20
    创建场景()
    移动战机()
    如果 (音效开关 == 真) {
        播放音效文件("资源/start.wav")
    }
}

函数 移动战机() {
    移动3D物体(场景, 机身ID, 玩家X, 玩家Y, 玩家Z)
    移动3D物体(场景, 左翼ID, 玩家X - 40, 玩家Y - 2, 玩家Z + 10)
    移动3D物体(场景, 右翼ID, 玩家X + 40, 玩家Y - 2, 玩家Z + 10)
    移动3D物体(场景, 座舱ID, 玩家X, 玩家Y + 12, 玩家Z + 32)
    移动3D物体(场景, 引擎左ID, 玩家X - 16, 玩家Y, 玩家Z + 42)
    移动3D物体(场景, 引擎右ID, 玩家X + 16, 玩家Y, 玩家Z + 42)
}

函数 爆炸(中心X, 中心Y, 中心Z) {
    如果 (音效开关 == 真) {
        播放音效文件("资源/clear.wav")
    }
    变量 序号 = 0
    当 (序号 < 10) {
        变量 粒X = 中心X + 随机整数(-20, 20)
        变量 粒Y = 中心Y + 随机整数(-20, 20)
        变量 粒Z = 中心Z + 随机整数(-20, 20)
        变量 粒ID = 添加粒子(场景, 粒X, 粒Y, 粒Z, 10, 爆炸颜色)
        设置气泡材质(场景, 粒ID, 爆炸颜色)
        设置3D物体材质(场景, 粒ID, 爆炸颜色, 0.0, 8, 0.9, 0.1, 0.3, 0.95)
        列表追加(粒子ID, 粒ID)
        列表追加(粒子X, 粒X)
        列表追加(粒子Y, 粒Y)
        列表追加(粒子Z, 粒Z)
        列表追加(粒子VX, 随机整数(-16, 16))
        列表追加(粒子VY, 随机整数(-6, 20))
        列表追加(粒子寿命, 20)
        序号 = 序号 + 1
    }
}

函数 更新粒子() {
    变量 新ID = []
    变量 新X = []
    变量 新Y = []
    变量 新Z = []
    变量 新VX = []
    变量 新VY = []
    变量 新寿命 = []
    变量 序号 = 0
    当 (序号 < 列表长度(粒子ID)) {
        变量 余命 = 列表查询(粒子寿命, 序号) - 1
        如果 (余命 > 0) {
            变量 粒X = 列表查询(粒子X, 序号) + 列表查询(粒子VX, 序号)
            变量 粒Y = 列表查询(粒子Y, 序号) + 列表查询(粒子VY, 序号)
            变量 粒Z = 列表查询(粒子Z, 序号) + 10
            变量 粒VY = 列表查询(粒子VY, 序号) - 1
            移动3D物体(场景, 列表查询(粒子ID, 序号), 粒X, 粒Y, 粒Z)
            列表追加(新ID, 列表查询(粒子ID, 序号))
            列表追加(新X, 粒X)
            列表追加(新Y, 粒Y)
            列表追加(新Z, 粒Z)
            列表追加(新VX, 列表查询(粒子VX, 序号))
            列表追加(新VY, 粒VY)
            列表追加(新寿命, 余命)
        } 否则 {
            删除3D物体(场景, 列表查询(粒子ID, 序号))
        }
        序号 = 序号 + 1
    }
    粒子ID = 新ID
    粒子X = 新X
    粒子Y = 新Y
    粒子Z = 新Z
    粒子VX = 新VX
    粒子VY = 新VY
    粒子寿命 = 新寿命
}

函数 生成陨石() {
    如果 (计时 % 生成间隔 != 0) {
        返回
    }
    如果 (列表长度(陨石ID) >= 最大陨石数) {
        返回
    }
    变量 半径 = 随机整数(14, 30)
    变量 石X = 随机整数(-460, 460)
    变量 石Y = 随机整数(-40, 210)
    变量 石Z = 1050
    变量 石ID = 添加球体(场景, 石X, 石Y, 石Z, 半径, 陨石颜色)
    设置塑料材质(场景, 石ID, 陨石颜色)
    变量 速度 = 陨石基础速度 + 取整(分数 / 难度增长)
    如果 (速度 > 40) {
        速度 = 40
    }
    列表追加(陨石ID, 石ID)
    列表追加(陨石X, 石X)
    列表追加(陨石Y, 石Y)
    列表追加(陨石Z, 石Z)
    列表追加(陨石半径, 半径)
    列表追加(陨石速度, 速度)
}

函数 更新陨石() {
    变量 新ID = []
    变量 新X = []
    变量 新Y = []
    变量 新Z = []
    变量 新半径 = []
    变量 新速度 = []
    变量 序号 = 0
    当 (序号 < 列表长度(陨石ID)) {
        变量 石Z = 列表查询(陨石Z, 序号) - 列表查询(陨石速度, 序号)
        变量 石X = 列表查询(陨石X, 序号)
        变量 石Y = 列表查询(陨石Y, 序号)
        变量 半径 = 列表查询(陨石半径, 序号)
        变量 撞了 = 假
        如果 (石Z > 玩家Z - 90 且 石Z < 玩家Z + 90) {
            变量 差X = 玩家X - 石X
            变量 差Y = 玩家Y - 石Y
            如果 (差X > -60 且 差X < 60 且 差Y > -50 且 差Y < 50) {
                撞了 = 真
            }
        }
        如果 (撞了 == 真) {
            爆炸(石X, 石Y, 石Z)
            删除3D物体(场景, 列表查询(陨石ID, 序号))
            生命 = 生命 - 1
            如果 (音效开关 == 真) {
                播放音效文件("资源/drop.wav")
            }
            如果 (生命 <= 0) {
                游戏结束 = 真
                如果 (音效开关 == 真) {
                    播放音效文件("资源/gameover.wav")
                }
            }
        } 否则 {
            如果 (石Z < -480) {
                删除3D物体(场景, 列表查询(陨石ID, 序号))
                分数 = 分数 + 5
            } 否则 {
                移动3D物体(场景, 列表查询(陨石ID, 序号), 石X, 石Y, 石Z)
                列表追加(新ID, 列表查询(陨石ID, 序号))
                列表追加(新X, 石X)
                列表追加(新Y, 石Y)
                列表追加(新Z, 石Z)
                列表追加(新半径, 半径)
                列表追加(新速度, 列表查询(陨石速度, 序号))
            }
        }
        序号 = 序号 + 1
    }
    陨石ID = 新ID
    陨石X = 新X
    陨石Y = 新Y
    陨石Z = 新Z
    陨石半径 = 新半径
    陨石速度 = 新速度
}

函数 更新星空() {
    变量 新ID = []
    变量 新X = []
    变量 新Y = []
    变量 新Z = []
    变量 新速 = []
    变量 序号 = 0
    当 (序号 < 列表长度(星星ID)) {
        变量 星X = 列表查询(星星X, 序号)
        变量 星Y = 列表查询(星星Y, 序号)
        变量 星Z = 列表查询(星星Z, 序号) - 列表查询(星星速度, 序号)
        变量 速度 = 列表查询(星星速度, 序号)
        如果 (星Z < -430) {
            星Z = 1100
            星X = 随机整数(-700, 700)
            星Y = 随机整数(-120, 300)
            速度 = 随机整数(10, 40)
        }
        移动3D物体(场景, 列表查询(星星ID, 序号), 星X, 星Y, 星Z)
        列表追加(新ID, 列表查询(星星ID, 序号))
        列表追加(新X, 星X)
        列表追加(新Y, 星Y)
        列表追加(新Z, 星Z)
        列表追加(新速, 速度)
        序号 = 序号 + 1
    }
    星星ID = 新ID
    星星X = 新X
    星星Y = 新Y
    星星Z = 新Z
    星星速度 = 新速
}

函数 更新相机() {
    变量 跟随X = 玩家X * 45 / 100
    变量 摆动 = 正弦(计时 * 0.03) * 10
    相机运镜(场景, 跟随X + 摆动, 70, 0 - 相机距离, 跟随X * 0.4, 20, 300)
}

函数 绘制界面() {
    画布_清屏(九S画布())
    渲染3D场景(场景)
    画布_画文本(九S画布(), 20, 18, "分数: " + 文本(分数), 颜色_白, 22)
    画布_画文本(九S画布(), 20, 50, "生命: " + 文本(生命), 颜色_黄, 20)
    画布_画文本(九S画布(), 20, 80, "3D 原生 9S · 躲避陨石", 颜色_青, 15)
    画布_画文本(九S画布(), 20, 112, "帧率: " + 文本(取整(获取渲染帧率())) + " fps", 颜色_绿, 13)
    画布_画文本(九S画布(), 20, 560, "方向键 3D 移动　R 重开　ESC 退出", 颜色_白, 14)
    如果 (游戏结束 == 真) {
        画布_画文本(九S画布(), 250, 240, "坠毁！", 颜色_红, 44)
        画布_画文本(九S画布(), 240, 310, "按 R 键重新开始", 颜色_白, 20)
    }
}

函数 按键处理(键码) {
    如果 (游戏结束 == 假) {
        如果 (键码 == 键_左) {
            玩家X = 玩家X - 玩家速度
        }
        如果 (键码 == 键_右) {
            玩家X = 玩家X + 玩家速度
        }
        如果 (键码 == 键_上) {
            玩家Y = 玩家Y + 玩家速度
        }
        如果 (键码 == 键_下) {
            玩家Y = 玩家Y - 玩家速度
        }
        如果 (玩家X < -360) {
            玩家X = -360
        }
        如果 (玩家X > 360) {
            玩家X = 360
        }
        如果 (玩家Y < -40) {
            玩家Y = -40
        }
        如果 (玩家Y > 180) {
            玩家Y = 180
        }
        移动战机()
    }
    如果 (键码 == 键_R) {
        初始化()
    }
    如果 (键码 == 键_退出) {
        关闭窗口()
        返回
    }
    请求重绘()
}

函数 帧刷新() {
    如果 (游戏结束 == 假) {
        计时 = 计时 + 1
        如果 (计时 % 30 == 0) {
            分数 = 分数 + 1
        }
        更新星空()
        生成陨石()
        更新陨石()
        更新粒子()
        更新相机()
    }
    请求重绘()
}

窗口 = 创建窗口("九艾斯3D躲避陨石 · 可改配置", 800, 600)
画布 = 九S画布(窗口)
初始化()
设置绘制函数(绘制界面)
设置按键函数(按键处理)
设置定时器(33, 帧刷新)
显示窗口()
请求重绘()
启动消息循环()