So something like this?

 

    @Nullable
    public ItemStack getMultiResult(ItemStack stack)
    {
        for (Entry<ItemStack, ItemStack> entry : this.smeltingList.entrySet())
        {
            if (this.compareItemStacks(stack, entry.getKey()))
            {
            	multismeltList.get(stack);
                return stack;
            }
        }

        return null;
    }

 

or this?

 

    @Nullable
    public List<OutputWrapper> getMultiResult(ItemStack stack)
    {
        for (Entry<ItemStack, ItemStack> entry : this.smeltingList.entrySet())
        {
            if (this.compareItemStacks(stack, entry.getKey()))
            {
                List<OutputWrapper> list = new ArrayList<OutputWrapper>();
                return list;
            }
        }

        return null;
    }

 

or neither?

public List<OutputWrapper> getMultiResult(ItemStack stack) {

    return multismeltList.get(stack);

}

 

You don't need to iterate over the entry set.

 

The whole point of creating the wrapper was so you could do this:

 

smeltmulti.get(stack);

Okay,

 

So now the Tile is wanting a list, which I gave, however I'm getting a bunch of errors because its a list, instead of an itemstack.

 

Edit:

 

Here is the function that needs some tweaking:

 

private boolean smeltItem(boolean performSmelt)
{
	Integer firstSuitableInputSlot = null;
	Integer firstSuitableOutputSlot = null;
	List<OutputWrapper> result = null;
	for (int inputSlot = FIRST_INPUT_SLOT; inputSlot < FIRST_INPUT_SLOT + INPUT_SLOTS_COUNT; inputSlot++)	{
		if (itemStacks[inputSlot] != null) {
			result = getSmeltingResultForItem(itemStacks[inputSlot]);
  			if (result != null) {
				// find the first suitable output slot- either empty, or with identical item that has enough space
				for (int outputSlot = FIRST_OUTPUT_SLOT; outputSlot < FIRST_OUTPUT_SLOT + OUTPUT_SLOTS_COUNT; outputSlot++) {
					ItemStack outputStack = itemStacks[outputSlot];
					if (outputStack == null) {
						firstSuitableInputSlot = inputSlot;
						firstSuitableOutputSlot = outputSlot;
						break;
					}

					if (outputStack.getItem() == result.getItem() && (!outputStack.getHasSubtypes() || outputStack.getMetadata() == outputStack.getMetadata())
									&& ItemStack.areItemStackTagsEqual(outputStack, result)) {
						int combinedSize = itemStacks[outputSlot].stackSize + result.stackSize;
						if (combinedSize <= getInventoryStackLimit() && combinedSize <= itemStacks[outputSlot].getMaxStackSize()) {
							firstSuitableInputSlot = inputSlot;
							firstSuitableOutputSlot = outputSlot;
							break;
						}
					}
				}
				if (firstSuitableInputSlot != null) break;
			}
		}
	}

	if (firstSuitableInputSlot == null) return false;
	if (!performSmelt) return true;

	// alter input and output
	itemStacks[firstSuitableInputSlot].stackSize--;
	if (itemStacks[firstSuitableInputSlot].stackSize <=0) itemStacks[firstSuitableInputSlot] = null;
	if (itemStacks[firstSuitableOutputSlot] == null) {
		itemStacks[firstSuitableOutputSlot] = result.copy(); // Use deep .copy() to avoid altering the recipe
	} else {
		itemStacks[firstSuitableOutputSlot].stackSize += result.stackSize;
	}
	markDirty();
	return true;
}

Sorry, that's too dense for me to figure out what your intentions are.

I assumed you had a 1-input, multi-output furnace.  It looks like you actually have multi-(1-input:1-output) furnace.

 

The idea I had in my head was that you had one input, you would get its list of outputs, and iterate over that list, checking to see if the probabilistic result item was outputted or not.

No I have a 1 input > 5 output slots

Then what is this loop for?

for (int inputSlot = FIRST_INPUT_SLOT; inputSlot < FIRST_INPUT_SLOT + INPUT_SLOTS_COUNT; inputSlot++) {...}

It was when I had multiple inputs, but I changed the slots, will change.

Okay, So I'm having a problem with applying the multiple output slots, the item smelts, but doesn't give an output nor get used.

I KNOW there is something with it, but I cant figure it out:

 

private boolean canSmelt() {return smeltItem(false);}

/**
 * Smelt an input item into an output slot, if possible
 */
private void smeltItem() {smeltItem(true);}

/**
 * checks that there is an item to be smelted in one of the input slots and that there is room for the result in the output slots
 * If desired, performs the smelt
 * @param performSmelt if true, perform the smelt.  if false, check whether smelting is possible, but don't change the inventory
 * @return false if no items can be smelted, true otherwise
 */
private boolean smeltItem(boolean performSmelt)
{
	Integer firstSuitableInputSlot = null;
	Integer firstSuitableOutputSlot = null;
	ItemStack result = null;

		if (itemStacks[0] != null) {
			result = getSmeltingResultForItem(itemStacks[0]);
  			if (result != null) {
				for (int outputSlot = FIRST_OUTPUT_SLOT; outputSlot < FIRST_OUTPUT_SLOT + OUTPUT_SLOTS_COUNT; outputSlot++) {
					ItemStack outputStack = itemStacks[outputSlot];
					if (outputStack == null) {
						firstSuitableOutputSlot = outputSlot;
						break;
					}
					if (outputStack.getItem() == result.getItem() && (!outputStack.getHasSubtypes() || outputStack.getMetadata() == outputStack.getMetadata()) && ItemStack.areItemStackTagsEqual(outputStack, result)) {
						int combinedSize = itemStacks[outputSlot].stackSize + result.stackSize;
						if (combinedSize <= getInventoryStackLimit() && combinedSize <= itemStacks[outputSlot].getMaxStackSize()) {
							firstSuitableOutputSlot = outputSlot;
							break;
						}
					}
				}
			}
		}

	return true;
}

// returns the smelting result for the given stack. Returns null if the given stack can not be smelted
public static ItemStack getSmeltingResultForItem(ItemStack stack) { return FurnaceRecipes.instance().getSmeltingResult(stack); }

// re

 

EDIT:

 

Just trying to get the regular furnace recipes working

 

You need to refactor things so that your "firstvalidoutputslot" variable isn't based on checking "is it this one? is it this one? is it this one?" You need to write a function to do that, rather than encapsulating it inside the smelt method.