Ajouter une nouvelle dimension

[Flow]

Ligne 114 et 220 dans AncientChunkProvider :

package mod.common.world.type;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import mod.common.world.structure.DimensionRegister;
import net.minecraft.entity.Entity;
import net.minecraft.init.Blocks;
import net.minecraft.util.Vec3;
import net.minecraft.world.WorldProvider;

public class AncientWorldProvider extends WorldProvider
{
public void registerWorldChunkManager()
{
this.worldChunkMgr = new AncientWorldChunkManager(worldObj.getSeed(), terrainType);
this.dimensionId = DimensionRegister.tutoDimAncient4;
}

public String getDimensionName()
{
return "Ancient World";
}

public String getSaveFolder()
{
return "AncientWorld";
}
public boolean canRespawnHere()
{
return true;
}
public boolean getWorldHasVoidParticles()
{
return true;
}
public int getHeight()
{
return 256;
}

public boolean canCoordinateBeSpawn(int par1, int par2)
{
return this.worldObj.getTopBlock(par1, par2) == Blocks.grass;
}

protected void generateLightBrightnessTable()
{
float f = 0.2F;

for(int i = 0; i <= 15; ++i)
{
float f1 = 1.0F - (float)i / 15.0F;
this.lightBrightnessTable* = (1.0F - f1) / (f1 * 3.0F + 1.0F) * (1.0F - f) + f;
}
}
public float calculateCelestialAngle(long par1, float par2)
{
int j = (int)(par1 % 24000L);
float f1 = ((float)j + par2) / 24000.0F - 0.25F;

if(f1 < 0.0F)
{
++f1;
}
if(f1 > 1.0F)
{
–f1;
}
float f2 = f1;
f1 = 1.0F - (float)((Math.cos((double)f1 * Math.PI) + 1.0D) / 2.0D);
f1 = f2 + (f1 - f2) / 3.0F;
return f1;
}
public int getMoonPhase(long par1)
{
return (int)(par1 / 24000L % 8L + 8L) % 8;
}
public String getWelcomeMessage()
{
if(this instanceof AncientWorldProvider)
{
return "Entering the Ancient Dimension";
}
return null;
}

public String getDepartMessage()
{
if(this instanceof AncientWorldProvider)
{
return "Leaving the Ancient Dimension";
}
return null;
}

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

@Override
public Vec3 getSkyColor(Entity cameraEntity, float partialTicks)
{ //à modifier pour changer la couleur
return Vec3.createVectorHelper(2.8, 1.1, 1.7);
}
}

Dans la classe WorldChunkManager du coup x) :

package mod.common.world.type;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import mod.common.world.biome.BiomeRegister;
import mod.common.world.generator.AncientGenLayer;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.WorldType;
import net.minecraft.world.biome.BiomeCache;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.biome.WorldChunkManager;
import net.minecraft.world.gen.layer.GenLayer;
import net.minecraft.world.gen.layer.IntCache;

public class AncientWorldChunkManager extends WorldChunkManager
{
/**
* GenLayer = classe de GenLayer si vous utiliser un GenLayer qui n’hérite
* pas de la classe GenLayer alors il faut changer par votre classe
*/
private GenLayer genBiomes;
private GenLayer biomeIndexLayer;
/** L'objet du BiomeCache pour le monde */
private BiomeCache biomeCache;
/** List des biome ou le joueur peu spawn */
private List <biomegenbase>biomesToSpawnIn;

protected AncientWorldChunkManager()
{
this.biomeCache = new BiomeCache(this);
// liste des biomes ou nous spawons
this.biomesToSpawnIn = new ArrayList<biomegenbase>();
// Ce biome n'est pas le biome ou vous spawner forcement, mais dans
// toute les classes il devra être mis
this.biomesToSpawnIn.add(BiomeGenBase.savanna);
}

public AncientWorldChunkManager(long par1, WorldType worldType)
{
this();
/**
* Appele la fonction makeTheWorld dans la classe TutoGenLayer, la
* fonction est la fonction de génération de nos biome
*/
GenLayer[] agenlayer = AncientGenLayer.makeTheWorld(par1);
this.genBiomes = agenlayer[0];
this.biomeIndexLayer = agenlayer[1];
}

public AncientWorldChunkManager(World world)
{
this(world.getSeed(), world.provider.terrainType);
}

/** Permet d'obtenir la list des biomes ou le joueur peut apparaitre */
public List <biomegenbase>getBiomesToSpawnIn()
{
return this.biomesToSpawnIn;
}

/** Renvoie au BiomeGenBase a la position x, z relative dans le monde */
public BiomeGenBase getBiomeGenAt(int x, int z)
{
BiomeGenBase biome = this.biomeCache.getBiomeGenAt(x, z);
if(biome == null)
{
return BiomeGenBase.savanna;

}
return biome;
}

/**
* Retourne a la list des valeurs pour la pluis… ... pour en fonction de
* blocs spésifier
*/
public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)
{
if(par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)
{
par1ArrayOfFloat = new float[par4 * par5];
}

Arrays.fill(par1ArrayOfFloat, 0, par4 * par5, 0.0F);
return par1ArrayOfFloat;
}

/** Retourne a une température donner par raport au y */
@SideOnly(Side.CLIENT)
public float getTemperatureAtHeight(float par1, int par2)
{
return par1;
}

