I have a block that works sort of like a crafting table in that it uses no tileEntities and instantly crafts something out of InventoryCrafting slots. After the crafting result appears, however, although I can shift click the result into my inventory without problems, I am unable to left click the craft result Itemstack as it just vanishes. Is this a result of the code being on the wrong side? If so, should the code in onCraftMatrixChanged() be on the server or client side? Thanks in advance!

 

Container class:

public class ContainerArkenstoneTable extends Container{
    public InventoryCrafting inputInventory = new InventoryCrafting(this, 3, 1);
    public int inputSlotNumber;
    public InventoryArkenstoneResult outputInventory = new InventoryArkenstoneResult();
    public ArkenstoneRecipeHandler arkenstoneRecipeHandler;
    private final World world;
    private final BlockPos pos;
    private final InventoryPlayer playerInventory;
    
    
    public ContainerArkenstoneTable(InventoryPlayer playerInventory, World worldIn, BlockPos posIn){
        this.world = worldIn;
        this.pos = posIn;
        this.playerInventory = playerInventory;
        
        arkenstoneRecipeHandler = new ArkenstoneRecipeHandler();
        
        this.addSlotToContainer(new NoInputSlot(outputInventory, 0, 124, 31));
        this.addSlotToContainer(new DiamondOnlySlot(inputInventory, 0, 26 + 0 * 18, 9 + 18));
        this.addSlotToContainer(new Slot(inputInventory, 1, 44 + 1 * 18, 9 + 18));
        this.addSlotToContainer(new Slot(inputInventory, 2, 44 + 1 * 18, 13 + 2*18));
        

        for (int k = 0; k < 3; ++k){
            for (int i1 = 0; i1 < 9; ++i1){
                this.addSlotToContainer(new Slot(playerInventory, i1 + k * 9 + 9, 8 + i1 * 18, 84 + k * 18));
            }
        }

        for (int l = 0; l < 9; ++l){
            this.addSlotToContainer(new Slot(playerInventory, l, 8 + l * 18, 142));
        }
    }
    
    /**
     * Callback for when the crafting matrix is changed.
     */
    public void onCraftMatrixChanged(IInventory inventoryIn){

		//if the inventory selected is actually input inventory
    	if(inventoryIn == inputInventory){
    		//if this thing is empty, stahp
            while(!inputInventory.isEmpty()) {
                ItemStack outputItemStack = arkenstoneRecipeHandler.getArkenstoneResults(inputInventory);
                
                //if this input crafts nothing
                if (outputItemStack == ItemStack.EMPTY ){
                    return;
                }else {//if this input can craft something
            		//if something is already lingering in outputInventory from before
            	  	if(!outputInventory.isEmpty()){
        	  			//if what is supposed to be in output is NOT the same as the thing actually in output
        	  			if(!outputItemStack.isItemEqual(outputInventory.getStackInSlot(0))){
        	  				//Add what is supposed to go into output inventory to player inventory 
        	  				//automatically, or drop it on the ground
        	  				if(!playerInventory.addItemStackToInventory(outputItemStack)){
        	  					EntityItem entityItem = playerInventory.player.entityDropItem(outputItemStack, 0.5f);
        	  					entityItem.posX = playerInventory.player.posX;
        	  					entityItem.posY = playerInventory.player.posY;
        	  					entityItem.posZ = playerInventory.player.posZ;
        	  				}
        	  				//clear the output inventory
        	  				outputInventory.setInventorySlotContents(0, ItemStack.EMPTY);
        	  			}
        	  		}//at this point output inventory of a different yield should be cleared
            	  	
            	  	//get current item stack in case it's the same item causing the segment before to not clear it
            	  	ItemStack currentStack = outputInventory.getStackInSlot(0);
        	  		//Test to see if different type of dye by getting item damage
        	  		int metadata = outputItemStack.getItemDamage();
        	  		if(metadata == 32767){
        	  			metadata = 0;
        	  		}
        	  		ItemStack newStack = ItemStack.EMPTY;
        	  		//Output Slot already has the item we're trying to craft, just tack on more of it
        	  		if(!currentStack.isEmpty() && 1 + currentStack.getCount() <= outputItemStack.getMaxStackSize()){
        	  			newStack = new ItemStack(outputItemStack.getItem(), 1 + currentStack.getCount(), metadata);
        	  		}else{ //if output slot is already empty OR output slot can't handle the amount we're crafting
        	  			//if output slot already has the item we're trying to craft, but just couldn't fit so much
        	  			if(!currentStack.isEmpty() && !playerInventory.addItemStackToInventory(currentStack)){
        	  				EntityItem entityItem = playerInventory.player.entityDropItem(currentStack, 0.5f);
        	  				entityItem.posX = playerInventory.player.posX;
        	  				entityItem.posY = playerInventory.player.posY;
        	  				entityItem.posZ = playerInventory.player.posZ;
        	  			}else{
        	  				newStack = new ItemStack(outputItemStack.getItem(), 1, metadata);
        	  			}
        	  		}
        	  		outputInventory.setInventorySlotContents(0, newStack);
            	  	
            	  	//removes the contents from input inventory after crafting is completed
            	  	inputInventory.decrStackSize(0,1);
            	  	inputInventory.decrStackSize(1,1);
            	  	inputInventory.decrStackSize(2,1);

                }
            }//while loop ends

    	}
    }


    

