猫史档案馆

从2019年入岛，到现在2022年已经4年了。

从最初的月球大战到现在的战地风云（最后一次上线看到的就是这个）

一代一代的创作者如长江之浪，后浪推前浪……

一个个老创作者的隐去，一个个新创作者的崛起，和永恒的起床……

岛三，不，神奇代码岛的风气也不如从前了。

也许老玩家被遗忘也是注定的吧，色盲派对，我不会再维护了，永别了，代码岛3.0，神奇代码岛，陪伴我4个春秋的度过，从3年级到6年级，也在今天别去……

色盲代码如下，希望新的创作者能创作出更好的作品，以后不会上岛，甚至来不了编程猫了。Q（屏蔽词）Q号2305039082，现在就玩猫鼠，MC（java版）这两个游戏了，神岛已经没有那些我熟悉的人了。

console.clear()
async function createTables() {
    await db.sql`CREATE TABLE IF NOT EXISTS mouren`

}

//不想写了
//datacta:代码可以自动化
//like this:
const voxellist = ['red', 'orange', 'black', 'air'];
var kings = ["名字鬼知道", "MX的一只萌新"]
var badmen = ["e5f02wPeVuWXbgu", "Y7jwvsBzRSP8B喵"]
//以下是喵all的
async function BOOM() {
    world.sunPhase = 0.8
    const Quat = new Box3Quaternion(0, 0, 0, 1) //默认的旋转状态
    const RED = new Box3RGBColor(0.5, 0, 0) //发光的红色
    await sleep(3000)
    world.say("聚变打击即将来袭！")
    const boom = world.createEntity({
        mesh: 'mesh/核弹.vb',
        meshScale: [1 / 2, 1 / 2, 1 / 2],
        position: [100, 50, 18],
        particleRate: 80, //每秒发出80个粒子
        particleLifetime: 2, //每个粒子存活2秒
        particleColor: [RED, RED, RED, RED, RED], //粒子在5个阶段的颜色都是红色
        particleSize: [10, 10, 10, 10, 10], //粒子在5个阶段的大小都是2
        gravity: false,
    })
    boom.meshOrientation = Quat.rotateY(Math.PI / -2)
    await sleep(5000)
    world.say("核弹即将发射")
    await sleep(3000)
    world.say("倒计时:")
    await sleep(1000)
    boom.meshEmissive = 0.3
    world.say("5")
    await sleep(1000)
    boom.meshEmissive = 0
    world.say("4")
    await sleep(1000)
    boom.meshEmissive = 0.3
    world.say("3")
    await sleep(1000)
    boom.meshEmissive = 0
    world.say("2")
    await sleep(1000)
    boom.meshEmissive = 0.3
    world.say("1")
    for (let i = 0; i < 100; i++) {
        await sleep(50)
        boom.position.x -= 1
    }
    world.say("BOOM！")
    boom.destroy()
    world.sunPhase = 0.25
    await sleep(3000)
    world.say("注意持续辐射伤害！！！")
    world.querySelectorAll("player").forEach(async (e) => {
        while (e.hp > 0) {
            await sleep(1000)
            e.hp -= 1
            console.log(e.hp)
        }
    })
}
async function killBox(pos, size, fn) {
    const entities = world.searchBox({
        lo: [pos.x - size, pos.y - size, pos.z - size],
        hi: [pos.x + size, pos.y + size, pos.z + size],
    })
    for (const e of entities) {
        e.hurt(5)
        fn(e)
    }
}
async function makeDamage(e, dmg, color) {
    //e.meshcolor.copy(color)
    await sleep(500)
    //e.meshcolor.set(1,1,1)
}
const RED = new Box3RGBAColor(1, 0, 0, 1)
const GREEN = new Box3RGBAColor(0, 1, 0, 1)
const BLUE = new Box3RGBAColor(0, 0, 1, 1)
world.addCollisionFilter('player', 'player')
//这是林思其贵的
var nowPlayer = []
var gamePlayer = []
world.onChat(async ({ entity: e, message }) => {
    if (e && e.isPlayer) {
        if (e && '名字鬼知道 各字鬼知道 MX的一只萌新'.split(' ').indexOf(e.player.name) != -1 && message.charAt(0) == '/') {
            try {
                world.say('执行 ' + eval(message.split('/')[1]))
            } catch (err) {
                world.say('错误:' + err)
            }
        };
    }
})
//shyfcka的
async function ban(bans) {
    world.querySelectorAll('player').forEach(async (bad) => {
        if (bad.player.name.includes(bans)) {
            world.say(`管喵把${bad.player.name}踢出了房间并长期禁言`)
            bad.player.muted = true
            badmen.push(bad.player.boxId)
            bad.player.kick()
            
        }
    })
}
world.onPlayerJoin(({ entity }) => {
    entity.awa = 0
    if (badmen.includes(entity.player.boxId)) {
        entity.player.muted = true
        entity.player.directMessage("您已被永久禁言，请勿刷新")
    }
    entity.player.helper = false;
    if (kings.includes(entity.player.name)) {
        entity.player.muted = false
    }
})
world.onChat(async ({ message, entity }) => {
    if (message == '/help') {
        entity.player.dialog({
            type: Box3DialogType.TEXT,
            title: `帮助`,
            content: `本游戏为淘汰赛\n地面将会随机变色，随着变色会越来越不牢固\n颜色代表牢固等级：白>黄>橙>红>黑，当黑色方块变色时将会消失\n掉下虚空将会被淘汰，存活到最后吧！`
        })
    }
})
var skillList = [
    `主动-击退棒`,
    "主动-地雷",
    '主动-回旋镖',
    "主动-末影珍珠",
    `主动-TNT`,
    `主动-冲刺`,
    `主动-屏障`,
    `主动-锤子`,
    `被动-跳跃增强`,
    `被动-隐身`,
]
var skillIntroduce = [
    `击退棒：按下左键发出剑刃，造成击退效果。（CD：3）`,
    "地雷:按下左键放置地雷，放置后地雷会在2秒后进入隐藏状态。(CD:10)",
    '回旋镖:按下左键发出回旋镖，途中碰到敌人造成持续伤害/轻微击退效果(CD:4)',
    "末影珍珠:按下左键后发射一枚珍珠，经过抛物线后落地/珍珠落地玩家传送/珍珠传送距离过近不会传送(防止卡下虚空)(CD:3)",
    `TNT：按下左键后放置1个TNT，闪烁3秒后令附近4x4的地板牢固等级-3。（CD：6）`,
    `冲刺：按下左键后向目标冲刺一段距离。（CD：1.5）`,
    `屏障：按下左键后放置一个3X3的屏障，持续5秒（CD：8）`,
    `锤子：按下左键后修复3x3的地方至白色方块（CD:300）`,
    `跳跃增强：跳跃永远增强，可以二段跳。`,
    `隐身：永远隐身。`,
]
world.onPlayerJoin(async ({ entity: e }) => {
    e.hurtType = ""
    e.player.help = 1
    e.id = e.player.userKey
    world.addCollisionFilter('#' + e.id, '#' + e.id)
    nowPlayer.push(e.player.name)
    console.log('目前人员' + nowPlayer)
    e.player.directMessage(`欢迎来到《色盲派对》！说/help获取帮助，非游戏状态下，按下右键切换技能！`)
    e.player.skill = '主动-击退棒'
    e.hp = 20
    e.player.kill=0
    e.maxHp = 20
    if (e.player.name == '名字鬼知道' || e.player.name == '名字鬼知道') {
        world.say(`作者驾到！`)
        const fly = await e.player.dialog({
            type: Box3DialogType.SELECT,
            title: `开启作者模式`,
            content: `敬爱的名字鬼知道大人，是否开启作者模式？`,
            options: ['是', '不是']
        })
        if (fly.index == 0) {
            e.player.canFly = true
            e.maxHp = Infinity
            e.hp = e.maxHp
            e.player.emissive = 1
        }
    }
    if (e.player.name == 'ZXYTVAUSKS闪电祖z8寻狼王') {
        e.hp = 50
        e.maxHp = 50
        e.player.jumpPower = 1.15
        e.player.jumpSpeedFactor = 1.15
        e.player.emissive = 1
        e.player.directMessage('您是大神，自带低配版的跳跃加强，血量上限为50，击退棒伤害翻倍并发出光芒')
        e.player.enableDoubleJump = true
    }
    if (e.player.name == '帆一凡'||e.player.name == '花灾悲凉'||e.player.name == '冷胖') {
        e.hp = 30
        e.maxHp = 30
        e.player.emissive = 1
        e.player.directMessage('您是测试员，血量上限为30，并且发光')
    }
    e.player.helper = false;
    e.player.cool = 0
    e.player.win = 0
    e.player.enableDoubleJump = false;
    e.player.enemy = 0
    e.player.scale = 0.8
    e.player.enable3DCursor = true
    e.player.spectator = true;
    e.player.showName = false;
    e.player.invisible = true;
    await sleep(100)
    if (nowPlayer.length < 2) {
        e.player.dialog({
            type: Box3DialogType.TEXT,
            title: `${e.player.name}，非常抱歉`,
            content: `尊敬的${e.player.name}，人数还未满2人，游戏无法开始，请您耐心等待其他人进入，敬请谅解。`
        })
    } else if (nowPlayer.length > 2) {
        e.player.dialog({
            type: Box3DialogType.TEXT,
            title: `${e.player.name}，非常抱歉`,
            content: `尊敬的${e.player.name}，游戏正在进行，无法中途加入，请您耐心等待下局开始，敬请谅解。`
        })
    }
    e.player.onPress(async ({ button, raycast: { direction, distance, normal, voxelIndex, hitEntity }, raycast }) => {
        if (button == Box3ButtonType.ACTION1 && !gamePlayer.includes(e.player.name)) {
            const r = await e.player.dialog({
                type: Box3DialogType.SELECT,
                title: `目前技能${e.player.skill}`,
                content: `主动技能点击左键释放。\n被动技能为永远加强。`,
                options: skillList,
            })
            if (!r || r === null) { return; }
            await e.player.dialog({
                type: Box3DialogType.SELECT,
                title: `准备选择技能：${skillList[r.index]}`,
                content: skillIntroduce[r.index],
                options: [`确定`],
            })
            e.player.skill = skillList[r.index]
            e.player.directMessage(`技能切换到：${e.player.skill}`)
            if (e.player.skill == '被动-跳跃增强') {
                e.player.helper = false;
                e.player.jumpPower = 1.45
                e.player.jumpSpeedFactor = 1.45
                e.player.enableDoubleJump = true
                e.player.cameraMode = "follow"
            }
        } else {
            e.player.walkSpeed = 0.22
            e.player.runSpeed = 0.4
            e.player.jumpPower = 0.96
            e.player.jumpSpeedFactor = 0.85
            e.player.enableDoubleJump = false
            e.player.cameraMode = "follow"
            if (e.player.name == 'ZXYTVAUSKS闪电祖z8寻狼王') {
                e.player.jumpPower = 1.15
                e.player.jumpSpeedFactor = 1.15
                e.player.enableDoubleJump = true
            }
        }
        if (e.player.skill == '被动-隐身') {
            e.player.helper = false;
            e.player.invisible = true
        } else if (e.player.skill != '被动-隐身' && gamePlayer.includes(e.player.name)) {
            e.player.helper = false;
            e.player.invisible = false

        } else if (e.player.skill == "被动-救援平台") {
            e.player.helper = true;
        }
        //}
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && e.player.skill == '主动-击退棒' && e.player.cool == 0) {
            e.player.helper = false;
            e.player.cool = 1
            const MeshScale = [1 / 16, 1 / 16, 1 / 16] //正常的模型缩放比例
            const Quat = new Box3Quaternion(0, 0, 0, 1) //默认的旋转状态
            const RED = new Box3RGBColor(255, 250, 250) //发光的红色
            const d = e.player.facingDirection //玩家的朝向
            const knife = world.createEntity({
                meshScale: MeshScale,
                mesh: 'mesh/刀光.vb',
                collides: true, // 开启碰撞
                gravity: false, // 不受重力影响
                position: e.position, // 在玩家的位置生成飞刀
                velocity: d.scale(4), // 飞刀的初速度是玩家朝向向量的2倍
                meshOrientation: Quat.rotateY(Math.atan2(d.z, d.x)), // 刀头指向玩家的朝向
                particleRate: 20, //每秒发出80个粒子
                particleLifetime: 2, //每个粒子存活2秒
                particleSize: [2, 2, 2, 2, 2], //粒子在5个阶段的大小都是2
                particleColor: [RED, RED, RED, RED, RED], //粒子在5个阶段的颜色都是红色
                // particleTarget: entity,
                particleVelocity: d.scale(-2),
                bounds: [0.5, 0.5, 0.5],// 子弹实体0.2个方块大小
            })
            knife.id = e.player.userKey //将小刀的id设置成玩家userKey, 便于碰撞过滤器识别
            knife.onEntityContact(({ other }) => {//每当飞刀碰到另一个实体
                if (!other.isPlayer) { return }
                other.velocity.x += direction.x * 4//被碰实体受10点伤害
                other.velocity.z += direction.z * 4
                other.hurtType = "击退棒"
                if (e.player.name == '名字鬼知道' || e.player.name == '各字鬼知道' || e.player.name == '各字鬼知道' || e.player.name == 'ZXYTVAUSKS闪电祖z8寻狼王') {
                    other.hurt(5, {
                        attacker: e,
                    })
                } else {
                    other.hurt(3, {
                        attacker: e,
                    })
                }
                knife.destroy()
            })
            for (let q = 0; q < 51; q++) {
                await sleep(20)
                knife.meshOrientation = knife.meshOrientation.rotateY(Math.PI / 2)
            }//等2秒后
            if (knife) {
                knife.destroy()//清除飞刀, 防止飞刀数量太多超过服务器负载
            }
            await sleep(2000)//2000
            e.player.cool = 0
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && e.player.skill == '主动-回旋镖' && e.player.cool == 0) {
            e.player.helper = false;
            e.player.cool = 3
            const MeshScale = [1 / 16, 1 / 16, 1 / 16] //正常的模型缩放比例
            const Quat = new Box3Quaternion(0, 0, 0, 1) //默认的旋转状态
            const RED = new Box3RGBColor(1, 0, 0) //发光的红色
            const d = e.player.facingDirection //玩家的朝向
            const knife = world.createEntity({
                meshScale: MeshScale,
                mesh: 'mesh/刀光.vb',
                collides: true, // 开启碰撞
                gravity: false, // 不受重力影响
                position: e.position, // 在玩家的位置生成飞刀
                meshOrientation: Quat.rotateY(Math.atan2(d.z, d.x)), // 刀头指向玩家的朝向
                particleRate: 40, //每秒发出80个粒子
                particleLifetime: 1.1, //每个粒子存活2秒
                particleSize: [1, 4, 3, 2, 4], //粒子在5个阶段的大小都是2
                particleColor: [RED, RED, RED, RED, RED], //粒子在5个阶段的颜色都是红色
                particleVelocity: d.scale(-2),
                bounds: [0.5, 0.5, 0.5],// 子弹实体0.2个方块大小
            })
            knife.id = e.player.userKey
            knife.onEntityContact(async ({ entity, other }) => {
                if (!other.isPlayer) { return }
                other.hurt(1, { attacker: e, })
            })
            for (let i = 0; i < 2; i++) {
                for (let q = 0; q < 30; q++) {
                    await sleep(10)
                    knife.velocity.x += direction.x * 0.2
                    knife.velocity.z += direction.z * 0.2
                    knife.meshOrientation = knife.meshOrientation.rotateY(Math.PI / 2)
                }
                for (let q = 0; q < 30; q++) {
                    await sleep(5)
                    knife.meshOrientation = knife.meshOrientation.rotateY(Math.PI / 2)
                }
                for (let q = 0; q < 30; q++) {
                    await sleep(10)
                    knife.velocity.x -= direction.x * 0.2
                    knife.velocity.z -= direction.z * 0.2
                    knife.meshOrientation = knife.meshOrientation.rotateY(Math.PI / 2)
                }
                for (let q = 0; q < 30; q++) {
                    await sleep(5)
                    knife.meshOrientation = knife.meshOrientation.rotateY(Math.PI / 2)
                }
            }
            if (knife) {
                knife.destroy()//清除飞刀, 防止飞刀数量太多超过服务器负载
            }
            await sleep(4000)
            e.player.cool = 0
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && e.player.skill == '主动-冲刺' && e.player.cool == 0) {
            e.player.helper = false;
            e.player.cool = 1
            e.velocity.y += 3
            e.velocity.x += direction.x * 10
            e.velocity.z += direction.z * 10

            await sleep(1500)//1500
            e.player.cool = 0
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && distance < 14 && e.player.skill == '主动-TNT' && e.player.cool == 0) {
            e.player.helper = false;
            e.player.cool = 1
            let v = voxelIndex.add(normal);
            console.log(v)
            boom()
            async function boom() {
                const boom = world.createEntity({
                    mesh: 'mesh/我的世界:TNT.vb',
                    collides: true, // 开启碰撞
                    gravity: true, // 不受重力影响
                    position: new Box3Vector3(v.x, v.y + 2, v.z), // 在玩家的位置生成飞刀
                    meshScale: new Box3Vector3(1.5 / 16, 1.5 / 16, 1.5 / 16),
                    tags:[e.player.name]
                })

                for (let i = 0; i < 4; i++) {
                    boom.meshEmissive = 1
                    await sleep(500)
                    boom.meshEmissive = 0
                    await sleep(500)
                }
                for (let i = boom.position.x - 2; i < boom.position.x + 3; i++) {
                    for (let j = boom.position.z - 2; j < boom.position.z + 3; j++) {
                        for (let k = boom.position.y - 2; k < boom.position.y + 3; k++) {
                            if (voxels.name(voxels.getVoxel(i, k, j)) == 'white') {
                                voxels.setVoxel(i, k, j, 'red')
                            } else if (voxels.name(voxels.getVoxel(i, k, j)) == 'lemon') {
                                voxels.setVoxel(i, k, j, 'black')
                            } else if (voxels.name(voxels.getVoxel(i, k, j)) == 'orange') {
                                voxels.setVoxel(i, k, j, 'air')
                            } else if (voxels.name(voxels.getVoxel(i, k, j)) == 'red') {
                                voxels.setVoxel(i, k, j, 'air')
                            } else if (voxels.name(voxels.getVoxel(i, k, j)) == 'black') {
                                voxels.setVoxel(i, k, j, 'air')
                            }
                        }
                    }
                }
                const size = 4
                killBox(boom.position, size, (en) => {
                    en.hurtType = "TNT"
                    if(en.isPlayer){
                    en.player.enemy = boom.tags[0]
                    }
                })
                boom.destroy()
            }
            await sleep(6000)//3k
            e.player.cool = 0
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && distance < 14 && e.player.skill == '主动-屏障' && e.player.cool == 0) {
            e.player.cool = 1
            let v = voxelIndex.add(normal);
            console.log(v)
            for (let i = v.x - 1; i < v.x + 2; i++) {
                for (let j = v.z - 1; j < v.z + 2; j++) {
                    for (let k = v.y; k < v.y + 3; k++) {
                        voxels.setVoxel(i, k, j, 'bounce_pad')
                    }
                }
            }
            await sleep(5000)
            for (let i = v.x - 1; i < v.x + 2; i++) {
                for (let j = v.z - 1; j < v.z + 2; j++) {
                    for (let k = v.y; k < v.y + 3; k++) {
                        voxels.setVoxel(i, k, j, 'air')
                    }
                }
            }
            await sleep(3000)
            e.player.cool = 0
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && e.player.skill == '主动-末影珍珠' && e.player.cool == 0) {
            e.player.helper = false
            e.player.cool = 1
            const ball = world.createEntity({
                mesh: 'mesh/珍珠.vb',
                gravity: true,
                fixed: false,
                collides: false,
                meshScale: [1 / 16, 1 / 16, 1 / 16],
                mass: 9999,
                position: [e.position.x, e.position.y + 2, e.position.z]
            })
            var loss = 0
            for (let i = 0; i < 20; i++) {
                if (voxels.getVoxel(ball.position.x, ball.position.y, ball.position.z) != 0) {
                    break;
                }
                await sleep(10)
                ball.position.x += direction.x / 10
                ball.position.z += direction.z / 10
                ball.position.y += direction.y * 2
                loss += 0.01
            }
            for (let i = 0; i < 40; i++) {
                ball.position.x += direction.x / 20
                ball.position.z += direction.z / 20
                ball.position.y += direction.y
                loss += 0.01
                if (voxels.getVoxel(ball.position.x, ball.position.y, ball.position.z) != 0) {
                    break;
                }
                await sleep(10)
            }
            while (voxels.getVoxel(ball.position.x, ball.position.y - 1, ball.position.z) == 0 && ball.position.y > 31) {
                loss += 0.01
                ball.position.x += direction.x / 3
                ball.position.z += direction.z / 3
                await sleep(10)
            }
            if (ball.position.y < 34 && ball.position.x < 33 && ball.position.z < 32 && ball.position.x >= 0 && ball.position.z >= 0 && ball.position.y >= 31) {
                e.position.set(ball.position.x, ball.position.y + 2, ball.position.z)
                e.player.cool = 0
            }
            ball.destroy()
            await sleep(3000)
            e.player.cool = 0
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && distance < 14 && e.player.skill == '主动-地雷' && e.player.cool == 0) {
            e.player.cool = 1
            let v = voxelIndex.add(normal);
            const dl = world.createEntity({
                mesh: "mesh/地雷.vb",
                meshEmissive: 0.3,
                position: [v.x, v.y + 0.5, v.z],
                gravity: true,
                tags: ["地雷",e.player.name],
                fixed: true
            })
            dl.onEntityContact(({ entity ,other}) => {
                killBox(entity.position, 1, ((en) => {
                    en.hurtType = "地雷"
                    console.log (en)
                    console.log(en.isPlayer)
                    if(en.isPlayer){
                    en.player.enemy = dl.tags[1]}
                }))
                entity.destroy()
            })
            await sleep(2000)
            dl.position.y -= 0.69
            await sleep(10000)
            e.player.cool = 0
            await sleep (280000)
            if(dl){
            dl.destroy()
            }
        }
        if (button == Box3ButtonType.ACTION0 && gamePlayer.includes(e.player.name) && distance < 14 && e.player.skill == '主动-锤子' && e.player.cool == 0) {
            e.player.helper = false;
            e.player.cool = 25
            let v = voxelIndex.add(normal);
            console.log(v)
            for (let i = v.x - 1; i < v.x + 2; i++) {
                for (let k = v.z; k < v.z + 3; k++) {
                    voxels.setVoxel(i, 32, k, 'white')
                }

            }
        }
    })

})
world.onPlayerLeave(({ entity }) => { //当玩家离开地图时
    world.removeCollisionFilter('#' + entity.id, '#' + entity.id)//取消这个玩家的碰撞过滤器
    nowPlayer.splice(nowPlayer.indexOf(entity.player.name), 1);
    if (gamePlayer.includes(entity.player.name)) {
        gamePlayer.splice(gamePlayer.indexOf(entity.player.name), 1);
    }
    if (winnerName == entity.player.name) {
        winnerName = '不在地图'
        winnerGames = 0
    }
})
/*


*/
world.onDie(async ({ attacker, entity }) => {
    if (!entity.isPlayer) { return }
    console.log(gamePlayer.indexOf(entity.player.name))
    gamePlayer.splice(gamePlayer.indexOf(entity.player.name), 1);
    console.log(gamePlayer)
    if (entity.hurtType=="虚空") {
        world.say(`${entity.player.name}掉下了虚空，剩余${gamePlayer.length}人！`)
    } else if (entity.hurtType == "击退棒") {
        world.say(`${entity.player.name}被${attacker.player.name}利用击退棒打喵了，剩余${gamePlayer.length}人！`)
        attacker.hp+=5
        attacker.kill+=1
        if(attacker.hp>attacker.maxHp){
            attacker.hp=attacker.maxHp
        }
        attacker.player.directMessage("杀敌恢复5血！")
    } else if (entity.hurtType == "地雷") {

        world.say(`${entity.player.name}走路不看路，被地雷炸喵了，剩余${gamePlayer.length}人！`)

    } else if (entity.hurtType == "回旋镖") {
        if (entity != attacker) {
            world.say(`${entity.player.name}被${attacker.player.name}利用回旋镖打喵了，剩余${gamePlayer.length}人！`)
            attacker.hp+=5
            attacker.kill+=1
            if(attacker.hp>attacker.maxHp){
                attacker.hp=attacker.maxHp
            }
            attacker.player.directMessage("杀敌恢复5血！")
        }else{
            world.say(`${entity.player.name}玩回旋镖的时候失手，剩余${gamePlayer.length}人！`)
        }
    } else if (entity.hurtType == "TNT") {
        world.say(`${entity.player.name}被炸喵了，剩余${gamePlayer.length}人！`)
    }
    entity.player.spectator = true;
    entity.player.showName = false;
    entity.enableDamage = false
    entity.player.invisible = true;
    entity.player.cool = 1
    entity.player.forceRespawn()
    entity.position.y = 35
    entity.hurtType = ""
    entity.player.dialog({
        type: Box3DialogType.TEXT,
        title: `你被淘汰了！`,
        content: `非常遗憾，你被淘汰了，请等待下局开始！`
    })
})
function randomNum(minNum, maxNum) {
    switch (arguments.length) {
        case 1:
            return parseInt(Math.random() * minNum + 1, 10);
            break;
        case 2:
            return parseInt(Math.random() * (maxNum - minNum + 1) + minNum, 10);
            break;
        default:
            return 0;
            break;
    }
}
world.onTick(async ({ tick }) => {
    if (tick % 1 == 0) {
        world.querySelectorAll('player').forEach(async (g) => {
            if (g.position.y < 25 && gamePlayer.includes(g.player.name)) {//以下为萌新写的救援平台
                console.log(`${g.player.name} ${g.player.skill} ${g.player.help}`)
                entity = g;
                g.hurt(99999999)
                g.hurtType="虚空"
            }
        })
    }
})

