Craft de machine type four.



  • Bonjour j'ai créé grâce au tutoriel de votre site une machine type four le problème que je rencontre et dont je n'arrive pas à trouver la solutiion est que je veux par exemple pour craft une épée le joueur à besoin de 1 stack , 2 minerai et un patern de l'épée sauf qu'avec le système actuel il ne peux met que un minerai et cela fonctionne.En résumé ma question est comment avec l code si dessous je peux modifier le nmbre d'item nécessaire au craft dans chaque slot ?
    Merci d'avence pour votre réponse.

    private static final MachineEwiliteRecipe smeltingBase = new MachineEwiliteRecipe();
    private Map smeltingList = new HashMap();
    public MachineEwiliteRecipe ()
    {
    this.addRecipe(Items.apple, Items.apple, Items.arrow, new ItemStack(Blocks.diamond_block));
    }
    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 MachineTutoRecipes smelting()
    {
    return smeltingBase;
    }
    


  • En gros tu veut plusieurs item dans le meme slot ?



  • Oui c'est exactement sa



  • Salut, il faut que tu regardes du coté de ta fonction canSmelt() (ou nom semblable) de ton four, tu dois regarder si la stackSize de l'ingrédient est supérieure à 2



  • Le problème est que je n'ai pas de fonction cansmelt



  • Elle doit avoir un autre nom je pense, montre les fonctions qui gèrent la cuisson de ton four.



  • Tous le code qui gère la cuisson est sur le premier message le reste sert a la gui etc



  • envoi le tile entity de ton block stp



  • Voila le title entity :

    package thecraft.mod.common;
    
    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.tileentity.TileEntity;
    
    public class TileEntityEwiliteMachine extends TileEntity implements IInventory
    {
    private ItemStack[] contents = new ItemStack[4];
    private int workingTime = 0;
    private int workingTimeNeeded = 200;
    
    @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* != 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);
       }
    
    @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)
           {
               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 int getSizeInventory()
    {
    return this.contents.length;
    }
    
    @Override
    public ItemStack getStackInSlot(int slotIndex)
    {t
    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 "tile.ewilitemachine";
    }
    
    @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;
    }
    
    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 = MachineTutoRecipes.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;
           }
       }
    
    public void smeltItem()
       {
           if (this.canSmelt())
           {
               ItemStack itemstack = EwiliteMachinerecipe.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;
                }
           }
       }
    }
    


  • Dans ta fonction canSmelt() ligne 174 tu verifi juste si dans les slots en question le stacksize de l'itemstack est SUPERIEURE ou EGALE au nombre d'items requis et tu demarre le craft
    (et puis si tu y arrive pas envoi le dossier "src" et je te le ferais)



  • Je n'y arrive pas donc je te donne le src et j'ai une question au passage si tu veux par exemple plusieurs craft je vais devoir passer par un système d'éxeption comme le gui handler dans la class de recipes ?
    http://www.mediafire.com/file/55shea1d1daoan4/src.zip



  • Je vais voir cela plus en détail quand j'aurais un peu plus de temps
    tout ce que je sais c'est qu'il faut récupérer les itemstacks du craft et verif si en fonction du craft le stacksize de l'itemstack est supérieure ou égale a la quantité désiré, le check de la quantié doit se derouler dans dans la class du craft de la machine en question dans la fonction isSameKey si je me souviens bien et il faut par conséquent modifier aussi la fonction getSmeltingResult pour pouvoir recuperer de stacksize de chaque itemstack dans chaque slot de la mahine