Block doesn't open GUI

[dyno]

I've made a block with a GUI. When I right click it, GUI doesn't appear

 

Block

Spoiler

package OliveMod.machines.AlloySmelter;

import java.util.Random;

import com.google.common.util.concurrent.Service.State;

import OliveMod.Main;
import OliveMod.blocks.BlockBase_noRotation;
import OliveMod.init.ModBlocks;
import OliveMod.init.ModItems;
import OliveMod.util.IHasModels;
import OliveMod.util.Reference;
import OliveMod.util.handler.GuiHandler;
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.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
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 AlloySmelter extends BlockBase_noRotation implements ITileEntityProvider{
    
    public static final PropertyDirection FACING = BlockHorizontal.FACING;
    public static final PropertyBool BURNING = PropertyBool.create("burning");
    
    public AlloySmelter(String name) {
        super(name, Material.IRON);    
        setSoundType(SoundType.STONE);
        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));        
    }    
    
    public boolean obBlockActivated(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_ALLOY_SMELTER, worldIn, pos.getX(), pos.getY(), pos.getZ());        
        }
        return true;
    }

    public Item getItemDropped(IBlockState state, Random rand, int fortune){
        return Item.getItemFromBlock(ModBlocks.ALLOY_SMELTER);        
    }
    
    public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state){
        return new ItemStack(ModBlocks.ALLOY_SMELTER);
    }

    
    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 east = worldIn.getBlockState(pos.east());
            IBlockState west = worldIn.getBlockState(pos.west());
            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.ALLOY_SMELTER.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, true), 3);
        else
            worldIn.setBlockState(pos, ModBlocks.ALLOY_SMELTER.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, false), 3);
        
        if(tileentity != null)
        {
            tileentity.validate();
            worldIn.setTileEntity(pos, tileentity);
        }
        
    }

    @Override
    public TileEntity createNewTileEntity(World worldIn, int meta) {
        return new TileEntityAlloySmelter();
    }
    
    @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 void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
        TileEntityAlloySmelter tileentity = (TileEntityAlloySmelter)worldIn.getTileEntity(pos);
        InventoryHelper.dropInventoryItems(worldIn, pos, tileentity);
        super.breakBlock(worldIn, pos, state);
    }
    
    public EnumBlockRenderType getRenderType(IBlockState state)
    {
        return EnumBlockRenderType.MODEL;
    }
    
    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();
    }
}
 

Container

Spoiler

package OliveMod.machines.AlloySmelter;

import OliveMod.machines.AlloySmelter.slots.SlotSeparatorFuel;
import OliveMod.machines.AlloySmelter.slots.SlotSeparatorOutput;
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.event.enchanting.EnchantmentLevelSetEvent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import scala.xml.dtd.EMPTY;

public class ContainerAlloySmelter extends Container {

