Jump to content
Search the Forums BEFORE making a new post.
Currently supported: All versions

How to make Terrain Gen?

adamAndMath

By adamAndMath
in Modder Support

 Share

Recommended Posts

hydroflame World Shaper

hydroflame

Posted
Posted

well i don't have a tutorial, but i made some test with that and ill print you my classes.

 

I ADMIT I COPY PASTED. i dont reaaally know what exactly is doing what and why.

 

on a side note. i do know a lot about procedural generation and simplex/perlin noise, you *might* want to look at those before considering generating terrain as they are the source of minecraft terrain generation

 

package com.hydroflame.dimension;

import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.world.WorldProviderEnd;
import net.minecraftforge.common.DimensionManager;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.common.registry.LanguageRegistry;

@Mod(modid = "dimension", name = "Dimension Example", version = "EXAMPLE")
public class Dimension {

    @Instance("dimension")
    public static Dimension instance;

    public static int dimensionID;

    public static Block dimensionBlock;

    @PreInit
    @SuppressWarnings("deprecation")
    public void preInit(FMLPreInitializationEvent event) {
    	dimensionID = DimensionManager.getNextFreeDimId();
        DimensionManager.registerProviderType(dimensionID, WorldProviderDimension.class, false);
        DimensionManager.registerDimension(dimensionID, dimensionID);

        dimensionBlock = new BlockDimensionBlock(499, Material.rock).setCreativeTab(CreativeTabs.tabBlock).setUnlocalizedName("blockDiamond");
        GameRegistry.registerBlock(dimensionBlock);
        LanguageRegistry.addName(dimensionBlock, "Dimension Block");
        
    }

    @Init
    public void init(FMLInitializationEvent event) {}

    @PostInit
    public void postInit(FMLPostInitializationEvent ecent) {}
}

 

package com.hydroflame.dimension;

import net.minecraft.block.Block;
import net.minecraft.entity.monster.EntityEnderman;
import net.minecraft.world.biome.BiomeEndDecorator;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.biome.SpawnListEntry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class BiomeGenAether extends BiomeGenBase{
public BiomeGenAether(int par1)
    {
        super(par1);
        this.spawnableMonsterList.clear();
        this.spawnableCreatureList.clear();
        this.spawnableWaterCreatureList.clear();
        this.spawnableCaveCreatureList.clear();
        this.topBlock = (byte)Block.dirt.blockID;
        this.fillerBlock = (byte)Block.dirt.blockID;
    }


    /**
     * takes temperature, returns color
     */
    @SideOnly(Side.CLIENT)
    public int getSkyColorByTemp(float par1)
    {
        return 1;
    }
}

 

package com.hydroflame.dimension;

import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.world.World;

public class BlockDimensionBlock extends Block {

    public BlockDimensionBlock(int par1, Material par2Material) {
        super(par1, par2Material);
    }

    @Override
    /**
     * Called upon block activation (right click on the block.)
     */
    public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9) {
        if (par5EntityPlayer.ridingEntity == null
                && par5EntityPlayer.riddenByEntity == null) {
            if (par5EntityPlayer instanceof EntityPlayerMP) {
                EntityPlayerMP thePlayer = (EntityPlayerMP) par5EntityPlayer;
                if (par5EntityPlayer.dimension != Dimension.dimensionID) {
                    thePlayer.mcServer
                    .getConfigurationManager()
                    .transferPlayerToDimension(
                            thePlayer,
                            Dimension.dimensionID,
                            new TeleporterDimension(
                                    thePlayer.mcServer
                                    .worldServerForDimension(Dimension.dimensionID)));
                    return true;
                } else {
                    thePlayer.mcServer.getConfigurationManager()
                    .transferPlayerToDimension(
                            thePlayer,
                            0,
                            new TeleporterDimension(thePlayer.mcServer
                                    .worldServerForDimension(0)));
                    return true;
                }
            } else
                return false;
        } else
            return false;
    }
}

 

package com.hydroflame.dimension;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.MINESHAFT;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.RAVINE;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.SCATTERED_FEATURE;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.STRONGHOLD;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.VILLAGE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAVA;

import java.util.List;
import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.SpawnerAnimals;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.MapGenBase;
import net.minecraft.world.gen.MapGenCaves;
import net.minecraft.world.gen.MapGenRavine;
import net.minecraft.world.gen.NoiseGeneratorOctaves;
import net.minecraft.world.gen.feature.MapGenScatteredFeature;
import net.minecraft.world.gen.feature.WorldGenDungeons;
import net.minecraft.world.gen.feature.WorldGenLakes;
import net.minecraft.world.gen.structure.MapGenMineshaft;
import net.minecraft.world.gen.structure.MapGenStronghold;
import net.minecraft.world.gen.structure.MapGenVillage;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.Event.Result;
import net.minecraftforge.event.terraingen.ChunkProviderEvent;
import net.minecraftforge.event.terraingen.PopulateChunkEvent;
import net.minecraftforge.event.terraingen.TerrainGen;

public class ChunkManagerDimension implements IChunkProvider {

    /** RNG. */
    private Random rand;

    /** A NoiseGeneratorOctaves used in generating terrain */
    private NoiseGeneratorOctaves noiseGen1;

    /** A NoiseGeneratorOctaves used in generating terrain */
    private NoiseGeneratorOctaves noiseGen2;

    /** A NoiseGeneratorOctaves used in generating terrain */
    private NoiseGeneratorOctaves noiseGen3;

    /** A NoiseGeneratorOctaves used in generating terrain */
    private NoiseGeneratorOctaves noiseGen4;

    /** 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;

    /**
     * Holds the overall noise array used in chunk
     * generation
     */
    private double[] noiseArray;
    private double[] stoneNoise = new double[256];
    private MapGenBase caveGenerator = new MapGenCaves();

    /** Holds Stronghold Generator */
    private MapGenStronghold strongholdGenerator = new MapGenStronghold();

    /** Holds Village Generator */
    private MapGenVillage villageGenerator = new MapGenVillage();

    /** Holds Mineshaft Generator */
    private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();
    private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();

    /** Holds ravine generator */
    private MapGenBase ravineGenerator = new MapGenRavine();

    /** The biomes that are used to generate the chunk */
    private BiomeGenBase[] biomesForGeneration;

    /**
     * A double array that hold terrain noise from noiseGen3
     */
    double[] noise3;

    /** A double array that hold terrain noise */
    double[] noise1;

    /**
     * A double array that hold terrain noise from noiseGen2
     */
    double[] noise2;

    /**
     * A double array that hold terrain noise from noiseGen5
     */
    double[] noise5;

    /**
     * A double array that holds terrain noise from
     * noiseGen6
     */
    double[] noise6;

    /**
     * Used to store the 5x5 parabolic field that is used
     * during terrain generation.
     */
    float[] parabolicField;
    int[][] field_73219_j = new int[32][32];