/** Retourne à un tableau pour les biomes a générer */
public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)
{
IntCache.resetIntCache();

if(par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)
{
par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
}

int[] aint = this.genBiomes.getInts(par2, par3, par4, par5);

for(int i = 0; i < par4 * par5; ++i)
{
if(aint* >= 0)
{
par1ArrayOfBiomeGenBase* = BiomeGenBase.getBiome(aint*);
}
else
{
par1ArrayOfBiomeGenBase* = BiomeGenBase.forest;
}
}

return par1ArrayOfBiomeGenBase;
}

/** Retourne au biome et charge les données pour les blocs */
public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)
{
return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true);
}

/**
* Retourne a une liste de biome pour les blocs spécifiés argument : x, y,
* largeur, longueur, cache.
*/
public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] arrayOfBiomeGenBase, int x, int y, int width, int length, boolean cacheFlag)
{
if(arrayOfBiomeGenBase == null || arrayOfBiomeGenBase.length < width * length)
{
arrayOfBiomeGenBase = new BiomeGenBase[width * length];
}

if(cacheFlag && width == 16 && length == 16 && (x & 15) == 0 && (y & 15) == 0)
{
BiomeGenBase[] abiomegenbase1 = this.biomeCache.getCachedBiomes(x, y);
System.arraycopy(abiomegenbase1, 0, arrayOfBiomeGenBase, 0, width * length);
return arrayOfBiomeGenBase;
}
else
{
int[] aint = this.biomeIndexLayer.getInts(x, y, width, length);

for(int i1 = 0; i1 < width * length; ++i1)
{
if(aint[i1] >= 0)
{
arrayOfBiomeGenBase[i1] = BiomeGenBase.getBiome(aint[i1]);
}

else
{
arrayOfBiomeGenBase[i1] = BiomeGenBase.forest;
}
}

return arrayOfBiomeGenBase;
}
}

/** Verifie les données du chunk */
public boolean areBiomesViable(int x, int y, int z, List par4List)
{
IntCache.resetIntCache();
int l = x - z >> 2;
int i1 = y - z >> 2;
int j1 = x + z >> 2;
int k1 = y + z >> 2;
int l1 = j1 - l + 1;
int i2 = k1 - i1 + 1;
int[] aint = this.genBiomes.getInts(l, i1, l1, i2);

for(int j2 = 0; j2 < l1 * i2; ++j2)
{
BiomeGenBase biomegenbase = BiomeGenBase.getBiome(aint[j2]);

if(!par4List.contains(biomegenbase))
{
return false;
}
}

return true;
}

/** Supprime le biome dans les 30s. si il n'est pas vérifier dans la temps */
public void cleanupCache()
{
this.biomeCache.cleanupCache();
}
}

Ligne 13 et 15 dans AncientWorldProvider :

package mod.common.world.type;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import mod.common.world.structure.DimensionRegister;
import net.minecraft.entity.Entity;
import net.minecraft.init.Blocks;
import net.minecraft.util.Vec3;
import net.minecraft.world.WorldProvider;

public class AncientWorldProvider extends WorldProvider
{
public void registerWorldChunkManager()
{
this.worldChunkMgr = new AncientWorldChunkManager(worldObj.getSeed(), terrainType);
this.dimensionId = DimensionRegister.tutoDimAncient4;
}

public String getDimensionName()
{
return "Ancient World";
}

public String getSaveFolder()
{
return "AncientWorld";
}
public boolean canRespawnHere()
{
return true;
}
public boolean getWorldHasVoidParticles()
{
return true;
}
public int getHeight()
{
return 256;
}

public boolean canCoordinateBeSpawn(int par1, int par2)
{
return this.worldObj.getTopBlock(par1, par2) == Blocks.grass;
}

protected void generateLightBrightnessTable()
{
float f = 0.2F;

for(int i = 0; i <= 15; ++i)
{
float f1 = 1.0F - (float)i / 15.0F;
this.lightBrightnessTable* = (1.0F - f1) / (f1 * 3.0F + 1.0F) * (1.0F - f) + f;
}
}
public float calculateCelestialAngle(long par1, float par2)
{
int j = (int)(par1 % 24000L);
float f1 = ((float)j + par2) / 24000.0F - 0.25F;

if(f1 < 0.0F)
{
++f1;
}
if(f1 > 1.0F)
{
–f1;
}
float f2 = f1;
f1 = 1.0F - (float)((Math.cos((double)f1 * Math.PI) + 1.0D) / 2.0D);
f1 = f2 + (f1 - f2) / 3.0F;
return f1;
}
public int getMoonPhase(long par1)
{
return (int)(par1 / 24000L % 8L + 8L) % 8;
}
public String getWelcomeMessage()
{
if(this instanceof AncientWorldProvider)
{
return "Entering the Ancient Dimension";
}
return null;
}

public String getDepartMessage()
{
if(this instanceof AncientWorldProvider)
{
return "Leaving the Ancient Dimension";
}
return null;
}

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

@Override
public Vec3 getSkyColor(Entity cameraEntity, float partialTicks)
{ //à modifier pour changer la couleur
return Vec3.createVectorHelper(2.8, 1.1, 1.7);
}
}

J’ai rien trouver d’autre et je vois pas d’erreur…</biomegenbase></biomegenbase></biomegenbase>

[Diangle]

tu t’es tromper de classe :D, tu pourrais envoyer le ChunkProvider ?

[Flow]

package mod.common.world.type;

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

import mod.common.world.biome.AncientBiome;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFalling;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.init.Blocks;
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.biome.BiomeGenPlains;
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.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.MapGenMineshaft;
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;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*;

