Беда с генерацией структур....

BlesseNtumble · 28 Ноя 2015

Добрый день.
Собственно, не работает генерация структур в ChunkProvider'e
Код чанкпровайдера:

Код:

public class ChunkProviderBarnarda2 extends ChunkProviderSpaceLakes {
 
    private List<MapGenBaseMeta> worldGenerators;
    
    private BiomeGenBase[] biomesForGeneration = this.getBiomesForGeneration();
    private final MapGenCavesBarnarda2 caveGenerator = new MapGenCavesBarnarda2();
    private final MapGenRavineBarnarda2 ravineGenerator = new MapGenRavineBarnarda2();

 @Override
    protected List getWorldGenerators()
    {
        List<MapGenBaseMeta> generators = Lists.newArrayList();
        return generators;
    }

public ChunkProviderBarnarda2(World par1World, long seed, boolean mapFeaturesEnabled) 

{
 super(par1World, seed, mapFeaturesEnabled);

}

@Override
protected BiomeDecoratorSpace getBiomeGenerator() {


    return new BiomeDecoratorBarnarda2Ore();

}


@Override
protected BiomeGenBase[] getBiomesForGeneration() {


    return new BiomeGenBase[]{BiomeGenBaseBarnarda2.Barnarda2, BiomeGenBaseBarnarda2.Barnarda2Hills, BiomeGenBaseBarnarda2.Barnarda2LowPlains};

}


@Override
protected SpawnListEntry[] getCreatures() {

 

    return new SpawnListEntry[]{};

}


@Override
public double getHeightModifier() {

    return 15;

}



@Override
protected SpawnListEntry[] getMonsters() {

    SpawnListEntry skele = new SpawnListEntry(EntitySkeleton.class, 100, 4, 4);
    SpawnListEntry creeper = new SpawnListEntry(EntityCreeper.class, 100, 4, 4);
    SpawnListEntry spider = new SpawnListEntry(EntitySpider.class, 100, 4, 4);
    
  

    return new SpawnListEntry[]{skele, creeper, spider};

}



@Override
public void onChunkProvide(int cX, int cZ, Block[] blocks, byte[] metadata) {
 
 Arrays.fill(blocks, Blocks.air);
 this.generateTerrain(cX, cZ, blocks, metadata);
 this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, cX * 16, cZ * 16, 16, 16);
    this.replaceBlocksForBiome(cX, cZ, blocks, metadata, this.biomesForGeneration);
 this.ravineGenerator.func_151539_a(this, this.worldObj, cX, cZ, blocks);
 this.caveGenerator.generate(this, this.worldObj, cX, cZ, blocks, metadata);
}



@Override
public void onPopulate(IChunkProvider arg0, int arg1, int arg2){

}


@Override
public boolean chunkExists(int x, int y){

    return false;

}


@Override
protected SpawnListEntry[] getWaterCreatures() {

 return new SpawnListEntry[]{};
}

@Override
public boolean canGenerateWaterBlock() {

 return true;
}

@Override
protected BlockMetaPair getWaterBlock() {

 return new BlockMetaPair(Blocks.water, (byte) 0);
}

@Override
public byte getWaterLevel() {
 return 63;
}

}

Родитель чанка:

Код:

public abstract class ChunkProviderSpaceLakes extends ChunkProviderGenerate 
{ 
 protected Random rand;
 private NoiseGeneratorOctaves noiseGen4;
 public NoiseGeneratorOctaves noiseGen5;
 public NoiseGeneratorOctaves noiseGen6;
 public NoiseGeneratorOctaves mobSpawnerNoise;
 protected World worldObj;
 private double[] stoneNoise;
 private BiomeGenBase[] biomesForGeneration = this.getBiomesForGeneration();
 double[] noise3;
 double[] noise1;
 double[] noise2;
 double[] noise5;
 double[] noise6;
 float[] squareTable;
 private NoiseGeneratorOctaves field_147431_j;
 private NoiseGeneratorOctaves field_147432_k;
 private NoiseGeneratorOctaves field_147429_l;
 private NoiseGeneratorPerlin field_147430_m;
 private double[] terrainCalcs;
 private float[] parabolicField;
 double[] field_147427_d;
 double[] field_147428_e;
 double[] field_147425_f;
 double[] field_147426_g;
 int[][] field_73219_j = new int[32][32];
 
 private List<MapGenBaseMeta> worldGenerators;

 public ChunkProviderSpaceLakes(World world, long seed, boolean flag)
 {
 super(world, seed, flag);
 this.stoneNoise = new double[256];
 this.worldObj = world;
 this.rand = new Random(seed);
 this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4);
 this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
 this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
 this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
 this.field_147431_j = new NoiseGeneratorOctaves(this.rand, 16);
 this.field_147432_k = new NoiseGeneratorOctaves(this.rand, 16);
 this.field_147429_l = new NoiseGeneratorOctaves(this.rand, 8);
 this.field_147430_m = new NoiseGeneratorPerlin(this.rand, 4);
 this.terrainCalcs = new double[825];
 this.parabolicField = new float[25];

