Créer un bloc type four (machine)

[BrokenSwing]

Sommaire

• Introduction
• Pré-requis
• Code
  • La classe principale
  • La classe du bloc
  • La classe du TileEntity
  • La classe des recettes
  • La classe du container
  • La classe du SlotResult
  • La classe du GUI
• Bonus
• Résultat

Introduction

Attention : Ce tutoriel comporte des erreurs, il reste cependant fonctionnel, la machine que vous créerai fonctionnera. Pour un tutoriel de meilleur qualité veuillez changer de version et vous référer aux tutoriels des versions supérieurs.

Dans ce tutoriel nous allons apprendre à faire un bloc ressemblant au four (inputs -> outputs). Le bloc possèdera sa classe, un TileEntity, un Container et nous complèterons cela par une classe contenant les différentes recettes que réalisera le bloc.
Je n’est pas besoin de rappeler qu’il faut importer (Ctrl + Maj + O) et si vous avez le choix entre plusieurs imports, choisissez toujours ceux commençants par net.minecraft puis ceux commençants par java.util.

Pré-requis

• Créer un bloc basique
• Créer un gui et un container sur un bloc
• Ajouter un TileEntity au bloc

Code

La classe principale

Tout d’abord, déclarez votre bloc dans votre classe principale avec tous vos autres blocs :

public static Block machineTuto;

Puis instanciez-le dans la méthode pre-init :

@EventHandler
public void preInit(FMLPreInitializationEvent event)
machineTuto = new MachineTuto().setBlockName("machineTuto");
//N'oubliez pas le l'enregistrer
GameRegistry.registerBlock(machineTuto, "machineTuto");

Vous avez une erreur sur la classe MachineTuto(), créez-la.

La classe du bloc

La classe de votre bloc devrait être extends BlockContainer, si ce n’est pas le cas, faites-le. Créez aussi le constructeur de la classe :

public MachineTuto()
{
    super(Material.rock); //Mettez le material qui convient
    this.setResistance(8.0F);
    this.setHarvestLevel("pickaxe", 2); //Outil pour casser le bloc, pour le chiffre : 0=bois, 1=pierre, 2=fer, 3=diamant
    this.setBlockTextureName(ModTutoriel.MODID + ":nom_de_la_texture"); //N'oubliez pas de remplacer "ModTutoriel"
    // ... Mettez les attributs complémentaires que vous voulez
}

Maintenant nous allons nous attaquer au TileEntity du bloc, il faut d’abord dire que le bloc possède un TileEntity :

@Override
    public TileEntity createNewTileEntity(World world, int metadata) //Instancie le TileEntity
    {
        return new TileEntityMachineTuto();
    }

    @Override
    public boolean hasTileEntity(int metadata) //Permet de savoir si le bloc a un TileEntity
    {
        return true;
    }

Il y a une erreur sur la classe TileEntityMachineTuto(), créez-la on y revient dans pas longtemps.
Et ajoutons aussi la méthode qui permet de loot les objets contenus dans le bloc sur le sol (j’ai repris la méthode de minecraft):

public void breakBlock(World world, int x, int y, int z, Block block, int metadata)
    {
        TileEntity tileentity = world.getTileEntity(x, y, z);

                if (tileentity instanceof IInventory)
                {
                    IInventory inv = (IInventory)tileentity;
                    for (int i1 = 0; i1 < inv.getSizeInventory(); ++i1)
                    {
                        ItemStack itemstack = inv.getStackInSlot(i1);

                        if (itemstack != null)
                        {
                            float f = world.rand.nextFloat() * 0.8F + 0.1F;
                            float f1 = world.rand.nextFloat() * 0.8F + 0.1F;
                            EntityItem entityitem;

                            for (float f2 = world.rand.nextFloat() * 0.8F + 0.1F; itemstack.stackSize > 0; world.spawnEntityInWorld(entityitem))
                            {
                                int j1 = world.rand.nextInt(21) + 10;

                                if (j1 > itemstack.stackSize)
                                {
                                    j1 = itemstack.stackSize;
                                }

                                itemstack.stackSize -= j1;
                                entityitem = new EntityItem(world, (double)((float)x + f), (double)((float)y + f1), (double)((float)z + f2), new ItemStack(itemstack.getItem(), j1, itemstack.getItemDamage()));
                                float f3 = 0.05F;
                                entityitem.motionX = (double)((float)world.rand.nextGaussian() * f3);
                                entityitem.motionY = (double)((float)world.rand.nextGaussian() * f3 + 0.2F);
                                entityitem.motionZ = (double)((float)world.rand.nextGaussian() * f3);

                                if (itemstack.hasTagCompound())
                                {
                                    entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());
                                }
                            }
                        }
                    }

                world.func_147453_f(x, y, z, block);
            }

        super.breakBlock(world, x, y, z, block, metadata);
    }

La classe du TileEntity

