[1.12.2] Refreshing an old code - Multi Output Furnace for a single input [Solved]

[sunsigne]

Hello

 

i'm working on a multi-output furnace and i finally found a topic that could help me, but it is very old and i'm refreshing the code. Can anyone help me on a little part please ?

 

here are the lines i adapted (from recipes)

Spoiler

    public void addCentrifugeRecipe(ItemStack input, ItemStack item1, ItemStack item2) 
    {
        this.smeltingList.put(input, twoItem(item1, item2));
    }
      
    
    public void addSolidifying2(ItemStack input, ItemStack item1, ItemStack item2)
    {
            solidifyingList2.put(input, twoItem(item1, item2)/*add the ItemStack array into the recipe list*/);
    }

        
    private ItemStack [] twoItem(ItemStack i1 , ItemStack i2)
    {
            return new ItemStack[] {i1, i2};
    }
        

 

//HERE IS THE IMPORTANT PART, my new line and the old one as "commentary"

 

    public ItemStack [] getSolidifyingResult2Out(ItemStack index)//returns an ItemStack array so it can hold 2 items
    {
            return (ItemStack [])solidifyingList2.get(index);
    }

//    public ItemStack [] getSolidifyingResult2Out(int i)//returns an ItemStack array so it can hold 2 items
//    {
//            return (ItemStack [])solidifyingList2.get(Integer.valueOf(i));
//    }
    

 

And here is the part i can't figure out how i am supposed to adapt (from the tileentity)

Spoiler

ItemStack [] itemstack = RFurnaceRecipes.smelting().getSolidifyingResult2Out(furnaceItemStacks[0].getItem().itemID);

The solution is probably simple, but it's been two hours i can't figure out how i am supposed to do ^^

I stast like "ItemStack [] itemstack = CentrifugeRecipes.getInstance().getSolidifyingResult2Out((ItemStack)this.inventory.get(0)......." but then i don't know what to do.

 

 

if it can help you thinking, here are some lines after that part where "itemstack []" is used :