    {
        caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);
        strongholdGenerator = (MapGenStronghold) TerrainGen.getModdedMapGen(
                strongholdGenerator, STRONGHOLD);
        villageGenerator = (MapGenVillage) TerrainGen.getModdedMapGen(
                villageGenerator, VILLAGE);
        mineshaftGenerator = (MapGenMineshaft) TerrainGen.getModdedMapGen(
                mineshaftGenerator, MINESHAFT);
        scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen
                .getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);
        ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);
    }

    public ChunkManagerDimension(World par1World, long par2, boolean par4) {
        this.worldObj = par1World;
        this.mapFeaturesEnabled = par4;
        this.rand = new Random(par2);
        this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);
        this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);
        this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, ;
        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, ;

        NoiseGeneratorOctaves[] noiseGens = { noiseGen1, noiseGen2, noiseGen3,
                noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise };
        noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.rand,
                noiseGens);
        this.noiseGen1 = noiseGens[0];
        this.noiseGen2 = noiseGens[1];
        this.noiseGen3 = noiseGens[2];
        this.noiseGen4 = noiseGens[3];
        this.noiseGen5 = noiseGens[4];
        this.noiseGen6 = noiseGens[5];
        this.mobSpawnerNoise = noiseGens[6];
    }

    /**
     * Returns if the IChunkProvider supports saving.
     */
    @Override
    public boolean canSave() {
        return true;
    }

    /**
     * Checks to see if a chunk exists at x, y
     */
    @Override
    public boolean chunkExists(int par1, int par2) {
        return true;
    }

    /**
     * Returns the location of the closest structure of the
     * specified type. If not found returns null.
     */
    @Override
    public ChunkPosition findClosestStructure(World par1World, String par2Str,
            int par3, int par4, int par5) {
        return "Stronghold".equals(par2Str) && this.strongholdGenerator != null ? this.strongholdGenerator
                .getNearestInstance(par1World, par3, par4, par5) : null;
    }

    @Override
    public void func_104112_b() {

    }

    /**
     * Generates the shape of the terrain for the chunk
     * though its all stone though the water is frozen if
     * the temperature is low enough
     */
    public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte) {
        byte var4 = 4;
        byte var5 = 16;
        byte var6 = 63;
        int var7 = var4 + 1;
        byte var8 = 17;
        int var9 = var4 + 1;
        this.biomesForGeneration = this.worldObj.getWorldChunkManager()
                .getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2,
                        par2 * 4 - 2, var7 + 5, var9 + 5);
        this.noiseArray = this.initializeNoiseField(this.noiseArray, par1
                * var4, 0, par2 * var4, var7, var8, var9);

        for (int var10 = 0; var10 < var4; ++var10) {
            for (int var11 = 0; var11 < var4; ++var11) {
                for (int var12 = 0; var12 < var5; ++var12) {
                    double var13 = 0.125D;
                    double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0)
                            * var8 + var12 + 0];
                    double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1)
                            * var8 + var12 + 0];
                    double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0)
                            * var8 + var12 + 0];
                    double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1)
                            * var8 + var12 + 0];
                    double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0)
                            * var8 + var12 + 1] - var15)
                            * var13;
                    double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1)
                            * var8 + var12 + 1] - var17)
                            * var13;
                    double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0)
                            * var8 + var12 + 1] - var19)
                            * var13;
                    double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1)
                            * var8 + var12 + 1] - var21)
                            * var13;

                    for (int var31 = 0; var31 < 8; ++var31) {
                        double var32 = 0.25D;
                        double var34 = var15;
                        double var36 = var17;
                        double var38 = (var19 - var15) * var32;
                        double var40 = (var21 - var17) * var32;

                        for (int var42 = 0; var42 < 4; ++var42) {
                            int var43 = var42 + var10 * 4 << 11
                                    | 0 + var11 * 4 << 7 | var12 * 8 + var31;
                            short var44 = 128;
                            var43 -= var44;
                            double var45 = 0.25D;
                            double var49 = (var36 - var34) * var45;
                            double var47 = var34 - var49;

                            for (int var51 = 0; var51 < 4; ++var51) {
                                if ((var47 += var49) > 0.0D) {
                                    par3ArrayOfByte[var43 += var44] = (byte) Block.ice.blockID;
                                } else if (var12 * 8 + var31 < var6) {
                                    par3ArrayOfByte[var43 += var44] = (byte) Block.ice.blockID;
                                } else {
                                    par3ArrayOfByte[var43 += var44] = 0;
                                }
                            }

                            var34 += var38;
                            var36 += var40;
                        }

                        var15 += var23;
                        var17 += var25;
                        var19 += var27;
                        var21 += var29;
                    }
                }
            }
        }
    }

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

    /**
     * Returns a list of creatures of the specified type
     * that can spawn at the given location.
     */
    @Override
    @SuppressWarnings("rawtypes")
    public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType,
            int par2, int par3, int par4) {
        BiomeGenBase var5 = this.worldObj.getBiomeGenForCoords(par2, par4);
        return var5 == null ? null : (var5 == BiomeGenBase.swampland
                && par1EnumCreatureType == EnumCreatureType.monster
                && this.scatteredFeatureGenerator.hasStructureAt(par2, par3,
                        par4) ? this.scatteredFeatureGenerator
                .getScatteredFeatureSpawnList() : var5
                .getSpawnableList(par1EnumCreatureType));
    }

    /**
     * generates a subset of the level's terrain data. Takes
     * 7 arguments: the [empty] noise array, the position,
     * and the size.
     */
    private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2,
            int par3, int par4, int par5, int par6, int par7) {
        ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(
                this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
        MinecraftForge.EVENT_BUS.post(event);
        if (event.getResult() == Result.DENY)
            return event.noisefield;

        if (par1ArrayOfDouble == null) {
            par1ArrayOfDouble = new double[par5 * par6 * par7];
        }

        if (this.parabolicField == null) {
            this.parabolicField = new float[25];

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

        double var44 = 684.412D;
        double var45 = 684.412D;
        this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2,
                par4, par5, par7, 1.121D, 1.121D, 0.5D);
        this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2,
                par4, par5, par7, 200.0D, 200.0D, 0.5D);
        this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2,
                par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D,
                var44 / 80.0D);
        this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2,
                par3, par4, par5, par6, par7, var44, var45, var44);
        this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2,
                par3, par4, par5, par6, par7, var44, var45, var44);
        int var12 = 0;
        int var13 = 0;

        for (int var14 = 0; var14 < par5; ++var14) {
            for (int var15 = 0; var15 < par7; ++var15) {
                float var16 = 0.0F;
                float var17 = 0.0F;
                float var18 = 0.0F;
                byte var19 = 2;
                BiomeGenBase var20 = this.biomesForGeneration[var14 + 2
                        + (var15 + 2) * (par5 + 5)];

                for (int var21 = -var19; var21 <= var19; ++var21) {
                    for (int var22 = -var19; var22 <= var19; ++var22) {
                        BiomeGenBase var23 = this.biomesForGeneration[var14
                                + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)];
                        float var24 = this.parabolicField[var21 + 2
                                + (var22 + 2) * 5]
                                / (var23.minHeight + 2.0F);

                        if (var23.minHeight > var20.minHeight) {
                            var24 /= 2.0F;
                        }

                        var16 += var23.maxHeight * var24;
                        var17 += var23.minHeight * var24;
                        var18 += var24;
                    }
                }

                var16 /= var18;
                var17 /= var18;
                var16 = var16 * 0.9F + 0.1F;
                var17 = (var17 * 4.0F - 1.0F) / 8.0F;
                double var47 = this.noise6[var13] / 8000.0D;

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

                var47 = var47 * 3.0D - 2.0D;

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

                    if (var47 < -1.0D) {
                        var47 = -1.0D;
                    }

                    var47 /= 1.4D;
                    var47 /= 2.0D;
                } else {
                    if (var47 > 1.0D) {
                        var47 = 1.0D;
                    }

                    var47 /= 8.0D;
                }

                ++var13;

                for (int var46 = 0; var46 < par6; ++var46) {
                    double var48 = var17;
                    double var26 = var16;
                    var48 += var47 * 0.2D;
                    var48 = var48 * par6 / 16.0D;
                    double var28 = par6 / 2.0D + var48 * 4.0D;
                    double var30 = 0.0D;
                    double var32 = (var46 - var28) * 12.0D * 128.0D / 128.0D
                            / var26;

                    if (var32 < 0.0D) {
                        var32 *= 4.0D;
                    }

                    double var34 = this.noise1[var12] / 512.0D;
                    double var36 = this.noise2[var12] / 512.0D;
                    double var38 = (this.noise3[var12] / 10.0D + 1.0D) / 2.0D;

                    if (var38 < 0.0D) {
                        var30 = var34;
                    } else if (var38 > 1.0D) {
                        var30 = var36;
                    } else {
                        var30 = var34 + (var36 - var34) * var38;
                    }

                    var30 -= var32;

                    if (var46 > par6 - 4) {
                        double var40 = (var46 - (par6 - 4)) / 3.0F;
                        var30 = var30 * (1.0D - var40) + -10.0D * var40;
                    }

                    par1ArrayOfDouble[var12] = var30;
                    ++var12;
                }
            }
        }

        return par1ArrayOfDouble;
    }

    /**
     * loads or generates the chunk at the chunk location
     * specified
     */
    @Override
    public Chunk loadChunk(int par1, int par2) {
        return this.provideChunk(par1, par2);
    }

    /**
     * Converts the instance data to a readable string.
     */
    @Override
    public String makeString() {
        return "RandomLevelSource";
    }

    /**
     * Populates chunk with ores etc etc
     */
    @Override
    public void populate(IChunkProvider par1IChunkProvider, int par2, int par3) {

        BlockSand.fallInstantly = true;
        int var4 = par2 * 16;
        int var5 = par3 * 16;
        BiomeGenBase var6 = 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(par2 * var7 + par3 * var9 ^ this.worldObj.getSeed());
        boolean var11 = false;

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(
                par1IChunkProvider, worldObj, rand, par2, par3, var11));

        if (this.mapFeaturesEnabled) {
            this.mineshaftGenerator.generateStructuresInChunk(this.worldObj,
                    this.rand, par2, par3);
            var11 = this.villageGenerator.generateStructuresInChunk(
                    this.worldObj, this.rand, par2, par3);
            this.strongholdGenerator.generateStructuresInChunk(this.worldObj,
                    this.rand, par2, par3);
            this.scatteredFeatureGenerator.generateStructuresInChunk(
                    this.worldObj, this.rand, par2, par3);
        }

        int var12;
        int var13;
        int var14;

        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3,
                var11, LAKE) && !var11 && this.rand.nextInt(4) == 0) {
            var12 = var4 + this.rand.nextInt(16) + 8;
            var13 = this.rand.nextInt(128);
            var14 = var5 + this.rand.nextInt(16) + 8;
            (new WorldGenLakes(Block.ice.blockID)).generate(
                    this.worldObj, this.rand, var12, var13, var14);
        }

        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3,
                var11, LAVA) && !var11 && this.rand.nextInt( == 0) {
            var12 = var4 + this.rand.nextInt(16) + 8;
            var13 = this.rand.nextInt(this.rand.nextInt(120) + ;
            var14 = var5 + this.rand.nextInt(16) + 8;

            if (var13 < 63 || this.rand.nextInt(10) == 0) {
                (new WorldGenLakes(Block.lavaStill.blockID)).generate(
                        this.worldObj, this.rand, var12, var13, var14);
            }
        }

        boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand,
                par2, par3, var11, DUNGEON);
        for (var12 = 0; doGen && var12 < 8; ++var12) {
            var13 = var4 + this.rand.nextInt(16) + 8;
            var14 = this.rand.nextInt(128);
            int var15 = var5 + this.rand.nextInt(16) + 8;

            if ((new WorldGenDungeons()).generate(this.worldObj, this.rand,
                    var13, var14, var15)) {
                ;
            }
        }

        var6.decorate(this.worldObj, this.rand, var4, var5);
        SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4 + 8,
                var5 + 8, 16, 16, this.rand);
        var4 += 8;
        var5 += 8;

        doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2,
                par3, var11, ICE);
        for (var12 = 0; doGen && var12 < 16; ++var12) {
            for (var13 = 0; var13 < 16; ++var13) {
                var14 = this.worldObj.getPrecipitationHeight(var4 + var12, var5
                        + var13);

                if (this.worldObj.isBlockFreezable(var12 + var4, var14 - 1,
                        var13 + var5)) {
                    this.worldObj.setBlock(var12 + var4, var14 - 1, var13
                            + var5, Block.ice.blockID, 2, 2);
                }

                if (this.worldObj.canSnowAt(var12 + var4, var14, var13 + var5)) {
                    this.worldObj.setBlock(var12 + var4, var14, var13 + var5,
                            Block.snow.blockID, 2, 2);
                }
            }
        }

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(
                par1IChunkProvider, worldObj, rand, par2, par3, var11));

        BlockSand.fallInstantly = false;
    }

    /**
     * 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
     */
    @Override
    public Chunk provideChunk(int par1, int par2) {
        this.rand.setSeed(par1 * 341873128712L + par2 * 132897987541L);
        byte[] var3 = new byte[32768];
        this.generateTerrain(par1, par2, var3);
        this.biomesForGeneration = this.worldObj.getWorldChunkManager()
                .loadBlockGeneratorData(this.biomesForGeneration, par1 * 16,
                        par2 * 16, 16, 16);
        this.replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);
        this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);
        this.ravineGenerator.generate(this, this.worldObj, par1, par2, var3);

        if (this.mapFeaturesEnabled) {
            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2,
                    var3);
            this.villageGenerator.generate(this, this.worldObj, par1, par2,
                    var3);
            this.strongholdGenerator.generate(this, this.worldObj, par1, par2,
                    var3);
            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1,
                    par2, var3);
        }

        Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
        byte[] var5 = var4.getBiomeArray();

        for (int var6 = 0; var6 < var5.length; ++var6) {
            var5[var6] = (byte) this.biomesForGeneration[var6].biomeID;
        }

        var4.generateSkylightMap();
        return var4;
    }

    @Override
    public void recreateStructures(int par1, int par2) {
        if (this.mapFeaturesEnabled) {
            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2,
                    (byte[]) null);
            this.villageGenerator.generate(this, this.worldObj, par1, par2,
                    (byte[]) null);
            this.strongholdGenerator.generate(this, this.worldObj, par1, par2,
                    (byte[]) null);
            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1,
                    par2, (byte[]) null);
        }
    }

    /**
     * Replaces the stone that was placed in with blocks
     * that match the biome
     */
    public void replaceBlocksForBiome(int par1, int par2,
            byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase) {
        ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(
                this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase);
        MinecraftForge.EVENT_BUS.post(event);
        if (event.getResult() == Result.DENY)
            return;

        byte var5 = 63;
        double var6 = 0.03125D;
        this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise,
                par1 * 16, par2 * 16, 0, 16, 16, 1, var6 * 2.0D, var6 * 2.0D,
                var6 * 2.0D);

        for (int var8 = 0; var8 < 16; ++var8) {
            for (int var9 = 0; var9 < 16; ++var9) {
                BiomeGenBase var10 = par4ArrayOfBiomeGenBase[var9 + var8 * 16];
                float var11 = var10.getFloatTemperature();
                int var12 = (int) (this.stoneNoise[var8 + var9 * 16] / 3.0D + 3.0D + this.rand
                        .nextDouble() * 0.25D);
                int var13 = -1;
                byte var14 = var10.topBlock;
                byte var15 = var10.fillerBlock;

                for (int var16 = 127; var16 >= 0; --var16) {
                    int var17 = (var9 * 16 + var8) * 128 + var16;

                    if (var16 <= 0 + this.rand.nextInt(5)) {
                        par3ArrayOfByte[var17] = (byte) Block.bedrock.blockID;
                    } else {
                        byte var18 = par3ArrayOfByte[var17];

                        if (var18 == 0) {
                            var13 = -1;
                        } else if (var18 == Block.ice.blockID) {
                            if (var13 == -1) {
                                if (var12 <= 0) {
                                    var14 = 0;
                                    var15 = (byte) Block.ice.blockID;
                                } else if (var16 >= var5 - 4
                                        && var16 <= var5 + 1) {
                                    var14 = var10.topBlock;
                                    var15 = var10.fillerBlock;
                                }

                                if (var16 < var5 && var14 == 0) {
                                    // this has to do with
                                    // temperatures, make
                                    // them the same to be
                                    // the same no matter
                                    // what temperature
                                    if (var11 < 0.15F) {
                                        var14 = (byte) Block.ice.blockID;
                                    } else {
                                        var14 = (byte) Block.ice.blockID;
                                    }
                                }

                                var13 = var12;

                                if (var16 >= var5 - 1) {
                                    par3ArrayOfByte[var17] = var14;
                                } else {
                                    par3ArrayOfByte[var17] = var15;
                                }
                            } else if (var13 > 0) {
                                --var13;
                                par3ArrayOfByte[var17] = var15;

                                if (var13 == 0 && var15 == Block.sand.blockID) {
                                    var13 = this.rand.nextInt(4);
                                    var15 = (byte) Block.sandStone.blockID;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 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.
     */
    @Override
    public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate) {
        return true;
    }

    /**
     * Unloads the 100 oldest chunks from memory, due to a
     * bug with chunkSet.add() never being called it thinks
     * the list is always empty and will not remove any
     * chunks.
     */
    public boolean unload100OldestChunks() {
        return false;
    }

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

 

package com.hydroflame.dimension;

import java.util.List;
import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.NoiseGeneratorOctaves;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.Event.Result;
import net.minecraftforge.event.terraingen.ChunkProviderEvent;
import net.minecraftforge.event.terraingen.PopulateChunkEvent;
import net.minecraftforge.event.terraingen.TerrainGen;

public class ChunkProviderAether implements IChunkProvider{
    private Random endRNG;
    private NoiseGeneratorOctaves noiseGen1;
    private NoiseGeneratorOctaves noiseGen2;
    private NoiseGeneratorOctaves noiseGen3;
    public NoiseGeneratorOctaves noiseGen4;
    public NoiseGeneratorOctaves noiseGen5;
    private World endWorld;
    private double[] densities;

    /** The biomes that are used to generate the chunk */
    private BiomeGenBase[] biomesForGeneration;
    double[] noiseData1;
    double[] noiseData2;
    double[] noiseData3;
    double[] noiseData4;
    double[] noiseData5;
    int[][] field_73203_h = new int[32][32];

    public ChunkProviderAether(World par1World, long par2)
    {
        this.endWorld = par1World;
        this.endRNG = new Random(par2);
        this.noiseGen1 = new NoiseGeneratorOctaves(this.endRNG, 16);
        this.noiseGen2 = new NoiseGeneratorOctaves(this.endRNG, 16);
        this.noiseGen3 = new NoiseGeneratorOctaves(this.endRNG, ;
        this.noiseGen4 = new NoiseGeneratorOctaves(this.endRNG, 10);
        this.noiseGen5 = new NoiseGeneratorOctaves(this.endRNG, 16);

        NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5};
        noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.endRNG, noiseGens);
        this.noiseGen1 = noiseGens[0];
        this.noiseGen2 = noiseGens[1];
        this.noiseGen3 = noiseGens[2];
        this.noiseGen4 = noiseGens[3];
        this.noiseGen5 = noiseGens[4];
   }

    public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
    {
        byte b0 = 2;
        int k = b0 + 1;
        byte b1 = 33;
        int l = b0 + 1;
        this.densities = this.initializeNoiseField(this.densities, par1 * b0, 0, par2 * b0, k, b1, l);

        for (int i1 = 0; i1 < b0; ++i1)
        {
            for (int j1 = 0; j1 < b0; ++j1)
            {
                for (int k1 = 0; k1 < 32; ++k1)
                {
                    double d0 = 0.05D;
                    double d1 = this.densities[((i1 + 0) * l + j1 + 0) * b1 + k1 + 0];
                    double d2 = this.densities[((i1 + 0) * l + j1 + 1) * b1 + k1 + 0];
                    double d3 = this.densities[((i1 + 1) * l + j1 + 0) * b1 + k1 + 0];
                    double d4 = this.densities[((i1 + 1) * l + j1 + 1) * b1 + k1 + 0];
                    double d5 = (this.densities[((i1 + 0) * l + j1 + 0) * b1 + k1 + 1] - d1) * d0;
                    double d6 = (this.densities[((i1 + 0) * l + j1 + 1) * b1 + k1 + 1] - d2) * d0;
                    double d7 = (this.densities[((i1 + 1) * l + j1 + 0) * b1 + k1 + 1] - d3) * d0;
                    double d8 = (this.densities[((i1 + 1) * l + j1 + 1) * b1 + k1 + 1] - d4) * d0;

                    for (int l1 = 0; l1 < 4; ++l1)
                    {
                        double d9 = 0.125D;
                        double d10 = d1;
                        double d11 = d2;
                        double d12 = (d3 - d1) * d9;
                        double d13 = (d4 - d2) * d9;

                        for (int i2 = 0; i2 < 8; ++i2)
                        {
                            int j2 = i2 + i1 * 8 << 11 | 0 + j1 * 8 << 7 | k1 * 4 + l1;
                            short short1 = 128;
                            double d14 = 0.125D;
                            double d15 = d10;
                            double d16 = (d11 - d10) * d14;

                            for (int k2 = 0; k2 < 8; ++k2)
                            {
                                int l2 = 0;

                                if (d15 > 0.0D)
                                {
                                    l2 = Block.stone.blockID;
                                }

                                par3ArrayOfByte[j2] = (byte)l2;
                                j2 += short1;
                                d15 += d16;
                            }

                            d10 += d12;
                            d11 += d13;
                        }

                        d1 += d5;
                        d2 += d6;
                        d3 += d7;
                        d4 += d8;
                    }
                }
            }
        }
    }

    public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
    {
        ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase);
        MinecraftForge.EVENT_BUS.post(event);
        if (event.getResult() == Result.DENY) return;

        for (int k = 0; k < 16; ++k)
        {
            for (int l = 0; l < 16; ++l)
            {
                byte b0 = 1;
                int i1 = -1;
                byte b1 = (byte)Block.stone.blockID;
                byte b2 = (byte)Block.stone.blockID;

                for (int j1 = 127; j1 >= 0; --j1)
                {
                    int k1 = (l * 16 + k) * 128 + j1;
                    byte b3 = par3ArrayOfByte[k1];

                    if (b3 == 0)
                    {
                        i1 = -1;
                    }
                    else if (b3 == Block.stone.blockID)
                    {
                        if (i1 == -1)
                        {
                            if (b0 <= 0)
                            {
                                b1 = 0;
                                b2 = (byte)Block.stone.blockID;
                            }

                            i1 = b0;

                            if (j1 >= 0)
                            {
                                par3ArrayOfByte[k1] = b1;
                            }
                            else
                            {
                                par3ArrayOfByte[k1] = b2;
                            }
                        }
                        else if (i1 > 0)
                        {
                            --i1;
                            par3ArrayOfByte[k1] = b2;
                        }
                    }
                }
            }
        }
    }

    /**
     * loads or generates the chunk at the chunk location specified
     */
    public Chunk loadChunk(int par1, int par2)
    {
        return this.provideChunk(par1, par2);
    }

    /**
     * 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 par1, int par2)
    {
        this.endRNG.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
        byte[] abyte = new byte[32768];
        this.biomesForGeneration = this.endWorld.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
        this.generateTerrain(par1, par2, abyte, this.biomesForGeneration);
        this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);
        Chunk chunk = new Chunk(this.endWorld, abyte, par1, par2);
        byte[] abyte1 = chunk.getBiomeArray();

        for (int k = 0; k < abyte1.length; ++k)
        {
            abyte1[k] = (byte)this.biomesForGeneration[k].biomeID;
        }

        chunk.generateSkylightMap();
        return chunk;
    }

    /**
     * generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
     * size.
     */
    private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
    {
        ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
        MinecraftForge.EVENT_BUS.post(event);
        if (event.getResult() == Result.DENY) return event.noisefield;

        if (par1ArrayOfDouble == null)
        {
            par1ArrayOfDouble = new double[par5 * par6 * par7];
        }

        double d0 = 684.412D;
        double d1 = 684.412D;
        this.noiseData4 = this.noiseGen4.generateNoiseOctaves(this.noiseData4, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
        this.noiseData5 = this.noiseGen5.generateNoiseOctaves(this.noiseData5, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
        d0 *= 2.0D;
        this.noiseData1 = this.noiseGen3.generateNoiseOctaves(this.noiseData1, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D);
        this.noiseData2 = this.noiseGen1.generateNoiseOctaves(this.noiseData2, par2, par3, par4, par5, par6, par7, d0, d1, d0);
        this.noiseData3 = this.noiseGen2.generateNoiseOctaves(this.noiseData3, par2, par3, par4, par5, par6, par7, d0, d1, d0);
        int k1 = 0;
        int l1 = 0;

        for (int i2 = 0; i2 < par5; ++i2)
        {
            for (int j2 = 0; j2 < par7; ++j2)
            {
                double d2 = (this.noiseData4[l1] + 256.0D) / 512.0D;

                if (d2 > 1.0D)
                {
                    d2 = 1.0D;
                }

                double d3 = this.noiseData5[l1] / 8000.0D;

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

                d3 = d3 * 3.0D - 2.0D;
                float f = (float)(i2 + par2 - 0) / 1.0F;
                float f1 = (float)(j2 + par4 - 0) / 1.0F;
                float f2 = 100.0F - MathHelper.sqrt_float(f * f + f1 * f1) * 8.0F;

                if (f2 > 80.0F)
                {
                    f2 = 80.0F;
                }

                if (f2 < -100.0F)
                {
                    f2 = -100.0F;
                }

                if (d3 > 1.0D)
                {
                    d3 = 1.0D;
                }

                d3 /= 8.0D;
                d3 = 0.0D;

                if (d2 < 0.0D)
                {
                    d2 = 0.0D;
                }

                d2 += 0.5D;
                d3 = d3 * (double)par6 / 16.0D;
                ++l1;
                double d4 = (double)par6 / 2.0D;

                for (int k2 = 0; k2 < par6; ++k2)
                {
                    double d5 = 0.0D;
                    double d6 = ((double)k2 - d4) * 8.0D / d2;

                    if (d6 < 0.0D)
                    {
                        d6 *= -1.0D;
                    }

                    double d7 = this.noiseData2[k1] / 512.0D;
                    double d8 = this.noiseData3[k1] / 512.0D;
                    double d9 = (this.noiseData1[k1] / 10.0D + 1.0D) / 2.0D;

                    if (d9 < 0.0D)
                    {
                        d5 = d7;
                    }
                    else if (d9 > 1.0D)
                    {
                        d5 = d8;
                    }
                    else
                    {
                        d5 = d7 + (d8 - d7) * d9;
                    }

                    d5 -= 8.0D;
                    d5 += (double)f2;
                    byte b0 = 2;
                    double d10;

                    if (k2 > par6 / 2 - b0)
                    {
                        d10 = (double)((float)(k2 - (par6 / 2 - b0)) / 64.0F);

                        if (d10 < 0.0D)
                        {
                            d10 = 0.0D;
                        }

                        if (d10 > 1.0D)
                        {
                            d10 = 1.0D;
                        }

                        d5 = d5 * (1.0D - d10) + -3000.0D * d10;
                    }

                    b0 = 8;

                    if (k2 < b0)
                    {
                        d10 = (double)((float)(b0 - k2) / ((float)b0 - 1.0F));
                        d5 = d5 * (1.0D - d10) + -30.0D * d10;
                    }

                    par1ArrayOfDouble[k1] = d5;
                    ++k1;
                }
            }
        }

        return par1ArrayOfDouble;
    }

    /**
     * Checks to see if a chunk exists at x, y
     */
    public boolean chunkExists(int par1, int par2)
    {
        return true;
    }

    /**
     * Populates chunk with ores etc etc
     */
    public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)
    {
        BlockSand.fallInstantly = true;

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, endWorld, endWorld.rand, par2, par3, false));

        int k = par2 * 16;
        int l = par3 * 16;
        BiomeGenBase biomegenbase = this.endWorld.getBiomeGenForCoords(k + 16, l + 16);
        biomegenbase.decorate(this.endWorld, this.endWorld.rand, k, l);

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, endWorld, endWorld.rand, par2, par3, false));

        BlockSand.fallInstantly = false;
    }

    /**
     * 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 par1, IProgressUpdate par2IProgressUpdate)
    {
        return true;
    }

    public void func_104112_b() {}

    /**
     * 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";
    }

    /**
     * Returns a list of creatures of the specified type that can spawn at the given location.
     */
    public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
    {
    	return null;
    }

    /**
     * Returns the location of the closest structure of the specified type. If not found returns null.
     */
    public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
    {
        return null;
    }

    public int getLoadedChunkCount()
    {
        return 0;
    }

    public void recreateStructures(int par1, int par2) {}


}

 

package com.hydroflame.dimension;

import net.minecraft.entity.Entity;
import net.minecraft.world.Teleporter;
import net.minecraft.world.WorldServer;

public class TeleporterDimension extends Teleporter {

    public TeleporterDimension(WorldServer par1WorldServer) {
        super(par1WorldServer);
    }

    @Override
    public boolean makePortal(Entity par1Entity) {
        
        return true;
    }

    @Override
    public boolean placeInExistingPortal(Entity par1Entity, double par2,
            double par4, double par6, float par8) {
        return false;
    }
}

 

package com.hydroflame.dimension;

import net.minecraft.block.Block;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.MathHelper;
import net.minecraft.util.Vec3;
import net.minecraft.world.WorldProvider;
import net.minecraft.world.biome.WorldChunkManagerHell;
import net.minecraft.world.chunk.IChunkProvider;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class WorldProviderDimension extends WorldProvider {

/**
     * creates a new world chunk manager for WorldProvider
     */
    public void registerWorldChunkManager()
    {
        this.worldChunkMgr = new WorldChunkManagerHell(new BiomeGenAether(23), 0.5F, 0.0F);
        this.dimensionId = 1;
        this.hasNoSky = false;
    }

    /**
     * Returns a new chunk provider which generates chunks for this world
     */
    public IChunkProvider createChunkGenerator()
    {
        return new ChunkProviderAether(this.worldObj, this.worldObj.getSeed());
    }

    /**
     * Calculates the angle of sun and moon in the sky relative to a specified time (usually worldTime)
     */
    public float calculateCelestialAngle(long par1, float par3)
    {
        return 0.0F;
    }

    @SideOnly(Side.CLIENT)

    /**
     * Returns array with sunrise/sunset colors
     */
    public float[] calcSunriseSunsetColors(float par1, float par2)
    {
        return new float[]{1, 1, 1, 1};
    }

    @SideOnly(Side.CLIENT)

    /**
     * Return Vec3D with biome specific fog color
     */
    public Vec3 getFogColor(float par1, float par2)
    {
        int i = 10518688;
        float f2 = MathHelper.cos(par1 * (float)Math.PI * 2.0F) * 2.0F + 0.5F;

        if (f2 < 0.0F)
        {
            f2 = 0.0F;
        }

        if (f2 > 1.0F)
        {
            f2 = 1.0F;
        }

        float f3 = (float)(i >> 16 & 255) / 255.0F;
        float f4 = (float)(i >> 8 & 255) / 255.0F;
        float f5 = (float)(i & 255) / 255.0F;
        f3 *= f2 * 0.0F + 0.15F;
        f4 *= f2 * 0.0F + 0.15F;
        f5 *= f2 * 0.0F + 0.15F;
        return this.worldObj.getWorldVec3Pool().getVecFromPool((double)f3, (double)f4, (double)f5);
    }

    @SideOnly(Side.CLIENT)
    public boolean isSkyColored()
    {
        return true;
    }

    /**
     * True if the player can respawn in this dimension (true = overworld, false = nether).
     */
    public boolean canRespawnHere()
    {
        return false;
    }

    /**
     * Returns 'true' if in the "main surface world", but 'false' if in the Nether or End dimensions.
     */
    public boolean isSurfaceWorld()
    {
        return true;
    }

    @SideOnly(Side.CLIENT)

    /**
     * the y level at which clouds are rendered.
     */
    public float getCloudHeight()
    {
        return 128.0F;
    }

    /**
     * Will check if the x, z position specified is alright to be set as the map spawn point
     */
    public boolean canCoordinateBeSpawn(int par1, int par2)
    {
        int k = this.worldObj.getFirstUncoveredBlock(par1, par2);
        return k == 0 ? false : Block.blocksList[k].blockMaterial.blocksMovement();
    }

    /**
     * Gets the hard-coded portal location to use when entering this dimension.
     */
    public ChunkCoordinates getEntrancePortalLocation()
    {
        return new ChunkCoordinates(100, 50, 0);
    }

    public int getAverageGroundLevel()
    {
        return 50;
    }

    @SideOnly(Side.CLIENT)

    /**
     * Returns true if the given X,Z coordinate should show environmental fog.
     */
    public boolean doesXZShowFog(int par1, int par2)
    {
        return false;
    }

    /**
     * Returns the dimension's name, e.g. "The End", "Nether", or "Overworld".
     */
    public String getDimensionName()
    {
        return "Aether";
    }
}

 

ORIGINAL SOURCE: mew, MODIFIED BY: hydroflame

how to debug 101:http://www.minecraftforge.net/wiki/Debug_101

-hydroflame, author of the forge revolution-

hydroflame World Shaper

hydroflame

Posted
Posted

I'm not going to go into the details, but "noise" in this case is a set of randomly generated value that can output result that looks like terrain you shouldnt have to touch this unless you're doing something very very very very very very very very very specific, like very very very!!

how to debug 101:http://www.minecraftforge.net/wiki/Debug_101

-hydroflame, author of the forge revolution-

adamAndMath Tree Puncher

adamAndMath

Posted
  • Author
Posted

Ok, and I have spend so much time renaming variables.

 

Well I would like to generate a dimension with a roof that sortof follows the grounds height. Can you tell me have to use the output of "initializeNoiseField".

hydroflame World Shaper

hydroflame

Posted
Posted

this subject is actually very complicated so it would be hard to explain in a forum, but if you look at ChunkProviderAether.generateTerrain you should be able to find what you're looking for

how to debug 101:http://www.minecraftforge.net/wiki/Debug_101

-hydroflame, author of the forge revolution-

hydroflame World Shaper

hydroflame

Posted
Posted

no i know they really look alike and they are super hard to read, play around with the value and see what effect is has

how to debug 101:http://www.minecraftforge.net/wiki/Debug_101

-hydroflame, author of the forge revolution-

hydroflame World Shaper

hydroflame

Posted
Posted

im guessing that notch original code generate a layer of stone then another layer of dirt and the rest

 

maybe decorators

 

btw i envy your code very much right now :(

how to debug 101:http://www.minecraftforge.net/wiki/Debug_101

-hydroflame, author of the forge revolution-

adamAndMath Tree Puncher

adamAndMath

Posted
  • Author
Posted

Sorry. Here is the code:

package uwe.core.world;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAVA;

import java.util.List;
import java.util.Random;

import uwe.core.world.gen.feature.WorldGenNightStone;

import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.SpawnerAnimals;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.MapGenBase;
import net.minecraft.world.gen.MapGenCaves;
import net.minecraft.world.gen.NoiseGeneratorOctaves;
import net.minecraft.world.gen.feature.WorldGenLakes;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.Event.Result;
import net.minecraftforge.event.terraingen.ChunkProviderEvent;
import net.minecraftforge.event.terraingen.PopulateChunkEvent;
import net.minecraftforge.event.terraingen.TerrainGen;

public class ChunkProviderL1 implements IChunkProvider
{
float[] parabolicField;

private final byte stoneByte = (byte) Block.stone.blockID;
private final byte waterByte = (byte) Block.waterStill.blockID;
private final int blockMain = Block.stone.blockID;
private final int liquidStill = Block.waterStill.blockID;

private Random rand;

/** A NoiseGeneratorOctaves used in generating nether terrain */
private NoiseGeneratorOctaves noiseGen1;
private NoiseGeneratorOctaves noiseGen2;
private NoiseGeneratorOctaves noiseGen3;
private NoiseGeneratorOctaves noiseGen4;
private NoiseGeneratorOctaves noiseGen5;
private NoiseGeneratorOctaves noiseGen6;

/** Is the world that the nether is getting generated. */
private World worldObj;
private double[] noiseField;

/** The biomes that are used to generate the chunk */
private BiomeGenBase[] biomesForGeneration;

private MapGenBase caveGenerator = new MapGenCaves();
protected double[] noiseData1;
protected double[] noiseData2;
protected double[] noiseData3;
protected double[] noiseData5;
protected double[] noiseData6;

{
	caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);
}

public ChunkProviderL1(World par1World, long par2)
{
	this.worldObj = par1World;
	this.rand = new Random(par2);
	this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);
	this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);
	this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, ;
	this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4);
	this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 16);
	this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);

	NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6};
	noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.rand, noiseGens);
	this.noiseGen1 = noiseGens[0];
	this.noiseGen2 = noiseGens[1];
	this.noiseGen3 = noiseGens[2];
	this.noiseGen4 = noiseGens[3];
	this.noiseGen5 = noiseGens[4];
	this.noiseGen6 = noiseGens[5];
}

