[1.8] Dimension problems!

[DaveTheModder]

I'm trying to create custom dimensions. For development purposes only, I have it so that when a certain shovel is right-clicked, the player teleports to the dimension. The problem is that whenever I right click the shovel it takes me to the dimension for a tiny bit of time, but then takes me to the nether. Occasionally, it'll take me to the dimension, but not often.

 

Here is my WorldProvider class:

 

package com.codingcrusader.metalsplusplus;

 

import net.minecraft.world.WorldProvider;

import net.minecraft.world.biome.WorldChunkManagerHell;

import net.minecraft.world.chunk.Chunk;

import net.minecraft.world.chunk.IChunkProvider;

 

public class WorldProviderMetal extends WorldProvider {

    @Override

    protected void registerWorldChunkManager() {

        super.registerWorldChunkManager();

        this.worldChunkMgr = new WorldChunkManagerHell(new BiomeGenBronze(MetalMod.biomeBronzeId), 0.1F);

        this.dimensionId = MetalMod.dimensionBronzeId;

    }

 

    @Override

    public String getSaveFolder()

    {

        return "DIM-Bronze";

    }

 

    @Override

    public String getWelcomeMessage()

    {

        return "Yolo.....";

    }

 

    @Override

    public String getInternalNameSuffix() {

        return "bronzedimension";

    }

 

    @Override

    public String getDepartMessage()

    {

        return ".....oloY";

    }

 

    @Override

    public boolean canRespawnHere()

    {

        return true;

    }

 

    @Override

    public IChunkProvider createChunkGenerator()

    {

        return new ChunkProviderMetal(worldObj, worldObj.getSeed(), worldObj.getWorldInfo().isMapFeaturesEnabled(), worldObj.getWorldInfo().getGeneratorOptions());

    }

 

    @Override

    public String getDimensionName()

    {

        return "Bronze";

    }

 

 

    @Override

    public boolean canDoLightning(Chunk chunk)

    {

        return true;

    }

 

    @Override

    public boolean canDoRainSnowIce(Chunk chunk)

    {

        return false;

    }

}

 

 

 

Here is my ChunkProvider class:

 

package com.codingcrusader.metalsplusplus;

 

import net.minecraft.block.Block;

import net.minecraft.block.BlockFalling;

import net.minecraft.entity.EnumCreatureType;

import net.minecraft.init.Blocks;

import net.minecraft.util.BlockPos;

import net.minecraft.util.IProgressUpdate;

import net.minecraft.util.MathHelper;

import net.minecraft.world.ChunkCoordIntPair;

import net.minecraft.world.SpawnerAnimals;

import net.minecraft.world.World;

import net.minecraft.world.WorldType;

import net.minecraft.world.biome.BiomeGenBase;

import net.minecraft.world.chunk.Chunk;

import net.minecraft.world.chunk.ChunkPrimer;

import net.minecraft.world.chunk.IChunkProvider;

import net.minecraft.world.gen.*;

import net.minecraft.world.gen.feature.WorldGenDungeons;

import net.minecraft.world.gen.feature.WorldGenLakes;

import net.minecraft.world.gen.structure.*;

import net.minecraftforge.common.MinecraftForge;

import net.minecraftforge.event.terraingen.ChunkProviderEvent;

import net.minecraftforge.event.terraingen.PopulateChunkEvent;

import net.minecraftforge.event.terraingen.TerrainGen;

import net.minecraftforge.fml.common.eventhandler.Event;

 

import java.util.List;

import java.util.Random;

 

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*;

import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*;

 

public class ChunkProviderMetal implements IChunkProvider {

        /** RNG. */

        private Random rand;

        private NoiseGeneratorOctaves field_147431_j;

        private NoiseGeneratorOctaves field_147432_k;

        private NoiseGeneratorOctaves field_147429_l;

        private NoiseGeneratorPerlin field_147430_m;

        /** A NoiseGeneratorOctaves used in generating terrain */

        public NoiseGeneratorOctaves noiseGen5;

        /** A NoiseGeneratorOctaves used in generating terrain */

        public NoiseGeneratorOctaves noiseGen6;

        public NoiseGeneratorOctaves mobSpawnerNoise;

        /** Reference to the World object. */

        private World worldObj;

