Dimension sans herbe, sans terre et sans grotte



  • Bonjour ou bonsoir tout le monde !

    Alors voila aujourd’hui je voulais faire un dimension en 1.7.2 donc je prend mon code de la 1.6.4 je change ce qui va pas tout fonctionne mais voila pas de terre ni de dirt, que de la stone et c'est asser ennuyeux je me rappelle avoir eu se "bug" avant que javai régler en mettant des ID inférieur a environ 200 pour la dirt et la grass mais la il n'y a plus d'ID donc voila et deuxième problème sa par contre je n'ai jamais réussi, c'est d'avoir des grotte dans ma dimension !

    Bon je ne sais pas trop quelle class vous donner, mais je pense que l'erreur doit être dans le chunkProvider

    package portuar.otherWorld.client.world;
    
    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 java.util.List;
    import java.util.Random;
    
    import portuar.otherWorld.client.MainClass;
    
    import net.minecraft.block.Block;
    import net.minecraft.block.BlockFalling;
    import net.minecraft.entity.EnumCreatureType;
    import net.minecraft.init.Blocks;
    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.WorldType;
    import net.minecraft.world.biome.BiomeGenBase;
    import net.minecraft.world.chunk.Chunk;
    import net.minecraft.world.chunk.IChunkProvider;
    import net.minecraft.world.gen.NoiseGenerator;
    import net.minecraft.world.gen.NoiseGeneratorOctaves;
    import net.minecraft.world.gen.NoiseGeneratorPerlin;
    import net.minecraft.world.gen.feature.WorldGenDungeons;
    import net.minecraft.world.gen.feature.WorldGenLakes;
    import net.minecraft.world.gen.structure.MapGenScatteredFeature;
    import net.minecraftforge.common.MinecraftForge;
    import net.minecraftforge.event.terraingen.ChunkProviderEvent;
    import net.minecraftforge.event.terraingen.PopulateChunkEvent;
    import net.minecraftforge.event.terraingen.TerrainGen;
    import cpw.mods.fml.common.eventhandler.Event.Result;
    
    public class ChunkProviderOtherWorld implements IChunkProvider
    {
    private Random rand;
    private NoiseGeneratorOctaves noiseGen1;
    private NoiseGeneratorOctaves noiseGen2;
    private NoiseGeneratorOctaves noiseGen3;
    private NoiseGeneratorPerlin noiseGen4;
    public NoiseGeneratorOctaves noiseGen5;
    public NoiseGeneratorOctaves noiseGen6;
    public NoiseGeneratorOctaves mobSpawnerNoise;
    private World worldObj;
    private final boolean mapFeaturesEnabled;
    private WorldType worldType;
    private final double[] noiseArray;
    private final float[] parabolicField;
    private double[] stoneNoise = new double[256];
    private BiomeGenBase[] biomesForGeneration;
    double[] field_147427_d;
    double[] field_147428_e;
    double[] field_147425_f;
    double[] field_147426_g;
    private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();
    
    public ChunkProviderOtherWorld(World world, long seed, boolean features)
    {
    this.worldObj = world;
    this.mapFeaturesEnabled = features;
    this.worldType = world.getWorldInfo().getTerrainType();
    this.rand = new Random(seed);
    this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);
    this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);
    this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, 8);
    this.noiseGen4 = new NoiseGeneratorPerlin(this.rand, 4);
    this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
    this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
    this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
    this.noiseArray = new double[825];
    this.parabolicField = new float[25];
    
    for(int j = -2; j <= 2; ++j)
    {
    for(int k = -2; k <= 2; ++k)
    {
    float f = 10.0F / MathHelper.sqrt_float((float)(j * j + k * k) + 0.2F);
    this.parabolicField[j + 2 + (k + 2) * 5] = f;
    }
    }
    
    NoiseGenerator[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise};
    noiseGens = TerrainGen.getModdedNoiseGenerators(world, this.rand, noiseGens);
    this.noiseGen1 = (NoiseGeneratorOctaves)noiseGens[0];
    this.noiseGen2 = (NoiseGeneratorOctaves)noiseGens[1];
    this.noiseGen3 = (NoiseGeneratorOctaves)noiseGens[2];
    this.noiseGen4 = (NoiseGeneratorPerlin)noiseGens[3];
    this.noiseGen5 = (NoiseGeneratorOctaves)noiseGens[4];
    this.noiseGen6 = (NoiseGeneratorOctaves)noiseGens[5];
    this.mobSpawnerNoise = (NoiseGeneratorOctaves)noiseGens[6];
    }
    
    // = generateTerrain
    public void func_147424_a(int chunkX, int chunkZ, Block[] surfaceBlock)
    {
    byte b0 = 63;
    this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, chunkX * 4 - 2, chunkZ * 4 - 2, 10, 10);
    this.func_147423_a(chunkX * 4, 0, chunkZ * 4);
    
    final Random rand = new Random();
    
    for(int k = 0; k < 4; ++k)
    {
    int l = k * 5;
    int i1 = (k + 1) * 5;
    
    for(int j1 = 0; j1 < 4; ++j1)
    {
    int k1 = (l + j1) * 33;
    int l1 = (l + j1 + 1) * 33;
    int i2 = (i1 + j1) * 33;
    int j2 = (i1 + j1 + 1) * 33;
    
    for(int k2 = 0; k2 < 32; ++k2)
    {
    double d0 = 0.105D;
    double d1 = this.noiseArray[k1 + k2];
    double d2 = this.noiseArray[l1 + k2];
    double d3 = this.noiseArray[i2 + k2];
    double d4 = this.noiseArray[j2 + k2];
    double d5 = (this.noiseArray[k1 + k2 + 1] - d1) * d0;
    double d6 = (this.noiseArray[l1 + k2 + 1] - d2) * d0;
    double d7 = (this.noiseArray[i2 + k2 + 1] - d3) * d0;
    double d8 = (this.noiseArray[j2 + k2 + 1] - d4) * d0;
    
    for(int l2 = 0; l2 < 8; ++l2)
    {
    double d9 = 0.25D; // modified !
    double d10 = d1;
    double d11 = d2;
    double d12 = (d3 - d1) * d9; //default : *
    double d13 = (d4 - d2) * d9;
    
    for(int i3 = 0; i3 < 4; ++i3)
    {
    int j3 = i3 + k * 4 << 12 | 0 + j1 * 4 << 8 | k2 * 8 + l2;
    short short1 = 256;
    j3 -= short1;
    double d14 = 0.25D;
    double d16 = (d11 - d10) * d14;
    double d15 = d10 - d16;
    
    for(int k3 = 0; k3 < 4; ++k3)
    {
    if((d15 += d16) > 0.0D)
    {
    surfaceBlock[j3+=short1] = MainClass.oldStone;
    }
    else if(k2 * 8 + l2 < b0)
    {
    surfaceBlock[j3 += short1] = Blocks.water;
    }
    else
    {
    surfaceBlock[j3 += short1] = null;
    }
    }
    
    d10 += d12;
    d11 += d13;
    }
    
    d1 += d5;
    d2 += d6;
    d3 += d7;
    d4 += d8;
    }
    }
    }
    }
    }
    
    public void replaceBlocksForBiome(int x, int z, Block[] block, byte[] arrayOfByte, BiomeGenBase[] biomeList)
    {
    ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, x, z, block, biomeList);
    MinecraftForge.EVENT_BUS.post(event);
    if(event.getResult() == Result.DENY)
    return;
    
    double d0 = 0.03125D;
    this.stoneNoise = this.noiseGen4.func_151599_a(this.stoneNoise, (double)(x * 16), (double)(z * 16), 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D);
    
    for(int k = 0; k < 16; ++k)
    {
    for(int l = 0; l < 16; ++l)
    {
    BiomeGenOtherWorld biomegenbase = (BiomeGenOtherWorld)biomeList[l + k * 16];
    biomegenbase.genTerrainBlocks(this.worldObj, this.rand, block, arrayOfByte, x * 16 + k, z * 16 + l, this.stoneNoise[l + k * 16]);
    }
    }
    }
    
    public Chunk loadChunk(int x, int z)
    {
    return this.provideChunk(x, z);
    }
    
    public Chunk provideChunk(int x, int z)
    {
    this.rand.setSeed((long)x * 341873128712L + (long)z * 132897987541L);
    Block[] ablock = new Block[65536];
    byte[] abyte = new byte[65536];
    this.func_147424_a(x, z, ablock);
    this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, x * 16, z * 16, 16, 16);
    this.replaceBlocksForBiome(x, z, ablock, abyte, this.biomesForGeneration);
    
    Chunk chunk = new Chunk(this.worldObj, ablock, abyte, x, z);
    byte[] abyte1 = chunk.getBiomeArray();
    
    for(int k = 0; k < abyte1.length; ++k)
    {
    abyte1[k] = (byte)this.biomesForGeneration[k].biomeID;
    }
    
    chunk.generateSkylightMap();
    return chunk;
    }
    
    private void func_147423_a(int x, int y, int z)
    {
    double d0 = 684.412D;
    double d1 = 684.412D;
    double d2 = 512.0D;
    double d3 = 512.0D;
    this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, x, z, 5, 5, 200.0D, 200.0D, 0.5D);
    this.field_147427_d = this.noiseGen3.generateNoiseOctaves(this.field_147427_d, x, y, z, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);
    this.field_147428_e = this.noiseGen1.generateNoiseOctaves(this.field_147428_e, x, y, z, 5, 33, 5, 684.412D, 684.412D, 684.412D);
    this.field_147425_f = this.noiseGen2.generateNoiseOctaves(this.field_147425_f, x, y, z, 5, 33, 5, 684.412D, 684.412D, 684.412D);
    boolean flag1 = false;
    boolean flag = false;
    int l = 0;
    int i1 = 0;
    double d4 = 8.5D;
    
    for(int j1 = 0; j1 < 5; ++j1)
    {
    for(int k1 = 0; k1 < 5; ++k1)
    {
    float f = 0.0F;
    float f1 = 0.0F;
    float f2 = 0.0F;
    byte b0 = 2;
    BiomeGenBase biomegenbase = this.biomesForGeneration[j1 + 2 + (k1 + 2) * 10];
    
    for(int l1 = -b0; l1 <= b0; ++l1)
    {
    for(int i2 = -b0; i2 <= b0; ++i2)
    {
    BiomeGenBase biomegenbase1 = this.biomesForGeneration[j1 + l1 + 2 + (k1 + i2 + 2) * 10];
    float f3 = biomegenbase1.rootHeight;
    float f4 = biomegenbase1.heightVariation;
    
    float f5 = this.parabolicField[l1 + 2 + (i2 + 2) * 5] / (f3 + 2.0F);
    
    if(biomegenbase1.rootHeight > biomegenbase.rootHeight)
    {
    f5 /= 2.0F;
    }
    
    f += f4 * f5;
    f1 += f3 * f5;
    f2 += f5;
    }
    }
    
    f /= f2;
    f1 /= f2;
    f = f * 0.9F + 0.1F;
    f1 = (f1 * 4.0F - 1.0F) / 8.0F;
    double d13 = this.field_147426_g[i1] / 8000.0D;
    
    if(d13 < 0.0D)
    {
    d13 = -d13 * 0.3D;
    }
    
    d13 = d13 * 3.0D - 2.0D;
    
    if(d13 < 0.0D)
    {
    d13 /= 2.0D;
    
    if(d13 < -1.0D)
    {
    d13 = -1.0D;
    }
    
    d13 /= 1.4D;
    d13 /= 2.0D;
    }
    else
    {
    if(d13 > 1.0D)
    {
    d13 = 1.0D;
    }
    
    d13 /= 8.0D;
    }
    
    ++i1;
    double d12 = (double)f1;
    double d14 = (double)f;
    d12 += d13 * 0.2D;
    d12 = d12 * 8.5D / 8.0D;
    double d5 = 8.5D + d12 * 4.0D;
    
    for(int j2 = 0; j2 < 33; ++j2)
    {
    double d6 = ((double)j2 - d5) * 12.0D * 128.0D / 256.0D / d14;
    
    if(d6 < 0.0D)
    {
    d6 *= 4.0D;
    }
    
    double d7 = this.field_147428_e[l] / 512.0D;
    double d8 = this.field_147425_f[l] / 512.0D;
    double d9 = (this.field_147427_d[l] / 10.0D + 1.0D) / 2.0D;
    double d10 = MathHelper.denormalizeClamp(d7, d8, d9) - d6;
    
    if(j2 > 29)
    {
    double d11 = (double)((float)(j2 - 29) / 3.0F);
    d10 = d10 * (1.0D - d11) + -10.0D * d11;
    }
    
    this.noiseArray[l] = d10;
    ++l;
    }
    }
    }
    }
    
    public boolean chunkExists(int x, int z)
    {
    return true;
    }
    
    public void populate(IChunkProvider provider, int x, int z)
    {
    BlockFalling.fallInstantly = true;
    int k = x * 16;
    int l = z * 16;
    BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(k + 16, l + 16);
    this.rand.setSeed(this.worldObj.getSeed());
    long i1 = this.rand.nextLong() / 2L * 2L + 1L;
    long j1 = this.rand.nextLong() / 2L * 2L + 1L;
    this.rand.setSeed((long)x * i1 + (long)z * j1 ^ this.worldObj.getSeed());
    boolean flag = false;
    MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(provider, worldObj, rand, x, z, flag));
    
    int k1;
    int l1;
    int i2;
    
    if(biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && !flag && this.rand.nextInt(4) == 0 && TerrainGen.populate(provider, worldObj, rand, x, z, flag, LAKE))
    {
    k1 = k + this.rand.nextInt(16) + 8;
    l1 = this.rand.nextInt(256);
    i2 = l + this.rand.nextInt(16) + 8;
    (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, k1, l1, i2);
    }
    
    boolean doGen = TerrainGen.populate(provider, worldObj, rand, x, z, flag, DUNGEON);
    for(k1 = 0; doGen && k1 < 8; ++k1)
    {
    l1 = k + this.rand.nextInt(16) + 8;
    i2 = this.rand.nextInt(256);
    int j2 = l + this.rand.nextInt(16) + 8;
    (new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2);
    }
    
    biomegenbase.decorate(this.worldObj, this.rand, k, l);
    SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand);
    k += 8;
    l += 8;
    
    doGen = TerrainGen.populate(provider, worldObj, rand, x, z, flag, ICE);
    for(k1 = 0; doGen && k1 < 16; ++k1)
    {
    for(l1 = 0; l1 < 16; ++l1)
    {
    i2 = this.worldObj.getPrecipitationHeight(k + k1, l + l1);
    
    if(this.worldObj.isBlockFreezable(k1 + k, i2 - 1, l1 + l))
    {
    this.worldObj.setBlock(k1 + k, i2 - 1, l1 + l, Blocks.ice, 0, 2);
    }
    
    if(this.worldObj.func_147478_e(k1 + k, i2, l1 + l, true))
    {
    this.worldObj.setBlock(k1 + k, i2, l1 + l, Blocks.snow_layer, 0, 2);
    }
    }
    }
    MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(provider, worldObj, rand, x, z, flag));
    
    BlockFalling.fallInstantly = false;
    }
    
    public boolean saveChunks(boolean par1, IProgressUpdate progress)
    {
    return true;
    }
    
    public boolean canSave()
    {
    return true;
    }
    
    public String makeString()
    {
    return "RandomLevelSource";
    }
    
    public List getPossibleCreatures(EnumCreatureType creature, int x, int y, int z)
    {
    BiomeGenOtherWorld dimCreature = (BiomeGenOtherWorld)this.worldObj.getBiomeGenForCoords(x, z);
    return creature == EnumCreatureType.monster && this.scatteredFeatureGenerator.func_143030_a(x, y, z) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : dimCreature.getSpawnableList(creature);
    }
    
    public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
    {
    return null;
    }
    
    public void recreateStructures(int chunkX, int chunkY){}
    
    @Override
    public boolean unloadQueuedChunks()
    {
    return false;
    }
    
    @Override
    public void saveExtraData()
    {
    
    }
    
    public int getLoadedChunkCount()
    {
    return 0;
    }
    
    @Override
    public ChunkPosition func_147416_a(World world, String stucture, int x, int y, int z)
    {
    return null;
    }
    }
    


  • surfaceBlock[j3+=short1] = MainClass.oldStone;
    

    MainClass.oldStone

    Ca doit venir de là je pense



  • Il faut que tu ajoute le biome ^^, et si je dit pas de bêtise tu doit créer la classe des grottes.



  • J'ai ajouter un biome je donnerai la classe dans 1 heure et dans le biome j ai bien ajouter la this.TopBlock(un truc du genre et l équivalent pour la dirt)

    Edit : voila ma class Biome :

    package portuar.otherWorld.client.world;
    
    import java.util.List;
    
    import portuar.otherWorld.client.MainClass;
    import cpw.mods.fml.relauncher.Side;
    import cpw.mods.fml.relauncher.SideOnly;
    import net.minecraft.block.Block;
    import net.minecraft.block.material.Material;
    import net.minecraft.world.IBlockAccess;
    import net.minecraft.world.biome.BiomeGenBase;
    import net.minecraft.world.gen.feature.WorldGenerator;
    
    public class BiomeGenOtherWorld extends BiomeGenBase
    {
    private WorldGenerator UnDeadworldGeneratorBigTree;
    public final Material blockMaterial;
    
    public BiomeGenOtherWorld(int par1)
    {
    super(par1);
    this.setTemperatureRainfall(0.8F, 0.4F);
    this.setHeight(height_LowPlains);
    
    this.blockMaterial = Material.water;
    
    this.spawnableMonsterList.clear();
    this.spawnableCreatureList.clear();
    this.spawnableCaveCreatureList.clear();
    
    this.topBlock = MainClass.oldGrass;
    this.fillerBlock = MainClass.oldDirt;
    
    /** this changes the water colour, its set to red now but ggole the java colours **/
    this.waterColorMultiplier = 0x99CC33;
    }
    }
    


  • ton chunk Provider n'est pas bon, regarde dans le code de base, pour l'herbe normalement sa devrais être bon.

    regarde mon code ^^ :



  • J'ai pourtant copié collé le ChunkProviderGenerate et testé ceci :

    package portuar.otherWorld.client.world;
    
    import net.minecraft.world.World;
    import net.minecraft.world.gen.ChunkProviderGenerate;
    
    public class ChunkProviderOtherWorld extends ChunkProviderGenerate
    {
    
    public ChunkProviderOtherWorld(World par1World, long par2, boolean par4) {
    super(par1World, par2, par4);
    // TODO Auto-generated constructor stub
    }
    
    }
    

    Mais rien



  • je pense pas que comme sa sa marche ^^, il te faut créer ton propre chunkProvider, de toute façons un tuto sortira. 😄



  • Bah cela marche vue que le monde ce génère correctement, si un tuto va sortir je suis presser et je verrais où est mon erreur 🙂