Pchom Pchom
27 févr. 2017, 13:41

Sommaire

Introduction

Dans ce tutoriel, nous allons apprendre comment créer un bloc et lui attribuer une texture simplifiée.

Pré-requis

Code

Tout d’abord, faites bien attention aux pré-requis. Vous allez devoir créer un item pour que le bloc soit entièrement créé dans le jeu, alors vous devez savoir créer un item simple !

La classe des blocs :

Nous allons créer une classe pour enregistrer tous nos blocs. Elle sera très petite, mais au moins, tout ne sera pas dans la classe principale. Vous devez la créer avec le nom [MODID]Blocks, en remplaçant [MODID] par votre modid, en commençant par une majuscule. Dans mon cas, ce sera TutorialBlocks.
Voici donc la classe :

public class TutorialBlocks
{
    // Nous allons ici créer nos blocs.

    public static void setBlockName(Block block, String name)
    {
        // Nous allons ici définir le nom dans le registre du bloc, et son nom non-localisé.
    }
}

Pour créer un bloc, nous allons procéder de cette manière :

public static final Block NOM = new ClasseDuBloc(Material);

Il faut remplacer NOM par le nom de votre variable qui, comme pour les items, doit être entièrement en MAJUSCULE et les espaces remplacés par des underscores _.
ClasseDuBloc est le nom de la classe du bloc, que nous allons créer après, et Material est le matériau que vous souhaitez utiliser. J’utiliserai pour ce tutoriel Material.ROCK.

Chaque matériau possède ses propres attributs :

  • replaceable - Détermine si le bloc peut être remplacé par d’autres blocs lorsqu’ils sont posés, par exemple, la neige, l’herbe, …
  • isTranslucent - Détermine si le bloc est translucide.
  • requiresNoTool - Détermine si le bloc peut être cassé sans outil, ou avec le mauvais outil.
  • mobilityFlag - Peut prendre 3 valeurs :
    • 0, qui veut dire que le bloc est normal. (=EnumPushReaction.NORMAL)
    • 1, qui veut dire que le bloc ne peut pas pousser d’autres blocs. (=EnumPushReaction.DESTROY)
    • 2, qui signifie que le bloc ne peut pas être poussé. (=EnumPushReaction.BLOCK)
  • canBurn - Détermine si le bloc peut brûler.

Vous pouvez créer vos propres matériaux, mais je ne vous apprendrais pas comment le faire dans ce tutoriel. Je vous conseille d’ailleurs d’aller fouiller dans la classe Material, vous pourrez mieux comprendre comment sont faits les matériaux.

Et donc, le contenu de setBlockName :

public static void setBlockName(Block block, String name)
{
    block.setRegistryName(ClassePrincipale.MODID, name).setUnlocalizedName(ClassePrincipale.MODID + "." + name);
}

N’oubliez pas de remplacer ClassePrincipale par le nom de votre classe principale.

Voici donc ce que vous devez obtenir (avec des noms probablement différents) :

public class TutorialBlocks
{

    public static final Block TUTORIAL = new TutorialBlock(Material.ROCK);

    public static void setBlockName(Block block, String name)
    {
        block.setRegistryName(ModTutorial.MODID, name).setUnlocalizedName(ModTutorial.MODID + "." + name);
    }
}

La classe du bloc :

Maintenant que vous avez fait ce qu’il fallait dans la classe des blocs, nous allons créer la classe du bloc.
Vous pouvez l’appeler comme vous voulez, personnellement, j’ai opté pour TutorialBlock.

Nous allons avoir besoin de définir deux choses.

    public static final string NAME = "tutorial_block";

Nous allons utiliser NAME par la suite. “tutorial_block” sera le nom utilisé pour enregistrer le bloc dans le registre mais aussi pour le nom non-localisé, qui sera sous la forme “modid.NAME”. N’oubliez pas qu’il est conseillé que la valeur de NAME soit entièrement en minuscules, et que les espaces doivent être remplacés par des underscores.

Ensuite, nous allons définir le constructeur :

public TutorialBlock(Material material)
{
    super(material);

    TutorialBlocks.setBlockName(this, NAME);
    setResistance(5.0F);
    setHardness(3.0F);
    setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
}

La première ligne sert à appeler le constructeur parent, la seconde appelle notre fonction setBlockName que nous avons définie plus haut, avec comme bloc this et comme nom NAME. setResistance définit la résistance du bloc, c’est la résistance aux explosions. setHardness définit la vitesse de minage du bloc et setCreativeTab sert à choisir dans quel onglet on enregistre le bloc. Ici, nous l’enregistrons dans le premier onglet, où tous les blocs de construction sont présents.

Nous en avons terminé avec le bloc. Bien sûr, vous pouvez lui donner d’autres fonctions, mais le but ici est de faire un bloc basique.

La classe des items :

Pour avoir l’objet dans l’inventaire, il faut avoir un Item. Nous allons donc retourner dans la classe où nous enregistrons nos items.
À la suite de la définition de vos items, ajoutez cette ligne :

public static final Item BLOCK_NOMDELOBJET_ITEM = new ItemBlock([MODID]Blocks.NOM).setRegistryName([MODID]Blocks.NOM.getRegistryName());