/**
 * Generates the shape of the terrain.
 */
public void generateTerrain(int chunkX, int chunkZ, byte[] blockArray)
{
	byte chunkSize = 4;
	byte height = (byte) (64 / chunkSize);
	byte oceanHeight = 32;
	int sizeX = chunkSize + 1;
	byte sizeY = (byte) (height + 1);
	int sizeZ = chunkSize + 1;

	this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, chunkX * 4 - 2, chunkZ * 4 - 2, sizeX + 5, sizeY + 5);
	this.noiseField = this.initializeNoiseField(this.noiseField, chunkX * chunkSize, 0, chunkZ * chunkSize, sizeX, sizeY, sizeZ);

	for(int x = 0; x < chunkSize; ++x)
	{
		for(int z = 0; z < chunkSize; ++z)
		{
			for(int y = 0; y < height; ++y)
			{
				double terrainType = 1.0D;
				double nf1 = this.noiseField[((x + 0) * sizeZ + z + 0) * sizeY + y + 0];
				double nf2 = this.noiseField[((x + 0) * sizeZ + z + 1) * sizeY + y + 0];
				double nf3 = this.noiseField[((x + 1) * sizeZ + z + 0) * sizeY + y + 0];
				double nf4 = this.noiseField[((x + 1) * sizeZ + z + 1) * sizeY + y + 0];
				double nf1plus = (this.noiseField[((x + 0) * sizeZ + z + 0) * sizeY + y + 1] - nf1) * terrainType;
				double nf2plus = (this.noiseField[((x + 0) * sizeZ + z + 1) * sizeY + y + 1] - nf2) * terrainType;
				double nf3plus = (this.noiseField[((x + 1) * sizeZ + z + 0) * sizeY + y + 1] - nf3) * terrainType;
				double nf4plus = (this.noiseField[((x + 1) * sizeZ + z + 1) * sizeY + y + 1] - nf4) * terrainType;

				int test0 = 2 * chunkSize;
				int test1 = 16 / chunkSize;

				for(int exY = 0; exY < test0; ++exY)
				{
					double d9 = 0.25D;
					double mainNoise = nf1;
					double secondNoise = nf2;
					double d12 = (nf3 - nf1) * d9;
					double d13 = (nf4 - nf2) * d9;

					for(int exX = 0; exX < test1; ++exX)
					{
						int place = exX + x * test1 << 11 | 0 + z * test1 << 7 | y * test0 + exY;
						short worldHeight = 128;
						double d14 = 0.25D;
						double d15 = (secondNoise - mainNoise) * d14;
						double d16 = mainNoise - d15;

						for(int exZ = 0; exZ < test1; ++exZ)
						{
							int placedBlock = 0;

							if ((d16 += d15) > 0.0D)
							{
								placedBlock = stoneByte;
							}
							else if (y * 8 + exY < oceanHeight)
							{
								placedBlock = waterByte;
							}


							blockArray[place] = (byte) placedBlock;
							place += worldHeight;
						}

						mainNoise += d12;
						secondNoise += d13;
					}

					nf1 += nf1plus;
					nf2 += nf2plus;
					nf3 += nf3plus;
					nf4 += nf4plus;
				}
			}
		}
	}
}

