1.12.2 Custom Furnace Issues

[Will11690]

Okay so I have a custom furnace that smelts 2 items into 1 and I'm currently have a bit of an issue with it.

 

The furnace is sometimes doubling the output when I only want it to output a single item. I always end up with 15 instead of 8. I believe the first one it makes is doing it right but then after that it outputs 2 instead of one.

 

It also doesn't always work, sometimes when it is placed or after the items are taken out and the GUI closed and reopened it will no longer smelt items.

 

Then most of the time if I pull the items it smelted out they just disappear out of the players inventory after you close the GUI.

 

Then the last issue I'm having is when the block is broken the items won't drop on the ground, they just vanish into thin air.

 

All of the source code for my furnace will be listed below(if i missed anything you need please let me know), if anybody could help me out that would be greatly appreciated and you will be mentioned in the credits of my finished mod once it's able to be released.

 

BLOCK CLASS:

Spoiler

import java.util.Random;

import will11690.mechanicraft.Main;
import will11690.mechanicraft.util.Reference;
import will11690.mechanicraft.blocks.BlockBase;
import will11690.mechanicraft.blocks.machines.basicinfuser.TileEntityBasicMetallicInfuser;
import will11690.mechanicraft.init.ModBlocks;
import net.minecraft.block.BlockHorizontal;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.SoundType;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumBlockRenderType;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.Mirror;
import net.minecraft.util.Rotation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;

public class BasicMetallicInfuser extends BlockBase
{
	public static final PropertyDirection FACING = BlockHorizontal.FACING;
	public static final PropertyBool BURNING = PropertyBool.create("burning");
	
	public BasicMetallicInfuser(String name) 
	{
		super(name, Material.IRON);
		setCreativeTab(Main.mechanicraftmachinestab);
		setSoundType(SoundType.METAL);
		this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));
	}
	
	@Override
	public Item getItemDropped(IBlockState state, Random rand, int fortune) 
	{
		return Item.getItemFromBlock(ModBlocks.BASIC_METALLIC_INFUSER);
	}
	
	@Override
	public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state)
	{
		return new ItemStack(ModBlocks.BASIC_METALLIC_INFUSER);
	}
	
	@Override
	public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) 
	{
		if(!worldIn.isRemote)
		{
			playerIn.openGui(Main.Instance, Reference.GUI_BASIC_METALLIC_INFUSER, worldIn, pos.getX(), pos.getY(), pos.getZ());
		}
		
		return true;
	}
	
	@Override
	public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) 
	{
		if (!worldIn.isRemote) 
        {
            IBlockState north = worldIn.getBlockState(pos.north());
            IBlockState south = worldIn.getBlockState(pos.south());
            IBlockState west = worldIn.getBlockState(pos.west());
            IBlockState east = worldIn.getBlockState(pos.east());
            EnumFacing face = (EnumFacing)state.getValue(FACING);

            if (face == EnumFacing.NORTH && north.isFullBlock() && !south.isFullBlock()) face = EnumFacing.SOUTH;
            else if (face == EnumFacing.SOUTH && south.isFullBlock() && !north.isFullBlock()) face = EnumFacing.NORTH;
            else if (face == EnumFacing.WEST && west.isFullBlock() && !east.isFullBlock()) face = EnumFacing.EAST;
            else if (face == EnumFacing.EAST && east.isFullBlock() && !west.isFullBlock()) face = EnumFacing.WEST;
            worldIn.setBlockState(pos, state.withProperty(FACING, face), 2);
        }
	}
	
	public static void setState(boolean active, World worldIn, BlockPos pos) 
	{
		IBlockState state = worldIn.getBlockState(pos);
		TileEntity tileentity = worldIn.getTileEntity(pos);
		
		if(active) worldIn.setBlockState(pos, ModBlocks.BASIC_METALLIC_INFUSER.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, true), 3);
		else worldIn.setBlockState(pos, ModBlocks.BASIC_METALLIC_INFUSER.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, false), 3);
		
		if(tileentity != null) 
		{
			tileentity.validate();
			worldIn.setTileEntity(pos, tileentity);
		}
	}
	
	@Override
	public boolean hasTileEntity(IBlockState state) 
	{
		return true;
	}
	
	@Override
	public TileEntity createTileEntity(World world, IBlockState state) 
	{
		return new TileEntityBasicMetallicInfuser();
	}
	
	@Override
	public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) 
	{
		return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
	}
	
	@Override
	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) 
	{
		worldIn.setBlockState(pos, this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
	}
	
	@Override
	public EnumBlockRenderType getRenderType(IBlockState state) 
	{
		return EnumBlockRenderType.MODEL;
	}
	
	@Override
	public IBlockState withRotation(IBlockState state, Rotation rot)
	{
		return state.withProperty(FACING, rot.rotate((EnumFacing)state.getValue(FACING)));
	}
	
	@Override
	public IBlockState withMirror(IBlockState state, Mirror mirrorIn) 
	{
		return state.withRotation(mirrorIn.toRotation((EnumFacing)state.getValue(FACING)));
	}
	
	@Override
	protected BlockStateContainer createBlockState() 
	{
		return new BlockStateContainer(this, new IProperty[] {BURNING,FACING});
	}
	
	@Override
	public IBlockState getStateFromMeta(int meta) 
	{
		EnumFacing facing = EnumFacing.getFront(meta);
		if(facing.getAxis() == EnumFacing.Axis.Y) facing = EnumFacing.NORTH;
		return this.getDefaultState().withProperty(FACING, facing);
	}
	
	@Override
	public int getMetaFromState(IBlockState state) 
	{
		return ((EnumFacing)state.getValue(FACING)).getIndex();
	}	
}

 

 

 

RECIPE CLASS{the recipes in here are for testing purposes}:

Spoiler