public abstract class AncientChunkProvider implements IChunkProvider {

private Random rand;
private NoiseGeneratorOctaves noiseGen1;//les noises
private NoiseGeneratorOctaves noiseGen2;
private NoiseGeneratorOctaves noiseGen3;
private NoiseGeneratorPerlin noiseGen4;
public NoiseGeneratorOctaves noiseGen5;
public NoiseGeneratorOctaves noiseGen6;
public NoiseGeneratorOctaves mobSpawnerNoise;
private World worldObj;
private WorldType worldType;
private final double[] noiseArray;
private final float[] parabolicField;
private final boolean mapFeaturesEnabled;

private MapGenBase caveGenerator = new MapGenCaves();//la génération des caves, remplacer par votre ravin si vous utiliser une autre stone
private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();//la génération des mineshaft, "" "" ""
private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();
private MapGenBase ravineGenerator = new MapGenRavine();//la structure du ravin, "" "" ""

private double[] stoneNoise = new double[256];
private BiomeGenBase[] biomesForGeneration;
double[] noiseData1; //les noises data
double[] noiseData2;
double[] noiseData3;
double[] noiseData4;

{
caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);
mineshaftGenerator = (MapGenMineshaft) TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT);
scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);
ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);
}

public AncientChunkProvider(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];
}

public void func_147424_a(int Xchunks, int Zchunks, Block[] topBlock)
{
byte b0 = 63;
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, Xchunks * 4 - 2, Zchunks * 4 - 2, 10, 10);
this.func_147423_a(Xchunks * 4, 0, Zchunks * 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;
double d10 = d1;
double d11 = d2;
double d12 = (d3 - d1) * d9;
double d13 = (d4 - d2) * d9;

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

for (int k3 = 0; k3 < 4; ++k3)
{
if ((d15 += d16) > 0.0D)
{
topBlock[j3 += short1] = Blocks.stone;
}
else if (k2 * 8 + l2 < b0)
{
topBlock[j3 += short1] = Blocks.water;
}
else
{
topBlock[j3 += short1] = null;
}
}

d10 += d12;
d11 += d13;
}

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

public void replaceBlocksForBiome(int coordX, int coordZ, Block[] block, byte[] arrayOfByte, BiomeGenBase[] biomeList)
{
ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, coordX, coordZ, 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)(coordX * 16), (double)(coordZ * 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)
{
AncientBiome biomegenbase = (AncientBiome /*TODO ce biome est a remplacer par le votre*/)biomeList[l + k * 16];
biomegenbase.genTerrainBlocks(this.worldObj, this.rand, block, arrayOfByte, coordX * 16 + k, coordZ * 16 + l, this.stoneNoise[l + k * 16]);
}
}
}

public Chunk loadChunk(int par1, int par2)
{
return this.provideChunk(par1, par2);
}

public Chunk provideChunk(int par1, int par2)
{
this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
Block[] ablock = new Block[65536];
byte[] abyte = new byte[65536];
this.func_147424_a(par1, par2, ablock);
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
this.replaceBlocksForBiome(par1, par2, ablock, abyte, this.biomesForGeneration);
this.caveGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock);
this.ravineGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock);

if (this.mapFeaturesEnabled)
{
this.mineshaftGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock);
this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock);
}

Chunk chunk = new Chunk(this.worldObj, ablock, 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;
}

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.noiseData4 = this.noiseGen6.generateNoiseOctaves(this.noiseData4, x, z, 5, 5, 200.0D, 200.0D, 0.5D);
this.noiseData1 = this.noiseGen3.generateNoiseOctaves(this.noiseData1, x, y, z, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);
this.noiseData2 = this.noiseGen1.generateNoiseOctaves(this.noiseData2, x, y, z, 5, 33, 5, 684.412D, 684.412D, 684.412D);
this.noiseData3 = this.noiseGen2.generateNoiseOctaves(this.noiseData3, 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.noiseData4[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 + d13 * 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.noiseData2[l] / 512.0D;
double d8 = this.noiseData3[l] / 512.0D;
double d9 = (this.noiseData1[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 par1, int par2)
{
return true;
}

public void populate(IChunkProvider chunkProvider, int x, int z)
{
BlockFalling.fallInstantly = true;
int x1 = x * 16;
int z1 = z * 16;
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(x1 + 16, z1 + 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(chunkProvider, worldObj, rand, x, z, flag));

// si l'option de génération des structures est activer alors nous générons le mineshaft et l'autre structure

if (this.mapFeaturesEnabled)
{
this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, x, z);
this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, x, z);
}

int x2;
int z2;
int i2;

//si le biome n'est pas un désert, une montagne du désert, et que la rand.nextIn(4) ne fait pas 0 alors nous avons un lac
if (biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && !flag && this.rand.nextInt(4) == 0
&& TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, LAKE))
{
x2 = x1 + this.rand.nextInt(16) + 8;
z2 = this.rand.nextInt(256);
i2 = z1 + this.rand.nextInt(16) + 8;
//Le blocs de génération du lac
(new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, x2, z2, i2);
}

//la condition est la même que en haut, sans les biomes
if (TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, LAVA) && !flag && this.rand.nextInt(8) == 0)
{
x2 = x1 + this.rand.nextInt(16) + 8;
//nous définissons les x, y, z
z2 = this.rand.nextInt(this.rand.nextInt(248) + 8);
i2 = z1 + this.rand.nextInt(16) + 8;

if (z2 < 63 || this.rand.nextInt(10) == 0)
{ //changer le par le blocs de votre choix
(new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, x2, z2, i2);
}
}