Spoiler

 if(!furnaceItemStacks[2].isItemEqual(itemstack[0]) || !furnaceItemStacks[3].isItemEqual(itemstack[1]))  //checks if the items in the output slots are equal to the ones that will be added
            {
                    return false;

 

 

 

Any advice is welcome

Edited January 31, 2019 by sunsigne
title change

[Draco18s]

Not enough code here for us to solve your problem. Post the entire class at a minimum.

[sunsigne]

Ok, here is it :

 

reciepes code :

Spoiler

package sunsigne.MyMod.container;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Maps;
import com.google.common.collect.Table;

import net.minecraft.block.Block;
import net.minecraft.block.BlockStoneBrick;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.EnumDyeColor;
import net.minecraft.item.Item;
import net.minecraft.item.ItemFishFood;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.FurnaceRecipes;
import sunsigne.MyMod.init.ModBlocks;
import sunsigne.MyMod.init.ModItems;

public class CentrifugeRecipes {

    
    private static final CentrifugeRecipes INSTANCE = new CentrifugeRecipes();
    private Map smeltingList = new HashMap();
    private HashMap<List<Integer>, ItemStack> metaSmeltingList = new HashMap<List<Integer>, ItemStack>();
    private Map solidifyingList2 = new HashMap();

    
    public static CentrifugeRecipes getInstance()
    {
        return INSTANCE;
    }
    
    private boolean compareItemStacks(ItemStack stack1, ItemStack stack2)
    {
        return stack2.getItem() == stack1.getItem() && (stack2.getMetadata() == 32767 || stack2.getMetadata() == stack1.getMetadata());
    }
    
    public Map<List<Integer>, ItemStack> getMetaSmeltingList()
    {
        return metaSmeltingList;
    }
    
    
    public Map getSmeltingList()
    {
        return this.smeltingList;
    }
    
    
    
    public void addCentrifugeRecipe(ItemStack input, ItemStack item1, ItemStack item2) 
    {
        this.smeltingList.put(input, twoItem(item1, item2));
    }
    
       
    
    public void addSolidifying2(ItemStack input, ItemStack item1, ItemStack item2)
    {
            solidifyingList2.put(input, twoItem(item1, item2)/*add the ItemStack array into the recipe list*/);
    }

        
    private ItemStack [] twoItem(ItemStack i1 , ItemStack i2)
    {
            return new ItemStack[] {i1, i2};
    }
        

    public ItemStack [] getSolidifyingResult2Out(ItemStack index)//returns an ItemStack array so it can hold 2 items
    {
            return (ItemStack [])solidifyingList2.get(index);
    }

//    public ItemStack [] getSolidifyingResult2Out(int i)//returns an ItemStack array so it can hold 2 items
//    {
//            return (ItemStack [])solidifyingList2.get(Integer.valueOf(i));
//    }
    
    

    public void addSmelting(int item, int metadata, ItemStack itemstack, float experience)
    {
        metaSmeltingList.put(Arrays.asList(item, metadata), itemstack);

    }

    public ItemStack getCentrifugeResult(ItemStack item) 
    {
        if (item == null)
        {
            return null;
        }
        ItemStack ret = (ItemStack)metaSmeltingList.get(Arrays.asList(item, item.getItemDamage()));
        if (ret != null) 
        {
            return ret;
        }
        return (ItemStack)smeltingList.get(item);
    }

    
        
    
    
    private CentrifugeRecipes() 
    {
        

        
        
                
        
        addCentrifugeRecipe(new ItemStack(Blocks.OBSIDIAN), new ItemStack(Blocks.GOLD_BLOCK), new ItemStack(Blocks.DIAMOND_BLOCK));
//        addCentrifugeRecipe(new ItemStack(Blocks.DIAMOND_BLOCK), new ItemStack(Blocks.GOLD_BLOCK), new ItemStack(Blocks.IRON_BLOCK));
//        addCentrifugeRecipe(new ItemStack(Blocks.IRON_BLOCK), new ItemStack(Blocks.DIAMOND_BLOCK), new ItemStack(Blocks.GOLD_BLOCK));
        
    }

 

and tilte entitiy code :

Spoiler

package sunsigne.MyMod.tileentity;

import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ItemStackHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import sunsigne.MyMod.Reference;
import sunsigne.MyMod.blocks.CentrifugeBlock;
import sunsigne.MyMod.container.CentrifugeRecipes;

public class CentrifugeTileEntity extends TileEntity implements ITickable, IInventory {

    private NonNullList<ItemStack> inventory = NonNullList.<ItemStack>withSize(10, ItemStack.EMPTY);
    private String customName;

    private int cookTime;
    private int totalCookTime;
    
    @Override
    public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newSate)
    {
        return true;
    }
    
    public int getCookTime(ItemStack input) 
    {
        return 40;

    }
    
        
    @Override
    public String getName() 
    {
        return this.hasCustomName() ? this.customName : "container.centrifuge_block";
    }

    @Override
    public boolean hasCustomName() 
    {
        return this.customName != null && !this.customName.isEmpty();
    }
    
    public void setCustomName(String customName) 
    {
        this.customName = customName;
    }
    
    @Override
    public ITextComponent getDisplayName() 
    {
        return this.hasCustomName() ? new TextComponentString(this.getName()) : new TextComponentTranslation(this.getName());
    }

    @Override
    public int getSizeInventory() 
    {
        return this.inventory.size();
    }

    @Override
    public boolean isEmpty() 
    {
        for(ItemStack stack : this.inventory)
        {
            if(!stack.isEmpty()) return false;
        }
        return true;
    }

    @Override
    public ItemStack getStackInSlot(int index)
    {
        return (ItemStack)this.inventory.get(index);
    }

    @Override
    public ItemStack decrStackSize(int index, int count) 
    {
        return ItemStackHelper.getAndSplit(this.inventory, index, count);
    }

    @Override
    public ItemStack removeStackFromSlot(int index) 
    {
        return ItemStackHelper.getAndRemove(this.inventory, index);
    }

    @Override
    public void setInventorySlotContents(int index, ItemStack stack) 
    {
        ItemStack itemstack = (ItemStack)this.inventory.get(index);
        boolean flag = !stack.isEmpty() && stack.isItemEqual(itemstack) && ItemStack.areItemStackTagsEqual(stack, itemstack);
        this.inventory.set(index, stack);
        
        if(stack.getCount() > this.getInventoryStackLimit()) stack.setCount(this.getInventoryStackLimit());
        if(index == 0 && !flag)
        {
            this.totalCookTime = this.getCookTime(stack);
            this.cookTime = 0;
            this.markDirty();
        }
    }
    
    @Override
    public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        this.inventory = NonNullList.<ItemStack>withSize(this.getSizeInventory(), ItemStack.EMPTY);
        ItemStackHelper.loadAllItems(compound, this.inventory);
        this.cookTime = compound.getInteger("CookTime");
        this.totalCookTime = compound.getInteger("CookTimeTotal");
        
        if(compound.hasKey("CustomName", 8)) this.setCustomName(compound.getString("CustomName"));
    }
    
    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) 
    {
        compound.setInteger("CookTime", (short)this.cookTime);
        compound.setInteger("CookTimeTotal", (short)this.totalCookTime);
        ItemStackHelper.saveAllItems(compound, this.inventory);
        
        if(this.hasCustomName()) compound.setString("CustomName", this.customName);
        return super.writeToNBT(compound);
    }

    @Override
    public int getInventoryStackLimit() 
    {
        return 64;
    }
    
    public boolean isCooking() 
    {
        return this.cookTime > 0;
    }
    
    @SideOnly(Side.CLIENT)
    public static boolean isCooking(IInventory inventory) 
    {
        return inventory.getField(0) > 0;
    }
    
    public void update() 
    {
        
        boolean flag1 = false;
                
        if(!this.world.isRemote) 
        {
                        
            if(!((ItemStack)this.inventory.get(0)).isEmpty()) 
            {
                if(this.canSmelt()) 
                
                {
                    ++this.cookTime;
                    
                    if(this.cookTime == this.totalCookTime) 
                    {
                        this.cookTime = 0;
                        this.totalCookTime = this.getCookTime((ItemStack)this.inventory.get(0));
                        this.smeltItem();
                        flag1 = true;
                    }
                } 
                else this.cookTime = 0;
            } 
            else if(this.cookTime > 0) 
            {
                this.cookTime = MathHelper.clamp(this.cookTime - 2, 0, this.totalCookTime);
            }
            
        } 
        this.markDirty();
    }
    
    
    
    @Override
    public boolean isUsableByPlayer(EntityPlayer player) 
    {
        return this.world.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;
    }

    @Override
    public void openInventory(EntityPlayer player) {}

    @Override
    public void closeInventory(EntityPlayer player) {}

    
    @Override
    public boolean isItemValidForSlot(int index, ItemStack stack) 
    {
        if(index != 0) return false;
        else return true;
            
    }
    
    public String getGuiID() 
    {
        return Reference.MODID + ":centrifuge_block";
    }

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

    @Override
    public void setField(int id, int value) 
    {
        switch(id) 
        {
        case 1:
            this.cookTime = value;
            break;
        case 2:
            this.totalCookTime = value;
        }
    }

    @Override
    public int getFieldCount() 
    {
        return 2;
    }

    @Override
    public void clear() 
    {
        this.inventory.clear();
    }

    
    
    
    
    // note sure about that
    
    private boolean canSmelt() 
    {
        if(((ItemStack)this.inventory.get(0)).isEmpty()) return false;
        else 
        {
            ItemStack result = CentrifugeRecipes.getInstance().getCentrifugeResult((ItemStack)this.inventory.get(0));    
            if(result.isEmpty()) return false;
            else
            

            {
                
                ItemStack output1 = (ItemStack)this.inventory.get(1);
                ItemStack output2 = (ItemStack)this.inventory.get(2);
                
                            
                
                if(output1.isEmpty() && output2.isEmpty()) return true;
                if(!output1.isItemEqual(result)) return false;
                int res = output1.getCount() + result.getCount();
                return res <= getInventoryStackLimit() && res <= output1.getMaxStackSize();
            }
        }
    }
    
    // note sure about that
    
    public void smeltItem() 
    {
        if(this.canSmelt()) 
        {
            ItemStack input = (ItemStack)this.inventory.get(0);
            ItemStack result = CentrifugeRecipes.getInstance().getCentrifugeResult(input);
            ItemStack output1 = (ItemStack)this.inventory.get(1);
            
            
            if(output1.isEmpty()) this.inventory.set(1, result.copy());
            else if(output1.getItem() == result.getItem()) output1.grow(result.getCount());
            
            
            
            input.shrink(1);
        }
    }
        
    
    
    //to adapt !!
    
    
    private boolean canSolidify2()
    {
        
            if(this.furnaceItemStacks[0] == null)
    //correct translation of this line is : 
            if(((ItemStack)this.inventory.get(0)).isEmpty())
            {
                    return false;
            }    
            
            ItemStack [] itemstack = RFurnaceRecipes.smelting().getSolidifyingResult2Out(furnaceItemStacks[0].getItem().itemID);
     //start of a correct translation       
            ItemStack [] itemstack = CentrifugeRecipes.getInstance().getSolidifyingResult2Out(???);
            if(itemstack == null)
           {
                    return false;
            }
           if(furnaceItemStacks[2] == null && furnaceItemStacks[3] == null)
            {
                    return true;
            }
            if(!furnaceItemStacks[2].isItemEqual(itemstack[0]) || !furnaceItemStacks[3].isItemEqual(itemstack[1]))//checks if the items in the output slots are equal to the ones that will be added
            {
                    return false;
            }
            if(furnaceItemStacks[2].stackSize < getInventoryStackLimit() && furnaceItemStacks[2].stackSize < furnaceItemStacks[2].getMaxStackSize() && furnaceItemStacks[3].stackSize < getInventoryStackLimit() && furnaceItemStacks[3].stackSize < furnaceItemStacks[3].getMaxStackSize())//checks the stack limit of both output slots
            {
                  return true;
            }
            return furnaceItemStacks[2].stackSize < itemstack[0].getMaxStackSize() && furnaceItemStacks[3].stackSize < itemstack[1].getMaxStackSize();
    }

    public void solidifyItem2()
   {
            if(!canSolidify2())
            {
                    return;
            }
            ItemStack [] itemstack = RFurnaceRecipes.smelting().getSolidifyingResult5Out(furnaceItemStacks[0].getItem().itemID);
           if(furnaceItemStacks[2] == null)
            {
                    furnaceItemStacks[2] = itemstack[0].copy();
            } else
           if(furnaceItemStacks[2].itemID == itemstack[0].itemID)
            {
                    furnaceItemStacks[2].stackSize += itemstack[0].stackSize;
            }
            if(furnaceItemStacks[3] == null)//this is so that the game knows to add the solidified item in the second output slot
            {
                    furnaceItemStacks[3] = itemstack[1].copy();
            } else
            if(furnaceItemStacks[3].itemID == itemstack[1].itemID)//so is this
            {
                    furnaceItemStacks[3].stackSize += itemstack[1].stackSize;
            }
            if(furnaceItemStacks[0].getItem().hasContainerItem())
            {
                    furnaceItemStacks[0] = new ItemStack(furnaceItemStacks[0].getItem().getContainerItem());
            } else
            {
                    furnaceItemStacks[0].stackSize--;
            }
            if(furnaceItemStacks[0].stackSize <= 0)
            {
                    furnaceItemStacks[0] = null;
            }
    }
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
   }
 

 