    private final TileEntityAlloySmelter tileentity;
    private int BurnTime, WorkTime, currentWorkTime, totalWorkTime;
    
    
    public ContainerAlloySmelter(InventoryPlayer player, TileEntityAlloySmelter tileentity) 
    {
        this.tileentity = tileentity;
        this.addSlotToContainer(new Slot(tileentity, 0, 26, 11));
        this.addSlotToContainer(new Slot(tileentity, 1, 26, 59));
        this.addSlotToContainer(new SlotSeparatorFuel(tileentity, 2, 7, 35));
        this.addSlotToContainer(new SlotSeparatorOutput(player.player, tileentity, 3, 81, 36));
        
        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 addListener(IContainerListener listener) {
        super.addListener(listener);
        listener.sendAllWindowProperties(this, this.tileentity);
    }
    
    
    @Override
    public void detectAndSendChanges() {
        super.detectAndSendChanges();
        
        for(int i=0; i < this.listeners.size(); ++i)
        {
            IContainerListener listener = (IContainerListener)this.listeners.get(i);
            
            if(this.WorkTime != 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.currentWorkTime != this.tileentity.getField(1))
                listener.sendWindowProperty(this, 1, this.tileentity.getField(1));
            if(this.totalWorkTime != this.tileentity.getField(3))
                listener.sendWindowProperty(this, 3, this.tileentity.getField(3));
        }
        
        this.WorkTime = this.tileentity.getField(2);
        this.BurnTime = this.tileentity.getField(0);
        this.currentWorkTime = this.tileentity.getField(1);
        this.totalWorkTime = 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))
                     slot.onSlotChange(stack1, stack);     
             }
             else if (index != 2 && index != 1 && index != 0)
             {
                 Slot slot1 = this.inventorySlots.get(index + 1);
                 
                 if(AlloySmelterRecipes.getInstance().getSeparatorResult(stack1, slot1.getStack()).isEmpty())
                 {
                     if(!this.mergeItemStack(stack1, 0, 2, false))
                     {
                         return ItemStack.EMPTY;
                     }
                     else if (TileEntityAlloySmelter.isItemFuel(stack1))
                     {
                         if(!this.mergeItemStack(stack1, 2, 3, false))
                             return ItemStack.EMPTY;         
                     }
                     else if (TileEntityAlloySmelter.isItemFuel(stack1))
                     {
                         if(!this.mergeItemStack(stack1, 2, 3, false))
                             return ItemStack.EMPTY;         
                     }
                     else if (TileEntityAlloySmelter.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 (!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

Spoiler

package OliveMod.machines.AlloySmelter;

import OliveMod.util.Reference;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.util.ResourceLocation;

public class GUI_AlloySmelter extends GuiContainer{

    private static final ResourceLocation TEXTURES = new ResourceLocation(Reference.MOD_ID + "oil:textures/gui/alloy_smelter");
    private final InventoryPlayer player;
    private final TileEntityAlloySmelter tileentity;

    
    public GUI_AlloySmelter(InventoryPlayer player, TileEntityAlloySmelter tileentity) {
        super(new ContainerAlloySmelter(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) + 3, 8, 4210752);
        this.fontRenderer.drawString(this.player.getDisplayName().getUnformattedText(), 122, this.ySize - 96 + 2, 4210752);
        super.drawGuiContainerForegroundLayer(mouseX, mouseY);
    }
    
    
    @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(TileEntityAlloySmelter.isWorking(tileentity))
        {
            int k = getWorkLeftScale(13);
            this.drawTexturedModalRect(this.guiLeft + 45, this.guiTop + 32 + 12 - k, 166, 12 - k, 14, k + 1);
            
        }
        
        int l = this.getWorkProgressScaled(24);
        this.drawTexturedModalRect(this.guiLeft + 78, this.guiTop + 30, 166, 14, l + 1, 16);
    }
    
    
    private int getWorkLeftScale(int pixels){
        int i = this.tileentity.getField(1);
        if (i == 0)
            i = 200;
        return this.tileentity.getField(1) * pixels/i;
    }
    
    private int getWorkProgressScaled(int pixels) {
        int i = this.tileentity.getField(2);
        int j = this.tileentity.getField(3);
        
        return j != 0 && i != 0 ? i * pixels / j : 0;
    }
    
}
 

TileEntity

Spoiler

package OliveMod.machines.AlloySmelter;

import OliveMod.init.ModBlocks;
import OliveMod.init.ModItems;
import OliveMod.items.ItemBase;
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.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import scala.tools.nsc.doc.model.Public;

public class TileEntityAlloySmelter extends TileEntity implements IInventory, ITickable {

    NonNullList<ItemStack> inventory = NonNullList.<ItemStack>withSize(4, ItemStack.EMPTY);
    private String customName;
    
    private int burnTime;
    private int currentCookTime;
    private int cookTime;
    private int totalCookTime;
    
    @Override
    public String getName() {
        return this.hasCustomName() ? this.customName : "container.alloy_smelter"; 
    }
    
    
    @Override
    public boolean hasCustomName() {
        return this.customName != null && !this.customName.isEmpty();
    }
    
    
    public void setCustomName(String customName)
    {
        this.customName = customName;
    }
    
    @Override
    public ITextComponent getDisplayName()
    {
        return this.hasCustomName() ? new TextComponentString(this.getName()) : new TextComponentTranslation(this.getName());
    }
    
    
    @Override
    public int getSizeInventory() {
        return this.inventory.size();
    }
    
    
    @Override
    public boolean isEmpty() {
        for(ItemStack stack : this.inventory)
        {
            if (!stack.isEmpty())
                return false;
        }
        return true;
    }
    
    
    @Override
    public ItemStack getStackInSlot(int index) {
        return (ItemStack)this.inventory.get(index);
    }
    
    
    @Override
    public ItemStack decrStackSize(int index, int count) {
        return ItemStackHelper.getAndSplit(this.inventory, index, count);
    }
    
    
    @Override
    public ItemStack removeStackFromSlot(int index) {
        return ItemStackHelper.getAndRemove(this.inventory, index);
    }
    
    
    @Override
    public void setInventorySlotContents(int index, ItemStack stack) {
        ItemStack itemstack = (ItemStack)this.inventory.get(index);
        boolean flag = !stack.isEmpty() && stack.isItemEqual(itemstack) && ItemStack.areItemStacksEqual(stack, itemstack);
        this.inventory.set(index, stack);
        
        if(stack.getCount() > this.getInventoryStackLimit() )
            stack.setCount(this.getInventoryStackLimit());
        
        if(index == 0 && index + 1 == 1 && !flag)
        {
            ItemStack stack1 = (ItemStack)this.inventory.get(index + 1);
            this.totalCookTime = this.getBurnTime(index, stack1);
            this.cookTime = 0;
            this.markDirty();
        }
    }
    
    private int getBurnTime(int index, ItemStack stack1) {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        this.inventory = NonNullList.<ItemStack>withSize(this.getSizeInventory(), ItemStack.EMPTY);
        ItemStackHelper.loadAllItems(compound, this.inventory);
        this.burnTime = compound.getInteger("BurnTime");
        this.cookTime = compound.getInteger("CookTime");
        this.totalCookTime = compound.getInteger("WorkTimeTotal");
        this.currentCookTime = getItemBurnTime((ItemStack)this.inventory.get(2));
    
        if(compound.hasKey("customName", 0))
            this.setCustomName(compound.getString("customName"));
    }
    
    public NBTTagCompound writeToNBT(NBTTagCompound compound)
    {
        super.writeToNBT(compound);
        compound.setInteger("BurnTime", (short)this.burnTime);
        compound.setInteger("WorkTime", (short)this.cookTime);
        compound.setInteger("WorkTimeTotal", (short)this.totalCookTime);
        ItemStackHelper.saveAllItems(compound, this.inventory);
        
        if(this.hasCustomName())
            compound.setString("custonName", this.customName);
        
        return compound;        
    }

    @Override
    public int getInventoryStackLimit() {
        return 64;
    }
    
    public boolean isBurning(){
        return this.cookTime > 0;
    }
    
    
    @SideOnly(Side.CLIENT)
    public static boolean isWorking(IInventory inventory){
        return inventory.getField(0) > 0;
    }
    
    public void update()
    {
        boolean flag = this.isBurning();
        boolean flag1 = false;
        
        if(this.isBurning()) 
            --this.cookTime;
        
        if(this.world.isRemote)
        {
            ItemStack stack = (ItemStack)this.inventory.get(2);
            if(this.isBurning() || !stack.isEmpty() && !((((ItemStack)this.inventory.get(0)).isEmpty()) || ((ItemStack)this.inventory.get(0)).isEmpty()) )
            {
                if(!this.isBurning() && this.canWork() )
                {
                    this.burnTime = getItemBurnTime(stack);
                    this.currentCookTime = cookTime;
                    
                    if(this.isBurning())
                    {
                        flag1 = true;
                        
                        if(!stack.isEmpty())
                        {
                            Item item = stack.getItem();
                            stack.shrink(1);
                            
                            if(stack.isEmpty())
                            {
                                ItemStack item1 = item.getContainerItem(stack);
                                this.inventory.set(2, item1);
                            }
                        }
                    }
                    
                }
                if(this.isBurning() && this.canWork())
                {
                    ++this.cookTime;
                    if(this.cookTime == this.totalCookTime)
                    {
                        this.cookTime = 0;
                        this.totalCookTime = this.getWorkTime((ItemStack)this.inventory.get(0), (ItemStack)this.inventory.get(1));
                        this.WorkItem();
                        flag1 = true;
                    }
                    else this.cookTime = 0;
                    
                }
                else if(!this.isBurning() && this.cookTime > 0)
                {
                    this.cookTime = MathHelper.clamp(this.cookTime - 2, 0, this.totalCookTime);
                }
                if(flag != this.isBurning())
                {
                    flag1 = true;
                    AlloySmelter.setState(this.isBurning(), this.world, this.pos);
                }
            }
            if(flag1)
                this.markDirty();
        }
    }
    
    
    
    private static int getItemBurnTime(ItemStack fuel) {
        if(fuel.isEmpty())
            return 0;
        else
        {
            Item item = fuel.getItem();
            if(item instanceof ItemBase && Block.getBlockFromItem(item) != Blocks.AIR)
            {
                Block itemToWork = Block.getBlockFromItem(item);
                if(itemToWork == Blocks.COAL_BLOCK)
                    return 16000;
                if(itemToWork.getDefaultState().getMaterial() == Material.WOOD)
                    return 200;

            }
            if(item == Items.COAL)
                return 1600;
            
            return GameRegistry.getFuelValue(fuel);
        }
        
    }
    
    public static boolean isItemFuel(ItemStack fuel)
    {
        return getItemBurnTime(fuel) > 0;
    }

    private void WorkItem() {
        if(this.canWork())
        {
            ItemStack input1 = (ItemStack)this.inventory.get(0);
            ItemStack input2 = (ItemStack)this.inventory.get(1);
            ItemStack result = AlloySmelterRecipes.getInstance().getSeparatorResult(input1, input2);
            ItemStack output = (ItemStack)this.inventory.get(3);    
            
            if(output.isEmpty())
                this.inventory.set(3, result.copy());
            else if (output.getItem() == result.getItem())
                output.grow(result.getCount());
            input1.shrink(1);
            input2.shrink(1);
        }
        
        
    }

    private int getWorkTime(ItemStack itemStack, ItemStack stack1) {

        return 200;
    }

 

    private boolean canWork() {
        if (((ItemStack)this.inventory.get(0)).isEmpty() || ((ItemStack)this.inventory.get(1)).isEmpty())        
            return false;
        else
        {
            ItemStack result = AlloySmelterRecipes.getInstance().getSeparatorResult((ItemStack)this.inventory.get(0), (ItemStack)this.inventory.get(1));
            if(result.isEmpty())
                return false;
            else
            {
                ItemStack output = (ItemStack)this.inventory.get(3);
                if(output.isEmpty())
                    return true;
                if(!output.isItemEqual(result))
                    return false;
                int res = output.getCount() + result.getCount();
                return res <= getInventoryStackLimit() && res <= output.getMaxStackSize();
            }
        }
    }

    @Override
    public boolean isUsableByPlayer(EntityPlayer player) {
        return this.world.getTileEntity(this.pos) != this ? false : player.getDistanceSq((double)this.pos.getX()+0.5D, (double)this.pos.getY()+0.5D,(double)this.pos.getZ()+0.5D) <= 64;
    }
    
    
    @Override
    public void openInventory(EntityPlayer player) {        
    }
    
    
    @Override
    public void closeInventory(EntityPlayer player) {    
    }
    
    
    @Override
    public boolean isItemValidForSlot(int index, ItemStack stack) {
        if(index == 3)
            return true;
        else if (index != 2)
            return true;
        else
            return isItemFuel(stack);
    }
    
    
    public String getGuiID()
    {
        return "oil:separator";
    }
    
    @Override
    public int getField(int id) {
        switch (id)
        {
        case 0:
            return this.burnTime;
        case 1:
            return this.currentCookTime;
        case 2:
            return this.cookTime;
        case 3:
            return this.totalCookTime;
            
        default:
            return 0;
        }
    }
    
    
    @Override
    public void setField(int id, int value) {
        switch (id)
        {
        case 0:
            this.burnTime = value;
        case 1:
            this.currentCookTime = value;
        case 2:
            this.cookTime = value;
        case 3:
            this.totalCookTime = value;
        }
        
    }
    
    
    @Override
    public int getFieldCount() {
        return 4;
    }
    
    
    @Override
    public void clear() {
        this.inventory.clear();
    }
    
}
 

Gui Handler

Spoiler

package OliveMod.util.handler;

import OliveMod.machines.AlloySmelter.ContainerAlloySmelter;
import OliveMod.machines.AlloySmelter.GUI_AlloySmelter;
import OliveMod.machines.AlloySmelter.TileEntityAlloySmelter;
import OliveMod.util.Reference;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.IGuiHandler;

public class GuiHandler implements IGuiHandler {
    
    
    @Override
    public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
        if(ID == Reference.GUI_ALLOY_SMELTER)
            return new ContainerAlloySmelter(player.inventory, (TileEntityAlloySmelter)world.getTileEntity(new BlockPos(x, y, z)));
        return null;

    }

    @Override
    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
        if(ID == Reference.GUI_ALLOY_SMELTER)
            return new GUI_AlloySmelter(player.inventory, (TileEntityAlloySmelter)world.getTileEntity(new BlockPos(x, y, z)));
        return null;
    }

}
 

Register Handler

Spoiler

package OliveMod.util.handler;

import com.google.common.graph.Network;

import OliveMod.Main;
import OliveMod.init.ModBlocks;
import OliveMod.init.ModItems;
import OliveMod.util.IHasModels;
import net.minecraft.block.Block;
import net.minecraft.client.audio.SoundHandler;
import net.minecraft.item.Item;
import net.minecraftforge.client.event.ModelRegistryEvent;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.network.NetworkRegistry;

@EventBusSubscriber
public class RegistryHandlers {

    @SubscribeEvent
    public static void onItemRegister(RegistryEvent.Register<Item> event) {
        event.getRegistry().registerAll(ModItems.ITEMS.toArray(new Item[0]));

    }

    @SubscribeEvent
    public static void onBlockRegister(RegistryEvent.Register<Block> event) {
        event.getRegistry().registerAll(ModBlocks.BLOCKS.toArray(new Block[0]));
        TileEntityHandler.registerTileEntities();

    }

    @SubscribeEvent
    public static void onModelRegister(ModelRegistryEvent event) {

        for (Item item : ModItems.ITEMS) {
            if (item instanceof IHasModels) {

                ((IHasModels) item).registerModels();

            }
        }

        for (Block block : ModBlocks.BLOCKS) {
            if (block instanceof IHasModels) {

                ((IHasModels) block).registerModels();

            }
        }

    }
    
    public static void initRegistries() {
        NetworkRegistry.INSTANCE.registerGuiHandler(Main.instance, new GuiHandler());
    }
}
 

TileEntity Handler

Spoiler

package OliveMod.util.handler;

import OliveMod.machines.AlloySmelter.TileEntityAlloySmelter;
import net.minecraftforge.fml.common.registry.GameRegistry;

public class TileEntityHandler {

    public static void registerTileEntities() {
        GameRegistry.registerTileEntity(TileEntityAlloySmelter.class, "alloy_smelter");
    }
}