 for (int j = -2; j <= 2; j++)
 {
 for (int k = -2; k <= 2; k++)
 {
 float f = 10.0F / MathHelper.sqrt_float(j * j + k * k + 0.2F);
 this.parabolicField[j + 2 + (k + 2) * 5] = f;
 }
 }
 }

 @Override
 public Chunk provideChunk(int x, int z)
 {
 this.rand.setSeed(x * 341873128712L + z * 132897987541L);
 Block[] blockStorage = new Block[256 * 256];
 byte[] metaStorage = new byte[256 * 256];
 this.generateTerrain(x, z, blockStorage, metaStorage);
 this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, x * 16, z * 16, 16, 16);
 this.replaceBlocksForBiome(x, z, blockStorage, metaStorage, this.biomesForGeneration);
 Chunk chunk = new Chunk(this.worldObj, blockStorage, metaStorage, x, z);
 byte[] chunkBiomes = chunk.getBiomeArray();

 if (this.worldGenerators == null)
        {
            this.worldGenerators = this.getWorldGenerators();
        }

        for (MapGenBaseMeta generator : this.worldGenerators)
        {
            generator.generate(this, this.worldObj, x, z, blockStorage, metaStorage);
        }
        
        for (int i = 0; i < chunkBiomes.length; i++)
 {
 chunkBiomes[i] = (byte)this.biomesForGeneration[i].biomeID;
 }
        
        this.onChunkProvide(x, z, blockStorage, metaStorage);
 chunk.generateSkylightMap();
 return chunk;
 }

 public void generateTerrain(int chunkX, int chunkZ, Block[] blockStorage, byte[] metaStorage)
 {
 byte seaLevel = this.getWaterLevel();
 metaStorage = new byte[256 * 256];
 this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, chunkX * 4 - 2, chunkZ * 4 - 2, 10, 10);
 this.makeLandPerBiome2(chunkX * 4, 0, chunkZ * 4);

 for (int k = 0; k < 4; k++)
 {
 int l = k * 5;
 int i1 = (k + 1) * 5;

 for (int j1 = 0; j1 < 4; j1++)
 {
 int k1 = (l + j1) * 33;
 int l1 = (l + j1 + 1) * 33;
 int i2 = (i1 + j1) * 33;
 int j2 = (i1 + j1 + 1) * 33;

 for (int k2 = 0; k2 < 32; k2++)
 {
 double d0 = 0.125D;
 double d1 = this.terrainCalcs[k1 + k2];
 double d2 = this.terrainCalcs[l1 + k2];
 double d3 = this.terrainCalcs[i2 + k2];
 double d4 = this.terrainCalcs[j2 + k2];
 double d5 = (this.terrainCalcs[k1 + k2 + 1] - d1) * d0;
 double d6 = (this.terrainCalcs[l1 + k2 + 1] - d2) * d0;
 double d7 = (this.terrainCalcs[i2 + k2 + 1] - d3) * d0;
 double d8 = (this.terrainCalcs[j2 + k2 + 1] - d4) * d0;

 for (int l2 = 0; l2 < 8; l2++)
 {
 double d9 = 0.25D;
 double d10 = d1;
 double d11 = d2;
 double d12 = (d3 - d1) * d9;
 double d13 = (d4 - d2) * d9;

 for (int i3 = 0; i3 < 4; ++i3)
 {
 int j3 = i3 + k * 4 << 12 | 0 + j1 * 4 << 8 | k2 * 8 + l2;
 short short1 = 256;
 j3 -= short1;
 double d14 = 0.25D;
 double d16 = (d11 - d10) * d14;
 double d15 = d10 - d16;

 for (int k3 = 0; k3 < 4; ++k3)
 {
 if ((d15 += d16) > 0.0D)
 {
 blockStorage[j3 += short1] = Blocks.stone;
 }
 else if (k2 * 8 + l2 < seaLevel && this.canGenerateWaterBlock())
 {
 blockStorage[j3 += short1] = this.getWaterBlock().getBlock();
 }
 else
 {
 blockStorage[j3 += short1] = null;
 }
 }
 d10 += d12;
 d11 += d13;
 }
 d1 += d5;
 d2 += d6;
 d3 += d7;
 d4 += d8;
 }
 }
 }
 }
 }

 private void makeLandPerBiome2(int x, int zero, int z)
 {
 this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, x, z, 5, 5, 200.0D, 200.0D, 0.5D);
 this.field_147427_d = this.field_147429_l.generateNoiseOctaves(this.field_147427_d, x, zero, z, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);
 this.field_147428_e = this.field_147431_j.generateNoiseOctaves(this.field_147428_e, x, zero, z, 5, 33, 5, 684.41200000000003D, 684.41200000000003D, 684.41200000000003D);
 this.field_147425_f = this.field_147432_k.generateNoiseOctaves(this.field_147425_f, x, zero, z, 5, 33, 5, 684.41200000000003D, 684.41200000000003D, 684.41200000000003D);
 int terrainIndex = 0;
 int noiseIndex = 0;

 for (int ax = 0; ax < 5; ax++)
 {
 for (int az = 0; az < 5; az++)
 {
 float totalVariation = 0.0F;
 float totalHeight = 0.0F;
 float totalFactor = 0.0F;
 byte two = 2;
 BiomeGenBase biomegenbase = this.biomesForGeneration[ax + 2 + (az + 2) * 10];

 for (int ox = -two; ox <= two; ox++)
 {
 for (int oz = -two; oz <= two; oz++)
 {
 BiomeGenBase biomegenbase1 = this.biomesForGeneration[ax + ox + 2 + (az + oz + 2) * 10];
 float rootHeight = biomegenbase1.rootHeight;
 float heightVariation = biomegenbase1.heightVariation;
 float heightFactor = this.parabolicField[ox + 2 + (oz + 2) * 5] / (rootHeight + 2.0F);

 if (biomegenbase1.rootHeight > biomegenbase.rootHeight)
 {
 heightFactor /= 2.0F;
 }
 totalVariation += heightVariation * heightFactor;
 totalHeight += rootHeight * heightFactor;
 totalFactor += heightFactor;
 }
 }
 totalVariation /= totalFactor;
 totalHeight /= totalFactor;
 totalVariation = totalVariation * 0.9F + 0.1F;
 totalHeight = (totalHeight * 4.0F - 1.0F) / 8.0F;
 double terrainNoise = this.field_147426_g[noiseIndex] / 8000.0D;

 if (terrainNoise < 0.0D)
 {
 terrainNoise = -terrainNoise * 0.3D;
 }

 terrainNoise = terrainNoise * 3.0D - 2.0D;

 if (terrainNoise < 0.0D)
 {
 terrainNoise /= 2.0D;

 if (terrainNoise < -1.0D)
 {
 terrainNoise = -1.0D;
 }
 terrainNoise /= 1.4D;
 terrainNoise /= 2.0D;
 }
 else
 {
 if (terrainNoise > 1.0D)
 {
 terrainNoise = 1.0D;
 }
 terrainNoise /= 8.0D;
 }
 noiseIndex++;
 double heightCalc = totalHeight;
 double variationCalc = totalVariation * this.getHeightModifier() / 10D;
 heightCalc += terrainNoise * 0.2D;
 heightCalc = heightCalc * 8.5D / 8.0D;
 double d5 = 8.5D + heightCalc * 4.0D;

 for (int ay = 0; ay < 33; ay++)
 {
 double d6 = (ay - d5) * 12.0D * 128.0D / 256.0D / variationCalc;

 if (d6 < 0.0D)
 {
 d6 *= 4.0D;
 }
 double d7 = this.field_147428_e[terrainIndex] / 512.0D;
 double d8 = this.field_147425_f[terrainIndex] / 512.0D;
 double d9 = (this.field_147427_d[terrainIndex] / 10.0D + 1.0D) / 2.0D;
 double terrainCalc = MathHelper.denormalizeClamp(d7, d8, d9) - d6;

 if (ay > 29)
 {
 double d11 = (ay - 29) / 3.0F;
 terrainCalc = terrainCalc * (1.0D - d11) + -10.0D * d11;
 }
 this.terrainCalcs[terrainIndex] = terrainCalc;
 terrainIndex++;
 }
 }
 }
 }

 @Override
 public void replaceBlocksForBiome(int chunkX, int chunkZ, Block[] blockStorage, byte[] metaStorage, BiomeGenBase[] biomes)
 {
 double d0 = 0.03125D;
 this.stoneNoise = this.field_147430_m.func_151599_a(this.stoneNoise, chunkX * 16, chunkZ * 16, 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D);

 for (int z = 0; z < 16; z++)
 {
 for (int x = 0; x < 16; x++)
 {
 BiomeGenBase biomegenbase = biomes[x + z * 16];
 biomegenbase.genTerrainBlocks(this.worldObj, this.rand, blockStorage, metaStorage, chunkX * 16 + z, chunkZ * 16 + x, this.stoneNoise[x + z * 16]);
 }
 }
 }

 @Override
 public Chunk loadChunk(int x, int z)
 {
 return this.provideChunk(x, z);
 }

 @Override
 public boolean chunkExists(int x, int z)
 {
 return true;
 }

 @Override
 public void populate(IChunkProvider chunk, int x, int z)
 {
 BlockFalling.fallInstantly = true;
 int var4 = x * 16;
 int var5 = z * 16;
 BiomeGenBase biomeGen = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);
 this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);
 this.rand.setSeed(this.worldObj.getSeed());
 long var7 = this.rand.nextLong() / 2L * 2L + 1L;
 long var9 = this.rand.nextLong() / 2L * 2L + 1L;
 this.rand.setSeed(x * var7 + z * var9 ^ this.worldObj.getSeed());
 biomeGen.decorate(this.worldObj, this.rand, var4, var5);
 this.decoratePlanet(this.worldObj, this.rand, var4, var5);
 SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomeGen, var4 + 8, var5 + 8, 16, 16, this.rand);
 this.onPopulate(chunk, x, z);
 BlockFalling.fallInstantly = false;
 }

 public void decoratePlanet(World world, Random rand, int x, int z)
 {
 this.getBiomeGenerator().decorate(world, rand, x, z);
 }

 @Override
 public boolean saveChunks(boolean flag, IProgressUpdate progress)
 {
 return true;
 }

 @Override
 public boolean canSave()
 {
 return true;
 }

 @Override
 public String makeString()
 {
 return "RandomLevelSource";
 }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int i, int j, int k)
    {
        if (par1EnumCreatureType == EnumCreatureType.monster)
        {
            final List monsters = new ArrayList();

            for (SpawnListEntry monster : this.getMonsters())
            {
                monsters.add(monster);
            }

            return monsters;
        }
        else if (par1EnumCreatureType == EnumCreatureType.creature)
        {
            final List creatures = new ArrayList();

            for (SpawnListEntry creature : this.getCreatures())
            {
                creatures.add(creature);
            }

            return creatures;
        }
        else if (par1EnumCreatureType == EnumCreatureType.waterCreature)
        {
            final List watercreatures = new ArrayList();

            for (SpawnListEntry watercreature : this.getWaterCreatures())
            {
                watercreatures.add(watercreature);
            }

            return watercreatures;
        }
        else
        {
            return null;
        }
    }

 @Override
 public int getLoadedChunkCount()
 {
 return 0;
 }

 @Override
 public void recreateStructures(int x, int z)
 {
 
 }

 @Override
 public boolean unloadQueuedChunks()
 {
 return false;
 }

 @Override
 public void saveExtraData() {}

 @Override
 public ChunkPosition func_147416_a(World world, String string, int x, int y, int z)
 {
 return null;
 }
 
    /**
     * Do not return null
     *
     * @return The biome generator for this world, handles ore, flower, etc
     * generation. See GCBiomeDecoratorBase.
     */
    protected abstract BiomeDecoratorSpace getBiomeGenerator();
    
    /**
     * Do not return null, have at least one biome for generation
     *
     * @return Biome instance for generation
     */
    protected abstract BiomeGenBase[] getBiomesForGeneration();
    
    public abstract void onChunkProvide(int cX, int cZ, Block[] blocks, byte[] metadata);

    public abstract void onPopulate(IChunkProvider provider, int cX, int cZ);
    
    /**
     * @return List of spawn list entries for monsters
     */
    protected abstract SpawnListEntry[] getMonsters();

    /**
     * @return List of spawn list entries for creatures
     */
    protected abstract SpawnListEntry[] getCreatures();
    
    /**
     * @return List of spawn list entries for water creatures
     */
    protected abstract SpawnListEntry[] getWaterCreatures();
    
    /**
     * List of all world generators to use. Caves, ravines, structures, etc.
     * <p/>
     * Return an empty list for no world generators. Do not return null.
     *
     * @return
     */
    protected abstract List<MapGenBaseMeta> getWorldGenerators();
    
    /**
     * @return Base height modifier
     */
    public abstract double getHeightModifier();
    
    /**
     * @return Base height modifier
     */
    public abstract byte getWaterLevel();
    
    /**
     * @return Generate Water Block on sealevel.
     */
    public abstract boolean canGenerateWaterBlock();
    
    /**
     * The water block to be generated.
     *
     * @return BlockMetaPair instance containing ID and metadata for water
     * block.
     */
    protected abstract BlockMetaPair getWaterBlock();
}