package will11690.mechanicraft.blocks.machines.basicinfuser;

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.init.Blocks;
import net.minecraft.item.ItemStack;
import will11690.mechanicraft.init.ModBlocks;

public class BasicMetallicInfuserRecipes {
	
	private static final BasicMetallicInfuserRecipes INSTANCE = new BasicMetallicInfuserRecipes();
	private final Table<ItemStack, ItemStack, ItemStack> smeltingList = HashBasedTable.<ItemStack, ItemStack, ItemStack>create();
	private final Map<ItemStack, Float> experienceList = Maps.<ItemStack, Float>newHashMap();
	
	public static BasicMetallicInfuserRecipes getInstance() {
		
		return INSTANCE;
		
	}
	
	private BasicMetallicInfuserRecipes() {
		
		this.addInfuserRecipe(new ItemStack(ModBlocks.COPPER_BLOCK), new ItemStack(ModBlocks.BLOCK_IRON), new ItemStack(Blocks.ACACIA_FENCE), 5.0F);
		this.addInfuserRecipe(new ItemStack(Blocks.ACACIA_FENCE), new ItemStack(Blocks.ACACIA_FENCE_GATE), new ItemStack(ModBlocks.ENDONIUM_CRYSTAL_BLOCK), 5.0F);
		
	}

	
	public void addInfuserRecipe(ItemStack input1, ItemStack input2, ItemStack result, float experience) {
		
		if(getInfuserResult(input1, input2) != ItemStack.EMPTY) return;
		this.smeltingList.put(input1, input2, result);
		this.experienceList.put(result, Float.valueOf(experience));
		
	}
	
	public ItemStack getInfuserResult(ItemStack input1, ItemStack input2) {
		
		for(Entry<ItemStack, Map<ItemStack, ItemStack>> entry : this.smeltingList.columnMap().entrySet()) {
			
			if(this.compareItemStacks(input1, (ItemStack)entry.getKey())) {
				
				for(Entry<ItemStack, ItemStack> ent : entry.getValue().entrySet()) {
					
					if(this.compareItemStacks(input2, (ItemStack)ent.getKey())) {
						
						return (ItemStack)ent.getValue();
						
					}
					
				}
				
			}
			
		}
		
		return ItemStack.EMPTY;
	}
	
	private boolean compareItemStacks(ItemStack stack1, ItemStack stack2) {
		
		return stack2.getItem() == stack1.getItem() && (stack2.getMetadata() == 32767 || stack2.getMetadata() == stack1.getMetadata());
		
	}
	
	public Table<ItemStack, ItemStack, ItemStack> getDualSmeltingList() {
		
		return this.smeltingList;
		
	}
	
	public float getInfuserExperience(ItemStack stack) {
		
		for (Entry<ItemStack, Float> entry : this.experienceList.entrySet()) {
			
			if(this.compareItemStacks(stack, (ItemStack)entry.getKey())) {
				
				return ((Float)entry.getValue()).floatValue();
				
			}
			
		}
		
		return 0.0F;
	}
}

 

 

 

CONTAINER CLASS:

Spoiler

package will11690.mechanicraft.blocks.machines.basicinfuser;

import will11690.mechanicraft.blocks.machines.basicinfuser.BasicMetallicInfuserRecipes;
import will11690.mechanicraft.blocks.machines.basicinfuser.slots.SlotBasicMetallicInfuserFuel;
import will11690.mechanicraft.blocks.machines.basicinfuser.slots.SlotBasicMetallicInfuserOutput;
import will11690.mechanicraft.blocks.machines.basicinfuser.TileEntityBasicMetallicInfuser;

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;

public class ContainerBasicMetallicInfuser extends Container
{
	private final TileEntityBasicMetallicInfuser tileentity;
	private int cookTime, totalCookTime, burnTime, currentBurnTime;
	
	public ContainerBasicMetallicInfuser(InventoryPlayer player, TileEntityBasicMetallicInfuser tileentity) 
	{
		this.tileentity = tileentity;
		IItemHandler handler = tileentity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
		
		this.addSlotToContainer(new SlotItemHandler(handler, 0, 30, 22));
		this.addSlotToContainer(new SlotItemHandler(handler, 1, 58, 22));
		this.addSlotToContainer(new SlotItemHandler(handler, 2, 45, 46));
		this.addSlotToContainer(new SlotItemHandler(handler, 3, 124, 22));
		
		for(int y = 0; y < 3; y++)
		{
			for(int x = 0; x < 9; x++)
			{
				this.addSlotToContainer(new Slot(player, x + y*9 + 9, 8 + x*18, 84 + y*18));
			}
		}
		
		for(int x = 0; x < 9; x++)
		{
			this.addSlotToContainer(new Slot(player, x, 8 + 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));
			if(this.totalCookTime != this.tileentity.getField(3)) listener.sendWindowProperty(this, 3, this.tileentity.getField(3));
		}
		
		this.cookTime = this.tileentity.getField(2);
		this.burnTime = this.tileentity.getField(0);
		this.currentBurnTime = this.tileentity.getField(1);
		this.totalCookTime = this.tileentity.getField(3);
	}
	
	@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 == 3) 
			{
				if(!this.mergeItemStack(stack1, 4, 40, true)) return ItemStack.EMPTY;
				slot.onSlotChange(stack1, stack);
			}
			else if(index != 2 && index != 1 && index != 0) 
			{		
				Slot slot1 = (Slot)this.inventorySlots.get(index + 1);
				
				if(!BasicMetallicInfuserRecipes.getInstance().getInfuserResult(stack1, slot1.getStack()).isEmpty())
				{
					if(!this.mergeItemStack(stack1, 0, 2, false)) 
					{
						return ItemStack.EMPTY;
					}
					else if(TileEntityBasicMetallicInfuser.isItemFuel(stack1))
					{
						if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
					}
					else if(TileEntityBasicMetallicInfuser.isItemFuel(stack1))
					{
						if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
					}
					else if(TileEntityBasicMetallicInfuser.isItemFuel(stack1))
					{
						if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
					}
					else if(index >= 4 && index < 31)
					{
						if(!this.mergeItemStack(stack1, 31, 40, false)) return ItemStack.EMPTY;
					}
					else if(index >= 31 && index < 40 && !this.mergeItemStack(stack1, 4, 31, false))
					{
						return ItemStack.EMPTY;
					}
				}
			} 
			else if(!this.mergeItemStack(stack1, 4, 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;
	}
}

 

 

 