        /** are map structures going to be generated (e.g. strongholds) */

        private final boolean mapFeaturesEnabled;

        private WorldType field_177475_o;

        private final double[] field_147434_q;

        private final float[] parabolicField;

        private ChunkProviderSettings settings;

        private Block field_177476_s;

        private double[] stoneNoise;

        private MapGenBase caveGenerator;

        /** Holds Stronghold Generator */

        /** Holds Village Generator */

        /** Holds Mineshaft Generator */

        private MapGenMineshaft mineshaftGenerator;

        private MapGenScatteredFeature scatteredFeatureGenerator;

        /** Holds ravine generator */

        private MapGenBase ravineGenerator;

        /** The biomes that are used to generate the chunk */

        private BiomeGenBase[] biomesForGeneration;

        double[] field_147427_d;

        double[] field_147428_e;

        double[] field_147425_f;

        double[] field_147426_g;

 

        public ChunkProviderMetal(World worldIn, long p_i45636_2_, boolean p_i45636_4_, String p_i45636_5_)

        {

            this.field_177476_s = Blocks.water;

            this.stoneNoise = new double[256];

            this.caveGenerator = new MapGenCaves();

            this.mineshaftGenerator = new MapGenMineshaft();

            this.scatteredFeatureGenerator = new MapGenScatteredFeature();

            this.ravineGenerator = new MapGenRavine();

            {

                caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);

                mineshaftGenerator = (MapGenMineshaft)TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT);

