/*
得分：Math.round(造成伤害对应损失/100),占领1格据点获得500分，每格据点被占领扣500分


*/



let redScore = 0;
let blueScore = 0;
let gameStart = false;
let bluePos = [];
let redPos = [];
let map1 = [];//普通地图
let map2 = [];//海岛战争
global.map1 = map1
global.map2 = map2
let map = '海岛战争';
(async function gameMain() {
    await sleep(100);
    var gameNum = 0;
    for (let x = 0; x < 256; x++) {
        for (let z = 0; z < 256; z++) {
            var y = [0, 30]
            for (let a in y) {
                var az = y[a]
                var voxelName = voxels.name(voxels.getVoxelId(x, az, z))
                if (dx[voxelName]) {
                    if (dx[voxelName].lx == '资源') {
                        voxels.setVoxel(x, az, z, dx[voxelName].forward)
                    }
                }
                global[`map${parseInt(a) + 1}`].push([x, z, voxels.getVoxelId(x, az, z)])
                voxels.setVoxelId(x, az, z, 0)
            }
        }
    }
    while (1) {
        await sleep(2000);
        if (world.querySelectorAll('player').length > 1) {
        } else {
            world.say('人数不足2人，无法开始游戏！快去邀请人吧！')
            continue;
        }
        gameNum++
        world.querySelectorAll('.士兵').forEach((e) => {
            e.destroy();
        })
        world.querySelectorAll('.占领标识').forEach((e) => {
            e.destroy();
        })
        for (let x = 0; x < 256; x++) {
            for (let z = 0; z < 256; z++) {
                var id = voxels.getVoxelId(x, 0, z)
                var name = voxels.name(id)
                if (name == 'blue_light' || name == 'red_light') {
                    voxels.setVoxel(x, 0, z, 'white_light')
                }
            }
        }
        let mapList = []
        if (map == '普通地图') {
            map = '海岛战争'
            mapList = map2
        } else if (map == '海岛战争') {
            map = '普通地图';
            mapList = map1
        }
        for (let i in mapList) {
            voxels.setVoxelId(mapList[i][0], 0, mapList[i][1], mapList[i][2])
        }
        world.say(`开启新一局游戏！本次地图：${map}`);
        redScore = 0;
        blueScore = 0;
        var players = world.querySelectorAll('player');

        redPos = []
        bluePos = []
        for (let x = 0; x < 256; x++) {
            if (dx[getPosVoxel(x, 1.5)].name == '陆军基地') {
                redPos.push([x + 0.5, 1.5])
            }
            if (dx[getPosVoxel(x, 253.5)].name == '陆军基地') {
                bluePos.push([x + 0.5, 253.5])
            }
        }

        while (players.length > 0) {
            var num = Math.floor(Math.random() * players.length)
            var player = players[num]
            player.isCommander = false;
            player.score = 0;
            player.money = 10000;
            player.jd = ''
            player.team = '旁观者'
            player.removeTag('红队');
            player.removeTag('蓝队')
            if (world.querySelectorAll('.蓝队').length < world.querySelectorAll('.红队').length) {
                joinTeam(player, '蓝队');
            } else if (world.querySelectorAll('.红队').length < world.querySelectorAll('.蓝队').length) {
                joinTeam(player, '红队')
            } else {
                if (Math.random() < 0.5) {
                    joinTeam(player, '蓝队')
                } else {
                    joinTeam(player, '红队')
                }
            }
            var list = []
            for (let i in players) {
                if (i != num) {
                    list.push(players[i])
                }
            }
            players = list
        }
        gameStart = true;
        for (world.gameTime = 0; world.gameTime < 5400; world.gameTime++) {
            if (world.querySelectorAll('player').length <= 1) {
                continue;
            }
            if (blueScore >= 1000000) {
                break;
            };
            if (redScore >= 1000000) {
                break;
            };
            if (gameStart == false) {
                break;
            }
            if (world.gameTime == 1800) {
                world.say('游戏已经过去一半，继续努力！')
            } else if (world.gameTime % 120 == 0) {
                world.say(`游戏时间：${world.gameTime / 120}分钟/45分钟`)
            }
            await sleep(500)
        }
        world.querySelectorAll('player').forEach((e) => {
            e.removeTag('inGame')
        })
        gameStart = false;
        var winTeam = '平局'
        if (blueScore >= 1000000 && redScore <= 1000000) {
            winTeam = '蓝队'
        }
        if (redScore >= 1000000 && blueScore <= 1000000) {
            winTeam = '红队'
        }
        if (blueScore > redScore) {
            winTeam = '蓝队';
        }
        if (redScore > blueScore) {
            winTeam = '红队'
        }
        let mvp = ''
        for (let i of players) {
            if (mvp == '') {
                mvp = i
            }
            if (i.score > mvp.score) {
                mvp = i
            }
        }
        if (!mvp) {
            mvp = { 'player': { name: '无mvp' } }
        }
        if (winTeam != '平局') {
            world.say(`${winTeam}胜利！本局mvp：${mvp.player.name}`)
        } else {
            world.say(`平局！本局mvp：${mvp.player.name}`)
        }
        world.querySelectorAll(`.${winTeam}`).forEach((e) => {
            e.player.directMessage(`你在本局中胜利～获得了军衔星*1和军团币*1000`)
            e.star += 1;
            e.coin += 1000;
        })
        world.querySelectorAll('player').forEach((e) => {
            if (mvp == e) {
                e.player.directMessage('你在本局中获得了mvp～获得了1000军团币和定点迁城*1');
                e.coin += 1000;
                e.bag['定点迁城'] += 1
            }
        })

        if (gameNum == 10) {
            world.say('为了更好的游戏体验，5局时所有玩家的进度都保存，10秒后重启');
            world.querySelectorAll('player').forEach((e) => {
                savePlayer(e)
            })
            await sleep(10000);
            world.say('开始重启...')
            eval('for(;;){}')
        }
    }
})();


async function chooseCommander(team, reason = '') {
    var nameList = []//名字列表
    var playerList = world.querySelectorAll(`.${team}`).sort(function (a, b) { a.star > b.star })
    var scoreList = []//票数列表
    for (let i of playerList) {
        if (i.star > 3) {
            nameList.push(i.player.name)
            scoreList.push(0)
        }
    }
    world.querySelectorAll(`.${team}`).forEach(async (e) => {
        var result = await e.player.dialog({
            type: Box3DialogType.SELECT,
            title: '指挥官投票',
            content: `${reason}我们进行一次本次军事演习的总指挥官投票，请在下列玩家中选出你认为可以胜任本队指挥官的玩家名字～`,
            options: nameList,
        })
        if (!result || result == null) {
            return e.player.directMessage('你弃票了')
        } else {
            if (scoreList[result.index]) {
                scoreList[result.index] += 1;
                e.player.directMessage(`你投票给了${result.value}`)
            }
        }

    })
    await sleep(20000);
    world.querySelectorAll(`.${team}`).forEach((e) => {
        e.player.cancelDialogs()
    })
    var maxPlayer = playerList[0]//最高投票者
    var index = 0;
    for (let i in scoreList) {
        if (scoreList[i] > scoreList[index] && playerList[i]) {
            maxPlayer = playerList[i]
            index = i
        }
    }
    world.say(`恭喜${team}队的${maxPlayer.player.name}以${scoreList[index]}分拿下此队总指挥官的席位！`);
    maxPlayer.isCommander = true;
}
function getCommander(team) {
    return world.querySelectorAll(`.${team}`).filter(e => e.isCommander == true)[0]
}



async function joinTeam(entity = new Box3Entity, team = '') {
    if (!entity.createJD) { while (!entity.createJD) { await sleep(100) } }
    entity.addTag(team)
    entity.addTag('inGame')
    entity.team = team
    entity.color = colors[team[0] + '色']
    entity.player.directMessage('++++【你加入了' + team + '】++++')
    world.say(entity.player.name + '加入了' + team)
    let pos = [];
    if (team == '红队') {
        pos = redPos[Math.floor(Math.random() * redPos.length)]
    }
    if (team == '蓝队') {
        pos = bluePos[Math.floor(Math.random() * bluePos.length)]
    }
    if (!pos) return;
    entity.createJD(new Box3Vector3(pos[0], 1.01, pos[1]))
}
console.clear();
require('./SQL.js')
const dir = [new Box3Vector3(-1, 0, 0), new Box3Vector3(0, 0, -1), new Box3Vector3(0, 0, 1), new Box3Vector3(1, 0, 0)];
let spawnPos = []
for (let x = 1; x < 254; x++) {
    for (let z = 1; z < 254; z++) {
        for (let y = 0; y < 1; y++) {
            if ((x == 253 || x == 1 || z == 253 || z == 1) && voxels.getVoxel(x, y, z) == '607') {//陆军基地
                spawnPos.push([x, y, z])
            };
        };
    };
};
function goJiDi(entity) {
    entity.jd.position.x = Math.floor(entity.position.x) + 0.5
    entity.jd.position.z = Math.floor(entity.position.z) + 0.5
}
let spawnPos1 = []
for (let x = 1; x < 254; x++) {
    for (let z = 1; z < 254; z++) {
        if (voxels.getVoxel(x, 0, z) == '607' && (x > 50 && x < 200) && (z > 50 && z < 200) && new Box3Vector3(x, 0, z).distance(new Box3Vector3(128, 0, 128)) > 30) {
            spawnPos1.push([x, 1, z])
        }
    }
}

async function getZiYuanNum() {//获取当前世界资源点数量
    var a = [0, 0, 0]//矿，油，粮
    for (let x = 1; x < 254; x++) {
        for (let z = 1; z < 254; z++) {
            try {
                var name = dx[voxels.name(voxels.getVoxelId(x, 0, z))].name
                if (name == '矿物挖掘处') {
                    a[0]++
                }
                if (name == '石油挖掘处') {
                    a[1]++
                }
                if (name == '农田') {
                    a[2]++
                }
            } catch (e) {

            }
        }
        await sleep(1)
    }
    return a
};
async function fzZiYuan() {//刷新资源点
    return;
    let g = await getZiYuanNum()
    var a = g[0];
    var b = g[1];
    var c = g[2];
    var a1 = 0;
    var b1 = 0;
    var c1 = 0;//分别是一次恢复的量记录
    if (a < 150) {
        for (let i = 0; i < 150 - a; i++) {
            if (a1 > 50) continue;
            var pos = new Box3Vector3(10 + Math.random() * 242, 0, 10 + Math.random() * 242)
            if (voxels.name(voxels.getVoxelId(pos.x, pos.y, pos.z)) == 'rock') {
                voxels.setVoxel(pos.x, pos.y, pos.z, 'dark_stone');
                a++
                a1++
            }
            await sleep(2)
        }
    }
    await sleep(10)
    if (b < 300) {
        for (let i = 0; i < 300 - b; i++) {
            if (b1 > 30) continue;
            var pos = new Box3Vector3(1 + Math.random() * 252, 0, 1 + Math.random() * 252)
            if (voxels.name(voxels.getVoxelId(pos.x, pos.y, pos.z)) == 'leaf_05') {
                voxels.setVoxel(pos.x, pos.y, pos.z, 'honeycomb_01')
                b++
                b1++
            }
            await sleep(2)
        }
    }
    await sleep(10)
    if (c < 500) {
        for (let i = 0; i < 500 - c; i++) {
            if (c1 > 50) continue;
            var pos = new Box3Vector3(10 + Math.random() * 242, 0, 10 + Math.random() * 242)
            if (voxels.name(voxels.getVoxelId(pos.x, pos.y, pos.z)) == 'grass') {
                voxels.setVoxel(pos.x, pos.y, pos.z, 'yellow_grass')
                c++
                c1++
                if (Math.random() < 0.1) {
                    for (let x = pos.x - 1; x < pos.x + 1; x++) {
                        for (let z = pos.z - 1; z < pos.z + 1; z++) {
                            if (voxels.getVoxel(x, 0, z) == voxels.id('grass')) {
                                voxels.setVoxel(x, pos.y, z, 'yellow_grass')
                            }
                            c++
                            c1++
                        }
                    }
                }
            }
            await sleep(1)
        }
    }

}
function find(name, index = -1) {
    if (index == -1) {
        for (let i of world.querySelectorAll('player')) {
            if (i.player.name == name) {
                return i
            }
        }
    } else {
        return world.querySelectorAll('player')[index]
    }
}
world.canHurtTeam = 0;
const colors = {
    '白色': new Box3RGBAColor(255, 255, 255, 255),
    '红色': new Box3RGBAColor(255, 0, 0, 255),
    '荧绿色': new Box3RGBAColor(0, 255, 0, 255),
    '深蓝色': new Box3RGBAColor(0, 0, 255, 255),
    '粉紫色': new Box3RGBAColor(255, 0, 255, 255),
    '荧黄色': new Box3RGBAColor(255, 255, 0, 255),
    '蓝色': new Box3RGBAColor(0, 255, 255, 255),
    '黑色': new Box3RGBAColor(0, 0, 0, 255),
}
function textDialog(entity = Box3Entity, title, content) {
    entity.player.dialog({
        type: Box3DialogType.TEXT,
        title: title,
        content: content,
    })
}
global.textDialog = textDialog
/*var a = [];
a[voxels.id('medium_gray')] = 1;
a[voxels.id('grass')] = 2
a[voxels.id('leaf_05')] = 4
a[voxels.id('rock')] = 1000;
a[voxels.id('water')] = 1000;*/
const pifu = {
    '【皮肤】突击步兵': {
        text: '一种速度更快，攻击更高的轻步兵',
        coin: 800,
        forward: '轻步兵',//前一代
        mesh: '轻步兵',
        damage: 1.2,//伤害加成（*）
        fangyu: 1,//防御加成（/）
        speed: 1,//速度加成（+）
        attMaxSize: 0,//攻击最大范围加成（+）
        attMinSize: 0,//攻击最低范围加成（+）
        state: {//加成cd
            '移动': -3,
            '攻击': -2,
        },
        energy: 0,//能量
    },
    '【皮肤】炮兵': {
        text: '一种射程远，伤害大，装填满，血薄的重火力步兵',
        coin: 1000,
        forward: '反坦克步兵',
        mesh: '炮兵',
        damage: 3,
        fangyu: 0.9,
        speed: -1,
        attMaxSize: 3,
        attMinSize: 1,
        state: {
            '移动': 0,
            '攻击': 5,
        },
        energy: 0,
    },
    '【皮肤】凯门鳄侦察车': {
        text: '速度超快防御高攻击cd低的侦察车',
        coin: 3000,
        forward: '侦察车',
        mesh: '侦察车',
        damage: 1,
        fangyu: 1.2,
        speed: 3,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -1,
        },
        energy: 2,
    },
    '【皮肤】BMP-3步兵战车': {
        text: '一种速度快，伤害为侦察车的伤害，而且能载人，运量大(多2人)，防御高',
        coin: 5000,
        forward: '履带运输车',
        mesh: 'BMP-3步兵战车',
        damage: 1,
        fangyu: 1.5,
        speed: 2,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': 0,
        },
        energy: 5,
        maxSit: 2,
    },
    '【皮肤】89式自行火炮': {
        text: '伤害高，射程远，速度慢，装甲薄',
        coin: 4500,
        forward: '自行火炮',
        mesh: '自行火炮',
        damage: 1.5,
        fangyu: 0.8,
        speed: -2,
        attMaxSize: 2,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': 0,
        },
        energy: 3,
    },
    '【皮肤】95式高射炮': {
        text: '攻击力大，射程远，移动快的自行高射炮',
        coin: 4500,
        forward: '高射炮',
        mesh: '95式高射炮',
        damage: 1.4,
        fangyu: 1,
        speed: 2,
        attMaxSize: 1,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': 0,
        },
        energy: 2,
    },
    '【皮肤】虎式重型坦克': {
        text: '速度慢，攻击高的重坦',
        coin: 5500,
        forward: '重型坦克',
        mesh: '重型坦克',
        damage: 1.5,
        fangyu: 1.1,
        speed: -1,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': 0,
        },
        energy: 3,
    },
    '【皮肤】T-34中型坦克': {
        text: '速度快，伤害防御高的中坦克',
        coin: 5500,
        forward: '中型坦克',
        mesh: '中型坦克',
        damage: 1.3,
        fangyu: 1.3,
        speed: 2,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': 0,
        },
        energy: 3,
    },
    '【皮肤】卡-50黑鲨武装直升机': {
        text: '伤害高，速度快，血厚的武装直升机',
        coin: 6000,
        forward: '武装直升机',
        mesh: '武装直升机',
        damage: 1.2,
        fangyu: 1.2,
        speed: 2,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': 0,
        },
        energy: 2,
    },
    '【皮肤】P51战斗机': {
        text: '伤害高，灵活性高（移动cd短），续航久，血量薄的战斗机',
        coin: 7000,
        forward: '战斗机',
        mesh: '战斗机',
        damage: 1.3,
        fangyu: 0.8,
        speed: 0,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': -4,
            '攻击': 0,
        },
        energy: 5,
    },
    '【皮肤】B-17轰炸机': {
        text: '一种速度快，续航大，攻击高的大型轰炸机',
        coin: 8000,
        forward: '轰炸机',
        mesh: '轰炸机',
        damage: 1.2,
        fangyu: 1,
        speed: 1,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -2,
        },
        energy: 5,
    },
    '【皮肤】红旗-18防空导弹': {
        text: '伤害高，攻击cd短，速度慢，机动性差，装甲较薄，射程较短',
        coin: 8500,
        forward: '对空飞弹车',
        mesh: '对空飞弹车',
        damage: 1.3,
        fangyu: 0.9,
        speed: -2,
        attMaxSize: -2,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -5,
        },
        energy: 2,
    },
    '【皮肤】密集火箭炮': {
        text: '对地火箭车改造，火力密集,伤害虽然低于对地火箭车（*0.8），但是装填只有5秒,攻击最大范围-2，攻击最小范围-1',
        coin: 8000,
        forward: '对地火箭车',
        mesh: '密集火箭炮',
        damage: 0.8,
        fangyu: 1,
        speed: 1,
        attMaxSize: -2,
        attMinSize: -1,
        state: {
            '移动': 0,
            '攻击': -10,
        },
        energy: 0,
    },
    '【皮肤】堡垒P反舰导弹车': {
        text: '攻击高，范围广，血薄的反舰导弹车',
        coin: 9000,
        forward: '反舰导弹车',
        mesh: '反舰导弹车',
        damage: 1.5,
        fangyu: 0.6,
        speed: 1,
        attMaxSize: 2,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -2,
        },
        energy: 2,
    },
    '【皮肤】空想级驱逐舰': {
        text: `超快驱逐舰，鱼雷很强（伤害高CD慢射程高1格）（空想的火炮就是摆设。。（））,血薄`,
        coin: 8000,
        forward: '驱逐舰',
        mesh: '驱逐舰',
        damage: 1.5,
        fangyu: 0.8,
        speed: 3,
        attMaxSize: 1,
        attMinSize: 0,
        state: {
            '移动': -4,
            '攻击': 5,
        },
        energy: 5,
    },
    '【皮肤】U型潜艇': {
        text: '伤害较高，灵活，血厚的潜艇',
        coin: 9500,
        forward: '潜艇',
        mesh: '潜艇',
        damage: 1.2,
        fangyu: 1.2,
        speed: 0,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': -4,
            '攻击': -2,
        },
        energy: 5,
    },
    '【皮肤】克利夫兰级巡洋舰': {
        text: '克利夫兰巡洋舰，伤害高攻击cd恢复快，速度快（模型先压着）',
        coin: 9000,
        forward: '巡洋舰',
        mesh: '巡洋舰',
        damage: 1.3,
        fangyu: 1.1,
        speed: 2,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -2,
        },
        energy: 3,
    },
    '【皮肤】伊尔-2攻击机': {
        text: '速度快，续航久，攻击高，攻击范围低，血厚,空地兼备，坦克杀手',
        coin: 10000,
        forward: '空地战斗机',
        mesh: '空地战斗机',
        damage: 1.3,
        fangyu: 1.2,
        speed: 1,
        attMaxSize: -1,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -2,
        },
        energy: 5,
    },
    '【皮肤】大和级战列舰': {
        text: '防御及其强，攻击cd短（模型先压着），攻击范围大，无内径',
        coin: 10000,
        forward: '主力战舰',
        mesh: '大和级战列舰',
        damage: 1,
        fangyu: 1.6,
        speed: 1,
        attMaxSize: 1,
        attMinSize: -2,
        state: {
            '移动': 0,
            '攻击': -5,
        },
        energy: 3,
    },
    '【皮肤】企业号航母': {
        text: '一种血量厚，火力强大，速度快，续航强的航母',
        coin: 11000,
        forward: '航母',
        mesh: '航母',
        damage: 1.5,
        fangyu: 1.2,
        speed: 1,
        attMaxSize: 0,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -2,
        },
        energy: 5,
    },
    '【皮肤】核弹发射车': {
        text: '一种射程巨远，伤害巨大的灭世武器',
        coin: 9999999,
        forward: '远程导弹车',
        mesh: '远程导弹车',
        damage: 10,
        fangyu: 1,
        speed: 0,
        attMaxSize: 50,
        attMinSize: 0,
        state: {
            '移动': 0,
            '攻击': -120,
        },
        energy: 5,
    },
};
const tasks = {
    '第一个步兵': {
        text: `
        在这个游戏里，步兵是很重要的一个兵种，可以占领城市/基地/上车，多功能的兵，怕侦察车，现在你要做出第一个步兵
        那么，开始你的指挥官之旅吧
        要求：制作1个轻步兵，点击基地制作兵（不要点击白色模型，点击模型下的方块）
        奖励：100个军团币
        每次完成任务都可以加1点军衔星
        `,
        score: [1],//分数，如果所有分数都达到那么就ok
        coins: 200,//军团币奖励
        forward: '',
        after: '陆军出击！',
        needMake: ['轻步兵'],
    },
    '陆军出击！': {
        text: `
        很好！你做出了你指挥官生涯的第一个步兵！
        现在，你需要制作一些陆军，使用你的步兵占领城市获得钱，再次点击基地，制造陆军：
        自爆兵是个老六，就不让你们去祸害别人了（）
        要求：制造反坦克步兵*2，侦察车*1
        奖励：150军团币
        `,
        score: [2, 1],
        coins: 300,
        forward: '第一个步兵',
        after: '钢铁洪流I',
        needMake: ['反坦克步兵', '侦察车'],
    },
    '钢铁洪流I': {
        text: `
        你成功制造了2个反坦克步兵，1个侦察车！
        反坦克步兵克制坦克，特别是中坦
        侦察车则克制步兵
        但是，就制造这一点兵是不够的～
        你需要开拓更多兵种！！！
        要求：制造自行火炮*1，中坦*1
        奖励：200军团币
        `,
        score: [1, 1],
        coins: 400,
        forward: '陆军出击！',
        after: '载人运输',
        needMake: ['自行火炮', '中型坦克'],
    },
    '载人运输': {
        text: `
        你制造了1个自行火炮和1个中坦
        自行火炮相当于是远程辅助，而中坦可以冲锋陷阵（打装甲车）
        但是，资金不够呢。而且我们的基地位置也是很不好。
        步兵走的又太慢了，这下咋办？
        要求：制造轮式运输车*1，履带运输车*1～
        tips:小知识，轮式走公路，履带能越野～利用好地形是打仗的基本要求～
        奖励：200军团币
        `,
        score: [1, 1],
        coins: 400,
        forward: '钢铁洪流I',
        after: '钢铁洪流II',
        needMake: ['轮式运输车', '履带运输车'],
    },
    '钢铁洪流II': {
        text: `
        你制造了载人的部队，可以载人去进行开拓势力范围～金钱不用愁～
        有了钱，你就可以制造真正的重火力军团了！！！
        要求：制造高射炮*1，重坦*1
        奖励：300军团币
        `,
        score: [1, 1],
        coins: 600,
        forward: '载人运输',
        after: '远程三剑客',
        needMake: ['高射炮', '重型坦克'],
    },
    '远程三剑客': {
        text: `
        在前线打仗时，有些"老六"总是喜欢偷袭，老六，他来啦～
        要求：制造对地火箭车*1，对空飞弹车*1，反舰导弹车*1
        奖励：400军团币
        `,
        score: [1, 1, 1],
        coins: 800,
        forward: '钢铁洪流II',
        after: '专业后勤',
        needMake: ['对地火箭车', '对空飞弹车', '反舰导弹车'],
    },
    '专业后勤': {
        text: `
        在现代战争中，后勤总是必不可少的
        工程车可以建造设施，也可以对周围装甲陆军进行维修，速度快
        资源运输车可以运输资源，可以对一些部队进行补给
        补给方法：
        步兵在资源点上，可以对身边半径3的部队进行补给，如果他是资源运输车，额外进行补给，然后资源运输车靠近别人3格内就可以补给啦，具体看帮助
        要求：制造工程车*1，资源运输车*1
        奖励：250军团币
        `,
        score: [1, 1],
        coins: 500,
        forward: '远程三剑客',
        after: '战争开始！！！',
        needMake: ['工程车', '资源运输车'],
    },
    '第一个海军': {
        text: `
        现在你的陆军已经完成了，也完成了你的第一次实战。
        虽然你已经具备了弄海军的能力，但还不是时候。
        先做登陆艇和资源运输船试试手吧！
        要求：制作抢滩登陆艇*1，资源运输船*1
        奖励：军团币*400
        `,
        score: [1, 1],
        coins: 800,
        forward: '战争开始！！！',
        after: '空军你好',
        needMake: ['抢滩登陆艇', '资源运输船'],
    },
    '空军你好': {
        text: `
        你已经成功的制造了你的第一个海军，但是...
        海军还是太难了，于是你先做空军（？
        要求：制作运输直升机*1，武装直升机*1
        奖励：军团币*400
        `,
        score: [1, 1],
        coins: 800,
        forward: '第一个海军',
        after: '装甲海军I',
        needMake: ['运输直升机', '武装直升机'],
    },
    '装甲海军I': {
        text: `
        你已经制造了你指挥官之旅中第一个空军。
        你现在可以制造驱逐舰（反潜艇，机动性）巡洋舰（打驱逐舰，对空）
        要求：制作1个驱逐舰，1个巡洋舰，期待你的表现～
        奖励：军团币*450           
        `,
        score: [1, 1],
        coins: 900,
        forward: '空军你好',
        after: '空中打击',
        needMake: ['驱逐舰', '巡洋舰'],
    },
    '空中打击': {
        text: `
        你离全兵种就差1步之遥了！！加油！！
        要求：使用航母制造3个空军
        奖励：军团币*600，基础部队已经拥有
        `,
        score: [3],
        coin: 1000,
        forward: '装甲海军I',
        after: '实战！！！',
    },
};








