Minecraft的世界生成过程（六）村庄

蔚落 2022-06-18 07:51 248阅读 0赞

本篇内容是生成村庄，生成其他建筑的过程也差不多就不研究了（代码太多也研究不完）

# 构造村庄组件数据 #

它的recursiveGenerate继承自这里，类名`net.minecraft.world.gen.structure.MapGenStructure`

// 只是生成结构数据，暂时不操作方块
        protected final void recursiveGenerate(World worldIn, final int chunkX, final int chunkZ, int p_180701_4_, int p_180701_5_, ChunkPrimer chunkPrimerIn)
        {
            // 尝试载入保存的结构数据
            this.func_143027_a(worldIn);
    
            // 载入失败则生成
            if (!this.structureMap.containsKey(Long.valueOf(ChunkCoordIntPair.chunkXZ2Int(chunkX, chunkZ))))
            {
                this.rand.nextInt();
    
                try
                {
                    // 子类实现判断能否生成
                    if (this.canSpawnStructureAtCoords(chunkX, chunkZ))
                    {
                        // 子类实现的生成数据
                        StructureStart structurestart = this.getStructureStart(chunkX, chunkZ);
                        this.structureMap.put(Long.valueOf(ChunkCoordIntPair.chunkXZ2Int(chunkX, chunkZ)), structurestart);
                        // 保存数据
                        this.func_143026_a(chunkX, chunkZ, structurestart);
                    }
                }
                catch (Throwable throwable)
                {
                    // ...
                }
            }
        }

村庄构造流程是这样的：计算村庄里的组件（田、房子、铁匠铺等），构造水井，构造水井周围的道路，沿着道路随机选之前计算好的组件来构造或者构造新的道路

类名`net.minecraft.world.gen.structure.MapGenVillage`

protected boolean canSpawnStructureAtCoords(int chunkX, int chunkZ)
        {
            int _chunkX = chunkX;
            int _chunkZ = chunkZ;
    
            // field_82665_g是村庄平均距离，默认=32
            // field_82666_h是村庄最小距离，默认=8
            // 所以在坐标为n * 32 + 12的区块附近比较可能找到村庄
    
            // 防止在原点附近生成的村庄可能靠太近
    
            if (chunkX < 0)
            {
                chunkX -= this.field_82665_g - 1;
            }
    
            if (chunkZ < 0)
            {
                chunkZ -= this.field_82665_g - 1;
            }
    
            // 注意这是整数除法
            int keyChunkX = chunkX / this.field_82665_g;
            int keyChunkZ = chunkZ / this.field_82665_g;
            // 设置世界随机种子并返回Random对象
            Random random = this.worldObj.setRandomSeed(keyChunkX, keyChunkZ, 10387312);
            // 附近可以生成村庄的区块坐标
            // keyChunkXZ * field_82665_g后变成了field_82665_g的倍数
            keyChunkX = keyChunkX * this.field_82665_g + random.nextInt(this.field_82665_g - this.field_82666_h);
            keyChunkZ = keyChunkZ * this.field_82665_g + random.nextInt(this.field_82665_g - this.field_82666_h);
    
            if (_chunkX == keyChunkX && _chunkZ == keyChunkZ)
            {
                // 判断生物群系是否可以生成村庄
                return this.worldObj.getWorldChunkManager().areBiomesViable(_chunkX * 16 + 8, _chunkZ * 16 + 8, 0, villageSpawnBiomes);
            }
    
            return false;
        }
    
        protected StructureStart getStructureStart(int chunkX, int chunkZ)
        {
            // terrainType默认为0，超平坦为1，影响村庄各组件数量
            // 读取用的键名为size，所以后面就叫size了
            return new MapGenVillage.Start(this.worldObj, this.rand, chunkX, chunkZ, this.terrainType);
        }
    
        public static class Start extends StructureStart { 
                /** well ... thats what it does */
                private boolean hasMoreThanTwoComponents;
    
                public Start()
                {
                }
    
                public Start(World worldIn, Random rand, int x, int z, int size)
                {
                    super(x, z);
                    // 计算这个村庄的组件
                    List<StructureVillagePieces.PieceWeight> pieces = StructureVillagePieces.getStructureVillageWeightedPieceList(rand, size);
                    // 构造水井
                    StructureVillagePieces.Start startComponent = new StructureVillagePieces.Start(worldIn.getWorldChunkManager(), 0, rand, x * 16 + 2, z * 16 + 2, pieces, size);
                    this.components.add(startComponent);
                    // 这里构造了水井周围的道路并加入components和field_74930_j
                    startComponent.buildComponent(startComponent, this.components, rand);
    
                    // 构造子组件（一开始只有道路）
    
                    List<StructureComponent> list1 = startComponent.field_74930_j;
                    List<StructureComponent> list2 = startComponent.field_74932_i;
    
                    // 优先构造list1的组件（道路），然后构造list2的
                    while (!list1.isEmpty() || !list2.isEmpty())
                    {
                        if (list1.isEmpty())
                        {
                            // 随机顺序
                            int i = rand.nextInt(list2.size());
                            StructureComponent structurecomponent = (StructureComponent)list2.remove(i);
                            structurecomponent.buildComponent(startComponent, this.components, rand);
                        }
                        else
                        {
                            int j = rand.nextInt(list1.size());
                            StructureComponent structurecomponent2 = (StructureComponent)list1.remove(j);
                            structurecomponent2.buildComponent(startComponent, this.components, rand);
                        }
                    }
    
                    // 计算包围盒，使所有组件在包围盒内
                    this.updateBoundingBox();
    
                    // 计算除了道路的组件数量
    
                    int componentCount = 0;
    
                    for (StructureComponent component : this.components)
                    {
                        if (!(component instanceof StructureVillagePieces.Road))
                        {
                            ++componentCount;
                        }
                    }
    
                    this.hasMoreThanTwoComponents = componentCount > 2;
                }
    
                // ...
            }

