[1.10] Double Input Furnace not smelting.

[Lambda]

EDIT: Detailed

 

Hello,

 

So I have created a TE that uses 2 INPUTS for 1 OUTPUT, however, when I go to put the intended recipe in, the TE does not process it into the intended output, instead it sits and idles. What I want to have happen is for the TE to use BOTH inputs for 1 output.

 

Here is the TE:

 

 

package com.lambda.plentifulmisc.tile;

import com.lambda.plentifulmisc.recipe.AtomicDiffuserRecipes;
import com.lambda.plentifulmisc.util.StackUtil;
import com.lambda.plentifulmisc.util.misc.AtomicDiffuserRecipeRegistry;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

import java.util.Stack;

/**
* Created by Blake on 11/26/2016.
*/
public class TileEntityAtomicDiffuser extends TileEntityInventoryBase implements ICustomEnergyReceiver {

    public static final int SLOT_INPUT_1 = 0;
    public static final int SLOT_INPUT_2 = 1;
    public static final int SLOT_OUTPUT_1 = 2;


    public static final int ENERGY_USE = 25;
    private static final int SMELT_TIME = 80;
    public final CustomEnergyStorage storage = new CustomEnergyStorage(50000, 80);
    public int firstSmeltTime;
    private int lastEnergy;
    private int lastFirstSmelt;

    public TileEntityAtomicDiffuser() {
        super(3, "atmoicdiffuser");
    }

    @Override
    public void writeSyncableNBT(NBTTagCompound compound, TileEntityBase.NBTType type){
        super.writeSyncableNBT(compound, type);
        if(type != TileEntityBase.NBTType.SAVE_BLOCK){
            compound.setInteger("FirstSmeltTime", this.firstSmeltTime);
        }
        this.storage.writeToNBT(compound);
    }

    @Override
    public void readSyncableNBT(NBTTagCompound compound, TileEntityBase.NBTType type){
        super.readSyncableNBT(compound, type);
        if(type != TileEntityBase.NBTType.SAVE_BLOCK){
            this.firstSmeltTime = compound.getInteger("FirstSmeltTime");
        }
        this.storage.readFromNBT(compound);
    }

    @Override
    public void updateEntity(){
        super.updateEntity();
        if(!this.worldObj.isRemote){

            boolean flag = this.firstSmeltTime > 0;

            boolean canSmeltOnFirst = this.canSmeltOn(SLOT_INPUT_1, SLOT_INPUT_2, SLOT_OUTPUT_1);

            if(canSmeltOnFirst){
                if(this.storage.getEnergyStored() >= ENERGY_USE){
                    this.firstSmeltTime++;
                    if(this.firstSmeltTime >= SMELT_TIME){
                        this.finishBurning(SLOT_INPUT_1, SLOT_INPUT_2, SLOT_OUTPUT_1);
                        this.firstSmeltTime = 0;
                    }
                    this.storage.extractEnergyInternal(ENERGY_USE, false);
                }
            }
            else{
                this.firstSmeltTime = 0;
            }

            if((this.lastEnergy != this.storage.getEnergyStored() || this.lastFirstSmelt != this.firstSmeltTime) && this.sendUpdateWithInterval()){
                this.lastEnergy = this.storage.getEnergyStored();
                this.lastFirstSmelt = this.firstSmeltTime;
            }

        }
    }

    @Override
    public boolean isItemValidForSlot(int i, ItemStack stack){
        return (i == SLOT_INPUT_1 || i == SLOT_INPUT_2) && AtomicDiffuserRecipeRegistry.getRecipeFromInput(stack, stack) != null;
    }

    public boolean canSmeltOn(int theInput, int theInputSecond, int theOutput){
        if(StackUtil.isValid(this.slots.get(theInput)) && StackUtil.isValid(this.slots.get(theInputSecond))){
            ItemStack output = AtomicDiffuserRecipeRegistry.getOutput(this.slots.get(theInput), this.slots.get(theInputSecond));
            if(StackUtil.isValid(output)){
                if(!StackUtil.isValid(this.slots.get(theOutput)) || (this.slots.get(theOutput).isItemEqual(output) && StackUtil.getStackSize(this.slots.get(theOutput)) <= this.slots.get(theOutput).getMaxStackSize()-StackUtil.getStackSize(output))){
                    return true;
                }
            }

        }
        return false;
    }