GUI CLASS:

Spoiler

import will11690.mechanicraft.util.Reference;
import will11690.mechanicraft.blocks.machines.basicinfuser.ContainerBasicMetallicInfuser;
import will11690.mechanicraft.blocks.machines.basicinfuser.TileEntityBasicMetallicInfuser;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;

public class GuiBasicMetallicInfuser extends GuiContainer
{
	private static final ResourceLocation TEXTURES = new ResourceLocation(Reference.MOD_ID + ":textures/gui/basic_metallic_infuser.png");
	private final InventoryPlayer player;
	private final TileEntityBasicMetallicInfuser tileentity;
	
	public GuiBasicMetallicInfuser(InventoryPlayer player, TileEntityBasicMetallicInfuser tileentity) 
	{
		super(new ContainerBasicMetallicInfuser(player, tileentity));
		this.player = player;
		this.tileentity = tileentity;
	}
	
	@Override
	protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) 
	{
		String tileName = this.tileentity.getDisplayName().getUnformattedText();
		this.fontRenderer.drawString(tileName, (this.xSize / 2 - this.fontRenderer.getStringWidth(tileName) / 2) + 0, 4, 4210752);
		this.fontRenderer.drawString(this.player.getDisplayName().getUnformattedText(), 122, this.ySize - 96 + 2, 4210752);
	}
	
	@Override
	protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY)
	{
		GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f);
		this.mc.getTextureManager().bindTexture(TEXTURES);
		this.drawTexturedModalRect(this.guiLeft, this.guiTop, 0, 0, this.xSize, this.ySize);
		
		if(TileEntityBasicMetallicInfuser.isBurning(tileentity))
		{
			int k = this.getBurnLeftScaled(13);
			this.drawTexturedModalRect(this.guiLeft + 47, this.guiTop + 66 + 12 - k, 176, 12 - k, 14, k + 1);
		}
		
		int l = this.getCookProgressScaled(24);
		this.drawTexturedModalRect(this.guiLeft + 84, this.guiTop + 23, 176, 14, l + 1, 16);
	}
	
	private int getBurnLeftScaled(int pixels)
	{
		int i = this.tileentity.getField(1);
		if(i == 0) i = 200;
		return this.tileentity.getField(0) * pixels / i;
	}
	
	private int getCookProgressScaled(int pixels)
	{
		int i = this.tileentity.getField(2);
		int j = this.tileentity.getField(3);
		return j != 0 && i != 0 ? i * pixels / j : 0;
	}
}

 

 

 

TILE ENTITY:

 

package will11690.mechanicraft.blocks.machines.basicinfuser;

import will11690.mechanicraft.blocks.machines.basicinfuser.BasicMetallicInfuser;
import will11690.mechanicraft.blocks.machines.basicinfuser.BasicMetallicInfuserRecipes;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
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.ItemHoe;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemSword;
import net.minecraft.item.ItemTool;
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.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.energy.CapabilityEnergy;
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;

public class TileEntityBasicMetallicInfuser extends TileEntity implements ITickable
{
	private ItemStackHandler handler = new ItemStackHandler(4);
	private String customName;
	private ItemStack smelting = ItemStack.EMPTY;
	
	private int burnTime;
	private int currentBurnTime;
	private int cookTime;
	private int totalCookTime = 200;