/**
 * name based on ChunkProviderGenerate
 */
public void replaceBlocksForBiome(int par1, int par2, byte[] blockArray, BiomeGenBase[] biomes)
{
	ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, blockArray, biomes);
	MinecraftForge.EVENT_BUS.post(event);
	if (event.getResult() == Result.DENY)
	{
		return;
	}

	byte waterHeight = 63;

	for (int posX = 0; posX < 16; ++posX)
	{
		for (int posZ = 0; posZ < 16; ++posZ)
		{
			byte air = (byte) blockMain;
			byte ground = (byte) blockMain;

			for (int posY = 127; posY >= 0; --posY)
			{
				int pos = (posZ * 16 + posX) * 128 + posY;

				if (posY <= 0 + this.rand.nextInt(5))
				{
					blockArray[pos] = (byte) Block.bedrock.blockID;
				}
				else if (posY >= 127 - this.rand.nextInt(5))
				{
					blockArray[pos] = (byte) Block.bedrock.blockID;
				}
				else
				{
					if (blockArray[pos] == stoneByte)
					{
						if (posY >= waterHeight - 4 && posY <= waterHeight + 1)
						{
							air = (byte) blockMain;
							ground = (byte) blockMain;
						}

						if (posY < waterHeight && air == 0)
						{
							air = (byte) liquidStill;
						}

						if (posY >= waterHeight - 1)
						{
							blockArray[pos] = air;
						}
						else
						{
							blockArray[pos] = ground;
						}
					}
				}
			}
		}
	}
}

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