    public void finishBurning(int theInput, int theInputSecond, int theOutput){
        ItemStack output = AtomicDiffuserRecipeRegistry.getOutput(this.slots.get(theInput), this.slots.get(theInputSecond));
        if(!StackUtil.isValid(this.slots.get(theOutput))){
            this.slots.set(theOutput, output.copy());
        }
        else if(this.slots.get(theOutput).getItem() == output.getItem()){
            this.slots.set(theOutput, StackUtil.addStackSize(this.slots.get(theOutput), StackUtil.getStackSize(output)));
        }

        this.slots.set(theInput, StackUtil.addStackSize(this.slots.get(theInput), -1));
        this.slots.set(theInputSecond, StackUtil.addStackSize(this.slots.get(theInputSecond), -1));
    }

    @SideOnly(Side.CLIENT)
    public int getFirstTimeToScale(int i){
        return this.firstSmeltTime*i/SMELT_TIME;
    }

    @Override
    public boolean canInsertItem(int slot, ItemStack stack, EnumFacing side){
        return this.isItemValidForSlot(slot, stack);
    }

    @Override
    public boolean canExtractItem(int slot, ItemStack stack, EnumFacing side){
        return slot == SLOT_OUTPUT_1;
    }

    @Override
    public int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate){
        return this.storage.receiveEnergy(maxReceive, simulate);
    }

    @Override
    public int getEnergyStored(EnumFacing from){
        return this.storage.getEnergyStored();
    }

    @Override
    public int getMaxEnergyStored(EnumFacing from){
        return this.storage.getMaxEnergyStored();
    }

    @Override
    public boolean canConnectEnergy(EnumFacing from){
        return true;
    }


}

 

 

Container:

 

 

package com.lambda.plentifulmisc.inventory;

/**
* Created by Blake on 11/26/2016.
*/
import com.lambda.plentifulmisc.inventory.slot.SlotOutput;
import com.lambda.plentifulmisc.tile.TileEntityAtomicDiffuser;
import com.lambda.plentifulmisc.tile.TileEntityBase;
import com.lambda.plentifulmisc.util.StackUtil;
import com.lambda.plentifulmisc.util.misc.AtomicDiffuserRecipeRegistry;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;


public class ContainerAtomicDiffuser extends Container{

    public final TileEntityAtomicDiffuser tileAtomic;