Nous allons coder la classe la plus longue de ce tutoriel, alors prenez-vous un bon café et c’est partie !

Je ne vais pas détailler toute les fonctions car la plupart sont expliquées dans le tutoriel de robin sur les TileEntity.
Nous allons faire un bloc qui aura trois slots d’input et un slot d’output, cela fait en tout quatre slots pour notre bloc.
Implémentez d’abord IIventory à TileEntityMachineTuto, n’implémentez cependant pas les méthodes, nous allons le faire manuellement au fur et à mesure.
Instancions d’abord nos ItemStack correspondants à nos slots :

private ItemStack[] contents = new ItemStack[4]; //0, 1 et 2 sont les inputs et 3 est l'output

Nous allons aussi tout de suite déclarer deux int qui correspondent au temps de “cuisson” déjà atteint et au temps de “cuisson” nécessaire pour finir la recette :

private int workingTime = 0; //Temps de cuisson actuel
private int workingTimeNeeded = 200; //Temps de cuisson nécessaire

Ces deux valeurs doivent être écrites dans le NBT ainsi que notre tableau d’ItemStack :

    @Override
    public void writeToNBT(NBTTagCompound compound)
    {
        super.writeToNBT(compound);
        NBTTagList nbttaglist = new NBTTagList();

        for (int i = 0; i < this.contents.length; ++i) //pour les slots
        {
            if (this.contents[i] != null)
            {
                NBTTagCompound nbttagcompound1 = new NBTTagCompound();
                nbttagcompound1.setByte("Slot", (byte)i);
                this.contents[i].writeToNBT(nbttagcompound1);
                nbttaglist.appendTag(nbttagcompound1);
            }
        }

        compound.setTag("Items", nbttaglist);
        compound.setShort("workingTime",(short)this.workingTime); //On les enregistrent en short
        compound.setShort("workingTimeNeeded", (short)this.workingTimeNeeded);
    }

Et la méthode pour les lire :

    @Override
    public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);

        NBTTagList nbttaglist = compound.getTagList("Items", 10);
        this.contents = new ItemStack[this.getSizeInventory()];

        for (int i = 0; i < nbttaglist.tagCount(); ++i) //Encore une fois pour les slots
        {
            NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
            int j = nbttagcompound1.getByte("Slot") & 255;

            if (j >= 0 && j < this.contents.length)
            {
                this.contents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
            }
        }

        this.workingTime = compound.getShort("workingTime"); //On lit nos valeurs
        this.workingTimeNeeded = compound.getShort("workingTimeNeeded");
    }

Voilà deux grosses méthodes de faites, on s’arrête pas, on passe aux autres :

    @Override
    public int getSizeInventory() { //Tout est dans le nom, retourne la taille de l'inventaire, pour notre bloc c'est quatre
        return this.contents.length;
    }

    @Override
    public ItemStack getStackInSlot(int slotIndex) { //Renvoie L'itemStack se trouvant dans le slot passé en argument
        return this.contents[slotIndex];
    }

    @Override //Comme dit plus haut, c'est expliqué dans le tutoriel de robin
    public ItemStack decrStackSize(int slotIndex, int amount) {
            if (this.contents[slotIndex] != null)
            {
                ItemStack itemstack;

                if (this.contents[slotIndex].stackSize <= amount)
                {
                    itemstack = this.contents[slotIndex];
                    this.contents[slotIndex] = null;
                    this.markDirty();
                    return itemstack;
                }
                else
                {
                    itemstack = this.contents[slotIndex].splitStack(amount);

                    if (this.contents[slotIndex].stackSize == 0)
                    {
                        this.contents[slotIndex] = null;
                    }

                    this.markDirty();
                    return itemstack;
                }
            }
            else
            {
                return null;
            }
    }

    @Override
    public ItemStack getStackInSlotOnClosing(int slotIndex) {
        if (this.contents[slotIndex] != null)
        {
            ItemStack itemstack = this.contents[slotIndex];
            this.contents[slotIndex] = null;
            return itemstack;
        }
        else
        {
            return null;
        }
    }

    @Override
    public void setInventorySlotContents(int slotIndex, ItemStack stack) {
        this.contents[slotIndex] = stack;

        if (stack != null && stack.stackSize > this.getInventoryStackLimit())
        {
            stack.stackSize = this.getInventoryStackLimit();
        }

        this.markDirty();
    }

    @Override
    public String getInventoryName() { //J'ai décider qu'on ne pouvait pas mettre de nom custom
        return "tile.machineTuto";
    }

    @Override
    public boolean hasCustomInventoryName() {
        return false;
    }

    @Override
    public int getInventoryStackLimit() {
        return 64;
    }

    @Override
    public boolean isUseableByPlayer(EntityPlayer player) {
        return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : player.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;
    }

    @Override
    public void openInventory() {

    }

    @Override
    public void closeInventory() {

    }

    @Override
    public boolean isItemValidForSlot(int slot, ItemStack stack) {
        return slot == 3 ? false : true;
    }