Except all the part after "canSmelt()" where i'm not sure, the code is working. I tried on another block.

(I know i should used IItemHandler, but as this system work for my first furnace while my other "iitemhadler" furnace refuse to cook anything (and i don't know why), i continue this method a little bit before fully adatping my entire code once i solved this problem.).

 

 

 

Ho, and thank again for helping us each time I read a topic I saw your name with good advices  it's pleasant to see your passion 

 

[Cadiboo]

12 hours ago, sunsigne said:

sunsigne.MyMod.container;

Required Java conventions

What: Lowercase package naming

Why: Some file systems (windows) considering “iTeMs” and “items” to be the same, but every other one considering them to be different.

Consequences: Not doing this _may_ never cause any issues (and very likely won’t in your dev environment), but on other operating systems with different case-sensitivities from yours this can cause massive problems.

How: Name your packages all in lowercase

 

What: Packaging that reflects your web presence

Why: Avoid name collisions - your web presence is unique so it is commonly used.

Consequences: Errors loading classes with other mods installed, usually happens when 2 mods never changed their packaging from the default in the MDK.

How: If you have an illegal character in your web presence, the convention is to replace it with “_”. If you don’t have a website, you can use your version-control repository as your web presence, e.g. “com.github.username”. If you don’t use version control, start using it! In the meantime you can use the packaging “mod.username.modid”.

12 hours ago, sunsigne said:

implements IInventory

Do not use IInventory. Use the capability API with IItemHandler. Why? its legacy vanilla code, and bad at that. it also prevents you from having hoppers hopper-like machines, pipes etc. interface with your TileEntity, and breaks compatibility with other mods

Edited January 29, 2019 by Cadiboo

[Draco18s]

4 hours ago, Cadiboo said:

 

Do not use IInventory. Use the capability API with IItemHandler. Why? its legacy vanilla code, and bad at that. it also prevents you from having hoppers etc. interface with your TileEntity, and breaks compatibility with other mods

Hoppers work just fine. It's mod added machines that won't interface properly.

[sunsigne]

@Cadiboo

You got some really good advices overall ! I'll take note of all that. But actually i'm just creating a mod for me and my girlfriend so i don't really need the second one, but i'll use the lowercase one

 

And about IItemhandler, i'm okay with using it but i can't as long as this topic will remain unsolved. I'm working on the adaptation and post the answer when i'll find it out, but it's not my priority yet.

 

But still thank for your good advices

[sunsigne]

I'll simplify the question. What is the equivalent today for 

 

.getItem().itemID

 

.getItem() exist but not itemID anymore

[sunsigne]

1 hour ago, diesieben07 said:

None. Use the Item instance. To save to disk use getRegistryName.

Okay thank you  i'll follow that track and give the result

[sunsigne]

Here is it ! It's solved ! Now i have my multi-output furnace

 

for curious people, here is the codes (be carefull, it is fuel-free)

 

the container :

Spoiler

package sunsigne.MyMod.container;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IContainerListener;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;
import sunsigne.MyMod.container.recipes.CentrifugeRecipes;
import sunsigne.MyMod.container.slots.CentrifugeOutputSlot;
import sunsigne.MyMod.tileentity.CentrifugeTileEntity;
import sunsigne.MyMod.tileentity.EnchantedCraftingTableTileEntity;

public class CentrifugeContainer extends Container {

    private final CentrifugeTileEntity tileentity;
    private int cookTime, burnTime, currentBurnTime;
    
    public CentrifugeContainer(InventoryPlayer player, CentrifugeTileEntity tileentity) 
    {
        this.tileentity = tileentity;
        IItemHandler itemHandler = tileentity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
        
        this.addSlotToContainer(new SlotItemHandler(itemHandler, 0, 66, 36));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 1, 138, 18));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 2, 156, 18));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 3, 174, 18));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 4, 138, 36));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 5, 156, 36));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 6, 174, 36));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 7, 138, 54));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 8, 156, 54));
        this.addSlotToContainer(new CentrifugeOutputSlot(player.player, itemHandler, 9, 174, 54));
        
        
        for(int y = 0; y < 3; y++)
        {
            for(int x = 0; x < 9; x++)
            {
                this.addSlotToContainer(new Slot(player, x + y*9 + 9, 48 + x*18, 84 + y*18));
            }
        }
        
        for(int x = 0; x < 9; x++)
        {
            this.addSlotToContainer(new Slot(player, x, 48 + x * 18, 142));
        }
    }
    
    
    
    @Override
    public void detectAndSendChanges() 
    {
        super.detectAndSendChanges();
        
        for(int i = 0; i < this.listeners.size(); ++i) 
        {
            IContainerListener listener = (IContainerListener)this.listeners.get(i);
            
            if(this.cookTime != this.tileentity.getField(2)) listener.sendWindowProperty(this, 2, this.tileentity.getField(2));
            if(this.burnTime != this.tileentity.getField(0)) listener.sendWindowProperty(this, 0, this.tileentity.getField(0));
            if(this.currentBurnTime != this.tileentity.getField(1)) listener.sendWindowProperty(this, 1, this.tileentity.getField(1));
            
        }
        
        this.cookTime = this.tileentity.getField(2);
        this.burnTime = this.tileentity.getField(0);
        this.currentBurnTime = this.tileentity.getField(1);
        
    }
    
    @Override
    @SideOnly(Side.CLIENT)
    public void updateProgressBar(int id, int data) 
    {
        this.tileentity.setField(id, data);
    }
    
    @Override
    public boolean canInteractWith(EntityPlayer playerIn) 
    {
        return this.tileentity.isUsablebyplayer(playerIn);
    }
    
    @Override
    public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) 
    {
        ItemStack stack = ItemStack.EMPTY;
        Slot slot = (Slot)this.inventorySlots.get(index);
        
        if(slot != null && slot.getHasStack()) 
        {
            ItemStack stack1 = slot.getStack();
            stack = stack1.copy();
            
            if(index == 1 || index == 2 || index == 3 || index == 4 || index == 5 || index == 6 || index == 7 || index == 8 || index == 9) 
            {
                if(!this.mergeItemStack(stack1, 10, 40, true)) return ItemStack.EMPTY;
                slot.onSlotChange(stack1, stack);
            }
            else if(index != 0) 
            {        
                
                ItemStack [] result = CentrifugeRecipes.getInstance().getCentrifugeResult(stack1);    
                
                if(result[0].isEmpty() || result[1].isEmpty())
                {
                    if(!this.mergeItemStack(stack1, 1, 9, false)) 
                    {
                        return ItemStack.EMPTY;
                    }
                    else if(index >= 10 && index < 31)
                    {
                        if(!this.mergeItemStack(stack1, 31, 40, false)) return ItemStack.EMPTY;
                    }
                    else if(index >= 31 && index < 40 && !this.mergeItemStack(stack1, 7, 31, false))
                    {
                        return ItemStack.EMPTY;
                    }
                }
            } 
            else if(!this.mergeItemStack(stack1, 10, 40, false)) 
            {
                return ItemStack.EMPTY;
            }
            if(stack1.isEmpty())
            {
                slot.putStack(ItemStack.EMPTY);
            }
            else
            {
                slot.onSlotChanged();

            }
            if(stack1.getCount() == stack.getCount()) return ItemStack.EMPTY;
            slot.onTake(playerIn, stack1);
        }
        return stack;
    }
}

 