                scatteredFeatureGenerator = (MapGenScatteredFeature)TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);

                ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);

            }

            this.worldObj = worldIn;

            this.mapFeaturesEnabled = p_i45636_4_;

            this.field_177475_o = worldIn.getWorldInfo().getTerrainType();

            this.rand = new Random(p_i45636_2_);

            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, ;

            this.field_147430_m = new NoiseGeneratorPerlin(this.rand, 4);

            this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);

            this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);

            this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, ;

            this.field_147434_q = 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((float) (j * j + k * k) + 0.2F);

                    this.parabolicField[j + 2 + (k + 2) * 5] = f;

                }

            }

 

            if (p_i45636_5_ != null)

            {

                this.settings = ChunkProviderSettings.Factory.func_177865_a(p_i45636_5_).func_177864_b();

                this.field_177476_s = this.settings.useLavaOceans ? Blocks.lava : Blocks.water;

            }

 

            NoiseGenerator[] noiseGens = {field_147431_j, field_147432_k, field_147429_l, field_147430_m, noiseGen5, noiseGen6, mobSpawnerNoise};

            noiseGens = TerrainGen.getModdedNoiseGenerators(worldIn, this.rand, noiseGens);

            this.field_147431_j = (NoiseGeneratorOctaves)noiseGens[0];

            this.field_147432_k = (NoiseGeneratorOctaves)noiseGens[1];

            this.field_147429_l = (NoiseGeneratorOctaves)noiseGens[2];

            this.field_147430_m = (NoiseGeneratorPerlin)noiseGens[3];

            this.noiseGen5 = (NoiseGeneratorOctaves)noiseGens[4];

            this.noiseGen6 = (NoiseGeneratorOctaves)noiseGens[5];

            this.mobSpawnerNoise = (NoiseGeneratorOctaves)noiseGens[6];

        }

 

    public void setBlocksInChunk(int p_180518_1_, int p_180518_2_, ChunkPrimer p_180518_3_)

    {

        this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, p_180518_1_ * 4 - 2, p_180518_2_ * 4 - 2, 10, 10);

        this.func_147423_a(p_180518_1_ * 4, 0, p_180518_2_ * 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.field_147434_q[k1 + k2];

                    double d2 = this.field_147434_q[l1 + k2];

                    double d3 = this.field_147434_q[i2 + k2];

                    double d4 = this.field_147434_q[j2 + k2];

                    double d5 = (this.field_147434_q[k1 + k2 + 1] - d1) * d0;

                    double d6 = (this.field_147434_q[l1 + k2 + 1] - d2) * d0;

                    double d7 = (this.field_147434_q[i2 + k2 + 1] - d3) * d0;

                    double d8 = (this.field_147434_q[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)

                        {

                            double d14 = 0.25D;

                            double d16 = (d11 - d10) * d14;

                            double d15 = d10 - d16;

 

                            for (int j3 = 0; j3 < 4; ++j3)

                            {

                                if ((d15 += d16) > 0.0D)

                                {

                                    p_180518_3_.setBlockState(k * 4 + i3, k2 * 8 + l2, j1 * 4 + j3, Blocks.stone.getDefaultState());

                                }

                                else if (k2 * 8 + l2 < this.settings.seaLevel)

                                {

                                    p_180518_3_.setBlockState(k * 4 + i3, k2 * 8 + l2, j1 * 4 + j3, this.field_177476_s.getDefaultState());

                                }

                            }

 

                            d10 += d12;

                            d11 += d13;

                        }

 

                        d1 += d5;

                        d2 += d6;

                        d3 += d7;

                        d4 += d8;

                    }

                }

            }

        }

    }

 

    public void func_180517_a(int p_180517_1_, int p_180517_2_, ChunkPrimer p_180517_3_, BiomeGenBase[] p_180517_4_)

    {

        ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, p_180517_1_, p_180517_2_, p_180517_3_, this.worldObj);

        MinecraftForge.EVENT_BUS.post(event);

        if (event.getResult() == Event.Result.DENY) return;

 

        double d0 = 0.03125D;

        this.stoneNoise = this.field_147430_m.func_151599_a(this.stoneNoise, (double)(p_180517_1_ * 16), (double)(p_180517_2_ * 16), 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D);

 

        for (int k = 0; k < 16; ++k)

        {

            for (int l = 0; l < 16; ++l)

            {

                BiomeGenBase biomegenbase = p_180517_4_[l + k * 16];

                biomegenbase.genTerrainBlocks(this.worldObj, this.rand, p_180517_3_, p_180517_1_ * 16 + k, p_180517_2_ * 16 + l, this.stoneNoise[l + k * 16]);

            }

        }

    }

 

    /**

    * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the

    * specified chunk from the map seed and chunk seed

    */

    public Chunk provideChunk(int x, int z)

    {

        this.rand.setSeed((long)x * 341873128712L + (long)z * 132897987541L);

        ChunkPrimer chunkprimer = new ChunkPrimer();

        this.setBlocksInChunk(x, z, chunkprimer);

        this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, x * 16, z * 16, 16, 16);

        this.func_180517_a(x, z, chunkprimer, this.biomesForGeneration);

 

        if (this.settings.useCaves)

        {

            this.caveGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer);

        }

 

        if (this.settings.useRavines)

        {

            this.ravineGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer);

        }

 

        if (this.settings.useMineShafts && this.mapFeaturesEnabled)

        {

            this.mineshaftGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer);

        }

 

        if (this.settings.useTemples && this.mapFeaturesEnabled)

        {

            this.scatteredFeatureGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer);

        }

 

        Chunk chunk = new Chunk(this.worldObj, chunkprimer, x, z);

        byte[] abyte = chunk.getBiomeArray();

 

        for (int k = 0; k < abyte.length; ++k)

        {

            abyte[k] = (byte)this.biomesForGeneration[k].biomeID;

        }

 

        chunk.generateSkylightMap();

        return chunk;

    }

 

    private void func_147423_a(int p_147423_1_, int p_147423_2_, int p_147423_3_)

    {

        this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, p_147423_1_, p_147423_3_, 5, 5, (double)this.settings.depthNoiseScaleX, (double)this.settings.depthNoiseScaleZ, (double)this.settings.depthNoiseScaleExponent);

        float f = this.settings.coordinateScale;

        float f1 = this.settings.heightScale;

        this.field_147427_d = this.field_147429_l.generateNoiseOctaves(this.field_147427_d, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, (double)(f / this.settings.mainNoiseScaleX), (double)(f1 / this.settings.mainNoiseScaleY), (double)(f / this.settings.mainNoiseScaleZ));

        this.field_147428_e = this.field_147431_j.generateNoiseOctaves(this.field_147428_e, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, (double)f, (double)f1, (double)f);

        this.field_147425_f = this.field_147432_k.generateNoiseOctaves(this.field_147425_f, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, (double)f, (double)f1, (double)f);

        boolean flag1 = false;

        boolean flag = false;

        int l = 0;

        int i1 = 0;

 

        for (int j1 = 0; j1 < 5; ++j1)

        {

            for (int k1 = 0; k1 < 5; ++k1)

            {

                float f2 = 0.0F;

                float f3 = 0.0F;

                float f4 = 0.0F;

                byte b0 = 2;

                BiomeGenBase biomegenbase = this.biomesForGeneration[j1 + 2 + (k1 + 2) * 10];

 

                for (int l1 = -b0; l1 <= b0; ++l1)

                {

                    for (int i2 = -b0; i2 <= b0; ++i2)

                    {

                        BiomeGenBase biomegenbase1 = this.biomesForGeneration[j1 + l1 + 2 + (k1 + i2 + 2) * 10];

                        float f5 = this.settings.biomeDepthOffSet + biomegenbase1.minHeight * this.settings.biomeDepthWeight;

                        float f6 = this.settings.biomeScaleOffset + biomegenbase1.maxHeight * this.settings.biomeScaleWeight;

 

                        if (this.field_177475_o == WorldType.AMPLIFIED && f5 > 0.0F)

                        {

                            f5 = 1.0F + f5 * 2.0F;

                            f6 = 1.0F + f6 * 4.0F;

                        }

 

                        float f7 = this.parabolicField[l1 + 2 + (i2 + 2) * 5] / (f5 + 2.0F);

 

                        if (biomegenbase1.minHeight > biomegenbase.minHeight)

                        {

                            f7 /= 2.0F;

                        }

 

                        f2 += f6 * f7;

                        f3 += f5 * f7;

                        f4 += f7;

                    }

                }

 

                f2 /= f4;

                f3 /= f4;

                f2 = f2 * 0.9F + 0.1F;

                f3 = (f3 * 4.0F - 1.0F) / 8.0F;

                double d7 = this.field_147426_g[i1] / 8000.0D;

 

                if (d7 < 0.0D)

                {

                    d7 = -d7 * 0.3D;

                }

 

                d7 = d7 * 3.0D - 2.0D;

 

                if (d7 < 0.0D)

                {

                    d7 /= 2.0D;

 

                    if (d7 < -1.0D)

                    {

                        d7 = -1.0D;

                    }

 

                    d7 /= 1.4D;

                    d7 /= 2.0D;

                }

                else

                {

                    if (d7 > 1.0D)

                    {

                        d7 = 1.0D;

                    }

 

                    d7 /= 8.0D;

                }

 

                ++i1;

                double d8 = (double)f3;

                double d9 = (double)f2;

                d8 += d7 * 0.2D;

                d8 = d8 * (double)this.settings.baseSize / 8.0D;

                double d0 = (double)this.settings.baseSize + d8 * 4.0D;

 

                for (int j2 = 0; j2 < 33; ++j2)

                {

                    double d1 = ((double)j2 - d0) * (double)this.settings.stretchY * 128.0D / 256.0D / d9;

 

                    if (d1 < 0.0D)

                    {

                        d1 *= 4.0D;

                    }

 

                    double d2 = this.field_147428_e[l] / (double)this.settings.lowerLimitScale;

                    double d3 = this.field_147425_f[l] / (double)this.settings.upperLimitScale;

                    double d4 = (this.field_147427_d[l] / 10.0D + 1.0D) / 2.0D;

                    double d5 = MathHelper.denormalizeClamp(d2, d3, d4) - d1;

 

                    if (j2 > 29)

                    {

                        double d6 = (double)((float)(j2 - 29) / 3.0F);

                        d5 = d5 * (1.0D - d6) + -10.0D * d6;

                    }

 

                    this.field_147434_q[l] = d5;

                    ++l;

                }

            }

        }

    }

 

    /**

    * Checks to see if a chunk exists at x, z

    */

    public boolean chunkExists(int x, int z)

    {

        return true;

    }

 

    /**

    * Populates chunk with ores etc etc

    */

    public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_)

    {

        BlockFalling.fallInstantly = true;

        int k = p_73153_2_ * 16;

        int l = p_73153_3_ * 16;

        BlockPos blockpos = new BlockPos(k, 0, l);

        BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(blockpos.add(16, 0, 16));

        this.rand.setSeed(this.worldObj.getSeed());

        long i1 = this.rand.nextLong() / 2L * 2L + 1L;

        long j1 = this.rand.nextLong() / 2L * 2L + 1L;

        this.rand.setSeed((long)p_73153_2_ * i1 + (long)p_73153_3_ * j1 ^ this.worldObj.getSeed());

        boolean flag = false;

        ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(p_73153_2_, p_73153_3_);

 

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag));

 

        if (this.settings.useMineShafts && this.mapFeaturesEnabled)

        {

            this.mineshaftGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair);

        }

 

        if (this.settings.useTemples && this.mapFeaturesEnabled)

        {

            this.scatteredFeatureGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair);

        }

 

        int k1;

        int l1;

        int i2;

 

        if (biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && this.settings.useWaterLakes && !flag && this.rand.nextInt(this.settings.waterLakeChance) == 0

                && TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAKE))

        {

            k1 = this.rand.nextInt(16) + 8;

            l1 = this.rand.nextInt(256);

            i2 = this.rand.nextInt(16) + 8;

            (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, blockpos.add(k1, l1, i2));

        }

 

        if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAVA) && !flag && this.rand.nextInt(this.settings.lavaLakeChance / 10) == 0 && this.settings.useLavaLakes)

        {

            k1 = this.rand.nextInt(16) + 8;

            l1 = this.rand.nextInt(this.rand.nextInt(248) + ;

            i2 = this.rand.nextInt(16) + 8;

 

            if (l1 < 63 || this.rand.nextInt(this.settings.lavaLakeChance / == 0)

            {

                (new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, blockpos.add(k1, l1, i2));

            }

        }

 

        if (this.settings.useDungeons)

        {

            boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, DUNGEON);

            for (k1 = 0; doGen && k1 < this.settings.dungeonChance; ++k1)

            {

                l1 = this.rand.nextInt(16) + 8;

                i2 = this.rand.nextInt(256);

                int j2 = this.rand.nextInt(16) + 8;

                (new WorldGenDungeons()).generate(this.worldObj, this.rand, blockpos.add(l1, i2, j2));

            }

        }

 

        biomegenbase.decorate(this.worldObj, this.rand, new BlockPos(k, 0, l));

        if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ANIMALS))

        {

            SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand);

        }

        blockpos = blockpos.add(8, 0, ;

 

        boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ICE);

        for (k1 = 0; doGen && k1 < 16; ++k1)

        {

            for (l1 = 0; l1 < 16; ++l1)

            {

                BlockPos blockpos1 = this.worldObj.getPrecipitationHeight(blockpos.add(k1, 0, l1));

                BlockPos blockpos2 = blockpos1.down();

 

                if (this.worldObj.func_175675_v(blockpos2))

                {

                    this.worldObj.setBlockState(blockpos2, Blocks.ice.getDefaultState(), 2);

                }

 

                if (this.worldObj.canSnowAt(blockpos1, true))

                {

                    this.worldObj.setBlockState(blockpos1, Blocks.snow_layer.getDefaultState(), 2);

                }

            }

        }

 

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag));

 

        BlockFalling.fallInstantly = false;

    }

 

    public boolean func_177460_a(IChunkProvider p_177460_1_, Chunk p_177460_2_, int p_177460_3_, int p_177460_4_)

    {

        boolean flag = false;

 

        /*if (this.settings.useMonuments && this.mapFeaturesEnabled && p_177460_2_.getInhabitedTime() < 3600L)

        {

            flag |= this.oceanMonumentGenerator.func_175794_a(this.worldObj, this.rand, new ChunkCoordIntPair(p_177460_3_, p_177460_4_));

        }*/

 

        return flag;

    }

 

    /**

    * Two modes of operation: if passed true, save all Chunks in one go.  If passed false, save up to two chunks.

    * Return true if all chunks have been saved.

    */

    public boolean saveChunks(boolean p_73151_1_, IProgressUpdate p_73151_2_)

    {

        return true;

    }

 

    /**

    * Save extra data not associated with any Chunk.  Not saved during autosave, only during world unload.  Currently

    * unimplemented.

    */

    public void saveExtraData() {}

 

    /**

    * Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk.

    */

    public boolean unloadQueuedChunks()

    {

        return false;

    }

 

    /**

    * Returns if the IChunkProvider supports saving.

    */

    public boolean canSave()

    {

        return true;

    }

 

    /**

    * Converts the instance data to a readable string.

    */

    public String makeString()

    {

        return "RandomLevelSource";

    }

 

    public List func_177458_a(EnumCreatureType p_177458_1_, BlockPos p_177458_2_)

    {

        BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(p_177458_2_);

 

        if (this.mapFeaturesEnabled)

        {

            if (p_177458_1_ == EnumCreatureType.MONSTER && this.scatteredFeatureGenerator.func_175798_a(p_177458_2_))

            {

                return this.scatteredFeatureGenerator.getScatteredFeatureSpawnList();

            }

        }

 

        return biomegenbase.getSpawnableList(p_177458_1_);

    }

 

    @Override

    public BlockPos getStrongholdGen(World worldIn, String p_180513_2_, BlockPos p_180513_3_) {

        return null;

    }

 

    public int getLoadedChunkCount()

    {

        return 0;

    }

 

    public void recreateStructures(Chunk p_180514_1_, int p_180514_2_, int p_180514_3_)

    {

        if (this.settings.useMineShafts && this.mapFeaturesEnabled)

        {

            this.mineshaftGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null);

        }

 

        if (this.settings.useTemples && this.mapFeaturesEnabled)

        {

            this.scatteredFeatureGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null);

        }

    }

 

    public Chunk provideChunk(BlockPos blockPosIn)

    {

        return this.provideChunk(blockPosIn.getX() >> 4, blockPosIn.getZ() >> 4);

    }

}

 

 

 