const technology = {
    '综合': {
        '军风军纪': {
            text: '锻炼军队的军风军纪，防御力攻击力速度都*1.05',
            lx: ['陆', '海', '空'],
            coin: 1000,
            needChip: 20,
            damage: 1.05,
            fangyu: 1.05,
            speed: 1.05,
            need: '',
        },
        '快速行军I': {
            text: '让部队更快速的行军(行军速度*1.1)',
            lx: ['陆', '海', '空'],//类型，分为海陆空资源
            coin: 1000,//军团币
            needChip: 20,//需要对应碎片多少，这里是20个综合碎片
            speed: 1.1,//速度增益*
            need: '',//需要前置科技
        },
        '金融学I': {
            text: '每次从城市获得钱收益*1.1',
            lx: ['资源'],
            coin: 1000,
            needChip: 25,
            money: 1.1,
            need: '',
        },
        '装甲强化I': {
            text: '强化部队装甲，防御*1.1',
            lx: ['陆', '海', '空'],
            coin: 1500,
            needChip: 30,
            fangyu: 1.1,
            need: '金融学I',
        },
        '攻击强化I': {
            text: '强化部队火炮等攻击设施，攻击*1.1',
            lx: ['陆', '海', '空'],
            coin: 1500,
            needChip: 30,
            damage: 1.1,
            fangyu: 1,
            need: '装甲强化I'
        },
        '快速行军II': {
            text: '在快速行军I基础上再*1.1',
            lx: ['陆', '海', '空'],
            coin: 3000,
            needChip: 40,
            speed: 1.1,
            need: '快速行军I',
        },
        '金融学II': {
            text: '在金融学I基础上再*1.1',
            lx: ['资源'],
            coin: 3500,
            needChip: 45,
            money: 1.1,
            need: '金融学I',
        },
        '装甲强化II': {
            text: '在装甲强化I基础上再*1.1',
            lx: ['陆', '海', '空'],
            coin: 4500,
            needChip: 50,
            fangyu: 1.1,
            need: '装甲强化I',
        },
        '攻击强化II': {
            text: '在攻击强化I基础上再*1.1',
            lx: ['陆', '海', '空'],
            coin: 4500,
            needChip: 50,
            damage: 1.1,
            need: '攻击强化I',
        },
        '快速训练I': {
            text: '基地训练兵的时间*0.8(-20%)(仅限基地)',
            lx: ['训练'],
            coin: 5000,
            needChip: 40,
            cdTime: 0.8,
            need: '装甲强化II'
        },
    },
    '陆': {
        '武器强化I': {
            text: '强化攻击力*1.2',
            lx: ['陆'],
            coin: 2000,
            needChip: 50,
            damage: 1.2,
            need: '',
        },
        '机动强化I': {
            text: '强化速度*1.2',
            lx: ['陆'],
            coin: 4000,
            needChip: 100,
            speed: 1.2,
            need: '武器强化I',
        },
    },
    '海': {
        '装甲强化I': {
            text: '强化防御力*1.2',
            lx: ['海'],
            coin: 2000,
            needChip: 50,
            fangyu: 1.2,
            need: '',
        },
        '武器强化I': {
            text: '强化攻击力*1.2',
            lx: ['海'],
            coin: 4000,
            needChip: 100,
            damage: 1.2,
            need: '装甲强化I'
        },
    },
    '空': {
        '机动强化I': {
            text: '强化速度*1.2',
            lx: ['空'],
            coin: 2000,
            needChip: 50,
            speed: 1.2,
            need: '',
        },
        '装甲强化I': {
            text: '强化防御*1.2',
            lx: ['空'],
            coin: 5000,
            needChip: 100,
            fangyu: 1.2,
            need: '机动强化I'
        },
    },
};