[merge_posts_bbcode]Добавлено: 29.11.2015 02:08:50[/merge_posts_bbcode]

Генератор пещер:

Код:

public class MapGenCavesBarnarda2 extends MapGenBaseMeta
{
    public static final int BREAK_THROUGH_CHANCE = 25; // 1 in n chance

    protected void generateLargeCaveNode(long par1, int par3, int par4, Block[] blockIdArray, byte[] metaArray, double par6, double par8, double par10)
    {
        this.generateCaveNode(par1, par3, par4, blockIdArray, metaArray, par6, par8, par10, 1.0F + this.rand.nextFloat() * 6.0F, 0.0F, 0.0F, -1, -1, 0.5D);
    }

    protected void generateCaveNode(long par1, int par3, int par4, Block[] blockIdArray, byte[] metaArray, double par6, double par8, double par10, float par12, float par13, float par14, int par15, int par16, double par17)
    {
        final double d4 = par3 * 16 + 8;
        final double d5 = par4 * 16 + 8;
        float f3 = 0.0F;
        float f4 = 0.0F;
        final Random random = new Random(par1);

        if (par16 <= 0)
        {
            final int j1 = this.range * 16 - 16;
            par16 = j1 - random.nextInt(j1 / 4);
        }

        boolean flag = false;

        if (par15 == -1)
        {
            par15 = par16 / 2;
            flag = true;
        }

        final int k1 = random.nextInt(par16 / 2) + par16 / 4;

        for (final boolean flag1 = random.nextInt(6) == 0; par15 < par16; ++par15)
        {
            final double d6 = 1.5D + MathHelper.sin(par15 * (float) Math.PI / par16) * par12 * 1.0F;
            final double d7 = d6 * par17;
            final float f5 = MathHelper.cos(par14);
            final float f6 = MathHelper.sin(par14);
            par6 += MathHelper.cos(par13) * f5;
            par8 += f6;
            par10 += MathHelper.sin(par13) * f5;

            if (flag1)
            {
                par14 *= 0.92F;
            }
            else
            {
                par14 *= 0.7F;
            }

            par14 += f4 * 0.1F;
            par13 += f3 * 0.1F;
            f4 *= 0.9F;
            f3 *= 0.75F;
            f4 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F;
            f3 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F;

            if (!flag && par15 == k1 && par12 > 1.0F && par16 > 0)
            {
                this.generateCaveNode(random.nextLong(), par3, par4, blockIdArray, metaArray, par6, par8, par10, random.nextFloat() * 0.5F + 0.5F, par13 - (float) Math.PI / 2F, par14 / 3.0F, par15, par16, 1.0D);
                this.generateCaveNode(random.nextLong(), par3, par4, blockIdArray, metaArray, par6, par8, par10, random.nextFloat() * 0.5F + 0.5F, par13 + (float) Math.PI / 2F, par14 / 3.0F, par15, par16, 1.0D);
                return;
            }

            if (flag || random.nextInt(4) != 0)
            {
                final double d8 = par6 - d4;
                final double d9 = par10 - d5;
                final double d10 = par16 - par15;
                final double d11 = par12 + 2.0F + 16.0F;

                if (d8 * d8 + d9 * d9 - d10 * d10 > d11 * d11)
                {
                    return;
                }

                if (par6 >= d4 - 16.0D - d6 * 2.0D && par10 >= d5 - 16.0D - d6 * 2.0D && par6 <= d4 + 16.0D + d6 * 2.0D && par10 <= d5 + 16.0D + d6 * 2.0D)
                {
                    int l1 = MathHelper.floor_double(par6 - d6) - par3 * 16 - 1;
                    int i2 = MathHelper.floor_double(par6 + d6) - par3 * 16 + 1;
                    int j2 = MathHelper.floor_double(par8 - d7) - 1;
                    int k2 = MathHelper.floor_double(par8 + d7) + 1;
                    int l2 = MathHelper.floor_double(par10 - d6) - par4 * 16 - 1;
                    int i3 = MathHelper.floor_double(par10 + d6) - par4 * 16 + 1;

                    if (l1 < 0)
                    {
                        l1 = 0;
                    }

                    if (i2 > 16)
                    {
                        i2 = 16;
                    }

                    if (j2 < 1)
                    {
                        j2 = 1;
                    }

                    if (k2 > 120)
                    {
                        k2 = 120;
                    }

                    if (l2 < 0)
                    {
                        l2 = 0;
                    }

                    if (i3 > 16)
                    {
                        i3 = 16;
                    }

                    final boolean flag2 = false;
                    int j3;
                    for (j3 = l1; j3 < i2; ++j3)
                    {
                        for (int l3 = l2; l3 < i3; ++l3)
                        {
                            for (int i4 = k2 + 1; i4 >= j2 - 1; --i4)
                            {
                                if (i4 >= 0 && i4 < 128)
                                {
                                    if (i4 != j2 - 1 && j3 != l1 && j3 != i2 - 1 && l3 != l2 && l3 != i3 - 1)
                                    {
                                        i4 = j2;
                                    }
                                }
                            }
                        }
                    }

                    if (true)
                    {

                        for (int localY = j2; localY < k2; localY++)
                        {
                            final double yfactor = (localY + 0.5D - par8) / d7;
                            final double yfactorSq = yfactor * yfactor;

                            for (int localX = l1; localX < i2; localX++)
                            {
                                final double zfactor = (localX + par3 * 16 + 0.5D - par6) / d6;
                                final double zfactorSq = zfactor * zfactor;

                                for (int localZ = l2; localZ < i3; localZ++)
                                {
                                    final double xfactor = (localZ + par4 * 16 + 0.5D - par10) / d6;
                                    final double xfactorSq = xfactor * xfactor;

                                    if (xfactorSq + zfactorSq < 1.0D)
                                    {
                                        final int coords = (localX * 16 + localZ) * 256 + localY;

                                        if (yfactor > -0.7D && xfactorSq + yfactorSq + zfactorSq < 1.0D)
                                        {
                                            if (blockIdArray[coords] == BRBlocks.Barnarda2Grass && random.nextInt(MapGenCavesBarnarda2.BREAK_THROUGH_CHANCE) == 0)
                                            {
                                                    blockIdArray[coords] = Blocks.air;
                                            }
                                            else if (blockIdArray[coords] == BRBlocks.Barnarda2Dirt)
                                            {
                                                    blockIdArray[coords] = Blocks.air;
                                            }
                                                                                        
                                        }
                                    }
                                }
                            }
                        }

                        if (flag)
                        {
                            break;
                        }
                    }
                }
            }
        }
    }