类名`net.minecraft.world.gen.structure.StructureVillagePieces`

// 计算这个村庄的组件
        public static List<StructureVillagePieces.PieceWeight> getStructureVillageWeightedPieceList(Random random, int size)
        {
            List<StructureVillagePieces.PieceWeight> list = Lists.<StructureVillagePieces.PieceWeight>newArrayList();
            // 后两个参数是权重和数量(villagePiecesLimit)
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.House4Garden.class, 4, MathHelper.getRandomIntegerInRange(random, 2 + size, 4 + size * 2)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.Church.class, 20, MathHelper.getRandomIntegerInRange(random, 0 + size, 1 + size)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.House1.class, 20, MathHelper.getRandomIntegerInRange(random, 0 + size, 2 + size)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.WoodHut.class, 3, MathHelper.getRandomIntegerInRange(random, 2 + size, 5 + size * 3)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.Hall.class, 15, MathHelper.getRandomIntegerInRange(random, 0 + size, 2 + size)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.Field1.class, 3, MathHelper.getRandomIntegerInRange(random, 1 + size, 4 + size)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.Field2.class, 3, MathHelper.getRandomIntegerInRange(random, 2 + size, 4 + size * 2)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.House2.class, 15, MathHelper.getRandomIntegerInRange(random, 0, 1 + size)));
            list.add(new StructureVillagePieces.PieceWeight(StructureVillagePieces.House3.class, 8, MathHelper.getRandomIntegerInRange(random, 0 + size, 3 + size * 2)));
            net.minecraftforge.fml.common.registry.VillagerRegistry.addExtraVillageComponents(list, random, size);
            Iterator<StructureVillagePieces.PieceWeight> iterator = list.iterator();
    
            while (iterator.hasNext())
            {
                // villagePiecesLimit = 0代表不生成，这里直接去掉
                if (((StructureVillagePieces.PieceWeight)iterator.next()).villagePiecesLimit == 0)
                {
                    iterator.remove();
                }
            }
    
            return list;
        }
    
        // 继承自Well，说明水井是村庄的起点，每个村庄一定有水井
        public static class Start extends StructureVillagePieces.Well { 
                public WorldChunkManager worldChunkMngr;
                /** Boolean that determines if the village is in a desert or not. */
                public boolean inDesert;
                /** World terrain type, 0 for normal, 1 for flap map */
                public int terrainType;
                public StructureVillagePieces.PieceWeight structVillagePieceWeight;
                public List<StructureVillagePieces.PieceWeight> structureVillageWeightedPieceList;
                public List<StructureComponent> field_74932_i = Lists.<StructureComponent>newArrayList();
                public List<StructureComponent> field_74930_j = Lists.<StructureComponent>newArrayList();
                public BiomeGenBase biome;
    
                public Start()
                {
                }
    
                public Start(WorldChunkManager chunkManagerIn, int componentType, Random rand, int x, int z, List<StructureVillagePieces.PieceWeight> pieces, int size)
                {
                    super((StructureVillagePieces.Start)null, 0, rand, x, z);
                    this.worldChunkMngr = chunkManagerIn;
                    this.structureVillageWeightedPieceList = pieces;
                    this.terrainType = size;
                    BiomeGenBase biomegenbase = chunkManagerIn.getBiomeGenerator(new BlockPos(x, 0, z), BiomeGenBase.field_180279_ad);
                    this.inDesert = biomegenbase == BiomeGenBase.desert || biomegenbase == BiomeGenBase.desertHills;
                    this.biome = biomegenbase;
                    // 设置是否在沙漠
                    this.func_175846_a(this.inDesert);
                }
    
                // ...
            }
    
        public static class Well extends StructureVillagePieces.Village { 
                // ...
    
                /** * Initiates construction of the Structure Component picked, at the current Location of StructGen */
                public void buildComponent(StructureComponent start, List<StructureComponent> components, Random rand)
                {
                    // 对水井周围四个方向构造道路并加入组件
                    StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX - 1, this.boundingBox.maxY - 4, this.boundingBox.minZ + 1, EnumFacing.WEST, this.getComponentType());
                    StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.maxX + 1, this.boundingBox.maxY - 4, this.boundingBox.minZ + 1, EnumFacing.EAST, this.getComponentType());
                    StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX + 1, this.boundingBox.maxY - 4, this.boundingBox.minZ - 1, EnumFacing.NORTH, this.getComponentType());
                    StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX + 1, this.boundingBox.maxY - 4, this.boundingBox.maxZ + 1, EnumFacing.SOUTH, this.getComponentType());
                }
    
                // ...
            }
    
        // 构造道路
        private static StructureComponent func_176069_e(StructureVillagePieces.Start start, List<StructureComponent> components, Random rand, int x, int y, int z, EnumFacing facing, int componentType)
        {
            if (componentType > 3 + start.terrainType)
            {
                return null;
            }
            else if (   Math.abs(x - start.getBoundingBox().minX) <= 112
                     && Math.abs(z - start.getBoundingBox().minZ) <= 112) // 不能离起点太远
            {
                // 构造道路的包围盒，保证不与其他组件重叠
                StructureBoundingBox structureboundingbox = StructureVillagePieces.Path.func_175848_a(start, components, rand, x, y, z, facing);
    
                if (structureboundingbox != null && structureboundingbox.minY > 10)
                {
                    StructureComponent path = new StructureVillagePieces.Path(start, componentType, rand, structureboundingbox, facing);
                    int xCenter = (path.boundingBox.minX + path.boundingBox.maxX) / 2;
                    int zCenter = (path.boundingBox.minZ + path.boundingBox.maxZ) / 2;
                    int xSize = path.boundingBox.maxX - path.boundingBox.minX;
                    int zSize = path.boundingBox.maxZ - path.boundingBox.minZ;
                    int length = xSize > zSize ? xSize : zSize;
    
                    // 判断中心生物群系
                    if (start.getWorldChunkManager().areBiomesViable(xCenter, zCenter, length / 2 + 4, MapGenVillage.villageSpawnBiomes))
                    {
                        components.add(path);
                        // 加入优先构造的组件
                        start.field_74930_j.add(path);
                        return path;
                    }
                }
    
                return null;
            }
            else
            {
                return null;
            }
        }
    
        public static class Path extends StructureVillagePieces.Road { 
                // ...
    
                // 构造道路包围盒
                public static StructureBoundingBox func_175848_a(StructureVillagePieces.Start start, List<StructureComponent> components, Random rand, int x, int y, int z, EnumFacing facing)
                {
                    for (int length = 7 * MathHelper.getRandomIntegerInRange(rand, 3, 5); length >= 7; length -= 7)
                    {
                        // 向指定方向构造这个组件的包围盒
                        StructureBoundingBox structureboundingbox = StructureBoundingBox.getComponentToAddBoundingBox(x, y, z, 0, 0, 0, 3, 3, length, facing);
    
                        // 没有与已有组件重叠
                        if (StructureComponent.findIntersecting(components, structureboundingbox) == null)
                        {
                            return structureboundingbox;
                        }
                    }
    
                    return null;
                }
    
                public void buildComponent(StructureComponent start, List<StructureComponent> components, Random rand)
                {
                    boolean hasNewComponent = false;
    
                    // 构造组件
    
                    for (int lengthOffset = rand.nextInt(5); lengthOffset < this.length - 8; lengthOffset += 2 + rand.nextInt(5))
                    {
                        StructureComponent component = this.getNextComponentNN((StructureVillagePieces.Start)start, components, rand, 0, lengthOffset);
    
                        if (component != null)
                        {
                            lengthOffset += Math.max(component.boundingBox.getXSize(), component.boundingBox.getZSize());
                            hasNewComponent = true;
                        }
                    }
    
                    for (int lengthOffset = rand.nextInt(5); lengthOffset < this.length - 8; lengthOffset += 2 + rand.nextInt(5))
                    {
                        StructureComponent component = this.getNextComponentPP((StructureVillagePieces.Start)start, components, rand, 0, lengthOffset);
    
                        if (component != null)
                        {
                            lengthOffset += Math.max(component.boundingBox.getXSize(), component.boundingBox.getZSize());
                            hasNewComponent = true;
                        }
                    }
    
                    // 构造左右两边新的道路
    
                    if (hasNewComponent && rand.nextInt(3) > 0 && this.coordBaseMode != null)
                    {
                        switch (this.coordBaseMode)
                        {
                            case NORTH:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX - 1, this.boundingBox.minY, this.boundingBox.minZ, EnumFacing.WEST, this.getComponentType());
                                break;
                            case SOUTH:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX - 1, this.boundingBox.minY, this.boundingBox.maxZ - 2, EnumFacing.WEST, this.getComponentType());
                                break;
                            case WEST:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX, this.boundingBox.minY, this.boundingBox.minZ - 1, EnumFacing.NORTH, this.getComponentType());
                                break;
                            case EAST:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.maxX - 2, this.boundingBox.minY, this.boundingBox.minZ - 1, EnumFacing.NORTH, this.getComponentType());
                        }
                    }
    
                    if (hasNewComponent && rand.nextInt(3) > 0 && this.coordBaseMode != null)
                    {
                        switch (this.coordBaseMode)
                        {
                            case NORTH:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.maxX + 1, this.boundingBox.minY, this.boundingBox.minZ, EnumFacing.EAST, this.getComponentType());
                                break;
                            case SOUTH:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.maxX + 1, this.boundingBox.minY, this.boundingBox.maxZ - 2, EnumFacing.EAST, this.getComponentType());
                                break;
                            case WEST:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.minX, this.boundingBox.minY, this.boundingBox.maxZ + 1, EnumFacing.SOUTH, this.getComponentType());
                                break;
                            case EAST:
                                StructureVillagePieces.func_176069_e((StructureVillagePieces.Start)start, components, rand, this.boundingBox.maxX - 2, this.boundingBox.minY, this.boundingBox.maxZ + 1, EnumFacing.SOUTH, this.getComponentType());
                        }
                    }
                }
    
                // ...
            }
    
        public abstract static class Village extends StructureComponent { 
                // ...
    
                /** * Gets the next village component, with the bounding box shifted -1 in the X and Z direction. */
                protected StructureComponent getNextComponentNN(StructureVillagePieces.Start start, List<StructureComponent> components, Random rand, int yOffset, int lengthOffset)
                {
                    if (this.coordBaseMode != null)
                    {
                        switch (this.coordBaseMode)
                        {
                            case NORTH:
                                return StructureVillagePieces.func_176066_d(start, components, rand, this.boundingBox.minX - 1, this.boundingBox.minY + yOffset, this.boundingBox.minZ + lengthOffset, EnumFacing.WEST, this.getComponentType());
                            case SOUTH:
                                return StructureVillagePieces.func_176066_d(start, components, rand, this.boundingBox.minX - 1, this.boundingBox.minY + yOffset, this.boundingBox.minZ + lengthOffset, EnumFacing.WEST, this.getComponentType());
                            case WEST:
                                return StructureVillagePieces.func_176066_d(start, components, rand, this.boundingBox.minX + lengthOffset, this.boundingBox.minY + yOffset, this.boundingBox.minZ - 1, EnumFacing.NORTH, this.getComponentType());
                            case EAST:
                                return StructureVillagePieces.func_176066_d(start, components, rand, this.boundingBox.minX + lengthOffset, this.boundingBox.minY + yOffset, this.boundingBox.minZ - 1, EnumFacing.NORTH, this.getComponentType());
                        }
                    }
    
                    return null;
                }
    
                // ...
            }
    
        // 构造组件，和构造道路差不多
        private static StructureComponent func_176066_d(StructureVillagePieces.Start start, List<StructureComponent> components, Random rand, int x, int y, int z, EnumFacing facing, int componentType)
        {
            if (componentType > 50)
            {
                return null;
            }
            else if (   Math.abs(x - start.getBoundingBox().minX) <= 112
                     && Math.abs(z - start.getBoundingBox().minZ) <= 112) // 不能离起点太远
            {
                // 构造组件，保证不与其他组件重叠
                StructureComponent component = func_176067_c(start, components, rand, x, y, z, facing, componentType + 1);
    
                if (component != null)
                {
                    int xCenter = (component.boundingBox.minX + component.boundingBox.maxX) / 2;
                    int zCenter = (component.boundingBox.minZ + component.boundingBox.maxZ) / 2;
                    int xSize = component.boundingBox.maxX - component.boundingBox.minX;
                    int zSize = component.boundingBox.maxZ - component.boundingBox.minZ;
                    int length = xSize > zSize ? xSize : zSize;
    
                    // 判断中心生物群系
                    if (start.getWorldChunkManager().areBiomesViable(xCenter, zCenter, length / 2 + 4, MapGenVillage.villageSpawnBiomes))
                    {
                        components.add(component);
                        // 加入后构造的组件
                        start.field_74932_i.add(component);
                        return component;
                    }
                }
    
                return null;
            }
            else
            {
                return null;
            }
        }
    
        // 随机选剩下的组件来构造
        private static StructureVillagePieces.Village func_176067_c(StructureVillagePieces.Start start, List<StructureComponent> components, Random rand, int x, int y, int z, EnumFacing facing, int componentType)
        {
            // 剩下组件的总权重
            int totalWeight = func_75079_a(start.structureVillageWeightedPieceList);
    
            if (totalWeight <= 0)
            {
                return null;
            }
            else
            {
                // 尝试构造structureVillageWeightedPieceList里的组件5次
                for (i = 0; i < 5; ++i)
                {
                    // 加权随机选一个组件
                    int weight = rand.nextInt(totalWeight);
    
                    for (StructureVillagePieces.PieceWeight piece : start.structureVillageWeightedPieceList)
                    {
                        weight -= piece.villagePieceWeight;
    
                        // 应该生成这个组件
                        if (weight < 0)
                        {
                            if (   !piece.canSpawnMoreVillagePiecesOfType(componentType) // 已达到数量限制
                                || piece == start.structVillagePieceWeight // 上次已经生成这个了？
                                && start.structureVillageWeightedPieceList.size() > 1)
                            {
                                break;
                            }
    
                            // 构造组件，根据不同的class调用不同的函数
                            StructureVillagePieces.Village component = func_176065_a(start, piece, components, rand, x, y, z, facing, componentType);
    
                            if (component != null)
                            {
                                // 已生成数量+1
                                ++piece.villagePiecesSpawned;
                                start.structVillagePieceWeight = piece;
    
                                // 已达到数量限制则去掉这个组件
                                if (!piece.canSpawnMoreVillagePieces())
                                {
                                    start.structureVillageWeightedPieceList.remove(piece);
                                }
    
                                return component;
                            }
                        }
                    }
                }
    
                // 构造路灯包围盒，保证不与其他组件重叠
                StructureBoundingBox structureboundingbox = StructureVillagePieces.Torch.func_175856_a(start, components, rand, x, y, z, facing);
    
                if (structureboundingbox != null)
                {
                    // 构造路灯
                    return new StructureVillagePieces.Torch(start, componentType, rand, structureboundingbox, facing);
                }
                else
                {
                    return null;
                }
            }
        }
    
        // 计算剩下组件的总权重
        private static int func_75079_a(List<StructureVillagePieces.PieceWeight> pieces)
        {
            boolean hasPiece = false;
            int totalWeight = 0;
    
            for (StructureVillagePieces.PieceWeight piece : pieces)
            {
                if (   piece.villagePiecesLimit > 0
                    && piece.villagePiecesSpawned < piece.villagePiecesLimit)
                {
                    hasPiece = true;
                }
    
                totalWeight += piece.villagePieceWeight;
            }
    
            return hasPiece ? totalWeight : -1;
        }

