Jump to content

How to make Terrain Gen?


adamAndMath

Recommended Posts

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-

Link to comment
Share on other sites

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-

Link to comment
Share on other sites

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-

Link to comment
Share on other sites

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-

Link to comment
Share on other sites

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)
{
}
}

Link to comment
Share on other sites

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.



  • Recently Browsing

    • No registered users viewing this page.
  • Posts

    • I'm developing a dimension, but it's kinda resource intensive so some times during player teleporting it lags behind making the player phase down into the void, so im trying to implement some kind of pregeneration to force the game loading a small set of chunks in the are the player will teleport to. Some of the things i've tried like using ServerLevel and ServerChunkCache methods like getChunk() dont actually trigger chunk generation if the chunk isn't already on persistent storage (already generated) or placing tickets, but that doesn't work either. Ideally i should be able to check when the task has ended too. I've peeked around some pregen engines, but they're too complex for my current understanding of the system of which I have just a basic understanding (how ServerLevel ,ServerChunkCache  and ChunkMap work) of. Any tips or other classes I should be looking into to understand how to do this correctly?
    • https://mclo.gs/4UC49Ao
    • Way back in the Forge 1.17 days, work started for adding JPMS (Java Platform Module Support) to ModLauncher and ForgeModLoader. This has been used internally by Forge and some libraries for a while now, but mods (those with mods.toml specifically) have not been able to take advantage of it. As of Forge 1.21.1 and 1.21.3, this is now possible!   What is JPMS and what does it mean for modders? JPMS is the Java Platform Module System, introduced in Java 9. It allows you to define modules, which are collections of packages and resources that can be exported or hidden from other modules. This allows for much more fine-tuned control over visibility, cleaner syntax for service declarations and support for sealed types across packages. For example, you might have a mod with a module called `com.example.mod` that exports `com.example.mod.api` and `com.example.mod.impl` to other mods, but hides `com.example.mod.internal` from them. This would allow you to have a clean API for other mods to use, while keeping your internal implementation details hidden from IDE hints, helping prevent accidental usage of internals that might break without prior notice. This is particularly useful if you'd like to use public records with module-private constructors or partially module-private record components, as you can create a sealed interface that only your record implements, having the interface be exported and the record hidden. It's also nice for declaring and using services, as you'll get compile-time errors from the Java compiler for typos and the like, rather than deferring to runtime errors. In more advanced cases, you can also have public methods that are only accessible to specific other modules -- handy if you want internal interactions between multiple of your own mods.   How do I bypass it? We understand there may be drama in implementing a system that prevents mods from accessing each other's internals when necessary (like when a mod is abandoned or you need to fix a compat issue) -- after all, we are already modding a game that doesn't have explicit support for Java mods yet. We have already thought of this and are offering APIs from day one to selectively bypass module restrictions. Let me be clear: Forge mods are not required to use JPMS. If you don't want to use it, you don't have to. The default behaviour is to have fully open, fully exported automatic modules. In Java, you can use the `Add-Opens` and `Add-Exports` manifest attributes to selectively bypass module restrictions of other mods at launch time, and we've added explicit support for these when loading your Forge mods. At compile-time, you can use existing solutions such as the extra-java-module-info Gradle plugin to deal with non-modular dependencies and add extra opens and exports to other modules. Here's an example on how to make the internal package `com.example.examplemod.internal` open to your mod in your build.gradle: tasks.named('jar', Jar) { manifest { attributes([ 'Add-Opens' : 'com.example.examplemod/com.example.examplemod.internal' 'Specification-Title' : mod_id, 'Specification-Vendor' : mod_authors // (...) ]) } } With the above in your mod's jar manifest, you can now reflectively access the classes inside that internal package. Multiple entries are separated with a space, as per Java's official spec. You can also use Add-Exports to directly call without reflection, however you'd need to use the Gradle plugin mentioned earlier to be able to compile. The syntax for Add-Exports is the same as Add-Opens, and instructions for the compile-time step with the Gradle plugin are detailed later in this post. Remember to prefer the opens and exports keywords inside module-info.java for sources you control. The Add-Opens/Add-Exports attributes are only intended for forcing open other mods.   What else is new with module support? Previously, the runtime module name was always forced to the first mod ID in your `mods.toml` file and all packages were forced fully open and exported. Module names are now distinguished from mod IDs, meaning the module name in your module-info.java can be different from the mod ID in your `mods.toml`. This allows you to have a more descriptive module name that doesn't have to be the same as your mod ID, however we strongly recommend including your mod ID as part of your module name to aid troubleshooting. The `Automatic-Module-Name` manifest attribute is now also honoured, allowing you to specify a module name for your mod without needing to create a `module-info.java` file. This is particularly useful for mods that don't care about JPMS features but want to have a more descriptive module name and easier integration with other mods that do use JPMS.   How do I use it? The first step is to create a `module-info.java` file in your mod's source directory. This file should be in the same package as your main mod class, and should look something like this: open module com.example.examplemod { requires net.minecraftforge.eventbus; requires net.minecraftforge.fmlcore; requires net.minecraftforge.forge; requires net.minecraftforge.javafmlmod; requires net.minecraftforge.mergetool.api; requires org.slf4j; requires logging; } For now, we're leaving the whole module open to reflection, which is a good starting point. When we know we want to close something off, we can remove the open modifier from the module and open or export individual packages instead. Remember that you need to be open to Forge (module name net.minecraftforge.forge), otherwise it can't call your mod's constructor. Next is fixing modules in Gradle. While Forge and Java support modules properly, Gradle does not put automatic modules on the module path by default, meaning that the logging module (from com.mojang:logging) is not found. To fix this, add the Gradle plugin and add a compile-time module definition for that Mojang library: plugins { // (...) id 'org.gradlex.extra-java-module-info' version "1.9" } // (...) extraJavaModuleInfo { failOnMissingModuleInfo = false automaticModule("com.mojang:logging", "logging") } The automatic module override specified in your build.gradle should match the runtime one to avoid errors. You can do the same for any library or mod dependency that is missing either a module-info or explicit Automatic-Module-Name, however be aware that you may need to update your mod once said library adds one. That's all you need to get started with module support in your mods. You can learn more about modules and how to use them at dev.java.
    • Faire la mise à jour grâce à ce lien m'a aider personnellement, merci à @Paint_Ninja. https://www.amd.com/en/support 
    • When I came across the 'Exit Code: I got a 1 error in my Minecraft mods, so I decided to figure out what was wrong. First, I took a look at the logs. In the mods folder (usually where you'd find logs or crash reports), I found the latest.log file or the corresponding crash report. I read it through carefully, looking for any lines with errors or warnings. Then I checked the Minecraft Forge support site, where you can often find info on what causes errors and how to fix them. I then disabled half of my mods and tried running the game. If the error disappeared, it meant that the problem was with the disabled mod. I repeated this several times to find the problem mod.
  • Topics

×
×
  • Create New...

Important Information

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