Machine avec plusieurs input



  • Bonjour ! ou reBonjour !
    J'ai créé une machine il y a très peu de temps grace au tuto de BrokenSwing mais j'aimerai avoir un craft avec plusieurs item en input dans chaque slot
    Exemple: "3 sticks dans le premier slot , 2 sticks dans le 2ème slot et enfin 1 charbon dans le 3ème slot donne 4 buches"
    La question a déja été posée dans le tuto en question mais aucune réponse n'a vraiment été donnée.

    Voici quelques classes potentiellement utile pour qu'on me fournisse de l'aide:

    La tile entity de ma machine :

    
    package com.iutils.infinite.tileentities;
    
    import com.iutils.infinite.recipes.CompressorRecipes;
    
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.inventory.IInventory;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.nbt.NBTTagList;
    import net.minecraft.network.NetworkManager;
    import net.minecraft.network.Packet;
    import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
    import net.minecraft.tileentity.TileEntity;
    import net.minecraftforge.common.util.Constants;
    
    public class CompressorTE extends TileEntity implements IInventory
    {
        private ItemStack[] contents = new ItemStack[4];
        private String customName;
        private int workingTime = 0;
        private int workingTimeNeeded = 200;
    
        @Override
        public void readFromNBT(NBTTagCompound compound)
        {
            super.readFromNBT(compound);
    
            if (compound.hasKey("CustomName", Constants.NBT.TAG_STRING))
            {
                this.customName = compound.getString("CustomName");
            }
    
            NBTTagList nbttaglist = compound.getTagList("Items", Constants.NBT.TAG_COMPOUND);
            this.contents = new ItemStack[this.getSizeInventory()];
    
            for (int i = 0; i < nbttaglist.tagCount(); ++i)
            {
                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");
            this.workingTimeNeeded = compound.getShort("workingTimeNeeded");
        }
    
        @Override
        public void writeToNBT(NBTTagCompound compound)
        {
            super.writeToNBT(compound);
            NBTTagList nbttaglist = new NBTTagList();
    
            if (this.hasCustomInventoryName())
            {
                compound.setString("CustomName", this.customName);
            }
    
            for (int i = 0; i < this.contents.length; ++i)
            {
                if (this.contents* != null)
                {
                    NBTTagCompound nbttagcompound1 = new NBTTagCompound();
                    nbttagcompound1.setByte("Slot", (byte)i);
                    this.contents*.writeToNBT(nbttagcompound1);
                    nbttaglist.appendTag(nbttagcompound1);
                }
            }
            compound.setTag("Items", nbttaglist);
            compound.setShort("workingTime",(short)this.workingTime);
            compound.setShort("workingTimeNeeded", (short)this.workingTimeNeeded);
        }
    
        public Packet getDescriptionPacket()
        {
            NBTTagCompound nbttagcompound = new NBTTagCompound();
            this.writeToNBT(nbttagcompound);
            return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, nbttagcompound);
        }
    
        public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt)
        {
            this.readFromNBT(pkt.func_148857_g());
        }
    
        @Override
        public int getSizeInventory()
        {
            return this.contents.length;
        }
    
        @Override
        public ItemStack getStackInSlot(int slotIndex)
        {
            return this.contents[slotIndex];
        }
    
        @Override
        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()
        {
            return this.hasCustomInventoryName() ? this.customName : "tile.compressor.name";
        }
    
        @Override
        public boolean hasCustomInventoryName()
        {
            return this.customName != null && !this.customName.isEmpty();
        }
    
        public void setCustomName(String customName)
        {
            this.customName = customName;
        }
    
        @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 slotIndex, ItemStack stack)
        {
            return true;
        }
    
        public boolean isBurning()
        {
            return this.workingTime > 0;
        }
        private boolean canSmelt()
        {
            if (this.contents[0] == null || this.contents[1] == null || this.contents[2] == null)
            {
                return false;
            }
            else
            {
                ItemStack itemstack = CompressorRecipes.smelting().getSmeltingResult(new ItemStack[]{this.contents[0], this.contents[1], this.contents[2]});
                if (itemstack == null) 
                    return false;
                if (this.contents[3] == null) 
                    return true;
                if (!this.contents[3].isItemEqual(itemstack)) 
                    return false;
                int result = contents[3].stackSize + itemstack.stackSize;
                    return result <= getInventoryStackLimit() && result <= this.contents[3].getMaxStackSize();
            }
        }
    
        public void updateEntity()
        {
            if(this.isBurning() && this.canSmelt())
            {
                ++this.workingTime;
            }
            if(this.canSmelt() && !this.isBurning())
            {
                this.workingTime = 1;
            }
            if(this.canSmelt() && this.workingTime == this.workingTimeNeeded)
            {
                this.smeltItem();
                this.workingTime = 0;
            }
            if(!this.canSmelt())
            {
                   this.workingTime= 0;
            }
            System.out.println("wT = " + workingTime);
            System.out.println("wTN = " + workingTimeNeeded);
        }
    
        public void smeltItem()
        {
            if (this.canSmelt())
            {
                ItemStack itemstack = CompressorRecipes.smelting().getSmeltingResult(new ItemStack[]{this.contents[0], this.contents[1], this.contents[2]});
                 if (this.contents[3] == null)
                 {
                      this.contents[3] = itemstack.copy();
                 }
                 else if (this.contents[3].getItem() == itemstack.getItem())
                 {
                      this.contents[3].stackSize += itemstack.stackSize;
                 }
    
                 –this.contents[0].stackSize;
                 –this.contents[1].stackSize;
                 –this.contents[2].stackSize;
    
                 if (this.contents[0].stackSize <= 0)
                 {
                     this.contents[0] = null;
                 }
                 if (this.contents[1].stackSize <= 0)
                 {
                     this.contents[1] = null;
                 }
                 if (this.contents[2].stackSize <= 0)
                 {
                     this.contents[2] = null;
                 }
            }
        }
    }
    
    

    La classe des recipes :

    
    package com.iutils.infinite.recipes;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Map.Entry;
    
    import net.minecraft.block.Block;
    import net.minecraft.init.Blocks;
    import net.minecraft.init.Items;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    
    public class CompressorRecipes
    {
        private static final CompressorRecipes smeltingBase = new CompressorRecipes();
        private Map smeltingList = new HashMap();
    
        public CompressorRecipes()
        {
            this.addRecipe(Items.apple, Items.apple, Items.arrow, new ItemStack(Items.iron_helmet));
            this.addRecipe(Items.apple, Items.apple, Items.apple, new ItemStack(Items.golden_apple));
        }
    
        public void addRecipe(ItemStack stack1, ItemStack stack2, ItemStack stack3, ItemStack stack4)
        {
            ItemStack[] stackList = new ItemStack[]{stack1, stack2, stack3};
            this.smeltingList.put(stackList, stack4);
        }
    
            public void addRecipe(Item item1, Item item2, Item item3, ItemStack stack)
        {
            this.addRecipe(new ItemStack(item1), new ItemStack(item2), new ItemStack(item3), stack);
        }
    
        public void addRecipe(Block block1, Item item2, Item item3, ItemStack stack)
        {
            this.addRecipe(Item.getItemFromBlock(block1), item2, item3, stack);
        }
    
        public void addRecipe(Block block1, Block block2, Item item3, ItemStack stack)
        {
            this.addRecipe(Item.getItemFromBlock(block1), Item.getItemFromBlock(block2), item3, stack);
        }
    
        public void addRecipe(Block block1, Block block2, Block block3, ItemStack stack)
        {
            this.addRecipe(Item.getItemFromBlock(block1), Item.getItemFromBlock(block2), Item.getItemFromBlock(block3), stack);
        }
    
        public ItemStack getSmeltingResult(ItemStack[] stack)
        {
            Iterator iterator = this.smeltingList.entrySet().iterator();
            Entry entry;
    
            do
            {
                if (!iterator.hasNext())
                {
                    return null;
                }
               entry = (Entry)iterator.next();
           }
           while (!this.isSameKey(stack, (ItemStack[])entry.getKey()));
    
           return (ItemStack)entry.getValue();
         }
    
        private boolean isSameKey(ItemStack[] stackList, ItemStack[] stackList2)
        {
            boolean isSame = false;
            for(int i=0; i<=2; i++)
            {
                if(stackList*.getItem() == stackList2*.getItem())
                {
                    isSame = true;
                }
                else
                {
                    return false;
                }
            }
            return isSame;
        }
    
        public Map getSmeltingList()
        {
           return this.smeltingList;
        }
    
    public static CompressorRecipes smelting()
       {
           return smeltingBase;
       }
    }
    
    

    En espérant que quelqu'un puisse m'aider !



  • Salut, alors je pense qu'il faudrait que tout simplement dans la fonction "isSameKey(ItemStack[] stackList, ItemStack[] stackList2)" de ta classe "CompressorRecipes" tu checkes si la taille du stack en input est plus grande ou égale à la taille spécifiée dans la recette (qu'il faudra changer). Il faudra aussi changer la fonction "smeltItem()" de ta machine pour que les items disparaissent correctement de leurs slots respectifs.



  • Je sais vraiment pas comment faire pour enlever le nombre d'items que j'ai mis dans la recette parce que je doit récupérer des données de la class CompressorRecipes


Log in to reply