Voilà, référez-vous encore une fois au tutoriel de robin pour la partie ci-dessus.
Maintenant nous allons voir les méthodes propres à l’aspect machine du bloc.
Cette méthode renvoie true si la recette est en train de procéder et false si ce n’est pas le cas.

    public boolean isBurning()
    {
        return this.workingTime > 0;
    }

Cette méthode vérifie si les trois slots d’inputs ne sont pas vides, si les trois items forment une recette et si le slot d’output n’est pas plein et que l’item étant à l’intérieur n’est pas différent de celui que l’on veut créer. Retourne true si on peut lancer le processus de recette et false si on ne peut pas.

    private boolean canSmelt()
    {
        if (this.contents[0] == null || this.contents[1] == null || this.contents[2] == null) //Si les trois premiers slots sont vides
        {
            return false; //On ne peut pas lancer le processus
        }
        else
        {
            ItemStack itemstack = MachineTutoRecipes.smelting().getSmeltingResult(new ItemStack[]{this.contents[0], this.contents[1], this.contents[2]}); //Il y a une erreur ici, c'est normal, on y vient après (c'est pour les recettes)
            if (itemstack == null) return false; //rapport avec les recettes
            if (this.contents[3] == null) return true; //vérifications du slot d'output
            if (!this.contents[3].isItemEqual(itemstack)) return false; //ici aussi
            int result = contents[3].stackSize + itemstack.stackSize;
            return result <= getInventoryStackLimit() && result <= this.contents[3].getMaxStackSize(); //Et là aussi décidément
        }
    }

La méthode suivante est simple à comprendre, vous allez voir :

    public void updateEntity() //Méthode exécutée à chaque tick
    {
        if(this.isBurning() && this.canSmelt()) //Si on "cuit" et que notre recette et toujours bonne, on continue
        {
            ++this.workingTime; //incrémentation
        }
        if(this.canSmelt() && !this.isBurning()) //Si la recette est bonne mais qu'elle n'est toujours pas lancée, on la lance
        {
            this.workingTime = 1; //La méthode isBurning() renverra true maintenant (1>0)
        }
        if(this.canSmelt() && this.workingTime == this.workingTimeNeeded) //Si on est arrivé au bout du temps de cuisson et que la recette est toujours bonne
        {
            this.smeltItem(); //on "cuit" les items
            this.workingTime = 0; //et on réinitialise le temps de cuisson
        }
        if(!this.canSmelt()) //Si la recette la recette n'est plus bonne
        {
                this.workingTime= 0; //le temps de cuisson est de 0
        }
    }

La méthode suivante est celle qui “cuit” les items, vous aurez des erreurs car on utilise la classe qu’on crée juste après :

    public void smeltItem()
    {
        if (this.canSmelt())
        {
            ItemStack itemstack = MachineTutoRecipes.smelting().getSmeltingResult(new ItemStack[]{this.contents[0], this.contents[1], this.contents[2]}); //On récupère l'output de la recette
            if (this.contents[3] == null) //Si il y a rien dans le slot d'output
            {
                this.contents[3] = itemstack.copy(); //On met directement l'ItemStack
            }
            else if (this.contents[3].getItem() == itemstack.getItem()) //Et si l'item que l'on veut est le même que celui qu'il y a déjà
            {
                this.contents[3].stackSize += itemstack.stackSize; // Alors ont incrémente l'ItemStack
            }

            --this.contents[0].stackSize; //On décrémente les slots d'input
            --this.contents[1].stackSize;
            --this.contents[2].stackSize;

            if (this.contents[0].stackSize <= 0) //Si les slots sont vides, on remet à null le slot
            {
                this.contents[0] = null;
            }
            if (this.contents[1].stackSize <= 0)
            {
                this.contents[1] = null;
            }
            if (this.contents[2].stackSize <= 0)
            {
                this.contents[2] = null;
            }
        }
    }

Voilà pour le TileEntity ! Pas trop long ? On passe aux recettes.

La classe des recettes

Créez cette classe une laissant votre souris sur MachineTutoRecipes() et en cliquant sur create class.
Votre classe n’aura pas d’extends ni d’implémentation.
En tout premier lieu, instanciez deux objets :

    private static final MachineTutoRecipes smeltingBase = new MachineTutoRecipes(); //Permet d'instancier votre classe car vous le l'instancierez nul part ailleur
    private Map smeltingList = new HashMap(); //Ceci permet de mettre vos recettes

Mettons en place notre constructeur dans lequel nous mettrons nos recettes :

    public MachineTutoRecipes()
    {
        this.addRecipe(Items.apple, Items.apple, Items.arrow, new ItemStack(Blocks.diamond_block)); //Ajout d'une recette, on fait un bloc de diamant à partie de deux pommes et une flèche
    }

