Créer un bloc type four (machine)


  • Moddeurs confirmés Rédacteurs

    Sommaire

    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

    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



  • Super tuto !


  • Moddeurs confirmés Rédacteurs

    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.


  • Moddeurs confirmés Rédacteurs Modérateurs Administrateurs

    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.


  • Moddeurs confirmés Rédacteurs

    @'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.


  • Moddeurs confirmés Rédacteurs Modérateurs Administrateurs

    Des erreurs dans le tutoriel pas dans le code.

    Envoyé de mon Nexus 4 en utilisant Tapatalk


  • Moddeurs confirmés Rédacteurs Administrateurs

    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.


  • Moddeurs confirmés Rédacteurs

    @'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 ?


  • Moddeurs confirmés Rédacteurs Administrateurs

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


  • Moddeurs confirmés Rédacteurs

    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.



  • 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



  • 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  😛


  • Moddeurs confirmés Rédacteurs

    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 😉



  • 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



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


  • Moddeurs confirmés Rédacteurs Administrateurs

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



  • 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 😛



  • 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?


  • Moddeurs confirmés Rédacteurs Administrateurs

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



  • 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


Log in to reply