	@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 (T) this.handler;
		return super.getCapability(capability, facing);
	}
	
	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.customName) : new TextComponentTranslation("container.basic_metallic_infuser");
	}
	
	@Override
	public void readFromNBT(NBTTagCompound compound)
	{
		super.readFromNBT(compound);
		this.handler.deserializeNBT(compound.getCompoundTag("Inventory"));
		this.burnTime = compound.getInteger("BurnTime");
		this.cookTime = compound.getInteger("CookTime");
		this.totalCookTime = compound.getInteger("CookTimeTotal");
		this.currentBurnTime = getItemBurnTime((ItemStack)this.handler.getStackInSlot(2));
		
		if(compound.hasKey("CustomName", 8)) this.setCustomName(compound.getString("CustomName"));
	}
	
	@Override
	public NBTTagCompound writeToNBT(NBTTagCompound compound) 
	{
		super.writeToNBT(compound);
		compound.setInteger("BurnTime", (short)this.burnTime);
		compound.setInteger("CookTime", (short)this.cookTime);
		compound.setInteger("CookTimeTotal", (short)this.totalCookTime);
		compound.setTag("Inventory", this.handler.serializeNBT());
		
		if(this.hasCustomName()) compound.setString("CustomName", this.customName);
		return compound;
	}
	
	public boolean isBurning() 
	{
		return this.burnTime > 0;
	}
	
	@SideOnly(Side.CLIENT)
	public static boolean isBurning(TileEntityBasicMetallicInfuser te) 
	{
		return te.getField(0) > 0;
	}
	
	public void update() 
	{	
		if(this.isBurning())
		{
			--this.burnTime;
			BasicMetallicInfuser.setState(true, world, pos);
		}
		
		ItemStack[] inputs = new ItemStack[] {handler.getStackInSlot(0), handler.getStackInSlot(1)};
		ItemStack fuel = this.handler.getStackInSlot(2);
		
		if(this.isBurning() || !fuel.isEmpty() && !this.handler.getStackInSlot(0).isEmpty() || this.handler.getStackInSlot(1).isEmpty())
		{
			if(!this.isBurning() && this.canSmelt())
			{
				this.burnTime = getItemBurnTime(fuel);
				this.currentBurnTime = burnTime;
				
				if(this.isBurning() && !fuel.isEmpty())
				{
					Item item = fuel.getItem();
					fuel.shrink(1);
					
					if(fuel.isEmpty())
					{
						ItemStack item1 = item.getContainerItem(fuel);
						this.handler.setStackInSlot(2, item1);
					}
				}
			}
		}
		
		if(this.isBurning() && this.canSmelt() && cookTime > 0)
		{
			cookTime++;
			if(cookTime == totalCookTime)
			{
				if(handler.getStackInSlot(3).getCount() > 0)
				{
					handler.getStackInSlot(3).grow(1);
				}
				else
				{
					handler.insertItem(3, smelting, false);
				}
				
				smelting = ItemStack.EMPTY;
				cookTime = 0;
				return;
			}
		}
		else
		{
			if(this.canSmelt() && this.isBurning())
			{
				ItemStack output = BasicMetallicInfuserRecipes.getInstance().getInfuserResult(inputs[0], inputs[1]);
				if(!output.isEmpty())
				{
					smelting = output;
					cookTime++;
					inputs[0].shrink(1);
					inputs[1].shrink(1);
					handler.setStackInSlot(0, inputs[0]);
					handler.setStackInSlot(1, inputs[1]);
				}
			}
		}
	}
	
	private boolean canSmelt() 
	{
		if(((ItemStack)this.handler.getStackInSlot(0)).isEmpty() || ((ItemStack)this.handler.getStackInSlot(1)).isEmpty()) return false;
		else 
		{
			ItemStack result = BasicMetallicInfuserRecipes.getInstance().getInfuserResult((ItemStack)this.handler.getStackInSlot(0), (ItemStack)this.handler.getStackInSlot(1));	
			if(result.isEmpty()) return false;
			else
			{
				ItemStack output = (ItemStack)this.handler.getStackInSlot(3);
				if(output.isEmpty()) return true;
				if(!output.isItemEqual(result)) return false;
				int res = output.getCount() + result.getCount();
				return res <= 64 && res <= output.getMaxStackSize();
			}
		}
	}
	
	public static int getItemBurnTime(ItemStack fuel) 
	{
		if(fuel.isEmpty()) return 0;
		else 
		{
			Item item = fuel.getItem();

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

				if (block == Blocks.WOODEN_SLAB) return 150;
				if (block.getDefaultState().getMaterial() == Material.WOOD) return 300;
				if (block == Blocks.COAL_BLOCK) return 16000;
			}

			if (item instanceof ItemTool && "WOOD".equals(((ItemTool)item).getToolMaterialName())) return 200;
			if (item instanceof ItemSword && "WOOD".equals(((ItemSword)item).getToolMaterialName())) return 200;
			if (item instanceof ItemHoe && "WOOD".equals(((ItemHoe)item).getMaterialName())) 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 GameRegistry.getFuelValue(fuel);
		}
	}
		
	public static boolean isItemFuel(ItemStack fuel)
	{
		return getItemBurnTime(fuel) > 0;
	}
	
	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;
	}

	public int getField(int id) 
	{
		switch(id) 
		{
		case 0:
			return this.burnTime;
		case 1:
			return this.currentBurnTime;
		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.burnTime = value;
			break;
		case 1:
			this.currentBurnTime = value;
			break;
		case 2:
			this.cookTime = value;
			break;
		case 3:
			this.totalCookTime = value;
		}
	}
}

 

Edited September 10, 2018 by Will11690
Updated tags and put code in spoilers

[Animefan8888]

12 minutes ago, Will11690 said:

All of the source code for my furnace will be listed below

What is the formatting on your code? Why is it all left aligned? It is such a pain to read.

12 minutes ago, Will11690 said:

BLOCK CLASS:

You have so many unnecessary methods in here. All you need are Block#onBlockActivated (to open the GUI), Block#breakBlock (to drop all the contained items), Block# hasTIleEntity, Block#createTileEntity, Block#getStateForPlacement (to apply the FACING property correctly), Block#getStateFromMeta, Block#getMetaFromState, and Block#createBlockState

 

12 minutes ago, Will11690 said:

public void update()

This method can be shortened massively, and I mean massively. Also it really needs to be formatted for me to look at without wanting to find a nice scenic cliff.

 

12 minutes ago, Will11690 said:

CONTAINER CLASS:

 

12 minutes ago, Will11690 said:

GUI CLASS:

You posted your Container class twice.

 

[Will11690]

2 hours ago, Animefan8888 said:

What is the formatting on your code? Why is it all left aligned? It is such a pain to read.

You have so many unnecessary methods in here. All you need are Block#onBlockActivated (to open the GUI), Block#breakBlock (to drop all the contained items), Block# hasTIleEntity, Block#createTileEntity, Block#getStateForPlacement (to apply the FACING property correctly), Block#getStateFromMeta, Block#getMetaFromState, and Block#createBlockState

 

This method can be shortened massively, and I mean massively. Also it really needs to be formatted for me to look at without wanting to find a nice scenic cliff.

 

 

You posted your Container class twice.

 

Sorry, my computer did that to me yesterday too with the left aligned thing, I didn't realize it did it again.

I was still half asleep, I will fix it now

[Will11690]

3 hours ago, Will11690 said:

Sorry, my computer did that to me yesterday too with the left aligned thing, I didn't realize it did it again.

I was still half asleep, I will fix it now

Ight I fixed it the formatting and also fixed the double posting. I had to right click and copy in Eclipse instead of control c to copy for some reason lol.

Edited September 10, 2018 by Will11690

[Animefan8888]

9 hours ago, Will11690 said:

if(this.isBurning() && this.canSmelt() && cookTime > 0)