    @Override
    protected void recursiveGenerate(World par1World, int par2, int par3, int par4, int par5, Block[] blockIdArray, byte[] metaArray)
    {
        int var7 = this.rand.nextInt(this.rand.nextInt(this.rand.nextInt(40) + 1) + 1);

        if (this.rand.nextInt(15) != 0)
        {
            var7 = 0;
        }

        for (int var8 = 0; var8 < var7; ++var8)
        {
            final double var9 = par2 * 16 + this.rand.nextInt(16);
            final double var11 = this.rand.nextInt(this.rand.nextInt(120) + 8);
            final double var13 = par3 * 16 + this.rand.nextInt(16);
            int var15 = 1;

            if (this.rand.nextInt(4) == 0)
            {
                this.generateLargeCaveNode(this.rand.nextLong(), par4, par5, blockIdArray, metaArray, var9, var11, var13);
                var15 += this.rand.nextInt(4);
            }

            for (int var16 = 0; var16 < var15; ++var16)
            {
                final float var17 = this.rand.nextFloat() * (float) Math.PI * 2.0F;
                final float var18 = (this.rand.nextFloat() - 0.5F) * 2.0F / 8.0F;
                float var19 = this.rand.nextFloat() * 2.0F + this.rand.nextFloat();

                if (this.rand.nextInt(10) == 0)
                {
                    var19 *= this.rand.nextFloat() * this.rand.nextFloat() * 3.0F + 1.0F;
                }

                this.generateCaveNode(this.rand.nextLong(), par4, par5, blockIdArray, metaArray, var9, var11, var13, var19, var17, var18, 0, 0, 1.0D);
            }
        }
    }
}