If it helps, here is my custom BiomeGen:

 

package com.codingcrusader.metalsplusplus;

 

import com.codingcrusader.metalsplusplus.blocks.ModBlocks;

import net.minecraft.block.material.Material;

import net.minecraft.entity.passive.EntityCow;

import net.minecraft.init.Blocks;

import net.minecraft.util.BlockPos;

import net.minecraft.world.World;

import net.minecraft.world.biome.BiomeGenBase;

import net.minecraft.world.gen.feature.WorldGenBigMushroom;

import net.minecraft.world.gen.feature.WorldGenerator;

 

import java.util.Random;

 

public class BiomeGenBronze extends BiomeGenBase {

    private WorldGenerator bronzethingy;

    public final Material blockMaterial;

    public BiomeGenBronze(int par1) {

        super(par1);

        this.blockMaterial = Material.water;

        this.minHeight = 0.1F;

        this.maxHeight = 0.6F;

        this.topBlock = ModBlocks.copper_ore.getDefaultState();

        this.fillerBlock = Blocks.dirt.getDefaultState();

        this.setBiomeName("Bronze");

        this.waterColorMultiplier = 0xE42D17;

        this.theBiomeDecorator.deadBushPerChunk = 10;

    }

 

    @Override

    public void decorate(World worldIn, Random random, BlockPos p_180624_3_) {

        super.decorate(worldIn, random, p_180624_3_);

        int worldHeight = 0;

        while(worldIn.getBlockState(new BlockPos(p_180624_3_.getX(), worldHeight, p_180624_3_.getZ())) != Blocks.air.getDefaultState()) {

            worldHeight++;

        }

 

        if (random.nextInt(500) == 0)

        {

            int k = p_180624_3_.getX() + random.nextInt(16) + 8;

            int l = p_180624_3_.getZ() + random.nextInt(16) + 8;

            WorldGenBigMushroom worldgendesertwells = new WorldGenBigMushroom();

            worldgendesertwells.generate(worldIn, random, new BlockPos(k, worldHeight+1, l));

        }

    }

}

 

 

 

Any ideas what is causing the problem?

 

Thanks for help!

[thebest108]

Probably the fact your worldChunkManager is the same one used for the nether. That's the only thing I can see that could be causing it.

[DaveTheModder]

I would agree, but I've seen other mods do it the same way with apparently no issues.

 

Maybe I should create a custom WorldChunkManager?

[1Poseidon3]

I don't know much about Miinecraft 1.8 biome creation but maybe it is because you are using WorldChunkManagerHell and not WorldChunkManager. Like I said, I don't know much but that might be it.

 

 

EDIT: You also might want to disable BBCode in your post. It's making smilies inside the code.