//sa nous permet de générer des donjons, comme plus haut changer la classe par la votre pour générer vos donjons
boolean doGen = TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, DUNGEON);
for (x2 = 0; doGen && x2 < 8; ++x2)
{
z2 = x1 + this.rand.nextInt(16) + 8;
i2 = this.rand.nextInt(256);
int j2 = z1 + this.rand.nextInt(16) + 8;
//changer la classe par votre classe
(new WorldGenDungeons()).generate(this.worldObj, this.rand, z2, i2, j2);
}

biomegenbase.decorate(this.worldObj, this.rand, x1, z1);
//sa ajoute des mobs
if (TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, ANIMALS))
{
SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, x1 + 8, z1 + 8, 16, 16, this.rand);
}
x1 += 8;
z1 += 8;

//sa remplace la génération de l'eau par de la glasse, et ajoute la tomber de neige
doGen = TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, ICE);
for (x2 = 0; doGen && x2 < 16; ++x2)
{
for (z2 = 0; z2 < 16; ++z2)
{
i2 = this.worldObj.getPrecipitationHeight(x1 + x2, z1 + z2);

if (this.worldObj.isBlockFreezable(x2 + x1, i2 - 1, z2 + z1))
{
this.worldObj.setBlock(x2 + x1, i2 - 1, z2 + z1, Blocks.ice, 0, 2);
}

if (this.worldObj.func_147478_e(x2 + x1, i2, z2 + z1, true))
{
this.worldObj.setBlock(x2 + x1, i2, z2 + z1, Blocks.snow_layer, 0, 2);
}
}
}

MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(chunkProvider, worldObj, rand, x, z, flag));

BlockFalling.fallInstantly = false;
}

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

public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
{
/*TODO*/AncientBiome biomegenbase = (/*TODO*/AncientBiome)this.worldObj.getBiomeGenForCoords(par2, par4);
return par1EnumCreatureType == EnumCreatureType.monster && this.scatteredFeatureGenerator.func_143030_a(par2, par3, par4) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : biomegenbase.getSpawnableList(par1EnumCreatureType);
}

public ChunkPosition func_147416_a(World world, String strg, int x, int y, int z)
{
return null;
}

public int getLoadedChunkCount()
{
return 0;
}

public void recreateStructures(int par1, int par2)
{
if (this.mapFeaturesEnabled)
{
this.mineshaftGenerator.func_151539_a(this, this.worldObj, par1, par2, (Block[])null);
this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, par1, par2, (Block[])null);
}
}

}

Mince ! voici

[Diangle]

Tu pourrais m’envoyer ton code en .zip en MP ? j’irais surement plus vite, je te dirais se qui va pas ^^.

[Flow]

Jte donne tout , ou juste les classes concernés dans un dossier Zip ?

[Flow]

J’ai une question concernant la 1.8 je cherche a update mon activateur en 1.8 voici mon code mais ca ne marche pas

package mod.common.item;

import mod.DinoCraft;
import mod.common.block.BlockRegister;
import mod.common.world.structure.DimensionRegister;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;

public class ItemEnhancer extends Item
{

public ItemEnhancer()
{
this.setUnlocalizedName("itemEnhancer");
}

public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, BlockPos pos, int side, float par8, float par9, float par10)
{
int x = pos.getX();
int y = pos.getY();
int z = pos.getZ();

if(world.getBlockState(new BlockPos(x, y, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
System.out.println("CA MARCHE ?");

}
}
}
}
}
}
}
}

for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x + l, y + 1 + h, z), (IBlockState)BlockRegister.BlockPortail);
System.out.println("CA MARCHE ?");
}
}
}

if(world.getBlockState(new BlockPos(x - 1, y, z)).equals(BlockRegister.BlockAmbre))
{

if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x - l, y + 1 + h, z) , (IBlockState)BlockRegister.BlockPortail);
}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 2)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z + l), (IBlockState)BlockRegister.BlockPortail);
}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 2)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z - l), (IBlockState)BlockRegister.BlockPortail);
}
}
}
}
}
}
}
}
}
}

}
}

return false;
}
}

Je pnese que c’est ca qui craint :

world.setBlockState(new BlockPos(x + l, y + 1 + h, z), (IBlockState)BlockRegister.BlockPortail);

avec le (IBlockState)

mais si je l’enlève ca ne veut pas car la fonction (pos , block) n’existe pas y’a que (pos , state) qui fonctionne

[robin4002]

BlockRegistry.BlockPortail.getDefaultBlockState()

[Flow]

Je suppose que tu veut dire

BlockRegister.BlockPortail.getDefaultState() car getDefaultBlockState() n’existe pas

Pourtant ca ne marche toujours pas , et le system.out.printIn(“CA MARCHE ?”)

n’apparaît pas dans la console voila le code entier modifier :

package mod.common.item;

import mod.DinoCraft;
import mod.common.block.BlockRegister;
import mod.common.world.structure.DimensionRegister;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;

public class ItemEnhancer extends Item
{

public ItemEnhancer()
{
this.setUnlocalizedName("itemEnhancer");
}

public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, BlockPos pos, int side, float par8, float par9, float par10)
{
int x = pos.getX();
int y = pos.getY();
int z = pos.getZ();

if(world.getBlockState(new BlockPos(x, y, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x + l, y + 1 + h, z), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE ?");
}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x - 1, y, z)).equals(BlockRegister.BlockAmbre))
{

if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x - l, y + 1 + h, z) , BlockRegister.BlockPortail.getDefaultState());
}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 2)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z + l), BlockRegister.BlockPortail.getDefaultState());
}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 2)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z - l), BlockRegister.BlockPortail.getDefaultState());
}
}
}
}
}
}
}
}
}
}

}
}