[merge_posts_bbcode]Добавлено: 29.11.2015 02:08:51[/merge_posts_bbcode]

Генератор пещер:

Код:

public class MapGenCavesBarnarda2 extends MapGenBaseMeta
{
    public static final int BREAK_THROUGH_CHANCE = 25; // 1 in n chance

    protected void generateLargeCaveNode(long par1, int par3, int par4, Block[] blockIdArray, byte[] metaArray, double par6, double par8, double par10)
    {
        this.generateCaveNode(par1, par3, par4, blockIdArray, metaArray, par6, par8, par10, 1.0F + this.rand.nextFloat() * 6.0F, 0.0F, 0.0F, -1, -1, 0.5D);
    }

    protected void generateCaveNode(long par1, int par3, int par4, Block[] blockIdArray, byte[] metaArray, double par6, double par8, double par10, float par12, float par13, float par14, int par15, int par16, double par17)
    {
        final double d4 = par3 * 16 + 8;
        final double d5 = par4 * 16 + 8;
        float f3 = 0.0F;
        float f4 = 0.0F;
        final Random random = new Random(par1);

        if (par16 <= 0)
        {
            final int j1 = this.range * 16 - 16;
            par16 = j1 - random.nextInt(j1 / 4);
        }

        boolean flag = false;

        if (par15 == -1)
        {
            par15 = par16 / 2;
            flag = true;
        }

        final int k1 = random.nextInt(par16 / 2) + par16 / 4;

        for (final boolean flag1 = random.nextInt(6) == 0; par15 < par16; ++par15)
        {
            final double d6 = 1.5D + MathHelper.sin(par15 * (float) Math.PI / par16) * par12 * 1.0F;
            final double d7 = d6 * par17;
            final float f5 = MathHelper.cos(par14);
            final float f6 = MathHelper.sin(par14);
            par6 += MathHelper.cos(par13) * f5;
            par8 += f6;
            par10 += MathHelper.sin(par13) * f5;

            if (flag1)
            {
                par14 *= 0.92F;
            }
            else
            {
                par14 *= 0.7F;
            }

            par14 += f4 * 0.1F;
            par13 += f3 * 0.1F;
            f4 *= 0.9F;
            f3 *= 0.75F;
            f4 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F;
            f3 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F;

            if (!flag && par15 == k1 && par12 > 1.0F && par16 > 0)
            {
                this.generateCaveNode(random.nextLong(), par3, par4, blockIdArray, metaArray, par6, par8, par10, random.nextFloat() * 0.5F + 0.5F, par13 - (float) Math.PI / 2F, par14 / 3.0F, par15, par16, 1.0D);
                this.generateCaveNode(random.nextLong(), par3, par4, blockIdArray, metaArray, par6, par8, par10, random.nextFloat() * 0.5F + 0.5F, par13 + (float) Math.PI / 2F, par14 / 3.0F, par15, par16, 1.0D);
                return;
            }

            if (flag || random.nextInt(4) != 0)
            {
                final double d8 = par6 - d4;
                final double d9 = par10 - d5;
                final double d10 = par16 - par15;
                final double d11 = par12 + 2.0F + 16.0F;

                if (d8 * d8 + d9 * d9 - d10 * d10 > d11 * d11)
                {
                    return;
                }

                if (par6 >= d4 - 16.0D - d6 * 2.0D && par10 >= d5 - 16.0D - d6 * 2.0D && par6 <= d4 + 16.0D + d6 * 2.0D && par10 <= d5 + 16.0D + d6 * 2.0D)
                {
                    int l1 = MathHelper.floor_double(par6 - d6) - par3 * 16 - 1;
                    int i2 = MathHelper.floor_double(par6 + d6) - par3 * 16 + 1;
                    int j2 = MathHelper.floor_double(par8 - d7) - 1;
                    int k2 = MathHelper.floor_double(par8 + d7) + 1;
                    int l2 = MathHelper.floor_double(par10 - d6) - par4 * 16 - 1;
                    int i3 = MathHelper.floor_double(par10 + d6) - par4 * 16 + 1;

                    if (l1 < 0)
                    {
                        l1 = 0;
                    }

                    if (i2 > 16)
                    {
                        i2 = 16;
                    }

                    if (j2 < 1)
                    {
                        j2 = 1;
                    }

                    if (k2 > 120)
                    {
                        k2 = 120;
                    }

                    if (l2 < 0)
                    {
                        l2 = 0;
                    }

                    if (i3 > 16)
                    {
                        i3 = 16;
                    }

                    final boolean flag2 = false;
                    int j3;
                    for (j3 = l1; j3 < i2; ++j3)
                    {
                        for (int l3 = l2; l3 < i3; ++l3)
                        {
                            for (int i4 = k2 + 1; i4 >= j2 - 1; --i4)
                            {
                                if (i4 >= 0 && i4 < 128)
                                {
                                    if (i4 != j2 - 1 && j3 != l1 && j3 != i2 - 1 && l3 != l2 && l3 != i3 - 1)
                                    {
                                        i4 = j2;
                                    }
                                }
                            }
                        }
                    }

                    if (true)
                    {

                        for (int localY = j2; localY < k2; localY++)
                        {
                            final double yfactor = (localY + 0.5D - par8) / d7;
                            final double yfactorSq = yfactor * yfactor;

                            for (int localX = l1; localX < i2; localX++)
                            {
                                final double zfactor = (localX + par3 * 16 + 0.5D - par6) / d6;
                                final double zfactorSq = zfactor * zfactor;

                                for (int localZ = l2; localZ < i3; localZ++)
                                {
                                    final double xfactor = (localZ + par4 * 16 + 0.5D - par10) / d6;
                                    final double xfactorSq = xfactor * xfactor;

                                    if (xfactorSq + zfactorSq < 1.0D)
                                    {
                                        final int coords = (localX * 16 + localZ) * 256 + localY;

                                        if (yfactor > -0.7D && xfactorSq + yfactorSq + zfactorSq < 1.0D)
                                        {
                                            if (blockIdArray[coords] == BRBlocks.Barnarda2Grass && random.nextInt(MapGenCavesBarnarda2.BREAK_THROUGH_CHANCE) == 0)
                                            {
                                                    blockIdArray[coords] = Blocks.air;
                                            }
                                            else if (blockIdArray[coords] == BRBlocks.Barnarda2Dirt)
                                            {
                                                    blockIdArray[coords] = Blocks.air;
                                            }
                                                                                        
                                        }
                                    }
                                }
                            }
                        }

                        if (flag)
                        {
                            break;
                        }
                    }
                }
            }
        }
    }