这样这个村庄的所有组件和它们的位置就决定好了，接下来该操作方块生成整个村庄

# 生成村庄 #

在provideChunk之后还会调用populate函数，它的作用是给区块加上矿石、树、雪层之类的点缀，还会真正生成村庄等建筑

调用populate函数的参数满足以下条件：1)周围4个区块有且只有一个区块不存在，2)参数为这4个区块中XZ坐标最小的

它会调用这个函数，类名`net.minecraft.world.gen.structure.MapGenStructure`

public boolean generateStructure(World worldIn, Random randomIn, ChunkCoordIntPair chunkCoord)
        {
            // 尝试载入保存的结构数据，recursiveGenerate也调用过
            this.func_143027_a(worldIn);
            // 用来构造4个区块中心16*16的包围盒
            int xMin = (chunkCoord.chunkXPos << 4) + 8;
            int zMin = (chunkCoord.chunkZPos << 4) + 8;
            boolean generated = false;
    
            for (StructureStart start : this.structureMap.values())
            {
                if (   start.isSizeableStructure() // 只有村庄实现了，非道路组件>2则返回true
                    && start.func_175788_a(chunkCoord) // 只有神庙实现了
                    && start.getBoundingBox().intersectsWith(xMin, zMin, xMin + 15, zMin + 15)) // 这个结构和包围盒有重叠
                {
                    // 生成结构和包围盒重叠的部分
                    start.generateStructure(worldIn, randomIn, new StructureBoundingBox(xMin, zMin, xMin + 15, zMin + 15));
                    // 只有神庙实现了
                    start.func_175787_b(chunkCoord);
                    generated = true;
                    // 保存数据，recursiveGenerate也调用过
                    this.func_143026_a(start.getChunkPosX(), start.getChunkPosZ(), start);
                }
            }
    
            return generated;
        }