@Override
public Chunk provideChunk(int chunkX, int chunkZ)
{
	this.rand.setSeed((long) chunkX * 341873128712L + (long) chunkZ * 132897987541L);
	byte[] blockArray = new byte[32768];
	this.generateTerrain(chunkX, chunkZ, blockArray);
	this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, chunkX * 16, chunkZ * 16, 16, 16);
	this.replaceBlocksForBiome(chunkX, chunkZ, blockArray, biomesForGeneration);
	this.caveGenerator.generate(this, this.worldObj, chunkX, chunkZ, blockArray);
	Chunk chunk = new Chunk(this.worldObj, blockArray, chunkX, chunkZ);
	byte[] biomeIds = chunk.getBiomeArray();

	for(int i = 0; i < biomeIds.length; ++i)
	{
		biomeIds[i] = (byte) biomesForGeneration[i].biomeID;
	}

	chunk.resetRelightChecks();
	return chunk;
}

private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
{
	ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
	MinecraftForge.EVENT_BUS.post(event);
	if (event.getResult() == Result.DENY) return event.noisefield;

	if (par1ArrayOfDouble == null)
	{
		par1ArrayOfDouble = new double[par5 * par6 * par7];
	}

	if (this.parabolicField == null)
	{
		this.parabolicField = new float[25];

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

	double d0 = 684.412D;
	double d1 = 684.412D;
	this.noiseData5 = this.noiseGen5.generateNoiseOctaves(this.noiseData5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
	this.noiseData6 = this.noiseGen6.generateNoiseOctaves(this.noiseData6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
	this.noiseData3 = this.noiseGen3.generateNoiseOctaves(this.noiseData3, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D);
	this.noiseData1 = this.noiseGen1.generateNoiseOctaves(this.noiseData1, par2, par3, par4, par5, par6, par7, d0, d1, d0);
	this.noiseData2 = this.noiseGen2.generateNoiseOctaves(this.noiseData2, par2, par3, par4, par5, par6, par7, d0, d1, d0);
	int i2 = 0;
	int j2 = 0;

	for (int k2 = 0; k2 < par5; ++k2)
	{
		for (int l2 = 0; l2 < par7; ++l2)
		{
			float f1 = 0.0F;
			float f2 = 0.0F;
			float f3 = 0.0F;
			byte b0 = 2;
			BiomeGenBase biomegenbase = this.biomesForGeneration[k2 + 2 + (l2 + 2) * (par5 + 5)];

			for (int i3 = -b0; i3 <= b0; ++i3)
			{
				for (int j3 = -b0; j3 <= b0; ++j3)
				{
					BiomeGenBase biomegenbase1 = this.biomesForGeneration[k2 + i3 + 2 + (l2 + j3 + 2) * (par5 + 5)];
					float f4 = this.parabolicField[i3 + 2 + (j3 + 2) * 5] / (biomegenbase1.minHeight + 2.0F);

					if (biomegenbase1.minHeight > biomegenbase.minHeight)
					{
						f4 /= 2.0F;
					}

					f1 += biomegenbase1.maxHeight * f4;
					f2 += biomegenbase1.minHeight * f4;
					f3 += f4;
				}
			}

			f1 /= f3;
			f2 /= f3;
			f1 = f1 * 0.9F + 0.1F;
			f2 = (f2 * 4.0F - 1.0F) / 8.0F;
			double d2 = this.noiseData6[j2] / 8000.0D;

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

			d2 = d2 * 3.0D - 2.0D;

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

				if (d2 < -1.0D)
				{
					d2 = -1.0D;
				}

				d2 /= 1.4D;
				d2 /= 2.0D;
			}
			else
			{
				if (d2 > 1.0D)
				{
					d2 = 1.0D;
				}

				d2 /= 8.0D;
			}

			++j2;

			for (int k3 = 0; k3 < par6; ++k3)
			{
				double d3 = (double)f2;
				double d4 = (double)f1;
				d3 += d2 * 0.2D;
				d3 = d3 * (double)par6 / 16.0D;
				double d5 = (double)par6 / 2.0D + d3 * 4.0D;
				double d6 = 0.0D;
				double d7 = ((double)k3 - d5) * 12.0D * 128.0D / 128.0D / d4;

				if (d7 < 0.0D)
				{
					d7 *= 4.0D;
				}

				double d8 = this.noiseData1[i2] / 512.0D;
				double d9 = this.noiseData2[i2] / 512.0D;
				double d10 = (this.noiseData3[i2] / 10.0D + 1.0D) / 2.0D;

				if (d10 < 0.0D)
				{
					d6 = d8;
				}
				else if (d10 > 1.0D)
				{
					d6 = d9;
				}
				else
				{
					d6 = d8 + (d9 - d8) * d10;
				}

				d6 -= d7;

				if (k3 > par6 - 4)
				{
					double d11 = (double)((float)(k3 - (par6 - 4)) / 3.0F);
					d6 = d6 * (1.0D - d11) + -10.0D * d11;
				}

				par1ArrayOfDouble[i2] = d6;
				++i2;
			}
		}
	}

	return par1ArrayOfDouble;
}

@Override
public boolean chunkExists(int par1, int par2)
{
	return true;
}

@Override
public void populate(IChunkProvider chunkProvider, int chunkX, int chunkZ)
{
	BlockSand.fallInstantly = true;

	int posX = chunkX * 16;
	int posZ = chunkZ * 16;

	BiomeGenBase biomegenbase = worldObj.getBiomeGenForCoords(posX + 16, posZ + 16);
	rand.setSeed(worldObj.getSeed());
	long seedX = rand.nextLong() / 2L * 2L + 1L;
	long seedZ = rand.nextLong() / 2L * 2L + 1L;
	rand.setSeed((long)chunkX * seedX + (long)chunkZ * seedZ ^ worldObj.getSeed());
	boolean flag = false;

	MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(chunkProvider, worldObj, rand, chunkX, chunkZ, flag));

	int x;
	int y;
	int z;

        int generates = rand.nextInt(rand.nextInt(10) + 1);
        
	for(int i = 0; i < generates; ++i)
	{
		x = posX + rand.nextInt(16) + 8;
		y = rand.nextInt(128 + 4);
		z = posZ + rand.nextInt(16) + 8;
		(new WorldGenNightStone()).generate(worldObj, rand, x, y, z);
	}

	for(int i = 0; i < 10; ++i)
	{
		x = posX + rand.nextInt(16) + 8;
		y = rand.nextInt(128);
		z = posZ + rand.nextInt(16) + 8;
		(new WorldGenNightStone()).generate(worldObj, rand, x, y, z);
	}

	if (TerrainGen.populate(chunkProvider, worldObj, rand, chunkX, chunkZ, flag, LAVA) && !flag && this.rand.nextInt( == 0)
	{
		x = posX + this.rand.nextInt(16) + 8;
		y = this.rand.nextInt(this.rand.nextInt(120) + ;
		z = posZ + this.rand.nextInt(16) + 8;

		if (y < 63 || this.rand.nextInt(10) == 0)
		{
			(new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, x, y, z);
		}
	}

	biomegenbase.decorate(this.worldObj, this.rand, posX, posZ);
	SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, posX + 8, posZ + 8, 16, 16, this.rand);

	MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(chunkProvider, worldObj, rand, chunkX, chunkZ, flag));

	BlockSand.fallInstantly = false;
}

@Override
public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate)
{
	return true;
}

@Override
public void func_104112_b()
{

}

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

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

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

@Override
@SuppressWarnings("rawtypes")
public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
{
	BiomeGenBase var5 = this.worldObj.getBiomeGenForCoords(par2, par4);
	return var5 == null? null : var5.getSpawnableList(par1EnumCreatureType);
}

@Override
public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
{
	return null;
}

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

@Override
public void recreateStructures(int par1, int par2)
{
}
}

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
 Share
Go to topic listing

Announcements



×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.

  I accept