Il y a une erreur sur la fonction addRecipe, ne vous inquiétez pas, il suffit de la créer. Cependant ici il faut faire un choix : quel genre d’items pourront apparaîtrent dans vos recettes ? Que des blocs ? Que des items ? Les deux ? Les deux évidemment il faut alors faire plusieurs versions de la fonction addRecipe(), je prends en compte que dans mon exemple il y a trois slots d’inputs, il y a donc 4 cas possibles :

• Trois items
• Un bloc et deux items
• Deux blocs et un item
• Trois blocsLors de mes recettes, si elles comprennent des blocs, je mettrai ces derniers dans les slots 0 puis 1 puis 2.

Ce qui m’amène à ces fonctions :

    public void addRecipe(ItemStack stack1, ItemStack stack2, ItemStack stack3, ItemStack stack4) //Cette fonction de comprend que des ItemStack, c'est celle qui ajoute les recettes à la HashMap
    {
        ItemStack[] stackList = new ItemStack[]{stack1, stack2, stack3};
        this.smeltingList.put(stackList, stack4);
    }

        public void addRecipe(Item item1, Item item2, Item item3, ItemStack stack) //1er cas
    {
        this.addRecipe(new ItemStack(item1), new ItemStack(item2), new ItemStack(item3), stack);
    }

    public void addRecipe(Block block1, Item item2, Item item3, ItemStack stack) //2nd cas
    {
        this.addRecipe(Item.getItemFromBlock(block1), item2, item3, stack);
    }

    public void addRecipe(Block block1, Block block2, Item item3, ItemStack stack) //3ème cas
    {
        this.addRecipe(Item.getItemFromBlock(block1), Item.getItemFromBlock(block2), item3, stack);
    }

    public void addRecipe(Block block1, Block block2, Block block3, ItemStack stack) //4ème cas
    {
        this.addRecipe(Item.getItemFromBlock(block1), Item.getItemFromBlock(block2), Item.getItemFromBlock(block3), stack);
    }

Chaque fonction est très simple à comprendre, cela ne devrai pas vous poser de problèmes.

Maintenant une fonction qui permet d’avoir le résultat d’une recette :

    public ItemStack getSmeltingResult(ItemStack[] stack) // En argument : un tableau avec le contenu des trois slots d'input
    {
        Iterator iterator = this.smeltingList.entrySet().iterator();
        Entry entry;

        do
        {
            if (!iterator.hasNext()) // Si il n'y a plus de recettes dans la liste
            {
                return null; //Il n'y a pas de recette correspondante
            }
        entry = (Entry)iterator.next(); //prend la recette suivante
    }
    while (!this.isSameKey(stack, (ItemStack[])entry.getKey())); //Check si le tableau passé en argument correspond à celui de la recette, vous avez une erreur ici, on crée la fonction tout de suite.

    return (ItemStack)entry.getValue(); //retourne l'itemstack : resultat de la recette
    }

Cette fonction compare les items des slots avec ceux de la recette :

    private boolean isSameKey(ItemStack[] stackList, ItemStack[] stackList2)
    {
        boolean isSame = false; //Au début ce n'est pas la même
        for(int i=0; i<=2; i++) // Pour les 3 items
        {
            if(stackList[i].getItem() == stackList2[i].getItem()) //On vérifie si ce sont les même
            {
                isSame = true; // Si c'est le cas alors isSame vaut true
            }
            else
            {
                return false; //Si un seul n'est pas bon, on cherche pas, c'est pas la bonne recette
            }
        }
        return isSame;
    }

Deux fonctions qui permettent : d’avoir la liste des recettes et d’avoir l’instance de la classe MachineTutoRecipes

    public Map getSmeltingList()
    {
        return this.smeltingList;
    }

    public static MachineTutoRecipes smelting()
    {
        return smeltingBase;
    }

S’en est fini de la classe pour les recettes, il vous suffit maintenant de rajouter autant de recettes que vous le voulez dans le constructeur.

La classe du container

Créez un nouvelle classe ContainerMachineTuto extends Container

public class ContainerMachineTuto extends Container {

}

Déclarez un objet de type TileEntityMachineTuto mais ne l’instanciez pas :

    private TileEntityMachineTuto tileMachineTuto;

Et ajoutez les slots via le constructeur :

    public ContainerMachineTuto(TileEntityMachineTuto tile, InventoryPlayer inventory)
    {
        this.tileMachineTuto = tile;
        this.addSlotToContainer(new Slot(tile, 0, 49, 75)); //Lancez votre jeu en debug pour calibrer vos slots
        this.addSlotToContainer(new Slot(tile, 1, 89, 75));
        this.addSlotToContainer(new Slot(tile, 2, 129, 75));
        this.addSlotToContainer(new SlotResult(tile, 3, 89, 135)); //Ici c'est un slot que j'ai créer, on le fera après
        this.bindPlayerInventory(inventory); //Les containers ont été vus dans un tutoriel de robin, merci de d'y référer
    }

