Faire fondre la glace



  • forge 845
    1.6.2

    Je suis en train de créer un block qui ferait fondre la glace
    ( comme la glowstone )

    mais j'ai beau regarder dans le block.java
    ou le class de la glowstone je ne vois rien de spécial

    et par la meme occasion comment faire pour que l'eau gèle dans une dimension

    Merci de votre aide 🙂



  • C'est par rapport à la luminosité de l'endroit où se trouve le bloc de glace.



  • si c'est tres lumineux sa fond ?



  • C'est çà.



  • Ok cool et pour le monde sa marche comment
    je voudrais que toute source d'eau se transforme en glace


  • Administrateurs

    C'est aussi en rapport avec la température du biome: biome froid-> la glace ne font pas; biome chaud->la glace fond.



  • ok mais on la met ou la temperature dans tout sa ? :

    
    package common;
    
    import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE;
    import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.SCATTERED_FEATURE;
    import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE;
    
    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.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 ChunkProviderMoon 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);
    scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen
    .getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);
    
    }
    
    public ChunkProviderMoon(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, 8);
    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, 8);
    
    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];
    }
    
    /**
    * 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 b0 = 4;
    byte b1 = 16;
    byte b2 = 63;
    int k = b0 + 1;
    byte b3 = 17;
    int l = b0 + 1;
    this.biomesForGeneration = this.worldObj.getWorldChunkManager()
    .getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2,
    par2 * 4 - 2, k + 5, l + 5);
    this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * b0,
    0, par2 * b0, k, b3, l);
    
    for (int i1 = 0; i1 < b0; ++i1) {
    for (int j1 = 0; j1 < b0; ++j1) {
    for (int k1 = 0; k1 < b1; ++k1) {
    double d0 = 0.125D;
    double d1 = this.noiseArray[((i1 + 0) * l + j1 + 0) * b3
    + k1 + 0];
    double d2 = this.noiseArray[((i1 + 0) * l + j1 + 1) * b3
    + k1 + 0];
    double d3 = this.noiseArray[((i1 + 1) * l + j1 + 0) * b3
    + k1 + 0];
    double d4 = this.noiseArray[((i1 + 1) * l + j1 + 1) * b3
    + k1 + 0];
    double d5 = (this.noiseArray[((i1 + 0) * l + j1 + 0) * b3
    + k1 + 1] - d1)
    * d0;
    double d6 = (this.noiseArray[((i1 + 0) * l + j1 + 1) * b3
    + k1 + 1] - d2)
    * d0;
    double d7 = (this.noiseArray[((i1 + 1) * l + j1 + 0) * b3
    + k1 + 1] - d3)
    * d0;
    double d8 = (this.noiseArray[((i1 + 1) * l + j1 + 1) * b3
    + k1 + 1] - d4)
    * d0;
    
    for (int l1 = 0; l1 < 8; ++l1) {
    double d9 = 0.25D;
    double d10 = d1;
    double d11 = d2;
    double d12 = (d3 - d1) * d9;
    double d13 = (d4 - d2) * d9;
    
    for (int i2 = 0; i2 < 4; ++i2) {
    int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1
    * 8 + l1;
    short short1 = 128;
    j2 -= short1;
    double d14 = 0.25D;
    double d15 = (d11 - d10) * d14;
    double d16 = d10 - d15;
    
    for (int k2 = 0; k2 < 4; ++k2) {
    if ((d16 += d15) > 0.0D) {
    par3ArrayOfByte[j2 += short1] = (byte) common.MainMod.MoonStone.blockID;
    } else if (k1 * 8 + l1 < b2) {
    par3ArrayOfByte[j2 += short1] = (byte) Block.ice.blockID;
    } else {
    par3ArrayOfByte[j2 += short1] = 0;
    }
    }
    
    d10 += d12;
    d11 += d13;
    }
    
    d1 += d5;
    d2 += d6;
    d3 += d7;
    d4 += d8;
    }
    }
    }
    }
    }
    
    /**
    * 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 b0 = 63;
    double d0 = 0.03125D;
    this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise,
    par1 * 16, par2 * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D,
    d0 * 2.0D);
    
    for (int k = 0; k < 16; ++k) {
    for (int l = 0; l < 16; ++l) {
    BiomeGenBase biomegenbase = par4ArrayOfBiomeGenBase[l + k * 16];
    float f = biomegenbase.getFloatTemperature();
    int i1 = (int) (this.stoneNoise[k + l * 16] / 3.0D + 3.0D + this.rand
    .nextDouble() * 0.25D);
    int j1 = -1;
    byte b1 = biomegenbase.topBlock;
    byte b2 = biomegenbase.fillerBlock;
    
    for (int k1 = 127; k1 >= 0; –k1) {
    int l1 = (l * 16 + k) * 128 + k1;
    
    if (k1 <= 0 + this.rand.nextInt(5)) {
    par3ArrayOfByte[l1] = (byte) Block.bedrock.blockID;
    } else {
    byte b3 = par3ArrayOfByte[l1];
    
    if (b3 == 0) {
    j1 = -1;
    } else if (b3 == common.MainMod.MoonStone.blockID) {
    if (j1 == -1) {
    if (i1 <= 0) {
    b1 = (byte)common.MainMod.MoonDirt.blockID;
    b2 = (byte) common.MainMod.MoonStone.blockID;
    } else if (k1 >= b0 - 4 && k1 <= b0 + 1) {
    b1 = biomegenbase.topBlock;
    b2 = biomegenbase.fillerBlock;
    }
    
    if (k1 < b0 && b1 == 0) {
    if (f > 0.0F) {
    b1 = (byte) Block.ice.blockID;
    } else {
    b1 = (byte) Block.ice.blockID;
    }
    }
    
    j1 = i1;
    
    if (k1 >= b0 - 1) {
    par3ArrayOfByte[l1] = b1;
    } else {
    par3ArrayOfByte[l1] = b2;
    }
    } else if (j1 > 0) {
    –j1;
    par3ArrayOfByte[l1] = b2;
    
    if (j1 == 0
    && b2 == common.MainMod.MoonDirt.blockID) {
    j1 = this.rand.nextInt(4);
    b2 = (byte) common.MainMod.MoonDirt.blockID;
    }
    }
    }
    }
    }
    }
    }
    }
    
    /**
    * 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.rand.setSeed((long) par1 * 341873128712L + (long) par2
    * 132897987541L);
    byte[] abyte = new byte[32768];
    this.generateTerrain(par1, par2, abyte);
    this.biomesForGeneration = this.worldObj.getWorldChunkManager()
    .loadBlockGeneratorData(this.biomesForGeneration, par1 * 16,
    par2 * 16, 16, 16);
    this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);
    this.caveGenerator.generate(this, this.worldObj, par1, par2, abyte);
    this.ravineGenerator.generate(this, this.worldObj, par1, par2, abyte);
    
    if (this.mapFeaturesEnabled) {
    this.mineshaftGenerator.generate(this, this.worldObj, par1, par2,
    abyte);
    this.villageGenerator.generate(this, this.worldObj, par1, par2,
    abyte);
    this.strongholdGenerator.generate(this, this.worldObj, par1, par2,
    abyte);
    this.scatteredFeatureGenerator.generate(this, this.worldObj, par1,
    par2, abyte);
    }
    
    Chunk chunk = new Chunk(this.worldObj, 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];
    }
    
    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.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, d0 / 80.0D, d1 / 160.0D,
    d0 / 80.0D);
    this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2,
    par3, par4, par5, par6, par7, d0, d1, d0);
    this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2,
    par3, par4, par5, par6, par7, d0, d1, d0);
    boolean flag = false;
    boolean flag1 = false;
    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.noise6[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.noise1[i2] / 512.0D;
    double d9 = this.noise2[i2] / 512.0D;
    double d10 = (this.noise3[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;
    }
    
    /**
    * 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;
    int k = par2 * 16;
    int l = par3 * 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) par2 * i1 + (long) par3 * j1
    ^ this.worldObj.getSeed());
    boolean flag = false;
    
    MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(
    par1IChunkProvider, worldObj, rand, par2, par3, flag));
    
    if (this.mapFeaturesEnabled) {
    
    }
    
    int k1;
    int l1;
    int i2;
    
    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;
    
    boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand,
    par2, par3, 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,
    common.MainMod.MoonDirt.blockID, 0, 2);
    }
    
    }
    
    }
    
    MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(
    par1IChunkProvider, worldObj, rand, par2, par3, flag));
    
    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) {
    BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2,
    par4);
    return biomegenbase == null ? null
    : (biomegenbase == BiomeGenBase.swampland
    && par1EnumCreatureType == EnumCreatureType.monster
    && this.scatteredFeatureGenerator.hasStructureAt(par2,
    par3, par4) ? this.scatteredFeatureGenerator
    .getScatteredFeatureSpawnList() : biomegenbase
    .getSpawnableList(par1EnumCreatureType));
    }
    
    /**
    * Returns the location of the closest structure of the specified type. If
    * not found returns null.
    */
    
    public int getLoadedChunkCount() {
    return 0;
    }
    
    public void recreateStructures(int par1, int par2) {
    }
    
    @Override
    public ChunkPosition findClosestStructure(World world, String s, int i,
    int j, int k) {
    // TODO Auto-generated method stub
    return null;
    }
    }
    
    

  • Administrateurs

    La température est définie dans la class du biome.



  • Ok mais j'ai pas reussi a integrer mon biome
    je l'ai creer j'ai mis une temperature froide
    mais j'arrive pas a l'integrer


  • Administrateurs



  • Ok biome integré
    mais quand je lance le jeu crash

    
    –-- Minecraft Crash Report ----
    // Who set us up the TNT?
    
    Time: 25/10/13 15:57
    Description: Initializing game
    
    java.lang.ExceptionInInitializerError
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Unknown Source)
    at cpw.mods.fml.common.FMLModContainer.constructMod(FMLModContainer.java:457)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at com.google.common.eventbus.EventHandler.handleEvent(EventHandler.java:74)
    at com.google.common.eventbus.SynchronizedEventHandler.handleEvent(SynchronizedEventHandler.java:45)
    at com.google.common.eventbus.EventBus.dispatch(EventBus.java:313)
    at com.google.common.eventbus.EventBus.dispatchQueuedEvents(EventBus.java:296)
    at com.google.common.eventbus.EventBus.post(EventBus.java:267)
    at cpw.mods.fml.common.LoadController.sendEventToModContainer(LoadController.java:194)
    at cpw.mods.fml.common.LoadController.propogateStateMessage(LoadController.java:174)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at com.google.common.eventbus.EventHandler.handleEvent(EventHandler.java:74)
    at com.google.common.eventbus.SynchronizedEventHandler.handleEvent(SynchronizedEventHandler.java:45)
    at com.google.common.eventbus.EventBus.dispatch(EventBus.java:313)
    at com.google.common.eventbus.EventBus.dispatchQueuedEvents(EventBus.java:296)
    at com.google.common.eventbus.EventBus.post(EventBus.java:267)
    at cpw.mods.fml.common.LoadController.distributeStateMessage(LoadController.java:105)
    at cpw.mods.fml.common.Loader.loadMods(Loader.java:509)
    at cpw.mods.fml.client.FMLClientHandler.beginMinecraftLoading(FMLClientHandler.java:181)
    at net.minecraft.client.Minecraft.startGame(Minecraft.java:470)
    at net.minecraft.client.Minecraft.func_99999_d(Minecraft.java:796)
    at net.minecraft.client.main.Main.main(Main.java:93)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at net.minecraft.launchwrapper.Launch.launch(Launch.java:57)
    at net.minecraft.launchwrapper.Launch.main(Launch.java:18)
    Caused by: java.lang.NullPointerException
    at common.BiomeGenMoon.<init>(BiomeGenMoon.java:18)
    at common.MainMod.<clinit>(MainMod.java:122)
    ... 35 more
    
    A detailed walkthrough of the error, its code path and all known details is as follows:
    ---------------------------------------------------------------------------------------
    
    -- Head --
    Stacktrace:
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Unknown Source)
    at cpw.mods.fml.common.FMLModContainer.constructMod(FMLModContainer.java:457)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at com.google.common.eventbus.EventHandler.handleEvent(EventHandler.java:74)
    at com.google.common.eventbus.SynchronizedEventHandler.handleEvent(SynchronizedEventHandler.java:45)
    at com.google.common.eventbus.EventBus.dispatch(EventBus.java:313)
    at com.google.common.eventbus.EventBus.dispatchQueuedEvents(EventBus.java:296)
    at com.google.common.eventbus.EventBus.post(EventBus.java:267)
    at cpw.mods.fml.common.LoadController.sendEventToModContainer(LoadController.java:194)
    at cpw.mods.fml.common.LoadController.propogateStateMessage(LoadController.java:174)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at com.google.common.eventbus.EventHandler.handleEvent(EventHandler.java:74)
    at com.google.common.eventbus.SynchronizedEventHandler.handleEvent(SynchronizedEventHandler.java:45)
    at com.google.common.eventbus.EventBus.dispatch(EventBus.java:313)
    at com.google.common.eventbus.EventBus.dispatchQueuedEvents(EventBus.java:296)
    at com.google.common.eventbus.EventBus.post(EventBus.java:267)
    at cpw.mods.fml.common.LoadController.distributeStateMessage(LoadController.java:105)
    at cpw.mods.fml.common.Loader.loadMods(Loader.java:509)
    at cpw.mods.fml.client.FMLClientHandler.beginMinecraftLoading(FMLClientHandler.java:181)
    at net.minecraft.client.Minecraft.startGame(Minecraft.java:470)
    
    -- Initialization --
    Details:
    Stacktrace:
    at net.minecraft.client.Minecraft.func_99999_d(Minecraft.java:796)
    at net.minecraft.client.main.Main.main(Main.java:93)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at net.minecraft.launchwrapper.Launch.launch(Launch.java:57)
    at net.minecraft.launchwrapper.Launch.main(Launch.java:18)
    
    -- System Details --
    Details:
    Minecraft Version: 1.6.2
    Operating System: Windows 7 (amd64) version 6.1
    Java Version: 1.7.0_25, Oracle Corporation
    Java VM Version: Java HotSpot(TM) 64-Bit Server VM (mixed mode), Oracle Corporation
    Memory: 752360168 bytes (717 MB) / 1037959168 bytes (989 MB) up to 1037959168 bytes (989 MB)
    JVM Flags: 3 total; -Xincgc -Xmx1024M -Xms1024M
    AABB Pool Size: 0 (0 bytes; 0 MB) allocated, 0 (0 bytes; 0 MB) used
    Suspicious classes: FML and Forge are installed
    IntCache: cache: 0, tcache: 0, allocated: 0, tallocated: 0
    FML: MCP v8.04 FML v6.2.57.845 Minecraft Forge 9.10.0.845 4 mods loaded, 4 mods active
    mcp{8.04} [Minecraft Coder Pack] (minecraft.jar) Unloaded->Constructed
    FML{6.2.57.845} [Forge Mod Loader] (bin) Unloaded->Constructed
    Forge{9.10.0.845} [Minecraft Forge] (bin) Unloaded->Constructed
    GADD{Alpha 1.0.0} [Galacticraft AddOns] (bin) Unloaded
    Launched Version: 1.6
    
    

    et j'ai pas tres bien compris pourquoi</clinit></init>


  • Administrateurs

    Regarde : Caused by: java.lang.NullPointerException
    at common.BiomeGenMoon.<init>(BiomeGenMoon.java:18)
    at common.MainMod.<clinit>(MainMod.java:122)</clinit></init>



  • ouai mais je comprends pas ce que sa veut dire 😕


  • Administrateurs

    Affiches ces deux class ici.



  • ok alors

    MainMod

    
    package common;
    
    import net.minecraft.block.Block;
    import net.minecraft.item.EnumArmorMaterial;
    import net.minecraft.item.EnumToolMaterial;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemSeeds;
    import net.minecraft.item.ItemStack;
    import net.minecraft.world.biome.BiomeGenBase;
    import net.minecraftforge.common.DimensionManager;
    import net.minecraftforge.common.EnumHelper;
    import cpw.mods.fml.common.Mod;
    import cpw.mods.fml.common.Mod.EventHandler;
    import cpw.mods.fml.common.Mod.Instance;
    import cpw.mods.fml.common.SidedProxy;
    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.network.NetworkMod;
    import cpw.mods.fml.common.registry.GameRegistry;
    import cpw.mods.fml.common.registry.LanguageRegistry;
    
    @Mod(modid = "GADD", name = "Galacticraft AddOns", version = "Alpha 1.0.0")
    @NetworkMod(clientSideRequired = true, serverSideRequired = false)
    public class MainMod {
    
    // Stone outils
    public static Item GPickaxe, GAxe, GSword, GHoe, GShovel, GShears;
    
    static EnumToolMaterial MPickaxe = EnumHelper.addToolMaterial(
    "steelpickaxe", 3, 250, 20F, 2F, 50);
    static EnumToolMaterial MAxe = EnumHelper.addToolMaterial("steelaxe", 3,
    250, 10F, 3F, 50);
    static EnumToolMaterial MSword = EnumHelper.addToolMaterial("steelsword",
    0, 500, 0, 5, 50);
    static EnumToolMaterial MHoe = EnumHelper.addToolMaterial("steelhoe", 0,
    300, 0, 1, 50);
    static EnumToolMaterial MShovel = EnumHelper.addToolMaterial("steelshovel",
    0, 400, 0, 1, 50);
    static EnumToolMaterial MShears = EnumHelper.addToolMaterial("steelshears",
    0, 800, 0, 1, 50);
    
    // Obsidian Outils
    public static Item GOPickaxe, GOAxe, GOSword, GOHoe, GOShovel;
    
    static EnumToolMaterial MOPickaxe = EnumHelper.addToolMaterial(
    "obsipickaxe", 3, 4000, 20F, 2F, 50);
    static EnumToolMaterial MOAxe = EnumHelper.addToolMaterial("obsiaxe", 3,
    8000, 10F, 3F, 50);
    static EnumToolMaterial MOSword = EnumHelper.addToolMaterial("obsisword",
    0, 4000, 0, 5, 50);
    static EnumToolMaterial MOHoe = EnumHelper.addToolMaterial("obsihoe", 0,
    4000, 0, 1, 50);
    static EnumToolMaterial MOShovel = EnumHelper.addToolMaterial("obsishovel",
    0, 4000, 0, 1, 50);
    
    // Hache de guerre en verre
    public static Item GGAxe;
    
    static EnumToolMaterial MGAxe = EnumHelper.addToolMaterial("glassaxe", 3,
    25, 0F, 9F, 50);
    
    //Armure, Combinaison spatiale
    public static Item CasqueNasa, ArmureNasa, PantalonNasa, ChaussuresNasa;
    
    static EnumArmorMaterial Mhelmet = EnumHelper.addArmorMaterial("LH", 60, new int[]{8, 8, 8, 8}, 50);
    
    static EnumArmorMaterial Mplastron = EnumHelper.addArmorMaterial("LP", 60, new int[]{8, 8, 8, 8}, 50);
    
    static EnumArmorMaterial Mleggin = EnumHelper.addArmorMaterial("LL", 60, new int[]{8, 8, 8, 8}, 50);
    
    static EnumArmorMaterial Mboots = EnumHelper.addArmorMaterial("LB", 60, new int[]{8, 8, 8, 8}, 50);
    
    // DirtDust
    
    public static Item DirtDust;
    
    // Agri de Riz
    public static Item ItemRiz, ItemRizGraines;
    
    public static Block BlockRizCulture;
    
    // Agri de Coton
    public static Item ItemCotonGraines;
    
    public static Block BlockCotonCulture;
    
    // Bol de riz
    public static Item BolRiz;
    
    // cereales de riz
    public static Item CerealesDeRiz;
    
    // block de coton plants
    public static Block Coton;
    
    // Kevlar
    public static Block Kevlar;
    
    // Glass
    public static Block Glass;
    
    // StoneReinforced
    public static Block ReinforcedStone;
    
    // logonasa
    public static Block NasaLogo;
    
    // dimension LUNE
    public static final int dimensionId = 10;
    
    // MoonStone
    public static Block MoonStone;
    
    //MoonDirt
    public static Block MoonDirt;
    
    //portal to moon
    public static Block portalMoonBlock;
    
    public static final BiomeGenBase MoonBiome = new BiomeGenMoon(25);
    
    @Instance("GADD")
    public static MainMod instance;
    
    @SidedProxy(clientSide = "common.ClientProxy", serverSide = "common.CommonProxy")
    public static CommonProxy proxy;
    
    @EventHandler
    public void preInit(FMLPreInitializationEvent event) {
    
    portalMoonBlock = new BlockPortalTutorial(501).setUnlocalizedName("portalTutorialBlock");
    GameRegistry.registerBlock(portalMoonBlock, "GADD" + (portalMoonBlock.getUnlocalizedName().substring(5)));
    LanguageRegistry.addName(portalMoonBlock, "Portal Tutorial Block");
    
    // culture de Riz
    BlockRizCulture = new BlockFOODCulture(999)
    .setUnlocalizedName("Culture d'orge");
    ItemRiz = new Item(1000).setUnlocalizedName("Riz").func_111206_d(
    "rm:riz");
    ItemRizGraines = new ItemSeeds(1001, this.BlockRizCulture.blockID,
    Block.tilledField.blockID).setUnlocalizedName("Graines de Riz")
    .func_111206_d("rm:seeds_riz");
    
    GameRegistry.registerBlock(BlockRizCulture, "Culture de Riz");
    GameRegistry.registerItem(ItemRiz, "durizz", "GADD");
    GameRegistry.registerItem(ItemRizGraines, "Graines de Riz", "GADD");
    
    // culture de coton
    BlockCotonCulture = new BlockCotonCulture(1002)
    .setUnlocalizedName("Culture de coton");
    
    ItemCotonGraines = new ItemSeeds(1003, this.BlockCotonCulture.blockID,
    Block.tilledField.blockID).setUnlocalizedName(
    "Graines de coton").func_111206_d("rm:graines de coton");
    
    GameRegistry.registerBlock(BlockCotonCulture, "Culture de Coton");
    GameRegistry.registerItem(ItemCotonGraines, "Graines de Coton", "GADD");
    
    // Bol de riz Item Mangeable
    BolRiz = new BolRiz(1004, 8, 2, false).setUnlocalizedName("BOLRIZE")
    .func_111206_d("rm:riz_bowl");
    
    // CEREALES de RIZ
    CerealesDeRiz = new CerealesRiz(1005).setUnlocalizedName("CERIZ")
    .func_111206_d("rm:riz_cereales");
    
    // Block de Kevlar
    Kevlar = new BlockNasaKevlar(1006).func_111022_d("rm:kevlar")
    .setUnlocalizedName("Kev").setHardness(1.0F)
    .setResistance(10000F);
    
    GameRegistry.registerBlock(Kevlar, "Kevlar de la Nasa");
    
    LanguageRegistry.addName(Kevlar, "Kevlar de la Nasa");
    
    // coton sauvage
    Coton = new BlockCoton(1007).func_111022_d("rm:cotonplant")
    .setUnlocalizedName("Coton").setHardness(0.2F);
    
    GameRegistry.registerBlock(Coton, "Coton sauvage");
    
    LanguageRegistry.addName(Coton, "Coton sauvage");
    
    // Bloc de verre Nasa
    
    Glass = new BlockNasaGlass(1008).func_111022_d("rm:glass")
    .setUnlocalizedName("Glasse").setHardness(2.0F)
    .setResistance(10000F);
    
    GameRegistry.registerBlock(Glass, "Verre de la Nasa");
    
    LanguageRegistry.addName(Glass, "Verre de la Nasa");
    
    // Block Reinforced Stone Nasa
    
    ReinforcedStone = new BlockNasaStone(1009)
    .func_111022_d("rm:reinforced_stone")
    .setUnlocalizedName("Rstone").setHardness(3.0F)
    .setResistance(10000F);
    
    GameRegistry.registerBlock(ReinforcedStone, "Stone de la Nasa");
    
    LanguageRegistry.addName(ReinforcedStone, "Stone de la Nasa");
    
    // NasaLogo
    NasaLogo = new BlockNasaLogo(1010).setUnlocalizedName("Nlogo")
    .setHardness(1.0F);
    
    GameRegistry.registerBlock(NasaLogo, "Logo de la Nasa");
    
    LanguageRegistry.addName(NasaLogo, "Logo de la Nasa");
    
    // Moon Dimension
    DimensionManager.registerProviderType(common.MainMod.dimensionId,
    WorldProviderMoon.class, false);
    DimensionManager.registerDimension(common.MainMod.dimensionId,
    common.MainMod.dimensionId);
    
    // MoonBlocks
    
    MoonStone = new BlockMoonStone(250).func_111022_d("rm:moon_stone")
    .setUnlocalizedName("Mstone").setHardness(3.0F);
    
    GameRegistry.registerBlock(MoonStone, "Stone de la Lune");
    
    LanguageRegistry.addName(MoonStone, "Stone de la Lune");
    
    MoonDirt = new BlockMoonDirt(251).func_111022_d("rm:moon_dirt")
    .setUnlocalizedName("Mdirt").setHardness(1.0F);
    
    GameRegistry.registerBlock(MoonDirt, "Dirt de la Lune");
    
    LanguageRegistry.addName(MoonDirt, "Dirt de la Lune");
    
    }
    
    @EventHandler
    public void load(FMLInitializationEvent event) {
    proxy.registerRenderers();
    
    //Combi spatiale
    CasqueNasa = new Combi(9986, Mhelmet, 0, 0).setUnlocalizedName("Combi").func_111206_d("rm:nasa-casque");
    ArmureNasa = new Combi(9985,Mplastron, 0, 1).setUnlocalizedName("Combi1").func_111206_d("rm:nasa_armure");
    PantalonNasa = new Combi(9984,Mleggin, 0, 2).setUnlocalizedName("Combi2").func_111206_d("rm:nasa_pantalon");
    ChaussuresNasa = new Combi(9983,Mboots, 0, 3).setUnlocalizedName("Combi3").func_111206_d("rm:nasa_chaussures");
    
    GameRegistry.registerItem(CasqueNasa, "Casque de la Nasa");
    GameRegistry.registerItem(ArmureNasa, "Plastron de la Nasa");
    GameRegistry.registerItem(PantalonNasa, "Pantalon de la Nasa");
    GameRegistry.registerItem(ChaussuresNasa, "Chaussures de la Nasa");
    
    LanguageRegistry.addName(CasqueNasa, "Casque de la Nasa");
    LanguageRegistry.addName(ArmureNasa, "Plastron de la Nasa");
    LanguageRegistry.addName(PantalonNasa, "Pantalon de la Nasa");
    LanguageRegistry.addName(ChaussuresNasa, "Chaussures de la Nasa");
    
    // Outils
    // STEELPICKAXE
    
    GPickaxe = new StonePickaxe(9999, MPickaxe)
    .setUnlocalizedName("FAPFAP").func_111206_d("rm:stone_pickaxe");
    LanguageRegistry.addName(GPickaxe, "Moon Pickaxe");
    
    GameRegistry.addRecipe(new ItemStack(GPickaxe), new Object[] { "XXX",
    "XYX", " Y ", 'X', common.MainMod.MoonStone, 'Y', Item.stick });
    
    // STEELAXE
    
    GAxe = new StoneAxe(9998, MAxe).setUnlocalizedName("BLOPP")
    .func_111206_d("rm:stone_axe");
    LanguageRegistry.addName(GAxe, "Moon Axe");
    
    GameRegistry.addRecipe(new ItemStack(GAxe), new Object[] { "XX", "XY",
    " Y", 'X', common.MainMod.MoonStone, 'Y', Item.stick });
    
    // STEELSWORD
    
    GSword = new StoneSword(9997, MSword).setUnlocalizedName("BLOb")
    .func_111206_d("rm:stone_sword");
    LanguageRegistry.addName(GSword, "Moon Sword");
    
    GameRegistry.addRecipe(new ItemStack(GSword), new Object[] { " X",
    " X", " Y", 'X', common.MainMod.MoonStone, 'Y', Item.stick });
    
    // STEELHOE
    
    GHoe = new StoneHoe(9996, MHoe).setUnlocalizedName("BLO")
    .func_111206_d("rm:stone_hoe");
    LanguageRegistry.addName(GHoe, "Moon Hoe");
    
    GameRegistry.addRecipe(new ItemStack(GHoe), new Object[] { "XX", " Y",
    " Y", 'X', common.MainMod.MoonStone, 'Y', Item.stick });
    
    // STEELPELLE
    
    GShovel = new StoneShovel(9995, MShovel).setUnlocalizedName("BLOG")
    .func_111206_d("rm:stone_shovel");
    LanguageRegistry.addName(GShovel, "Moon Shovel");
    
    GameRegistry.addRecipe(new ItemStack(GShovel), new Object[] { " X",
    " Y", " Y", 'X', common.MainMod.MoonStone, 'Y', Item.stick });
    
    // STEELSHEARS
    
    GShears = new StoneShears(9994, MShears)
    .setUnlocalizedName("BLOSHEARS").func_111206_d(
    "rm:stone_shears");
    LanguageRegistry.addName(GShears, "Moon Shears");
    
    GameRegistry.addRecipe(new ItemStack(GShears), new Object[] { "XYX",
    "XYX", "YXY", 'X', common.MainMod.MoonStone });
    
    // OBSIPICKAXE
    
    GOPickaxe = new ObsiPickaxe(9993, MOPickaxe).setUnlocalizedName(
    "FAPFAPe").func_111206_d("rm:obsi_pickaxe");
    LanguageRegistry.addName(GOPickaxe, "Obsidian Pickaxe");
    
    GameRegistry.addRecipe(new ItemStack(GOPickaxe), new Object[] { "XXX",
    "XYX", " Y ", 'X', Block.obsidian, 'Y', Item.stick });
    
    // OBSIAXE
    
    GOAxe = new ObsiAxe(9992, MOAxe).setUnlocalizedName("BLOPPe")
    .func_111206_d("rm:obsi_axe");
    LanguageRegistry.addName(GOAxe, "Obsidian Axe");
    
    GameRegistry.addRecipe(new ItemStack(GOAxe), new Object[] { "XX", "XY",
    " Y", 'X', Block.obsidian, 'Y', Item.stick });
    
    // OBSISWORD
    
    GOSword = new ObsiSword(9991, MOSword).setUnlocalizedName("BLObe")
    .func_111206_d("rm:obsi_sword");
    LanguageRegistry.addName(GOSword, "Obsidian Sword");
    
    GameRegistry.addRecipe(new ItemStack(GOSword), new Object[] { " X",
    " X", " Y", 'X', Block.obsidian, 'Y', Item.stick });
    
    // OBSIHOE
    
    GOHoe = new ObsiHoe(9990, MOHoe).setUnlocalizedName("BLOe")
    .func_111206_d("rm:obsi_hoe");
    LanguageRegistry.addName(GOHoe, "Obsidian Hoe");
    
    GameRegistry.addRecipe(new ItemStack(GOHoe), new Object[] { "XX", " Y",
    " Y", 'X', Block.obsidian, 'Y', Item.stick });
    
    // OBSIPELLE
    
    GOShovel = new ObsiShovel(9989, MOShovel).setUnlocalizedName("BLOGe")
    .func_111206_d("rm:obsi_shovel");
    LanguageRegistry.addName(GOShovel, "Obsidian Shovel");
    
    GameRegistry.addRecipe(new ItemStack(GOShovel), new Object[] { " X",
    " Y", " Y", 'X', Block.obsidian, 'Y', Item.stick });
    
    // GLASSWARAXE
    GGAxe = new GlassAxe(9988, MGAxe).setUnlocalizedName("BLOGaxe")
    .func_111206_d("rm:glass_axe");
    LanguageRegistry.addName(GGAxe, "Glass WarAxe");
    
    GameRegistry.addRecipe(new ItemStack(GGAxe), new Object[] { " X", " Y",
    " Y", 'X', Block.glass, 'Y', Item.stick });
    
    // Items Basiques
    // Poussiere de terre
    
    proxy.registerRenderers();
    DirtDust = new DustDirt(9987).func_111206_d("rm:DUST");
    
    GameRegistry.registerItem(DirtDust, "Dust of Dirt");
    
    LanguageRegistry.addName(DirtDust, "Dust of Dirt");
    // soncraft
    GameRegistry.addRecipe(new ItemStack(DirtDust, 5), new Object[] {
    "XXX", "YXY", "XXX", 'X', Block.stone, 'Y', Block.wood });
    
    // recipe de la terre
    GameRegistry.addRecipe(new ItemStack(Block.dirt, 10), new Object[] {
    "XXX", "XXX", "XXX", 'X', common.MainMod.DirtDust });
    
    // sand recipe four
    GameRegistry.addSmelting(Block.dirt.blockID, new ItemStack(Block.sand,
    5), 0.2f);
    
    // recipe laine de coton
    GameRegistry.addRecipe(new ItemStack(Block.cloth, 1), new Object[] {
    "XXX", "XXX", "XXX", 'X', common.MainMod.ItemCotonGraines });
    
    // Recipe Bol de Riz
    
    GameRegistry
    .addRecipe(new ItemStack(BolRiz),
    new Object[] { " X", " Y", 'X',
    common.MainMod.ItemRizGraines, 'Y',
    Item.bowlEmpty });
    
    // recipe Kevlar
    GameRegistry.addRecipe(new ItemStack(Kevlar), new Object[] { "XXX",
    "XXX", "XXX", 'X', Block.cloth });
    
    // recipe reinforced stone
    GameRegistry.addRecipe(new ItemStack(ReinforcedStone), new Object[] {
    "XXX", "XXX", "XXX", 'X', Block.stone });
    
    // recipe NasaLogo
    GameRegistry.addRecipe(new ItemStack(NasaLogo), new Object[] { "XXX",
    "XYX", "XXX", 'X', Block.stone, 'Y', Item.coal });
    
    // recipe NasaGlass
    GameRegistry.addRecipe(new ItemStack(Glass), new Object[] { "YYY",
    "XXX", "YYY", 'X', Block.glass, 'Y', Block.stone });
    
    // Generation d'herbe
    GameRegistry.registerWorldGenerator(new WorldGeneratorCoton());
    
    }
    
    @EventHandler
    public void postInit(FMLPostInitializationEvent event) {
    
    }
    }
    
    

    et

    
    package common;
    import net.minecraft.block.material.Material;
    import net.minecraft.client.main.Main;
    import net.minecraft.world.biome.BiomeGenBase;
    import net.minecraft.world.gen.feature.WorldGenerator;
    public class BiomeGenMoon extends BiomeGenBase
    {
    private WorldGenerator UnDeadworldGeneratorBigTree;
    public final Material blockMaterial;
    public BiomeGenMoon(int par1)
    {
    super(par1);
    this.blockMaterial = Material.water;
    this.minHeight = 0.1F;
    this.maxHeight = 0.6F;
    this.spawnableMonsterList.clear();
    this.spawnableCreatureList.clear();
    this.topBlock = ((byte)common.MainMod.MoonDirt.blockID);
    this.fillerBlock = ((byte)common.MainMod.MoonDirt.blockID);
    this.setBiomeName("Tutorial");
    
    /** this changes the water colour, its set to red now but ggole the java colours **/
    this.waterColorMultiplier = 0xE42D20;
    }
    }
    
    

  • Administrateurs

    Si tu remplace java this.fillerBlock = ((byte)common.MainMod.MoonDirt.blockID); par ```java
    this.fillerBlock = ((byte)common.MainMod.MoonStone.blockID);



  • Oui

    
    Caused by: java.lang.NullPointerException
    at common.BiomeGenMoon.<init>(BiomeGenMoon.java:18)
    at common.MainMod.<clinit>(MainMod.java:122)
    … 35 more
    
    ```</clinit></init>

  • Administrateurs

    la ligne 18 de ton BiomeGenMoon correspond à this.spawnableCreatureList.clear(); ou pas?



  • non 16 = this.spawnableMonsterList.clear();
    17 = this.spawnableCreatureList.clear();
    18 = this.topBlock = ((byte)common.MainMod.MoonDirt.blockID);


  • Administrateurs

    Si tu retire le common. et que tu importes MainMod, ça change quelque chose?


Log in to reply