    public ContainerAtomicDiffuser(InventoryPlayer inventory, TileEntityBase tile){
        this.tileAtomic = (TileEntityAtomicDiffuser)tile;

        this.addSlotToContainer(new Slot(this.tileAtomic, TileEntityAtomicDiffuser.SLOT_INPUT_1, 80, 21));
        this.addSlotToContainer(new Slot(this.tileAtomic, TileEntityAtomicDiffuser.SLOT_INPUT_2, 66, 69));
        this.addSlotToContainer(new SlotOutput(this.tileAtomic, TileEntityAtomicDiffuser.SLOT_OUTPUT_1, 92, 69));


        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 9; j++){
                this.addSlotToContainer(new Slot(inventory, j+i*9+9, 8+j*18, 97+i*18));
            }
        }
        for(int i = 0; i < 9; i++){
            this.addSlotToContainer(new Slot(inventory, i, 8+i*18, 155));
        }
    }

    @Override
    public ItemStack transferStackInSlot(EntityPlayer player, int slot){
        int inventoryStart = 3;
        int inventoryEnd = inventoryStart+26;
        int hotbarStart = inventoryEnd+1;
        int hotbarEnd = hotbarStart+8;

        Slot theSlot = this.inventorySlots.get(slot);

        if(theSlot != null && theSlot.getHasStack()){
            ItemStack newStack = theSlot.getStack();
            ItemStack otherNewSlot = theSlot.getStack();
            ItemStack currentStack = newStack.copy();

            //Slots in Inventory to shift from
            if(slot == TileEntityAtomicDiffuser.SLOT_OUTPUT_1){
                if(!this.mergeItemStack(newStack, inventoryStart, hotbarEnd+1, true)){
                    return StackUtil.getNull();
                }
                theSlot.onSlotChange(newStack, currentStack);
            }
            //Other Slots in Inventory excluded
            else if(slot >= inventoryStart){
                //Shift from Inventory
                if(AtomicDiffuserRecipeRegistry.getRecipeFromInput(newStack, otherNewSlot) != null){
                    if(!this.mergeItemStack(newStack, TileEntityAtomicDiffuser.SLOT_INPUT_1, TileEntityAtomicDiffuser.SLOT_INPUT_1+1, false)){
                            return StackUtil.getNull();
                        }
                    }
                //

                else if(slot >= inventoryStart && slot <= inventoryEnd){
                    if(!this.mergeItemStack(newStack, hotbarStart, hotbarEnd+1, false)){
                        return StackUtil.getNull();
                    }
                }
                else if(slot >= inventoryEnd+1 && slot < hotbarEnd+1 && !this.mergeItemStack(newStack, inventoryStart, inventoryEnd+1, false)){
                    return StackUtil.getNull();
                }
            }
            else if(!this.mergeItemStack(newStack, inventoryStart, hotbarEnd+1, false)){
                return StackUtil.getNull();
            }

            if(!StackUtil.isValid(newStack)){
                theSlot.putStack(StackUtil.getNull());
            }
            else{
                theSlot.onSlotChanged();
            }

            if(StackUtil.getStackSize(newStack) == StackUtil.getStackSize(currentStack)){
                return StackUtil.getNull();
            }
            theSlot.func_190901_a(player, newStack);


            return currentStack;
        }
        return StackUtil.getNull();
    }

    @Override
    public boolean canInteractWith(EntityPlayer player){
        return this.tileAtomic.isUseableByPlayer(player);
    }
}

 

 

 

RecipeRegistry:

public class AtomicDiffuserRecipeRegistry {

        public static void registerFinally(){
            int recipeStartedAt = PlentifulMiscAPI.ATOMIC_RECIPES.size();

            ArrayList<String> addedRecipes = new ArrayList<String>();
            for(int i = recipeStartedAt; i < PlentifulMiscAPI.ATOMIC_RECIPES.size(); i++){
                AtomicDiffuserRecipe recipe = PlentifulMiscAPI.ATOMIC_RECIPES.get(i);
                addedRecipes.add(recipe.firstInput+"+"+recipe.secondInput+" -> "+recipe.output);
            }
            ModUtil.LOGGER.info("Added "+addedRecipes.size()+" Atomic Recipes automatically: "+addedRecipes);
        }
/*
        public static boolean hasBlacklistedOutput(ItemStack output, String[] config){
            if(StackUtil.isValid(output)){
                Item item = output.getItem();
                if(item != null){
                    String reg = item.getRegistryName().toString();

                    for(String conf : config){
                        String confReg = conf;
                        int meta = 0;

                        if(conf.contains("@")){
                            try{
                                String[] split = conf.split("@");
                                confReg = split[0];
                                meta = Integer.parseInt(split[1]);
                            }
                            catch(Exception e){
                                ModUtil.LOGGER.warn("A config option appears to be incorrect: The entry "+conf+" can't be parsed!");
                            }
                        }

                        if(reg.equals(confReg) && output.getItemDamage() == meta){
                            return true;
                        }
                    }

                    return false;
                }
            }
            return true;
        }
*/
        private static boolean hasException(String ore){
            for(String conf : ConfigStringListValues.ATOMIC_RECIPE_EXCEPTIONS.getValue()){
                if(conf.equals(ore)){
                    return true;
                }
            }
            return false;
        }

        public static ItemStack getOutput(ItemStack input, ItemStack inputSecond){
            AtomicDiffuserRecipe recipe = getRecipeFromInput(input, inputSecond);
            return recipe == null ? null : recipe.output;
        }