Les fonctions vues dans le tutoriel de robin (modifiées pour l’alignement) :

    @Override
    public boolean canInteractWith(EntityPlayer player) {
        return this.tileMachineTuto.isUseableByPlayer(player);
    }

    private void bindPlayerInventory(InventoryPlayer inventory)
    {
        int i;
        for (i = 0; i < 3; ++i)
        {
            for (int j = 0; j < 9; ++j)
            {
                this.addSlotToContainer(new Slot(inventory, j + i * 9 + 9, 17 + j * 18, 171 + i * 18));
            }
        }

        for (i = 0; i < 9; ++i)
        {
            this.addSlotToContainer(new Slot(inventory, i, 17 + i * 18, 229));
        }
    }

    public ItemStack transferStackInSlot(EntityPlayer player, int quantity)
    {
        ItemStack itemstack = null;
        Slot slot = (Slot)this.inventorySlots.get(quantity);

        if (slot != null && slot.getHasStack())
        {
            ItemStack itemstack1 = slot.getStack();
            itemstack = itemstack1.copy();

            if (quantity < this.tileMachineTuto.getSizeInventory())
            {
                if (!this.mergeItemStack(itemstack1, this.tileMachineTuto.getSizeInventory(), this.inventorySlots.size(), true))
                {
                    return null;
                }
            }
            else if (!this.mergeItemStack(itemstack1, 0, this.tileMachineTuto.getSizeInventory(), false))
            {
                return null;
            }

            if (itemstack1.stackSize == 0)
            {
                slot.putStack((ItemStack)null);
            }
            else
            {
                slot.onSlotChanged();
            }
        }

        return itemstack;
    }

    public void onContainerClosed(EntityPlayer player)
    {
        super.onContainerClosed(player);
        this.tileMachineTuto.closeInventory();
    }

La classe du SlotResult

Créez une classe SlotResult extends Slot.
Voici la classe du slot d’output, le but étant que on ne puisse pas y mettre d’items manuellement :

public class SlotResult extends Slot {

    public SlotResult(IInventory inventory, int id, int x, int y)
    {
        super(inventory, id, x, y);
    }

    @Override
    public boolean isItemValid(ItemStack stack) //Interdit la pose d'items dans le slot
    {
        return false;
    }

    public ItemStack decrStackSize(int amount)
    {
        return super.decrStackSize(amount);
    }

    public void onPickupFromSlot(EntityPlayer player, ItemStack stack)
    {
        super.onCrafting(stack);
        super.onPickupFromSlot(player, stack);
    }
}

Passons à la dernière classe.

La classe du GUI

Créez une classe GuiMachineTuto extends GuiContainer.
Voici la classe du GUI :

public class GuiMachineTuto extends GuiContainer {

    private static final ResourceLocation texture = new ResourceLocation(ModTutoriel.MODID,"textures/gui/container/guiMachineTuto.png");
    @SuppressWarnings("unused")
    private TileEntityMachineTuto tileMachineTuto;
    private IInventory playerInv;

    public GuiMachineTuto(TileEntityMachineTuto tile, InventoryPlayer inventory)
    {
        super(new ContainerMachineTuto(tile, inventory));
        this.tileMachineTuto = tile;
        this.playerInv = inventory;
        this.allowUserInput = false;
        this.ySize = 256;
        this.xSize = 256;
    }

    @Override
    protected void drawGuiContainerBackgroundLayer(float partialRenderTick, int x, int y)
    {

        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        this.mc.getTextureManager().bindTexture(texture);
        int k = (this.width - this.xSize) / 2;
        int l = (this.height - this.ySize) / 2;
        this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize);
        this.drawTexturedModalRect(0, 0, 176, 14, 100 + 1, 16);

    }

    protected void drawGuiContainerForegroundLayer(int x, int y)
    {
        this.fontRendererObj.drawString(this.playerInv.hasCustomInventoryName() ? this.playerInv.getInventoryName() : I18n.format(this.playerInv.getInventoryName()), 10, this.ySize - 98, 4210752);
    }

}

Voici la texture du GUI :

Ajoutez dans la classe du bloc :

    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitx, float hity, float hitz)
    {
        if (world.isRemote)
        {
            return true;
        }
        else
        {
            player.openGui(ModTutoriel.instance, 0, world, x, y, z);
            return true;
        }
    }

N’oubliez pas de gérer le guiHandler et d’enregistrer votre TileEntityMachineTuto dans la classe principale :

GameRegistry.registerTileEntity(TileEntityMachineTuto.class, "ModTutoriel:MachineTutoTileEntity");

Je suis passé vite sur le container et le gui car ce n’est pas tout à fait le sujet du tutoriel.

Bonus

Il y aura plusieurs choses dans ce bonus, je les posterais au fur et à mesure. Commençons tout de suite par la première :