the tileentiity :

Spoiler

package sunsigne.MyMod.tileentity;

import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.ItemStackHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraft.world.World;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.ItemStackHandler;
import sunsigne.MyMod.Reference;
import sunsigne.MyMod.blocks.CentrifugeBlock;
import sunsigne.MyMod.container.recipes.CentrifugeRecipes;

public class CentrifugeTileEntity extends TileEntity implements ITickable {

    public static final int SIZE = 10;
    

    private int cookTime;
        
    
    private ItemStackHandler itemStackHandler = new ItemStackHandler(SIZE)
    {
        @Override
        protected void onContentsChanged(int slot) {
            
            CentrifugeTileEntity.this.markDirty();
        }
    };
    

    
    
    @Override
    public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newSate)
    {
        return true;
    }

    
    @SideOnly(Side.CLIENT)
      public static boolean isCooking(CentrifugeTileEntity te) {

        return te.getField(0) > 0;
    }

    public boolean isCooking() 
    {
        return this.cookTime > 0;
    }
    
    
    
    public void update() 
    {
        boolean flag = this.isCooking();
        boolean flag1 = false;

        if(!this.world.isRemote) 
        {
            if(!(this.itemStackHandler.getStackInSlot(0)).isEmpty())
            {
                if(this.canSmelt()) 
                {
                    ++this.cookTime;
                    
//the 20 here is the total cook time i want. The cook lasts 20 ticks then the item is cooked
                    
                    if(this.cookTime == 20) 
                    {
                        this.cookTime = 0;
                        this.smeltItem();
                        flag1 = true;
                    }
                } 
                else this.cookTime = 0;
            } 
            else if(this.cookTime > 0) 
                
//same here : 20 is for 20 ticks of cooking                
            {
                this.cookTime = MathHelper.clamp(this.cookTime - 2, 0, 20);
            }
            if(flag != this.isCooking()) 
            {
                flag1 = true;
                CentrifugeBlock.setState(this.isCooking(), this.world, this.pos);
            }
        } 
        if(flag1) this.markDirty();
    }
    
    
    
    
    
    public int getField(int id)
    {
        switch(id)
        {
       case 0:
            return this.cookTime;
        default:
            return 0;
        }
    }
        public void setField(int id, int value)
    {
        switch(id)
        {
        case 0:
            this.cookTime = value;
            break;
        }
    }

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

    this.cookTime = compound.getInteger("CookTime");
    
     if (compound.hasKey("items")) {itemStackHandler.deserializeNBT((NBTTagCompound) compound.getTag("items"));}
    
    }