    @Override
    protected void recursiveGenerate(World par1World, int par2, int par3, int par4, int par5, Block[] blockIdArray, byte[] metaArray)
    {
        int var7 = this.rand.nextInt(this.rand.nextInt(this.rand.nextInt(40) + 1) + 1);

        if (this.rand.nextInt(15) != 0)
        {
            var7 = 0;
        }

        for (int var8 = 0; var8 < var7; ++var8)
        {
            final double var9 = par2 * 16 + this.rand.nextInt(16);
            final double var11 = this.rand.nextInt(this.rand.nextInt(120) + 8);
            final double var13 = par3 * 16 + this.rand.nextInt(16);
            int var15 = 1;

            if (this.rand.nextInt(4) == 0)
            {
                this.generateLargeCaveNode(this.rand.nextLong(), par4, par5, blockIdArray, metaArray, var9, var11, var13);
                var15 += this.rand.nextInt(4);
            }

            for (int var16 = 0; var16 < var15; ++var16)
            {
                final float var17 = this.rand.nextFloat() * (float) Math.PI * 2.0F;
                final float var18 = (this.rand.nextFloat() - 0.5F) * 2.0F / 8.0F;
                float var19 = this.rand.nextFloat() * 2.0F + this.rand.nextFloat();

                if (this.rand.nextInt(10) == 0)
                {
                    var19 *= this.rand.nextFloat() * this.rand.nextFloat() * 3.0F + 1.0F;
                }

                this.generateCaveNode(this.rand.nextLong(), par4, par5, blockIdArray, metaArray, var9, var11, var13, var19, var17, var18, 0, 0, 1.0D);
            }
        }
    }
}