This line in your update method is causing the problem cookTime is never able to be incremented. 

9 hours ago, Will11690 said:

public boolean isBurning() { return this.burnTime > 0; }

You can combine this method and consuming fuel so you only need to call it once.

9 hours ago, Will11690 said:

BasicMetallicInfuser.setState

There is no point in having this method in your Block class write the code in your TileEntity.

9 hours ago, Will11690 said:

TILE ENTITY:

You also need to override shouldRefresh and return true if the blocks are different, not the blockstates.

 

As well as my aforementioned changes.

[Will11690]

On 9/10/2018 at 5:37 PM, Animefan8888 said:

This line in your update method is causing the problem cookTime is never able to be incremented. 

You can combine this method and consuming fuel so you only need to call it once.

There is no point in having this method in your Block class write the code in your TileEntity.

You also need to override shouldRefresh and return true if the blocks are different, not the blockstates.

 

As well as my aforementioned changes.

Im not saying fix it for me but could you give me a couple examples? I've tried a few things with adding shouldRefresh and I can't seem to get it working. Also I have tooled around with the broken cook time section and I can get it "SEMI" working by changing this:

 

if(this.isBurning() && this.canSmelt() && cookTime > 0)
        {
            cookTime++;
            if(cookTime == totalCookTime)
            {
                if(handler.getStackInSlot(3).getCount() > 0)
                {

                    handler.getStackInSlot(3).grow(1);
                }
                else
                {
                    handler.insertItem(3, smelting, false);
                }
                
                smelting = ItemStack.EMPTY;
                cookTime = 0;
                return;
            }
        }

 

to this:

 

if(this.isBurning() && this.canSmelt() && cookTime > 0)
        {
            cookTime++;
            if(cookTime == totalCookTime)
            {
                if(handler.getStackInSlot(3).getCount() >= 0)
                {

                    handler.getStackInSlot(3).grow(1);
                }
                else
                {
                    handler.insertItem(3, smelting, false);
                }
                
                smelting = ItemStack.EMPTY;
                cookTime = 0;
                return;
            }
        }

 

but it only works if I put the output Item in the output slot. If I do that though it works 100% correct so long as the output item stays there.

 

I tried to add the breakBlock function in to drop the items but it whines about not having IInventory implemented in the tile entity and I'm not sure of another way to do it.

 

    public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
        
        TileEntityBasicMetallicInfuser tileentity = (TileEntityBasicMetallicInfuser)worldIn.getTileEntity(pos);
        InventoryHelper.dropInventoryItems(worldIn, pos, tileentity);
        super.breakBlock(worldIn, pos, state);
        
    }

[Animefan8888]

4 hours ago, Will11690 said:

I tried to add the breakBlock function in to drop the items but it whines about not having IInventory implemented in the tile entity and I'm not sure of another way to do it.

Huh, I wonder if there is another way this could be done. Let's try looking at what InventoryHelper.dropInventoryItems does. Why not try to replicate it.

4 hours ago, Will11690 said:

I've tried a few things with adding shouldRefresh and I can't seem to get it working.

 

On 9/10/2018 at 2:37 PM, Animefan8888 said:

You also need to override shouldRefresh and return true if the blocks are different, not the blockstates.

 

4 hours ago, Will11690 said:

Also I have tooled around with the broken cook time section and I can get it "SEMI" working by changing this:

 

On 9/10/2018 at 2:37 PM, Animefan8888 said:

You can combine this method and consuming fuel so you only need to call it once.

if inputsAreRecipe

if isBurningOrHasFuel()

cookTime++

If cookTime >= done

output getOutputFromRecipe

removeInputs

insertItem(output)

[Will11690]

I appreciate all the assistance! I finally got it working as intended.

[Leronus]

On 10/15/2018 at 4:00 AM, Will11690 said:

I appreciate all the assistance! I finally got it working as intended.

Please share your code.... Having the exact same issues you mentioned but even with those answers I can't figure it out...

[loordgek]

Leronus what version are you modding ?

 

[Leronus]

On 9/16/2018 at 11:39 PM, Animefan8888 said:

Huh, I wonder if there is another way this could be done. Let's try looking at what InventoryHelper.dropInventoryItems does. Why not try to replicate it.

 

 

 

if inputsAreRecipe

if isBurningOrHasFuel()

cookTime++

If cookTime >= done

output getOutputFromRecipe

removeInputs

insertItem(output)

 

8 minutes ago, loordgek said:

Leronus what version are you modding ?

 

1.12.2.... I know it's unsupported ;-;

[Leronus]

package mod.mores.objects.blocks.machines;

import mod.mores.init.BlockInit;
import mod.mores.util.Reference;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
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.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.network.play.server.SPacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
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.event.ForgeEventFactory;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.ItemStackHandler;

import java.util.ArrayList;

public class TileEntityAlloyFurnace extends TileEntity implements ITickable {
    private ItemStackHandler inventory = new ItemStackHandler(NonNullList.withSize(4, ItemStack.EMPTY));
    private String customName;
    private ItemStack smelting = ItemStack.EMPTY;

    private static final String BURNTIME_KEY = "BurnTime";
    private static final String COOKTIME_KEY = "CookTime";
    private static final String COOKTIMETOTAL_KEY = "CookTimeTotal";

    private static final String INVENTORY_KEY = "inventory";
    private static final String CUSTOMNAME_KEY = "CustomName";

    public static final int INPUT_LEFT = 0;
    public static final int INPUT_RIGHT = 1;
    public static final int INPUT_FUEL = 2;
    public static final int OUTPUT = 3;

    public int burnTime = 0;
    public int currentBurnTime = 0;
    public int cookTime = 0;
    public int totalCookTime = 600;

    public TileEntityAlloyFurnace() {
        Reference.LOGGER.info("TileEntity is successfully bound to a block");
    }