const dx = {//地形
    'candy': {//candy
        name: '边界',
        text: '地图的边界，任何部队都无法通过',
        fangyu: 0,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 9999,
            '轮式车辆': 9999,
            '履带车辆': 9999,
            '海军': 9999,
            '空军': 9999,
        },
        lx: '边界',
    },
    'medium_gray': {
        name: '公路',
        text: '易于车辆行驶,防御力无加成',
        fangyu: 1,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '地形',
    },
    'grass': {
        name: '平原',
        text: '防御力+20%，不易于轮式车辆行驶',
        fangyu: 1.2,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 2,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '地形',
    },
    'leaf_05': {
        name: '森林',
        text: '防御力+40%，不利于车辆行驶',
        fangyu: 1.4,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 4,
            '履带车辆': 2,
            '海军': 9999,
            '空军': 1,
        },
        lx: '地形',
    },
    'rock': {
        name: '山地',
        text: '防御力+75%，车辆不能行驶',
        fangyu: 1.75,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 2,
            '轮式车辆': 9999,
            '履带车辆': 9999,
            '海军': 9999,
            '空军': 1,
        },
        lx: '地形',
    },
    'water': {
        name: '海洋或湖泊（水系）',
        text: '陆军无法通过,防御力没有特殊防御',
        fangyu: 1,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 9999,
            '轮式车辆': 9999,
            '履带车辆': 9999,
            '海军': 1,
            '空军': 1,
        },
        lx: '地形',
    },
    'sand': {
        name: '浅滩',
        text: '防御力+10%，陆和海的交界处，不利于轮式车辆行驶，海军也会减缓速度',
        fangyu: 1.1,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 2,
            '履带车辆': 1,
            '海军': 2,
            '空军': 1,
        },
        lx: '地形',
    },
    'stone_wall': {
        name: '桥',
        text: '防御力-30%，易于行驶，任意兵种都能通过',
        fangyu: 0.7,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 1,
            '空军': 1,
        },
        lx: '地形',
    },
    'orange_juice': {//orange_juice
        name: '沼泽',
        text: '只有步兵和空军能通过，防御力-10%',
        fangyu: 0.9,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 2,
            '轮式车辆': 9999,
            '履带车辆': 9999,
            '海军': 9999,
            '空军': 1,
        },
        lx: '地形',
    },
    'lab_material_06': {//lab_material_06
        name: '陆军基地',
        text: '防御力+50%，生产陆军的基地',
        fangyu: 1.5,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '基地',
        options: ['轻步兵', '反坦克步兵', '自爆兵', '侦察车', '工程车', '轮式运输车', '履带运输车', '资源运输车', '自行火炮', '中型坦克', '高射炮', '对空飞弹车', '反舰导弹车', '对地火箭车', '重型坦克', '远程导弹车'],
        moneys: [2000, 4000, 4000, 7000, 7000, 8000, 9000, 8000, 10000, 12000, 13000, 15000, 16000, 18000, 20000, 60000],
    },
    'lab_material_13': {//lab_material_13
        name: '空军基地',
        text: '防御力+50%，生产空军的基地',
        fangyu: 1.5,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '基地',
        options: ['轻步兵', '无人机', '运输直升机', '武装直升机', '战斗机', '轰炸机', '鱼雷机', '空地战斗机'],
        moneys: [2500, 5000, 9000, 11000, 25000, 30000, 20000, 32000],
    },
    'bounce_pad': {//bounce_pad
        name: '海军基地',
        text: '防御力+50%，生产海军的基地',
        fangyu: 1.5,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 1,
            '空军': 1,
        },
        lx: '基地',
        options: ['轻步兵', '抢滩登陆艇', '资源运输船', '大型运输船', '驱逐舰', '巡洋舰', '潜艇', '主力战舰', '航母'],
        moneys: [2500, 11000, 12000, 13000, 15000, 23000, 26000, 38000, 60000],
    },
    'ledfloor01': {//ledfloor01
        name: '城市',
        text: '防御力+40%，每30秒获得1000元',
        fangyu: 1.4,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 100,
            '空军': 1,
        },
        lx: '城市',
    },
    'air': {//ledfloor01
        name: '空气',
        text: '',
        fangyu: 0,
        speed: {//关于不同兵种而降低的移动力
            '步兵': 9999,
            '轮式车辆': 9999,
            '履带车辆': 9999,
            '海军': 9999,
            '空军': 9999,
        },
        lx: '地形',
    },
    'honeycomb_01': {
        name: '石油挖掘处',
        text: '防御+20%，不利于轮式车辆行驶，可以从这里挖掘石油，用任意步兵单位挖掘(站它上面)时用资源运输车靠近（3格内），资源运输车的燃油罐就会逐渐加满，如果物资运输车或者是正在挖掘的步兵单位附近（5格内）有缺油的单位会自动补给   (原型：森林有几率变成石油矿，有几率采完重回森林)',
        fangyu: 1.2,
        speed: {
            '步兵': 1,
            '轮式车辆': 2,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '资源',
        num: 1,
        forward: 'leaf_05',//上一级
    },
    'dark_stone': {
        name: '矿物挖掘处',
        text: '防御+20%，不利于轮式车辆行驶，可从这里挖掘矿物（金属，石头统称矿物）（步兵站在其上面），挖掘时用资源运输车靠近（3格内），资源运输车的矿物储物仓就会逐渐加满，工程车需要矿物进行维修，可以靠近他进行补给，也可以卖钱造兵（一定意义上也是进行了制造）（山地有几率变成矿有几率挖完重回山地）。',
        fangyu: 1.2,
        speed: {
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '资源',
        num: 0,
        forward: 'rock',
    },
    'yellow_grass': {
        name: '农田',
        text: '防御+20%，不利于轮式车辆行驶，可以在这里收集粮食，而部队的粮食消耗很大，如果没有粮食则会缓慢的扣血，特别是步兵。需要步兵站在上面获取，获取时用资源运输车靠近，然后运输车的粮食储物仓就会逐渐加满，运输车或者正在挖掘的资源点靠近任何部队3格内就可以补给粮食',
        fangyu: 1.2,
        speed: {
            '步兵': 1,
            '轮式车辆': 2,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '资源',
        num: 2,
        forward: 'grass',
    },
    'white_light': {
        name: '中立据点',
        text: '中立据点，不属于任何队伍',
        fangyu: 1,
        speed: {
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '据点',
    },
    'red_light': {
        name: '红色据点',
        text: '红色据点，防御力*2，可以为占领在这个据点上的人提供城市的5倍资金，是后期结算的重要指标',
        fangyu: 2,
        speed: {
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '据点',
    },
    'blue_light': {
        name: '蓝色据点',
        text: '蓝色据点，防御力*2，可以为占领在这个据点上的人提供城市的5倍资金，是后期结算的重要指标',
        fangyu: 2,
        speed: {
            '步兵': 1,
            '轮式车辆': 1,
            '履带车辆': 1,
            '海军': 9999,
            '空军': 1,
        },
        lx: '据点'
    }
};
for (let i in dx) {
    dx[i].speed['设施'] = 1;
}
function pmDist(a = new Box3Vector3, b = new Box3Vector3) {//平面distance-平面上的距离
    return new Box3Vector3(a.x, 0, a.z).distance(new Box3Vector3(b.x, 0, b.z))
}
const soldiers = {//兵种属性，燃料为每次移动1点
    '轻步兵': {
        lx1: '陆',//类型————兵种
        lx2: '步兵',//类型————具体分类
        text: '轻型步兵，可以占领城市（每30秒1000元）和基地，据点，是重要的兵种',//介绍
        kz: '克制：无   被克制：所有兵种，不仅是最重要的，也是最弱小的兵种',//克制关系
        time: 1,//造的间隔
        speed: 4,//速度
        state: {//CD
            '移动': 10,
            '攻击': 8,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 25,
            '反坦克步兵': 15,
            '侦察车': 3,
            '自行火炮': 5,
            '轮式运输车': 5,
            '履带运输车': 3,
            '中型坦克': 1,
            '工程车': 3,
            '高射炮': 2,
            '武装直升机': 1,
            '运输直升机': 3,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 5,
            '潜艇': 0,
            '主力战舰': 5,
            '巡洋舰': 3,
            '对空飞弹车': 5,
            '对地火箭车': 5,
            '重型坦克': 2,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 3,
            '资源运输车': 3,
            '驱逐舰': 0,
            '资源运输船': 1,
            '航母': 0,
            '自爆兵': 35,
            '墙': 2,
            '防御塔': 1,
            '反舰导弹车': 5,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 10,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.25,//y轴的提升  
        energy: Infinity,
    },
    '反坦克步兵': {
        lx1: '陆',
        lx2: '步兵',
        text: '携带重武器的步兵，可以占领城市，基地，据点，比轻步兵而言他的攻击和防御都提升了，就是速度不行',
        kz: '克制：装甲运输车，中坦 较为克制：高射炮，重坦克 被克制：侦察车，轰炸机',
        time: 2,
        speed: 3,
        state: {
            '移动': 10,
            '攻击': 10,
        },
        damage: {
            '轻步兵': 40,
            '反坦克步兵': 30,
            '侦察车': 20,
            '自行火炮': 40,
            '轮式运输车': 60,
            '履带运输车': 55,
            '中型坦克': 60,
            '工程车': 40,
            '高射炮': 50,
            '武装直升机': 10,
            '运输直升机': 15,
            '战斗机': 30,
            '轰炸机': 30,
            '抢滩登陆艇': 20,
            '潜艇': 0,
            '主力战舰': 10,
            '巡洋舰': 5,
            '对空飞弹车': 60,
            '对地火箭车': 55,
            '重型坦克': 20,
            '鱼雷机': 30,
            '空地战斗机': 30,
            '远程导弹车': 5,
            '资源运输车': 55,
            '驱逐舰': 5,
            '航母': 0,
            '资源运输船': 10,
            '自爆兵': 50,
            '墙': 10,
            '防御塔': 5,
            '反舰导弹车': 45,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 25,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.25,
        energy: Infinity,
    },
    '侦察车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '速度快，擅长侦察和扫荡运输单位和步兵',//介绍
        kz: '克制：运输单位和步兵  ',//克制关系
        time: 4,//造的间隔
        speed: 15,//速度
        state: {//CD
            '移动': 10,
            '攻击': 5,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 70,
            '反坦克步兵': 60,
            '侦察车': 10,
            '自行火炮': 5,
            '轮式运输车': 15,
            '履带运输车': 12,
            '中型坦克': 3,
            '工程车': 10,
            '高射炮': 2,
            '武装直升机': 5,
            '运输直升机': 15,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 15,
            '潜艇': 0,
            '主力战舰': 8,
            '巡洋舰': 5,
            '对空飞弹车': 3,
            '对地火箭车': 3,
            '重型坦克': 1,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 6,
            '资源运输车': 10,
            '驱逐舰': 3,
            '航母': 0,
            '资源运输船': 5,
            '自爆兵': 100,
            '墙': 5,
            '防御塔': 1,
            '反舰导弹车': 25,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 20,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        energy: 15,
    },
    '轮式运输车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '速度快，造价便宜，擅长在公路上运输步兵',//介绍
        kz: '无，此兵种不能攻击，只能被动挨打，所以最好带上一些保镖或者步兵',//克制关系
        time: 4,//造的间隔
        speed: 11,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        maxSit: 3,
        energy: 15,
        canSit: ['轻步兵', '反坦克步兵']
    },
    '履带运输车': {
        lx1: '陆',//类型————兵种
        lx2: '履带车辆',//类型————具体分类
        text: '速度较快，造价较便宜，擅长越野运输步兵，比轮式运输车血厚',//介绍
        kz: '无，此兵种不能攻击，只能被动挨打，所以最好带上一些保镖或者步兵',//克制关系
        time: 4,//造的间隔
        speed: 9,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害

        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        maxSit: 3,
        energy: 20,
        canSit: ['轻步兵', '反坦克步兵'],
    },
    '自行火炮': {
        lx1: '陆',//类型————兵种
        lx2: '履带车辆',//类型————具体分类
        text: '对地火力辅助',//介绍
        kz: '对地火力辅助，不能近战',//克制关系
        time: 5,//造的间隔
        speed: 6,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 70,
            '反坦克步兵': 60,
            '侦察车': 40,
            '自行火炮': 30,
            '轮式运输车': 40,
            '履带运输车': 35,
            '中型坦克': 55,
            '工程车': 40,
            '高射炮': 60,
            '武装直升机': 5,
            '运输直升机': 10,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 40,
            '潜艇': 5,
            '主力战舰': 15,
            '巡洋舰': 25,
            '对空飞弹车': 40,
            '对地火箭车': 35,
            '重型坦克': 30,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 25,
            '资源运输车': 40,
            '驱逐舰': 15,
            '航母': 1,
            '资源运输船': 20,
            '自爆兵': 100,
            '墙': 15,
            '防御塔': 10,
            '反舰导弹车': 35,
            '避雷针': 100,
            '气象台': 50,
        },
        attMaxSize: 5,
        attMinSize: 1,
        yAdd: 0,
        energy: 15,
    },

    '中型坦克': {
        lx1: '陆',//类型————兵种
        lx2: '履带车辆',//类型————具体分类
        text: '中型坦克，擅长轰击装甲',//介绍
        kz: '克制：侦察车，自行火炮，运输车等装甲类型兵   被克制：反坦克兵，重型坦克',//克制关系
        time: 5,//造的间隔
        speed: 9,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 30,
            '反坦克步兵': 15,
            '侦察车': 55,
            '自行火炮': 70,
            '轮式运输车': 70,
            '履带运输车': 60,
            '中型坦克': 30,
            '工程车': 55,
            '高射炮': 55,
            '武装直升机': 3,
            '运输直升机': 10,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 25,
            '潜艇': 0,
            '主力战舰': 5,
            '巡洋舰': 8,
            '对空飞弹车': 35,
            '对地火箭车': 30,
            '重型坦克': 25,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 30,
            '资源运输车': 55,
            '驱逐舰': 1,
            '航母': 0,
            '资源运输船': 5,
            '自爆兵': 100,
            '墙': 10,
            '防御塔': 5,
            '反舰导弹车': 50,
            '避雷针': 100,
            '气象台': 50,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        energy: 15,
    },
    '工程车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '速度快，每秒对自己和身边距离<5的所有己方车辆单位进行治疗,每秒1点血恢复,还可以建造一些设施，一种很nb的后勤兵种',//介绍
        kz: '此兵种被动挨打，请带上保镖',//克制关系
        time: 4,//造的间隔
        speed: 5,//速度
        state: {//CD
            '移动': 3,
            '攻击': Infinity,
        },
        damage: {//对于每个兵种的伤害
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        energy: 60,
        buildOptions: ['墙', '防御塔', '避雷针', '气象台'],//可以在工程车上做的
        buildMoneys: [1000, 8000, 1500, 20000],
        buildPos: [['grass', 'leaf_05', 'medium_gray', 'rock', 'sand', 'stone_wall'], ['grass', 'leaf_05', 'medium_gray', 'sand'], ['grass', 'leaf_05', 'medium_gray', 'rock'], ['grass', 'leaf_05', 'medium_gray']],
    },
    '高射炮': {
        lx1: '陆',//类型————兵种
        lx2: '履带车辆',//类型————具体分类
        text: '可以对空对地的大口径机炮',//介绍
        kz: '擅长打空军，和陆运输单位和一些轻型装甲车（如工程车和侦察车），如果打陆军还不如用坦克呢～打他也得用坦克～',//克制关系
        time: 8,//造的间隔
        speed: 9,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 70,
            '反坦克步兵': 65,
            '侦察车': 45,
            '自行火炮': 30,
            '轮式运输车': 55,
            '履带运输车': 50,
            '中型坦克': 10,
            '工程车': 55,
            '高射炮': 40,
            '武装直升机': 70,
            '运输直升机': 80,
            '战斗机': 70,
            '轰炸机': 75,
            '抢滩登陆艇': 15,
            '潜艇': 0,
            '主力战舰': 8,
            '巡洋舰': 5,
            '对空飞弹车': 25,
            '对地火箭车': 20,
            '重型坦克': 5,
            '鱼雷机': 65,
            '空地战斗机': 60,
            '远程导弹车': 25,
            '资源运输车': 55,
            '驱逐舰': 10,
            '航母': 0,
            '资源运输船': 5,
            '自爆兵': 100,
            '墙': 15,
            '防御塔': 10,
            '反舰导弹车': 20,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 90,
        },
        attMaxSize: 2,
        attMinSize: 0,
        yAdd: 0,
        energy: 20,
    },
    '武装直升机': {
        lx1: '空',//类型————兵种
        lx2: '空军',//类型————具体分类
        text: '擅长进行侦察任务，携带武器的直升机，擅长低空或对地作战',//介绍
        kz: '克制：坦克等不能对空的单位   被克制：能对空的打直升机都是吨量伤害',//克制关系
        time: 8,//造的间隔
        speed: 11,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 60,
            '反坦克步兵': 55,
            '侦察车': 50,
            '自行火炮': 50,
            '轮式运输车': 70,
            '履带运输车': 75,
            '中型坦克': 60,
            '工程车': 55,
            '高射炮': 15,
            '武装直升机': 10,
            '运输直升机': 65,
            '战斗机': 2,
            '轰炸机': 4,
            '抢滩登陆艇': 65,
            '潜艇': 5,
            '主力战舰': 35,
            '巡洋舰': 40,
            '对空飞弹车': 10,
            '对地火箭车': 15,
            '重型坦克': 20,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 30,
            '资源运输车': 50,
            '驱逐舰': 35,
            '航母': 5,
            '资源运输船': 40,
            '自爆兵': 100,
            '墙': 20,
            '防御塔': 15,
            '反舰导弹车': 15,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 90,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 1.5,
        energy: 15,
    },

    '运输直升机': {
        lx1: '空',//类型————兵种
        lx2: '空军',//类型————具体分类
        text: '比运输车的优势：速度快，没有地形限制。劣势：造价贵，运输量低',//介绍
        kz: '被动挨打，请带好保镖或步兵',//克制关系
        time: 8,//造的间隔
        speed: 10,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 1.9,
        maxSit: 2,
        energy: 20,
        canSit: ['轻步兵', '反坦克步兵']
    },
    '抢滩登陆艇': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '比运输车的优势：运量大 劣势：造价贵，速度慢',//介绍
        kz: '被动挨打，请带好保镖',//克制关系
        time: 8,//造的间隔
        speed: 8,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.2,
        maxSit: 5,
        energy: 35,
        canSit: ['轻步兵', '反坦克步兵']
    },
    '大型运输船': {
        lx1: '海',
        lx2: '海军',
        text: '大容量，可以携带步兵/反坦克步兵/自爆兵/侦察车/工程车/中坦/自行火炮/高射炮/3个著名远程陆地单位/无人机/重坦  *2，速度比登陆艇慢1格',
        kz: '被动挨打',
        time: 10,
        speed: 7,
        state: {
            '移动': 10,
            '攻击': 10,
        },
        damage: {},
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.25,
        maxSit: 2,
        energy: 40,
        canSit: ['轻步兵', '反坦克步兵', '自爆兵', '侦察车', '工程车', '中型坦克', '自行火炮', '高射炮', '对地火箭车', '对空飞弹车', '反舰导弹车', '无人机', '重型坦克']
    },
    '战斗机': {
        lx1: '空',//类型————兵种
        lx2: '空军',//类型————具体分类
        text: '擅长空对空作战',//介绍
        kz: '克制：任意空军单位   被克制：高射炮及其一切可以对空单位',//克制关系
        time: 10,//造的间隔
        speed: 18,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 0,
            '反坦克步兵': 0,
            '侦察车': 0,
            '自行火炮': 0,
            '轮式运输车': 0,
            '履带运输车': 0,
            '中型坦克': 0,
            '工程车': 0,
            '高射炮': 0,
            '武装直升机': 85,
            '运输直升机': 95,
            '战斗机': 55,
            '轰炸机': 80,
            '抢滩登陆艇': 0,
            '潜艇': 0,
            '主力战舰': 0,
            '巡洋舰': 0,
            '对空飞弹车': 0,
            '对地火箭车': 0,
            '重型坦克': 0,
            '鱼雷机': 85,
            '空地战斗机': 65,
            '远程导弹车': 0,
            '资源运输车': 0,
            '驱逐舰': 0,
            '航母': 0,
            '资源运输船': 0,
            '自爆兵': 0,
            '墙': 0,
            '防御塔': 0,
            '反舰导弹车': 0,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 90,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 1.5,
        energy: 15,
    },
    '轰炸机': {
        lx1: '空',//类型————兵种
        lx2: '空军',//类型————具体分类
        text: '擅长高空对地轰炸',//介绍
        kz: '克制：任何陆军和海军（如果能对空，则不相上下）   被绝对克制：战斗机',//克制关系
        time: 10,//造的间隔
        speed: 13,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 85,
            '反坦克步兵': 80,
            '侦察车': 75,
            '自行火炮': 65,
            '轮式运输车': 75,
            '履带运输车': 80,
            '中型坦克': 75,
            '工程车': 80,
            '高射炮': 55,
            '武装直升机': 0,
            '运输直升机': 0,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 75,
            '潜艇': 65,
            '主力战舰': 60,
            '巡洋舰': 35,
            '对空飞弹车': 80,
            '对地火箭车': 85,
            '重型坦克': 75,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 60,
            '资源运输车': 75,
            '驱逐舰': 40,
            '航母': 20,
            '资源运输船': 50,
            '自爆兵': 100,
            '墙': 40,
            '防御塔': 30,
            '反舰导弹车': 85,
            '避雷针': 100,
            '气象台': 50,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 1.5,
        energy: 15,
    },
    '潜艇': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '舰艇克星，专打海军，怕深水炸弹（比如轰炸机和驱逐舰的）',//介绍
        kz: '克制：海军（深水炸弹除外）',//克制关系
        time: 10,//造的间隔
        speed: 8,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 0,
            '反坦克步兵': 0,
            '侦察车': 0,
            '自行火炮': 0,
            '轮式运输车': 0,
            '履带运输车': 0,
            '中型坦克': 0,
            '工程车': 0,
            '高射炮': 0,
            '武装直升机': 0,
            '运输直升机': 0,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 85,
            '潜艇': 55,
            '主力战舰': 75,
            '巡洋舰': 80,
            '对空飞弹车': 0,
            '对地火箭车': 0,
            '重型坦克': 0,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 0,
            '资源运输车': 0,
            '驱逐舰': 5,
            '航母': 40,
            '资源运输船': 80,
            '自爆兵': 0,
            '墙': 0,
            '防御塔': 0,
            '反舰导弹车': 0,
            '避雷针': 0,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.8,
        energy: 35,
    },
    '主力战舰': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '远程对地对海火力援助',//介绍
        kz: '克制：海军，陆军，远程精准打击，攻击防御都可以，打空军防空炮比巡洋舰弱',//克制关系
        time: 12,//造的间隔
        speed: 6,//速度
        state: {//CD
            '移动': 10,
            '攻击': 20,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 90,
            '反坦克步兵': 80,
            '侦察车': 75,
            '自行火炮': 60,
            '轮式运输车': 65,
            '履带运输车': 60,
            '中型坦克': 60,
            '工程车': 75,
            '高射炮': 70,
            '武装直升机': 12,
            '运输直升机': 12,
            '战斗机': 5,
            '轰炸机': 5,
            '抢滩登陆艇': 40,
            '潜艇': 0,
            '主力战舰': 40,
            '巡洋舰': 45,
            '对空飞弹车': 75,
            '对地火箭车': 70,
            '重型坦克': 65,
            '鱼雷机': 5,
            '空地战斗机': 5,
            '远程导弹车': 55,
            '资源运输车': 55,
            '驱逐舰': 70,
            '航母': 20,
            '资源运输船': 65,
            '自爆兵': 100,
            '墙': 40,
            '防御塔': 35,
            '反舰导弹车': 65,
            '避雷针': 120,
            '气象台': 80,
            '无人机': 5,
        },
        attMaxSize: 10,
        attMinSize: 2,
        yAdd: -0.2,
        energy: 30,
    },
    '巡洋舰': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '对地辅助登陆作战，对海打驱逐舰等轻型战舰，对空',//介绍
        kz: '对地辅助登陆作战，对海打驱逐舰等轻型战舰，对空，平衡的战舰',//克制关系
        time: 10,//造的间隔
        speed: 9,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 30,
            '反坦克步兵': 25,
            '侦察车': 30,
            '自行火炮': 25,
            '轮式运输车': 25,
            '履带运输车': 20,
            '中型坦克': 20,
            '工程车': 25,
            '高射炮': 30,
            '武装直升机': 70,
            '运输直升机': 70,
            '战斗机': 65,
            '轰炸机': 60,
            '抢滩登陆艇': 60,
            '潜艇': 0,
            '主力战舰': 55,
            '巡洋舰': 40,
            '对空飞弹车': 10,
            '对地火箭车': 15,
            '重型坦克': 5,
            '鱼雷机': 65,
            '空地战斗机': 50,
            '远程导弹车': 10,
            '资源运输车': 40,
            '驱逐舰': 55,
            '航母': 10,
            '资源运输船': 70,
            '自爆兵': 30,
            '墙': 10,
            '防御塔': 8,
            '反舰导弹车': 10,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 90,
        },
        attMaxSize: 3,
        attMinSize: 0,
        yAdd: -0.1,
        energy: 40,
    },
    '对空飞弹车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '远程对空精准打击',//介绍
        kz: '远程打空军，就是打不了其他部队，打飞机一旦打中，那非死也是死（）',//克制关系
        time: 10,//造的间隔
        speed: 6,//速度
        state: {//CD
            '移动': 10,
            '攻击': 15,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 0,
            '反坦克步兵': 0,
            '侦察车': 0,
            '自行火炮': 0,
            '轮式运输车': 0,
            '履带运输车': 0,
            '中型坦克': 0,
            '工程车': 0,
            '高射炮': 0,
            '武装直升机': 95,
            '运输直升机': 95,
            '战斗机': 90,
            '轰炸机': 85,
            '抢滩登陆艇': 0,
            '对空飞弹车': 0,
            '对地火箭车': 0,
            '重型坦克': 0,
            '潜艇': 0,
            '主力战舰': 0,
            '巡洋舰': 0,
            '鱼雷机': 95,
            '空地战斗机': 90,
            '远程导弹车': 0,
            '资源运输车': 0,
            '驱逐舰': 0,
            '航母': 0,
            '资源运输船': 0,
            '自爆兵': 0,
            '墙': 0,
            '防御塔': 0,
            '反舰导弹车': 0,
            '避雷针': 0,
            '无人机': 100,
        },
        attMaxSize: 7,
        attMinSize: 1,
        yAdd: 0,
        energy: 15,
    },
    '对地火箭车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '远程打击陆军～～～',//介绍
        kz: '克制：陆军，打海军也能造成伤害，就是拿空军没办法',//克制关系
        time: 10,//造的间隔
        speed: 5,//速度
        state: {//CD
            '移动': 10,
            '攻击': 15,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 80,
            '反坦克步兵': 75,
            '侦察车': 40,
            '自行火炮': 40,
            '轮式运输车': 45,
            '履带运输车': 45,
            '中型坦克': 45,
            '工程车': 40,
            '高射炮': 50,
            '武装直升机': 0,
            '运输直升机': 0,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 50,
            '潜艇': 1,
            '主力战舰': 20,
            '巡洋舰': 20,
            '对空飞弹车': 50,
            '对地火箭车': 30,
            '重型坦克': 40,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 40,
            '资源运输车': 40,
            '驱逐舰': 25,
            '航母': 10,
            '资源运输船': 30,
            '自爆兵': 100,
            '墙': 25,
            '防御塔': 20,
            '反舰导弹车': 30,
            '避雷针': 100,
            '气象台': 50,
        },
        attMaxSize: 9,
        attMinSize: 2,
        yAdd: 0,
        energy: 15,
    },
    '重型坦克': {
        lx1: '陆',//类型————兵种
        lx2: '履带车辆',//类型————具体分类
        text: '陆军霸主，横扫一切陆军',//介绍
        kz: '克制：所有陆军 被绝对克制：轰炸机',//克制关系
        time: 10,//造的间隔
        speed: 8,//速度
        state: {//CD
            '移动': 10,
            '攻击': 8,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 85,
            '反坦克步兵': 80,
            '侦察车': 75,
            '自行火炮': 75,
            '轮式运输车': 70,
            '履带运输车': 75,
            '中型坦克': 60,
            '工程车': 55,
            '高射炮': 60,
            '武装直升机': 1,
            '运输直升机': 1,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 25,
            '潜艇': 0,
            '主力战舰': 10,
            '巡洋舰': 5,
            '对空飞弹车': 60,
            '对地火箭车': 65,
            '重型坦克': 60,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 55,
            '资源运输车': 75,
            '驱逐舰': 10,
            '航母': 1,
            '资源运输船': 15,
            '自爆兵': 100,
            '墙': 30,
            '防御塔': 25,
            '反舰导弹车': 70,
            '避雷针': 100,
            '气象台': 50,
        },
        attMaxSize: 2,
        attMinSize: 0,
        yAdd: 0,
        energy: 25,
    },
    '远程导弹车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '东风快递，使命必达',//介绍
        kz: '超远程对所有类型部队的一击',//克制关系
        time: 20,//造的间隔
        speed: 5,//速度
        state: {//CD
            '移动': 10,
            '攻击': 120,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 100,
            '反坦克步兵': 100,
            '侦察车': 99,
            '自行火炮': 99,
            '轮式运输车': 99,
            '履带运输车': 99,
            '中型坦克': 99,
            '工程车': 99,
            '高射炮': 99,
            '武装直升机': 55,
            '运输直升机': 55,
            '战斗机': 55,
            '轰炸机': 55,
            '抢滩登陆艇': 55,
            '潜艇': 10,
            '主力战舰': 55,
            '巡洋舰': 55,
            '对空飞弹车': 99,
            '对地火箭车': 99,
            '重型坦克': 99,
            '鱼雷机': 55,
            '空地战斗机': 55,
            '远程导弹车': 99,
            '资源运输车': 99,
            '驱逐舰': 50,
            '航母': 50,
            '资源运输船': 50,
            '自爆兵': 100,
            '墙': 99,
            '防御塔': 99,
            '反舰导弹车': 99,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 100,
        },
        attMaxSize: 60,
        attMinSize: 8,
        yAdd: 0,
        energy: 10,
    },
    '鱼雷机': {
        lx1: '空',//类型————兵种
        lx2: '空军',//类型————具体分类
        text: '高空投鱼雷精准炸战舰',//介绍
        kz: '克制：海军（除潜艇），被绝对克制：战斗机，高射炮',//克制关系
        time: 10,//造的间隔
        speed: 15,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 0,
            '反坦克步兵': 0,
            '侦察车': 0,
            '自行火炮': 0,
            '轮式运输车': 0,
            '履带运输车': 0,
            '中型坦克': 0,
            '工程车': 0,
            '高射炮': 0,
            '武装直升机': 0,
            '运输直升机': 0,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 85,
            '潜艇': 0,
            '主力战舰': 75,
            '巡洋舰': 75,
            '对空飞弹车': 0,
            '对地火箭车': 0,
            '重型坦克': 0,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 0,
            '资源运输车': 0,
            '驱逐舰': 85,
            '航母': 35,
            '资源运输船': 90,
            '自爆兵': 0,
            '墙': 0,
            '防御塔': 0,
            '反舰导弹车': 0,
            '避雷针': 0,
            '气象台': 0,
        },
        attMaxSize: 3,
        attMinSize: 1,
        yAdd: 1.5,
        energy: 25,
    },
    '空地战斗机': {
        lx1: '空',//类型————兵种
        lx2: '空军',//类型————具体分类
        text: '擅长空对空，地，海作战',//介绍
        kz: '一种抛弃了部分对空火力机炮和装甲和速度而加装中程追踪导弹的战斗机',//克制关系
        time: 12,//造的间隔
        speed: 16,//速度
        state: {//CD
            '移动': 10,
            '攻击': 20,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 80,
            '反坦克步兵': 80,
            '侦察车': 60,
            '自行火炮': 60,
            '轮式运输车': 65,
            '履带运输车': 65,
            '中型坦克': 55,
            '工程车': 55,
            '高射炮': 55,
            '武装直升机': 80,
            '运输直升机': 95,
            '战斗机': 70,
            '轰炸机': 80,
            '抢滩登陆艇': 55,
            '潜艇': 0,
            '主力战舰': 60,
            '巡洋舰': 60,
            '对空飞弹车': 65,
            '对地火箭车': 65,
            '重型坦克': 30,
            '鱼雷机': 85,
            '空地战斗机': 70,
            '远程导弹车': 55,
            '资源运输车': 60,
            '驱逐舰': 20,
            '航母': 10,
            '资源运输船': 25,
            '自爆兵': 100,
            '墙': 5,
            '防御塔': 3,
            '反舰导弹车': 65,
            '避雷针': 100,
            '气象台': 50,
            '无人机': 90,
        },
        attMaxSize: 4,
        attMinSize: 0,
        yAdd: 1.5,
        energy: 10,
    },
    '资源运输车': {
        lx1: '陆',
        lx2: '轮式车辆',
        text: '运输资源大帮手，可以对陆军海军进行补给矿油粮，还可以运2个步兵',
        kz: '在部队后方进行补给运输的重要单位',
        time: 5,
        speed: 12,
        state: {
            '移动': 10,
            '攻击': 15,
        },
        damage: {

        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        energy: 25,
        maxZiYuan: [150, 200, 300],//矿油粮
        maxSit: 2,
    },
    '驱逐舰': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '携带了深水炸弹的战舰，可以反潜艇，也可以进行海战，携带鱼雷，速度快还便宜，就是血薄，有轻防空炮',//介绍
        kz: '反潜艇，对地辅助进战打击，速度灵活，可控性强',//克制关系
        time: 8,//造的间隔
        speed: 12,//速度
        state: {//CD
            '移动': 10,
            '攻击': 8,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 5,
            '反坦克步兵': 3,
            '侦察车': 1,
            '自行火炮': 1,
            '轮式运输车': 1,
            '履带运输车': 1,
            '中型坦克': 1,
            '工程车': 1,
            '高射炮': 1,
            '武装直升机': 10,
            '运输直升机': 10,
            '战斗机': 8,
            '轰炸机': 8,
            '抢滩登陆艇': 35,
            '潜艇': 75,
            '主力战舰': 15,
            '巡洋舰': 20,
            '对空飞弹车': 1,
            '对地火箭车': 1,
            '重型坦克': 1,
            '鱼雷机': 8,
            '空地战斗机': 8,
            '远程导弹车': 1,
            '资源运输车': 1,
            '驱逐舰': 30,
            '航母': 5,
            '资源运输船': 40,
            '自爆兵': 5,
            '墙': 1,
            '防御塔': 0,
            '反舰导弹车': 1,
            '避雷针': 20,
            '气象台': 5,
            '无人机': 80,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.02,
        energy: 25,
    },
    '航母': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '一种血厚，速度慢，携带一些副炮刮痧的大型战舰，可以制造，停泊，维修，补给，起飞飞机。无限补给3格内的己方空军',//介绍
        kz: '血厚归血厚，飞机归飞机，慢就慢一点，就是太贵和副炮太刮痧',//克制关系
        time: 15,//造的间隔
        speed: 6,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 2,
            '反坦克步兵': 1,
            '侦察车': 1,
            '自行火炮': 1,
            '轮式运输车': 1,
            '履带运输车': 1,
            '中型坦克': 1,
            '工程车': 1,
            '高射炮': 1,
            '武装直升机': 8,
            '运输直升机': 8,
            '战斗机': 5,
            '轰炸机': 5,
            '抢滩登陆艇': 15,
            '潜艇': 0,
            '主力战舰': 2,
            '巡洋舰': 5,
            '对空飞弹车': 1,
            '对地火箭车': 1,
            '重型坦克': 1,
            '鱼雷机': 5,
            '空地战斗机': 5,
            '远程导弹车': 1,
            '资源运输车': 1,
            '墙': 0,
            '防御塔': 0,
            '反舰导弹车': 1,
            '避雷针': 3,
            '气象台': 1,
            '无人机': 30,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.15,
        energy: 45,
    },
    '资源运输船': {
        lx1: '海',//类型————兵种
        lx2: '海军',//类型————具体分类
        text: '对海陆提供矿油粮，运量大速度慢，还可以运3步兵',//介绍
        kz: '和运输车一样，不过速度慢，运量大，对海军和陆军提供矿油粮',//克制关系
        time: 8,//造的间隔
        speed: 10,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.15,
        energy: 55,
        maxZiYuan: [250, 350, 500],
        maxSit: 3,
        canSit: ['轻步兵', '反坦克步兵'],
    },
    '自爆兵': {
        lx1: '陆',//类型————兵种
        lx2: '步兵',//类型————具体分类
        text: '自爆！TNT！（血薄，速度快，伤害高，便宜，一次性）',//介绍
        kz: '别被打到～否则秒杀～',//克制关系
        time: 2,//造的间隔
        speed: 8,//速度
        state: {//CD
            '移动': 10,
            '攻击': 10,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 100,
            '反坦克步兵': 100,
            '侦察车': 80,
            '自行火炮': 80,
            '轮式运输车': 80,
            '履带运输车': 80,
            '中型坦克': 70,
            '工程车': 80,
            '高射炮': 70,
            '武装直升机': 0,
            '运输直升机': 0,
            '战斗机': 0,
            '轰炸机': 0,
            '抢滩登陆艇': 0,
            '潜艇': 0,
            '主力战舰': 0,
            '巡洋舰': 0,
            '对空飞弹车': 60,
            '对地火箭车': 60,
            '重型坦克': 55,
            '鱼雷机': 0,
            '空地战斗机': 0,
            '远程导弹车': 55,
            '资源运输车': 80,
            '驱逐舰': 0,
            '航母': 0,
            '资源运输船': 0,
            '自爆兵': 100,
            '墙': 20,
            '防御塔': 18,
            '反舰导弹车': 60,
            '避雷针': 100,
            '气象台': 50,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: -0.25,
        energy: Infinity,
    },
    '防御塔': {
        lx1: '陆',//类型————兵种
        lx2: '设施',//类型————具体分类
        text: '可以载人，里面人越多攻击越大，有防空炮和炮兵，一种远程多人作战单位，擅长放在路边阻挡敌人的脚步(ps：被动防御伤害*1.2)',//介绍
        kz: '血厚，人越多攻击越大，人数*基础伤害=最终伤害,最多20人',//克制关系
        time: 5,//造的间隔
        speed: 0,//速度
        state: {//CD
            '移动': Infinity,
            '攻击': 6,
        },
        damage: {//对于每个兵种的伤害
            '轻步兵': 6,
            '反坦克步兵': 5,
            '侦察车': 4,
            '自行火炮': 3,
            '轮式运输车': 5,
            '履带运输车': 5,
            '中型坦克': 3,
            '工程车': 5,
            '高射炮': 6,
            '武装直升机': 4,
            '运输直升机': 4,
            '战斗机': 2,
            '轰炸机': 2,
            '抢滩登陆艇': 3,
            '潜艇': 0,
            '主力战舰': 2,
            '巡洋舰': 2,
            '对空飞弹车': 3,
            '对地火箭车': 3,
            '重型坦克': 3,
            '鱼雷机': 2,
            '空地战斗机': 2,
            '远程导弹车': 6,
            '资源运输车': 6,
            '驱逐舰': 2,
            '航母': 1,
            '资源运输船': 3,
            '自爆兵': 100,
            '墙': 3,
            '防御塔': 4,
            '反舰导弹车': 3,
            '避雷针': 50,
            '气象台': 20,
            '无人机': 10,
        },
        attMaxSize: 9,
        attMinSize: 0,
        yAdd: 0,
        energy: Infinity,
        maxSit: 15,
    },
    '墙': {
        lx1: '陆',//类型————兵种
        lx2: '设施',//类型————具体分类
        text: '肉盾防御抗打',//介绍
        kz: '防御划领土专用',//克制关系
        time: 1,//造的间隔
        speed: 0,//速度
        state: {//CD
            '移动': Infinity,
            '攻击': Infinity,
        },
        damage: {//对于每个兵种的伤害
        },
        attMaxSize: 0,
        attMinSize: 0,
        yAdd: -0.25,
        energy: Infinity,
    },
    '反舰导弹车': {
        lx1: '陆',//类型————兵种
        lx2: '轮式车辆',//类型————具体分类
        text: '远程打击海军～～～',//介绍
        kz: '克制：海军，其他的都打不了',//克制关系
        time: 10,//造的间隔
        speed: 5,//速度
        state: {//CD
            '移动': 10,
            '攻击': 15,
        },
        damage: {//对于每个兵种的伤害
            '抢滩登陆艇': 100,
            '潜艇': 60,
            '主力战舰': 40,
            '巡洋舰': 50,
            '驱逐舰': 40,
            '航母': 25,
            '资源运输船': 90,
        },
        attMaxSize: 8,
        attMinSize: 1,
        yAdd: 0,
        energy: 20,
    },
    '避雷针': {
        lx1: '陆',//类型————兵种
        lx2: '设施',//类型————具体分类
        text: '保护距离20内的所有单位不受雷劈',//介绍
        kz: '基本上都是被秒杀的',//克制关系
        time: 2,//造的间隔
        speed: 0,//速度
        state: {//CD
            '移动': Infinity,
            '攻击': Infinity,
        },
        damage: {//对于每个兵种的伤害

        },
        attMaxSize: 1,
        attMinSize: 1,
        yAdd: 0,
        energy: 0,
    },
    '气象台': {
        lx1: '陆',//类型————兵种
        lx2: '设施',//类型————具体分类
        text: '灾害天气预报台',//介绍
        kz: '无，此兵种不能攻击，只能被动挨打，所以最好带上一些保镖或者步兵',//克制关系
        time: 3,//造的间隔
        speed: 0,//速度
        state: {//CD
            '移动': Infinity,
            '攻击': Infinity,
        },
        damage: {//对于每个兵种的伤害

        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 0,
        energy: 0,
    },
    '无人机': {
        lx1: '空',
        lx2: '空军',
        text: '轻巧的无人机擅长进行干扰，冲锋，自爆（5格内所有部队都受到普攻伤害*5的伤害），移动间隔灵活，不需要食物',
        kz: '血薄，造价便宜，被克制多',
        time: 3,
        speed: 9,
        state: {
            '移动': 6,
            '攻击': 6,
        },
        damage: {
            '轻步兵': 20,
            '反坦克步兵': 15,
            '侦察车': 10,
            '轮式运输车': 10,
            '履带运输车': 8,
            '自行火炮': 5,
            '中型坦克': 5,
            '工程车': 5,
            '高射炮': 3,
            '武装直升机': 8,
            '运输直升机': 8,
            '抢滩登陆艇': 10,
            '主力战舰': 5,
            '巡洋舰': 5,
            '对空飞弹车': 5,
            '对地火箭车': 8,
            '重型坦克': 5,
            '远程导弹车': 5,
            '资源运输车': 10,
            '驱逐舰': 5,
            '航母': 1,
            '资源运输船': 10,
            '自爆兵': 200,
            '防御塔': 5,
            '墙': 5,
            '反舰导弹车': 8,
            '避雷针': 50,
            '气象台': 30,
            '无人机': 30,
        },
        attMaxSize: 1,
        attMinSize: 0,
        yAdd: 1,
        energy: 15,

    },
};
for (let i in soldiers) {
    if (soldiers[i].damage['资源运输船']) {
        soldiers[i].damage['大型运输船'] = soldiers[i].damage['资源运输船']
    }
}



let soldiersList = []
for (let i in soldiers) {
    soldiersList.push(i)
}





fzZiYuan()
let yunShuDanWei = ['轮式运输车', '履带运输车', '运输直升机', '抢滩登陆艇', '资源运输车', '资源运输船', '大型运输船', '防御塔']//运输单位
let ziYuanYunShu = ['资源运输车', '资源运输船']
async function bfs_HAJT(x, y, z, size, lx, entity = new Box3Entity) {//黑暗军团移动计算
    let queue = [];
    let stpq = [0];
    queue.push(new Box3Vector3(x, y, z));
    var voxel = [];
    for (let az = 0; az < Infinity; az++) {
        if (az % 30 == 0) {
            await sleep(1)
        }
        if (queue.length <= 0) {
            break;
        }
        let now = queue[0];
        queue.shift();
        let stp = stpq[0];
        stpq.shift();
        for (let i = 0; i < 4; i++) {
            let nowx = now.x + dir[i].x;
            let nowy = now.y + dir[i].y;
            let nowz = now.z + dir[i].z;
            if (voxels.getVoxelId(nowx, nowy, nowz) == 0) {
                if (dx[voxels.name(voxels.getVoxelId(nowx, nowy - 1, nowz))] != undefined) {
                    if (stp + dx[voxels.name(voxels.getVoxelId(nowx, nowy - 1, nowz))].speed[lx] - 1 < size) {
                        queue.push(new Box3Vector3(nowx, nowy, nowz));
                        stpq.push(stp + dx[voxels.name(voxels.getVoxelId(nowx, nowy - 1, nowz))].speed[lx]);
                        voxel.push([nowx, nowy, nowz]);
                    }
                }
            }
        }
    }
    return voxel[Math.floor(Math.random() * voxel.length)]
}






async function bfs(x, y, z, size, lx, entity) {
    let queue = [];
    let stpq = [0];
    queue.push(new Box3Vector3(x, y, z));
    var voxel = [];
    var end = 0;
    for (let az = 0; az < Infinity; az++) {
        if (az % 32 == 0) {
            await sleep(1);
        };
        if (queue.length <= 0) {
            break;
        }
        let now = queue[0];
        queue.shift();
        let stp = stpq[0];
        stpq.shift();
        for (let i = 0; i < 4; i++) {
            if (entity.removingSoldier == '') continue;
            let nowx = now.x + dir[i].x;
            let nowy = now.y + dir[i].y;
            let nowz = now.z + dir[i].z;
            if (voxels.getVoxelId(nowx, nowy, nowz) == 0) {
                if (dx[voxels.name(voxels.getVoxelId(nowx, nowy - 1, nowz))] != undefined) {
                    if (stp + dx[voxels.name(voxels.getVoxelId(nowx, nowy - 1, nowz))].speed[lx] - 1 < size) {
                        var soldier = getSoldier(new Box3Vector3(nowx, nowy, nowz));
                        queue.push(new Box3Vector3(nowx, nowy, nowz));
                        let a = 0;
                        let b = 0;
                        try {
                            if (soldier != '') {
                                a = 1;
                                if (soldier.own != entity && soldiers[entity.removingSoldier.name].lx1 != '空' && entity.team != soldier.team) {
                                    b = 9999;
                                };
                            };
                        } catch (e) {
                            console.log(e);
                        };
                        stpq.push(stp + dx[voxels.name(voxels.getVoxelId(nowx, nowy - 1, nowz))].speed[lx] + b);
                        if (a == 1) {
                            if (yunShuDanWei.includes(soldier.name) && (entity.removingSoldier.name != '自爆兵' || soldier.name != '防御塔')) {
                                if (soldiers[soldier.name].canSit) {
                                    if (soldiers[soldier.name].canSit.includes(entity.removingSoldier.name)) {
                                        if (soldier.sits.length < soldiers[soldier.name].maxSit + pifuChuLi(soldier.pifu, 'maxSit', 0)) {
                                            a = 0;
                                        };
                                    }
                                }
                            };
                        };
                        if ((nowx != x || nowz != z) && a == 0) {
                            voxel.push([nowx, nowy, nowz]);
                            (async function () {
                                var x1 = nowx;
                                var y1 = nowy;
                                var z1 = nowz;
                                voxels.setVoxel(nowx, nowy, nowz, 'glass');
                                var emm = 0;
                                for (let i = 0; i < 3; i++) {
                                    await sleep(500);
                                    if (end == 0) {
                                        i -= 1;
                                        continue;
                                    };
                                    await sleep(1500);
                                    if (voxels.getVoxelId(nowx, nowy, nowz) == 0) {
                                        emm = 1;
                                        continue;
                                    }
                                };
                                if (emm == 0) {
                                    voxels.setVoxelId(x1, y1, z1, 0);
                                };
                            })();
                        };
                    };
                };
            };
        };
    };
    end = 1;
    return voxel;
};

world.onPlayerJoin(async ({ entity }) => {
    entity.isCommander = false;
    entity.team = '旁观者'
    entity.jd = ''
    entity.guaji = false;
    entity.score = 0;
    (async function () {
        while (!entity.createJD) {
            await sleep(1)
        }
        if (gameStart == true) {
            if (world.querySelectorAll('.蓝队').length < world.querySelectorAll('.红队').length) {
                joinTeam(entity, '蓝队')
            } else if (world.querySelectorAll('.红队').length < world.querySelectorAll('.蓝队').length) {
                joinTeam(entity, '红队')
            } else {
                if (Math.random() < 0.5) {
                    joinTeam(entity, '蓝队');
                } else {
                    joinTeam(entity, '红队')
                }
            }
        }
    })()
    textDialog(entity, '公告', `
这里是沙盘演习，红队和蓝队展开pk，敬请期待吧！
`)
    entity.coin += 10
    entity.player.directMessage('登陆奖励10军团币～')
    entity.xuanzhanTime = 0;
    entity.clicked = 0;//是否按过按钮
    entity.enemy = [];//所有敌人,存储格式：[{entity,score:xxx,time:x},...],敌人离开地图则胜利，每次造成1点伤害，则分数+造价/100，分数到达30万时候或者有兵占领/堵敌人基地则达到者胜利，敌人投降你胜利，求和即回归和平状态，输的人要赔掉随机30%部队和50%资金
    entity.player.cameraMode = 'fps'
    entity.kaigua = 0
    entity.locked = 0;
    entity.color = new Box3RGBAColor(255, 255, 255, 255)
    entity.voxel = []
    entity.attVoxel = []
    entity.removingSoldier = ''
    entity.attSoldier = ''
    entity.player.spectator = true;
    entity.player.invisible = true;
    entity.player.canFly = true;
    entity.player.showName = false;
    entity.player.enable3DCursor = true;
    entity.money = 10000;
    entity.foodZiDong = 1;
    entity.chatTime = 0;//私信剩余时间
    entity.createJD = function (pos) {
        var e = world.createEntity({
            mesh: 'mesh/占领标识.vb',
            position: new Box3Vector3(pos.x, 1.01, pos.z),
            meshScale: new Box3Vector3(0.03, 0.03, 0.03),
            collides: false,
            gravity: false,
        })
        e.addTag(entity.player.name)
        e.addTag('占领标识')
        e.addTag('基地占领标识')
        e.own = entity
        entity.jd = e;//基地
        entity.jd.cdTime = 0;
        entity.position.x = e.position.x
        entity.position.y = e.position.y + 8
        entity.position.z = e.position.z
    }
});
world.onPlayerLeave(async ({ entity }) => {
    /*    if (entity.enemy.length > 0) {
            for (let i in entity.enemy) {
                var other = entity.enemy[i][0]
                other.player.directMessage('你和' + entity.player.name + '的战争结束！！！你赢了！！！')
                world.say(entity.player.name + '和' + other.player.name + '的战争结束了' + other.player.name + '赢了！！！（对方退出游戏）')
                warEnd(other, entity, type = 'leave')
                var enemy = []
                for (let i in other.enemy) {
                    if (other.enemy[i][0] == entity) {
    
                    } else {
                        enemy.push(other.enemy[i])
                    }
                }
                other.enemy = enemy
            }
            entity.enemy = []
        }*/
    if (entity.jd && entity.money) {
        world.querySelectorAll('.' + entity.player.name).forEach(async (e) => {
            e.destroy();
        })
    }
})
Box3Entity.prototype.doingTask = function () {
    if (this.tasks[1].length > 0) {
        return tasks[this.tasks[1][this.tasks[1].length - 1]].after
    } else {
        return '第一个步兵'
    }
}
Box3Entity.prototype.soldiers = function () {
    var soldiers = []
    world.querySelectorAll('.士兵').forEach((e) => {
        if (e.hasTag(this.player.name)) {
            soldiers.push(e)
        }
    })
    return soldiers
};
Box3Entity.prototype.getCityNum = function () {
    var soldiers = []
    var pos = []
    world.querySelectorAll('.士兵').forEach((e) => {
        if (e.hasTag(this.player.name) && (e.name == '轻步兵' || e.name == '反坦克步兵')) {
            soldiers.push(e)
        }
    })
    if (soldiers.length == 0) return 0;
    var num = 0;
    for (let i of soldiers) {
        for (let x = i.position.x - 1; x < i.position.x + 2; x++) {
            for (let z = i.position.z - 1; z < i.position.z + 2; z++) {
                if (dx[getPosVoxel(x, z)].name == '城市' && !pos.includes(x + ',' + z)) {
                    num++
                    pos.push(x + ',' + z)
                }
            }
        }
        var voxel = getPosVoxel(i.position.x, i.position.z)
        var name = ''
        if (this.team == '红队') {
            name = '红色据点';
        }
        if (this.team == '蓝队') {
            name = '蓝色据点';
        }
        if (dx[voxel]) {
            if (dx[voxel].name == name) {
                num += 5
            }
        }
    }
    return num
};
function getPosVoxel(x, z) {
    return voxels.name(voxels.getVoxel(Math.floor(x) + 0.5, 0, Math.floor(z) + 0.5))
}
function deleteArrayStr(array = [], str = '') {
    var arr = []
    for (let i of array) {
        if (i != str) {
            arr.push(i)
        }
    }
    return arr
}
let admin = ['jmd123456', 'ydm666666', 'jmd123456789']
let ncPlayer = ['jmd123456', 'ydm666666', '5021210sshlyw', 'nAE3y3WXBS4HJaf', 'jiyyds', 'xinwmwxdr']
let admin1 = ['inputprintsrsc'];//学而思
world.onChat(({ entity, message }) => {
    if (!admin.includes(entity.player.boxId)) return;
    if (message.charAt(0) == '$') {
        try {
            world.say('<~ ' + eval(message.slice(1)));
        } catch (e) {
            entity.player.directMessage(e)
        }
    }
});
global.getHelp = getHelp
async function getHelp(entity) {
    var result = await entity.player.dialog({
        type: Box3DialogType.SELECT,
        title: "帮助",
        content: `右键点击回基地选项回基地，左键基地边缘制造兵种，左键兵有部署操作，右键有工具操作，步兵移动到基地上换基地，移动到城市上占领，每个城市一定要有步兵驻守后每30秒+1000元`,
        options: ['关于资源', '克制建议', '天气和时间和自然灾害', '科技', '各种资源获得方式', '沙盘演习的玩法和胜负判定'],
        // 将提供玩家选择的选项放入数组里。
    });

    // 如果玩家点击了屏幕其他区域，取消了对话框。
    if (!result || result === null) {
        return;
    }

    // 判断玩家选了什么选项。
    switch (result.value) {
        case '各种资源获得方式':
            textDialog(entity, '各种资源获得方式', `
            军团币获得方式：
            1.做任务
            2.做活动
            3.找作者要（bushi）
            碎片获得方式：打黑暗军团或者在商店买
            军衔星获得方式：做任务，或者找别人打架（宣战）
            游戏币获得方式：占领城镇
            三种资源（矿/油/粮）获得方式见关于资源
            `)
            break;
        case '科技':
            textDialog(entity, '科技帮助',
                `
            科技可以给你的兵种带来超大buff提升～
            比如金融学可以让你的收入增加，装甲强化可以加强你的防御，攻击什么的...
            碎片获得方式：
            1.打黑暗军团
            2.在商店买
            军团币获得方式太多了，很多方式基本上都行
            `
            )
            break;
        case '关于资源':
            entity.player.dialog({
                type: Box3DialogType.TEXT,
                title: "资源帮助",
                content: `
                步兵移动到资源点上，就可以对附近3格的己方单位补给，如果此单位是运输车则补给运输车，有几率采集完
                石油：单位缺石油则不能移动
                粮食：单位没有粮食会不断扣血
                矿物：给工程车补给，制造固定设施需要使用
                移动攻击都需要粮食
                `,
            });
            break;
        case '克制建议':
            textDialog(entity, '克制建议',
                `
            轻步兵：挨打，速度快，灵活，便宜
            反坦克步兵：反装甲，血厚，速度慢
            自爆兵：老六，打地面装甲，拼手速
            侦察车：打步兵和运输单位
            工程车：后方辅助，还能制造固定设施
            坦克单位：轰击地面装甲
            高射炮：远程输出～打飞机和一些轻装甲专用～
            远程地对空：飞机：van了，芭比Q了
            远程地对地：需要前线有近战单位的辅助，秀超神，利用地形隔山打人（）
            无人机：让我看看谁想被我自爆～
            武装直升机：只会打轻型装甲的屑fw
            轰炸机：打陆军专用
            战斗机：克制全部空军
            鱼雷机：打战舰
            巡洋舰：打飞机，打海战的话打驱逐舰还行
            驱逐舰：反潜艇，速度快，打劫专用（bushi），和侦察车一个性质（）
            主力战舰：远程对地火炮～放在桥附近这陆地不防御的死死的（）就是不能对空
            航母：无限补给飞机～还能制造飞机～第二基地～
            运输单位：快快快！（被动挨打ing）
            资源运输单位：嘿嘿嘿（）
            `)
            break;
        case '天气和时间和自然灾害':
            textDialog(entity, '天气和时间',
                `
            （开发中）
            时间：
            白天：可见度强，无增益
            黑夜：所有单位移动速度*0.9，防御*0.9

            天气：
            晴，多云，阴：普通常见天气，无增益
            小雨：部队移动*0.8，远程单位攻击*0.8，所有单位防御*0.9
            中雨：部队移动*0.7，远程单位攻击*0.7，所有单位防御*0.8
            大雨：部队移动*0.6，远程单位攻击*0.6，所有单位防御*0.7
            雷雨：部队移动*0.7，远程单位攻击*0.7，所有单位防御*0.8，每隔着20秒每个单位都有5%几率被雷劈，如果在森林，山地则提升几率至15%，如果在城市，基地则不会被雷劈(伤害30～90)
            雪：部队移动*0.6，部队防御*0.5，部队攻击*0.6
            雾霾：部队移动速度*0.7，远程单位攻击*0.5，部队防御*0.8

            自然灾害：
            地震：在一个地震原点半径30~80内，每个部队每秒都有80%几率受到5点地震伤害，持续15秒，在基地里的或者在城市里的每次伤害改为2点伤害，会有一部分的陆地变成山地，30～60秒后恢复
            海啸：伴随着地震产生也可以独立产生，多发在雨天，在地震范围内或者是独立范围内80%的部队检测附近是不是有大型沿海，如果有则会受到50点伤害，会给10秒紧急撤离
            洪水：和海啸差不多，也可以伴随着地震产生也可以独立产生，多发在雨天。在地震范围内或者独立范围内的所有部队身边如果有水系的话则受到20点伤害
            台风：在任意一个位置对附近30~60的距离内所有部队进行持续10秒，每秒2点的伤害，对空军双倍伤害
            龙卷风：在任意一个位置对附近8~12距离区域内所有部队进行持续5秒，每秒3点的伤害，对空军三倍伤害
            饥荒：地图上农田在一瞬间减少90%，补给和购买粮食需要钱数*4，然后缓慢恢复农田数量
            瘟疫：（部队重量小于一百不会发生瘟疫），母体选择地图上任意10个内部有生物部队（不是固定设施），只要感染上了则会双倍速度消耗食物，同时会感染附近5格内的所有部队，每个部队感染上每秒扣3滴血，持续20秒，在发生1分钟后或者世界部队总量小于100消失            
            `)
            break;
        case '沙盘演习的玩法和胜负判定':
            textDialog(entity, '沙盘演习玩法', `
            得分方式：占领据点得分20000，如果是敌人的据点敌人的分数-20000，对别人造成损失可以获得损失/50的分数，达到100万分胜利
            如果在游戏开始后45分钟后没有决定胜负，那么分数多的获胜，否则平局
            `)
            break;
        default:
        // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
    }
};
const weathers = {
    '晴': {
        damage: 1,//普通单位攻击
        farDamage: 1,//远程单位攻击
        fangyu: 1,
        speed: 1,
    },
    '阴': {
        damage: 1,//普通单位攻击
        farDamage: 1,//远程单位攻击
        fangyu: 1,
        speed: 1,
    },
    '多云': {
        damage: 1,//普通单位攻击
        farDamage: 1,//远程单位攻击
        fangyu: 1,
        speed: 1,
    },
    '小雨': {
        damage: 1,//普通单位攻击
        farDamage: 0.8,//远程单位攻击
        fangyu: 0.9,
        speed: 0.8,
    },
    '中雨': {
        damage: 1,//普通单位攻击
        farDamage: 0.7,//远程单位攻击
        fangyu: 0.8,
        speed: 0.7,
    },
    '大雨': {
        damage: 1,//普通单位攻击
        farDamage: 0.6,//远程单位攻击
        fangyu: 0.7,
        speed: 0.6,
    },
    '雷雨': {
        damage: 1,//普通单位攻击
        farDamage: 0.7,//远程单位攻击
        fangyu: 0.8,
        speed: 0.7,
    },
    '雪': {
        damage: 0.6,//普通单位攻击
        farDamage: 0.6,//远程单位攻击
        fangyu: 0.5,
        speed: 0.6,
    },
    '雾霾': {
        damage: 1,//普通单位攻击
        farDamage: 0.5,//远程单位攻击
        fangyu: 0.8,
        speed: 0.7,
    },
};
function nature(type, attMaxSize = 0) {//type可以是speed，damage等等
    if (weathers[world.weather]) {
        let damage = 1;
        let farDamage = 1;
        let fangyu = 1;
        let speed = 1;
        if (world.sunPhase < 0.5) {

        } else {//晚上
            speed *= 0.9;
            fangyu *= 0.9;
        }
        damage *= weathers[world.weather].damage
        farDamage *= weathers[world.weather].farDamage
        fangyu *= weathers[world.weather].fangyu
        speed *= weathers[world.weather].speed
        if (type == 'damage') {
            if (attMaxSize > 5) {
                return farDamage
            } else {
                return damage
            }
        }
        if (type == 'fangyu') {
            return fangyu
        }
        if (type == 'speed') {
            return speed
        }
    } else {
        return 1
    }
}
world.weather = '晴'
world.weathers = ['晴']
world.onChat(({ entity, message }) => {
    if (message == '/help' || message.includes('怎么玩') || message.includes('咋玩') || message.includes('怎么造兵')) {
        getHelp(entity)
    }
});
for (let i = 0; i < 20; i++) {
    var a = Math.random()
    if (a < 0.2) {
        world.weathers.push('晴')
    } else if (a < 0.35) {
        world.weathers.push('多云')
    } else if (a < 0.5) {
        world.weathers.push('阴')
    } else if (a < 0.6) {
        world.weathers.push('小雨')
    } else if (a < 0.65) {
        world.weathers.push('中雨')
    } else if (a < 0.7) {
        world.weathers.push('大雨')
    } else if (a < 0.75) {
        world.weathers.push('雷雨')
    } else if (a < 0.85) {
        world.weathers.push('雪')
    } else if (a < 1) {
        world.weathers.push('雾霾')
    }
}
world.testHigh = 800
world.yc = 0
world.onTick(async ({ elapsedTimeMS, tick }) => {
    if ((world.sunPhase + world.sunFrequency * tick) % 1 <= world.sunFrequency) {
        world.say('迎接新的一天')
        world.weather = world.weathers.shift()
        var a = Math.random()
        if (a < 0.2) {
            world.weathers.push('晴')
        } else if (a < 0.35) {
            world.weathers.push('多云')
        } else if (a < 0.5) {
            world.weathers.push('阴')
        } else if (a < 0.6) {
            world.weathers.push('小雨')
        } else if (a < 0.65) {
            world.weathers.push('中雨')
        } else if (a < 0.7) {
            world.weathers.push('大雨')
        } else if (a < 0.75) {
            world.weathers.push('雷雨')
        } else if (a < 0.85) {
            world.weathers.push('雪')
        } else if (a < 1) {
            world.weathers.push('雾霾')
        }
    }
    world.yc = elapsedTimeMS
});
world.sunFrequency = 0.0005
world.tickJg = 1000;//1000毫秒循环间隔
world.nowTime = 0;
world.snowTexture = 'snow/snow.part';
world.snowSizeLo = 1;
world.natureZaiHai = [];//自然灾害间隔2分钟～5分钟发生一次，会发生在一些地方
/*(async function () {//自然灾害循环
    world.ziYuanNum = await getZiYuanNum()
    while (1) {
        await sleep(Math.floor(120 + Math.random() * 180) * 1000);
        (async function () {
            var zaiHai = world.natureZaiHai.shift()
            if (world.natureZaiHai[0].name == '饥荒' || Math.random() < 0.2) {
                world.say('近期世界上可能会发生饥荒，请做好粮食准备')
            }
            if (zaiHai.name == '地震') {
                var radius = Math.floor(30 + Math.random() * 50)
                world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了一次地震！！！半径：' + radius)
                var fwq = world.createEntity({
                    mesh: 'mesh/范围圈.vb',
                    position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                    meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                    gravity: false,
                    fixed: true,
                    collides: false,
                })
                for (let i = 0; i < 5; i++) {
                    if (i == 1) {
                        fwq.destroy()
                    }
                    world.querySelectorAll('.士兵').forEach((e) => {
                        if (pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius && soldiers[e.name].lx1) {
                            if (Math.random() < 0.8) {
                                var damage = 0
                                if (dx[getPosVoxel(e.position.x, e.position.z)].lx == '基地' || dx[getPosVoxel(e.position.x, e.position.z)].lx == '城市') {
                                    damage = 15
                                } else {
                                    damage = 12
                                }
                                e.hurt(damage)
                            }
                        }
                    })
                    await sleep(3000)
                }
                await sleep(5000)
                if (Math.random() < 0.1) {
                    world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了震后海啸！！！半径：' + radius)
                    await sleep(10000)
                    var fwq = world.createEntity({
                        mesh: 'mesh/范围圈.vb',
                        position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                        meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                        gravity: false,
                        fixed: true,
                        collides: false,
                    })
                    world.querySelectorAll('.士兵').forEach((e) => {
                        if (Math.random() < 0.8 && pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius) {
                            var a = 0;
                            for (let x = e.position.x - 3; x < e.position.x + 4; x++) {
                                for (let z = e.position.z - 3; z < e.position.z + 4; z++) {
                                    if (getPosVoxel(x, z) != 'water') {
                                        a = 1
                                    }
                                }
                            }
                            if (a == 1) {
                                e.hurt(50)
                            }
                        }
                    })
                    await sleep(2000)
                    fwq.destroy()
                } else if (Math.random() < 0.1) {
                    world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了震后洪水！！！半径：' + radius)
                    var fwq = world.createEntity({
                        mesh: 'mesh/范围圈.vb',
                        position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                        meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                        gravity: false,
                        fixed: true,
                        collides: false,
                    })
                    world.querySelectorAll('.士兵').forEach((e) => {
                        if (soldiers[e.name].lx1 != '空') {
                            if (pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius) {
                            } else {
                                var a = 0;
                                for (let x = e.position.x - 3; x < e.position.x + 4; x++) {
                                    for (let z = e.position.z - 3; z < e.position.z + 4; z++) {
                                        if (getPosVoxel(x, z) != 'water') {
                                            a = 1
                                        }
                                    }
                                }
                                if (a == 1) {
                                    e.hurt(20)
                                }
                            }
                        }
                    })
                    await sleep(2000)
                    fwq.destroy()
                }
            }
            if (zaiHai.name == '海啸') {
                var radius = Math.floor(60 + Math.random() * 20)
                world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了海啸！！！半径：' + radius)
                await sleep(10000)
                var fwq = world.createEntity({
                    mesh: 'mesh/范围圈.vb',
                    position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                    meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                    gravity: false,
                    fixed: true,
                    collides: false,
                })
                world.querySelectorAll('.士兵').forEach((e) => {
                    if (Math.random() < 0.8 && pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius) {
                        var a = 0;
                        for (let x = e.position.x - 3; x < e.position.x + 4; x++) {
                            for (let z = e.position.z - 3; z < e.position.z + 4; z++) {
                                if (getPosVoxel(x, z) != 'water') {
                                    a = 1
                                }
                            }
                        }
                        if (a == 1) {
                            e.hurt(50)
                        }
                    }
                })
                await sleep(2000)
                fwq.destroy()
            }
            if (zaiHai.name == '洪水') {
                var radius = Math.floor(80 + Math.random() * 20)
                world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了洪水！！！半径：' + radius)
                var fwq = world.createEntity({
                    mesh: 'mesh/范围圈.vb',
                    position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                    meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                    gravity: false,
                    fixed: true,
                    collides: false,
                })
                world.querySelectorAll('.士兵').forEach((e) => {
                    if (soldiers[e.name].lx1 != '空') {
                        if (pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius) {
                        } else {
                            var a = 0;
                            for (let x = e.position.x - 3; x < e.position.x + 4; x++) {
                                for (let z = e.position.z - 3; z < e.position.z + 4; z++) {
                                    if (getPosVoxel(x, z) != 'water') {
                                        a = 1
                                    }
                                }
                            }
                            if (a == 1) {
                                e.hurt(20)
                            }
                        }
                    }
                })
                await sleep(2000)
                fwq.destroy()
            }
            if (zaiHai.name == '龙卷风') {
                var radius = Math.floor(8 + Math.random() * 4)
                world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了龙卷风！！！半径：' + radius)
                var fwq = world.createEntity({
                    mesh: 'mesh/范围圈.vb',
                    position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                    meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                    gravity: false,
                    fixed: true,
                    collides: false,
                })
                for (let i = 0; i < 5; i++) {
                    if (i == 2) {
                        fwq.destroy()
                    }
                    world.querySelectorAll('.士兵').forEach((e) => {
                        if (pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius) {
                        } else {
                            e.hurt(3)
                            if (soldiers[e.name].lx1 == '空') {
                                e.hurt(6)
                            }
                        }
                    })
                    await sleep(1000)
                }
            }
            if (zaiHai.name == '台风') {
                var radius = Math.floor(30 + Math.random() * 30)
                world.say('在x:' + zaiHai.x + 'z:' + zaiHai.z + '发生了台风！！！半径：' + radius)
                var fwq = world.createEntity({
                    mesh: 'mesh/范围圈.vb',
                    position: new Box3Vector3(zaiHai.x, 1.1, zaiHai.z),
                    meshScale: new Box3Vector3(0.0625 * radius, 0.07, 0.0625 * radius),
                    gravity: false,
                    fixed: true,
                    collides: false,
                })
                for (let i = 0; i < 10; i++) {
                    if (i == 2) {
                        fwq.destroy()
                    }
                    world.querySelectorAll('.士兵').forEach((e) => {
                        if (pmDist(e.position, new Box3Vector3(zaiHai.x, 0, zaiHai.z)) <= radius) {
                        } else {
                            e.hurt(2)
                            if (soldiers[e.name].lx1 == '空') {
                                e.hurt(2)
                            }
                        }
                    })
                    await sleep(1000)
                }
            }
            if (zaiHai.name == '饥荒') {
                world.say('世界发生了饥荒!!!')
                for (let x = 0; x < 256; x++) {
                    for (let z = 0; z < 256; z++) {
                        if (voxels.name(voxels.getVoxelId(x, 0, z)) == 'yellow_grass' && Math.random() < 0.7) {
                            voxels.setVoxel(x, 0, z, 'grass')
                        }
                    }
                }
            }
        })()
    }
})()
for (let i = 0; i < 100; i++) {
    var a = Math.random()
    if (world.natureZaiHai[world.natureZaiHai.length - 1] == '地震') {
        a -= 0.05
    }
    if (a < 0.2) {
        world.natureZaiHai.push({ name: '地震', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    } else if (a < 0.3) {
        world.natureZaiHai.push({ name: '海啸', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    } else if (a < 0.45) {
        world.natureZaiHai.push({ name: '洪水', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    } else if (a < 0.6) {
        world.natureZaiHai.push({ name: '台风', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    } else if (a < 0.75) {
        world.natureZaiHai.push({ name: '龙卷风', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    } else if (a < 0.9) {
        world.natureZaiHai.push({ name: '饥荒', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    } else if (a < 1) {
        world.natureZaiHai.push({ name: '瘟疫', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
    }
};
*/
world.enableMain = 1;
(async function main() {//主循环
    let i = 0;
    while (1) {
        try {
            if (world.enableMain == 0 || gameStart == false) {
                await sleep(1000);
                continue;
            }
            i++
            if (i % 10 == 0) {
                world.ziYuanNum = 0
                /*
                                if (world.natureZaiHai.length < 10) {
                                    for (let i = 0; i < 100; i++) {
                                        var a = Math.random()
                                        if (world.natureZaiHai[world.natureZaiHai.length - 1] == '地震') {
                                            a -= 0.05
                                        }
                                        if (a < 0.2) {
                                            world.natureZaiHai.push({ name: '地震', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        } else if (a < 0.3) {
                                            world.natureZaiHai.push({ name: '海啸', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        } else if (a < 0.45) {
                                            world.natureZaiHai.push({ name: '洪水', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        } else if (a < 0.6) {
                                            world.natureZaiHai.push({ name: '台风', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        } else if (a < 0.75) {
                                            world.natureZaiHai.push({ name: '龙卷风', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        } else if (a < 0.9) {
                                            world.natureZaiHai.push({ name: '饥荒', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        } else if (a < 1) {
                                            world.natureZaiHai.push({ name: '瘟疫', x: Math.round(10 + Math.random() * 236), z: Math.round(10 + Math.random() * 236) })
                                        }
                                    }
                                }
                */
            }
            if (world.weather == '雷雨') {
                if (Math.random() < 0.8) {
                    (async function () {
                        var dot = world.createEntity({
                            mesh: 'mesh/单元方块.vb',
                            position: new Box3Vector3(10 + Math.random() * 236, 100, 10 + Math.random() * 236),
                            gravity: 0,
                            fixed: 1,
                            collides: 0,
                            meshScale: new Box3Vector3(0, 0, 0)
                        });

                        Object.assign(dot, {
                            particleRate: 10000,
                            particleLifetime: 1,
                            particleColor: new Box3RGBColor(1, 10, 10),
                            particleSize: 5,
                            particleVelocity: [0, -300, 0],
                            particleNoise: 5,  //数值越大频率越高
                            particleNoiseFrequency: Infinity

                        })
                        await sleep(500);
                        dot.destroy()
                    })()
                }
                if (i % 15 == 0) {
                    world.querySelectorAll('.士兵').forEach(async (e) => {
                        var a = 0.05;
                        var voxel = getPosVoxel(e.position.x, e.position.z)
                        if (voxel == 'rock' || voxel == 'leaf_05') {
                            a = 0.15
                        }
                        if (dx[voxel].lx == '基地' || dx[voxel].lx == '城市') {
                            a = 0
                        }
                        if (Math.random() < a) {
                            var b = 0;
                            world.querySelectorAll('.避雷针').forEach((x) => {
                                if (pmDist(x.position, e.position) <= 20) {
                                    b = 1
                                    x.hurt(10)
                                }
                            })
                            if (b == 0) {
                                e.hurt(Math.floor(30 + Math.random() * 60))
                                var dot = world.createEntity({
                                    mesh: 'mesh/单元方块.vb',
                                    position: new Box3Vector3(e.position.x, 60, e.position.z),
                                    gravity: 0,
                                    fixed: 1,
                                    collides: 0,
                                    meshScale: new Box3Vector3(0, 0, 0)
                                });

                                Object.assign(dot, {
                                    particleRate: 10000,
                                    particleLifetime: 1,
                                    particleColor: new Box3RGBColor(1, 10, 10),
                                    particleSize: 5,
                                    particleVelocity: [0, -300, 0],
                                    particleNoise: 5,  //数值越大频率越高
                                    particleNoiseFrequency: Infinity

                                })
                                await sleep(500);
                                dot.destroy()
                            }
                        }
                    })
                }
            }
            world.snowDensity = 0;
            world.snowFallSpeed = 0;
            if (world.weather == '雾霾') {
                world.rainSpeed = 0;
                world.rainDensity = 0;
                world.maxFog = 0.8;                             // 最大雾量
                world.fogColor = new Box3RGBColor(1, 1, 1);   // 颜色
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 10;                   // 起始距离
                world.fogUniformDensity = 0.8;                  // 均匀密度
            } else if (world.weather == '小雨') {
                world.rainSpeed = 0.5;
                world.rainDensity = 0.1;
                world.maxFog = 0.3;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.3;
            } else if (world.weather == '中雨') {
                world.rainSpeed = 0.6;
                world.rainDensity = 0.3;
                world.maxFog = 0.4;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.4;                  // 均匀密度
            } else if (world.weather == '大雨') {
                world.rainSpeed = 0.7;
                world.rainDensity = 0.5;
                world.maxFog = 0.5;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.5;                  // 均匀密度
            } else if (world.weather == '雷雨') {
                world.rainSpeed = 0.6;
                world.rainDensity = 0.5;
                world.maxFog = 0.5;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.5;                  // 均匀密度
            } else if (world.weather == '阴') {
                world.rainSpeed = 0;
                world.rainDensity = 0;
                world.maxFog = 0.2;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.2;                  // 均匀密度
            } else if (world.weather == '多云') {
                world.rainSpeed = 0;
                world.rainDensity = 0;
                world.maxFog = 0.1;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.1;                  // 均匀密度
            } else if (world.weather == '雪') {
                world.snowDensity = 0.1;
                world.snowFallSpeed = 0.2;
                world.rainSpeed = 0;
                world.rainDensity = 0;
                world.maxFog = 0.1;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0.1;
            } else {
                world.rainSpeed = 0;
                world.rainDensity = 0;
                world.maxFog = 0;                             // 最大雾量
                world.fogHeightOffset = 0;                 // 高度
                world.fogStartDistance = 0;                   // 起始距离
                world.fogUniformDensity = 0;                  // 均匀密度
            }
            world.nowTime++
            if (i % 30 == 0) {
                fzZiYuan()
                world.say(`
资源刷新中
内测版，左键点击基地造兵，左键兵有操作，右键有操作，具体帮助请说/help
目前比分：（蓝）${blueScore}:（红）${redScore}
                `)

            };
            (async function () {
                /*
                                if (world.querySelectorAll('.黑暗军团小兵').length > 0) {
                                    for (let i = 0; i < 3; i++) {
                                        var e = world.querySelectorAll('.黑暗军团小兵')[Math.floor(Math.random() * world.querySelectorAll('.黑暗军团小兵').length)]
                                        if (e.state['移动'] <= 0 && world.yc < 300) {
                                            num += 1;
                                            let pos = await bfs_HAJT(e.position.x, 1, e.position.z, soldiers[e.name].speed, soldiers[e.name].lx2, e)
                                            if (getSoldier(new Box3Vector3(pos[0], 0, pos[2])) != '') return;
                                            e.position.x = pos[0]
                                            e.position.z = pos[2]
                                            e.state['移动'] = soldiers[e.name].state['移动']
                                            await sleep(1000)
                                        }
                                    }
                                }
                */
            })();
            for (let e of world.querySelectorAll('player').filter(e => e.team != '旁观者')) {
                await sleep(1)
                if (Number.isNaN(e.money)) {
                    e.money = 114514
                    e.player.directMessage('因为你的钱是NAN，这是bug，赔你了114514')
                }
                if (i % 60 == 0) {
                    await savePlayer(e)
                }
                if (e.jd) {
                    e.jd.meshColor = e.color
                    for (let i in e.enemy) {
                        e.enemy[i][2]--
                        if (e.enemy[i][1] >= 300000) {
                            var other = world.querySelectorAll('player').filter(a => a == e.enemy[i][0])[0]
                            other.player.directMessage('你和' + other.player.name + '的战争结束！！！你落败了！！！')
                            e.player.directMessage('你和' + other.player.name + '的战争结束！！！你赢了！！！')
                            world.say(other.player.name + '和' + e.player.name + '的战争结束了,结果是' + e.player.name + '赢了！！！比分分别是' + otherScore + ' : 300000')
                            warEnd(e, other)
                            e.enemy = deleteArrayStr(e.enemy, e.enemy[i])
                            var enemy = []
                            for (let i in other.enemy) {
                                if (other.enemy[i][0] == e) {

                                } else {
                                    enemy.push(other.enemy[i])
                                }
                            }
                            other.enemy = enemy
                        }
                        //时间--
                        if (e.enemy[i]) {
                            if (e.enemy[i][2] <= 0) {//如果时间到了
                                var other = world.querySelectorAll('player').filter(a => a == e.enemy[i][0])[0]
                                var otherScore = 0;
                                var myScore = e.enemy[i][1]
                                for (let i of other.enemy) {
                                    if (i[0] == e) {
                                        otherScore = i[1]//拿到敌人对你的分数
                                    }
                                }
                                if (otherScore > myScore) {
                                    e.player.directMessage('你和' + other.player.name + '的战争结束！！！你落败了！！！')
                                    other.player.directMessage('你和' + e.player.name + '的战争结束！！！你赢了！！！')
                                    world.say(e.player.name + '和' + other.player.name + '的战争结束了,结果是' + other.player.name + '赢了！！！比分分别是' + myScore + ' : ' + otherScore)
                                    warEnd(other, e)
                                } else if (myScore > otherScore) {
                                    other.player.directMessage('你和' + e.player.name + '的战争结束！！！你落败了！！！')
                                    e.player.directMessage('你和' + other.player.name + '的战争结束！！！你赢了！！！')
                                    world.say(other.player.name + '和' + entity.player.name + '的战争结束了,结果是' + e.player.name + '赢了！！！比分分别是' + otherScore + ' : ' + myScore)
                                    warEnd(e, other)
                                } else {
                                    world.say(e.player.name + '和' + other.player.name + '的战争结束了,结果是平局！！！比分分别是' + myScore + ' : ' + otherScore)
                                }
                                e.enemy = deleteArrayStr(e.enemy, e.enemy[i])
                                var enemy = []
                                for (let i in other.enemy) {
                                    if (other.enemy[i][0] == e) {

                                    } else {
                                        enemy.push(other.enemy[i])
                                    }
                                }
                                other.enemy = enemy
                            }
                        }
                    }
                    e.chatTime -= 1
                    e.xuanzhanTime -= 1
                    if (e.kaigua == 1) {
                        e.money = Infinity;
                        e.jd.cdTime = 0;
                    }
                    if (i % 30 == 0) {
                        e.money += (e.getCityNum() * 1000 + 1000) * techChuLi(e, 'money', 1, '资源')
                        e.money = Math.floor(e.money)
                        e.player.directMessage('你获得了' + Math.floor((e.getCityNum() * 1000 + 1000) * techChuLi(e, 'money', 1, '资源')) + '元')
                        if (Math.random < 0.5) {
                            savePlayer(e)
                        }
                    }
                }
            }
            await sleep(world.tickJg)
            if (world.querySelectorAll('.黑暗军团小兵').length < 100) {
                for (let i = 0; i < 100 - world.querySelectorAll('.黑暗军团小兵').length; i++) {
                    createHAJTXB()
                }
            }
            if (i % 2 == 0) {
                for (let e of world.querySelectorAll('.士兵')) {
                    e.interactHint = e.own.player.name + ' 的 ' + e.pifu
                    e.meshColor = e.own.color
                    e.mesh = `mesh/${pifuChuLi(e.pifu, 'mesh', e.name)}.vb`
                    if (e.own.kaigua == 1) {
                        e.cdTime = 0;
                    }
                    /*
                                        if (i % 2 == 0) {
                                            if (e.food <= 0) {
                                                if (e.own.foodZiDong == 1) {
                                                    if (e.own.money >= 50) {
                                                        e.own.money -= 50
                                                        e.food++
                                                    }
                                                }
                                            }
                                            if (e.food > 0) {
                                                if (!e.hasTag('黑暗军团小兵') && e.name != '无人机') {
                                                    e.food--
                                                }
                                                if (e.hurtTime <= 0 && e.hp > 0) {
                                                    e.hp += 2
                                                    if (e.hp > e.maxHp) {
                                                        e.hp = e.maxHp
                                                    }
                                                } else {
                                                    e.hurtTime--
                                                }
                                            } else {
                                                if (e.ziyuan[2] > 0) {
                                                    e.ziyuan[2]--
                                                    e.food++
                                                } else {
                                                    e.hurt(4)
                                                    e.food = 0
                                                }
                                            }
                                        }
                                        if (i % 3 == 0) {
                                            if (e.name == '航母' && !e.hasTag('黑暗军团小兵')) {
                                                for (let x of world.querySelectorAll('.士兵')) {
                                                    if (x.own == e.own && soldiers[x.name].lx1 == '空' && pmDist(x.position, e.position) <= 3) {
                                                        x.energy += 5
                                                        if (x.energy > soldiers[x.name].energy + pifuChuLi(x.pifu, 'energy', 0)) {
                                                            x.energy = soldiers[x.name].energy + pifuChuLi(x.pifu, 'energy', 0)
                                                        }
                                                        x.food += 10
                                                        if (x.food > 100) {
                                                            x.food = 100
                                                        }
                                                        x.hp += 5
                                                        if (x.hp > x.maxHp) {
                                                            x.hp = x.maxHp
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if (i % 3 == 0) {
                                            if (ziYuanYunShu.includes(e.name) && !e.hasTag('黑暗军团小兵')) {//
                                                world.querySelectorAll('.士兵').forEach((b) => {
                                                    if (b.position.distance(e.position) <= 5 && soldiers[b.name].lx2 != '步兵'
                                                        && b.own == e.own && soldiers[b.name].lx2 != '空军') {
                                                        if (b.energy < soldiers[b.name].energy + pifuChuLi(b.pifu, 'energy', 0) && e.ziyuan[1] > 0) {
                                                            b.energy += 6
                                                            e.ziyuan[1] -= 6
                                                        }
                                                        if (b.food < 100 && e.ziyuan[2] > 0) {
                                                            b.food += 6
                                                            e.ziyuan[2] -= 6
                                                        }
                                                        if (b.name == '工程车' && e.ziyuan[0] > 0) {
                                                            if (b.lingJian < 50) {
                                                                b.lingJian += 6
                                                                e.ziyuan[0] -= 6
                                                            }
                                                        }
                                                    }
                                                })
                                            }
                                        }
                                        if (i % 4 == 0) {
                                            if (soldiers[e.name].lx2 == '步兵' && e.name != '自爆兵' && !e.hasTag('黑暗军团小兵')) {
                                                e.hp += 4;
                                                if (e.hp > e.maxHp) {
                                                    e.hp = e.maxHp
                                                }
                                                if (dx[getPosVoxel(e.position.x, e.position.z)].lx == '资源') {
                                                    for (let x of world.querySelectorAll('.士兵').filter(x => pmDist(e.position, x.position) <= 3 && x.own == e.own)) {//又是士兵又是他的的兵
                                                        if (dx[getPosVoxel(e.position.x, e.position.z)].name == '石油挖掘处') {
                                                            x.energy += 8
                                                            if (x.energy > soldiers[x.name].energy + pifuChuLi(x.pifu, 'energy', 0)) {
                                                                x.energy = soldiers[x.name].energy + pifuChuLi(x.pifu, 'energy', 0)
                                                            }
                                                            if (Math.random() < 0.02) {
                                                                voxels.setVoxel(e.position.x, 0, e.position.z, dx[getPosVoxel(e.position.x, e.position.z)].forward)
                                                            }
                                                        }
                                                        if (dx[getPosVoxel(e.position.x, e.position.z)].name == '农田') {
                                                            x.food += 8
                                                            if (x.food > 100) {
                                                                x.food = 100
                                                            }
                                                            if (Math.random() < 0.02) {
                                                                voxels.setVoxel(e.position.x, 0, e.position.z, dx[getPosVoxel(e.position.x, e.position.z)].forward)
                                                            }
                                                        }
                                                        if (dx[getPosVoxel(e.position.x, e.position.z)].name == '矿物挖掘处' && x.name == '工程车') {
                                                            x.lingJian += 8
                                                            if (x.lingJian > 100) {
                                                                x.lingJian = 100
                                                            }
                                                            if (Math.random() < 0.02) {
                                                                voxels.setVoxel(e.position.x, 0, e.position.z, dx[getPosVoxel(e.position.x, e.position.z)].forward)
                                                            }
                                                        }
                                                        if (ziYuanYunShu.includes(x.name)) {
                                                            var num = dx[getPosVoxel(e.position.x, e.position.z)].num
                                                            x.ziyuan[num] += 10
                                                            if (x.ziyuan[num] > soldiers[x.name].maxZiYuan[num]) {
                                                                x.ziyuan[num] = soldiers[x.name].maxZiYuan[num]
                                                            } else {
                                                                if (Math.random() < 0.01) {
                                                                    voxels.setVoxel(e.position.x, 0, e.position.z, dx[getPosVoxel(e.position.x, e.position.z)].forward)
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if (e.name == '工程车') {
                                            if (i % 4 == 0) {
                                                world.querySelectorAll('.士兵').forEach((x) => {
                                                    if (x.own == e.own && new Box3Vector3(x.position.x, 0, x.position.z).distance(new Box3Vector3(e.position.x, 0, e.position.z)) < 5 && soldiers[x.name].lx2 != '步兵' && soldiers[x.name].lx1 == '陆' && e.lingJian > 0) {
                                                        x.hp += 10
                                                        e.lingJian--
                                                        if (x.hp > x.maxHp) {
                                                            x.hp = x.maxHp
                                                        }
                                                    }
                                                })
                                            }
                                        }
                    */
                    if (!e.own || e.own == undefined) {
                        e.destroy()
                    }
                    e.state['移动'] -= 2
                    e.state['攻击'] -= 2
                    e.hurtTime -= 2
                    if (e.state['移动'] < 0) {
                        e.state['移动'] = 0
                    }
                    if (e.state['攻击'] < 0) {
                        e.state['攻击'] = 0
                    }
                }
            }
        } catch (e) {


        }
    }
})();
















function warEnd(winner = new Box3Entity, loser = new Box3Entity, moneyXiShu = 2, bdXiShu = 0.3, type = '') {//结算战争系统
    if (type != 'leave') {
        winner.coin += 500;
        winner.star += 1;
        winner.tasks[0][0] += 1//胜场+1
        loser.tasks[0][2] += 1//输场+1
    }
    if (loser.money > 10000) {
        winner.money += (loser.money - 10000) / moneyXiShu
        winner.player.directMessage('你获得了敌人赔款的' + (loser.money - 10000) / moneyXiShu + '个资金')
        loser.player.directMessage('你失去了' + (loser.money - 10000) / moneyXiShu + '个资金（赔款给敌人）')
        loser.money -= (loser.money - 10000) / moneyXiShu
        winner.money = Math.floor(winner.money)
        loser.money = Math.floor(loser.money)
    }
    var lostMaxBD = loser.soldiers().length * bdXiShu
    lostMaxBD = Math.ceil(lostMaxBD)
    for (let i = 0; i < lostMaxBD; i++) {
        var theSoldier = ''
        try {
            theSoldier = loser.soldiers()[Math.floor(Math.random() * (loser.soldiers().length - 1))]
            loser.player.directMessage('你的' + theSoldier.pifu + '赔给了敌人')
            theSoldier.own = winner
            theSoldier.removeTag(loser.player.name)
            theSoldier.addTag(winner.player.name)
            winner.player.directMessage('敌人赔给你了' + theSoldier.pifu)
        } catch (e) {
            console.log(e)
        }
    }


    if (winner.tasks[2].length > 0) {//有在做的任务
        if (tasks[winner.tasks[2][0]]) {//是不是存在这个任务
            if (tasks[winner.tasks[2][0]]) {
                if (tasks[winner.tasks[2][0]].needWin) {
                    try {
                        var index = 0
                        winner.tasks[2][1][index] += 1
                        if (winner.tasks[2][1][index] > tasks[winner.tasks[2][0]].score[index]) {//分数超过则回去
                            winner.tasks[2][1][index] = tasks[winner.tasks[2][0]].score[index]
                        } else {
                            winner.player.directMessage(`你的《${winner.tasks[2][0]}》任务进度：` + winner.tasks[2][1] + '，最终进度：' + tasks[winner.tasks[2][0]].score)
                        }
                        var num = 0;//完成度
                        for (let i in tasks[winner.tasks[2][0]].score) {
                            if (winner.tasks[2][1][i] >= tasks[winner.tasks[2][0]].score[i]) {
                                num++
                            }
                        }
                        if (num >= tasks[winner.tasks[2][0]].score.length) {
                            winner.player.directMessage(`你的《${winner.tasks[2][0]}》任务完成了！！！获得了` + tasks[winner.tasks[2][0]].coins + '个军团币！')
                            winner.coin += tasks[winner.tasks[2][0]].coins
                            winner.star++
                            if (winner.tasks[2][0] == '实战！！！') {
                                winner.titles.push('高级指挥官')
                            }
                            winner.tasks[1].push(winner.tasks[2][0])
                            winner.tasks[2] = []
                        }

                    } catch (e) {
                        console.log('tasks Error:' + e)
                    }
                }
            }
        }

    }
}





function getSoldier(pos = new Box3Vector3) {
    var entities1 = [];
    var entities = world.searchBox({
        lo: [pos.x - 0.4, 0, pos.z - 0.4], //包围盒下边界
        hi: [pos.x + 0.4, 64, pos.z + 0.4], //包围盒上边界
    });
    for (let i in entities) {
        if (entities[i].hasTag('士兵')) {
            entities1.push(entities[i]);
        };
    };
    if (entities1.length > 0) {
        return entities1[0];
    } else {
        return '';
    };
};













world.onPress(async ({ entity, button, raycast: { hitEntity, hitPosition, hitVoxel, voxelIndex } }) => {//终极核心
    if (button != 'action0' && button != 'action1') return;
    if (entity.team == '旁观者') return entity.player.directMessage('你是旁观者！不能打开面板！')
    if (entity.jd == '') return;
    entity.clicked = 1
    if (world.yc >= world.testHigh * 1.2 || world.nowTime <= 2) {
        return entity.player.directMessage('卡顿时不能进行任何操作！！！')
    }
    if (entity.locked == 1) {
        return;
    };
    (async function () {
        entity.locked = 1;
        await sleep(500);
        entity.locked = 0;
    })();
    if (button == Box3ButtonType.ACTION1) {
        entity.locked = 1
        var options = ['回基地', '部队查看/编辑快捷工具', '开/关 粮食不足自动补足', '功能/设置']
        if (entity.isCommander == true) {
            options.push('总指挥官操作')
        }
        if (admin.includes(entity.player.boxId) || admin1.includes(entity.player.boxId)) {
            options.push('管理员特权')
        }
        var result = await entity.player.dialog({
            type: Box3DialogType.SELECT,
            title: "请选择操作",
            content: `
            你有${entity.money}元
            请选择
            `,
            options: options,   // 将提供玩家选择的选项放入数组里。
        });
        entity.locked = 0
        // 如果玩家点击了屏幕其他区域，取消了对话框。
        if (!result || result === null) {
            return;
        }

        // 判断玩家选了什么选项。
        switch (result.value) {
            case '总指挥官操作':
                var result = await entity.player.dialog({
                    type: Box3DialogType.SELECT,
                    title: '请选择总指挥官操作',
                    content: `请选择`,
                    options: ['指挥官操作说明', '投放补给空投']
                });
                if (!result || result == null) {
                    return;
                }
                switch (result.index) {
                    case 0:
                        entity.player.dialog({
                            type: Box3DialogType.TEXT,
                            title: '指挥官操作说明',
                            content: `
                            队伍内的总指挥官可以通过坐标位置来进行一些操作
                            在操作点中，在半径50格内必须要有至少一个完全占领的据点，且指挥官冷却时间<=0

                            接下来是关于每个操作的说明：
                            1.投放补给空投：
                                投放补给空投，可以对补给点的15格半径内的所有我方部队加20格血，
                                然后在15秒内每秒增加4格血量，攻击力*1.3，防御力*1.3，并且拥有了防毒面具可以无视毒气弹伤害
                                指挥官操作冷却时间+45秒


                            2.区域火炮轰炸
                                对轰炸点20格半径内的的所有敌军造成自行火炮*2的伤害（也就是说对某些单位无效，懂得都懂）
                                指挥官操作冷却时间+1分钟

                            3.高射炮阵地
                                对选择点20格半径内的所有敌军空军部队，造成持续10秒的每秒3～6格血的伤害
                                指挥官操作冷却时间+1分钟

                            4.海军克星
                                对选择点20格半径内的所有敌军海军部队，造成持续10秒的2～5格血的伤害
                                指挥官操作冷却时间+1分钟

                            5.撤退和反击
                                对选择点10格半径内的所有hp<50己方部队：
                                hp=50，移动力*1.5，防御力*1.3，攻击力*1.3
                                翻盘和撤退都很好用～
                                指挥官操作冷却时间+45秒

                            6.毒气弹
                                对选择点25格半径内的所有部队：
                                陆军每秒受到8点伤害，无视装甲/地形防御，持续10秒
                                陆军防御力*0.5，持续一分钟

                                一局只能使用两次
                                指挥官操作冷却时间+2分钟，消耗5000分

                            7.导弹
                                选择点附近30格半径内的所有敌人受到40点伤害，陆军额外受到50点伤害
                                一局只能使用三次
                                指挥官操作冷却时间+2分钟，消耗5000分

                            `
                        })
                        break;
                    default:
                }
                break;
            case '对...宣战':
                if (entity.xuanzhanTime > 0) {
                    return entity.player.directMessage('宣战冷却中，还剩' + entity.xuanzhanTime + '秒')
                }
                var options = []
                world.querySelectorAll('player').forEach((e) => {
                    if (e && e.jd) {
                        options.push(e.player.name)
                    }
                })
                var result = await entity.player.dialog({
                    type: Box3DialogType.SELECT,
                    title: "请选择宣战目标",
                    content: `
                    请选择（还没做完）
                    宣战规则：
                    5分钟到了打别人的损失谁大谁赢，相等就平局，在5分钟内如果让敌人损失大于等于30万元则你赢，如果求和平局，如果投降你输，离开游戏离开者输
                    宣战条件：
                    被宣战方基地必须要在宣战方基地150格范围内，双方都得有至少20000元和10个兵
                    如果你点击的那个人已经和你在交战，你点进去可以进行投降或者求和
                    `,
                    options: options,   // 将提供玩家选择的选项放入数组里。
                });

                // 如果玩家点击了屏幕其他区域，取消了对话框。
                if (!result || result === null) {
                    return;
                }
                entity.xuanzhanTime = 10;
                var other = world.querySelectorAll('player').filter(e => e.player.name == result.value)[0]
                var azaz = 0//随便起的
                for (let i in entity.enemy) {
                    if (entity.enemy[i][0] == other) {
                        azaz = 1
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择操作",
                            content: `这个人已经和你交战中，请你选择对他的操作`,
                            options: ['投降', '求和', '啥也不干'],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result.index) {
                            case 0:
                                for (let i in entity.enemy) {
                                    if (entity.enemy[i][0] == other) {
                                        if (entity.enemy[i][2] > 180) {
                                            return entity.player.directMessage('交战时间小于180秒，不可以投降！')
                                        }
                                    }
                                }
                                entity.player.directMessage('你和' + other.player.name + '的战争结束！！！你落败了！！！')
                                other.player.directMessage('你和' + entity.player.name + '的战争结束！！！你赢了！！！')
                                world.say(entity.player.name + '和' + other.player.name + '的战争结束了,结果是' + other.player.name + '赢了！！！(一方投降)')
                                warEnd(other, entity)
                                for (let i in entity.enemy) {
                                    if (entity.enemy[i][0] == other) {
                                        entity.enemy = deleteArrayStr(entity.enemy, entity.enemy[i])

                                    }
                                }
                                var enemy = []
                                for (let i in other.enemy) {
                                    if (other.enemy[i][0] == entity) {

                                    } else {
                                        enemy.push(other.enemy[i])
                                    }
                                }
                                other.enemy = enemy
                                break;
                            case 1:
                                (async function () {
                                    entity.locked = true;
                                    await sleep(5000);
                                    entity.locked = false;
                                })();

                                var result = await other.player.dialog({
                                    type: Box3DialogType.SELECT,
                                    title: "有人给你发出了求和贴",
                                    content: `${entity.player.name}给你发出了求和贴`,
                                    options: ['同意和平', '不同意'],   // 将提供玩家选择的选项放入数组里。
                                });

                                // 如果玩家点击了屏幕其他区域，取消了对话框。
                                if (!result || result === null) {
                                    return;
                                }
                                // 判断玩家选了什么选项。
                                switch (result.index) {
                                    case 0:
                                        world.say(entity.player.name + '和' + other.player.name + '的战争结束了,结果是平局！！！')
                                        entity.tasks[0][1] += 1//平局+1
                                        other.tasks[0][1] += 1//平局+1
                                        entity.enemy = deleteArrayStr(entity.enemy, entity.enemy[i])
                                        for (let i in entity.enemy) {
                                            if (entity.enemy[i][0] == other) {
                                                entity.enemy = deleteArrayStr(entity.enemy, entity.enemy[i])

                                            }
                                        }
                                        var enemy = []
                                        for (let i in other.enemy) {
                                            if (other.enemy[i][0] == entity) {

                                            } else {
                                                enemy.push(other.enemy[i])
                                            }
                                        }
                                        other.enemy = enemy
                                        break;
                                    default:
                                    // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                                }
                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }

                    }
                }
                if (azaz == 1) return;
                if (!other || other.destroyed) {
                    return entity.player.directMessage('敌人不存在')
                }
                if (other == entity) {
                    return entity.player.directMessage('宣战自己?没搞错吧。。。')
                }
                if (!admin.includes(entity.player.boxId)) {
                    if (pmDist(other.jd.position, entity.jd.position) > 150) {
                        return entity.player.directMessage('宣战目标基地必须在你的基地150格范围内！')
                    }
                    if (entity.money < 20000) {
                        return entity.player.directMessage('你必须至少要有20000元才能进行战争！！！')
                    }
                    if (other.money < 20000) {
                        return entity.player.directMessage('对方必须至少要有20000元才能进行战争！！！')
                    }
                    if (entity.soldiers().length < 10) {
                        return entity.player.directMessage('你必须至少要有10个单位才能进行战争！！！')
                    }
                    if (other.soldiers().length < 10) {
                        return entity.player.directMessage('对方必须至少要有10个单位才能进行战争！！！')
                    }
                    entity.player.directMessage('申请已经发送～')
                    var result1 = await other.player.dialog({
                        type: Box3DialogType.SELECT,
                        title: "有敌人向你宣战",
                        content: `${entity.player.name}向你宣战`,
                        options: ['接受', '不接受'],   // 将提供玩家选择的选项放入数组里。
                    });

                    // 如果玩家点击了屏幕其他区域，取消了对话框。
                    if (!result1 || result1 === null) {
                        return;
                    }
                    if (result1.index == 1) {
                        return entity.player.directMessage(other.player.name + '拒绝战争')
                    }
                }

                world.say(entity.player.name + '和' + other.player.name + '开始了战争！！')
                other.enemy.push([entity, 0, 300])
                entity.enemy.push([other, 0, 300])
                break;
            case '功能/设置':
                var result = await entity.player.dialog({
                    type: Box3DialogType.SELECT,
                    title: "功能/设置",
                    content: `
                    请选择操作
                    个人信息：
                    名字:${entity.player.name},boxId:${entity.player.boxId},userKey:${entity.player.userKey},
                    军团币：${entity.coin},军衔星:${entity.star},科技碎片:${entity.technology['碎片']}（综合，陆，海，空）
                    `,
                    options: ['保存存档', '切换称号', '礼包码', '皮肤商店',
                        '使用道具', '英雄商店/升级/调配（未开放）', '科技学院',
                        '任务', '军团币商店', '银行', '活动', '帮助'],   // 将提供玩家选择的选项放入数组里。
                });

                // 如果玩家点击了屏幕其他区域，取消了对话框。
                if (!result || result === null) {
                    return;
                }

                // 判断玩家选了什么选项。
                switch (result.value) {
                    case '保存存档':
                        savePlayer(entity)
                        entity.player.directMessage('保存成功')
                        break;
                    case '使用道具':
                        var options = []
                        var names = []
                        for (let i in entity.bag) {
                            if (entity.bag[i] > 0) {
                                options.push(i + '拥有' + entity.bag[i] + '个')
                                names.push(i)
                            }
                        }
                        if (options.length <= 0) {
                            return entity.player.directMessage('你没有任何道具！！！')
                        }
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: '请选择你要使用的道具',
                            content: '请选择～',
                            options: options,
                        })
                        if (!result || result == null) {
                            return;
                        }
                        var name = names[result.index]
                        if (entity.bag[name] <= 0) {
                            return entity.player.directMessage('你没有此道具')
                        }
                        entity.bag[name] -= 1;
                        switch (name) {
                            case '随机迁城':
                                var end = 0;
                                for (let i = 0; i < 1000; i++) {
                                    if (end == 1) continue;
                                    var pos = spawnPos.concat(spawnPos1)[Math.floor(Math.random() * spawnPos.concat(spawnPos1).length)]
                                    if (pmDist(new Box3Vector3(pos[0], 0, pos[2]), entity.jd.position) < 50) {
                                        entity.jd.position.x = pos[0] + 0.5
                                        entity.jd.position.z = pos[2] + 0.5
                                        entity.position.x = entity.jd.position.x
                                        entity.position.z = entity.jd.position.z
                                        end = 1;
                                    }
                                }
                                entity.player.directMessage('已使用随机迁城*1')
                                break;
                            default:
                                entity.bag[name] += 1;
                                entity.player.directMessage('此道具不可以在通用中使用，有特殊用途')
                        }
                        break;
                    case '银行':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择兑换选项",
                            content: `请选择`,
                            options: ['军团币兑换游戏币'/*,`游戏币兑换军团币(限次数)`*/],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result.value) {
                            case '军团币兑换游戏币':
                                var result = await entity.player.dialog({
                                    type: Box3DialogType.INPUT,
                                    title: "军团币兑换游戏币",
                                    content: `你有${entity.coin}个军团币，1个军团币可以兑换50个游戏币，请输入你需要兑换游戏币所使用的军团币的数量`,
                                    confirmText: '确认',
                                });
                                if (!result || result == null) {
                                    return;
                                }
                                result = parseInt(result)
                                if (!Number.isInteger(result)) return entity.player.directMessage('请输入整数');
                                if (result <= 0) return entity.player.directMessage('请输入正数');
                                if (entity.coin < result) {
                                    return entity.player.directMessage('军团币不足！')
                                }
                                entity.coin -= result
                                entity.money += result * 50
                                entity.player.directMessage('兑换成功')
                                break;
                            case `游戏币兑换军团币(限次数)`:
                                var result = await entity.player.dialog({
                                    type: Box3DialogType.INPUT,
                                    title: "游戏币兑换军团币(限次数)",
                                    content: `你有${entity.money}个游戏币，60个游戏币可以兑换1个军团币，请输入你要兑换军团币的数量（剩余兑换次数：${entity.presents['兑币剩余次数']}）`,
                                    confirmText: '确认',
                                });
                                if (!result || result == null) {
                                    return;
                                }
                                result = parseInt(result)
                                if (!Number.isInteger(result)) return entity.player.directMessage('请输入整数');
                                if (result <= 0) return entity.player.directMessage('请输入正数');
                                if (entity.presents['兑币剩余次数'] < result) {
                                    return entity.player.directMessage('兑换剩余次数不足啦~')
                                }
                                if (entity.money < result * 60) {
                                    return entity.player.directMessage('游戏币不足！')
                                }
                                entity.presents['兑币剩余次数'] -= result
                                entity.coin += result
                                entity.money -= result * 60
                                entity.player.directMessage('兑换成功')
                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }

                        break;
                    case '军团币商店':
                        var shopCoins = {//商品军团币单价
                            '综合科技碎片': 300,
                            '陆军科技碎片': 300,
                            '海军科技碎片': 300,
                            '空军科技碎片': 300,
                            '领土迁城': 500,
                            '随机迁城': 500,
                            '定点迁城': 800,
                        };
                        var shopList = []
                        var names = []
                        for (let i in shopCoins) {
                            shopList.push(i + '  单价 ' + shopCoins[i] + ' 元')
                            names.push(i)
                        }
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: '请选择你要购买的商品',
                            content: `请选择(你有${entity.coin}个军团币)`,
                            options: shopList,
                        });
                        if (!result || result == null) {
                            return;
                        };
                        var name = names[result.index]
                        var sl = await entity.player.dialog({
                            type: Box3DialogType.INPUT,
                            title: '请输入数量',
                            content: '请输入一个大于0的整数',
                            confirmText: '确定',
                        })
                        if (!sl || sl == null) {
                            return;
                        }
                        sl = parseInt(sl)
                        if (!Number.isInteger(sl)) {
                            return entity.player.directMessage('你的输入不是整数！！！')
                        }
                        if (sl <= 0) {
                            return entity.player.directMessage('数量是要大于0的整数！！！')
                        }
                        if (entity.coin < shopCoins[name] * sl) {
                            return entity.player.directMessage('你钱不足哦')
                        }
                        entity.coin -= shopCoins[name] * sl
                        switch (name) {
                            case '综合科技碎片':
                                entity.technology['碎片'][0] += sl
                                break;
                            case '陆军科技碎片':
                                entity.technology['碎片'][1] += sl
                                break;
                            case '海军科技碎片':
                                entity.technology['碎片'][2] += sl
                                break;
                            case '空军科技碎片':
                                entity.technology['碎片'][3] += sl
                                break;
                            case '随机迁城':
                                entity.bag['随机迁城'] += sl
                                break;
                            case '领土迁城':
                                entity.bag['领土迁城'] += sl
                                reak;
                            case '定点迁城':
                                entity.bag['定点迁城'] += sl
                                break;

                            default:
                        }
                        entity.player.directMessage(`购买${sl}个【${name}】成功！感谢光临！`)
                        break;
                    case '切换称号':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择切换的称号",
                            content: `请选择(第一个是你使用的称号)`,
                            options: entity.titles,   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        entity.player.directMessage('切换成功！！')
                        entity.titles = deleteArrayStr(entity.titles, result.value)
                        entity.titles = [result.value].concat(entity.titles)
                        break;
                    case '科技学院':
                        //                        if (!ncPlayer.includes(entity.player.boxId)) return entity.player.directMessage('科技还在内测中，您暂无内测资格')
                        if (entity.star < 9) {
                            return entity.player.directMessage('至少要有9个军衔星才能启动科技学院')
                        }
                        for (let i = 0; i < 100; i++) {
                            var options = []
                            for (let i in technology) {
                                options.push(i)//选项加上科技类别
                            }
                            var result = await entity.player.dialog({
                                type: Box3DialogType.SELECT,
                                title: '科技学院/研究所',
                                content: `
                            请选择你要研究的科技类型
                            综合科技：所有全局部队基本上都可以用（除非一些特殊类别），需要综合科技碎片和军团币作为资金
                            兵种科技：仅限一个兵种内的一些兵可以用，需要对应兵种科技碎片和军团币作为资金
                            `,
                                options: options,
                            })
                            if (!result || result == null) {
                                return;
                            }
                            var lx = result.value
                            var options = []
                            var chips = []
                            var coins = []
                            var names = []
                            for (let i in technology[lx]) {
                                options.push('【' + i + '】需要：' + technology[lx][i].needChip + '个碎片，' + technology[lx][i].coin + '个军团币')
                                chips.push(technology[lx][i].needChip)
                                coins.push(technology[lx][i].coin)
                                names.push(i)
                            }
                            for (let i = 0; i < 100; i++) {
                                var result = await entity.player.dialog({
                                    type: Box3DialogType.SELECT,
                                    title: `选择${lx}类型的科技`,
                                    content: `请选择哦～你现在拥有军团币${entity.coin},拥有碎片${entity.technology['碎片']}（分别综合陆海空的碎片）`,
                                    options: options,
                                })
                                if (!result || result == null) {
                                    break;
                                }
                                var name = names[result.index]
                                var chip = chips[result.index]
                                var coin = coins[result.index]
                                var result = await entity.player.dialog({
                                    type: Box3DialogType.SELECT,
                                    title: `确认研究`,
                                    content: `
                                确认研究【${name}】吗，需要${chip}个对应碎片，${coin}个军团币
                                ta的作用：${technology[lx][name].text}
                                前置科技：${technology[lx][name].need}
                                你有：${entity.coin}个军团币，${entity.technology['碎片']}个碎片（分别综合，陆，海，空）
                                `,
                                    options: ['确认研究', '我再想想']
                                })
                                if (!result || result == null) {
                                    continue;
                                }
                                if (result.index == 1) continue;
                                if (!entity.technology[lx].includes(technology[lx][name].need) && technology[lx][name].need != '') {
                                    entity.player.directMessage('你没有研究他的前置科技【' + technology[lx][name].need + '】请先研究他的前置科技！！！')
                                    continue;
                                }
                                if (entity.technology[lx].includes(name)) {
                                    entity.player.directMessage('你已经研究过了哦～')
                                    continue;
                                }
                                if (entity.coin < coin) {
                                    entity.player.directMessage('你的军团币不足');
                                    continue;
                                }
                                var num = 0
                                switch (lx) {
                                    case '综合':
                                        num = 0;
                                        break;
                                    case '陆':
                                        num = 1;
                                        break;
                                    case '海':
                                        num = 2;
                                        break;
                                    case '空':
                                        num = 3;
                                        break;
                                    default:
                                }
                                if (entity.technology['碎片'][num] < chip) {
                                    entity.player.directMessage('碎片不足')
                                    continue;
                                }
                                entity.technology[lx].push(name)
                                entity.coin -= coin
                                entity.technology['碎片'][num] -= chip
                                entity.player.directMessage(`科技【${name}】研究成功！！！`)
                            }
                        }
                        break;
                    case '任务':
                        for (let i = 0; i < 100; i++) {
                            var options = []
                            var names = []
                            for (let i in tasks) {
                                if (entity.tasks[2][0] == i) {
                                    options.push(i + '  正在完成')
                                } else if (entity.tasks[1].includes(i)) {
                                    options.push(i + '  已完成')
                                } else {
                                    options.push(i + '  未完成')
                                }
                                names.push(i)
                            }
                            var result = await entity.player.dialog({
                                type: Box3DialogType.SELECT,
                                title: "请选择任务",
                                content: `请选择`,
                                options: options,   // 将提供玩家选择的选项放入数组里。
                            });

                            // 如果玩家点击了屏幕其他区域，取消了对话框。
                            if (!result || result === null) {
                                return;
                            }
                            var name = names[result.index]
                            var options = []
                            if (entity.doingTask() == name) {
                                options = ['接受任务', '不接受']
                            }
                            if (entity.tasks[2].length > 0 && names[result.index] == entity.tasks[2][0]) {
                                options = ['刷新/重做任务（当前任务清零）']
                            }
                            var result1 = await entity.player.dialog({
                                type: Box3DialogType.SELECT,
                                title: "任务",
                                content: `
                            ${tasks[name].text}
                            `,
                                options: options,   // 将提供玩家选择的选项放入数组里。
                            });
                            // 如果玩家点击了屏幕其他区域，取消了对话框。
                            if (!result1 || result1 === null || options.length <= 0) {
                                continue;
                            }
                            if (result1.value == '不接受') return;
                            var array = []
                            for (let i = 0; i < tasks[name].score.length; i++) {
                                array.push(0)
                            }
                            entity.tasks[2] = [name, array]
                            entity.player.directMessage('接受任务成功！')
                        }
                        break;
                    case '礼包码':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.INPUT,
                            title: '礼包码',
                            content: '请输入礼包码',
                            confirmText: '确定',
                        })
                        if (!result || result == null) {
                            return;
                        }
                        if (entity.presents['礼包码'].includes(result)) {
                            return entity.player.directMessage('你的礼包码已经用过了！')
                        }
                        switch (result) {
                            default:
                                entity.player.directMessage('礼包码不存在!或已经被开发者清除！')
                        }
                        savePlayer(entity)
                        break;
                    case '皮肤商店':
                        var options = []
                        var names = []
                        var moneys = []
                        var texts = []
                        for (let i in pifu) {
                            if (entity.items.includes(i)) {
                                options.push(i + ' ' + pifu[i].coin + '元(已拥有)')
                            } else {
                                options.push(i + ' ' + pifu[i].coin + '元(未拥有)')
                            }
                            names.push(i)
                            moneys.push(pifu[i].coin)
                            texts.push(pifu[i].text)
                        }
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择皮肤",
                            content: `
                            请选择 ，你有${entity.coin}个军团币
                            `,
                            options: options,   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "是否购买" + result.value,
                            content: `简介：${texts[result.index]}`,
                            options: ['购买！', '不买了'],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result1 || result1 === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result1.index) {
                            case 0:
                                break;
                            case 1:
                                return;
                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }
                        var money = moneys[result.index]
                        var name = names[result.index]
                        if (entity.items.includes(name)) {
                            return entity.player.directMessage('你已经拥有了这个皮肤')
                        }
                        if (entity.coin >= money) {
                            entity.coin -= money
                            entity.items.push(name)
                            entity.player.directMessage(name + ' 入手')
                        } else {
                            entity.player.directMessage('军团币不足')
                        }


                        break;
                    case '活动':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择活动",
                            content: `请选择`,
                            options: ['签到活动', '邀请新人得好礼', '找出这个地图上好的地形区'],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result.value) {
                            case '找出这个地图上好的地形区':
                                entity.player.link('https://shequ.codemao.cn/community/459695')
                                break;
                            case '签到活动':
                                entity.player.dialog({
                                    type: Box3DialogType.TEXT,
                                    title: "签到活动",
                                    content: `每天加入游戏会自动签到~每天签到都可以领取100个军团币，签到3天送突击步兵和100军团币，7天送炮兵和200军团币，
                                    14天送虎式重型坦克和400军团币，21天送T-34和800军团币，30天送B-17空中堡垒和1000军团币`,
                                });

                                break;
                            case '邀请新人得好礼':
                                var result = await entity.player.dialog({
                                    type: Box3DialogType.SELECT,
                                    title: "邀请新人得好礼",
                                    content: `这个活动每邀请一个新人通过你的邀请链接第一次进入游戏，你可以获得1000军团币,新人也可以获得200军团币~最多邀请10人哦~邀请满10人额外获得2000军团币～`,
                                    options: ['生成邀请链接并且去邀请新人~', '查看目前邀请情况'],   // 将提供玩家选择的选项放入数组里。
                                });

                                // 如果玩家点击了屏幕其他区域，取消了对话框。
                                if (!result || result === null) {
                                    return;
                                }

                                // 判断玩家选了什么选项。
                                switch (result.index) {
                                    case 0:
                                        entity.player.dialog({
                                            type: Box3DialogType.TEXT,
                                            title: "邀请新人链接",
                                            content: world.url + '/?invite=' + entity.player.userKey,
                                        });


                                        break;
                                    case 1:
                                        entity.player.dialog({
                                            type: Box3DialogType.TEXT,
                                            title: "查看目前邀请情况",
                                            content: `
                                            目前有${entity.presents['邀请新人活动'].length}个人进入了你的链接，
                                            他们是 ${entity.presents['邀请新人活动']}
                                            `,
                                        });

                                        break;
                                    default:
                                    // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                                }

                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }
                        break;
                    case '帮助':
                        getHelp(entity)
                        break;
                    default:
                    // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                }
                break;
            case '开/关 粮食不足自动补足':
                if (entity.foodZiDong == 0) {
                    entity.foodZiDong = 1
                    entity.player.directMessage('开启自动补足（比手动补足贵2倍）（1份粮食50元）')
                } else {
                    entity.foodZiDong = 0
                    entity.player.directMessage('关闭自动补足')
                }
                break;
            case '回基地':
                entity.position.copy(entity.jd.position);
                entity.position.y += 5
                break;
            case '管理员特权':
                var options = []
                if (admin1.includes(entity.player.boxId)) {
                    options = ['禁言管理', '解禁', '踢人', '重启游戏']
                } else {
                    options = ['禁言管理', '封号管理', '重启游戏', '控制台', '解禁', '踢人']
                }
                var players = world.querySelectorAll('player')
                var names = []
                for (const i in players) {
                    if (i) {
                        names.push(players[i].player.name)
                    }
                }
                var result = await entity.player.dialog({
                    type: Box3DialogType.SELECT,
                    title: "管理员",
                    options: options,    // 将提供玩家选择的选项放入数组里。
                });
                // 如果玩家点击了屏幕其他区域，取消了对话框。
                if (!result || result === null) {
                    return;
                }

                // 判断玩家选了什么选项。
                switch (result.value) {
                    case '禁言管理':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "管理员",
                            options: names,    // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "管理员,请选择天数",
                            options: ['1', '7', '14', '30', '60', '90', '180', '360'],    // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result1 || result1 === null) {
                            return
                        }
                        var num = parseInt(result1.value)

                        world.querySelectorAll('player').forEach((x) => {
                            if (x.player.name == result.value) {
                                x.danger = -1;
                                world.say(result.value + '被管理员' + entity.player.name + '禁言了' + num + '天！')
                                x.player.muted = true;
                                x.time = num
                            }
                        })
                        break;
                    case '封号管理':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "管理员",
                            options: names,    // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "管理员,请选择天数",
                            options: ['1', '7', '14', '30', '60', '90', '180', '360'],    // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result1 || result1 === null) {
                            return
                        }
                        var num = parseInt(result1.value)
                        world.querySelectorAll('player').forEach((x) => {
                            if (x.player.name == result.value && !admin.includes(entity.player.name)) {
                                x.danger = -2;
                                world.say(result.value + '被管理员' + entity.player.name + '封号了' + num + '天！')
                                x.time = num
                                x.player.kick();
                            }
                        })
                        break;
                    case '解禁':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "管理员",
                            options: names,    // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }

                        world.querySelectorAll('player').forEach((x) => {
                            if (x.player.name == result.value) {
                                x.danger = 0;
                                world.say(result.value + '被管理员' + entity.player.name + '解禁了')
                                x.player.muted = false;
                                x.time = 0;
                            }
                        })
                        break;
                    case '踢人':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "管理员",
                            options: names,    // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }

                        world.querySelectorAll('player').forEach((x) => {
                            if (x.player.name == result.value) {
                                x.player.kick()
                                world.say(result.value + '被管理员' + entity.player.name + '踢出游戏')
                            }
                        })
                        break;
                    case '重启游戏':
                        world.say(`管理员 @${entity.player.name} 进行了重启`)
                        await sleep(1000)
                        eval('for(;;){}')
                        break;
                    case '控制台':
                        const result4 = await entity.player.dialog({
                            type: Box3DialogType.INPUT,
                            title: "控制台",
                            content: `这是管理员专用的控制台，可以在运行模式下输入代码并执行。`,
                            confirmText: '确定', // 确定按钮上面的文字。按下确定按钮后，提交回答。
                            placeholder: '在这里输入代码。（注意“;”）', // 输入框背景上的提示文字。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result4 || result4 === null) {
                            entity.player.directMessage('已取消执行。');
                            return;
                        }

                        try {
                            await entity.player.dialog({
                                type: Box3DialogType.TEXT,   // 对话框的类型，TEXT是文本框。
                                title: '代码执行器',               // 对话框标题为NPC名字，表示正在说话的是NPC
                                content: '<~ ' + eval(result4)
                            });
                        } catch (err) {
                            await entity.player.dialog({
                                type: Box3DialogType.TEXT,   // 对话框的类型，TEXT是文本框。
                                title: '代码执行器',               // 对话框标题为NPC名字，表示正在说话的是NPC
                                content: 'Error:' + err
                            });
                        }
                        break;

                    default:
                    // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                }
                break;
            case '部队查看/编辑快捷工具':

                var result = await entity.player.dialog({
                    type: Box3DialogType.SELECT,
                    title: "请选择工具",
                    content: `请选择`,
                    options: ['选择一个玩家，并且你移动到他的基地的位置', '所有部队查看', '选择一个玩家，并且向ta发送私信', '到指定坐标位置', '团队广播'],   // 将提供玩家选择的选项放入数组里。
                });

                // 如果玩家点击了屏幕其他区域，取消了对话框。
                if (!result || result === null) {
                    return;
                }

                // 判断玩家选了什么选项。
                switch (result.value) {
                    case '选择一个玩家，并且你移动到他的基地的位置':
                        var options = []
                        world.querySelectorAll('player').forEach((e) => {
                            if (e.jd != '') {
                                options.push(e.player.name)
                            }
                        })
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择人",
                            content: `请选择`,
                            options: options,   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result1 || result1 === null) {
                            return;
                        }
                        try {
                            for (let e of world.querySelectorAll('player')) {
                                if (e.player.name == result1.value) {
                                    entity.position.x = e.jd.position.x
                                    entity.position.z = e.jd.position.z
                                }
                            }
                        } catch (e) {

                        }
                        break;
                    case '所有部队查看':
                        var options = []
                        entity.soldiers().forEach((e) => {
                            options.push(e.name)
                        })
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: '请选择部队',
                            content: '请选择',
                            options: options,
                        })
                        if (!result || result == null) {
                            return;
                        }
                        try {
                            entity.position.x = entity.soldiers()[result.index].position.x
                            entity.position.z = entity.soldiers()[result.index].position.z
                        } catch (e) {
                        }
                        break;
                    case '团队广播':
                        if (entity.danger <= -1) {
                            return entity.player.directMessage('禁言中');
                        }
                        if (entity.chatTime > 0) {
                            return entity.player.directMessage('广播冷却中')
                        }
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.INPUT,
                            title: '请输入内容',
                            content: '请输入（不超过100字）（请文明友好的发言）',
                            confirmText: '确定'
                        });
                        if (!result1 || result1 == null) {
                            return;
                        }
                        if (result1.length > 100) {
                            return entity.player.directMessage('超过100字！')
                        }
                        entity.chatTime = 5;
                        world.querySelectorAll(`.${entity.team}`).forEach(async (e) => {
                            for (let i = 0; i < 4; i++) {
                                entity.player.directMessage(`${entity.player.name} 发送了团队广播:${result1}`)
                                await sleep(500);
                            }
                        })
                        break;
                    case '选择一个玩家，并且向ta发送私信':
                        if (entity.danger <= -1) {
                            return entity.player.directMessage('禁言中')
                        }
                        if (entity.chatTime <= 0) {

                            var options = []
                            world.querySelectorAll('player').forEach((e) => {
                                if (e.jd) {
                                    options.push(e.player.name)
                                }
                            })
                            var result1 = await entity.player.dialog({
                                type: Box3DialogType.SELECT,
                                title: "请选择人",
                                content: `请选择`,
                                options: options,   // 将提供玩家选择的选项放入数组里。
                            });

                            // 如果玩家点击了屏幕其他区域，取消了对话框。
                            if (!result1 || result1 === null) {
                                return;
                            }
                            try {
                                world.querySelectorAll('player').forEach(async (e) => {
                                    if (e.player.name == result1.value) {
                                        var result = await entity.player.dialog({
                                            type: Box3DialogType.INPUT,
                                            title: "私信",
                                            content: `对 ${e.player.name} 发送私信 ,最多50字，请文明友好发言，如果有发现有人骂人请及时提供相关证据报告作者，作者会对他禁言3天`,
                                            confirmText: '确定',
                                        });
                                        if (!result || result === null) {
                                            entity.player.directMessage('你取消了发送');
                                            return;
                                        }
                                        if (result.length > 50) {
                                            return entity.player.directMessage('最多50字！！！')
                                        }
                                        e.player.directMessage(`${entity.player.name} 对你发送了私信： ${result} （ps：如果有发现有人骂人请及时提供相关证据报告作者或者管理员，查实后禁言3天，严重的封号）`)
                                        entity.player.directMessage('发送成功！！！')
                                        entity.chatTime = 5
                                    }
                                })
                            } catch (e) {

                            }
                        } else {
                            entity.player.directMessage('私信冷却剩余' + entity.chatTime + '秒')
                        }
                        break;
                    case '到指定坐标位置':
                        var x = await entity.player.dialog({
                            type: Box3DialogType.INPUT,
                            title: "请填写x坐标",
                            confirmText: '确定',
                        });
                        if (!x || x === null) {
                            return;
                        }
                        var z = await entity.player.dialog({
                            type: Box3DialogType.INPUT,
                            title: "请填写z坐标",
                            confirmText: '确定',
                        });
                        if (!z || z === null) {
                            return;
                        }
                        entity.position.x = x
                        entity.position.z = z
                        break;
                    default:
                    // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                }
                break;
            default:
            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
        }
    }
    if (button == Box3ButtonType.ACTION0) {
        if (hitVoxel != 0) {
            if (dx[voxels.name(hitVoxel)]) {
                if (dx[voxels.name(hitVoxel)].lx == '基地' && !(Math.floor(hitPosition.x) + 0.5 != entity.jd.position.x || Math.floor(hitPosition.z) + 0.5 != entity.jd.position.z)) {
                    entity.locked = 1
                    var zzxs = 1//资金系数 
                    zzxs += Math.round(entity.soldiers().length / 20)
                    if (zzxs > 10) {
                        zzxs = 10
                    }
                    var options = []
                    for (let i in dx[voxels.name(hitVoxel)].options) {
                        options.push(dx[voxels.name(hitVoxel)].options[i] + '  ' + dx[voxels.name(hitVoxel)].moneys[i] * (zzxs) + '元')
                    }
                    if (entity.jd.cdTime > 0) {
                        options = ['取消正在做的部队进程（钱不会返还）cd:' + entity.jd.cdTime]
                    }
                    var result = await entity.player.dialog({
                        type: Box3DialogType.SELECT,
                        title: dx[voxels.name(hitVoxel)].name,
                        content: `
                    坐标x:${Math.round(hitPosition.x)},坐标z:${Math.round(hitPosition.z)}
                    ${dx[voxels.name(hitVoxel)].text}
                    请选择制造的兵种 (你有${entity.money}元)
                    (资金系数：${zzxs})部队越多越贵，因为需要规划
                    `,
                        options: options,   // 将提供玩家选择的选项放入数组里。
                    });
                    entity.locked = 0;
                    // 如果玩家点击了屏幕其他区域，取消了对话框。
                    if (!result || result === null) {
                        return;
                    }
                    if (result.value.includes('取消正在做的部队进程（钱不会返还）')) {
                        return entity.jd.cdTime = -1;
                    }
                    if (getSoldier(new Box3Vector3(Math.floor(hitPosition.x) + 0.5, 1.5, Math.floor(hitPosition.z) + 0.5)) != '') {
                        return entity.player.directMessage('基地已经有部队占据，不能造新的部队~')
                    }
                    if (entity.money < dx[voxels.name(hitVoxel)].moneys[result.index] * zzxs) return entity.player.directMessage('资金不足~')
                    if (entity.soldiers().length >= 300) {
                        return entity.player.directMessage('部队达到了300规模上限，不能增加新的部队')
                    }
                    if (world.querySelectorAll('player').length >= 30 && entity.soldiers().length >= 200) {
                        return entity.player.directMessage('因为人多，部队达到了200规模上限就不能再造兵了')
                    }
                    if (world.entityQuota() <= 100) {
                        return entity.player.directMessage('世界实体爆满，不可以再创建部队！！！')
                    }
                    var name = dx[voxels.name(hitVoxel)].options[result.index]
                    if (name == '远程导弹车') {
                        if (world.querySelectorAll('.远程导弹车').filter(e => e.own == entity).length >= 3) {
                            return entity.player.directMessage('一个人最多拥有3台远程导弹车！')
                        }
                    }
                    entity.money -= dx[voxels.name(hitVoxel)].moneys[result.index] * zzxs
                    entity.jd.cdTime = soldiers[dx[voxels.name(hitVoxel)].options[result.index]].time
                    entity.player.directMessage('开始制造！需要' + entity.jd.cdTime + '秒')
                    for (let i = 0; Math.round(i < soldiers[dx[voxels.name(hitVoxel)].options[result.index]].time * techChuLi(entity, 'cdTime', 1, '训练')); i++) {

                        if (entity.jd.cdTime <= -1) {
                            entity.player.directMessage('你取消了这个兵的制造进程')
                            return;
                        }
                        if (entity.jd.cdTime == 0) continue;
                        entity.jd.cdTime--
                        await sleep(1000)
                    }
                    if (getSoldier(new Box3Vector3(Math.floor(hitPosition.x) + 0.5, 1.5, Math.floor(hitPosition.z) + 0.5)) != '') {
                        return entity.player.directMessage('哦不！你的兵被敌人占领的基地时候摧毁了！！！')
                    }

                    if (entity.tasks[2].length > 0) {//有在做的任务
                        if (tasks[entity.tasks[2][0]]) {//是不是存在这个任务
                            if (tasks[entity.tasks[2][0]].needMake) {//是不是需要建造的任务
                                if (tasks[entity.tasks[2][0]].needMake.includes(name)) {//建造的部队是不是任务要的部队
                                    try {
                                        var index = tasks[entity.tasks[2][0]].needMake.indexOf(name)
                                        entity.tasks[2][1][index] += 1
                                        if (entity.tasks[2][1][index] > tasks[entity.tasks[2][0]].score[index]) {//分数超过则回去
                                            entity.tasks[2][1][index] = tasks[entity.tasks[2][0]].score[index]
                                        } else {
                                            entity.player.directMessage(`你的《${entity.tasks[2][0]}》任务进度：` + entity.tasks[2][1] + '，最终进度：' + tasks[entity.tasks[2][0]].score)
                                        }
                                        var num = 0;//完成度
                                        for (let i in tasks[entity.tasks[2][0]].score) {
                                            if (entity.tasks[2][1][i] >= tasks[entity.tasks[2][0]].score[i]) {
                                                num++
                                            }
                                        }
                                        if (num >= tasks[entity.tasks[2][0]].score.length) {
                                            entity.player.directMessage(`你的《${entity.tasks[2][0]}》任务完成了！！！获得了` + tasks[entity.tasks[2][0]].coins + '个军团币！')
                                            entity.coin += tasks[entity.tasks[2][0]].coins
                                            entity.star++
                                            entity.tasks[1].push(entity.tasks[2][0])
                                            entity.tasks[2] = []
                                        }

                                    } catch (e) {
                                        console.log('tasks Error:' + e)
                                    }
                                }
                            }
                        }
                    }

                    entity.player.directMessage('制造完毕！')
                    createSoldier(entity, new Box3Vector3(Math.floor(hitPosition.x) + 0.5, 1.5 + soldiers[dx[voxels.name(hitVoxel)].options[result.index]].yAdd, Math.floor(hitPosition.z) + 0.5), name, '')
                } else {
                    var result = await entity.player.dialog({
                        type: Box3DialogType.SELECT,
                        title: dx[voxels.name(hitVoxel)].name,
                        content: `
                    坐标x:${Math.round(hitPosition.x)},坐标z:${Math.round(hitPosition.z)}
                    ${dx[voxels.name(hitVoxel)].text}
                    `,
                        options: ['使用迁城道具(仅限基地类型)（50格内领土用领土迁城）'],
                    });
                    if (!result || result == null) {
                        return;
                    }
                    if (result.index == 0) {
                        if (dx[voxels.name(hitVoxel)].lx != '基地') {
                            return entity.player.directMessage('迁城仅限基地类型方块！')
                        }
                        var a = 0;
                        world.querySelectorAll('.基地').forEach((e) => {
                            if (pmDist(e, new Box3Vector3(voxelIndex.x + 0.5, 0, voxelIndex.z + 0.5)) <= 10) {
                                a = 1;
                            }
                        })
                        if (a == 1) {
                            return entity.player.directMessage('附近10格已经有别人的基地了')
                        }
                        var a = 0;
                        var name = ''
                        if (entity.team == '红队') {
                            name = 'red_light'
                        }
                        if (entity.team == '蓝队') {
                            name = 'blue_light'
                        }
                        for (let x = voxelIndex.x - 25; x <= voxelIndex.x + 25; x++) {
                            if (a == 1) {
                                break;
                            }
                            for (let z = voxelIndex.z - 25; z <= voxelIndex.z + 25; z++) {
                                if (a == 1) {
                                    break;
                                }
                                if (voxels.name(voxels.getVoxel(x, 0, z)) == name) {
                                    var num = 0;
                                    for (let x1 = x - 1; x1 <= x + 1; x1++) {
                                        for (let z1 = z - 1; z1 <= z + 1; z1++) {
                                            if (voxels.name(voxels.getVoxel(x, 0, z)) == name) {
                                                num += 1
                                            }
                                        }
                                    }
                                    if (num >= 9) {
                                        a = 1;
                                    }
                                }
                            }
                        }
                        if (entity.bag['定点迁城'] <= 0) {
                            if (a == 1 && entity.bag['领土迁城'] > 0) {

                            } else {
                                return entity.player.directMessage('定点迁城不足')
                            }
                        }
                        if (entity.jd.position.distance(voxelIndex) > 100) {
                            return entity.player.directMessage('你选的地方和你现有基地距离不能超过100格')
                        }
                        if (world.querySelectorAll('.inGame').filter(
                            e => e.jd.position.distance(voxelIndex) <= 10 && e.team != entity.team).length > 0) {
                            return entity.player.directMessage('附近10格内已经有敌人的基地了！')
                        }
                        if (a == 0 || (a == 1 && entity.bag['领土迁城'] <= 0)) {
                            entity.bag['定点迁城'] -= 1
                        } else {
                            entity.bag['领土迁城'] -= 1
                        }
                        entity.jd.position.x = voxelIndex.x + 0.5
                        entity.jd.position.z = voxelIndex.z + 0.5
                        entity.player.directMessage('使用成功！')
                    }
                }
            }
        }
        if (hitVoxel || hitEntity) {
            if (hitEntity) {
                if (hitEntity.hasTag('士兵')) {
                    if (yunShuDanWei.includes(hitEntity.name)) {
                        hitVoxel = voxels.getVoxelId(hitEntity.position.x, 1, hitEntity.position.z)
                        voxelIndex = new Box3Vector3(Math.floor(hitEntity.position.x), 1, Math.floor(hitEntity.position.z))
                    }
                }
            }
            if (hitVoxel == voxels.id('glass')) {
                for (let i of entity.voxel) {
                    voxels.setVoxelId(i[0], i[1], i[2], 0)
                    if (i[0] === voxelIndex.x + 0.5 && i[2] === voxelIndex.z + 0.5 && entity.removingSoldier != '') {
                        var other = getSoldier(voxelIndex.add(new Box3Vector3(0.5, 0, 0.5)))
                        if (other != '') {
                            if (!yunShuDanWei.includes(other.name)) {
                                if (other.own != entity) {
                                    if (!soldiers[other.name].canSit.includes(entity.removingSoldier.name)) {
                                        entity.player.directMessage('不要和其他部队重叠在一格')
                                        continue;
                                    }
                                }
                            }
                        }
                        entity.removingSoldier.state['移动'] = soldiers[entity.removingSoldier.name].state['移动'] + pifuChuLi(entity.removingSoldier.pifu, 'state', { '移动': 0, })['移动']
                        /*
                                                entity.removingSoldier.energy--
                                                if (entity.removingSoldier.name != '无人机') {
                                                    entity.removingSoldier.food -= 5
                                                }
                        */
                        if (other != '') {//上车
                            if (other.sits.length < soldiers[other.name].maxSit + pifuChuLi(other.pifu, 'maxSit', 0)) {
                                other.sits.push([entity.removingSoldier.name, entity.removingSoldier.hp, entity.removingSoldier.state, entity.removingSoldier.food])
                                entity.removingSoldier.destroy()
                            }
                            entity.removingSoldier.position.x = voxelIndex.x + 0.5
                            entity.removingSoldier.position.z = voxelIndex.z + 0.5
                            for (let i of entity.voxel) {
                                voxels.setVoxelId(i[0], 1, i[2], 0)
                            }
                            entity.removingSoldier = ''
                            entity.voxel = []
                            return;
                        }
                        entity.removingSoldier.position.x = voxelIndex.x + 0.5
                        entity.removingSoldier.position.z = voxelIndex.z + 0.5
                        if (dx[getPosVoxel(entity.removingSoldier.position.x, entity.removingSoldier.position.z)].lx == '基地' && (entity.removingSoldier.name == '轻步兵' || entity.removingSoldier.name == '反坦克步兵')) {
                            entity.jd.position.x = entity.removingSoldier.position.x
                            entity.jd.position.z = entity.removingSoldier.position.z
                        }
                        var name = ''
                        if (entity.team == '红队') {
                            name = '红色据点';
                        }
                        if (entity.team == '蓝队') {
                            name = '蓝色据点'
                        }
                        var voxelName = dx[getPosVoxel(entity.removingSoldier.position.x, entity.removingSoldier.position.z)].name
                        if (voxelName != name &&
                            (entity.removingSoldier.name == '轻步兵' || entity.removingSoldier.name == '反坦克步兵')
                            && voxelName.includes('据点')) {//占领

                            if (voxelName != entity.team[0] + '色据点') {
                                world.say(`${entity.team}的${entity.player.name}占领了一格${voxelName}!`)
                                var voxelId = '';
                                entity.score += 20000;
                                if (entity.team == '红队') {
                                    voxelId = 'red_light';
                                    redScore += 20000;
                                    if (voxelName != '中立据点') {
                                        blueScore -= 20000;
                                    }
                                }
                                if (entity.team == '蓝队') {
                                    voxelId = 'blue_light';
                                    blueScore += 20000;
                                    if (voxelName != '中立据点') {
                                        redScore -= 20000;
                                    }

                                }
                                if (voxelId != '') {
                                    voxels.setVoxel(entity.removingSoldier.position.x, 0, entity.removingSoldier.position.z, voxelId)
                                }
                            }
                        }
                        entity.removingSoldier = ''
                        entity.voxel = []

                    }
                }
                entity.removingSoldier = ''
            } else {
                for (let i of entity.voxel) {
                    voxels.setVoxelId(i[0], i[1], i[2], 0)
                }
                entity.removingSoldier = ''
                entity.voxel = []
            }

        }
        if (hitVoxel || hitEntity) {
            if (hitEntity) {
                if (hitEntity.hasTag('士兵')) {
                    hitVoxel = voxels.getVoxelId(hitEntity.position.x, 1, hitEntity.position.z)
                    voxelIndex = new Box3Vector3(Math.floor(hitEntity.position.x), 1, Math.floor(hitEntity.position.z))
                }
            }
            if (hitVoxel == voxels.id('red_glass')) {//伤害
                var Hit = 0;//有没有打中
                for (let i of entity.attVoxel) {
                    voxels.setVoxelId(i[0], 1, i[2], 0)
                    let soldier = getSoldier(new Box3Vector3(voxelIndex.x + 0.5, 0, voxelIndex.z + 0.5))
                    if (soldier != '') {
                        if ((soldier.own == entity || soldier.own.team == entity.team) && world.canHurtTeam == 0 && Hit != 1) {
                            entity.player.directMessage('别攻击队友')
                            Hit = 1
                        } else {
                            (async function () {
                                if (Hit != 1) {
                                    Hit = 1;
                                    entity.attSoldier.state['攻击'] = soldiers[entity.attSoldier.name].state['攻击'] + pifuChuLi(entity.attSoldier.pifu, 'state', { '攻击': 0 })['攻击']
                                    var damage = 0;
                                    var damage1 = 0;
                                    if (soldiers[entity.attSoldier.name].damage[soldier.name]) {
                                        damage = soldiers[entity.attSoldier.name].damage[soldier.name]
                                    }
                                    if (damage <= 0 || damage == undefined || damage == NaN || Number.isNaN(damage)) {
                                        damage = 0;
                                    }
                                    if (yunShuDanWei.includes(entity.attSoldier.name)) {
                                        if (entity.attSoldier.name == '防御塔') {
                                            damage *= (entity.attSoldier.sits.length + 1)
                                        } else {
                                            if (entity.attSoldier.pifu == 'BMP-3步兵战车') {
                                                damage = soldiers['侦察车'].damage[soldier.name]
                                            } else {
                                                if (entity.attSoldier.name != '大型运输船') {
                                                    for (let i of entity.attSoldier.sits) {
                                                        if (i[0] != '自爆兵') {
                                                            damage += soldiers[i[0]].damage[soldier.name]//i[0]是指代乘坐步兵name
                                                        }
                                                    }
                                                }
                                            }
                                        }

                                    }
                                    damage *= pifuChuLi(entity.attSoldier.pifu, 'damage', 1) * techChuLi(entity, 'damage', 1, soldiers[entity.attSoldier.name].lx1)
                                    damage /= pifuChuLi(soldier.pifu, 'fangyu', 1) * techChuLi(soldier.own, 'fangyu', 1, soldiers[soldier.name].lx1)
                                    damage *= nature('damage', soldiers[entity.attSoldier.name].attMaxSize + pifuChuLi(entity.attSoldier.pifu, 'attMaxSize', 0))
                                    damage /= nature('fangyu', 0);
                                    damage /= dx[getPosVoxel(soldier.position.x, soldier.position.z)].fangyu
                                    damage = Math.floor(damage / entity.attSoldier.maxHp * entity.attSoldier.hp)
                                    if (soldiers[soldier.name].lx1 == '空' && soldier.name != '无人机' && entity.attSoldier.name == '反坦克步兵' && Math.random() < 0.5) {
                                        damage = 0;
                                        entity.player.directMessage('50%几率，反坦克步兵未命中空军')
                                    }
                                    soldier.hurt(damage, { attacker: entity })
                                    world.say(`主动攻击：${getName(entity)}的${entity.attSoldier.pifu}对${getName(soldier.own)}的${soldier.pifu}造成了${damage}点伤害 位置${soldier.position.add(new Box3Vector3(-0.5, -0.5, -0.5))}`)
                                    /*
                                                                        if (entity.attSoldier.name != '无人机') {
                                                                            entity.attSoldier.food -= 5
                                                                        }
                                                                        */
                                    if (soldier.hp > 0 && new Box3Vector3(soldier.position.x, 0, soldier.position.z).distance(new Box3Vector3(entity.attSoldier.position.x, 0, entity.attSoldier.position.z)) <= soldiers[soldier.name].attMaxSize + pifuChuLi(soldier.pifu, 'attMaxSize', 0)
                                        && new Box3Vector3(soldier.position.x, 0, soldier.position.z).distance(new Box3Vector3(entity.attSoldier.position.x, 0, entity.attSoldier.position.z)) > soldiers[soldier.name].attMinSize + pifuChuLi(soldier.pifu, 'attMinSize', 0)) {

                                        var damage1 = soldiers[soldier.name].damage[entity.attSoldier.name]
                                        if (damage1 <= 0 || damage1 == undefined || damage1 == NaN || Number.isNaN(damage1)) {
                                            damage1 = 0
                                        }
                                        if (yunShuDanWei.includes(soldier.name)) {
                                            if (soldier.name == '防御塔') {
                                                damage1 *= (1.2 * soldier.sits.length + 1)
                                            } else {
                                                if (soldier.pifu == 'BMP-3步兵战车') {
                                                    damage1 = soldiers['侦察车'].damage[entity.attSoldier.name]
                                                } else {
                                                    if (soldiers.name != '大型运输船') {
                                                        for (let i of soldier.sits) {
                                                            damage1 += soldiers[i[0]].damage[entity.attSoldier.name]
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        damage1 *= pifuChuLi(soldier.pifu, 'damage', 1) * techChuLi(soldier.own, 'damage', 1, soldiers[soldier.name].lx1)
                                        damage1 /= pifuChuLi(entity.attSoldier.pifu, 'fangyu', 1) * techChuLi(entity, 'fangyu', 1, soldiers[entity.attSoldier.name].lx1)
                                        damage1 *= nature('damage', soldiers[soldier.name].attMaxSize + pifuChuLi(soldier.pifu, 'attMaxSize', 0))
                                        damage1 /= nature('fangyu', 0)
                                        damage1 /= dx[getPosVoxel(entity.attSoldier.position.x, entity.attSoldier.position.z)].fangyu
                                        if (soldier.name == '自爆兵') {
                                            damage1 /= 2
                                        }
                                        damage1 = Math.floor(damage1 * soldier.hp / soldier.maxHp)//防止防御塔伤害出现小数
                                        entity.attSoldier.hurt(damage1, { attacker: soldier.own })
                                        world.say(`被动防御：${getName(entity)}的${entity.attSoldier.pifu}被${getName(soldier.own)}的${soldier.pifu}造成了${damage1}点伤害 位置${soldier.position.add(new Box3Vector3(-0.5, -0.5, -0.5))}`)
                                    }
                                    if (entity.attSoldier.name == '自爆兵' && entity.attSoldier.hp > 0) {
                                        entity.attSoldier.hurt(100, { attacker: soldier.own })
                                    }
                                    if (soldier.name == '自爆兵' && soldier.hp > 0) {
                                        soldier.hurt(100, { attacker: entity })
                                    }
                                }
                            })()
                        }
                    }
                }
                await sleep(100)
                entity.attSoldier = ''
                entity.attVoxel = []
            } else {

                for (let i of entity.attVoxel) {
                    voxels.setVoxelId(i[0], i[1], i[2], 0)
                }
                entity.attVoxel = []
                entity.attSoldier = ''
            }
        }
    }







    if (hitEntity) {
        if (hitEntity.hasTag('士兵') && button == Box3ButtonType.ACTION0) {
            if (hitEntity.own == entity) {
                entity.locked = 1;
                var options = []
                if (hitEntity.name == '工程车' && hitEntity.cdTime > 0) {
                } else {
                    if (hitEntity.state['移动'] <= 0) {
                        options.push('移动')
                    }
                    if (hitEntity.state['攻击'] <= 0) {
                        options.push('攻击')
                    }

                }
                options.push('报废')
                if (yunShuDanWei.includes(hitEntity.name)) {
                    if (hitEntity.sits.length > 0) {
                        options.push('卸下')
                    }
                }
                if (hitEntity.name == '航母') {
                    options.push('航母操作')
                }
                /*
                                if (hitEntity.food < 50) {
                                    options.push('用钱买粮食(缺乏粮食数*25元)(世界上资源点少则要100元)')
                                }
                                if (hitEntity.energy <= 5) {
                                    options.push('买5份石油(2000元)')
                                }
                */
                if (hitEntity.name == '工程车') {
                    options.push('工程建造')
                }
                if (hitEntity.name == '气象台') {
                    options.push('气象台预报')
                }
                if (hitEntity.name == '轻步兵' || hitEntity.name == '反坦克步兵') {
                    if (dx[getPosVoxel(hitEntity.position.x, hitEntity.position.z)].lx == '基地') {
                        options.push('占领')
                    }
                }
                if (hitEntity.name == '无人机') {
                    options.push('无人机自爆')
                }
                options.push('其他操作')
                var result = await entity.player.dialog({
                    type: Box3DialogType.SELECT,
                    title: hitEntity.own.player.name + '的' + hitEntity.name,
                    content: `
                    坐标x:${Math.round(hitPosition.x)},坐标z:${Math.round(hitPosition.z)}
                    兵种：${ hitEntity.name}, 生命值: ${hitEntity.hp} / ${hitEntity.maxHp},` + /*燃油: ${hitEntity.energy} / ${soldiers[hitEntity.name].energy + pifuChuLi(hitEntity.pifu, 'energy', 0)}, 食物${hitEntity.food} / 100*/
                        `                    移动力：${soldiers[hitEntity.name].speed}, 射程：${soldiers[hitEntity.name].attMinSize + pifuChuLi(hitEntity.pifu, 'attMinSize', 0)} ~${soldiers[hitEntity.name].attMaxSize + pifuChuLi(hitEntity.pifu, 'attMaxSize', 0)}
                    所属兵种分类：${ soldiers[hitEntity.name].lx1}, 具体分类：${soldiers[hitEntity.name].lx2},
                    移动CD还剩: ${ hitEntity.state['移动']}秒，攻击CD还剩: ${hitEntity.state['攻击']}秒
`,
                    /*                    运输的资源: 矿物: ${ hitEntity.ziyuan[0]}, 石油: ${hitEntity.ziyuan[1]}, 粮食: ${hitEntity.ziyuan[2]}*/

                    options: options,   // 将提供玩家选择的选项放入数组里。
                });
                entity.locked = 0;
                // 如果玩家点击了屏幕其他区域，取消了对话框。
                if (!result || result === null) {
                    return;
                }

                // 判断玩家选了什么选项。
                switch (result.value) {
                    case '无人机自爆':
                        hitEntity.hp = 0;
                        world.querySelectorAll('.士兵').forEach((e) => {
                            if (e.own.team != hitEntity.own.team && pmDist(e.position, hitEntity.position) <= 5) {
                                if (soldiers['无人机'].damage[e.name]) {
                                    e.hurt(Math.min(soldiers['无人机'].damage[e.name] * 5, 99), { attacker: hitEntity.own })
                                }
                            }
                        })
                        break;
                    case '占领':
                        entity.jd.position.set(voxelIndex.x + 0.5, 1.01, voxelIndex.z + 0.5)
                        break;
                    case '气象台预报':
                        var content = `今天天气 ${world.weather},
                        接下来7天预报:`
                        for (let i = 0; i < 7; i++) {
                            content += '\n' + `第${i}天  ` + world.weathers[i]
                        }
                        content += '\n' + '接下来发生在这个气象台附近的自然灾害 \n'
                        for (let i = 0; i < 10; i++) {
                            if (pmDist(new Box3Vector3(world.natureZaiHai[i].x, 0, world.natureZaiHai[i].z), hitEntity.position) <= 50
                                && world.natureZaiHai[i].name != '瘟疫' && world.natureZaiHai[i].name != '饥荒') {
                                content += world.natureZaiHai[i].name + '\n'
                            }
                        }
                        entity.player.dialog({
                            type: Box3DialogType.TEXT,
                            title: "气象台预报",
                            content: content,
                        });



                        break;
                    case '买5份石油(2000元)':
                        if (hitEntity.energy > 5) return;
                        if (entity.money >= 2000) {
                            entity.money -= 2000
                            hitEntity.energy += 5
                            entity.player.directMessage('购买成功')
                        } else {
                            entity.player.directMessage("钱不够")
                        }
                        break;
                    case '用钱买粮食(缺乏粮食数*25元)(世界上资源点少则要100元)':
                        if (hitEntity.food > 50) return;
                        let money = 25
                        if (world.ziYuanNum[2] < 50) {
                            money = 100
                        }
                        if (entity.money > (50 - hitEntity.food) * money) {
                            hitEntity.food = 50
                            entity.money -= (50 - hitEntity.food) * money
                            entity.player.directMessage('购买成功')
                        } else {
                            entity.player.directMessage('钱不足')
                        }
                        break;
                    case '移动':
                        await sleep(500)
                        if (hitEntity.energy <= 0) {
                            return entity.player.directMessage('此单位没有燃油了！！！')
                        }
                        for (let i of entity.voxel) {
                            voxels.setVoxelId(i[0], i[1], i[2], 0)
                        }
                        entity.voxel = []
                        entity.removingSoldier = ''
                        hitEntity.state['移动'] += 2
                        //if (entity.removingSoldier != '' || entity.attSoldier != '') return entity.player.directMessage('请先把上一个部队操作')
                        entity.removingSoldier = hitEntity
                        entity.voxel = await bfs(hitEntity.position.x, 1, hitEntity.position.z, (soldiers[hitEntity.name].speed + pifuChuLi(hitEntity.pifu, 'speed', 0)) * nature('speed', 0) * techChuLi(entity, 'speed', 1, soldiers[hitEntity.name].lx1), soldiers[hitEntity.name].lx2, entity)
                        break;
                    case '攻击':
                        if (world.yc >= 600 && hitEntity.name == '远程导弹车') {
                            return entity.player.directMessage('现在太卡，不能使用导弹车防止崩溃')
                        }
                        await sleep(500)
                        for (let i of entity.attVoxel) {
                            voxels.setVoxelId(i[0], i[1], i[2], 0);
                        }
                        entity.attVoxel = []
                        entity.attSoldier = ''
                        if (hitEntity.name == '鱼雷机') {
                            if (getPosVoxel(hitEntity.position.x, hitEntity.position.z) != 'water') {
                                return entity.player.directMessage('鱼雷机投弹位置必须要在海上！！！')
                            }
                        }
                        hitEntity.state['攻击'] += 3
                        if (hitEntity.name == '远程导弹车') {
                            hitEntity.state['攻击'] += 17
                        }
                        //if (entity.attSoldier != '' || entity.removingSoldier != '') return entity.player.directMessage('请先把上一个部队操作')
                        var voxel = await attVoxelBuild(hitEntity.position,
                            (soldiers[hitEntity.name].attMinSize + pifuChuLi(hitEntity.pifu, 'attMinSize', 0)) * techChuLi(entity, 'attMinSize', 1, soldiers[hitEntity.name].lx1),
                            (soldiers[hitEntity.name].attMaxSize + pifuChuLi(hitEntity.pifu, 'attMaxSize', 0)) * techChuLi(entity, 'attMaxSize', 1, soldiers[hitEntity.name].lx1))
                        if (voxel.length > 0) {
                            entity.attSoldier = hitEntity
                            entity.attVoxel = voxel
                        } else {
                            entity.player.directMessage('身边没有部队，攻击无效')
                        }
                        break;
                    case '卸下':
                        var addPos = new Box3Vector3(0, 0, 1)
                        var options = []
                        for (let i of hitEntity.sits) {
                            options.push(i[0])
                        }
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择卸下兵种",
                            content: `请选择`,
                            options: options,   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择卸下位置",
                            content: `根据运输单位模型，选择卸下位置`,
                            options: ['左', '右', '前', '后'],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result1 || result1 === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result1.index) {
                            case 0:
                                addPos = new Box3Vector3(0, 0, -1)
                                break;
                            case 1:
                                addPos = new Box3Vector3(0, 0, 1)
                                break;
                            case 2:
                                addPos = new Box3Vector3(1, 0, 0)
                                break;
                            case 3:
                                addPos = new Box3Vector3(-1, 0, 0)
                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }
                        if (getPosVoxel(hitEntity.position.x + addPos.x, hitEntity.position.z + addPos.z) != 'medium_gray' && getPosVoxel(hitEntity.position.x + addPos.x, hitEntity.position.z + addPos.z) != 'grass' && getPosVoxel(hitEntity.position.x + addPos.x, hitEntity.position.z + addPos.z) != 'sand') {
                            return entity.player.directMessage('只能卸下在草地或者公路或者浅滩上')
                        }
                        if (getSoldier(hitEntity.position.add(addPos))) {
                            return entity.player.directMessage('你要卸下的位置已经有部队了')
                        }
                        createSoldier(hitEntity.own, hitEntity.position.add(new Box3Vector3(addPos.x, -hitEntity.position.y + 1.5, addPos.z)), hitEntity.sits[result.index][0], hitEntity.sits[result.index])
                        hitEntity.sits = deleteArrayStr(hitEntity.sits, hitEntity.sits[result.index])
                        break;
                    case '报废':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: '是否报废',
                            content: '是否报废',
                            options: ['是', '不报废了吧']
                        })
                        if (!result || result == null) {
                            return;
                        }
                        if (result.index == 1) {
                            return;
                        }
                        hitEntity.hp = 0
                        break;
                    case '航母操作':
                        var zzxs = 1.5//资金系数 
                        zzxs += Math.round(entity.soldiers().length / 20)
                        if (zzxs > 10) {
                            zzxs = 10
                        }
                        var options = []
                        for (let i in dx['lab_material_13'].options) {
                            options.push(dx['lab_material_13'].options[i] + '  ' + dx['lab_material_13'].moneys[i] * (zzxs) + '元')
                        }
                        if (hitEntity.cdTime > 0) {
                            options = ['取消正在做的部队进程（钱不会返还）cd:' + hitEntity.cdTime]
                        }
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: dx['lab_material_13'].name,
                            content: `
                    ${ dx['lab_material_13'].text}
                    请选择制造的兵种(你有${ entity.money}元)
                        (资金系数：${ zzxs})部队越多越贵，因为需要规划，航母另外比空军基地贵0.5倍
                    不可以生产轻步兵
                        `,
                            options: options,   // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        if (result.value.includes('轻步兵')) {
                            return entity.player.directMessage('航母上不可以生产轻步兵')
                        }
                        if (result.value.includes('取消正在做的部队进程（钱不会返还）')) {
                            return hitEntity.cdTime = -1;
                        }
                        if (getSoldier(new Box3Vector3(Math.floor(hitPosition.x) + 2.5, 1.5, Math.floor(hitPosition.z) + 0.5)) != '') {
                            return entity.player.directMessage('已经有部队占据，不能造新的部队~')
                        }
                        if (entity.money < dx['lab_material_13'].moneys[result.index] * zzxs) return entity.player.directMessage('资金不足~')
                        if (entity.soldiers().length >= 300) {
                            return entity.player.directMessage('达到了300规模上限，不能增加新的部队')
                        }
                        if (world.querySelectorAll('player').length >= 30 && entity.soldiers().length >= 200) {
                            return entity.player.directMessage('因为人多，部队达到了200规模上限就不能再造兵了')
                        }
                        if (world.entityQuota() <= 100) {
                            return entity.player.directMessage('世界实体爆满，不可以再创建部队！！！')
                        }
                        entity.money -= dx['lab_material_13'].moneys[result.index] * zzxs
                        hitEntity.cdTime = soldiers[dx['lab_material_13'].options[result.index]].time
                        entity.player.directMessage('开始制造！需要' + hitEntity.cdTime + '秒')
                        for (let i = 0; i < soldiers[dx['lab_material_13'].options[result.index]].time; i++) {
                            if (hitEntity.cdTime <= -1) {
                                entity.player.directMessage('你取消了这个兵的制造进程')
                                return;
                            }
                            if (hitEntity.cdTime == 0) continue;
                            hitEntity.cdTime--
                            await sleep(1000)
                        }
                        if (getSoldier(new Box3Vector3(Math.floor(hitPosition.x) + 2.5, 1.5, Math.floor(hitPosition.z) + 0.5)) != '') {
                            return entity.player.directMessage('这个位置已经有部队占据了')
                        }
                        entity.player.directMessage('制造完毕！')
                        if (entity.tasks[2].length > 0) {//有在做的任务
                            if (tasks[entity.tasks[2][0]]) {//是不是存在这个任务
                                if (tasks[entity.tasks[2][0]] == '空中打击') {
                                    try {
                                        var index = 0
                                        entity.tasks[2][1][index] += 1
                                        if (entity.tasks[2][1][index] > tasks[entity.tasks[2][0]].score[index]) {//分数超过则回去
                                            entity.tasks[2][1][index] = tasks[entity.tasks[2][0]].score[index]
                                        } else {
                                            entity.player.directMessage(`你的《${entity.tasks[2][0]}》任务进度：` + entity.tasks[2][1] + '，最终进度：' + tasks[entity.tasks[2][0]].score)
                                        }
                                        var num = 0;//完成度
                                        for (let i in tasks[entity.tasks[2][0]].score) {
                                            if (entity.tasks[2][1][i] >= tasks[entity.tasks[2][0]].score[i]) {
                                                num++
                                            }
                                        }
                                        if (num >= tasks[entity.tasks[2][0]].score.length) {
                                            entity.player.directMessage(`你的《${entity.tasks[2][0]}》任务完成了！！！获得了` + tasks[entity.tasks[2][0]].coins + '个军团币！')
                                            entity.coin += tasks[entity.tasks[2][0]].coins
                                            entity.star++
                                            entity.tasks[1].push(entity.tasks[2][0])
                                            entity.tasks[2] = []
                                        }

                                    } catch (e) {
                                        console.log('tasks Error:' + e)
                                    }
                                }
                            }
                        }
                        createSoldier(entity, new Box3Vector3(Math.floor(hitEntity.position.x) + 2.5, 1.5 + soldiers[dx['lab_material_13'].options[result.index]].yAdd, Math.floor(hitEntity.position.z) + 0.5), dx['lab_material_13'].options[result.index], '')
                        break;
                    case '工程建造':
                        var addPos = new Box3Vector3(0, 0, 1)
                        var name = '工程车'
                        var zzxs = 1//资金系数 
                        zzxs += Math.round(entity.soldiers().length / 20)
                        if (zzxs > 10) {
                            zzxs = 10
                        }
                        var options = []
                        for (let i in soldiers[name].buildOptions) {
                            options.push(soldiers[name].buildOptions[i] + '  ' + soldiers[name].buildMoneys[i] * (zzxs) + '元')
                        }
                        if (hitEntity.cdTime > 0) {
                            options = ['取消正在做的部队进程（钱不会返还）cd:' + hitEntity.cdTime]
                        }
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: '工程建造',
                            content: `
                    请选择制造的兵种(你有${ entity.money}元)
                        (资金系数：${ zzxs})部队越多越贵，因为需要规划
                    需要的零件 = 向上取整（需要钱数 / 1000）
                    `,
                            options: options,   // 将提供玩家选择的选项放入数组里。
                        });
                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }
                        if (result.value.includes('取消正在做的部队进程（钱不会返还）')) {
                            return hitEntity.cdTime = -1;
                        }
                        var result1 = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择建造位置",
                            content: `根据运输单位模型，选择建造位置`,
                            options: ['左', '右', '前', '后'],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result1 || result1 === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result1.index) {
                            case 0:
                                addPos = new Box3Vector3(0, 0, 1)
                                break;
                            case 1:
                                addPos = new Box3Vector3(0, 0, -1)
                                break;
                            case 2:
                                addPos = new Box3Vector3(-1, 0, 0)
                                break;
                            case 3:
                                addPos = new Box3Vector3(1, 0, 0)
                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }
                        if (!soldiers[hitEntity.name].buildPos[result.index].includes(getPosVoxel(hitEntity.position.x + addPos.x, hitEntity.position.z + addPos.z))) {
                            return entity.player.directMessage('这个地形并不包含在可以制造这个单位的里面，参考' + soldiers[hitEntity.name].buildPos[result.index])
                        }
                        if (getSoldier(new Box3Vector3(hitEntity.position.x + addPos.x, 1.5, hitEntity.position.z + addPos.z)) != '') {
                            return entity.player.directMessage('已经有部队占据，不能造新的部队~')
                        }
                        if (entity.money < soldiers[name].buildMoneys[result.index] * zzxs) return entity.player.directMessage('资金不足~')
                        /*
                                                var lingJian = Math.ceil(soldiers[name].buildOptions[result.index])
                                                if (hitEntity.lingJian < lingJian) return entity.player.directMessage('零件不足')
                                                hitEntity.lingJian -= lingJian
                        */
                        if (entity.soldiers().length >= 300) {
                            return entity.player.directMessage('达到了300规模上限，不能增加新的部队')
                        }
                        if (world.querySelectorAll('player').length >= 30 && entity.soldiers().length >= 200) {
                            return entity.player.directMessage('因为人多，部队达到了200规模上限就不能再造兵了')
                        }
                        if (world.entityQuota() <= 100) {
                            return entity.player.directMessage('世界实体爆满，不可以再创建部队！！！')
                        }
                        entity.money -= soldiers[name].buildMoneys[result.index] * zzxs
                        hitEntity.cdTime = soldiers[soldiers[name].buildOptions[result.index]].time
                        entity.player.directMessage('开始制造！需要' + hitEntity.cdTime + '秒')
                        for (let i = 0; i < soldiers[soldiers[name].buildOptions[result.index]].time; i++) {
                            if (hitEntity.cdTime <= -1) {
                                entity.player.directMessage('你取消了这个兵的制造进程')
                                return;
                            }
                            if (hitEntity.cdTime == 0) continue;
                            hitEntity.cdTime--
                            await sleep(1000)
                        }
                        if (getSoldier(new Box3Vector3(hitEntity.position.x + addPos.x, 1.5, hitEntity.position.z + addPos.z)) != '') {
                            return entity.player.directMessage('这个位置已经有部队占据了')
                        }
                        entity.player.directMessage('制造完毕！')
                        createSoldier(entity,
                            new Box3Vector3(hitEntity.position.x + addPos.x,
                                1.5 + soldiers[soldiers[name].buildOptions[result.index]].yAdd,
                                hitEntity.position.z + addPos.z),
                            soldiers[name].buildOptions[result.index], '')
                        break;
                    case '其他操作':
                        var result = await entity.player.dialog({
                            type: Box3DialogType.SELECT,
                            title: "请选择操作",
                            content: `请选择`,
                            options: ['转让部队', '切换皮肤'],   // 将提供玩家选择的选项放入数组里。
                        });

                        // 如果玩家点击了屏幕其他区域，取消了对话框。
                        if (!result || result === null) {
                            return;
                        }

                        // 判断玩家选了什么选项。
                        switch (result.value) {
                            case '转让部队':
                                if (hitEntity.name == '远程导弹车') {
                                    return entity.player.directMessage('不可以转让远程导弹车！！！F')
                                }
                                var options = []
                                world.querySelectorAll('player').forEach((e) => {
                                    if (e.jd && !options.includes(e.player.name)) {
                                        options.push(e.player.name)
                                    }
                                })

                                var result1 = await entity.player.dialog({
                                    type: Box3DialogType.SELECT,
                                    title: "请选择转让对象（请确保那个人有一个部队离你此单位距离50格以内，否则不好接洽）",
                                    content: ``,
                                    options: options,   // 将提供玩家选择的选项放入数组里。
                                });

                                // 如果玩家点击了屏幕其他区域，取消了对话框。
                                if (!result1 || result1 === null) {
                                    return;
                                }

                                world.querySelectorAll('player').forEach((e) => {
                                    if (e.player.name == result1.value && e != entity) {
                                        var a = 0;
                                        for (let i of e.soldiers()) {
                                            if (pmDist(i.position, hitEntity.position) <= 50) {
                                                a = 1
                                            }
                                        }
                                        if (a == 1 && e.team == entity.team) {
                                            hitEntity.own = e
                                            e.player.directMessage('你收到了来自' + entity.player.name + '的一个' + hitEntity.pifu)
                                            entity.player.directMessage('转让成功')
                                            hitEntity.removeTag(entity.player.name)
                                            hitEntity.addTag(e.player.name)
                                        } else {
                                            entity.player.directMessage('转让失败')
                                        }
                                    }
                                })

                                break;
                            case '切换皮肤':
                                var options = ['普通皮肤']
                                for (let i of entity.items) {
                                    if (i.slice(0, 4) == '【皮肤】') {
                                        if (pifu[i].forward == hitEntity.name && !options.includes(i)) {
                                            options.push(i)
                                        }
                                    }
                                }
                                var result1 = await entity.player.dialog({
                                    type: Box3DialogType.SELECT,
                                    title: "请选择皮肤",
                                    content: `请选择`,
                                    options: options,   // 将提供玩家选择的选项放入数组里。
                                });

                                // 如果玩家点击了屏幕其他区域，取消了对话框。
                                if (!result1 || result1 === null) {
                                    return;
                                }
                                if (result1.value == '普通皮肤') {
                                    hitEntity.pifu = hitEntity.name;
                                } else {
                                    hitEntity.pifu = result1.value.slice(4)//删掉【皮肤】
                                }
                                break;
                            default:
                            // 注意，使用 switch 分支的时候，不要漏了后面的 break; 
                        }
                        break;
                    default:
                    // 注意，使用 switch 分支的时候，不要漏了后面的 break; 

                }
            } else if (entity.attSoldier == '') {
                entity.player.dialog({
                    type: Box3DialogType.TEXT,
                    title: hitEntity.own.player.name + '的' + hitEntity.name,
                    content: `
                                        坐标x:${Math.round(hitPosition.x)},坐标z:${Math.round(hitPosition.z)}
                    兵种：${ hitEntity.name}, 生命值: ${hitEntity.hp} / ${hitEntity.maxHp}, 燃油: ${hitEntity.energy} / ${soldiers[hitEntity.name].energy + pifuChuLi(hitEntity.pifu, 'energy', 0)}, 食物${hitEntity.food} / 100
                    移动力：${ soldiers[hitEntity.name].speed}, 射程：${soldiers[hitEntity.name].attMinSize + pifuChuLi(hitEntity.pifu, 'attMinSize', 0)} ~${soldiers[hitEntity.name].attMaxSize + pifuChuLi(hitEntity.pifu, 'attMaxSize', 0)}
                    所属兵种分类：${ soldiers[hitEntity.name].lx1}, 具体分类：${soldiers[hitEntity.name].lx2},
                    移动CD还剩: ${ hitEntity.state['移动']}秒，攻击CD还剩: ${hitEntity.state['攻击']}秒
                    运输的资源: 矿物: ${ hitEntity.ziyuan[0]}, 石油: ${hitEntity.ziyuan[1]}, 粮食: ${hitEntity.ziyuan[2]}
                    `,
                });
            } else {

            }
        }
        if (hitEntity.hasTag('基地占领标识') && button == Box3ButtonType.ACTION0) {
            textDialog(entity, '基地', `坐标x:${Math.round(hitPosition.x)},坐标z:${Math.round(hitPosition.z)}
            ${hitEntity.own.player.name}  的基地`)
        }
    }
})
world.onTakeDamage(({ entity, attacker, damage }) => {
    if (!attacker) {
        return;
    }
    if (!attacker.isPlayer) {
        return;
    }
    if (!entity.own) {
        return;
    }
    if (damage == NaN) {
        return;
    }
    if (Number.isNaN(damage)) {
        return;
    }
    if (damage == null || damage == undefined) return;
    if (damage > entity.maxHp) { damage = entity.maxHp }
    if (!entity.hasTag('士兵')) return;
    entity.hurtTime = 5 + damage / 10;
    let index = -1;
    let money = -1
    for (let c in dx) {
        a = dx[c]
        index = -1
        if (a.lx == '基地') {
            for (let b in a.options) {
                if (a.options[b] == entity.name) {//对不对的上，获得索引
                    index = b
                }
            }
            if (index != -1) {
                money = a.moneys[index]
            }
        }
    }
    if (money == -1) {
    } else {
        var sunshi = Math.floor(money * damage / entity.maxHp)//损失
        sunshi = Math.ceil(sunshi / 50)
        entity.score += sunshi
        if (entity.own.team == '红队') {
            redScore += sunshi
        }
        if (entity.own.team == '蓝队') {
            blueScore += sunshi
        }
    }

})
function getName(entity) {
    if (entity.titles[0] != '萌新指挥官') {
        return `【${entity.titles[0]}】 ${entity.player.name}`
    } else {
        return entity.player.name
    }
}
function pifuChuLi(pifu1, text, moren) {
    if (pifu['【皮肤】' + pifu1] != undefined) {
        if (pifu['【皮肤】' + pifu1][text] != undefined) {
            return pifu['【皮肤】' + pifu1][text]
        } else {
            return moren;
        }
    } else {
        return moren;
    }
};
function techChuLi(entity = new Box3Entity, type = '', moren = 1, lx = '') {
    try {
        var num = moren;
        for (let aaa in entity.technology) {//遍历那个人的学院科技分类
            for (let i of entity.technology[aaa]) {//在每个分类里找到对应的科技
                if (technology[aaa]) {
                    if (technology[aaa][i]) {
                        if (technology[aaa][i]) {
                            if (technology[aaa][i][type]) {
                                if (technology[aaa][i].lx.includes(lx)) {
                                    num *= technology[aaa][i][type]
                                }
                            }
                        }
                    }
                }
            }
        }
    } catch (e) {
        return moren
    }
    return Math.round(num * 10) / 10
}
async function attVoxelBuild(pos = new Box3Vector3, minSize = 0, maxSize = 1) {
    var voxel = []
    for (let e of world.querySelectorAll('.士兵')) {
        if (Math.ceil(pmDist(e.position, pos)) <= maxSize
            && pmDist(e.position, pos) > minSize) {
            await sleep(1);
            (async function () {
                var x = e.position.x;
                var z = e.position.z
                voxel.push([x, 1, z])
                voxels.setVoxel(x, 1, z, 'red_glass');
                var a = 0
                for (let i = 0; i < 3; i++) {
                    if (maxSize > 30) {
                        i -= 0.5
                    }
                    if (voxels.getVoxelId(x, 1, z) == 0) {
                        a = 1
                        continue;
                    }
                    await sleep(2000)
                }
                if (a == 0) {
                    voxels.setVoxelId(x, 1, z, 0)
                }
            })();
        }
    }
    return voxel
}