return false;
}
}

[robin4002]

J’étais sur mon téléphone quand j’ai répondu donc oui c’est bien getDefaultState et non getDefaultBlockState
Par contre là je ne sais pas pourquoi ça ne fonctionne toujours pas. Vérifies que le getDefaultState n’est pas null, mais normalement ça ne devrait pas être le cas.

[Flow]

Il ne l’est pas effectivement , c’est bizarre je vais relire le tuto pour voir si j’ai pas louper quelque chose

Si Diangle passe par la , aide moi xD

[Diangle]

Met des system.out.println(…) Pour voir quel condition sont appeler.

[Flow]

package mod.common.item;

import mod.DinoCraft;
import mod.common.block.BlockRegister;
import mod.common.world.structure.DimensionRegister;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;

public class ItemEnhancer extends Item
{

public ItemEnhancer()
{
this.setUnlocalizedName("itemEnhancer");
}

public boolean onItemUse(ItemStack itemStack, EntityPlayer player, World world, BlockPos pos, EnumFacing facing, float par8, float par9, float par10)
{
int x = pos.getX();
int y = pos.getY();
int z = pos.getZ();
System.out.println("CA MARCHE ?");

if(world.getBlockState(new BlockPos(x, y, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 2, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x + l, y + 1 + h, z), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 1?");

}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x - 1, y, z)).equals(BlockRegister.BlockAmbre))
{

if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 1, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x - 2, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 1, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 2, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x + 1, y + 3, z)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x - l, y + 1 + h, z) , BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 2?");

}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 2)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z + l), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 3?");

}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 4, z - 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 1)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 2)).equals(BlockRegister.BlockAmbre))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 2)).equals(BlockRegister.BlockAmbre))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z - l), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 4?");

}
}
}
}
}
}
}
}
}
}

}
}

return false;
}

}

Il n’y a que la ligne 29 qui apparait quand je fais un click droit sur le block portail

[Diangle]

Regarde si il y a une fonction onItemRigthClick(…)

[Flow]

Oui j’ai essayé avec ca mais ca marche pas non plus xD Jvois pas pourquoi ca marche pas en fait oO

[Flow]

EUREKA ! Fallais rajouter .getDefaultState après chaque block du portail voici le code pour la 1.8 ceux qui le désire

package mod.common.item;

import mod.DinoCraft;
import mod.common.block.BlockRegister;
import mod.common.world.structure.DimensionRegister;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;

public class ItemEnhancer extends Item
{

public ItemEnhancer()
{
this.setUnlocalizedName("itemEnhancer");
}

public boolean onItemUse(ItemStack itemStack, EntityPlayer player, World world, BlockPos pos, EnumFacing facing, float par8, float par9, float par10)
{
int x = pos.getX();
int y = pos.getY();
int z = pos.getZ();
System.out.println("CA MARCHE ?");

if(world.getBlockState(new BlockPos(x, y, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 1, y, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 1, y + 4, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 1, y + 1, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 1, y + 2, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 1, y + 3, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 2, y + 1, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 2, y + 2, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 2, y + 3, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x + l, y + 1 + h, z), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 1?");

}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x - 1, y, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{

if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 1, y + 4, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 2, y + 1, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 2, y + 2, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x - 2, y + 3, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 1, y + 1, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 1, y + 2, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x + 1, y + 3, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x - l, y + 1 + h, z) , BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 2?");

}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z + 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 4, z + 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 2)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 2)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 2)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z + l), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 3?");

}
}
}
}
}
}
}
}
}
}
}

if(world.getBlockState(new BlockPos(x, y, z - 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 4, z)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 4, z - 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 1, z + 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 2, z + 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 3, z + 1)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 1, z - 2)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 2, z - 2)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
if(world.getBlockState(new BlockPos(x, y + 3, z - 2)).equals(BlockRegister.BlockAmbre.getDefaultState()))
{
for(int l = 0; l < 2; l++)
{
for(int h = 0; h < 3; h++)
{
world.setBlockState(new BlockPos(x, y + 1 + h, z - l), BlockRegister.BlockPortail.getDefaultState());
System.out.println("CA MARCHE 4?");

}
}
}
}
}
}
}
}
}
}

}
}

return false;
}

}

[EmotionFox]

Bonjour tout le monde, j’ai un petit problème quand j’essaye d’appliquer le mod “île flottante” en 1.8…

Le soucie doit provenir normalement de la classe ChunkProvider :

package mods.emotion.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.init.Blocks;
import net.minecraft.util.BlockPos;
import net.minecraft.util.IProgressUpdate;
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.NoiseGeneratorOctaves;
import net.minecraft.world.gen.feature.WorldGenBigTree;
import net.minecraft.world.gen.feature.WorldGenLakes;
import net.minecraft.world.gen.feature.WorldGenTrees;

public class SkyChunkProvider implements IChunkProvider
{
private Random rand;

private NoiseGeneratorOctaves noiseGen1;
private NoiseGeneratorOctaves noiseGen2;
private NoiseGeneratorOctaves noiseGen3;
private NoiseGeneratorOctaves noiseGen4;
public NoiseGeneratorOctaves noiseGen5;
public NoiseGeneratorOctaves noiseGen6;
private NoiseGeneratorOctaves noiseGen7;
public NoiseGeneratorOctaves mobSpawnerNoise;
private World worldObj;
private double[] noiseArray;

private double[] bNoise1;
private double[] bNoise2;
private double[] bNoise3;
private BiomeGenBase[] biomesForGeneration;
double[] noise1;
double[] noise2;
double[] noise3;
double[] noise4;
double[] noise5;
int[][] field_914_i = new int[32][32];
private double[] generatedTemperatures;

public Block topBlock;
public Block fillerBlock;

public SkyChunkProvider(World world, long seed)
{
this.bNoise1 = new double[256];
this.bNoise2 = new double[256];
this.bNoise3 = new double[256];
this.worldObj = world;
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, 32);
this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 64);
this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 4);
this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 10);
this.noiseGen7 = new NoiseGeneratorOctaves(this.rand, 16);
this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
}