1.Afficher une barre de progression de la recette (merci à Martin67370 pour sa participation)

Ceci est très simple, dans la texture de votre gui dessinez la barre de progression en entière mais de façon à ce qu’elle ne soit pas affiché lorsque l’on ouvre le GUI. Dans notre exemple cela pourrais donner ceci :

Ensuite retournez dans la classe GuiMachineTuto et dans la fonction drawGuiContainerBackgroundLayout(…) ajoutez :

if(this.tileMachineTuto.isBurning())
{
    int i = this.tileMachineTuto.getCookProgress(); //Nous créerons cette fonction après
    this.drawTexturedModalRect(x, y, u, v, width, height)
}

Elle devrait ressembler à ça :

@Override
protected void drawGuiContainerBackgroundLayer(float partialRenderTick, int x, int y)
{

    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    this.mc.getTextureManager().bindTexture(texture);
    int k = (this.width - this.xSize) / 2;
    int l = (this.height - this.ySize) / 2;
    this.drawTexturedModalRect(k, l, 0, 46, this.xSize, this.ySize); //Cette ligne a changé

    if(this.tileCompressor.isBurning())
    {
        int i = this.tileCompressor.getCookProgress();
        this.drawTexturedModalRect(k + 47, l + 46, 0, 2, 100, i);
    }
}

Examinons cette fonction :
x correspond à la coordonnée x du gui (in-game) où s’affichera la texture de la barre de progression.
y correspond à la coordonnée y du gui (in-game) où s’affichera la texture de la barre de progression.
u correspond à la position x de votre barre de progression sur votre texture (dans les ressources, l’image .png).
v correspond à la position y de votre barre de progression sur votre texture (dans les ressources, l’image .png).
width correspond à la largeur du morceau de texture que vous voulez afficher.
height correspond à la hauteur du morceau de texture que vous voulez afficher.

La fonction pour notre texture sera donc :

this.drawTexturedModalRect(k + 47, l + 46, 0, 2, 100, i)

Dans le constructeur changez les valeur ySize et xSize :

this.ySize = 207;
this.xSize = 195;

Donc votre classe TileEntityMachineTuto rajoutez la fonction :

@SideOnly(Side.CLIENT)
public int getCookProgress()
{
    return this.workingTime * 41 / this.workingTimeNeeded //41 correspond à la hauteur de la barre de progression car notre barre de progression se déroule de haut en bas
}

Expliquation de cette fonction, elle retourne un nombre entre 0 et 41 suivant le temps de cuisson actuel. Il faut le voir comme un tableau de proportionnalité :
Quantité de texture affichée : x | 41 (toute le texture)
Temps de cuisson : this.workingTime | this.workingTimeNeeded
Pour trouver x il faut faire l’opération suivante : 41 * this.workingTime / this.workingTimeNeeded

Ceci étant fait vous devriez obtenir cela après ré-ajustement de l’emplacement des slots de la classe du container :

Résultat

Voir le commit sur GitHub

[SCAREX]

Super tuto !

[BrokenSwing]

Merci SCAREX, je cherchais un tutoriel dans ce genre mais il n’y en a pas encore sur le forum il me semble (à moins d’avoir mal cherché).
N’hésitez pas à dire si il manque quelque chose ou si ce n’est pas assez clair. J’améliorerai volontier le tutoriel. Et pour la partie bonus je pensais à faire changer la texture au fur et à mesure de l’avancement de la recette car j’ai déjà le code mais vous pouvez toujours proposer autre chose, je ferai mon possible pour le faire.

[Superloup10]

Déjà, excellent tutoriel. Ensuite, il y a un tutoriel sur les fours (en 1.6.4 ou 1.7.2) dans le forum.
Pourquoi ne pas avoir extends MachineTuto de BlockContainer?
Il te reste quelques erreurs à corriger, par contre.

[BrokenSwing]

@‘Superloup10’:

Déjà, excellent tutoriel. Ensuite, il y a un tutoriel sur les fours (en 1.6.4 ou 1.7.2) dans le forum.
Pourquoi ne pas avoir extends MachineTuto de BlockContainer?
Il te reste quelques erreurs à corriger, par contre.

Je ne vois pas trop l’interêt de l’extends en BlockContainer, cela ne rajoute rien d’après ce que j’ai vu, a part peut-être la fonction onBlockEventReceived. Mais se serai plus propre effectivement. A propos des erreurs, pourrais-tu me les indiquer ? Je vais de toute façon tester le tutoriel tout de suite donc je vais sûrement les trouver. Je change donc en BlockContainer.

[Superloup10]

Des erreurs dans le tutoriel pas dans le code.

Envoyé de mon Nexus 4 en utilisant Tapatalk

[robin4002]

L’extends BlockContainer n’est pas utile comme Forge ajoute sa propre méthode pour les tileentity.

En tout cas merci pour ta contribution.
Il faudra juste aussi remettre en forme comme l’éditeur fait n’importe quoi après chaque édition.