function getJunXian(star) {//012，345...
    if (star < 3) {
        return `下等兵 ${star}星`
    }
    if (star < 6) {
        return `中等兵 ${star - 3 + 1}星`
    }
    if (star < 9) {
        return `上等兵 ${star - 6 + 1}星`
    }
    if (star < 14) {
        return `少校 ${star - 9 + 1}星`
    }
    if (star < 19) {
        return `中校 ${star - 14 + 1}星`
    }
    if (star < 24) {
        return `上校 ${star - 19 + 1}星`
    }
    if (star < 31) {
        return `少将 ${star - 24 + 1}星`
    }
    if (star < 38) {
        return `中将 ${star - 31 + 1}星`
    }
    if (star < 45) {
        return `大将 ${star - 38 + 1}星`
    }
    if (star < 55) {
        return `战神 ${star - 45 + 1}星`
    }
    return `战神之神 ${star - 55 + 1}星`
}
function makePlayer() {//伪造一个黑暗军团的玩家
    let entity = new Box3Entity;
    entity.isHAJT = true
    entity.isPlayer = true;
    entity.color = colors['粉紫色']
    entity.titles = ['萌新指挥官']
    entity.player = { 'name': '黑暗军团小兵', };
    return entity
}
async function createHAJTXB() {//黑暗军团小兵
    let pos = new Box3Vector3(0, 0, 0)
    while (1) {
        pos = new Box3Vector3(Math.floor(30 + Math.random() * 216) + 0.5, 1.5, Math.floor(30 + Math.random() * 216) + 0.5)
        if (getSoldier(pos) == '') {
            break;
        }
        await sleep(10)
    }
    createSoldier(makePlayer(),
        pos,
        soldiersList[Math.floor(Math.random() * soldiersList.length)]
    )
}

