Améliorer recette four double entrée

[HitArrowLegend]

Bonjour à tous

Donc après avoir réussi à créer un four double entrée qui fonctionne (maintenant il faut même deux charbon pour l’allumer ! Je sens le job à la Nasa qui arrive) J’en suis à un point ou je suis content d’avoir tout qui fonctionne mais ou je suis déçu de ne pas avoir d’XP et de ne pas pouvoir demander dans ma recette un nombre x d’item y. Pour le moment, mes recettes ne demandent que un seul item de chaque, sans pouvoir le modifier.

J’ai essayé plusieurs choses, remplacer Item par ItemStack etc… m’inspirer du code des recettes de base mais je n’arrive pas à trouver comment tout intégrer dans mon TileEntity sans que tout foire. J’ai aussi regardé quelques tutoriels par-ci par-la mais rien de concluant, à croire que personne n’a essayé d’en faire un. Au final, je reviens toujours au point de départ avec ma fonction toute bidon qui fonctionne à moitié (pas d’XP et un seul item par craft).

Je vous poste mon TileEntity ainsi que mon fichier Recipe. Si vous pouvez m’indiquez la voie, ça serait super

:::

package com.xtrem.outilleur.forge;

import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemHoe;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemSword;
import net.minecraft.item.ItemTool;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntityLockable;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.MathHelper;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class TileEntityFonderie extends TileEntityLockable implements ITickable, ISidedInventory
{
   private static final int[] slotsTop = new int[] {1};
   private static final int[] slotsBottom = new int[] {3};
   private static final int[] slotsSides = new int[] {2};
   /** 
    * The ItemStacks that hold the items currently being used in the fonderie 
    */
   private ItemStack[] fonderieItemStacks = new ItemStack[5];

   /** 
    * The number of ticks that the fonderie will keep burning 
    */
   private int fonderieBurnTime;

   /** 
    * The number of ticks that a fresh copy of the currently-burning item would keep the fonderie burning for
    */
   private int currentItemBurnTime;
   private int cookTime;
   private int totalCookTime;
   private String fonderieCustomName;

   /**
    * Returns the number of slots in the inventory.
    */
   public int getSizeInventory()
   {
       return this.fonderieItemStacks.length;
   }

   /**
    * Returns the stack in the given slot.
    */
   public ItemStack getStackInSlot(int index)
   {
       return this.fonderieItemStacks[index];
   }

   /**
    * Removes up to a specified number of items from an inventory slot and returns them in a new stack.
    */
   public ItemStack decrStackSize(int index, int count)
   {
       if (this.fonderieItemStacks[index] != null)
       {
           if (this.fonderieItemStacks[index].stackSize <= count)
           {
               ItemStack itemstack1 = this.fonderieItemStacks[index];
               this.fonderieItemStacks[index] = null;
               return itemstack1;
           }
           else
           {
               ItemStack itemstack = this.fonderieItemStacks[index].splitStack(count);

               if (this.fonderieItemStacks[index].stackSize == 0)
               {
                   this.fonderieItemStacks[index] = null;
               }

               return itemstack;
           }
       }
       else
       {
           return null;
       }
   }

   /**
    * Removes a stack from the given slot and returns it.
    */
   public ItemStack removeStackFromSlot(int index)
   {
       if (this.fonderieItemStacks[index] != null)
       {
           ItemStack itemstack = this.fonderieItemStacks[index];
           this.fonderieItemStacks[index] = null;
           return itemstack;
       }
       else
       {
           return null;
       }
   }

   /**
    * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).
    */
   public void setInventorySlotContents(int index, ItemStack stack)
   {
       boolean flag = stack != null && stack.isItemEqual(this.fonderieItemStacks[index]) && ItemStack.areItemStackTagsEqual(stack, this.fonderieItemStacks[index]);
       this.fonderieItemStacks[index] = stack;

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

       if (index == 0 && !flag)
       {
           this.totalCookTime = this.getCookTime(stack);
           this.cookTime = 0;
           this.markDirty();
       }
   }

   /**
    * Get the name of this object. For players this returns their username
    */
   public String getName()
   {
       return this.hasCustomName() ? this.fonderieCustomName : "container.fonderie";
   }

   /**
    * Returns true if this thing is named
    */
   public boolean hasCustomName()
   {
       return this.fonderieCustomName != null && this.fonderieCustomName.length() > 0;
   }

   public void setCustomInventoryName(String p_145951_1_)
   {
       this.fonderieCustomName = p_145951_1_;
   }

   public void readFromNBT(NBTTagCompound compound)
   {
       super.readFromNBT(compound);
       NBTTagList nbttaglist = compound.getTagList("Items", 10);
       this.fonderieItemStacks = new ItemStack[this.getSizeInventory()];

       for (int i = 0; i < nbttaglist.tagCount(); ++i)
       {
           NBTTagCompound nbttagcompound = nbttaglist.getCompoundTagAt(i);
           int j = nbttagcompound.getByte("Slot");

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

       this.fonderieBurnTime = compound.getShort("BurnTime");
       this.cookTime = compound.getShort("CookTime");
       this.totalCookTime = compound.getShort("CookTimeTotal");
       this.currentItemBurnTime = getItemBurnTime(this.fonderieItemStacks[2]) + getItemBurnTime(this.fonderieItemStacks[3]);

       if (compound.hasKey("CustomName", 8))
       {
           this.fonderieCustomName = compound.getString("CustomName");
       }
   }

   public void writeToNBT(NBTTagCompound compound)
   {
       super.writeToNBT(compound);
       compound.setShort("BurnTime", (short)this.fonderieBurnTime);
       compound.setShort("CookTime", (short)this.cookTime);
       compound.setShort("CookTimeTotal", (short)this.totalCookTime);
       NBTTagList nbttaglist = new NBTTagList();

       for (int i = 0; i < this.fonderieItemStacks.length; ++i)
       {
           if (this.fonderieItemStacks* != null)
           {
               NBTTagCompound nbttagcompound = new NBTTagCompound();
               nbttagcompound.setByte("Slot", (byte)i);
               this.fonderieItemStacks*.writeToNBT(nbttagcompound);
               nbttaglist.appendTag(nbttagcompound);
           }
       }

       compound.setTag("Items", nbttaglist);

       if (this.hasCustomName())
       {
           compound.setString("CustomName", this.fonderieCustomName);
       }
   }

   /**
    * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended.
    */
   public int getInventoryStackLimit()
   {
       return 64;
   }

   /**
    * fonderie isBurning
    */
   public boolean isBurning()
   {
       return this.fonderieBurnTime > 0;
   }

   @SideOnly(Side.CLIENT)
   public static boolean isBurning(IInventory p_174903_0_)
   {
       return p_174903_0_.getField(0) > 0;
   }

   /**
    * Like the old updateEntity(), except more generic.
    */
   public void update()
   {
       boolean flag = this.isBurning();
       boolean flag1 = false;

       if (this.isBurning())
       {
           –this.fonderieBurnTime;
       }

        if (!this.worldObj.isRemote)
               {
                   if (this.isBurning() || this.fonderieItemStacks[1] != null && this.fonderieItemStacks[0] != null &&
                    this.fonderieItemStacks[3] != null && this.fonderieItemStacks[2] != null)
                   {
                       if (!this.isBurning() && this.canSmelt())
                       {
                           this.currentItemBurnTime = this.fonderieBurnTime = getItemBurnTime(this.fonderieItemStacks[2]) + getItemBurnTime(this.fonderieItemStacks[3]);

                           if (this.isBurning())
                           {
                               flag1 = true;

                               if (this.fonderieItemStacks[2] != null && this.fonderieItemStacks[3] != null)
                               {
                                   –this.fonderieItemStacks[2].stackSize;
                                   –this.fonderieItemStacks[3].stackSize;

                                   if (this.fonderieItemStacks[2].stackSize == 0)
                                   {
                                       this.fonderieItemStacks[2] = fonderieItemStacks[2].getItem().getContainerItem(fonderieItemStacks[2]);
                                   }
                                   if (this.fonderieItemStacks[3].stackSize == 0)
                                   {
                                       this.fonderieItemStacks[3] = fonderieItemStacks[3].getItem().getContainerItem(fonderieItemStacks[3]);
                                   }
                               }
                           }
                       }
               if (this.isBurning() && this.canSmelt())
               {
                   ++this.cookTime;

                   if (this.cookTime == this.totalCookTime)
                   {
                       this.cookTime = 0;
                       this.totalCookTime = this.getCookTime(this.fonderieItemStacks[0]) + this.getCookTime(this.fonderieItemStacks[1]);
                       this.smeltItem();
                       flag1 = true;
                   }
               }
               else
               {
                   this.cookTime = 0;
               }
           }
           else if (!this.isBurning() && this.cookTime > 0)
           {
               this.cookTime = MathHelper.clamp_int(this.cookTime - 2, 0, this.totalCookTime);
           }

           if (flag != this.isBurning())
           {
               flag1 = true;
               BlockFonderie.setState(this.isBurning(), this.worldObj, this.pos);
           }

       if (flag1)
       {
           this.markDirty();
       }}}

   public int getCookTime(ItemStack stack)
   {
       return 200;
   }

   /**
    * Returns true if the fonderie can smelt an item, i.e. has a source item, destination stack isn't full, etc.
    */

   private boolean canSmelt()
   {
       if (fonderieItemStacks[0] == null || fonderieItemStacks[1] == null)
       {
           return false;
       }
       else
       {
    ItemStack itemstack = FonderieRecipes.getSmeltingResult(this.fonderieItemStacks[0].getItem(), this.fonderieItemStacks[1].getItem());

           if (itemstack == null) return false;
           if (this.fonderieItemStacks[4] == null) return true;
           if (!this.fonderieItemStacks[4].isItemEqual(itemstack)) return false;
           int result = fonderieItemStacks[4].stackSize + itemstack.stackSize;
           return result <= getInventoryStackLimit() && result <= this.fonderieItemStacks[4].getMaxStackSize(); //Forge BugFix: Make it respect stack sizes properly.
       }
   }

   /**
    * Turn one item from the fonderie source stack into the appropriate smelted item in the fonderie result stack
    */

   public void smeltItem()
   {
       if (this.canSmelt())
       {
    ItemStack itemstack = FonderieRecipes.getSmeltingResult(fonderieItemStacks[0].getItem(), fonderieItemStacks[1].getItem());

           if (this.fonderieItemStacks[4] == null)
           {
               this.fonderieItemStacks[4] = itemstack.copy();
           }
           else if (this.fonderieItemStacks[4].getItem() == itemstack.getItem())
           {
               this.fonderieItemStacks[4].stackSize += itemstack.stackSize; // Forge BugFix: Results may have multiple items ÷÷ Input 0 Fuel 1 Output 2
           }

           if (this.fonderieItemStacks[0].getItem() == Item.getItemFromBlock(Blocks.sponge) || this.fonderieItemStacks[1].getItem() == Item.getItemFromBlock(Blocks.sponge) && 
            this.fonderieItemStacks[0].getMetadata() == 1 || this.fonderieItemStacks[1].getMetadata() == 1 && 
            this.fonderieItemStacks[2] != null || this.fonderieItemStacks[3] != null && 
            this.fonderieItemStacks[2].getItem() == Items.bucket || this.fonderieItemStacks[3].getItem() == Items.bucket)

           {
               this.fonderieItemStacks[2] = new ItemStack(Items.water_bucket);
               this.fonderieItemStacks[3] = new ItemStack(Items.water_bucket);

           }

           –this.fonderieItemStacks[0].stackSize;
           –this.fonderieItemStacks[1].stackSize;

           if (this.fonderieItemStacks[0].stackSize <= 0)
           {
               this.fonderieItemStacks[0] = null;
           }
           if (this.fonderieItemStacks[1].stackSize <= 0)
           {
               this.fonderieItemStacks[1] = null;
           }
       }
   }

   /**
    * Returns the number of ticks that the supplied fuel item will keep the fonderie burning, or 0 if the item isn't
    * fuel
    */
   public static int getItemBurnTime(ItemStack p_145952_0_)
   {
       if (p_145952_0_ == null)
       {
           return 0;
       }
       else
       {
           Item item = p_145952_0_.getItem();

           if (item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.air)
           {
               Block block = Block.getBlockFromItem(item);

               if (block == Blocks.wooden_slab)
               {
                   return 150;
               }

               if (block.getMaterial() == Material.wood)
               {
                   return 300;
               }

               if (block == Blocks.coal_block)
               {
                   return 16000;
               }
           }

           if (item instanceof ItemTool && ((ItemTool)item).getToolMaterialName().equals("WOOD")) return 200;
           if (item instanceof ItemSword && ((ItemSword)item).getToolMaterialName().equals("WOOD")) return 200;
           if (item instanceof ItemHoe && ((ItemHoe)item).getMaterialName().equals("WOOD")) return 200;
           if (item == Items.stick) return 100;
           if (item == Items.coal) return 1600;
           if (item == Items.lava_bucket) return 20000;
           if (item == Item.getItemFromBlock(Blocks.sapling)) return 100;
           if (item == Items.blaze_rod) return 2400;
           return net.minecraftforge.fml.common.registry.GameRegistry.getFuelValue(p_145952_0_);
       }
   }

   public static boolean isItemFuel(ItemStack p_145954_0_)
   {
       /**
        * Returns the number of ticks that the supplied fuel item will keep the fonderie burning, or 0 if the item isn't
        * fuel
        */
       return getItemBurnTime(p_145954_0_) > 0;
   }

   /**
    * Do not make give this method the name canInteractWith because it clashes with Container
    */
   public boolean isUseableByPlayer(EntityPlayer player)
   {
       return this.worldObj.getTileEntity(this.pos) != this ? false : player.getDistanceSq((double)this.pos.getX() + 0.5D, (double)this.pos.getY() + 0.5D, (double)this.pos.getZ() + 0.5D) <= 64.0D;
   }

   public void openInventory(EntityPlayer player)
   {
   }

   public void closeInventory(EntityPlayer player)
   {
   }

   /**
    * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot.
    */
   public boolean isItemValidForSlot(int index, ItemStack stack)
   {
       return index == 2 ? false : (index != 1 ? true : isItemFuel(stack) || SlotFonderieFuel.isBucket(stack));
   }

   public int[] getSlotsForFace(EnumFacing side)
   {
       return side == EnumFacing.DOWN ? slotsBottom : (side == EnumFacing.UP ? slotsTop : slotsSides);
   }

   /**
    * Returns true if automation can insert the given item in the given slot from the given side. Args: slot, item,
    * side
    */
   public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction)
   {
       return this.isItemValidForSlot(index, itemStackIn);
   }

   /**
    * Returns true if automation can extract the given item in the given slot from the given side. Args: slot, item,
    * side
    */
   public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction)
   {
       if (direction == EnumFacing.DOWN && index == 1)
       {
           Item item = stack.getItem();

           if (item != Items.water_bucket && item != Items.bucket)
           {
               return false;
           }
       }

       return true;
   }

   public String getGuiID()
   {
       return "0";
   }

   public Container createContainer(InventoryPlayer playerInventory, EntityPlayer playerIn)
   {
       return new ContainerFonderie(playerInventory, this);
   }

   public int getField(int id)
   {
       switch (id)
       {
           case 0:
               return this.fonderieBurnTime;
           case 1:
               return this.currentItemBurnTime;
           case 2:
               return this.cookTime;
           case 3:
               return this.totalCookTime;
           default:
               return 0;
       }
   }

   public void setField(int id, int value)
   {
       switch (id)
       {
           case 0:
               this.fonderieBurnTime = value;
               break;
           case 1:
               this.currentItemBurnTime = value;
               break;
           case 2:
               this.cookTime = value;
               break;
           case 3:
               this.totalCookTime = value;
       }
   }

   public int getFieldCount()
   {
       return 4;
   }

   public void clear()
   {
       for (int i = 0; i < this.fonderieItemStacks.length; ++i)
       {
           this.fonderieItemStacks* = null;
       }
   }

   net.minecraftforge.items.IItemHandler handlerTop = new net.minecraftforge.items.wrapper.SidedInvWrapper(this, net.minecraft.util.EnumFacing.UP);
   net.minecraftforge.items.IItemHandler handlerBottom = new net.minecraftforge.items.wrapper.SidedInvWrapper(this, net.minecraft.util.EnumFacing.DOWN);
   net.minecraftforge.items.IItemHandler handlerSide = new net.minecraftforge.items.wrapper.SidedInvWrapper(this, net.minecraft.util.EnumFacing.WEST);

   @SuppressWarnings("unchecked")