        public static AtomicDiffuserRecipe getRecipeFromInput(ItemStack input, ItemStack secondInput){
            for(AtomicDiffuserRecipe recipe : PlentifulMiscAPI.ATOMIC_RECIPES){
                if(ItemUtil.areItemsEqual(recipe.firstInput, input, true) && ItemUtil.areItemsEqual(recipe.secondInput, secondInput, true)){
                    return recipe;
                }
            }
            return null;
        }
}

 

Recipes:

public final class AtomicDiffuserRecipes {

    public static final ArrayList<AtomicDiffuserRecipe> MISC_RECIPES = new ArrayList<AtomicDiffuserRecipe>();
    public void init() {

        ModUtil.LOGGER.info("Initializing Atomic Diffuser Recipes...");

        PlentifulMiscAPI.addAtomicRecipe(new ItemStack(Items.BONE), new ItemStack(Items.STICK), new ItemStack(Items.APPLE));
        MISC_RECIPES.add(RecipeUtil.lastAtomicRecipe());

        AtomicDiffuserRecipeRegistry.registerFinally();
    }
}

 

Main API:

public final class PlentifulMiscAPI{

    public static final String MOD_ID = "plentifulmisc";
    public static final String API_ID = MOD_ID+"api";
    public static final String API_VERSION = "1";

    public static IMethodHandler methodHandler;

    public static IRelayConnectionHandler connectionHandler;

    public static final List<AtomicDiffuserRecipe> ATOMIC_RECIPES = new ArrayList<AtomicDiffuserRecipe>();

    public static void addAtomicRecipe(ItemStack firstInput, ItemStack secondInput, ItemStack output){
        ATOMIC_RECIPES.add(new AtomicDiffuserRecipe(firstInput, secondInput, output));
    }

    public static boolean addAtomicRecipes(List<ItemStack> firstInput, List<ItemStack> secondInput, List<ItemStack> output)
    {
        return methodHandler.addAtomicRecipes(firstInput, secondInput, output);
    }

}

 

Recipe:

public class AtomicDiffuserRecipe {

    public ItemStack firstInput;
    public ItemStack secondInput;
    public ItemStack output;

    public AtomicDiffuserRecipe(ItemStack firstInput, ItemStack secondInput, ItemStack output) {
        this.firstInput = firstInput;
        this.secondInput = secondInput;
        this.output = output;
    }
}

[TheGreyGhost]

Hi Lambda

I'm running into some issues with the crafting handler and such

In order to help you, we really need a more detailed description of the problems you're having

 

ie.

What you expect to happen

vs

What actually happens (detailed symptoms, error logs, etc).

 

-TGG

[Lambda]

Okay, Updated,

 

For some reason I thought everybody would know my problem

[Draco18s]

Post your ItemUtil.areItemsEqual method.

[Lambda]

  public static boolean areItemsEqual(ItemStack stack1, ItemStack stack2, boolean checkWildcard){
        return StackUtil.isValid(stack1) && StackUtil.isValid(stack2) && (stack1.isItemEqual(stack2) || (checkWildcard && stack1.getItem() == stack2.getItem() && (stack1.getItemDamage() == UtilBase.WILDCARD || stack2.getItemDamage() == UtilBase.WILDCARD)));
    }

[Draco18s]

Hmm.

You might have to step through in the debugger.

[Lambda]

Where would I start? I probably should do some  kind of rewrite anyways, it seems a bit messy

[Draco18s]

Put a breakpoint on the canSmeltOn method, and step through line by line to figure out why it's not getting a result.

[Lambda]

Just got into Intellj, would you know how to add breakpoints, google search shows ALT+INS but that isnt working

[Choonster]

Just got into Intellj, would you know how to add breakpoints, google search shows ALT+INS but that isnt working

 

Click on the margin between the line numbers and the code.

[Lambda]

Hm, I'm not really able to lauch the game w/ breakpoints, it took 2 hours to load, and cant even click play..

[SanAndreaP]

But the breakpoint not next to the method name, but next to the first line of code after the method.

Method breakpoints are extremely sluggish.