start()
PLAYER = []
BADER=[]
async function start() {
    gamePlayer = []
    while (1) {
        for (let i = 0; i < 11; i++) {
            await sleep(1000)
            if (nowPlayer.length >= 2) {
                break;
            }
        }
        //world.say(`需要2人以上开始游戏！`)
        if (nowPlayer.length >= 2) {
            break;
        }
        world.say(`需要2人以上开始游戏！`)
    }
    await sleep(3000)
    world.querySelectorAll('.地雷').forEach(async (g) => {
        g.destroy()
    })
    world.say('游戏开始！')
    world.querySelectorAll('player').forEach(async (g) => {
        g.player.help = 1
        g.player.cool = 0;
        //console.log('在线玩家' + gamePlayer)
        gamePlayer.push(g.player.name)
        g.player.spectator = false;
        g.player.showName = true;
        if (g.player.s喵 != '被动-隐身') {
            g.player.invisible = false;
        }
        g.hp = g.maxHp
        g.enableDamage = true;
        g.position.set(Math.random() * 29 + 2, 35, Math.random() * 29 + 2)
        await g.player.dialog({
            type: Box3DialogType.SELECT,
            content: `请确认开始！`,
            options: ['确定']
        })
    })
    const bounds = new Box3Bounds3(new Box3Vector3(-50, 0, -50), new Box3Vector3(128, 喵, 128));
    world.searchBox(bounds).forEach(async (entityInBounds) => {
        if (entityInBounds.isPlayer) {
            PLAYER.push(entityInBounds.player.name)
        }
    });
        world.say(`所有玩家：${PLAYER}`)
        PLAYER = []
        game()
    
}
var shijian = 0
async function game() {
    while (true) {
        if (gamePlayer.length > 1) {
            await sleep(7500)
            shijian+=7.5
            for (let i = 0; i < 100; i++) {
                for (let j = 0; j < 100; j++) {
                    if (Math.random() * 20 < 2.5) {
                        for (let i = 0; i < 5; i++) {
                        }
                        if (voxels.name(voxels.getVoxel(i, 32, j)) == 'white') {
                            voxels.setVoxel(i, 32, j, 'lemon')
                        } else if (voxels.name(voxels.getVoxel(i, 32, j)) == 'lemon') {
                            voxels.setVoxel(i, 32, j, 'orange')
                        } else if (voxels.name(voxels.getVoxel(i, 32, j)) == 'orange') {
                            voxels.setVoxel(i, 32, j, 'red')
                        } else if (voxels.name(voxels.getVoxel(i, 32, j)) == 'red') {
                            voxels.setVoxel(i, 32, j, 'black')
                        } else if (voxels.name(voxels.getVoxel(i, 32, j)) == 'black') {
                            voxels.setVoxel(i, 32, j, 'air')
                        }
                    }
                }
            }
            if (gamePlayer.length < 2) {
                shijian=0
                break;
            }
            if (shijian > 300) {
                world.say("检测到5分钟游戏还没结束，强制重启")
                while(true){
                    world
                }
            }
        }
    }
    if (gamePlayer.length == 1) {
        const winPlayer = world.querySelectorAll('player').filter(e => e.player.name === gamePlayer[0])[0];
        world.say('游戏结束！胜利者：' + gamePlayer + '！他的击杀数'+winPlayer.player.喵)
        winPlayer.player.win += 1
        if (winPlayer.player.win > winnerGames) {
            winnerName = winPlayer.player.name
            winnerGames = winPlayer.player.win
            winPlayer.player.directMessage('你打破了本场游戏最高胜局！')
        }
    } else {
        world.say('游戏结束！和局，无人胜利！')
    }
    gamePlayer = []
    await sleep(5000)
    world.say(`游戏重启……目前最高胜局记录保持者：${winnerName}/${winnerGames}场！`)
    for (let i = 0; i < 33; i++) {
        for (let j = 0; j < 33; j++) {
            voxels.setVoxel(i, 32, j, 'white')
        }
    }
    await sleep(3000)
    gamePlayer = []
    start()
}
var winnerName = '无'
var winnerGames = 0

753行的代码，还有很大一部分是没用的，自己抄去吧，我也不追究了……