Modding FR

nostre

Aventurier
13 Novembre 2010
424
5
0
31
subject_mods_32.png

Minecraft est un jeu en plein développement,aussi bien du coté de chez Mojang que de celui de la communauté, qui ne cesse de développer toujours plus de mods et de extures packs.

Cependant, pour toute personne voulant tenter le modding de Minecraft,il faudra passer par les tutoriaux du forum officiel,où le français n'est pas vraiment courant.
De plus,si la personne en question ne connait pas un minimum certaines bases de code,sa devient vite un enfer de se lancer dans le domaines...

C'est pourquoi,devant l'absence total de tutoriel français sur le sujet,et afin d'encourager de nouveaux modder français,j'ai décidé de créer le 1er Tutoriel de Modding Minecraft FR.

Le but n'est pas seulement de créer un tutoriel en français,j'esseye de faire en sorte qu'il sois le plus accessible possible pour toutes personnes, compréhensible même pour des non initiés a toutes formes de codes (ou presque).

tutorial.gif


changelog.png
ChangeLog:
changelog.png

*27-02-11: Mise a jour des tutos I et III pour MCP 29a et ModLoader Beta 1.3_01v4.
*27-02-11: Correction d'une erreur dans le tuto II,merci a Woreck de me l'avoir fait remarquer !
*11-04-11: Mise a jour complète pour Minecraft Beta 1.4_01,MCP211 et ModLoader B1.4_01 v1.
*27-04-2011: Mise a jour pour Minecraft B1.5_01,MCP v2.12 et ModLoader v3 B1.5_01.
*30-04-2011: Correction d'une erreur avec les recettes,et mise a disposition des fichiers mod_MyMod.java et BlockMyBloc.java.
exclamation.gif
*29-05-11: Mise a jour pour Minecraft B1.6.5,MCP v3.3 et ModLoader v1 B1.6.5.


! Les liens suivants sont morts !

tuto.png

green-download-arrow-grey-line.png
Tutorial Modding FR - Téléchargement:
green-download-arrow-grey-line.png

asus_download_arrow004.gif
Tuto I - Téléchargement et installation
asus_download_arrow004.gif
Tuto II - Création d'un mod simple,ajout de nouveaux blocs
asus_download_arrow004.gif
Tuto III - Compilation et tests
asus_download_arrow004.gif
Tuto IV - Quelques petits trucs a savoir avant de continuer
asus_download_arrow004.gif
Tuto - Création de nouveaux objets
asus_download_arrow004.gif
Tuto - Ajouter des blocs et objets pour le four
asus_download_arrow004.gif
Tuto - Blocs – Autres possibilités
asus_download_arrow004.gif
Tuto - Autres possibilités - objets
asus_download_arrow004.gif
Sources du mod du Tuto II

Nouveaux fichiers ajoutés suite aux liens morts à la fin du message.
Il manque juste les "Sources du mod du Tuto II".
Je précise que ce sont les fichiers d'origine, le code est parfois obsolète !
 

Fichiers joints

Comment fait ton pour travailler avec un objet avec une puissance ?

Avec une recette, il faut faire apparement

Code:
new ItemStack(Block.cloth, 1, <puissance>)

Mais pour le reste ?
 
Thanks!!!!
Tuto simple est claire rien a redire. A quand la partit V? Abandonner ?

Sinon dans les premières page j'ai lu pour les plugin bukkit (c'est pour sa que je cherchai des tuto a la base)
http://wiki.bukkit.org/Programming_A_Plugin/fr
Il commence la traduction en français depuis quand je sais pas quand elle sera dispo je sais pas ... mais le tuto sur préparer son environnement de travail est lui déjà fait en Fr
http://wiki.bukkit.org/Setting_Up_Your_Workspace/fr

Je suis un peu en HS sorry mais est-ce que d'autre personne on des truc pour débuter dans Bukkit et les plugins (je suis déjà pas douer en français alors en anglais T_T).
 