    /**
     * Called when the container is closed.
     */
    @Override
    public void onContainerClosed(EntityPlayer playerIn)
    {
    	InventoryPlayer inventoryplayer = playerIn.inventory;
        if(!inventoryplayer.getItemStack().isEmpty())
        {
            playerIn.dropItem(inventoryplayer.getItemStack(), false);
            inventoryplayer.setItemStack(ItemStack.EMPTY);
        }
        if(!world.isRemote) {
        	ItemStack itemStack = outputInventory.getStackInSlot(0);
            if(!itemStack.isEmpty()){
            	if(!inventoryplayer.addItemStackToInventory(itemStack)) {
            		playerIn.dropItem(itemStack, false);
            	}
            }
            
            for(int i = 0; i < inputInventory.getSizeInventory(); i++ ){
                itemStack = inputInventory.getStackInSlot(i);
                if(!itemStack.isEmpty()){
                	if(!inventoryplayer.addItemStackToInventory(itemStack)) {
                		playerIn.dropItem(itemStack, false);
                	}
                }
            }
        }
    }

    /**
     * Determines whether supplied player can use this container
     */
    @Override
    public boolean canInteractWith(EntityPlayer playerIn)
    {
        if (this.world.getBlockState(this.pos).getBlock() != ModBlocks.ArkenstoneTableBlock)
        {
            return false;
        }
        else
        {
            return playerIn.getDistanceSq((double)this.pos.getX() + 0.5D, (double)this.pos.getY() + 0.5D, (double)this.pos.getZ() + 0.5D) <= 64.0D;
        }
    }

    /**
     * Handle when the stack in slot {@code index} is shift-clicked. Normally this moves the stack between the player
     * inventory and the other inventory(s).
     */
	@Override
	public ItemStack transferStackInSlot(final EntityPlayer player, final int index) {
		return ModUtils.transferStackInSlot(player, index, this);
	}
 

    /**
     * Called to determine if the current slot is valid for the stack merging (double-click) code. The stack passed in
     * is null for the initial slot that was double-clicked.
     */
    public boolean canMergeSlot(ItemStack stack, Slot slotIn){
        return slotIn.inventory != this.outputInventory && super.canMergeSlot(stack, slotIn);
    }
    


}

 

ModUtils class with methods that the above class references:

public class ModUtils {
	
	
	public static ItemStack transferStackInSlot(final EntityPlayer player, final int index, final Container container) {
		ItemStack itemstack = ItemStack.EMPTY;
		final Slot slot = container.inventorySlots.get(index);
		if ((slot != null) && slot.getHasStack()) {
			final ItemStack itemstack1 = slot.getStack();
			itemstack = itemstack1.copy();

			final int containerSlots = container.inventorySlots.size() - player.inventory.mainInventory.size();
			if (index < containerSlots) {
				if (!mergeItemStack(itemstack1, containerSlots, container.inventorySlots.size(), true, container)) {
					return ItemStack.EMPTY;
				}
			} else if (!mergeItemStack(itemstack1, 0, containerSlots, false, container)) {
				return ItemStack.EMPTY;
			}
			if (itemstack1.getCount() == 0) {
				slot.putStack(ItemStack.EMPTY);
			} else {
				slot.onSlotChanged();
			}
			if (itemstack1.getCount() == itemstack.getCount()) {
				return ItemStack.EMPTY;
			}
			slot.onTake(player, itemstack1);
		}
		if(container instanceof ContainerArkenstoneTable) {
			container.onCraftMatrixChanged(((ContainerArkenstoneTable) container).inputInventory);
		}
		return itemstack;
	}
   
   public static boolean mergeItemStack(final ItemStack stack, final int startIndex, final int endIndex, final boolean reverseDirection, final Container container) {
		boolean flag = false;
		int i = startIndex;

		if (reverseDirection) {
			i = endIndex - 1;
		}

		if (stack.isStackable()) {
			while (!stack.isEmpty()) {
				if (reverseDirection) {
					if (i < startIndex) {
						break;
					}
				} else if (i >= endIndex) {
					break;
				}

				final Slot slot = container.inventorySlots.get(i);
				final ItemStack itemstack = slot.getStack();

				if (!itemstack.isEmpty() && (itemstack.getItem() == stack.getItem()) && (!stack.getHasSubtypes() || (stack.getMetadata() == itemstack.getMetadata())) && ItemStack.areItemStackTagsEqual(stack, itemstack)) {
					final int j = itemstack.getCount() + stack.getCount();
					final int maxSize = Math.min(slot.getSlotStackLimit(), stack.getMaxStackSize());

					if (j <= maxSize) {
						stack.setCount(0);
						itemstack.setCount(j);
						slot.onSlotChanged();
						flag = true;
					} else if (itemstack.getCount() < maxSize) {
						stack.shrink(maxSize - itemstack.getCount());
						itemstack.setCount(maxSize);
						slot.onSlotChanged();
						flag = true;
					}
				}

				if (reverseDirection) {
					--i;
				} else {
					++i;
				}
			}
		}

		if (!stack.isEmpty()) {
			if (reverseDirection) {
				i = endIndex - 1;
			} else {
				i = startIndex;
			}

			while (true) {
				if (reverseDirection) {
					if (i < startIndex) {
						break;
					}
				} else if (i >= endIndex) {
					break;
				}

				final Slot slot1 = container.inventorySlots.get(i);
				final ItemStack itemstack1 = slot1.getStack();

				if (itemstack1.isEmpty() && slot1.isItemValid(stack)) {
					if (stack.getCount() > slot1.getSlotStackLimit()) {
						slot1.putStack(stack.splitStack(slot1.getSlotStackLimit()));
					} else {
						slot1.putStack(stack.splitStack(stack.getCount()));
					}

					slot1.onSlotChanged();
					flag = true;
					break;
				}

				if (reverseDirection) {
					--i;
				} else {
					++i;
				}
			}
		}

		return flag;
	}
}

 

ArkenstoneRecipeHandler class

package com.crumbletheundead.blocks.machines.ArkenstoneTable;

import net.minecraft.init.Items;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

public class ArkenstoneRecipeHandler {
	
	//items put into the crafting grid
	private boolean hasEmpty, hasDiamond, hasBone;
	
	public ArkenstoneRecipeHandler() {
	}
	