@Override
   public <t>T getCapability(net.minecraftforge.common.capabilities.Capability <t>capability, net.minecraft.util.EnumFacing facing)
   {
       if (facing != null && capability == net.minecraftforge.items.CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
           if (facing == EnumFacing.DOWN)
               return (T) handlerBottom;
           else if (facing == EnumFacing.UP)
               return (T) handlerTop;
           else
               return (T) handlerSide;
       return super.getCapability(capability, facing);
   }
}

:::
:::

package com.xtrem.outilleur.forge;

import com.xtrem.init.XtremItemsRegistry;

import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

public class FonderieRecipes
{
public FonderieRecipes()
{
}
public static ItemStack getSmeltingResult(Item i, Item j)
{

return getOutput(i, j);
}
private static ItemStack getOutput(Item i, Item j)
{

if (i == XtremItemsRegistry.fraise && j == XtremItemsRegistry.framboise ||
 i == XtremItemsRegistry.framboise && j == XtremItemsRegistry.fraise)

 { return new ItemStack(Blocks.anvil, 2);
 }

return null;

}
}

:::</t></t>

[AymericRed]

Tu fais des items stack avec la fraise et la framboise, tu comparé les items des stacks et la stackSize.

[HitArrowLegend]

Bon bah aucune idée de comment faire ça. Je vais plutôt transformer le four 2 entrées en 4, ça au moins je sais faire :d
Y’aura pas d’xp mais bon, on peut pas tout avoir dans la vie xD