    @Override
    public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newState)
    {
        return (oldState.getBlock() != newState.getBlock());
    }

    @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
        // TODO Auto-generated method stub
        if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
            return true;
        return super.hasCapability(capability, facing);
    }

    @Override
    public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
        // TODO Auto-generated method stub
        if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
            return (T) this.inventory;
        return super.getCapability(capability, facing);
    }

    public boolean hasCustomName() {

        return customName != null && !customName.isEmpty();
    }

    public void setCustomName(String customname) {
        this.customName = customname;
    }

    @Override
    public ITextComponent getDisplayName() {
        return this.hasCustomName() ? new TextComponentString(this.customName)
                : new TextComponentTranslation("container.alloy_furnace");
    }

    @Override
    public void readFromNBT(NBTTagCompound compound) {

        super.readFromNBT(compound);
        this.inventory.deserializeNBT(compound.getCompoundTag(INVENTORY_KEY));
        burnTime = compound.getInteger(BURNTIME_KEY);
        cookTime = compound.getInteger(COOKTIME_KEY);
        totalCookTime = compound.getInteger(COOKTIMETOTAL_KEY);
        currentBurnTime = getItemBurnTime((ItemStack) inventory.getStackInSlot(1));

        if (compound.hasKey(CUSTOMNAME_KEY, 8))
            setCustomName(compound.getString(CUSTOMNAME_KEY));
    }

    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {

        super.writeToNBT(compound);
        compound.setInteger(BURNTIME_KEY, (short) burnTime);
        compound.setInteger(COOKTIME_KEY, (short) cookTime);
        compound.setInteger(COOKTIMETOTAL_KEY, (short) totalCookTime);
        compound.setTag(INVENTORY_KEY, this.inventory.serializeNBT());

        if (hasCustomName())
            compound.setString(CUSTOMNAME_KEY, customName);
        return compound;
    }

    public boolean isBurning() {
        return burnTime > 0;
    }

    @SideOnly(Side.CLIENT)
    public static boolean isBurning(TileEntityAlloyFurnace te) {
        return te.burnTime > 0;
    }

    public static void setState(boolean active, World worldIn, BlockPos pos) {
        IBlockState state = worldIn.getBlockState(pos);
        TileEntity tileentity = worldIn.getTileEntity(pos);

        if (active)
            worldIn.setBlockState(pos, BlockInit.ALLOY_FURNACE.getDefaultState()
                    .withProperty(BlockAlloyFurnace.FACING, state.getValue(BlockAlloyFurnace.FACING)).withProperty(BlockAlloyFurnace.BURNING, true), 1 | 2);
        else
            worldIn.setBlockState(pos, BlockInit.ALLOY_FURNACE.getDefaultState()
                    .withProperty(BlockAlloyFurnace.FACING, state.getValue(BlockAlloyFurnace.FACING)).withProperty(BlockAlloyFurnace.BURNING, false), 1 | 2);

        if (tileentity != null) {
            tileentity.validate();
            worldIn.setTileEntity(pos, tileentity);
        }
    }


    @Override
    public void update() {
        boolean wasBurning = isBurning();
        boolean flag1 = false;

        if(this.isBurning())
        {
            --this.burnTime;
            setState(true, world, pos);
        }

        ItemStack[] inputs = new ItemStack[] {inventory.getStackInSlot(INPUT_LEFT), inventory.getStackInSlot(INPUT_RIGHT)};
        ItemStack fuel = this.inventory.getStackInSlot(INPUT_FUEL);

        if(this.isBurning() || !fuel.isEmpty() && !this.inventory.getStackInSlot(INPUT_LEFT).isEmpty() || !this.inventory.getStackInSlot(INPUT_RIGHT).isEmpty())
        {
            if(!this.isBurning() && this.canSmelt())
            {
                this.burnTime = getItemBurnTime(fuel);
                this.currentBurnTime = burnTime;

                if(this.isBurning() && !fuel.isEmpty())
                {
                    Item item = fuel.getItem();
                    fuel.shrink(1);

                    if(fuel.isEmpty())
                    {
                        ItemStack item1 = item.getContainerItem(fuel);
                        this.inventory.setStackInSlot(2, item1);
                    }
                }
            }
        }

        if(this.isBurning() && this.canSmelt() && cookTime > 0)
        {
            cookTime++;
            if(cookTime == totalCookTime)
            {
                if(inventory.getStackInSlot(3).getCount() > 0)
                {
                    inventory.getStackInSlot(3).grow(1);
                }
                else
                {
                    inventory.insertItem(3, smelting, false);
                }

                smelting = ItemStack.EMPTY;
                cookTime = 0;
                return;
            }
        }
        else
        {
            if(this.canSmelt() && this.isBurning())
            {
                ItemStack output = AlloyFurnaceRecipes.getInstance().getAlloyResult(inputs[0], inputs[1]);
                if(!output.isEmpty())
                {
                    smelting = output;
                    cookTime++;
                    inputs[0].shrink(1);
                    inputs[1].shrink(1);
                    inventory.setStackInSlot(0, inputs[0]);
                    inventory.setStackInSlot(1, inputs[1]);
                }
            }
        }
    }

    private boolean canSmelt() {
        if (((ItemStack) inventory.getStackInSlot(INPUT_LEFT)).isEmpty() || ((ItemStack) inventory.getStackInSlot(INPUT_RIGHT)).isEmpty())
            return false;
        else {
            ItemStack result1 = AlloyFurnaceRecipes.getInstance().getAlloyResult((ItemStack) inventory.getStackInSlot(INPUT_LEFT), (ItemStack) inventory.getStackInSlot(INPUT_RIGHT));
            if (result1.isEmpty())
                return false;
            else {
                ItemStack fuel = (ItemStack) inventory.getStackInSlot(INPUT_FUEL);
                ItemStack output = (ItemStack) inventory.getStackInSlot(OUTPUT);
                if(output.isEmpty()) return true;
                if(!output.isItemEqual(result1)) return false;
                int res1 = output.getCount() + result1.getCount();
                int res2 = fuel.getCount() + 1;
                return (res1 <= 64 && res1 <= output.getMaxStackSize())
                        || (res2 <= 64 && res2 <= fuel.getMaxStackSize());
            }
        }
    }

    public static int getItemBurnTime(ItemStack fuel) {
        if (fuel.isEmpty())
            return 0;
        else {
            Item item = fuel.getItem();

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

                if (block == Blocks.WOODEN_SLAB)
                    return 100;
                if (block == Blocks.ACACIA_STAIRS || block == Blocks.OAK_STAIRS || block == Blocks.JUNGLE_STAIRS
                        || block == Blocks.BIRCH_STAIRS || block == Blocks.DARK_OAK_STAIRS
                        || block == Blocks.SPRUCE_STAIRS)
                    return 150;
                if (block.getDefaultState().getMaterial() == Material.WOOD)
                    return 200;
                if (block == Blocks.COAL_BLOCK)
                    return 14400;
            }

            if (item instanceof ItemTool && "WOOD".contentEquals(((ItemTool) item).getToolMaterialName()))
                return 180;
            if (item instanceof ItemSword && "WOOD".contentEquals(((ItemTool) item).getToolMaterialName()))
                return 180;
            if (item instanceof ItemHoe && "WOOD".contentEquals(((ItemTool) item).getToolMaterialName()))
                return 180;
            if (item == Items.STICK)
                return 50;
            if (item == Items.COAL)
                return 1600;
            if (item == Items.LAVA_BUCKET)
                return 20000;
            if (item == Item.getItemFromBlock(Blocks.SAPLING))
                return 70;
            if (item == Items.BLAZE_ROD)
                return 1600;

            return ForgeEventFactory.getItemBurnTime(fuel);
        }
    }

    public static boolean isItemFuel(ItemStack fuel) {
        return getItemBurnTime(fuel) > 0;
    }

    public boolean isUsableByPlayer(EntityPlayer player) {

        return world.getTileEntity(pos) == this && player.getDistanceSq((double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D,
                (double) pos.getZ() + 0.5D) <= 64.0D;
    }

    public boolean isItemValidForSlot(int index, ItemStack stack) {
        if (index == 2 || index == 3)
            return false;
        if (index != 1)
            return true;
        else {
            return isItemFuel(stack);
        }
    }
    public final ArrayList<ItemStack> containerLists() {
        ArrayList<ItemStack> stackList = new ArrayList(inventory.getSlots());
        for (int i = 0; i < inventory.getSlots(); i++) {
            stackList.add(inventory.getStackInSlot(i));
        }
        return stackList;
    }

    public int getField(int id)
    {
        switch(id)
        {
            case 0:
                return this.burnTime;
            case 1:
                return this.currentBurnTime;
            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.burnTime = value;
                break;
            case 1:
                this.currentBurnTime = value;
                break;
            case 2:
                this.cookTime = value;
                break;
            case 3:
                this.totalCookTime = value;
        }
    }
    /*
    @Override
    public NBTTagCompound getUpdateTag() {
        return writeToNBT(new NBTTagCompound());
    }
     */


    /*
    @Override
    public SPacketUpdateTileEntity getUpdatePacket() {
        return null;
    }

     */

}