[merge_posts_bbcode]Добавлено: 29.11.2015 02:10:51[/merge_posts_bbcode]

Может ли Biome Decorator глушить генерацию структур?

nickita45 · 28 Ноя 2015

Какая версия?Ты в главном классе объявил ?
Смотрел как в майне это сделано с озерами?

BlesseNtumble · 28 Ноя 2015

nickita45 написал(а):
Какая версия?Ты в главном классе объявил ?
Смотрел как в майне это сделано с озерами?

1.7.10
Все объявлено.

Озера генерируются через Biome Decorator.
[merge_posts_bbcode]Добавлено: 29.11.2015 02:20:50[/merge_posts_bbcode]

У меня 18 измерений, 2 из которых используют чанкпровайдер выше.
И именно в том, который выше не работает генерация структур.

Все остальное (Биомы, уровень моря и прочее) генерируется как надо. Декоратор тоже вроде работает нормально.

nickita45 · 28 Ноя 2015

Не могу понять.Но по логике должен быть класс отвечающий за генерацию структур?
В лс напишу ответ.

BlesseNtumble · 28 Ноя 2015

nickita45 написал(а):
Не могу понять.Но по логике должен быть класс отвечающий за генерацию структур?
В лс напишу ответ.

Ну MapGenBase разве не он?
У меня используется модифицированный. MapGenBaseMeta