类名`net.minecraft.world.gen.structure.StructureStart`

/** * Keeps iterating Structure Pieces and spawning them until the checks tell it to stop */
        public void generateStructure(World worldIn, Random rand, StructureBoundingBox structurebb)
        {
            Iterator<StructureComponent> iterator = this.components.iterator();
    
            // 遍历结构所有组件
            while (iterator.hasNext())
            {
                StructureComponent structurecomponent = (StructureComponent)iterator.next();
    
                if (   structurecomponent.getBoundingBox().intersectsWith(structurebb) // 和包围盒有重叠
                    && !structurecomponent.addComponentParts(worldIn, rand, structurebb)) // 生成组件，如果生成失败返回false
                {
                    // 组件生成失败
                    iterator.remove();
                }
            }
        }

addComponentParts由子类实现，这里只研究水井的实现吧

类名`net.minecraft.world.gen.structure.StructureVillagePieces.Well`

/** * second Part of Structure generating, this for example places Spiderwebs, Mob Spawners, it closes * Mineshafts at the end, it adds Fences... */
                public boolean addComponentParts(World worldIn, Random randomIn, StructureBoundingBox structureBoundingBoxIn)
                {
                    // 地面高度，默认-1
                    if (this.field_143015_k < 0)
                    {
                        this.field_143015_k = this.getAverageGroundLevel(worldIn, structureBoundingBoxIn);
    
                        if (this.field_143015_k < 0)
                        {
                            return true;
                        }
    
                        // 把包围盒移动到地面
                        this.boundingBox.offset(0, this.field_143015_k - this.boundingBox.maxY + 3, 0);
                    }
    
                    // 填充水，两个方块参数是边界方块和填充方块
                    this.fillWithBlocks(worldIn, structureBoundingBoxIn, 1, 0, 1, 4, 12, 4, Blocks.cobblestone.getDefaultState(), Blocks.flowing_water.getDefaultState(), false);
                    // 开口
                    this.setBlockState(worldIn, Blocks.air.getDefaultState(), 2, 12, 2, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.air.getDefaultState(), 3, 12, 2, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.air.getDefaultState(), 2, 12, 3, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.air.getDefaultState(), 3, 12, 3, structureBoundingBoxIn);
                    // 栅栏
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 1, 13, 1, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 1, 14, 1, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 4, 13, 1, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 4, 14, 1, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 1, 13, 4, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 1, 14, 4, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 4, 13, 4, structureBoundingBoxIn);
                    this.setBlockState(worldIn, Blocks.oak_fence.getDefaultState(), 4, 14, 4, structureBoundingBoxIn);
                    // 房顶
                    this.fillWithBlocks(worldIn, structureBoundingBoxIn, 1, 15, 1, 4, 15, 4, Blocks.cobblestone.getDefaultState(), Blocks.cobblestone.getDefaultState(), false);
    
                    // 底座的砂砾
                    for (int x = 0; x <= 5; ++x)
                    {
                        for (int z = 0; z <= 5; ++z)
                        {
                            if (z == 0 || z == 5 || x == 0 || x == 5)
                            {
                                this.setBlockState(worldIn, Blocks.gravel.getDefaultState(), z, 11, x, structureBoundingBoxIn);
                                this.clearCurrentPositionBlocksUpwards(worldIn, z, 12, x, structureBoundingBoxIn);
                            }
                        }
                    }
    
                    return true;
                }
            }

MC中没有模型，建筑全是硬编码生成的…