[BrokenSwing]

@‘robin4002’:

L’extends BlockContainer n’est pas utile comme Forge ajoute sa propre méthode pour les tileentity.

En tout cas merci pour ta contribution.
Il faudra juste aussi remettre en forme comme l’éditeur fait n’importe quoi après chaque édition.

Pour la remise en forme, pas de problème, je vais le faire dès que possible et pour l’extends je l’ai déjà modifié, je le remet en extends Block ou je le laisse en extends BlockContainer ?

[robin4002]

Comme tu veux, de toute façon ça ne change rien en pratique.

[BrokenSwing]

J’ai revue tout le tutoriel, il y avait quelques erreurs dans le code, elles sont corrigées. J’ai aussi fait un GitHub et ai upload les sources.

[Norskel]

Super tuto grâce a ton tuto j’ai compris comment créé un gui, un container

Mais je voulait savoir comment faire pour faire une progress bar comme sur le four pour le temps de cuisson ?

EDIT : j’ai trouvé comment faire je vais faire des test

Martin

[Norskel]

Après une petite heure de boulot j’ai reussi a la faire (la progress bar)

si tu veux je t’envois les modif que j’ai fait pour le faire comme ca tu peux le rajouter en bonus dans ton tuto 

[BrokenSwing]

Merci à toi, je n’ai pas eu le temps de la faire malgré le fait que j’explique (de façon très rapide) dans la partie bonus comment la faire, tu peux en effet m’envoyer les modifications ainsi je compléterai ce passage, je me permet de reprendre ton image gif (si cela ne te dérange pas) et je te citerai bien sûr. Il me faudrait donc la texture du gui avec la barre de progression afin que je la mette à disposition dans le tutoriel pour une bonne compréhension du fonctionnement.

Merci d’avance

[Norskel]

Bon voila les modification que j’ai fait :

Dans GuiMachineTuto (attention moi ma classe s’appele GuiMachine )

package com.gmail.martin67370.MineAzurMod.common;

import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.resources.I18n;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.util.ResourceLocation;

import org.lwjgl.opengl.GL11;

public class GuiMachine extends GuiContainer {

private static final ResourceLocation texture = new ResourceLocation(MineAzurMod.MODID,"textures/gui/container/guiMachineTuto2.png");

private TileEntityMachine tileMachine;
   private IInventory playerInv;

public GuiMachine(TileEntityMachine tile, InventoryPlayer inventory)
{
super(new ContainerMachine(tile, inventory));
       this.tileMachine = tile;
       this.playerInv = inventory;
       this.allowUserInput = false;
       this.ySize = 256;
       this.xSize = 195;
}

@Override
protected void drawGuiContainerBackgroundLayer(float partialRenderTick, int x, int y)
{

GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
       this.mc.getTextureManager().bindTexture(texture);
       int k = (this.width - this.xSize) / 2;
       int l = (this.height - this.ySize) / 2;
       this.drawTexturedModalRect(k, l + 46 , 0, 46, this.xSize, this.ySize - 49); // position a modifier car toi tu aficher toute l'image alors que maintenant dans le même on a le truc pour la progress bar

       //Debut de modification

       if (this.tileMachine.isBurning())
       {

            int i1 = this.tileMachine.getCookProgressScaled(41);

           this.drawTexturedModalRect(k + 47, l + 91, 0, 1, 98, i1 + 1);
       }

       // Fun de modification

}

protected void drawGuiContainerForegroundLayer(int x, int y)
   {
this.fontRendererObj.drawString(this.playerInv.hasCustomInventoryName() ? this.playerInv.getInventoryName() : I18n.format(this.playerInv.getInventoryName()), 10, this.ySize - 98, 4210752);
      }

}

Et dans

TileEntityMachineTuto

a rajouter a la fin

public int getCookProgressScaled(int i) {
return this.workingTime * i / 200;

}

Et le gui

http://martin67370.besaba.com/Image/guiMachineTuto2.png

[sosoh]

Pourquoi le tutoriel n’a-t-il pas était validé ?

[robin4002]

Il est encore en attente car aucun n’admin n’a prit le temps de le vérifier puis de la valider.

[Flow]

Hello Je suis entrain de créer un block type four avec deux slot en input et un slot en output. J’ai également suivi le tutoriel de robin pour le GuiHandler etc mais il était en 1.6.x et je n’arrive pas a l’uptade pour la 1.7.10 voici mon code

package mod.common.block;

import mod.common.entity.TileEntityAnalyzer;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import cpw.mods.fml.common.network.IGuiHandler;

public class GuiHandler implements IGuiHandler
{
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity te = world.getTileEntity(x, y, z);
if(te instanceof TileEntityAnalyzer)
{
return new ContainerAnalyzer(player.inventory, (TileEntityAnalyzer)te);
}
return null;
}