nickita45 · 28 Ноя 2015

Тебе надо свой создать(класс отвечающий за генерацию построек в мире).

BlesseNtumble · 28 Ноя 2015

nickita45 написал(а):
Тебе надо свой создать.

Зачем?

Код:

public abstract class MapGenBaseMeta
{
    /**
     * The number of Chunks to gen-check in any given direction.
     */
    protected int range = 8;

    /**
     * The RNG used by the MapGen classes.
     */
    protected Random rand = new Random();

    /**
     * This world object.
     */
    protected World worldObj;

    public void generate(IChunkProvider par1IChunkProvider, World world, int chunkX, int chunkZ, Block[] blocks, byte[] metadata)
    {
        this.worldObj = world;
        this.rand.setSeed(world.getSeed());
        final long r0 = this.rand.nextLong();
        final long r1 = this.rand.nextLong();

        for (int x0 = chunkX - this.range; x0 <= chunkX + this.range; ++x0)
        {
            for (int y0 = chunkZ - this.range; y0 <= chunkZ + this.range; ++y0)
            {
                final long randX = x0 * r0;
                final long randZ = y0 * r1;
                this.rand.setSeed(randX ^ randZ ^ world.getSeed());
                this.recursiveGenerate(world, x0, y0, chunkX, chunkZ, blocks, metadata);
            }
        }
    }

    /**
     * Recursively called by generate() (generate) and optionally by itself.
     */
    protected void recursiveGenerate(World world, int xChunkCoord, int zChunkCoord, int origXChunkCoord, int origZChunkCoord, Block[] blocks, byte[] metadata)
    {
    }
}

[merge_posts_bbcode]Добавлено: 29.11.2015 02:35:07[/merge_posts_bbcode]

Как я уже сказал, 16 дименсов используют другой чанкпровайдер, в котором генерируется все прекрасно.
Генераторы пещер абсолютно одинаковы за исключением проверок на блоки.

nickita45 · 28 Ноя 2015

Значит пещеры генерируются,а озёры нет?

BlesseNtumble · 28 Ноя 2015

nickita45 написал(а):
Значит пещеры генерируются,а озёры нет?

Еще раз объясняю:

Есть дименс 1, у которого Родитель ChunkProvider1
И есть дименс 2, у которого Родитель ChunkProvider2

В ChunkProvider1 любые структуры (Пещеры, Каньоны и тд) генерируются прекрасно (Последний скрин)
А в ChunkProvider2, неизвестно почему, структуры не генерируются.