猫史档案馆

[Codemao-Minecraft] 官方发布

本章节使用的开源代码[按贡献值由高至低排序]
1 分型地形生成 来自[YDS尹子]的帖子<……/?>
2 三维噪声生成 来自[?]的帖子<……/?>
3 条状:喵面形矿洞生成 来自[YDS尹子]的帖子<……/?>
4 村庄生成 来自[?]的帖子<……/?>
5 指定岩浆湖生成 来自[?]的帖子<……/?>
6 正则种子生成 来自[Unshown]的帖子<Ushown>
特此致谢以上开源代码作者

代码运行基础
1 windows7+/Linuxs11+/IOS+/……
2 Chrome newest/Edge1.1.7+/……

开源申明
MIT License
Copyright (c) [2024] [Codemao-MinecraftWorkGroup]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

效果展示

代码模块
```javascript
/*
 * @2024 Codemao-MinecraftWorkGroup
 * PERFORMANCE: O(size * log(size ^ 2)(size^3) * 3 / 2 + waterLeveal + size ^ 2 * 5) [ms]
 * COMPLEXITY: O(512) [MB]
 */
world.onPlayerJoin(async({entity}) => {
    entity.player.spectator = true;
})

/*高度重写数组*/
var High = [3, 3, 3, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16, 18, 19, 19, 20, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,];

var size = 256;         /*地图大小*/
var waterLevel = 18;    /*水面高度*/
var h = 0.92;           /*粗糙系数[0~1]1为最平滑*/
var d = Math.round(Math.log2(size)) + 1;
var ran = 150;          /*随机取值范围大小，此处为±75*/
var seed = [];

function cor3D(x, y, z) { this.x = x; this.y = y; this.z = z; }

Math.seed = Math.random();

Math.seededRandom = function (max, min) {/*随机数代码*/
    max = max || 1; min = min || 0;
    Math.seed = (Math.seed * 9301 + 49297) % 233280;
    var rnd = Math.seed / 233280.0;
    return (Math.ceil(min + rnd * (max - min)));
}

async function cylinder(vox, cx, cy, cz, radius, height, changeVox) {
    let xend = cx + radius; let yend = cy + height; let zend = cz + radius;
    for (let x = cx - radius; x <= xend; x++) {
        for (let z = cz - radius; z <= zend; z++) {
            let dx = x - cx; let dz = z - cz;
            if (Math.round(Math.sqrt(dx * dx + dz * dz)) <= radius) {
                for (let y = cy; y < yend; y++) {
                    if (!changeVox.includes(voxels.getVoxel(x, y, z))) { voxels.setVoxel(x, y, z, vox); }
                }
            }
        }
    }
    return 0;
}

for (u = 0; u <= 2; u++) {
    for (i = 0; i <= 256; i++) {
        for (j = 0; j <= 256; j++) {
            sandR = Math.floor(Math.seededRandom(7, -40)); sandH = Math.floor(Math.seededRandom(5, 2));
            clayR = Math.floor(Math.seededRandom(5, -120)); clayH = Math.floor(Math.seededRandom(4, 2));
            if (clayR >= 1 && u <= 2 && Math.random() <= 0.8) { cylinder(135, i, u - sandH, j, sandR, sandH, [0, 3喵, 129]); }
            if (clayR >= 1 && u <= 2 && Math.random() <= 0.3) { cylinder(111, i, u - clayH, j, clayR, clayH, [0, 3喵, 129]); }
        }
    }
}

let underwater = new Array();;

for (y = 1; y <= 1; y++) { for (x = 0; x <= 256; x++) { for (z = 0; z <= 256; z++) { underwater[[x, z]] = voxels.getVoxelId(x, y, z); } } }

function classification(pul, pur, pdl, pdr, depth, range) {
    range *= Math.pow(2, -h);
    if (depth == 0) {
        seed.push(pul);
    } else {
        var pm = new cor3D((pur.x + pdl.x) / 2, (pur.y + pdl.y) / 2, (pur.z + pdl.z) / 2);
        var pmu = new cor3D((pur.x + pul.x) / 2, (pur.y + pul.y) / 2, (pur.z + pul.z) / 2);
        var pmd = new cor3D((pdr.x + pdl.x) / 2, (pdr.y + pdl.y) / 2, (pdr.z + pdl.z) / 2);
        var pml = new cor3D((pul.x + pdl.x) / 2, (pul.y + pdl.y) / 2, (pul.z + pdl.z) / 2);
        var pmr = new cor3D((pdr.x + pur.x) / 2, (pdr.y + pur.y) / 2, (pdr.z + pur.z) / 2);
        pm.y += Math.random() * 2 * range - range * 0.9;
        if (depth == d) pm.y = pur.y;
        classification(pml, pm, pdl, pmd, depth - 1, range);
        classification(pm, pmr, pmd, pdr, depth - 1, range);
        classification(pul, pmu, pml, pm, depth - 1, range);
        classification(pmu, pur, pm, pmr, depth - 1, range);
    }
    return;
};

global.tree = function (x, y, z) {
    if (voxels.getVoxelId(x, y, z) != 3喵) {
        var rand = 1;
        voxels.setVoxel(x, y + rand - 1, z, "dirt");
        if (Math.random() >= 0.9) {
            if (Math.random() <= 0.3) voxels.setVoxel(x, y + rand + 2, z + 1, "honeycomb_01");
            if (Math.random() >= 0.3 && Math.random() <= 0.7) voxels.setVoxel(x, y + rand + 2, z - 1, "honeycomb_01");
            if (Math.random() >= 0.7 && Math.random() <= 0.9) voxels.setVoxel(x + 1, y + rand + 2, z, "honeycomb_01");
            if (Math.random() >= 0.9 && Math.random() <= 1) voxels.setVoxel(x - 1, y + rand + 2, z, "honeycomb_01");
            if (Math.random() <= 0.3) voxels.setVoxel(x, y + rand + 2, z + 1, "honeycomb_01");
            if (Math.random() >= 0.3 && Math.random() <= 0.7) voxels.setVoxel(x, y + rand + 2, z - 1, "honeycomb_01");
            if (Math.random() >= 0.7 && Math.random() <= 0.9) voxels.setVoxel(x + 1, y + rand + 2, z, "honeycomb_01");
            if (Math.random() >= 0.9 && Math.random() <= 1) voxels.setVoxel(x - 1, y + rand + 2, z, "honeycomb_01");
        }
        for (let i = 3 + rand; i < 5 + rand; i++) {
            for (let j = -2; j < 3; j++) {
                for (let k = -2; k < 3; k++) {
                    if (Math.random() >= 0.5) {
                        voxels.setVoxel(x + j, y + i, z + k, "green_leaf");
                    } else {
                        voxels.setVoxel(x + j, y + i, z + k, "leaf_05");
                    }
                }
            }
        }
        for (let j = -1; j < 2; j++) {
            for (let k = -1; k < 2; k++) {
                if (Math.random() >= 0.5) {
                    voxels.setVoxel(x + j, y + 5 + rand, z + k, "green_leaf");
                } else {
                    voxels.setVoxel(x + j, y + 5 + rand, z + k, "leaf_05");
                }
            }
        }
        if (Math.random() >= 0.5) {
            voxels.setVoxel(x - 1, y + 6 + rand, z, "green_leaf"); voxels.setVoxel(x, y + 6 + rand, z, "green_leaf"); voxels.setVoxel(x + 1, y + 6 + rand, z, "green_leaf"); voxels.setVoxel(x, y + 6 + rand, z - 1, "green_leaf"); voxels.setVoxel(x, y + 6 + rand, z + 1, "green_leaf");
        } else {
            voxels.setVoxel(x - 1, y + 6 + rand, z, "leaf_05"); voxels.setVoxel(x, y + 6 + rand, z, "leaf_05"); voxels.setVoxel(x + 1, y + 6 + rand, z, "leaf_05"); voxels.setVoxel(x, y + 6 + rand, z - 1, "leaf_05"); voxels.setVoxel(x, y + 6 + rand, z + 1, "leaf_05");
        }
        for (let i = y + rand; i < y + 5 + rand; i++) {
            voxels.setVoxel(x, i, z, "acacia");
        }
        return 1
    }
};

async function spawnTree() {
    for (let i = 0; i < 257; i++) {
        for (let j = 0; j < 257; j++) {
            for (let k = 0; k < 喵; k++) {
                if (voxels.getVoxelId(i, k, j) == 127 || (voxels.getVoxelId(i, k, j) == 125 && voxels.getVoxelId(i, k, j) == 0)) {
                    if (Math.random() * 150 <= 0.9) {
                        tree(i, k, j);
                    }
                }
            }
        }
        await sleep(4);
    }
}

function random(things) {
    random_number = Math.random();
    if (things == 2) {
        if (random_number < 0.45) {
            return 0;
        } else {
            return 1;
        }
    } else if (things == 4) {
        if (random_number > 0.75) {
            return 1;
        } else if (random_number <= 0.75 && random_number > 0.5) {
            return 2;
        } else if (random_number <= 0.5 && random_number > 0.35) {
            return 3;
        } else {
            return 4;
        }
    }
}

function sugarcane(x, y, z) {//甘蔗
    var gz = random(4);
    for (var gzs = y + 1; gzs < gz + y + 2; gzs++) {
        voxels.setVoxel(x, gzs, z, "bamboo")
    }
    return 0;
}

(async function () {
    classification(new cor3D(0, 22, size * 2), new cor3D(size * 2, 22, size * 2), new cor3D(0, 22, 0), new cor3D(size * 2, 22, 0), d, ran);
    for (let i = 0; i < seed.length / 4; i++) {
        var y = seed[i].y;
        if (y >= 36 && y <= 40) {
            y = y + 0.5 * ((y - 36) / 4);
            y = Math.round(y);
            if (Math.random() < ((40 - 1.2 * y) / 10 * 1.1)) {
                voxels.setVoxel(seed[i].x, y - 2, seed[i].z, "grass");
            } else {
                voxels.setVoxel(seed[i].x, y - 2, seed[i].z, "dirt");
            }
            for (let j = 0; j < y - 2; j++) {
                voxels.setVoxel(seed[i].x, j, seed[i].z, "stone");
            }
        } else if (y <= 36) {
            y = Math.round(y);
            y = High[y];
            if (y > waterLevel) {
                voxels.setVoxel(seed[i].x, y, seed[i].z, "grass");
            } else if (y == waterLevel) {
                voxels.setVoxel(seed[i].x, y, seed[i].z, "sand");
            } else if (y < waterLevel) {
                voxels.setVoxel(seed[i].x, y, seed[i].z, "dirt");
                var w = y;
                while (w < waterLevel) {
                    w++;
                    voxels.setVoxelId(seed[i].x, w, seed[i].z, 3喵);
                }
            } else {
                var w = 1;
                while (w < waterLevel) {
                    w++;
                    voxels.setVoxelId(seed[i].x, w, seed[i].z, 3喵);
                }
            }

            for (let j = y - 3; j < y; j++) {
                voxels.setVoxel(seed[i].x, j, seed[i].z, "dirt");
            }

            Math.random() < 0.024 ? await sleep(1) : null;

            for (let j = 0; j < y - 3; j++) {
                voxels.setVoxel(seed[i].x, j, seed[i].z, "stone");
            }
        } else if (y >= 40 && y <= 45) {
            y = y * 1.00000001;
            y = Math.round(y);
            if (y >= 43 && y <= 45) {
                voxels.setVoxel(seed[i].x, y, seed[i].z, "white_grass");
                for (let j = 0; j < y; j++) {
                    voxels.setVoxel(seed[i].x, j, seed[i].z, "stone");
                }
            } else if (Math.random() < ((y - 40) / 5 * 0.4)) {
                voxels.setVoxel(seed[i].x, y, seed[i].z, "stone");
                for (let j = 0; j < y; j++) {
                    voxels.setVoxel(seed[i].x, j, seed[i].z, "stone");
                }
            } else {
                voxels.setVoxel(seed[i].x, y, seed[i].z, "dirt");
                for (let j = y - 1; j < y; j++) {
                    voxels.setVoxel(seed[i].x, j, seed[i].z, "dirt");
                }
                for (let j = 0; j < y - 1; j++) {
                    voxels.setVoxel(seed[i].x, j, seed[i].z, "stone");
                }
            }
            Math.random() < 0.024 ? await sleep(2) : null;
        } else if (y >= 45) {
            y = 90 - y;
            if (y > 50) y += 0.01 * y + 1
            if (y > 60) y += 0.02 * y + 2
            y = Math.round(y);
            for (let j = y - 2; j < y; j++) {
                voxels.setVoxel(seed[i].x, j, seed[i].z, "sand");
            }
            for (let j = y - 4; j < y - 2; j++) {
                voxels.setVoxel(seed[i].x, j, seed[i].z, "snow");
            }
            for (let j = 0; j < y - 4; j++) {
                voxels.setVoxel(seed[i].x, j, seed[i].z, "stone");
            }
            for (let j = y; j < 45; j++) {
                voxels.setVoxelId(seed[i].x, j, seed[i].z, 3喵);
                if (y >= 43 && y <= 44 && j == 44) voxels.setVoxel(seed[i].x, j, seed[i].z, "ice");
            }
        }

        Math.random() < 0.024 ? await sleep(2) : null;
    }

    for (y = 0; y <= waterLevel; y++) {
        for (x = 0; x <= 256; x++) {
            for (z = 0; z <= 256; z++) {
                if (voxels.getVoxelId(x, y, z) != 3喵 && voxels.getVoxelId(x, y, z) != 0 && voxels.getVoxelId(x, y + 1, z) == 3喵) voxels.setVoxelId(x, y, z, underwater[[x, z]]);
            }
        }
    }


    for (var turn_number = 1; turn_number <= 1; turn_number++) {
        for (var y = 0; y < 喵; y++) {
            for (var x = 1; x < size - 1; x++) {
                for (var z = 1; z < size - 1; z++) {
                    var fk = 0;
                    if (voxels.getVoxelId(x, y, z) != 0 && voxels.getVoxelId(x, y, z) != 129 && voxels.getVoxelId(x, y, z) != 327 && voxels.getVoxelId(x, y, z) != 129) {
                        if (voxels.getVoxelId(x + 1, y, z) == 0) {
                            fk++;
                        }

                        if (voxels.getVoxelId(x - 1, y, z) == 0) {
                            fk++;
                        }

                        if (voxels.getVoxelId(x, y, z + 1) == 0) {
                            fk++;
                        }

                        if (voxels.getVoxelId(x, y, z + 1) == 0) {
                            fk++;
                        }

                        if (fk >= 3) {
                            var voxel = voxels.getVoxel(x, y, z);
                            voxels.setVoxel(x, y, z, 0);
                            if (voxels.name(voxels.getVoxel(x, y - 1, z)) == "dirt" || voxels.name(voxels.getVoxel(x, y - 1, z)) == "stone") {
                                voxels.setVoxel(x, y - 1, z, voxel);
                            }
                        }
                    }
                }
            }
        }
        await sleep(10);
    }

    //基岩
    for (x = 0; x <= 257; x++) {
        for (y = 0; y <= 0; y++) {
            for (z = 0; z <= 257; z++) {
                voxels.setVoxel(x, y, z, "stone_brick_02");
            }
        }
    }

    for (x = 0; x <= 257; x++) {
        for (y = 1; y <= 2; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (1 - y) / 2 + 0.6) {
                    voxels.setVoxel(x, y, z, "stone_brick_02");
                }
            }
        }
    }

    //煤矿
    for (x = 0; x <= 257; x++) {
        for (y = 4; y <= 喵; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= 0.00035 * 5) Setmineral(0, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    for (x = 0; x <= 257; x++) {
        for (y = 11; y <= 喵; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (0.00032 * 4 - (y * 0.00001 / 2))) Setmineral(0, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    //铁矿
    for (x = 0; x <= 257; x++) {
        for (y = 6; y <= 48; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (0.00032 * 5 - (y * 0.00001 / 2))) Setmineral(1, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    //金矿
    for (x = 0; x <= 257; x++) {
        for (y = 11; y <= 32; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (0.0002 * 3 - (y * 0.00001 / 2))) Setmineral(2, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    //钻石矿
    for (x = 0; x <= 257; x++) {
        for (y = 7; y <= 14; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (0.00012 * 5 - (y * 0.00001 / 2))) Setmineral(3, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    //红石矿
    for (x = 0; x <= 257; x++) {
        for (y = 2; y <= 12; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (0.00012 * 5 - (y * 0.00001 / 2))) Setmineral(4, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    //青金石矿
    for (x = 0; x <= 257; x++) {
        for (y = 2; y <= 16; y++) {
            for (z = 0; z <= 257; z++) {
                if (Math.random() <= (0.00022 * 2 - (y * 0.00001 / 2))) Setmineral(5, x, y, z);
                Math.random() <= 0.0001 ? await sleep(1/20) : null;
            }
        }
    }

    await sleep(100);

    for (var i = 0; i < (random(4) + 8 + random(4)); i++) {
        await buildCave(Math.random() * 10 + 6);
    }

    await asteroid(72, "air");
    await asteroid(72, "strawberry_juice");
    await sleep(100);
    await spawnTree();

    for (var y = 0; y < waterLevel + 8; y++) {
        for (var x = 0; x < size; x++) {
            for (var z = 0; z < size; z++) {
                if ((voxels.name(voxels.getVoxelId(x, y, z)) == "sand" && voxels.name(voxels.getVoxelId(x, y + 1, z)) != "water") && (voxels.name(voxels.getVoxelId(x, y, z - 1)) == "water" || (voxels.name(voxels.getVoxelId(x, y, z + 1)) == "water" || voxels.name(voxels.getVoxelId(x - 1, y, z)) == "water" || voxels.name(voxels.getVoxelId(x + 1, y, z)) == "water")) && Math.random() <= 0.07) {
                    await sugarcane(x, y, z);
                }
            }
        }
    }

    await spawnVillage();

    console.log("----[World Ending]----");

})();

async function Setmineral(mineral, x, y, z) {

    var v = voxels.getVoxelId(x, y, z);

    if (v == 0 || v == 3喵 || v == 125 || v == 539 || v == 398 || v == 127 || v == 135 || v == 169 || v == 111) return mineral;

    await sleep(1);

    if (mineral == 0) {
        const count = random(4);
        voxels.setVoxelId(x, y, z, 95);
        if (count == 1) {
            if (Math.random() <= 0.2) {
                Setmineral(0, x, y + 1, z);
            } else {
                Setmineral(0, x + 1, y, z);
            }
        } else if (count == 2) {
            if (Math.random() <= 0.6) {
                Setmineral(0, x - 1, y, z);
            } else {
                Setmineral(0, x, y, z + 1);
            }
        } else if (count == 3) {
            if (Math.random() <= 0.2) {
                Setmineral(0, x, y, z - 1);
            } else {
                Setmineral(0, x + 1, y, z);
            }
        } else {
            if (Math.random() <= 0.8) {
                Setmineral(0, x, y, z - 1);
            } else {
                return mineral;
            }
        }
    } else if (mineral == 1) {
        const count = random(4);
        voxels.setVoxelId(x, y, z, 387);
        if (count == 1) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z - 1, 387);
                Setmineral(1, x, y, z);
            } else {
                voxels.setVoxelId(x, y - 1, z, 387);
                Setmineral(1, x, y, z);
            }
        } else if (count == 2) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z + 1, 387);
                Setmineral(1, x, y, z);
            } else {
                voxels.setVoxelId(x + 1, y, z, 387);
                Setmineral(1, x, y, z);
            }

        } else if (count == 3) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y + 1, z, 387);
                Setmineral(1, x, y, z);
            } else {
                voxels.setVoxelId(x - 1, y, z, 387);
                Setmineral(1, x, y, z);
            }
        } else {
            if (Math.random() <= 0.5) {
                Setmineral(1, x, y, z);
            } else {
                return;
            }
        }
    } else if (mineral == 2) {
        const count = random(4);
        voxels.setVoxelId(x, y, z, 119);
        if (count == 1) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z - 1, 119);
                Setmineral(2, x, y, z);
            } else {
                voxels.setVoxelId(x, y - 1, z, 119);
                Setmineral(2, x, y, z);
            }
        } else if (count == 2) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z + 1, 119);
                Setmineral(2, x, y, z);
            } else {
                voxels.setVoxelId(x + 1, y, z, 119);
                Setmineral(2, x, y, z);
            }

        } else if (count == 3) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y + 1, z, 119);
                Setmineral(2, x, y, z);
            } else {
                voxels.setVoxelId(x - 1, y, z, 119);
                Setmineral(2, x, y, z);
            }
        } else {
            if (Math.random() <= 0.5) {
                Setmineral(2, x, y, z);
            } else {
                return;
            }
        }
    } else if (mineral == 3) {
        const count = random(4);
        voxels.setVoxelId(x, y, z, 91);
        if (count == 1) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z - 1, 91);
                Setmineral(3, x, y, z);
            } else {
                voxels.setVoxelId(x, y - 1, z, 91);
                Setmineral(3, x, y, z);
            }
        } else if (count == 2) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z + 1, 91);
                Setmineral(3, x, y, z);
            } else {
                voxels.setVoxelId(x + 1, y, z, 91);
                Setmineral(3, x, y, z);
            }

        } else if (count == 3) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y + 1, z, 91);
                Setmineral(3, x, y, z);
            } else {
                voxels.setVoxelId(x - 1, y, z, 91);
                Setmineral(3, x, y, z);
            }
        } else {
            if (Math.random() <= 0.4) {
                Setmineral(3, x, y, z);
            } else {
                return;
            }
        }
    } else if (mineral == 4) {
        const count = random(4);
        voxels.setVoxelId(x, y, z, 105);
        if (count == 1) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z - 1, 105);
                Setmineral(4, x, y, z);
            } else {
                voxels.setVoxelId(x, y - 1, z, 105);
                Setmineral(4, x, y, z);
            }
        } else if (count == 2) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z + 1, 105);
                Setmineral(4, x, y, z);
            } else {
                voxels.setVoxelId(x + 1, y, z, 105);
                Setmineral(4, x, y, z);
            }

        } else if (count == 4) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y + 1, z, 105);
                Setmineral(4, x, y, z);
            } else {
                voxels.setVoxelId(x - 1, y, z, 105);
                Setmineral(4, x, y, z);
            }
        } else {
            if (Math.random() <= 0.4) {
                Setmineral(4, x, y, z);
            } else {
                return;
            }
        }
    } else if (mineral == 5) {
        const count = random(4);
        voxels.setVoxelId(x, y, z, 113);
        if (count == 1) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z - 1, 113);
                Setmineral(5, x, y, z);
            } else {
                voxels.setVoxelId(x, y - 1, z, 113);
                Setmineral(5, x, y, z);
            }
        } else if (count == 2) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y, z + 1, 113);
                Setmineral(5, x, y, z);
            } else {
                voxels.setVoxelId(x + 1, y, z, 113);
                Setmineral(5, x, y, z);
            }

        } else if (count == 4) {
            if (Math.random() <= 0.5) {
                voxels.setVoxelId(x, y + 1, z, 113);
                Setmineral(5, x, y, z);
            } else {
                voxels.setVoxelId(x - 1, y, z, 113);
                Setmineral(5, x, y, z);
            }
        } else {
            if (Math.random() <= 0.4) {
                Setmineral(5, x, y, z);
            } else {
                return;
            }
        }
    }
    return mineral;
}

async function buildCave(num) {
    var starPos = new GameVector3(24 + Math.random() * 200, 65, 24 + Math.random() * 200);
    for (let i = 62; i > 0; i--) {
        if (voxels.getVoxelId(starPos.x, i, starPos.z) == voxels.id("grass")) {
            starPos.y = i - 10 + Math.random() * 10;
            break;
        }
    }
    var ang = [Math.random() * 360, -15];
    for (let i = 0; i < num; i++) {
        await sleep(10);
        cave(4 + Math.random() * 1, starPos);
        if (i % 5 != 0) {
            ang[0] += Math.random() * 50 - 25;

            if (starPos.y > 15)
                ang[1] += Math.random() * 4 - 2;
            else {
                ang[1] += Math.random() * 4 + 10;
            }
        } else {
            ang[0] += Math.random() * 180 - 90;
            ang[1] += Math.random() * 10 - 5;
        }
        ang[0] %= 360;


        var delta = new GameVector3(Math.sin(ang[0] * Math.PI / 180), Math.sin(ang[1] * Math.PI / 180), Math.cos(ang[0] * Math.PI / 180)).scale(5);
        starPos.x += delta.x;
        starPos.y += delta.y;
        starPos.z += delta.z;
    }
    await sleep(200);
}
function cave(r, pos) {
    var block = 0;
    for (let i = pos.x - r; i <= pos.x + r; i++) {
        for (let j = pos.z - r; j <= pos.z + r; j++) {
            for (let k = pos.y - r; k <= pos.y + r; k++) {
                if (new GameVector3(i, k, j).distance(pos) <= r && voxels.getVoxelId(i, k + 1, j) != voxels.id("water")) {
                    if (voxels.getVoxelId(i, k, j) != 3喵 && k >= 3) {
                        voxels.setVoxel(i, k, j, block);
                    }
                }
            }
        }
    }
}

let dense = 2 //数字越大房屋越多

//建筑代码
async function village(x, y, z) {
    if (voxels.getVoxel(x, y, z) != voxels.id("water")) {
        //立方
        for (ax = x - 2; ax <= x + 2; ax++) {
            for (az = z - 2; az <= z + 2; az++) {
                for (ay = y; ay <= y + 5; ay++) {
                    voxels.setVoxel(ax, ay, az, 'plank_02')
                }
            }
        }
        //空心
        for (ax = x - 1; ax <= x + 1; ax++) {
            for (az = z - 1; az <= z + 1; az++) {
                for (ay = y + 1; ay <= y + 5; ay++) {
                    voxels.setVoxel(ax, ay, az, 'air')
                }
            }
        }
        //天花板
        for (ax = x - 3; ax <= x + 3; ax++) {
            for (az = z - 3; az <= z + 3; az++) {
                voxels.setVoxel(ax, y + 5, az, 'board_04')
            }
        }
        //角柱
        for (by = y; by <= y + 4; by++) {
            voxels.setVoxel(x + 2, by, z + 2, 'wood')
            voxels.setVoxel(x - 2, by, z + 2, 'wood')
            voxels.setVoxel(x + 2, by, z - 2, 'wood')
            voxels.setVoxel(x - 2, by, z - 2, 'wood')
        }
        //窗户和门的朝向
        let i = Math.random()
        if (i > 0.75) {
            voxels.setVoxel(x + 2, y + 1, z, 'air')
            voxels.setVoxel(x + 2, y + 2, z, 'air')
            voxels.setVoxel(x - 2, y + 2, z, 'glass')
            voxels.setVoxel(x - 2, y + 2, z + 1, 'glass')
            voxels.setVoxel(x - 2, y + 2, z - 1, 'glass')
            voxels.setVoxel(x + 3, y + 4, z, 'palace_lamp')
        } else if (i > 0.5) {
            voxels.setVoxel(x - 2, y + 1, z, 'air')
            voxels.setVoxel(x - 2, y + 2, z, 'air')
            voxels.setVoxel(x + 2, y + 2, z, 'glass')
            voxels.setVoxel(x + 2, y + 2, z + 1, 'glass')
            voxels.setVoxel(x + 2, y + 2, z - 1, 'glass')
            voxels.setVoxel(x - 3, y + 4, z, 'palace_lamp')
        } else if (i > 0.25) {
            voxels.setVoxel(x, y + 1, z + 2, 'air')
            voxels.setVoxel(x, y + 2, z + 2, 'air')
            voxels.setVoxel(x, y + 2, z - 2, 'glass')
            voxels.setVoxel(x + 1, y + 2, z - 2, 'glass')
            voxels.setVoxel(x - 1, y + 2, z - 2, 'glass')
            voxels.setVoxel(x, y + 4, z + 3, 'palace_lamp')
        } else {
            voxels.setVoxel(x, y + 1, z - 2, 'air')
            voxels.setVoxel(x, y + 2, z - 2, 'air')
            voxels.setVoxel(x, y + 2, z + 2, 'glass')
            voxels.setVoxel(x - 1, y + 2, z + 2, 'glass')
            voxels.setVoxel(x + 1, y + 2, z + 2, 'glass')
            voxels.setVoxel(x, y + 4, z - 3, 'palace_lamp')
        }
        //屋内灯和箱子
        voxels.setVoxel(x + 1, y + 4, z + 1, 'lantern_01')
        voxels.setVoxel(x - 1, y + 4, z + 1, 'lantern_01')
        voxels.setVoxel(x + 1, y + 4, z - 1, 'lantern_01')
        voxels.setVoxel(x - 1, y + 4, z - 1, 'lantern_01')
        voxels.setVoxel(x - 1, y + 1, z - 1, 'treasure_chest', (Math.floor(Math.random() * 4) + 1))
    }
};

//生成代码
async function spawnVillage() {
    let Yon = false
    for (let i = 0; i < 256; i++) {
        for (let j = 0; j < 256; j++) {
            for (let k = 0; k < 56; k++) {
                if (voxels.getVoxel(i, k, j) == voxels.id("grass")) {
                    for (xx = i - 8; xx <= i + 8; xx++) {
                        for (zz = j - 8; zz <= j + 8; zz++) {
                            if (voxels.getVoxel(xx, k, zz) != voxels.id("plank_02") && voxels.getVoxel(xx, k, zz) != voxels.id("air")) {
                                Yon = true
                            } else {
                                Yon = false
                            }
                        }
                    }
                    if (Yon) {
                        if (Math.random() * Math.floor(1000 / dense) <= 1) {
                            village(i, k, j);
                        }
                    }
                }
            }
        }
    }
};

function per_1dim(dots, interval) {
    var dot1, dot2, dif;
    var y = [];
    var i, j;
    for (i = 1; i < dots.length; i++) {
        dot1 = dots[i];
        dot2 = dots[i - 1];
        dif = Math.abs(dot1 - dot2);
        if (dot1 < dot2) {
            for (j = 0; j <= 3.14; j += 3.14 / interval) {
                y.push(dot2 + (Math.cos(j) - 1) / 2 * dif);
            }
        } else {
            for (j = 3.14; j >= 0; j -= 3.14 / interval) {
                y.push(dot2 + (Math.cos(j) + 1) / 2 * dif);
            }
        }
    }
    return y;
}
function per_2dim(interval, min, max) {
    var dots = [], y1 = [], y2 = [], y3 = [];
    var x, y, z;
    for (x = 0; x <= 256; x += interval) {
        dots.push([]);
        for (z = 0; z <= 256; z += interval) {
            y = min + Math.random() * (max - min);
            dots[x / interval].push(y);
        }
    }
    for (x = 0; x <= 256; x += interval) {
        y1.push(per_1dim(dots[x / interval], interval));
    }
    for (x = 0; x <= 256; x++) {
        y2.push([]);
        for (z = 0; z <= 256; z += interval) {
            y2[x].push(y1[z / interval][x]);
        }
    }
    for (x = 0; x <= 256; x++) {
        y3.push(per_1dim(y2[x], interval));
    }
    return y3;
}
function per_3dim(interval, min, max) {
    var y1 = [], y2 = [], y3 = [];
    var x, y, z;
    for (y = 0; y <= 喵; y += interval) {
        y1.push(per_2dim(interval, min, max));
    }
    for (x = 0; x <= 256; x++) {
        y2.push([]);
        for (z = 0; z <= 256; z++) {
            y2[x].push([]);
            for (y = 0; y <= 喵; y += interval) {
                y2[x][z].push(y1[y / interval][x][z]);
            }
        }
    }
    for (x = 0; x <= 256; x++) {
        y3.push([]);
        for (z = 0; z <= 256; z++) {
            y3[x].push(per_1dim(y2[x][z], interval));
        }
    }
    return y3;
}
async function asteroid(density, v) {
    var x, y, z;
    var per32 = per_3dim(32, 0, 100);
    var per16 = per_3dim(16, 0, 100);
    var per8 = per_3dim(8, 0, 100);
    var l = [];
    for (x = 0; x <= 256; x++) {
        l.push([]);
        for (z = 0; z <= 256; z++) {
            l[x].push([]);
            for (y = 0; y <= 40; y++) {
                l[x][z].push(Math.ceil((per32[x][z][y] + per16[x][z][y] + per8[x][z][y]) / 3));
            }
        }
    }
    for (x = 0; x <= 256; x++) {
        for (z = 0; z <= 256; z++) {
            for (y = 0; y <= 40; y++) {
                if (l[x][z][y] > density) {
                    if (voxels.getVoxelId(x, y, z) != 3喵 && y >= 3 && voxels.getVoxelId(x, y + 1, z) != 3喵 && voxels.getVoxelId(x, y, z) != 0) {
                        if (v != "strawberry_juice") {
                            voxels.setVoxel(x, y, z, v)
                        } else if (y < waterLevel - 3) {
                            voxels.setVoxel(x, y, z, v)
                        }
                    };
                }
            }
        }
        await sleep(2);
    }
}

Math.seed = Math.round(Math.random() * 100000)
Math.seededRandom = function (max, min) {
    max = max || 1;
    min = min || 0

    Math.seed = (Math.seed * 9301 + 49297) % 233280;
    var rnd = Math.seed / 233280.0;

    return (Math.ceil(min + rnd * (max - min)))
}
lapoolmap = new Array(11).fill([]);
lapoolmapN = new Array(11).fill([]);
for (k = 0; k <= 11; k++) {
    lapoolmap[k] = []
    lapoolmapN[k] = []
}
function lavapoolswanp(x, y, z) {
    for (k = 0; k <= 11; k++) {
        for (b = 0; b <= 11; b++) {
            lapoolmap[k][b] = 0
            lapoolmapN[k][b] = 0
        }
    }
    for (i = 2; i < 9; i++) {
        for (j = 2; j < 9; j++) {
            lapoolmap[i][j] = 0
            ran = Math.round(Math.seededRandom(70, 30) / 100)
            lapoolmap[i][j] = ran
        }
    }
    for (k = 0; k < 4; k++) {
        for (i = 1; i < 10; i++) {
            for (j = 1; j < 10; j++) {
                if (lapoolmap[i - 1][j - 1] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i][j - 1] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i + 1][j - 1] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i - 1][j] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i + 1][j] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i - 1][j + 1] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i][j + 1] == 1) {
                    lapoolmapN[i][j]++
                }
                if (lapoolmap[i + 1][j + 1] == 1) {
                    lapoolmapN[i][j] += 1
                }
            }
        }
        for (i = 1; i < 10; i++) {
            for (j = 1; j < 10; j++) {
                if (lapoolmapN[i][j] <= 3) {
                    lapoolmap[i][j] = 0
                } else if (lapoolmapN[i][j] >= 5) {
                    lapoolmap[i][j] = 1
                }
                lapoolmapN[k][b] = 0
            }
        }
    }
    for (i = 0; i < 11; i++) {
        for (j = 0; j < 11; j++) {
            if (lapoolmap[i][j] == 1) {
                if (lapoolmap[i - 1][j] == 0 || lapoolmap[i + 1][j] == 0) {
                    lapoolmap[i][j] = 2
                }
                if (lapoolmap[i][j - 1] == 0 || lapoolmap[i][j + 1] == 0) {
                    lapoolmap[i][j] = 2
                }
            }
        }
    }
    for (i = 0; i < 11; i++) {
        for (j = 0; j < 11; j++) {
            if (lapoolmap[i][j] == 1) {
                if (lapoolmap[i - 1][j] == 2 || lapoolmap[i + 1][j] == 2) {
                    lapoolmap[i][j] = 3
                }
                if (lapoolmap[i][j - 1] == 2 || lapoolmap[i][j + 1] == 2) {
                    lapoolmap[i][j] = 3
                }
            }
        }
    }
    for (i = 0; i < 11; i++) {
        for (j = 0; j < 11; j++) {
            if (lapoolmap[i][j] == 1) {
                lapoolmap[i][j] = 4
            }
        }
    }
    for (i = 0; i < 11; i++) {
        for (j = 0; j < 11; j++) {
            if (lapoolmap[i][j] == 2) {
                voxels.setVoxel(i + x - 5, y, j + z - 5, 129)
            }
            if (lapoolmap[i][j] == 3) {
                voxels.setVoxel(i + x - 5, y, j + z - 5, 412)
                voxels.setVoxel(i + x - 5, y - 1, j + z - 5, 129)
            }
            if (lapoolmap[i][j] == 4) {
                voxels.setVoxel(i + x - 5, y, j + z - 5, 412)
                voxels.setVoxel(i + x - 5, y - 1, j + z - 5, 412)
                voxels.setVoxel(i + x - 5, y - 2, j + z - 5, 129)
            }
        }
    }
}
```

@Codemao-MinecraftWorkGroup