Nous créons un nouvel Item de la classe ItemBlock. C’est la classe utilisée pour définir les items qui correspondent à un bloc. Nous lui donnons comme paramètre le bloc que nous avons précédemment créé, et nous lui donnons comme nom de registre le même nom que celui que nous avons attribué à notre bloc.
Vous devez remplacer NOMDELOBJET par le nom de votre objet, [MODID] par votre modid, en commençant par une majuscule (c’est la classe où nous avons créé notre bloc) et NOM par le nom que vous avez donné à la variable dans la classe des blocs.

Voici ce que ça donne, pour moi :

public static final Item BLOCK_TUTORIAL_ITEM = new ItemBlock(TutorialBlocks.TUTORIAL).setRegistryName(TutorialBlocks.TUTORIAL.getRegistryName());

Ensuite, dans la fonction registerItemModels(), ajoutez cette ligne :

registerModel(BLOCK_NOMDELOBJET_ITEM, 0);

N’oubliez pas de modifier le nom de la variable.

Nous en avons terminé avec la création de l’item.

La classe RegisteringHandler :

Maintenant que nous en avons terminé avec la création de l’objet et de son item, nous allons devoir les enregistrer.
Nous allons commencer avec l’enregistrement de l’item. Placez-vous dans la fonction registerItems. Vous devriez avoir cette ligne :

event.getRegistry.registerAll(TutorialItems.TUTORIAL);

Modifiez-là comme ceci :

event.getRegistry.registerAll(TutorialItems.TUTORIAL, TutorialItems.BLOCK_TUTORIAL_ITEM);

Si les noms de votre classe et de vos items sont différents, n’oubliez pas de les modifier.

Nous allons maintenant enregistrer le bloc.

@SubscribeEvent
public void registerBlocks(RegistryEvent.Register<Block> event)
{
    event.getRegistry.registerAll(TutorialBlocks.TUTORIAL);
}

Encore une fois, modifiez les noms que vous avez précédemment définis.
Dans l’ordre de l’enregistrement, les blocs seront enregistrés avant les items, c’est pourquoi je vous conseille d’écrire cette fonction avant celle pour l’enregistrement des items, comme ceci :

public class RegisteringHandler
{
    @SubscribeEvent
    public void registerBlocks(RegistryEvent.Register <block>event)
    {
        event.getRegistry().registerAll(TutorialBlocks.TUTORIAL);
    }

    @SubscribeEvent
    public void registerItems(RegistryEvent.Register event)
    {
        event.getRegistry().registerAll(TutorialItems.TUTORIAL, TutorialItems.BLOCK_TUTORIAL_ITEM);        
    }
}

Vous pouvez ouvrir le jeu, le bloc existe ! Mais… il a quelques bugs, que ça soit au niveau de l’item ou du bloc. Il faut régler ça.

Le modèle et la texture :

Vous vous rappelez du contenu de NAME, que nous avons défini dans la classe du bloc ? Notez-le bien, nous allons l’utiliser.
Vous allez vous placer dans le dossier resources/assets/modid/blockstates. Remplacez modid par votre modid, évidemment.

Nous allons créer un fichier nomdubloc.json, en remplaçant nomdubloc par le contenu de la variable NAME. Par la suite, à chaque fois que vous voyez nomdubloc, n’oubliez pas de le modifier.

{
    "variants": {
        "normal": {
            "model": "modid:nomdubloc"
        }
    }
}

Nous n’avons besoin que de ce code. N’oubliez pas de modifier modid et nomdubloc. Nous allons donc créer le modèle que nous appelons. Il se trouve dans le dossier resources/assets/modid/models/block, et il s’appelle nomdubloc.json, lui aussi.

{
    "parent": "block/cube_all",
    "textures": {
        "all": "modid:blocks/nomdubloc"
    }
}

Nous définissons ici la texture, qui devra se trouver dans le dossier resources/assets/modid/textures/blocks.
Nous devons également définir le modèle de l’item, qui peut être différent de celui du bloc. Il se trouve dans resources/assets/modid/models/item. Définissez-le comme ceci :

{
    "parent": "modid:block/nomdubloc"
}

Ici, nous ne faisons qu’utiliser le modèle du bloc, nous n’y apportons aucune modification.

Dans vos fichiers de langue, ajoutez cette ligne :

tile.modid.nomdubloc.name=Nom du bloc

Remplacez modid par votre modid et nomdubloc par la valeur de NAME que nousa vons définie dans la classe du bloc.

Vous pouvez lancer le jeu, en ayant placé la texture dans son dossier, et hop ! Tout est fonctionnel !

Vous avez donc créé votre premier bloc, un bloc certes, basique, mais un bloc tout de même !

Bonus

Pour aller plus loin, car je ne montre ici que des modèles et textures basiques, vous pouvez consulter ce tutoriel.

Résultat

0_1529094783954_tutoriel bloc.png

Crédits

Rédaction :

Correction :

Inspiration :

Creative Commons
Ce tutoriel de 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

retourRetour vers le sommaire des tutoriels