public void generateTerrain(int i, int j, Block[] block, BiomeGenBase[] abiomes)
{
byte byte0 = 2;
int k = byte0 + 1;
byte byte1 = 33;
int l = byte0 + 1;
this.noiseArray = initializeNoiseField(this.noiseArray, i * byte0, 0, j * byte0, k, byte1, l);

for(int i1 = 0; i1 < byte0; i1++)
{
for(int j1 = 0; j1 < byte0; j1++)
{
for(int k1 = 0; k1 < 32; k1++)
{
double d = 0.25D;
double d1 = this.noiseArray[(((i1 + 0) * l + j1 + 0) * byte1 + k1 + 0)];
double d2 = this.noiseArray[(((i1 + 0) * l + j1 + 1) * byte1 + k1 + 0)];
double d3 = this.noiseArray[(((i1 + 1) * l + j1 + 0) * byte1 + k1 + 0)];
double d4 = this.noiseArray[(((i1 + 1) * l + j1 + 1) * byte1 + k1 + 0)];
double d5 = (this.noiseArray[(((i1 + 0) * l + j1 + 0) * byte1 + k1 + 1)] - d1) * d;
double d6 = (this.noiseArray[(((i1 + 0) * l + j1 + 1) * byte1 + k1 + 1)] - d2) * d;
double d7 = (this.noiseArray[(((i1 + 1) * l + j1 + 0) * byte1 + k1 + 1)] - d3) * d;
double d8 = (this.noiseArray[(((i1 + 1) * l + j1 + 1) * byte1 + k1 + 1)] - d4) * d;
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;
char c = '€';
double d14 = 0.125D;
double d15 = d10;
double d16 = (d11 - d10) * d14;
for(int k2 = 0; k2 < 8; k2++)
{
Block l2 = Blocks.air;
if(d15 > 0.0D)
{
l2 = Blocks.stone;
}
block[j2] = l2;
j2 += c;
d15 += d16;
}

d10 += d12;
d11 += d13;
}

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

private double[] initializeNoiseField(double[] ad, int i, int j, int k, int l, int i1, int j1)
{
if(ad == null)
{
ad = new double[l * i1 * j1];
}
double d = 684.41200000000003D;
double d1 = 684.41200000000003D;

this.noise4 = this.noiseGen6.generateNoiseOctaves(this.noise4, i, k, l, j1, 1.121D, 1.121D, 0.5D);
this.noise5 = this.noiseGen7.generateNoiseOctaves(this.noise5, i, k, l, j1, 200.0D, 200.0D, 0.5D);
d *= 2.0D;
this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, i, j, k, l, i1, j1, d / 80.0D, d1 / 160.0D, d / 80.0D);
this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, i, j, k, l, i1, j1, d, d1, d);
this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, i, j, k, l, i1, j1, d, d1, d);
int k1 = 0;
int l1 = 0;
for(int j2 = 0; j2 < l; j2++)
{
for(int l2 = 0; l2 < j1; l2++)
{
double d4 = 1.0D;
d4 *= d4;
d4 *= d4;
d4 = 1.0D - d4;
double d5 = (this.noise4[l1] + 256.0D) / 512.0D;
d5 *= d4;
if(d5 > 1.0D)
{
d5 = 1.0D;
}
double d6 = this.noise5[l1] / 8000.0D;
if(d6 < 0.0D)
{
d6 = -d6 * 0.3D;
}
d6 = d6 * 3.0D - 2.0D;
if(d6 > 1.0D)
{
d6 = 1.0D;
}
d6 /= 8.0D;
d6 = 0.0D;
if(d5 < 0.0D)
{
d5 = 0.0D;
}
d5 += 0.5D;
d6 = d6 * i1 / 16.0D;
l1++;
double d7 = i1 / 2.0D;
for(int j3 = 0; j3 < i1; j3++)
{
double d8 = 0.0D;
double d9 = (j3 - d7) * 8.0D / d5;
if(d9 < 0.0D)
{
d9 *= -1.0D;
}
double d10 = this.noise1[k1] / 512.0D;
double d11 = this.noise2[k1] / 512.0D;
double d12 = (this.noise3[k1] / 10.0D + 1.0D) / 2.0D;
if(d12 < 0.0D)
{
d8 = d10;
}
else if(d12 > 1.0D)
{
d8 = d11;
}
else
{
d8 = d10 + (d11 - d10) * d12;
}
d8 -= 8.0D;
int k3 = 32;
if(j3 > i1 - k3)
{
double d13 = (j3 - (i1 - k3)) / (k3 - 1.0F);
d8 = d8 * (1.0D - d13) + -30.0D * d13;
}
k3 = 8;
if(j3 < k3)
{
double d14 = (k3 - j3) / (k3 - 1.0F);
d8 = d8 * (1.0D - d14) + -30.0D * d14;
}
ad[k1] = d8;
k1++;
}
}
}
return ad;
}