package mod.mores.objects.blocks.machines;

import mod.mores.init.BlockInit;
import mod.mores.init.ItemInit;
import mod.mores.modid.Mores;
import mod.mores.objects.BlockBase;
import mod.mores.particle.FlameParticle;
import mod.mores.particle.ParticleCustom;
import mod.mores.util.Reference;
import net.minecraft.block.Block;
import net.minecraft.block.BlockHorizontal;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.SoundType;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.particle.Particle;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.SoundEvents;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemBucket;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.*;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidActionResult;
import net.minecraftforge.fluids.FluidUtil;
import net.minecraftforge.fluids.UniversalBucket;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.items.CapabilityItemHandler;

import java.util.Random;

public class BlockAlloyFurnace extends Block {

    public static final PropertyDirection FACING = BlockHorizontal.FACING;
    public static final PropertyBool BURNING = PropertyBool.create("burning");


    public BlockAlloyFurnace(String name, Material material, CreativeTabs creativeTab) {
        super(material);
        setUnlocalizedName(name);
        setRegistryName(name);
        setCreativeTab(creativeTab);

        setSoundType(SoundType.ANVIL);
        setHardness(5.0f);
        setResistance(30.0f);
        setHarvestLevel("pickaxe", 1);
        setLightLevel(0.0f);
        // setLightOpacity(1);
        // setBlockUnbreakable();

        this.setDefaultState(
                this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));

