[1.4.x] Génération d'un nouveau village



  • Bonjour à tous,

    Je suis en train de construire un mod en 1.4.6 et je me retrouve bloqué depuis un bon moment sur l'ajout d'un nouveau type de village.

    J'ai jusque là créé la plupart des fichiers nécessaires pour générer un village de type bandit et j'ai pu vérifié que la génération fonctionnait en remplaçant mapgenVillage par mapgenBanditVillage dans les fichiers ChunkProviderFlat et ChunkProviderGenerate.
    Cependant, je ne veux pas devoir modifier un fichier de base pour effectuer la génération de ce village, surtout que j'ai 2 types de villages différents à ajouter.

    Voilà déjà à quoi devrait ressembler un village Bandit (généré à la place du village de base) :

    Le résultat est plutôt satisfaisant.

    Ensuite j'ai testé une autre méthode en ajoutant cette ligne dans le fichier ClientProxy dans le @PreInit (remplace WorldType.java par ModWorldType.java sans toucher directement au fichier de base) :
    WorldType FLAT = new ModWorldType(1, "flat");

    La map générée à sa création n'était étrangement pas plate, elle a générée un monde par défaut mélangé à un monde plat (comme un monde normal avec plein de trous). Le simple fait d'écrire WorldType FLAT = new WorldType(1, "flat"); pose ce problème, même sans utiliser le fichier ModWorldType.

    J'ai ensuite testé cette ligne :
    WorldType FLAT = new ModWorldType(3, "flat");

    Cette fois il y a une option supplémentaire qui permet au joueur de choisir un 4 ème type de map et cette fois elle était plate et montrait un résultat identique à la capture d'écran ci-dessus.
    Le problème c'est que je n'ai pas non plus envie d'obliger le joueur à choisir un type de map différent pour que le village soit généré correctement.

    Mon dernier test que j'ai effectué mis à part d'autres nombreux tests est l'ajout de cette ligne :
    WorldType DEFAULT = new ModWorldType(0, "default", 1);

    J'ai donc testé dans le monde par défaut pour voir si la structure était générée.
    La map générée semblait normale en apparence mais je pense que la méthode utilisée peut gêner l'utilisation d'autres mods.

    Voici le résultat obtenu sur le monde normal :

    Le village est générée dans un biome foret comme ce que j'avais prévu par défaut. J'ai trouvé beaucoup d'autres villages bandits mais cette fois les villages normaux n'apparaissent pas (je suppose que c'est normal puisque le fichier que j'ai utilisé doit prendre le dessus sur celui de base).

    Je met ici les dernières classes que j'ai utilisé :

    ClientProxy.java :

    
    package ModAddedItems.client;
    
    import java.util.Map;
    
    //… coupure car le message est trop long (juste des imports).
    public class ClientProxy extends CommonProxy
    {
    @Override
    public void registerRender() //PreLoad
    {
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/items/ModItems.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/blocks/ModBlocks.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/NormalDeamon.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/GlassDeamon.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/DarkDeamon.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/NetherDeamon.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Bandit1.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Bandit2.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Bandit3.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Hunter1.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Hunter2.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Hunter3.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Ghost1.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Ghost2.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Ghost3.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Ghost4.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Ghost5.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/Ghost6.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightBlueV1.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightBlueV2.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightBlueV3.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightBlueV4.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightRedV1.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightRedV2.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightRedV3.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KnightRedV4.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/BloodZombie.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/DevilZombie.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/MinerZombie1.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/MinerZombie2.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/DesSoldierZombie.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/KingZombie.png");
    MinecraftForgeClient.preloadTexture("/ModAddedItems/textures/mobs/DevilSkeleton.png");
    
    RenderingRegistry.registerEntityRenderingHandler(EntityNormalDeamon.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityGlassDeamon.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityDarkDeamon.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityNetherDeamon.class, new RenderBiped(new ModelBiped(), 0.5f));
    //RenderingRegistry.registerEntityRenderingHandler(EntityBandit.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityBandit.class, new RenderBandit(new ModelBipedWithShield(), 0.5f));/*
    RenderingRegistry.registerEntityRenderingHandler(EntityBandit2.class, new RenderBandit(new ModelBipedWithShield(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityBandit3.class, new RenderBiped(new ModelBipedWithShield(), 0.5f));*/
    RenderingRegistry.registerEntityRenderingHandler(EntityHunter.class, new RenderHunter(new ModelBipedWithShield(), 0.5f));/*
    RenderingRegistry.registerEntityRenderingHandler(EntityHunter2.class, new RenderHunter(new ModelBipedWithShield(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityHunter3.class, new RenderBiped(new ModelBipedWithShield(), 0.5f));*/
    RenderingRegistry.registerEntityRenderingHandler(EntityGhost.class, new RenderBiped(new ModelBiped(), 0.5f));/*
    RenderingRegistry.registerEntityRenderingHandler(EntityGhost2.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityGhost3.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityGhost4.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityGhost5.class, new RenderBiped(new ModelBiped(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityGhost6.class, new RenderBiped(new ModelBiped(), 0.5f));*/
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightBlue.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));/*
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightBlueV2.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightBlueV3.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightBlueV4.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));*/
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightRed.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));/*
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightRedV2.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightRedV3.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightRedV4.class, new RenderKnight(new ModelBipedWithShield(), 0.5f));*/
    RenderingRegistry.registerEntityRenderingHandler(EntityBloodZombie.class, new RenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityDevilZombie.class, new RenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityMinerZombie1.class, new ModRenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityMinerZombie2.class, new ModRenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityDesSoldierZombie.class, new RenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityKingZombie.class, new RenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityKnightZombie.class, new ModRenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityDevilSkeleton.class, new RenderSkeleton());
    RenderingRegistry.registerEntityRenderingHandler(EntityMonkey.class, new RenderBiped(new ModelMonkey(), 0.5f));
    RenderingRegistry.registerEntityRenderingHandler(EntityFatherChristmas.class, new RenderFatherChristmas());
    
    ModTileEntityGift.mainRegistry();
    ModTileEntityEnderGift.mainRegistry();
    
    // SOUNDS
    MinecraftForge.EVENT_BUS.register(new eventSounds());
    MinecraftForge.EVENT_BUS.register(new eventStreaming());
    //MinecraftForge.EVENT_BUS.register(new eventLeaves());
    //MinecraftForge.EVENT_BUS.register(new eventMobAttack());
    MinecraftForge.EVENT_BUS.register(new eventShields());
    
        //WorldType DEFAULT = new ModWorldType(0, "default", 1);
    
        /** Flat world type. */
        //WorldType FLAT = new ModWorldType(1, "flat");
    //MinecraftForge.TERRAIN_GEN_BUS.register(new ModWorldType(0, "default", 1));
    //MinecraftForge.TERRAIN_GEN_BUS.register(new ModWorldType(0, "default", 1));
    //MinecraftForge.TERRAIN_GEN_BUS.register(new ModWorldType(1, "flat"));
    }
    
    @Override
    public void registerRender2() { //Load
    int PinIconIndex = ModDeclare.pin.getIconIndex(new ItemStack(ModDeclare.pin));
    int NinjastarsIconIndex = ModDeclare.ninjastars.getIconIndex(new ItemStack(ModDeclare.ninjastars));
    RenderingRegistry.registerEntityRenderingHandler(EntityPin.class, new ModRenderItem(PinIconIndex));
    RenderingRegistry.registerEntityRenderingHandler(EntityNinjastars.class, new RenderNinjastars(NinjastarsIconIndex));
    RenderingRegistry.registerEntityRenderingHandler(EntitySpeardiamond.class, new RenderSpeardiamond());
    RenderingRegistry.registerEntityRenderingHandler(EntitySpeargold.class, new RenderSpeargold());
    RenderingRegistry.registerEntityRenderingHandler(EntitySpeariron.class, new RenderSpeariron());
    RenderingRegistry.registerEntityRenderingHandler(EntitySpearstone.class, new RenderSpearstone());
    RenderingRegistry.registerEntityRenderingHandler(EntitySpearwood.class, new RenderSpearwood());
    
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityGift.class, new TileEntityGiftRenderer());
    MinecraftForgeClient.registerItemRenderer(ModDeclare.Gift.blockID, new ItemRenderGift());
    
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityEnderGift.class, new TileEntityEnderGiftRenderer());
    MinecraftForgeClient.registerItemRenderer(ModDeclare.EnderGift.blockID, new ItemRenderEnderGift());
    }
    }
    
    

    ModWorldType.java :

    
    package ModAddedItems.world;
    
    //... coupure car le message est trop long (juste des imports).
    
    public class ModWorldType extends WorldType
    {
    //... coupure car le message est trop long.
        public IChunkProvider getChunkGenerator(World world, String generatorOptions)
        {
            return (this == FLAT ? new ModChunkProviderFlat(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled(), generatorOptions) : new ModChunkProviderGenerate(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled()));
        }
    
    //... coupure car le message est trop long.
    }
    
    

    ModChunkProviderFlat.java :

    
    //... coupure car le message est trop long (juste des imports).
    public class ModChunkProviderFlat extends ChunkProviderFlat
    {
        private World worldObj;
        private Random random;
        private final byte[] field_82700_c = new byte[256];
        private final byte[] field_82698_d = new byte[256];
        private final FlatGeneratorInfo field_82699_e;
        private final List field_82696_f = new ArrayList();
        private final boolean field_82697_g;
        private final boolean field_82702_h;
        private WorldGenLakes field_82703_i;
        private WorldGenLakes field_82701_j;
    
        public ModChunkProviderFlat(World par1World, long par2, boolean par4, String par5Str)
        {
        super(par1World, par2, par4, par5Str);
            this.worldObj = par1World;
            this.random = new Random(par2);
            this.field_82699_e = FlatGeneratorInfo.createFlatGeneratorFromString(par5Str);
    
            if (par4)
            {
                Map var6 = this.field_82699_e.getWorldFeatures();
    
                if (var6.containsKey("village"))
                {
                    Map var7 = (Map)var6.get("village");
    
                    if (!var7.containsKey("size"))
                    {
                        var7.put("size", "1");
                    }
    
                    this.field_82696_f.add(new MapGenBanditVillage(var7));
                }
    
                if (var6.containsKey("biome_1"))
                {
                    this.field_82696_f.add(new MapGenScatteredFeature((Map)var6.get("biome_1")));
                }
    
                if (var6.containsKey("mineshaft"))
                {
                    this.field_82696_f.add(new MapGenMineshaft((Map)var6.get("mineshaft")));
                }
    
                if (var6.containsKey("stronghold"))
                {
                    this.field_82696_f.add(new MapGenStronghold((Map)var6.get("stronghold")));
                }
            }
    
            this.field_82697_g = this.field_82699_e.getWorldFeatures().containsKey("decoration");
    
            if (this.field_82699_e.getWorldFeatures().containsKey("lake"))
            {
                this.field_82703_i = new WorldGenLakes(Block.waterStill.blockID);
            }
    
            if (this.field_82699_e.getWorldFeatures().containsKey("lava_lake"))
            {
                this.field_82701_j = new WorldGenLakes(Block.lavaStill.blockID);
            }
    
            this.field_82702_h = this.field_82699_e.getWorldFeatures().containsKey("dungeon");
            Iterator var9 = this.field_82699_e.getFlatLayers().iterator();
    
            while (var9.hasNext())
            {
                FlatLayerInfo var10 = (FlatLayerInfo)var9.next();
    
                for (int var8 = var10.getMinY(); var8 < var10.getMinY() + var10.getLayerCount(); ++var8)
                {
                    this.field_82700_c[var8] = (byte)(var10.getFillBlock() & 255);
                    this.field_82698_d[var8] = (byte)var10.getFillBlockMeta();
                }
            }
        }
    
        /**
         * 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)
        {
            Chunk var3 = new Chunk(this.worldObj, par1, par2);
    
            for (int var4 = 0; var4 < this.field_82700_c.length; ++var4)
            {
                int var5 = var4 >> 4;
                ExtendedBlockStorage var6 = var3.getBlockStorageArray()[var5];
    
                if (var6 == null)
                {
                    var6 = new ExtendedBlockStorage(var4, !this.worldObj.provider.hasNoSky);
                    var3.getBlockStorageArray()[var5] = var6;
                }
    
                for (int var7 = 0; var7 < 16; ++var7)
                {
                    for (int var8 = 0; var8 < 16; ++var8)
                    {
                        var6.setExtBlockID(var7, var4 & 15, var8, this.field_82700_c[var4] & 255);
                        var6.setExtBlockMetadata(var7, var4 & 15, var8, this.field_82698_d[var4]);
                    }
                }
            }
    
            var3.generateSkylightMap();
            BiomeGenBase[] var9 = this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[])null, par1 * 16, par2 * 16, 16, 16);
            byte[] var10 = var3.getBiomeArray();
    
            for (int var11 = 0; var11 < var10.length; ++var11)
            {
                var10[var11] = (byte)var9[var11].biomeID;
            }
    
            Iterator var12 = this.field_82696_f.iterator();
    
            while (var12.hasNext())
            {
            ModMapGenStructure var13 = (ModMapGenStructure)var12.next();
                var13.generate(this, this.worldObj, par1, par2, (byte[])null);
            }
    
            var3.generateSkylightMap();
            return var3;
        }
    
        /**
         * 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)
        {
            int var4 = par2 * 16;
            int var5 = par3 * 16;
            BiomeGenBase var6 = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);
            boolean var7 = false;
            this.random.setSeed(this.worldObj.getSeed());
            long var8 = this.random.nextLong() / 2L * 2L + 1L;
            long var10 = this.random.nextLong() / 2L * 2L + 1L;
            this.random.setSeed((long)par2 * var8 + (long)par3 * var10 ^ this.worldObj.getSeed());
            Iterator var12 = this.field_82696_f.iterator();
    
            while (var12.hasNext())
            {
            ModMapGenStructure var13 = (ModMapGenStructure)var12.next();
                boolean var14 = var13.generateStructuresInChunk(this.worldObj, this.random, par2, par3);
    
                if (var13 instanceof MapGenBanditVillage)
                {
                    var7 |= var14;
                }
            }
    
            int var16;
            int var17;
            int var18;
    
            if (this.field_82703_i != null && !var7 && this.random.nextInt(4) == 0)
            {
                var16 = var4 + this.random.nextInt(16) + 8;
                var17 = this.random.nextInt(128);
                var18 = var5 + this.random.nextInt(16) + 8;
                this.field_82703_i.generate(this.worldObj, this.random, var16, var17, var18);
            }
    
            if (this.field_82701_j != null && !var7 && this.random.nextInt(8) == 0)
            {
                var16 = var4 + this.random.nextInt(16) + 8;
                var17 = this.random.nextInt(this.random.nextInt(120) + 8);
                var18 = var5 + this.random.nextInt(16) + 8;
    
                if (var17 < 63 || this.random.nextInt(10) == 0)
                {
                    this.field_82701_j.generate(this.worldObj, this.random, var16, var17, var18);
                }
            }
    
            if (this.field_82702_h)
            {
                for (var16 = 0; var16 < 8; ++var16)
                {
                    var17 = var4 + this.random.nextInt(16) + 8;
                    var18 = this.random.nextInt(128);
                    int var15 = var5 + this.random.nextInt(16) + 8;
                    (new WorldGenDungeons()).generate(this.worldObj, this.random, var17, var18, var15);
                }
            }
    
            if (this.field_82697_g)
            {
                var6.decorate(this.worldObj, this.random, var4, var5);
            }
        }
    
        /**
         * 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;
        }
    
        /**
         * Unloads the 100 oldest chunks from memory, due to a bug with chunkSet.add() never being called it thinks the list
         * is always empty and will not remove any chunks.
         */
        public boolean unload100OldestChunks()
        {
            return false;
        }
    
        /**
         * Returns if the IChunkProvider supports saving.
         */
        public boolean canSave()
        {
            return true;
        }
    
        /**
         * Converts the instance data to a readable string.
         */
        public String makeString()
        {
            return "FlatLevelSource";
        }
    
        /**
         * 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 var5 = this.worldObj.getBiomeGenForCoords(par2, par4);
            return var5 == null ? null : var5.getSpawnableList(par1EnumCreatureType);
        }
    
        /**
         * Returns the location of the closest structure of the specified type. If not found returns null.
         */
        public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
        {
            if ("Stronghold".equals(par2Str))
            {
                Iterator var6 = this.field_82696_f.iterator();
    
                while (var6.hasNext())
                {
                MapGenStructure var7 = (MapGenStructure)var6.next();
    
                    if (var7 instanceof MapGenStronghold)
                    {
                        return var7.getNearestInstance(par1World, par3, par4, par5);
                    }
                }
            }
    
            return null;
        }
    
        public int getLoadedChunkCount()
        {
            return 0;
        }
    
        public void recreateStructures(int par1, int par2)
        {
            Iterator var3 = this.field_82696_f.iterator();
    
            while (var3.hasNext())
            {
            ModMapGenStructure var4 = (ModMapGenStructure)var3.next();
                var4.generate(this, this.worldObj, par1, par2, (byte[])null);
            }
        }
    }
    
    

    ModChunkProviderGenerate.java :

    
    package ModAddedItems.world.gen;
    
    //… coupure car le message est trop long (juste des imports).
    public class ModChunkProviderGenerate extends ChunkProviderGenerate
    {
        /** 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 Village Generator */
        private MapGenBanditVillage villageGenerator = new MapGenBanditVillage();
    
        /** 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);
            villageGenerator = (MapGenBanditVillage) TerrainGen.getModdedMapGen(villageGenerator, VILLAGE);
            ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);
        }
    
        public ModChunkProviderGenerate(World par1World, long par2, boolean par4)
        {
        super(par1World, par2, 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 var4 = 4;
            byte var5 = 16;
            byte var6 = 63;
            int var7 = var4 + 1;
            byte var8 = 17;
            int var9 = var4 + 1;
            this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, var7 + 5, var9 + 5);
            this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * var4, 0, par2 * var4, var7, var8, var9);
    
            for (int var10 = 0; var10 < var4; ++var10)
            {
                for (int var11 = 0; var11 < var4; ++var11)
                {
                    for (int var12 = 0; var12 < var5; ++var12)
                    {
                        double var13 = 0.125D;
                        double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];
                        double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];
                        double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];
                        double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];
                        double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;
                        double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;
                        double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;
                        double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;
    
                        for (int var31 = 0; var31 < 8; ++var31)
                        {
                            double var32 = 0.25D;
                            double var34 = var15;
                            double var36 = var17;
                            double var38 = (var19 - var15) * var32;
                            double var40 = (var21 - var17) * var32;
    
                            for (int var42 = 0; var42 < 4; ++var42)
                            {
                                int var43 = var42 + var10 * 4 << 11 | 0 + var11 * 4 << 7 | var12 * 8 + var31;
                                short var44 = 128;
                                var43 -= var44;
                                double var45 = 0.25D;
                                double var49 = (var36 - var34) * var45;
                                double var47 = var34 - var49;
    
                                for (int var51 = 0; var51 < 4; ++var51)
                                {
                                    if ((var47 += var49) > 0.0D)
                                    {
                                        par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID;
                                    }
                                    else if (var12 * 8 + var31 < var6)
                                    {
                                        par3ArrayOfByte[var43 += var44] = (byte)Block.waterStill.blockID;
                                    }
                                    else
                                    {
                                        par3ArrayOfByte[var43 += var44] = 0;
                                    }
                                }
    
                                var34 += var38;
                                var36 += var40;
                            }
    
                            var15 += var23;
                            var17 += var25;
                            var19 += var27;
                            var21 += var29;
                        }
                    }
                }
            }
        }
    
        /**
         * Replaces the stone that was placed in with blocks that match the biome
         */
        public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
        {
            ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase);
            MinecraftForge.EVENT_BUS.post(event);
            if (event.getResult() == Result.DENY) return;
    
            byte var5 = 63;
            double var6 = 0.03125D;
            this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D);
    
            for (int var8 = 0; var8 < 16; ++var8)
            {
                for (int var9 = 0; var9 < 16; ++var9)
                {
                    BiomeGenBase var10 = par4ArrayOfBiomeGenBase[var9 + var8 * 16];
                    float var11 = var10.getFloatTemperature();
                    int var12 = (int)(this.stoneNoise[var8 + var9 * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);
                    int var13 = -1;
                    byte var14 = var10.topBlock;
                    byte var15 = var10.fillerBlock;
    
                    for (int var16 = 127; var16 >= 0; –var16)
                    {
                        int var17 = (var9 * 16 + var8) * 128 + var16;
    
                        if (var16 <= 0 + this.rand.nextInt(5))
                        {
                            par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID;
                        }
                        else
                        {
                            byte var18 = par3ArrayOfByte[var17];
    
                            if (var18 == 0)
                            {
                                var13 = -1;
                            }
                            else if (var18 == Block.stone.blockID)
                            {
                                if (var13 == -1)
                                {
                                    if (var12 <= 0)
                                    {
                                        var14 = 0;
                                        var15 = (byte)Block.stone.blockID;
                                    }
                                    else if (var16 >= var5 - 4 && var16 <= var5 + 1)
                                    {
                                        var14 = var10.topBlock;
                                        var15 = var10.fillerBlock;
                                    }
    
                                    if (var16 < var5 && var14 == 0)
                                    {
                                        if (var11 < 0.15F)
                                        {
                                            var14 = (byte)Block.ice.blockID;
                                        }
                                        else
                                        {
                                            var14 = (byte)Block.waterStill.blockID;
                                        }
                                    }
    
                                    var13 = var12;
    
                                    if (var16 >= var5 - 1)
                                    {
                                        par3ArrayOfByte[var17] = var14;
                                    }
                                    else
                                    {
                                        par3ArrayOfByte[var17] = var15;
                                    }
                                }
                                else if (var13 > 0)
                                {
                                    –var13;
                                    par3ArrayOfByte[var17] = var15;
    
                                    if (var13 == 0 && var15 == Block.sand.blockID)
                                    {
                                        var13 = this.rand.nextInt(4);
                                        var15 = (byte)Block.sandStone.blockID;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    
        /**
         * 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[] var3 = new byte[32768];
            this.generateTerrain(par1, par2, var3);
            this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
            this.replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);
            this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);
            this.ravineGenerator.generate(this, this.worldObj, par1, par2, var3);
    
            if (this.mapFeaturesEnabled)
            {
                this.villageGenerator.generate(this, this.worldObj, par1, par2, var3);
            }
    
            Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
            byte[] var5 = var4.getBiomeArray();
    
            for (int var6 = 0; var6 < var5.length; ++var6)
            {
                var5[var6] = (byte)this.biomesForGeneration[var6].biomeID;
            }
    
            var4.generateSkylightMap();
            return var4;
        }
    
        /**
         * generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
         * size.
         */
        private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
        {
            ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
            MinecraftForge.EVENT_BUS.post(event);
            if (event.getResult() == Result.DENY) return event.noisefield;
    
            if (par1ArrayOfDouble == null)
            {
                par1ArrayOfDouble = new double[par5 * par6 * par7];
            }
    
            if (this.parabolicField == null)
            {
                this.parabolicField = new float[25];
    
                for (int var8 = -2; var8 <= 2; ++var8)
                {
                    for (int var9 = -2; var9 <= 2; ++var9)
                    {
                        float var10 = 10.0F / MathHelper.sqrt_float((float)(var8 * var8 + var9 * var9) + 0.2F);
                        this.parabolicField[var8 + 2 + (var9 + 2) * 5] = var10;
                    }
                }
            }
    
            double var44 = 684.412D;
            double var45 = 684.412D;
            this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
            this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
            this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);
            this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, var44, var45, var44);
            this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44);
            boolean var43 = false;
            boolean var42 = false;
            int var12 = 0;
            int var13 = 0;
    
            for (int var14 = 0; var14 < par5; ++var14)
            {
                for (int var15 = 0; var15 < par7; ++var15)
                {
                    float var16 = 0.0F;
                    float var17 = 0.0F;
                    float var18 = 0.0F;
                    byte var19 = 2;
                    BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)];
    
                    for (int var21 = -var19; var21 <= var19; ++var21)
                    {
                        for (int var22 = -var19; var22 <= var19; ++var22)
                        {
                            BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)];
                            float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F);
    
                            if (var23.minHeight > var20.minHeight)
                            {
                                var24 /= 2.0F;
                            }
    
                            var16 += var23.maxHeight * var24;
                            var17 += var23.minHeight * var24;
                            var18 += var24;
                        }
                    }
    
                    var16 /= var18;
                    var17 /= var18;
                    var16 = var16 * 0.9F + 0.1F;
                    var17 = (var17 * 4.0F - 1.0F) / 8.0F;
                    double var46 = this.noise6[var13] / 8000.0D;
    
                    if (var46 < 0.0D)
                    {
                        var46 = -var46 * 0.3D;
                    }
    
                    var46 = var46 * 3.0D - 2.0D;
    
                    if (var46 < 0.0D)
                    {
                        var46 /= 2.0D;
    
                        if (var46 < -1.0D)
                        {
                            var46 = -1.0D;
                        }
    
                        var46 /= 1.4D;
                        var46 /= 2.0D;
                    }
                    else
                    {
                        if (var46 > 1.0D)
                        {
                            var46 = 1.0D;
                        }
    
                        var46 /= 8.0D;
                    }
    
                    ++var13;
    
                    for (int var47 = 0; var47 < par6; ++var47)
                    {
                        double var48 = (double)var17;
                        double var26 = (double)var16;
                        var48 += var46 * 0.2D;
                        var48 = var48 * (double)par6 / 16.0D;
                        double var28 = (double)par6 / 2.0D + var48 * 4.0D;
                        double var30 = 0.0D;
                        double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26;
    
                        if (var32 < 0.0D)
                        {
                            var32 *= 4.0D;
                        }
    
                        double var34 = this.noise1[var12] / 512.0D;
                        double var36 = this.noise2[var12] / 512.0D;
                        double var38 = (this.noise3[var12] / 10.0D + 1.0D) / 2.0D;
    
                        if (var38 < 0.0D)
                        {
                            var30 = var34;
                        }
                        else if (var38 > 1.0D)
                        {
                            var30 = var36;
                        }
                        else
                        {
                            var30 = var34 + (var36 - var34) * var38;
                        }
    
                        var30 -= var32;
    
                        if (var47 > par6 - 4)
                        {
                            double var40 = (double)((float)(var47 - (par6 - 4)) / 3.0F);
                            var30 = var30 * (1.0D - var40) + -10.0D * var40;
                        }
    
                        par1ArrayOfDouble[var12] = var30;
                        ++var12;
                    }
                }
            }
    
            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 var4 = par2 * 16;
            int var5 = par3 * 16;
            BiomeGenBase var6 = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);
            this.rand.setSeed(this.worldObj.getSeed());
            long var7 = this.rand.nextLong() / 2L * 2L + 1L;
            long var9 = this.rand.nextLong() / 2L * 2L + 1L;
            this.rand.setSeed((long)par2 * var7 + (long)par3 * var9 ^ this.worldObj.getSeed());
            boolean var11 = false;
    
            MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, rand, par2, par3, var11));
    
            if (this.mapFeaturesEnabled)
            {
                var11 = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
            }
    
            int var12;
            int var13;
            int var14;
    
            if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, LAKE) && 
                    !var11 && this.rand.nextInt(4) == 0)
            {
                var12 = var4 + this.rand.nextInt(16) + 8;
                var13 = this.rand.nextInt(128);
                var14 = var5 + this.rand.nextInt(16) + 8;
                (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, var12, var13, var14);
            }
    
            if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, LAVA) &&
                    !var11 && this.rand.nextInt(8) == 0)
            {
                var12 = var4 + this.rand.nextInt(16) + 8;
                var13 = this.rand.nextInt(this.rand.nextInt(120) + 8);
                var14 = var5 + this.rand.nextInt(16) + 8;
    
                if (var13 < 63 || this.rand.nextInt(10) == 0)
                {
                    (new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, var12, var13, var14);
                }
            }
    
            boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, DUNGEON);
            for (var12 = 0; doGen && var12 < 8; ++var12)
            {
                var13 = var4 + this.rand.nextInt(16) + 8;
                var14 = this.rand.nextInt(128);
                int var15 = var5 + this.rand.nextInt(16) + 8;
    
                if ((new WorldGenDungeons()).generate(this.worldObj, this.rand, var13, var14, var15))
                {
                    ;
                }
            }
    
            var6.decorate(this.worldObj, this.rand, var4, var5);
            SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4 + 8, var5 + 8, 16, 16, this.rand);
            var4 += 8;
            var5 += 8;
    
            doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, ICE);
            for (var12 = 0; doGen && var12 < 16; ++var12)
            {
                for (var13 = 0; var13 < 16; ++var13)
                {
                    var14 = this.worldObj.getPrecipitationHeight(var4 + var12, var5 + var13);
    
                    if (this.worldObj.isBlockFreezable(var12 + var4, var14 - 1, var13 + var5))
                    {
                        this.worldObj.setBlockWithNotify(var12 + var4, var14 - 1, var13 + var5, Block.ice.blockID);
                    }
    
                    if (this.worldObj.canSnowAt(var12 + var4, var14, var13 + var5))
                    {
                        this.worldObj.setBlockWithNotify(var12 + var4, var14, var13 + var5, Block.snow.blockID);
                    }
                }
            }
    
            MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, rand, par2, par3, var11));
    
            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;
        }
    
        /**
         * Unloads the 100 oldest chunks from memory, due to a bug with chunkSet.add() never being called it thinks the list
         * is always empty and will not remove any chunks.
         */
        public boolean unload100OldestChunks()
        {
            return false;
        }
    
        /**
         * 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 var5 = this.worldObj.getBiomeGenForCoords(par2, par4);
            return var5.getSpawnableList(par1EnumCreatureType);
        }
    
        /**
         * Returns the location of the closest structure of the specified type. If not found returns null.
         */
        public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
        {
            return null;
        }
    
        public int getLoadedChunkCount()
        {
            return 0;
        }
    
        public void recreateStructures(int par1, int par2)
        {
            if (this.mapFeaturesEnabled)
            {
                this.villageGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);
            }
        }
    }
    
    

    MapGenBanditVillage.java :

    
    package ModAddedItems.world.gen.structure;
    
    //… coupure car le message est trop long (juste des imports).
    
    public class MapGenBanditVillage extends ModMapGenStructure
    {
        /** A list of all the biomes villages can spawn in. */
        public static List villageSpawnBiomes = Arrays.asList(new BiomeGenBase[] {BiomeGenBase.plains, BiomeGenBase.forest}); // plains pour test
    
        /** World terrain type, 0 for normal, 1 for flat map */
        private int terrainType;
        private int field_82665_g;
        private int field_82666_h;
    
        public MapGenBanditVillage()
        {
            this.terrainType = 0;
            this.field_82665_g = 32;
            this.field_82666_h = 8;
        }
    
        public MapGenBanditVillage(Map par1Map)
        {
            this();
            Iterator var2 = par1Map.entrySet().iterator();
    
            while (var2.hasNext())
            {
                Entry var3 = (Entry)var2.next();
    
                if (((String)var3.getKey()).equals("size"))
                {
                    this.terrainType = MathHelper.parseIntWithDefaultAndMax((String)var3.getValue(), this.terrainType, 0);
                }
                else if (((String)var3.getKey()).equals("distance"))
                {
                    this.field_82665_g = MathHelper.parseIntWithDefaultAndMax((String)var3.getValue(), this.field_82665_g, this.field_82666_h + 1);
                }
            }
        }
    
        protected boolean canSpawnStructureAtCoords(int par1, int par2)
        {
            int var3 = par1;
            int var4 = par2;
    
            if (par1 < 0)
            {
                par1 -= this.field_82665_g - 1;
            }
    
            if (par2 < 0)
            {
                par2 -= this.field_82665_g - 1;
            }
    
            int var5 = par1 / this.field_82665_g;
            int var6 = par2 / this.field_82665_g;
            Random var7 = this.worldObj.setRandomSeed(var5, var6, 10387312);
            var5 *= this.field_82665_g;
            var6 *= this.field_82665_g;
            var5 += var7.nextInt(this.field_82665_g - this.field_82666_h);
            var6 += var7.nextInt(this.field_82665_g - this.field_82666_h);
    
            if (var3 == var5 && var4 == var6)
            {
                boolean var8 = this.worldObj.getWorldChunkManager().areBiomesViable(var3 * 16 + 8, var4 * 16 + 8, 0, villageSpawnBiomes);
    
                if (var8)
                {
                    return true;
                }
            }
    
            return false;
        }
    
        protected ModStructureStart getStructureStart(int par1, int par2)
        {
            return new ModStructureVillageStart(this.worldObj, this.rand, par1, par2, this.terrainType);
        }
    }
    
    

    **WorldRegister.java : **(utilisé pour appelé le fichier registerWorldGen(new WorldGeneratorLittleHouseBandit1(), 0); )

    package ModAddedItems.world;
    
    //... coupure car le message est trop long (juste des imports).
    public class WorldRegister 
    {
    public static void MainRegistry()
    {
    registerWorldGen(new WorldGeneratorBlock(), -1);
    registerWorldGen(new WorldGeneratorBlock(), 0);
    //registerWorldGen(new ModComponentVillageField(), 0);
    registerWorldGen(new WorldGeneratorBlock(), 1);
    registerWorldGen(new WorldGeneratorLittleHouseBandit1(), 0);
    }
    
    public static void registerWorldGen(IWorldGenerator iGenerator, int probability)
    {
    GameRegistry.registerWorldGenerator(iGenerator);
    }
    }
    
    

    WorldGeneratorLittleHouseBandit1.java :
    J'ai utilisé ce fichier de base pour tester la génération d'une structure simple donc c'est normal si le nom ou certains bouts de codes sont bizarres.

    package ModAddedItems.world;
    
    //... coupure car le message est trop long (juste des imports).
    public class WorldGeneratorLittleHouseBandit1 implements IWorldGenerator
    {
    private int RandomSpawn = 0;
    
        /** Flat world type. *//*
        public static final WorldType FLAT = new WorldType(1, "flat");
        */
    
    /** Holds Village Generator */
        private MapGenBanditVillage villageGenerator = new MapGenBanditVillage();
    
    @Override
    public void generate(Random random, int chunkX, int chunkZ, World world,
    IChunkProvider chunkGenerator, IChunkProvider chunkProvider)
    {
    switch(world.provider.dimensionId)
    {
    case -1:
    GenerateNether(world, chunkX * 16, chunkZ * 16, random);
    break;
    case 0:
    GenerateOverWorld(world, chunkX * 16, chunkZ * 16, random);
    break;
    case 1:
    GenerateEnd(world, chunkX * 16, chunkZ * 16, random);
    break;
    }
    }
    
    private void GenerateEnd(World world, int i, int j, Random random)
    {
    
    }
    
    private void GenerateOverWorld(World world, int chunkX, int chunkZ, Random rand)
    {
    //RandomSpawn = rand.nextInt(250);
    
    //if (RandomSpawn==249) {
    //LittleHouseBandit1 house = new LittleHouseBandit1();
    MapGenBanditVillage MapGen = new MapGenBanditVillage();
    ChunkProviderGenerate ChunkGenerate = new ModChunkProviderGenerate(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled());
    ChunkProviderFlat ChunkFlat = new ModChunkProviderFlat(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled(), "village");
    
    for(int x = 0;x<2;x++)
    {
    int i = chunkX + rand.nextInt(16);
    int k = chunkZ + rand.nextInt(16);
    int j = world.getHeightValue(i, k);
    //house.generate(world, rand, i, j, k);
    //MapGen.generateStructuresInChunk(world, rand, chunkX, chunkZ);
    //MapGen.generate(getChunkGenerator(world, "village"), world, chunkX, chunkZ, (byte[])null);
    //new ModChunkProviderFlat(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled(), "village");
    //new ModChunkProviderGenerate(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled());
    //getChunkGenerator(world, "village");
    //villageGenerator = (MapGenBanditVillage) TerrainGen.getModdedMapGen(villageGenerator, VILLAGE);
    //TerrainGen.getModdedMapGen(villageGenerator, InitMapGenEvent.EventType.VILLAGE);
    //byte[] var3 = new byte[32768];
    //villageGenerator.generate(getChunkGenerator(world, "village"), world, chunkX, chunkZ, (byte[])null);
    }
    //}
    
    }
    
    private void GenerateNether(World world, int i, int j, Random random)
    {
    
    }
    
        public IChunkProvider getChunkGenerator(World world, String generatorOptions)
        {
        ChunkProviderGenerate ChunkGenerate = new ModChunkProviderGenerate(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled());
    ChunkProviderFlat ChunkFlat = new ModChunkProviderFlat(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled(), generatorOptions);
        if (WorldType.worldTypes.equals("flat"))
        {
        //return new ModChunkProviderFlat(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled(), generatorOptions);
        return ChunkFlat;
            } else {
        //return new ModChunkProviderGenerate(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled());
            return ChunkGenerate;
            }
            //return (world.getWorldInfo().getTerrainType() == FLAT ? new ModChunkProviderFlat(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled(), generatorOptions) : new ModChunkProviderGenerate(world, world.getSeed(), world.getWorldInfo().isMapFeaturesEnabled()));
        }
    }
    
    

    J'ai effectué beaucoup de test sur ce fichier et aucun n'a vraiment été concluant.
    J'ai essayé d'utiliser la fonction generate. du fichier MapGenBanditVillage() mais je ne comprend pas pourquoi il n'y a pas eu de génération.

    La seule solution qui a plus ou moins fonctionné c'est d'ajouter WorldType DEFAULT = new ModWorldType(0, "default", 1); dans le PreInit du ClientProxy mais dans le monde plat les chunks sont perturbés si j'essaie de faire un test sur ce type de monde.

    Je veux éviter les problèmes avec d'autres mods qui pourraient utiliser la même méthode et éviter les problèmes qui pourrait gêner la génération normale de la map donc j'aimerais savoir si d'autres solutions sont possibles comme par exemple comment faire fonctionner la fonction generate. de MapGen comme on pourrait le faire avec une structure normale.

    Si j'arrive à résoudre le problème j'essaierai de générer le village des chasseurs qui ressemble à peu près à ça (sans compter le puit qui n'est pas sur la capture d'écran) :

    Si vraiment personne n'a d'autres solutions je serais obligé de continuer mon mod avec ce petit problème de compatibilité éventuelle de mods, je devrais donc créer un fichier ini pour pouvoir stocker une variable false/true pour les joueurs qui veulent désactiver la génération des villages mais si il y a une autre solution possible ce problème sera peut être réglé.

    Je vous remercie d'avance des réponses que vous pourriez apporter.

    PS :
    Je sais que ça parait étrange que je crée mon mod en 1.4.6 mais si j'ai choisi cette version c'est tout simplement parce que j'ai déjà plusieurs autres mods d'installés sur cette version du minecraft de base. Quand le mod sera terminé je ferais évidement des adaptations pour d'autres versions un peu plus récentes.
    Je m'excuse également du manque de balise correcte dans le titre, le choix de la version 1.4 n'existe tout simplement pas.



  • Pourquoi faire un mod dans un version aussi vieille?



  • @'isador34':

    Pourquoi faire un mod dans un version aussi vieille?

    La plupart des mods que j'ai installé sont sur cette version et charger une map d'une version plus vieille à une version plus récente peut causer des petits problèmes comme l'apparition ou disparition de certains blocs sur la map ou la disparition des items des mods.

    C'était aussi une occasion d'apprendre facilement à créer un mod car il y a beaucoup moins de code à comprendre dans les classes.
    Mais je pense que ça aurait été plus facile en commençant par la 1.6 plutôt que la 1.4 car tous les tutoriels commences au moins par la 1.5.

    Heureusement il n'y a pas beaucoup de différences entre la version 1.4 et 1.6 mis à par quelques fonctionnalités de forge en moins.

    Quand j'aurais terminé mon mod j'ai prévu de l'adapter pour des versions plus récentes donc il faudra probablement que je revois plusieurs parties de mon mod, surtout à partir de la 1.7 qui doit comporter de plus gros changements dans le code.



  • En tout cas dev des mods sur cette chose ne te sera pas bénéfique pour ton apprentissage, autant commencer  immédiatement par la 1.12
    surtout que pas mal de mods son déjà sortit en 1.12 (api, etc…)
    et si tu veut vraiment pas trop te fatiguer ya la 1.7.10 pour ca



  • @'SpyMan':

    En tout cas dev des mods sur cette chose ne te sera pas bénéfique pour ton apprentissage, autant commencer  immédiatement par la 1.12
    surtout que pas mal de mods son déjà sortit en 1.12 (api, etc…)
    et si tu veut vraiment pas trop te fatiguer ya la 1.7.10 pour ca

    Peut être plus tard pour d'autres mods car mon mod est pratiquement terminé, il ne me reste plus que les trucs les plus compliqués comme les villages, éventuellement un château avec de nouveaux villageois et un roi ainsi que quelques petites modifications ou ajouts que je ferais à la fin de mon mod.

    Tout ce qu'il me reste à faire est surtout assez facultatif dans mon mod mais je vais quand même essayer de finir ma liste.


    Pour le moment les 2 nouveaux villages spawn dans le monde normal dans les biomes forets avec la première solution, je me suis rendu compte dans mes tests que utiliser la ligne WorldType DEFAULT = new ModWorldType(0, "default", 1); permettait également de modifier le monde plat sans perturber les chunks de la map.

    Comme les villages ne peuvent spawn uniquement que dans les biomes forêt je n'ai heureusement pas besoin du monde plat donc j'ai mis à l'écart la classe ModChunkProviderFlat et placé l'ancien à la place tout en laissant la modification du monde normal avec la classe ModChunkProviderGenerate.

    Je pense toujours que la première solution est assez contraignante à cause de la possibilité que le mod ne sois plus compatible avec d'autres mods qui modifient le monde normal donc même si la solution que j'ai utilisé fonctionne je regarderais encore de temps en temps sur le forum pour voir si d'autres solutions proposés permettraient d'obtenir le même résultat que la première solution mais sans risques de perturber d'autres mods.