public void replaceBlockForBiome(int i, int j, Block[] block, BiomeGenBase[] abiome)
{
double d = 0.03125D;
this.bNoise1 = this.noiseGen4.generateNoiseOctaves(this.bNoise1, i * 16, j * 16, 0, 16, 16, 1, d, d, 1.0D);
this.bNoise2 = this.noiseGen4.generateNoiseOctaves(this.bNoise2, i * 16, 109, j * 16, 16, 1, 16, d, 1.0D, d);
this.bNoise3 = this.noiseGen5.generateNoiseOctaves(this.bNoise3, i * 16, j * 16, 0, 16, 16, 1, d * 2.0D, d * 2.0D, d * 2.0D);
for(int k = 0; k < 16; k++)
{
for(int l = 0; l < 16; l++)
{
int i1 = (int)(this.bNoise3[(k + l * 16)] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);

int j1 = -1;
this.topBlock = Blocks.grass;
this.fillerBlock = Blocks.dirt;
Block block1 = this.topBlock;
Block block2 = this.fillerBlock;
Block stone = Blocks.stone;

if(block1 == Blocks.air)
{
block1 = Blocks.grass;
}
if(block2 == Blocks.air)
{
block2 = Blocks.dirt;
}
if(stone == Blocks.air)
{
stone = Blocks.stone;
}
for(int k1 = 127; k1 >= 0; k1–)
{
int l1 = (l * 16 + k) * 128 + k1;
Block block3 = block[l1];
if(block3 == Blocks.air)
{
j1 = -1;
}
else if(block3 == stone)
{

if(j1 == -1)
{

if(i1 <= 0)
{
block1 = Blocks.air;
block2 = stone;
}
j1 = i1;
if(k1 >= 0)
{
block[l1] = block1;
}
else
{
block[l1] = block2;
}

}
else if(j1 > 0)
{
j1–;
block[l1] = block2;
}
}
}
}
}
}

public List getPossibleCreatures(EnumCreatureType enumcreaturetype, int x, int y, int z)
{
BiomeGenBase var5 = this.worldObj.getBiomeGenForCoords(new BlockPos(x, y, z));
return var5 == null ? null : var5.getSpawnableList(enumcreaturetype);
}

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

@Override
public Chunk provideChunk(int x, int z)
{
this.rand.setSeed(x * 391279128714L + z * 132894987741L);
Block[] ablock = new Block[32768];
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, x * 16, z * 16, 16, 16);
generateTerrain(x, z, ablock, this.biomesForGeneration);
replaceBlockForBiome(x, z, ablock, this.biomesForGeneration);
Chunk chunk = new Chunk(this.worldObj, x, z);
byte[] abyte = chunk.getBiomeArray();

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

chunk.generateSkylightMap();
return chunk;
}

@Override
public Chunk provideChunk(BlockPos blockPosIn)
{
return this.provideChunk(blockPosIn.getX() >> 4, blockPosIn.getZ() >> 4);
}

@Override
public void populate(IChunkProvider iChunkProvider, int i, int j)
{
BlockSand.fallInstantly = true;

int var4 = i * 16;
int var5 = j * 16;
BiomeGenBase var6 = this.worldObj.getWorldChunkManager().getBiomeGenerator(new BlockPos(var4 + 16, 0, var5 + 16));
this.rand.setSeed(this.worldObj.getSeed());

if(this.rand.nextInt(4) == 0)
{
int var13 = var4 + this.rand.nextInt(16) + 8;
int var14 = this.rand.nextInt(256);
int var15 = var5 + this.rand.nextInt(16) + 8;
new WorldGenLakes(Blocks.water).generate(this.worldObj, this.rand, new BlockPos(var13, var14, var15));
}

Random rand = new Random();
int randomNum = rand.nextInt(6) + 1;
if(randomNum == 2)
{
WorldGenTrees var17 = new WorldGenTrees(true);

for(int var18 = 0; var18 < 5; var18++)
{
int var19 = var4 + this.rand.nextInt(16);
int var20 = var5 + this.rand.nextInt(16);
int var21 = this.worldObj.getHeight();
var17.generate(this.worldObj, this.rand, new BlockPos(var19, var21, var20));
}

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

for(int var21 = var4 + 8; var21 < var4 + 8 + 16; var21++)
{
for(int var20 = var5 + 8; var20 < var5 + 8 + 16; var20++)
{
int var10000 = var21 - (var4 + 8);
var10000 = var20 - (var5 + 8);
}
}
}
else if(randomNum == 3)
{
WorldGenTrees var17 = new WorldGenTrees(false);

for(int var18 = 0; var18 < 5; var18++)
{
int var19 = var4 + this.rand.nextInt(16);
int var20 = var5 + this.rand.nextInt(16);
int var21 = this.worldObj.getHeight();
var17.generate(this.worldObj, this.rand, new BlockPos(var19, var21, var20));
}

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

for(int var21 = var4 + 8; var21 < var4 + 8 + 16; var21++)
{
for(int var20 = var5 + 8; var20 < var5 + 8 + 16; var20++)
{
int var10000 = var21 - (var4 + 8);
var10000 = var20 - (var5 + 8);
}

}

}
else if(randomNum == 4)
{
WorldGenBigTree var17 = new WorldGenBigTree(true);

for(int var18 = 0; var18 < 5; var18++)
{
int var19 = var4 + this.rand.nextInt(16);
int var20 = var5 + this.rand.nextInt(16);
int var21 = this.worldObj.getHeight();
var17.generate(this.worldObj, this.rand, new BlockPos(var19, var21, var20));
}

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

for(int var21 = var4 + 8; var21 < var4 + 8 + 16; var21++)
{
for(int var20 = var5 + 8; var20 < var5 + 8 + 16; var20++)
{
int var10000 = var21 - (var4 + 8);
var10000 = var20 - (var5 + 8);
}
}
}
BlockSand.fallInstantly = false;
}