@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity te = world.getTileEntity(x, y, z);
if(te instanceof TileEntityAnalyzer)
{
return new GuiAnalyzer(player.inventory, (TileEntityAnalyzer)te);
}
return null;
}
}

J’ai mis le code en rouge pour ce qui apparait en erreur et dans ma classe blockAnalyzer

[size=smallreturn new ContainerAnalyzer(player.inventory, (TileEntityAnalyzer)te);]
[font=Monaco, Consolas, Courier, monospacereturn new GuiAnalyzer(player.inventory, (TileEntityAnalyzer)te);]

package mod.common.block;

import mod.ModMinecraft;
import mod.common.entity.TileEntityAnalyzer;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;

public class BlockAnalyzer extends Block
{
public BlockAnalyzer()
{
  super(Material.rock); //Mettez le material qui convient
  this.setResistance(8.0F);
  this.setHarvestLevel("pickaxe", 2); //Outil pour casser le bloc, pour le chiffre : 0=bois, 1=pierre, 2=fer, 3=diamant
  this.setBlockTextureName(ModMinecraft.MODID + ":analyzer.png"); //N'oubliez pas de remplacer "ModTutoriel"
  // … Mettez les attributs complémentaires que vous voulez
}

@Override
   public TileEntity

//Instancie le TileEntity
   {
       return new TileEntityAnalyzer();
   }

   @Override
   public boolean hasTileEntity(int metadata) //Permet de savoir si le bloc a un TileEntity
   {
       return true;
   }

   public void breakBlock(World world, int x, int y, int z, Block block, int metadata)
   {
       TileEntity tileentity = world.getTileEntity(x, y, z);

       if (tileentity instanceof IInventory)
       {
        IInventory inv = (IInventory)tileentity;
           for (int i1 = 0; i1 < inv.getSizeInventory(); ++i1)
           {
               ItemStack itemstack = inv.getStackInSlot(i1);

               if (itemstack != null)
               {
                   float f = world.rand.nextFloat() * 0.8F + 0.1F;
                   float f1 = world.rand.nextFloat() * 0.8F + 0.1F;
                   EntityItem entityitem;

                   for (float f2 = world.rand.nextFloat() * 0.8F + 0.1F; itemstack.stackSize > 0; world.spawnEntityInWorld(entityitem))
                   {
                       int j1 = world.rand.nextInt(21) + 10;

                       if (j1 > itemstack.stackSize)
                       {
                           j1 = itemstack.stackSize;
                       }

                       itemstack.stackSize -= j1;
                       entityitem = new EntityItem(world, (double)((float)x + f), (double)((float)y + f1), (double)((float)z + f2), new ItemStack(itemstack.getItem(), j1, itemstack.getItemDamage()));
                       float f3 = 0.05F;
                       entityitem.motionX = (double)((float)world.rand.nextGaussian() * f3);
                       entityitem.motionY = (double)((float)world.rand.nextGaussian() * f3 + 0.2F);
                       entityitem.motionZ = (double)((float)world.rand.nextGaussian() * f3);

                       if (itemstack.hasTagCompound())
                       {
                           entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());
                       }
                   }
               }
           }

           world.func_147453_f(x, y, z, block);
       }

       super.breakBlock(world, x, y, z, block, metadata);
   }

   public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitx, float hity, float hitz)
   {
       if (world.isRemote)
       {
           return true;
       }
       else
       {
        player.openGui(ModMinecraft.instance, 0, world, x, y, z);
           return true;
       }
   }
}

[font=Monaco, Consolas, Courier, monospacecreateNewTileEntity(World world, int metadata)]
Je crois que j’ai du oublier quelque chose j’ai re vérifier une fois tout mais je n’ai pas trouver

Merci pour votre aider

[Laserflip33]

Essaye quelque chose comme cela dans ton GuiHandler :

public class GuiHandler implements IGuiHandler
{
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
switch (ID) {

case 0:
TileEntity tile = world.getTileEntity(x, y, z);
if(tile instanceof TileEntityAnalyzer)
{
return new ContainerAnalyzer((TileEntityAnalyzer)tile, player.inventory);
}
}

return null;
}

@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
switch (ID) {

case 0:
TileEntity tile = world.getTileEntity(x, y, z);
if(tile instanceof TileEntityAnalyzer)
{
return new GuiAnalyzer((TileEntityAnalyzer)tile, player.inventory);
}
}

return null;
}

}

Sinon, tu dis qu’il y a une erreur sur la méthode createNewTileEntity(), mais elle n’est pas trouvable dans ton code?

[robin4002]

Sur la chaîne Youtube il y a un tutoriel sur les gui pour la 1.7.x

[Flow]

Merci de ta réponse LaserFlip , merci robin je vais aller voir alors

Bah l’erreur j’ai l’impression d’avoir oublié quelque chose qui créer l’erreur , si je passe sur l’erreur il me propose de supprimer le @Override :s