Créer un bloc simple


  • Administrateurs

    Le bloc est l'élément de Minecraft le plus typique du jeu, même son logo est un bloc. Si d'apparence cela semble être un élément simple, il se cache en fait de nombreuses choses derrière un bloc : un item (toute la partie inventaire des blocs dépend des ItemStack, eux-mêmes constitués d'un item. Il sera donc nécessaire de créer également un item pour manipuler certaines propriétés d'un bloc, par exemple son groupe d'item (aussi appelé onglet créatif)), mais aussi une entité, lorsque celui-ci est "drop" dans le monde, le bloc est en réalité une entité. Cette dernière précision relève plus du détail technique, puisque lorsqu'on créé un bloc la partie entité est automatiquement gérée.

    Le bloc, comme de nombreux autres éléments du jeu est identifié à l'aide d'un nom unique dans un registre, qui sera toujours précédé par l'identifiant du mod (ou minecraft pour le bloc présent de base) et d'un caractère :. Le registre évite les problèmes de conflit qui font désormais partie d'un autre temps.

    Sommaire du tutoriel

    Pré-requis

    La classe de déclaration des blocs

    Nous allons, dans un premier temps, créer la classe ModTutorialBlocks. Cette dernière contiendra les déclarations pour tous les blocs du mod ainsi que leur enregistrement :

    package dev.mff.modtutorial.common.block;
    
    public class ModTutorialBlocks {
    }
    
    package dev.mff.modtutorial.common.block
    
    object ModTutorialBlocks {
    }
    <

    Nous allons également rajouter l'annotation EventBusSubscriber au-dessus de la classe afin qu'on puisse y déclarer des événements :

    @Mod.EventBusSubscriber(modid = ModTutorial.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
    
    @KotlinEventBusSubscriber(modid = ModTutorial.MOD_ID, bus = KotlinEventBusSubscriber.Bus.MOD)
    <

    Je vous redirige vers le tutoriel sur les événements pour avoir plus de détails sur cette dernière.

    Déclaration des blocs

    Ensuite, nous allons déclarer un bloc en nous servant de l'annotation ObjectHolder ayant comme argument l'identifiant du mod ainsi qu'un caractère ":" et enfin le nom de registre du bloc. L'annotation permet à d'autres moddeurs de pouvoir récupérer et modifier les blocs que vous avez créés.

    @ObjectHolder(ModTutorial.MOD_ID + ":block_tutorial")
    public static final Block BLOCK_TUTORIAL = null;
    
    @ObjectHolder("${ModTutorial.MOD_ID}:block_tutorial")
    lateinit var BLOCK_TUTORIAL: Block
    <

    La valeur sera assignée à la volée par l'annotation ObjectHolder une fois le bloc ajouté au registre.

    Attention

    Importer bien la bonne classe Block !
    Pour ceux qui n'auraient pas fait attention, la bonne importation est la suivante : net.minecraft.block.Block

    Enregistrement des blocs

    Pour l'enregistrement des blocs, nous allons devoir utiliser l'événement RegistryEvent.Register<Block>. Pour cela, créez une méthode (registerBlock, par exemple) avec cet événement en argument, ce qui devrait vous donner une méthode proche de celle-ci :

    @SubscribeEvent
    public static void registerBlock(final RegistryEvent.Register<Block> event) {
    }
    
    @SubscribeEvent
    fun registerBlock(event: RegistryEvent.Register<Block>) {
    }
    <

    Maintenant que la méthode est créée, nous allons appeler la fonction getRegistry puis register de l'événement avec pour argument la nouvelle instance de notre bloc. Ce qui donne :

    event.getRegistry().register(new Block(Block.Properties.create(Material.ROCK)).setRegistryName("block_tutorial"));
    
    event.registry.register(Block(Block.Properties.create(Material.ROCK)).setRegistryName("block_tutorial"))
    <

    Attention

    Comme dit en introduction, le nom de registre du bloc doit être unique ! Il doit correspondre à celui mit dans l'annotation ObjectHolder et doit être en minuscule.

    Voilà, nous avons créé et enregistré le bloc le plus simple qui puisse exister.
    Nous pouvons lui définir une dureté (temps de destruction du bloc) et une résistance aux explosions en ajoutant après le matériel la fonction suivante :
    .hardnessAndResistance(dureté, résistance)
    L'obsidienne a pour valeur 50.0F et 1200.0F, la pierre 1.5F et 6.0F. La terre a, quant à elle, une dureté de 0.5F et une résistance de 0.
    Les blocs avec un matériel ROCK ne peuvent qu'être détruits à la pioche, contrairement aux matériels GROUND et ceux ayant le matériel WOOD peuvent brûler.

    Il est aussi possible de créer notre propre classe au lieu d'utiliser la classe Block et, dans ce cas, il suffit de faire :

    event.getRegistry().register(new BlockTutorial(Block.Properties.create(Material.ROCK)).setRegistryName("block_tutorial"));
    
    event.registry.register(BlockTutorial(Block.Properties.create(Material.ROCK)).setRegistryName("block_tutorial"))
    <

    Note

    Créer une classe permet plus de personnalisation du bloc, notamment en réimplémentant différentes méthodes de la classe Block afin de changer leur comportement.

    La classe BlockTutorial n'existant pas encore pour l'instant, il va y avoir une erreur ici. Nous allons donc la créer dans la partie juste en dessous. Pour ceux qui ont choisi d'utiliser la classe Block de Minecraft, vous pouvez directement passer à la partie sur les ressources.

    La classe du bloc

    Pour ceux qui sont toujours là, nous allons créer la classe BlockTutorial :

    package dev.mff.modtutorial.common.block;
    
    public class BlockTutorial{
    }
    
    package dev.mff.modtutorial.common.block
    
    class BlockTutorial
    <

    Note

    J'ai choisi de créer la classe BlockTutorial dans le même package que ModTutorialBlocks, mais vous auriez bien pu la créer ailleurs, mais dans ce cas, n'oubliez pas d'importer la classe.

    La classe est maintenant créée, mais ce n'est pas fini, pour qu'elle soit considérée comme un bloc, il faut la faire hériter de la classe Block, ce qui va donner :

    package dev.mff.modtutorial.common.block;
    
    import net.minecraft.block.Block;
    
    public class BlockTutorial extends Block {
    }
    
    package dev.mff.modtutorial.common.block
    
    import net.minecraft.block.Block
    
    class BlockTutorial: Block
    <

    Enfin, comme votre IDE devrait vous l'indiquer, il va falloir y ajouter un constructeur et vous devriez obtenir un code similaire à celui-ci :

    package dev.mff.modtutorial.common.block;
    
    import net.minecraft.block.Block;
    
    public class BlockTutorial extends Block {
        public BlockTutorial(Properties properties) {
            super(properties);
        }
    }
    
    package dev.mff.modtutorial.common.block
    
    import net.minecraft.block.Block
    
    class BlockTutorial(properties: Properties): Block(properties)
    <

    Les ressources

    L'ensemble des ressources vont aller dans le dossier des ressources src/main/resources puis dans le dossier assets/modid/ (en remplaçant modid par l'identifiant de votre mod). Si les dossiers n'existent pas, il faudra les créer.

    Attention

    Les noms de dossiers de l'ensemble des ressources ne peuvent pas être changés !

    Les états de blocs

    Nous allons, dans un premier temps, créer un dossier blockstates à l'intérieur du dossier assets/modid. Nous allons y mettre un fichier dont le nom doit correspondre au nom de registre, suivi de l'extension .json. Dans notre cas, ce sera donc block_tutorial.json.

    Dans ce fichier, nous allons renseigner le modèle pour chaque variante de notre bloc :

    {
      "variants": {
        "": {
          "model": "modtutorial:block/block_tutorial"
        }
      }
    }
    

    Étant donnée qu'il s'agit d'un bloc simple, il n'y a aucune variante hormis celle par défaut (représenté ici par la chaîne de caractère vide). On y indique que le modèle pour cette variante se trouve dans le dossier bloc du mod modtutorial et que le modèle se nomme block_tutorial.

    Les modèles de blocs

    Nous allons créer les dossiers suivants : models/block (toujours dans le dossier assets/modid) et, de la même façon que pour les états de blocs, nous allons créer le fichier block_tutorial.json.

    {
      "parent": "block/cube_all",
      "textures": {
        "all": "modtutorial:block/block_tutorial"
      }
    }
    
    • le paramètre parent correspond à un modèle de bloc prédéfini par Minecraft, vous pouvez mettre une autre valeur en fonction du bloc que vous voulez créer et vous pouvez également créer vos propres parents. cube_all est un bloc de taille normal avec la même texture sur toutes les faces.
    • le paramètre textures est étroitement lié au parent que vous avez défini au-dessus. Dans le cas d'un cube_all, il n'existe que le paramètre all qui est le chemin de la texture pour toutes les faces du bloc.

    Note

    Dans les dépendances externes de votre IDE, vous trouverez client-extra.jar dans lequel se trouvent toutes les ressources de Minecraft. Le package assets.minecraft.models.block contient les modèles des blocs de Minecraft mais aussi les json parents, comme cube_all.json, cube_bottom_top.json (trois textures, top en haut, bottomen bas et side pour les côtés), cube_column.json (deux textures end utilisé en haut et en bas, side sur les côtés), etc.

    Les modèles d'items blocs

    S'ils ne sont pas présents, nous allons créer les dossiers suivants : models/item, puis nous allons créer le fichier block_tutorial.json.

    {
      "parent": "modtutorial:block/block_tutorial"
    }
    

    Dans le cas des modèles d'items blocs, le parent correspond au modèle de bloc que nous avons défini.

    Les fichiers de langues

    Toujours la même chose, s'il n'existe pas déjà créez le dossier lang dans le dossier assets/modid. Ce dossier contient un fichier .json pour chacun des langages à supporter sous le format langage_variante.json. Donc fr_fr.json pour le français de la France, ou bien fr_ca.json pour le français canadien. Si un fichier de langage pour une variante n'existe pas, il prendra celui de la variante de base. S'il n'existe toujours pas, il passe sur l'anglais. Il faudra donc penser à aussi mettre un fichier en_us.json (pour l'anglais des états-unis, la langue de base de Minecraft).

    Dans ce fichier, nous devrons juste mettre :

    {
      "block.modtutorial.block_tutorial": "Nom traduit dans la langue du fichier"
    }
    

    Les textures

    Dernière étape pour les ressources, nous allons créer le dossier textures/block, puis nous allons ajouter le fichier de texture de notre bloc. La texture doit porter le même nom que le bloc dans le registre. Elle doit être au format .png et avoir une taille de 16x16 ou autre multiple de 2 si vous voulez faire une texture avec une résolution plus élevée.
    block_tutorial.png

    Maintenant que nous en avons fini avec les ressources, nous pouvons lancer le jeu.
    Malheureusement, vous allez vite vous rendre compte que votre bloc ne se trouve pas dans l'inventaire créatif et, pire encore, vous ne pouvez même pas utiliser la commande give pour vous le donner. Ne vous inquiétez pas, c'est totalement normal.
    En effet, nous avons créé un bloc, mais nous n'avons pas créé l'item associé à ce bloc. D'ailleurs, pour bien vous montrez que le bloc existe en jeu, vous pouvez utiliser la commande setblock.

    Ajouter votre bloc dans un groupe d'item

    Pour l'enregistrement des items associés à nos blocs, nous allons devoir créer une nouvelle méthode prenant en paramètre l'événement suivant : RegistryEvent.Register<Item>, ce qui devrait vous donnez une méthode proche de celle-ci :

    @SubscribeEvent
    public static void registerItem(final RegistryEvent.Register<Item> event) {
    }
    
    @SubscribeEvent
    fun registerItem(event: RegistryEvent.Register<Item>) {
    }
    <

    Maintenant que la méthode est créée, nous allons y enregistrer un item associé à notre bloc (un ItemBlock), qui sera présent dans la liste créative des blocs de construction :

    event.getRegistry().register(new ItemBlock(BLOCK_TUTORIAL, new Item.Properties().group(ItemGroup.BUILDING_BLOCKS)).setRegistryName(BLOCK_TUTORIAL.getRegistryName()));
    
    event.registry.register(ItemBlock(BLOCK_TUTORIAL, Item.Properties.group(ItemGroup.BUILDING_BLOCKS)).setRegistryName(BLOCK_TUTORIAL.registryName))
    <

    Voilà, nous avons créé et enregistré l'item associé à notre bloc.

    Désormais, si vous allez en jeu, vous trouverez votre bloc avec les autres blocs de Minecraft.

    Résultat

    2019-03-11_17.51.01.png

    Les différents modifications du code sont retrouvables sur le commit Github suivant : https://github.com/MinecraftForgeFrance/mod-tutorial-1.13.2/commit/d494cf46086cdccb1b95c7cb8c6bdf2b00a35a83

    Licence et attribution

    Creative Commons

    Ce tutoriel rédigé par @Superloup10, @robin4002 corrigé par @DiabolicaTrix et publié sur Minecraft Forge France est mis à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International

    retour Sommaire des tutoriels