@Override
public boolean func_177460_a(IChunkProvider p_177460_1_, Chunk p_177460_2_, int p_177460_3_, int p_177460_4_)
{
return false;
}

@Override
public boolean saveChunks(boolean p_73151_1_, IProgressUpdate p_73151_2_)
{
return true;
}

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

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

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

@Override
public List func_177458_a(EnumCreatureType enumCreatureType, BlockPos pos)
{
BiomeGenDream biomegenbase = (BiomeGenDream)this.worldObj.getBiomeGenForCoords(pos);
return biomegenbase.getSpawnableList(enumCreatureType);
}

@Override
public BlockPos getStrongholdGen(World worldIn, String p_180513_2_, BlockPos p_180513_3_)
{
return null;
}

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

@Override
public void recreateStructures(Chunk p_180514_1_, int p_180514_2_, int p_180514_3_)
{}

@Override
public void saveExtraData()
{}
}

Mais c’est peut-être un problème au niveau du biome :

package mods.emotion.dimension;

import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.ChunkPrimer;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class BiomeGenDream extends BiomeGenBase
{
public BiomeGenDream(int par1)
{
super(par1);
setTemperatureRainfall(0.0F, 0.0F);
setHeight(height_LowPlains);
this.theBiomeDecorator.treesPerChunk = 5;
this.theBiomeDecorator.flowersPerChunk = 4;
this.theBiomeDecorator.grassPerChunk = 10;
}

@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer chunkPrimer, int i, int j, double d1)
{
this.topBlock = Blocks.grass.getDefaultState();
this.fillerBlock = Blocks.dirt.getDefaultState();

this.generateEmotionBiomeTerrain(world, rand, chunkPrimer, i, j, d1);
}

public final void generateEmotionBiomeTerrain(World worldIn, Random p_180628_2_, ChunkPrimer p_180628_3_, int p_180628_4_, int p_180628_5_, double p_180628_6_)
{
boolean flag = true;
IBlockState iblockstate = this.topBlock;
IBlockState iblockstate1 = this.fillerBlock;
int k = -1;
int l = (int)(p_180628_6_ / 3.0D + 3.0D + p_180628_2_.nextDouble() * 0.25D);
int i1 = p_180628_4_ & 15;
int j1 = p_180628_5_ & 15;

for(int k1 = 255; k1 >= 0; –k1)
{
if(k1 <= p_180628_2_.nextInt(5))
{
p_180628_3_.setBlockState(j1, k1, i1, Blocks.air.getDefaultState());
}
else
{
IBlockState iblockstate2 = p_180628_3_.getBlockState(j1, k1, i1);

if(iblockstate2.getBlock().getMaterial() == Material.air)
{
k = -1;
}
else if(iblockstate2.getBlock() == Blocks.stone)
{
if(k == -1)
{
if(l <= 0)
{
iblockstate = null;
iblockstate1 = Blocks.stone.getDefaultState();
}
else if(k1 >= 59 && k1 <= 64)
{
iblockstate = this.topBlock;
iblockstate1 = this.fillerBlock;
}

if(k1 < 63 && (iblockstate == null || iblockstate.getBlock().getMaterial() == Material.air))
{
if(this.getFloatTemperature(new BlockPos(p_180628_4_, k1, p_180628_5_)) < 0.15F)
{
iblockstate = Blocks.ice.getDefaultState();
}
else
{
iblockstate = Blocks.water.getDefaultState();
}
}

k = l;

if(k1 >= 62)
{
p_180628_3_.setBlockState(j1, k1, i1, iblockstate);
}
else if(k1 < 56 - l)
{
iblockstate = null;
iblockstate1 = Blocks.stone.getDefaultState();
p_180628_3_.setBlockState(j1, k1, i1, Blocks.gravel.getDefaultState());
}
else
{
p_180628_3_.setBlockState(j1, k1, i1, iblockstate1);
}
}
else if(k > 0)
{
--k;
p_180628_3_.setBlockState(j1, k1, i1, iblockstate1);

if(k == 0 && iblockstate1.getBlock() == Blocks.sand)
{
k = p_180628_2_.nextInt(4) + Math.max(0, k1 - 63);
iblockstate1 = Blocks.air.getDefaultState();
}
}
}
}
}
}

@SideOnly(Side.CLIENT)
public int getGrassColorAtPos(BlockPos pos)
{
return 0xFF2bcda1;
}

@SideOnly(Side.CLIENT)
public int getFoliageColorAtPos(BlockPos pos)
{
return 0xFF2bcda1;
}
}

Aucune erreur à perte de vue, juste une apparition brutale au beau millieux du vide total… En ésperant que quelqu’un trouve une solution, merci d’avance

[EmotionFox]

Bon je sais pas réellement à combien de temps d’intervalle j’ai le droit de “up” mais je vais quand même me permette de le faire après 10h au cas ou quelqu’un de connaisseur passe par ici

[–— UP -----]

[DiabolicaTrix]

@‘robin4002’:

7. Le flood est interdit, il doit y avoir minimum 24h entre deux postes par la même personne. Si vous devez compléter un message et que personne n’a encore répondu, utilisez la fonction éditer.

[Diangle]

Se sour je rentre chez moi. Je regarderai.

Envoyé de mon GT-S7390G

[EmotionFox]

D’accord merci bien