@Override
public NBTTagCompound writeToNBT(NBTTagCompound compound) 
{
    super.writeToNBT(compound);
    
    compound.setInteger("CookTime", this.cookTime);

    
    compound.setTag("items", itemStackHandler.serializeNBT());
     return compound;
}

    
 @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing facing)
    {
        if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) return true;
        else return false;
    }
    
    @Override
    public <T> T getCapability(Capability<T> capability, EnumFacing facing)
    {
        if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
        return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(itemStackHandler);
        return super.getCapability(capability, facing);
    }

    private int getInventoryStackLimit() {
        return 64;
    
    }    
    
    public boolean isUsablebyplayer(EntityPlayer playerIn) {
        return !isInvalid() && playerIn.getDistanceSq(pos.add(0.5D, 0.5D, 0.5D)) <= 64D;
    }

    
    
    
    
        
    
 // note sure about that
    
         public void smeltItem() 
         {
             if(this.canSmelt()) 
             {
                 ItemStack input = this.itemStackHandler.getStackInSlot(0);
                 ItemStack [] result = CentrifugeRecipes.getInstance().getCentrifugeResult(input);
                 ItemStack output1 = this.itemStackHandler.getStackInSlot(1);
                 ItemStack output2 = this.itemStackHandler.getStackInSlot(2);
                 
                 {
                     if(output1.isEmpty()) this.itemStackHandler.setStackInSlot(1, result[0].copy());
                     if(output2.isEmpty()) this.itemStackHandler.setStackInSlot(2, result[1].copy());
                     
                     else {
                     
                         if(output1.getItem() == result[0].getItem()) output1.grow(result[0].getCount());
                         if(output2.getItem() == result[1].getItem()) output2.grow(result[1].getCount());
                     
                          }
                 }
                 
                                  
                 input.shrink(1);
             }
         }
    
    
    
      
    
    
    
    private boolean canSmelt() 
    {
            
            
        
        
        if((this.itemStackHandler.getStackInSlot(0)).isEmpty()) return false;
        else 
        {                
            ItemStack [] result = CentrifugeRecipes.getInstance().getCentrifugeResult(this.itemStackHandler.getStackInSlot(0));    
            
            if(result[0].isEmpty() || result[1].isEmpty()) return false;
            else
            {
                ItemStack output1 = this.itemStackHandler.getStackInSlot(1);
                ItemStack output2 = this.itemStackHandler.getStackInSlot(2);
                
                if(output1.isEmpty() && output2.isEmpty()) return true;
                if(!output1.isItemEqual(result[0]) || !output2.isItemEqual(result[1])) return false;
                int res = Math.max(output1.getCount() + result[0].getCount(), output2.getCount() + result[1].getCount());
                return res <= getInventoryStackLimit() && res <= output1.getMaxStackSize() && res <= output2.getMaxStackSize();
            }
        }
    }
    
    
    
    
}
    

 

