Jump to content
View in the app

A better way to browse. Learn more.
Forge Forums

A full-screen app on your home screen with push notifications, badges and more.

To install this app on iOS and iPadOS
  1. Tap the Share icon in Safari
  2. Scroll the menu and tap Add to Home Screen.
  3. Tap Add in the top-right corner.
To install this app on Android
  1. Tap the 3-dot menu (⋮) in the top-right corner of the browser.
  2. Tap Add to Home screen or Install app.
  3. Confirm by tapping Install.
Search the Forums BEFORE making a new post.
Currently supported: All versions

Block doesn't open GUI

dyno
in Modder Support

Featured Replies

Posted

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");
    }
}
 

 

Guest
This topic is now closed to further replies.
Go to topic listing

Important Information

By using this site, you agree to our Terms of Use.

I accept

Configure browser push notifications
Chrome (Android)
  1. Tap the lock icon next to the address bar.
  2. Tap Permissions → Notifications.
  3. Adjust your preference.
Chrome (Desktop)
  1. Click the padlock icon in the address bar.
  2. Select Site settings.
  3. Find Notifications and adjust your preference.