async function createSoldier(entity = new Box3Entity, position = new Box3Vector3, name = '', states = []) {
    if (dx[voxels.name(voxels.getVoxelId(position.x, 0, position.z - 0.5))].speed[soldiers[name].lx2] > 5) {
        return
    }
    if (states != '') {
        name = states[0]
    }
    var e = world.createEntity({
        mesh: `mesh/${name}.vb`,
        collides: false,
        gravity: false,
        meshScale: new Box3Vector3(1 / 32, 1 / 32, 1 / 32),
        position: position,
    })
    if (soldiers[name].lx2 == '步兵' || name == '墙') {
        e.meshScale = e.meshScale.scale(0.5)
    }
    if (yunShuDanWei.includes(name)) {
        e.sits = []
    }
    e.addTag(name)
    e.addTag(entity.player.name)
    e.addTag('士兵')
    e.name = name
    e.own = entity
    e.hp = 100;
    e.maxHp = 100;
    if (entity.isHAJT) {
        if (yunShuDanWei.includes(e.name) || ziYuanYunShu.includes(e.name) || (soldiers[e.name].lx2 == '设施' && e.name != '防御塔')
            || soldiers[e.name].lx2 == '步兵' || e.name == '工程车') {
            e.destroy()
        }
        e.maxHp = 200;
        e.hp = 200;
        e.addTag('黑暗军团')
        e.addTag('黑暗军团小兵')
        e.particleRate = 5;
        e.particleLifetime = 1;
        e.particleSize = 3
        e.particleVelocity = new Box3Vector3(0, 1, 0)
        e.particleColor = e.own.color;
        (async function () {
            await sleep(5 * 60 * 1000);
            e.destroy();
        })();
    } else {
        e.addTag('玩家士兵')
    }
    e.state = {//CD
        '移动': 0,
        '攻击': 0,
    }
    if (states != '') {
        e.state = states[2]
    }
    e.energy = soldiers[name].energy
    e.food = 100
    if (soldiers[name].lx2 == '设施') {
        e.food = Infinity
    }
    e.enableDamage = true;
    if (e.name == '工程车') {
        e.lingJian = 50
    }
    if (states != '') {
        e.hp = states[1]
        e.food = states[3]
    }
    e.ganran = 0;//是不是被感染瘟疫
    e.hurtTime = 0;
    e.cdTime = 0;//航母等兵种的cd
    e.pifu = e.name//普通皮肤
    e.destroyNot = 1//1的话就是损毁，否则就是不损毁，因为主人来了
    e.enableInteract = true;
    e.interactRadius = 30
    e.position.y = 1.5 + soldiers[e.name].yAdd
    e.ziyuan = [0, 0, 0]//矿，油，粮
    e.onDie(({ attacker }) => {
        if (e.hasTag('黑暗军团小兵')) {
            if (attacker) {
                if (attacker.isPlayer) {
                    var coinNum = Math.floor(200 + Math.random() * 100)
                    var moneyNum = Math.floor(2000 + Math.random() * 3000)
                    var chipNum = Math.floor(Math.random() * 2)
                    let chipIndex = 0;
                    if (Math.random() < 0.6) {
                        attacker.player.directMessage(`你击杀了黑暗军团小兵*1，获得了${soldiers[e.name].lx1}军科技碎片*${chipNum}`)
                        switch (soldiers[e.name].lx1) {
                            case '陆':
                                chipIndex = 1
                                break;
                            case '海':
                                chipIndex = 2
                                break;
                            case '空':
                                chipIndex = 3
                                break;
                        }
                    } else {
                        chipIndex = 0
                        attacker.player.directMessage(`你击杀了黑暗军团小兵*1，获得了综合型科技碎片*${chipNum}个`)
                    }
                    attacker.technology['碎片'][chipIndex]++
                    attacker.coin += coinNum
                    attacker.player.directMessage(`你击杀了黑暗军团小兵*1，获得了${coinNum}个军团币和${moneyNum}个游戏币！`)
                    attacker.money += moneyNum
                }
            }
        }
        world.say(getName(e.own) + '的' + e.pifu + '阵亡');
        e.destroy()
    })
    e.position.y += 0.01
}