and the recipes :

Spoiler

package sunsigne.MyMod.container.recipes;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Maps;
import com.google.common.collect.Table;

import net.minecraft.block.Block;
import net.minecraft.block.BlockStoneBrick;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.EnumDyeColor;
import net.minecraft.item.Item;
import net.minecraft.item.ItemFishFood;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.FurnaceRecipes;
import sunsigne.MyMod.init.ModBlocks;
import sunsigne.MyMod.init.ModItems;

public class CentrifugeRecipes {

    
    private static final CentrifugeRecipes INSTANCE = new CentrifugeRecipes();
    private final Map<ItemStack, ItemStack[]> smeltingList = Maps.<ItemStack, ItemStack[]>newHashMap();
    
    public static CentrifugeRecipes getInstance()
    { 
        return INSTANCE;
    }
    
    private boolean compareItemStacks(ItemStack stack1, ItemStack stack2)
    {
        return stack2.getItem() == stack1.getItem() && (stack2.getMetadata() == 32767 || stack2.getMetadata() == stack1.getMetadata());
    }
        
    
    public Map<ItemStack, ItemStack[]> getSmeltingList()
    {
        return this.smeltingList;
    }
    
    
    
    public void addCentrifugeRecipe(ItemStack input, ItemStack item1, ItemStack item2) 
    {
   
        this.smeltingList.put(input, twoItem(item1, item2));
    }
    
 
               