[AymericRed]

stack1.isItemStackEqual(stack2), ça vérifie l’item et la metadata, après tu compare les stack size de stack

Mais si tu sais faire avec autre chose c’est bon

[Deleted]

Pour la taille du stack à vérifier, AymericRed te disait de procéder ainsi je pense :
new ItemStack(tonItem).getItem().stackSize //à partir de cette valeur tu peux déjà faire des conditions dans ta classe Recipes

[HitArrowLegend]

@‘Plaigon’:

Pour la taille du stack à vérifier, AymericRed te disait de procéder ainsi je pense :
new ItemStack(tonItem).getItem().stackSize //à partir de cette valeur tu peux déjà faire des conditions dans ta classe Recipes

Et je devrais rajouter ça ou? Pour l’instant, la seule ligne qui me pose problème c’est celle la finalement :

ItemStack itemstack = FonderieRecipes.getSmeltingResult(fonderieItemStacks[0].getItem(), fonderieItemStacks[1].getItem());

En changeant tous les Item en ItemStack dans Recipe et en faisant ça ici :

ItemStack itemstack = FonderieRecipes.getSmeltingResult(new ItemStack(fonderieItemStacks[0].getItem()), new ItemStack(fonderieItemStacks[1].getItem()));

Ca met pas d’erreur mais ça marche pas. Je comprends de plus en plus ce code mais j’ai qu’une vague idée de ce que je dois faire ^^’ Dans ma tête ça marche mais en pratique non, et je sais pas pourquoi.

[XeNe]

Essaye plutot avec ça:

ItemStack itemstack = FonderieRecipes.getSmeltingResult(new ItemStack[]{fonderieItemStacks[0],fonderieItemStacks[1]});

[HitArrowLegend]

@‘XeNe’:

Essaye plutot avec ça:

ItemStack itemstack = FonderieRecipes.getSmeltingResult(new ItemStack[]{fonderieItemStacks[0],fonderieItemStacks[1]});

Je vais me renseigner sur les tableaux plus en détail, vu que j’y connais rien (encore) je peux pas tester ça ^^’ mais merci