j'ai un léger problème hier j'ai voulu continuer mon mode et j'ai fais un copie d'un de mes blocs
il était identique a part que j'ai changer le nom mais dans la version officiel ou la version test mais blocs ne font rien alors qu'on devrait s'enfoncer dedans car ils ont le même fonction que le web oO.

Ensuite je viens de me récréer un Bloc mais qui a une chose de différence il n'as pas la fonction du web mais de la SoulSand mais il ne ralenti pas les mouvement oO.

Dois-je mettre quelque chose à jour ? Franchement je vois pas ce qui cloche :s
 
alors voila j'ai creer une echelle tout se passe bien mais malheuresement je ne peut pas grimper voila le code

public static Block Lianeechelle = (new BlockLadder(99, ModLoader.addOverride("/terrain.png", "/mod/Lianeechelle.png"))).setHardness(0.0F).setBlockName("Liane Gripante").disableNeighborNotifyOnMetadataChange();
 
bonjour
j'ai un probleme: voila ce qu'il me met lorsque je recompile
3erreurs
je cite:
"cannot find symbol
symbole: variable modloader
public class mod_Mymod extends basemod" wtf?:mobcreeper:

2:"cannot find symbol
symbole: variable modloader
modloader.registerblock[mybloc] (les "[" sont les crochet je sais pas les faires :mobsheep:)" wtf?:mobcreeper:

3"cannot find symbol
symbole: variable modloader
modloader.addrecipe[new itemstack[mybloc, 1], new object []
WTF?:mobcreeper:

quels sont les problemes?
(desole pour les fautes mmais je dois ecrire en vitesse je doit eteindre le tout)
 
lorris97
Ce n'est pas modloader mais ModLoader sinon il trouve ps ;) et oui il faut faire attention car en programmation modloader et ModLoader sont des choses différentes ;)
 
j'ai créer une nouvelle dimension ( comme le nether en gros) et puis donc j'ai fait de nouveaux blocs et donc je devrais obtenir en gros ma nouvelle terre avec de la nouvelle stone en dessous comme dans le vrai monde sauf que j'ai que de la nouvelle stone quelqu'un sais pk ?
voilà mon fichier ChunkProvider****
Code:
package net.minecraft.src;

import java.util.Random;

// Referenced classes of package net.minecraft.src:
//            IChunkProvider, MapGenCaves, NoiseGeneratorOctaves, Block, 
//            BiomeGenBase, Chunk, World, WorldChunkManager, 
//            MapGenBase, BlockSand, WorldGenLakes, WorldGenDungeons, 
//            WorldGenClay, WorldGenMinable, WorldGenerator, WorldGenFlowers, 
//            BlockFlower, WorldGenTallGrass, BlockTallGrass, WorldGenDeadBush, 
//            BlockDeadBush, WorldGenReed, WorldGenPumpkin, WorldGenCactus, 
//            WorldGenLiquids, Material, IProgressUpdate

public class ChunkProviderSanctuaire
    implements IChunkProvider
{

    public ChunkProviderSanctuaire(World world, long l)
    {
        sandNoise = new double[256];
        gravelNoise = new double[256];
        stoneNoise = new double[256];
        field_902_u = new MapGenCaves();
        field_914_i = new int[32][32];
        worldObj = world;
        rand = new Random(l);
        field_912_k = new NoiseGeneratorOctaves(rand, 16);
        field_911_l = new NoiseGeneratorOctaves(rand, 16);
        field_910_m = new NoiseGeneratorOctaves(rand, 8);
        field_909_n = new NoiseGeneratorOctaves(rand, 4);
        field_908_o = new NoiseGeneratorOctaves(rand, 4);
        field_922_a = new NoiseGeneratorOctaves(rand, 10);
        field_921_b = new NoiseGeneratorOctaves(rand, 16);
        mobSpawnerNoise = new NoiseGeneratorOctaves(rand, 8);
    }

    public void generateTerrain(int i, int j, byte abyte0[], BiomeGenBase abiomegenbase[], double ad[])
    {
        byte byte0 = 4;
        byte byte1 = 64;
        int k = byte0 + 1;
        byte byte2 = 17;
        int l = byte0 + 1;
        field_4180_q = func_4061_a(field_4180_q, i * byte0, 0, j * byte0, k, byte2, l);
        for(int i1 = 0; i1 < byte0; i1++)
        {
            for(int j1 = 0; j1 < byte0; j1++)
            {
                for(int k1 = 0; k1 < 16; k1++)
                {
                    double d = 0.125D;
                    double d1 = field_4180_q[((i1 + 0) * l + (j1 + 0)) * byte2 + (k1 + 0)];
                    double d2 = field_4180_q[((i1 + 0) * l + (j1 + 1)) * byte2 + (k1 + 0)];
                    double d3 = field_4180_q[((i1 + 1) * l + (j1 + 0)) * byte2 + (k1 + 0)];
                    double d4 = field_4180_q[((i1 + 1) * l + (j1 + 1)) * byte2 + (k1 + 0)];
                    double d5 = (field_4180_q[((i1 + 0) * l + (j1 + 0)) * byte2 + (k1 + 1)] - d1) * d;
                    double d6 = (field_4180_q[((i1 + 0) * l + (j1 + 1)) * byte2 + (k1 + 1)] - d2) * d;
                    double d7 = (field_4180_q[((i1 + 1) * l + (j1 + 0)) * byte2 + (k1 + 1)] - d3) * d;
                    double d8 = (field_4180_q[((i1 + 1) * l + (j1 + 1)) * byte2 + (k1 + 1)] - d4) * d;
                    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;
                            char c = '\200';
                            double d14 = 0.25D;
                            double d15 = d10;
                            double d16 = (d11 - d10) * d14;
                            for(int k2 = 0; k2 < 4; k2++)
                            {
                                double d17 = ad[(i1 * 4 + i2) * 16 + (j1 * 4 + k2)];
                                int l2 = 0;
                                if(k1 * 8 + l1 < byte1)
                                {
                                    if(d17 < 0.5D && k1 * 8 + l1 >= byte1 - 1)
                                    {
                                        l2 = Block.waterStill.blockID;
                                    } else
                                    {
                                        l2 = Block.waterStill.blockID;
                                    }
                                }
                                if(d15 > 0.0D)
                                {
                                    l2 = mod_Infinity.Slimestone.blockID;
                                }
                                abyte0[j2] = (byte)l2;
                                j2 += c;
                                d15 += d16;
                            }

                            d10 += d12;
                            d11 += d13;
                        }

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

                }

            }

        }

    }

    public void replaceBlocksForBiome(int i, int j, byte abyte0[], BiomeGenBase abiomegenbase[])
    {
        byte byte0 = 64;
        double d = 0.03125D;
        sandNoise = field_909_n.generateNoiseOctaves(sandNoise, i * 16, j * 16, 0.0D, 16, 16, 1, d, d, 1.0D);
        gravelNoise = field_909_n.generateNoiseOctaves(gravelNoise, i * 16, 109.0134D, j * 16, 16, 1, 16, d, 1.0D, d);
        stoneNoise = field_908_o.generateNoiseOctaves(stoneNoise, i * 16, j * 16, 0.0D, 16, 16, 1, d * 2D, d * 2D, d * 2D);
        for(int k = 0; k < 16; k++)
        {
            for(int l = 0; l < 16; l++)
            {
                BiomeGenBase biomegenbase = abiomegenbase[k + l * 16];
                boolean flag = sandNoise[k + l * 16] + rand.nextDouble() * 0.20000000000000001D > 0.0D;
                boolean flag1 = gravelNoise[k + l * 16] + rand.nextDouble() * 0.20000000000000001D > 3D;
                int i1 = (int)(stoneNoise[k + l * 16] / 3D + 3D + rand.nextDouble() * 0.25D);
                int j1 = -1;
                byte byte1 = (byte)mod_Infinity.GSrass.blockID;
                byte byte2 = (byte)mod_Infinity.GSrass.blockID;
                for(int k1 = 127; k1 >= 0; k1--)
                {
                    int l1 = (l * 16 + k) * 128 + k1;
                    if(k1 <= 0 + rand.nextInt(5))
                    {
                        abyte0[l1] = (byte)Block.bedrock.blockID;
                        continue;
                    }
                    byte byte3 = abyte0[l1];
                    if(byte3 == 0)
                    {
                        j1 = -1;
                        continue;
                    }
                    if(byte3 != mod_Infinity.Slimestone.blockID)
                    {
                        continue;
                    }
                    if(j1 == -1)
                    {
                        if(i1 <= 0)
                        {
                            byte1 = 0;
                            byte2 = (byte)mod_Infinity.Slimestone.blockID;
                        } else
                        if(k1 >= byte0 - 4 && k1 <= byte0 + 1)
                        {
                            byte1 = (byte)mod_Infinity.GSrass.blockID;
                            byte2 = (byte)mod_Infinity.GSrass.blockID;
                            if(flag1)
                            {
                                byte1 = 0;
                            }
                            if(flag1)
                            {
                                byte2 = (byte)Block.gravel.blockID;
                            }
                            if(flag)
                            {
                                byte1 = (byte)mod_Infinity.Slimesand.blockID;
                            }
                            if(flag)
                            {
                                byte2 = (byte)mod_Infinity.Slimesand.blockID;
                            }
                        }
                        if(k1 < byte0 && byte1 == 0)
                        {
                            byte1 = (byte)Block.waterStill.blockID;
                        }
                        j1 = i1;
                        if(k1 >= byte0 - 1)
                        {
                            abyte0[l1] = byte1;
                        } else
                        {
                            abyte0[l1] = byte2;
                        }
                        continue;
                    }
                    if(j1 <= 0)
                    {
                        continue;
                    }
                    j1--;
                    abyte0[l1] = byte2;
                    if(j1 == 0 && byte2 == mod_Infinity.Slimesand.blockID)
                    {
                        j1 = rand.nextInt(4);
                        byte2 = (byte)mod_Infinity.Slimesand.blockID;
                    }
                }

            }

        }

    }

    public Chunk prepareChunk(int i, int j)
    {
        return provideChunk(i, j);
    }

    public Chunk provideChunk(int i, int j)
    {
        rand.setSeed((long)i * 0x4f9939f508L + (long)j * 0x1ef1565bd5L);
        byte abyte0[] = new byte[32768];
        Chunk chunk = new Chunk(worldObj, abyte0, i, j);
        biomesForGeneration = worldObj.getWorldChunkManager().loadBlockGeneratorData(biomesForGeneration, i * 16, j * 16, 16, 16);
        double ad[] = worldObj.getWorldChunkManager().temperature;
        generateTerrain(i, j, abyte0, biomesForGeneration, ad);
        replaceBlocksForBiome(i, j, abyte0, biomesForGeneration);
        field_902_u.func_867_a(this, worldObj, i, j, abyte0);
        chunk.func_1024_c();
        return chunk;
    }

    private double[] func_4061_a(double ad[], int i, int j, int k, int l, int i1, int j1)
    {
        if(ad == null)
        {
            ad = new double[l * i1 * j1];
        }
        double d = 684.41200000000003D;
        double d1 = 684.41200000000003D;
        double ad1[] = worldObj.getWorldChunkManager().temperature;
        double ad2[] = worldObj.getWorldChunkManager().humidity;
        field_4182_g = field_922_a.func_4109_a(field_4182_g, i, k, l, j1, 1.121D, 1.121D, 0.5D);
        field_4181_h = field_921_b.func_4109_a(field_4181_h, i, k, l, j1, 200D, 200D, 0.5D);
        field_4185_d = field_910_m.generateNoiseOctaves(field_4185_d, i, j, k, l, i1, j1, d / 80D, d1 / 160D, d / 80D);
        field_4184_e = field_912_k.generateNoiseOctaves(field_4184_e, i, j, k, l, i1, j1, d, d1, d);
        field_4183_f = field_911_l.generateNoiseOctaves(field_4183_f, i, j, k, l, i1, j1, d, d1, d);
        int k1 = 0;
        int l1 = 0;
        int i2 = 16 / l;
        for(int j2 = 0; j2 < l; j2++)
        {
            int k2 = j2 * i2 + i2 / 2;
            for(int l2 = 0; l2 < j1; l2++)
            {
                int i3 = l2 * i2 + i2 / 2;
                double d2 = ad1[k2 * 16 + i3];
                double d3 = ad2[k2 * 16 + i3] * d2;
                double d4 = 1.0D - d3;
                d4 *= d4;
                d4 *= d4;
                d4 = 1.0D - d4;
                double d5 = (field_4182_g[l1] + 256D) / 512D;
                d5 *= d4;
                if(d5 > 1.0D)
                {
                    d5 = 1.0D;
                }
                double d6 = field_4181_h[l1] / 8000D;
                if(d6 < 0.0D)
                {
                    d6 = -d6 * 0.29999999999999999D;
                }
                d6 = d6 * 3D - 2D;
                if(d6 < 0.0D)
                {
                    d6 /= 2D;
                    if(d6 < -1D)
                    {
                        d6 = -1D;
                    }
                    d6 /= 1.3999999999999999D;
                    d6 /= 2D;
                    d5 = 0.0D;
                } else
                {
                    if(d6 > 1.0D)
                    {
                        d6 = 1.0D;
                    }
                    d6 /= 8D;
                }
                if(d5 < 0.0D)
                {
                    d5 = 0.0D;
                }
                d5 += 0.5D;
                d6 = (d6 * (double)i1) / 16D;
                double d7 = (double)i1 / 2D + d6 * 4D;
                l1++;
                for(int j3 = 0; j3 < i1; j3++)
                {
                    double d8 = 0.0D;
                    double d9 = (((double)j3 - d7) * 12D) / d5;
                    if(d9 < 0.0D)
                    {
                        d9 *= 4D;
                    }
                    double d10 = field_4184_e[k1] / 512D;
                    double d11 = field_4183_f[k1] / 512D;
                    double d12 = (field_4185_d[k1] / 10D + 1.0D) / 2D;
                    if(d12 < 0.0D)
                    {
                        d8 = d10;
                    } else
                    if(d12 > 1.0D)
                    {
                        d8 = d11;
                    } else
                    {
                        d8 = d10 + (d11 - d10) * d12;
                    }
                    d8 -= d9;
                    if(j3 > i1 - 4)
                    {
                        double d13 = (float)(j3 - (i1 - 4)) / 3F;
                        d8 = d8 * (1.0D - d13) + -10D * d13;
                    }
                    ad[k1] = d8;
                    k1++;
                }

            }

        }

        return ad;
    }

    public boolean chunkExists(int i, int j)
    {
        return true;
    }

    public void populate(IChunkProvider ichunkprovider, int i, int j)
    {
        BlockSand.fallInstantly = true;
        int k = i * 16;
        int l = j * 16;
        BiomeGenBase biomegenbase = worldObj.getWorldChunkManager().getBiomeGenAt(k + 16, l + 16);
        rand.setSeed(worldObj.getRandomSeed());
        long l1 = (rand.nextLong() / 2L) * 2L + 1L;
        long l2 = (rand.nextLong() / 2L) * 2L + 1L;
        rand.setSeed((long)i * l1 + (long)j * l2 ^ worldObj.getRandomSeed());
        double d = 0.25D;
        if(rand.nextInt(4) == 0)
        {
            int i1 = k + rand.nextInt(16) + 8;
            int l4 = rand.nextInt(128);
            int i8 = l + rand.nextInt(16) + 8;
            (new WorldGenLakes(Block.waterStill.blockID)).generate(worldObj, rand, i1, l4, i8);
        }
        if(rand.nextInt(8) == 0)
        {
            int j1 = k + rand.nextInt(16) + 8;
            int i5 = rand.nextInt(rand.nextInt(120) + 8);
            int j8 = l + rand.nextInt(16) + 8;
            if(i5 < 64 || rand.nextInt(10) == 0)
            {
                (new WorldGenLakes(Block.lavaStill.blockID)).generate(worldObj, rand, j1, i5, j8);
            }
        }
        

        

        for(int j2 = 0; j2 < 20; j2++)
        {
            int l5 = k + rand.nextInt(16);
            int i9 = rand.nextInt(128);
            int l11 = l + rand.nextInt(16);
            (new WorldGenMinable(mod_Infinity.GSrass.blockID, 32)).generate(worldObj, rand, l5, i9, l11);
        }

        for(int k2 = 0; k2 < 10; k2++)
        {
            int i6 = k + rand.nextInt(16);
            int j9 = rand.nextInt(128);
            int i12 = l + rand.nextInt(16);
            (new WorldGenMinable(Block.gravel.blockID, 32)).generate(worldObj, rand, i6, j9, i12);
        }

         

        for(int l3 = 0; l3 < 8; l3++)
        {
            int i7 = k + rand.nextInt(16);
            int j10 = rand.nextInt(128);
            int i13 = l + rand.nextInt(16);
            (new WorldGenMinable(Block.oreRedstone.blockID, 7)).generate(worldObj, rand, i7, j10, i13);
        }

        
        for(int l18 = 0; l18 < 50; l18++)
        {
            int l21 = k + rand.nextInt(16) + 8;
            int k23 = rand.nextInt(rand.nextInt(120) + 8);
            int l24 = l + rand.nextInt(16) + 8;
            (new WorldGenLiquids(Block.waterMoving.blockID)).generate(worldObj, rand, l21, k23, l24);
        }

        for(int i19 = 0; i19 < 20; i19++)
        {
            int i22 = k + rand.nextInt(16) + 8;
            int l23 = rand.nextInt(rand.nextInt(rand.nextInt(112) + 8) + 8);
            int i25 = l + rand.nextInt(16) + 8;
            (new WorldGenLiquids(Block.lavaMoving.blockID)).generate(worldObj, rand, i22, l23, i25);
        }

        

        BlockSand.fallInstantly = false;
    }

    public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate)
    {
        return true;
    }

    public boolean unload100OldestChunks()
    {
        return false;
    }

    public boolean canSave()
    {
        return true;
    }

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

    private Random rand;
    private NoiseGeneratorOctaves field_912_k;
    private NoiseGeneratorOctaves field_911_l;
    private NoiseGeneratorOctaves field_910_m;
    private NoiseGeneratorOctaves field_909_n;
    private NoiseGeneratorOctaves field_908_o;
    public NoiseGeneratorOctaves field_922_a;
    public NoiseGeneratorOctaves field_921_b;
    public NoiseGeneratorOctaves mobSpawnerNoise;
    private World worldObj;
    private double field_4180_q[];
    private double sandNoise[];
    private double gravelNoise[];
    private double stoneNoise[];
    private MapGenBase field_902_u;
    private BiomeGenBase biomesForGeneration[];
    double field_4185_d[];
    double field_4184_e[];
    double field_4183_f[];
    double field_4182_g[];
    double field_4181_h[];
    int field_914_i[][];
    private double generatedTemperatures[];
}
si il faut que je donne d'autre fichier comme le WorldProvider***
oui le WorldChunkManager*** je les donnerais