    private ItemStack [] twoItem(ItemStack i1 , ItemStack i2)
    {
            return new ItemStack[] {i1, i2};
    }
        
    
    

    public ItemStack [] getCentrifugeResult(ItemStack input) 
    {
        for (Entry<ItemStack, ItemStack[]> entry : this.smeltingList.entrySet())
        {
            if (this.compareItemStacks(input, entry.getKey()))
            {
                return entry.getValue();
            }
        }

        return null;
    }

    
        
    
    
    private CentrifugeRecipes() 
    {
        
        
        
        //test recipe
        
        addCentrifugeRecipe(new ItemStack(Blocks.OBSIDIAN), new ItemStack(Blocks.GOLD_BLOCK), new ItemStack(Blocks.IRON_BLOCK));
        addCentrifugeRecipe(new ItemStack(Blocks.COBBLESTONE), new ItemStack(Blocks.OBSIDIAN), new ItemStack(Blocks.IRON_BLOCK));
        
                             
        
        
    }

 

it just has a HUGE default, if you put something that can't be smelt, it crashed the game. I didn't find HOW to explain the game just doing nothing

(even if i know I just need to turn "public ItemStack [] getCentrifugeResult(ItemStack input) .........   return null;" into an equivalent to "return Itemstack.EMPTY" but for severeal output)

 

but as long as i trick it, just forbidding the player putting anything but true input in the input slot, it's no longer a problem

 

exemple : 

Spoiler

@Override
        public boolean isItemValid(ItemStack input) 
        {
        
            if(input.isItemEqual(new ItemStack(Blocks.OBSIDIAN))) return true;
            if(input.isItemEqual(new ItemStack(Blocks.COBBLESTONE))) return true;
            else return false;
            
            
        }    
            

 

[Draco18s]

3 hours ago, sunsigne said:

Input.isItemEqual(new ItemStack(Blocks.OBSIDIAN))

This is equivalent to input.getItem() == Item.getFromBlock(Blocks.OBSIDIAN) and uses less memory by not creating an item stack that has to be cleaned up.