	public ItemStack getArkenstoneResults(InventoryCrafting inputInventory) {
		hasEmpty = false;
		hasDiamond = false;
		hasBone = false;
		//test if first slot has diamonds
		if(inputInventory.getStackInSlot(0).getItem().equals(Items.DIAMOND)) {
			hasDiamond = true;
		}
		
		//go through the other two slots to see if they have any items required
        for(int i = 1; i<= inputInventory.getSizeInventory()-1; i++) {
        	if(inputInventory.getStackInSlot(i).isEmpty()) {
        		hasEmpty = true;
        	}else if(inputInventory.getStackInSlot(i).getItem().equals(Items.BONE)) {
        		hasBone = true;
        	}
        }
        
        if(hasDiamond && hasBone && hasEmpty) {
        	return new ItemStack(Items.APPLE);
        }else {
        	return ItemStack.EMPTY;
        }
	}
	
}

 

InventoryArkenstone class

package com.crumbletheundead.blocks.machines.ArkenstoneTable;

import javax.annotation.Nullable;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ItemStackHelper;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.IRecipe;
import net.minecraft.util.NonNullList;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextComponentTranslation;

public class InventoryArkenstoneResult implements IInventory{
	private final NonNullList<ItemStack> stackResult = NonNullList.<ItemStack>withSize(1, ItemStack.EMPTY);
	
    /**
     * Returns the number of slots in the inventory.
     */
    @Override
    public int getSizeInventory()
    {
        return 1;
    }

    /**
     * Returns the stack in slot i
     */
    @Override
    public ItemStack getStackInSlot(int index)
    {
        return this.stackResult.get(0);
    }

    
    @Override
    public boolean isEmpty()
    {
        for (ItemStack itemstack : this.stackResult)
        {
            if (!itemstack.isEmpty())
            {
                return false;
            }
        }

        return true;
    }
    
    @Override
    public String getName()
    {
        return "Arkenstone Result";
    }
    
    @Override
    public boolean hasCustomName()
    {
        return false;
    }
    
    @Override
    public ITextComponent getDisplayName()
    {
        return new TextComponentTranslation(this.getName(), new Object[0]);
    }
    
    @Override
    public ItemStack decrStackSize(int index, int count)
    {
        if(this.stackResult.get(index) != null)
        {
            ItemStack itemstack = this.stackResult.get(index);
            this.stackResult.get(index).setCount(0);;
            return itemstack;
        }
        else
        {
            return ItemStack.EMPTY;
        }
    }
    
    
    @Override
    public ItemStack removeStackFromSlot(int index)
    {
        return ItemStackHelper.getAndRemove(this.stackResult, 0);
    }
    @Override
    public void setInventorySlotContents(int index, ItemStack stack)
    {
        this.stackResult.set(0, stack);
    }
    @Override
    public int getInventoryStackLimit()
    {
        return 64;
    }
    @Override
    public boolean isUsableByPlayer(EntityPlayer player)
    {
        return true;
    }
    @Override
    public void openInventory(EntityPlayer player)
    {
    }
    @Override
    public void closeInventory(EntityPlayer player)
    {
    }
    @Override
    public boolean isItemValidForSlot(int index, ItemStack stack)
    {
        return false;
    }
    public int getField(int id)
    {
        return 0;
    }

    public void setField(int id, int value)
    {
    }

    public int getFieldCount()
    {
        return 0;
    }

    public void clear()
    {
        this.stackResult.clear();
    }

	@Override
	public void markDirty() {
		
		
	}
}

 

Edited September 22, 20186 yr by Lumby
solved

My initial guess was that since items automatically crafted, when the output slot was clicked it checked the inputInventory again to find nothing and hence reset the output to ItemStack.Empty. After an afternoon in the debug perspective, however, I feel like the problem isn't within the onCraftingMatrixChanged() method, as it isn't called when I take items out of the slot. Any ideas what else may be a possible cause?

I've found out the problem. The problem was that my InventoryArkenstoneResult class had an outdated decrStackSize, since I was following a tutorial from older forge versions. The new one can pulled from the InventoryCraftingResult class if anyone else encounters this problem in the future. 

    public ItemStack decrStackSize(int index, int count)
    {
        return ItemStackHelper.getAndRemove(this.stackResult, 0);
    }