        BlockInit.BLOCKS.add(this);
        ItemInit.ITEMS.add(new ItemBlock(this).setRegistryName(this.getRegistryName()));
    }


    @Override
    public Item getItemDropped(IBlockState state, Random rand, int fortune) {
        return Item.getItemFromBlock(BlockInit.ALLOY_FURNACE);

    }

    @Override
    public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state) {
        return new ItemStack(BlockInit.ALLOY_FURNACE);

    }

    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn,
                                    EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
        if(!worldIn.isRemote)
        {
            playerIn.openGui(Mores.instance, Reference.GUI_ALLOY_FURNACE, worldIn, pos.getX(), pos.getY(), pos.getZ());
        }
        return true;
    }

    @Override
    public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) {
        // TODO Auto-generated method stub

        if (!worldIn.isRemote) {

            IBlockState north = worldIn.getBlockState(pos.north());
            IBlockState south = worldIn.getBlockState(pos.south());
            IBlockState west = worldIn.getBlockState(pos.west());
            IBlockState east = worldIn.getBlockState(pos.east());
            EnumFacing face = (EnumFacing) state.getValue(FACING);

            if (face == EnumFacing.NORTH)
                face = EnumFacing.SOUTH;
            if (face == EnumFacing.SOUTH)
                face = EnumFacing.NORTH;
            if (face == EnumFacing.WEST)
                face = EnumFacing.EAST;
            if (face == EnumFacing.EAST)
                face = EnumFacing.WEST;
            worldIn.setBlockState(pos, state.withProperty(FACING, face), 2);
        }
    }


    @Override
    public int getLightValue(IBlockState state, IBlockAccess world, BlockPos pos) {
        // TODO Auto-generated method stub
        return state.getValue(BURNING).booleanValue() ? 15 : 0;
    }

    @Override
    public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY,
                                            float hitZ, int meta, EntityLivingBase placer, EnumHand hand) {
        // TODO Auto-generated method stub
        return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
    }

    @Override
    public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer,
                                ItemStack stack) {
        // TODO Auto-generated method stub
        worldIn.setBlockState(pos,
                this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
    }

    @Override
    public IBlockState withRotation(IBlockState state, Rotation rot) {
        // TODO Auto-generated method stub
        return state.withProperty(FACING, rot.rotate((EnumFacing) state.getValue(FACING)));
    }

    @Override
    public IBlockState withMirror(IBlockState state, Mirror mirrorIn) {
        // TODO Auto-generated method stub
        return state.withRotation(mirrorIn.toRotation((EnumFacing) state.getValue(FACING)));
    }

    @Override
    protected BlockStateContainer createBlockState() {
        // TODO Auto-generated method stub
        return new BlockStateContainer(this, new IProperty[] { BURNING, FACING });
    }

    @Override
    public IBlockState getStateFromMeta(int meta) {
        // TODO Auto-generated method stub
        EnumFacing facing = EnumFacing.getFront(meta);
        if (facing.getAxis() == EnumFacing.Axis.Y)
            facing = EnumFacing.NORTH;
        return this.getDefaultState().withProperty(FACING, facing);
    }

    @Override
    public int getMetaFromState(IBlockState state) {
        // TODO Auto-generated method stub
        return ((EnumFacing) state.getValue(FACING)).getIndex();
    }

    @Override
    public boolean hasTileEntity(IBlockState state) {
        // TODO Auto-generated method stub
        return true;
    }

    @Override
    public TileEntityAlloyFurnace createTileEntity(World world, IBlockState state) {
        // TODO Auto-generated method stub
        return new TileEntityAlloyFurnace();
    }

    @Override
    public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
        // TODO Auto-generated method stub
        TileEntity te = worldIn.getTileEntity(pos);
        if (te instanceof TileEntityAlloyFurnace) {
            for (ItemStack stack : ((TileEntityAlloyFurnace) te).containerLists()) {
                spawnAsEntity(worldIn, pos, stack);
            }
        }
        super.breakBlock(worldIn, pos, state);
    }

    @SideOnly(Side.CLIENT)
    @SuppressWarnings("incomplete-switch")
    public void randomDisplayTick(IBlockState stateIn, World worldIn, BlockPos pos, Random rand)
    {
        if (stateIn.getValue(BURNING))
        {
            EnumFacing enumfacing = (EnumFacing)stateIn.getValue(FACING);
            double d0 = (double)pos.getX() + 0.5D;
            double d1 = (double)pos.getY() + rand.nextDouble() * 6.0D / 16.0D;
            double d2 = (double)pos.getZ() + 0.5D;
            double d3 = 0.52D;
            double d4 = rand.nextDouble() * 0.6D - 0.3D;

            if (rand.nextDouble() < 0.1D)
            {
                worldIn.playSound((double)pos.getX() + 0.5D, (double)pos.getY(), (double)pos.getZ() + 0.5D, SoundEvents.BLOCK_FURNACE_FIRE_CRACKLE, SoundCategory.BLOCKS, 1.0F, 1.0F, false);
            }

            switch (enumfacing) {
                case WEST:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 - 0.52D, d1, d2 + d4, 0.0D, 0.0D, 0.0D);
                    Particle newEffectWest = new ParticleCustom(new ParticleCustom.TextureDefinition("flame_fx"), worldIn, d0 - 0.52D, d1, d2 + d4, 0.0D, 0.0D, 0.0D);
                    Minecraft.getMinecraft().effectRenderer.addEffect(newEffectWest);
                    break;
                case EAST:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + 0.52D, d1, d2 + d4, 0.0D, 0.0D, 0.0D);
                    Particle newEffectEast = new ParticleCustom(new ParticleCustom.TextureDefinition("flame_fx"), worldIn, d0 + 0.52D, d1, d2 + d4, 0.0D, 0.0D, 0.0D);
                    Minecraft.getMinecraft().effectRenderer.addEffect(newEffectEast);
                    break;
                case NORTH:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 - 0.52D, 0.0D, 0.0D, 0.0D);
                    Particle newEffectNorth = new ParticleCustom(new ParticleCustom.TextureDefinition("flame_fx"), worldIn, d0 + d4, d1, d2 - 0.52D, 0.0D, 0.0D, 0.0D);
                    Minecraft.getMinecraft().effectRenderer.addEffect(newEffectNorth);
                    break;
                case SOUTH:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 + 0.52D, 0.0D, 0.0D, 0.0D);
                    Particle newEffectSouth = new ParticleCustom(new ParticleCustom.TextureDefinition("flame_fx"), worldIn, d0 + d4, d1, d2 + 0.52D, 0.0D, 0.0D, 0.0D);
                    Minecraft.getMinecraft().effectRenderer.addEffect(newEffectSouth);
            }
        }
    }
}

 

This is what my code looks like, in case anyone does decide to help

The issues I have as of now is that removing the output items freezes all entities and removing an input or fuel will have the Furnace remaining in its burning state  Have tried everything I could think of, searched every known 1.12.2 post known to man but to no avail *cries in 1.12.2*