[1.6.4]Inventory Item Issue

[Mecblader]

Hello, I have a custom furnace were the gui does not not rely on the block or a Tile Entity, similar to the way that the Crafting Table is coded, but I have a strange bug, it smelts the item fine and appears to delete what is in the first slot but when you click on the slot a item just appears and can bee smelted again. I have made sure that I am deleting what is in the first slot, but it does not seem to work. I am pretty sure that the handling of inventories and this sort of stuff is done on the server side and I do believe that is being called on the server side because I have my tick handler handle the updating of the inventory. I would appreciate any help that anyone can give because I have had this bug for a week and I have spent hours upon hours to try and figure it out, but I can't seem to figure it out.

 

(Note Code May Be Messy Due To Testing and Lazyness)

 

Inventory Code

 

package mod.xtronius.rc_mod.inventory;

 

import mod.xtronius.rc_mod.rc_mod;

import mod.xtronius.rc_mod.container.Furnace1Container;

import mod.xtronius.rc_mod.furnaceRecipies.RCCastFurnace1Recipes;

import mod.xtronius.rc_mod.furnaceRecipies.RCIngotFurnace1Recipes;

import mod.xtronius.rc_mod.handlers.ServerTickHandler;

import net.minecraft.entity.Entity;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.entity.player.EntityPlayerMP;

import net.minecraft.inventory.Container;

import net.minecraft.inventory.IInventory;

import net.minecraft.item.Item;

import net.minecraft.item.ItemStack;

import net.minecraft.item.crafting.FurnaceRecipes;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.nbt.NBTTagList;

import net.minecraft.world.World;

import net.minecraftforge.common.IExtendedEntityProperties;

 

public class InvFurnace1 implements IExtendedEntityProperties ,  IInventory

{

 

private Furnace1Container eventHandler;

 

private static final int[] slots_side_left= new int[] {0};

    private static final int[] slots_mid = new int[] {1};

    private static final int[] slots_side_right = new int[] {2};

   

    private ServerTickHandler tick = rc_mod.proxy.getServerTickHandler();

   

    private ItemStack[] furnaceItemStacks = new ItemStack[3];

   

public InvFurnace1(Container container, World world, EntityPlayer player, int x, int y, int z) {

 

tick.furnace1ContainerMap.put(player, (Furnace1Container) container);

this.eventHandler = (Furnace1Container) container;

}

 

/**

    * Returns the number of slots in the inventory.

    */

    public int getSizeInventory()

    {

        return this.furnaceItemStacks.length;

    }

 

    /**

    * Returns the stack in slot i

    */

    public ItemStack getStackInSlot(int par1)

    {

        return par1 >= this.getSizeInventory() ? null : this.furnaceItemStacks[par1];

    }

 

    /**

    * Returns the name of the inventory.

    */

    public String getInvName()

    {

        return "container.furnace";

    }

 

    /**

    * If this returns false, the inventory name will be used as an unlocalized name, and translated into the player's

    * language. Otherwise it will be used directly.

    */

    public boolean isInvNameLocalized()

    {

        return false;

    }

 

    /**

    * When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem -

    * like when you close a workbench GUI.

    */

    public ItemStack getStackInSlotOnClosing(int par1)

    {

        if (this.furnaceItemStacks[par1] != null)

        {

            ItemStack itemstack = this.furnaceItemStacks[par1];

            this.furnaceItemStacks[par1] = null;

            return itemstack;

        }

        else

        {

            return null;

        }

    }

 

    /**

    * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a

    * new stack.

    */

    public ItemStack decrStackSize(int par1, int par2)

    {

        if (this.furnaceItemStacks[par1] != null)

        {

            ItemStack itemstack;

 

            if (this.furnaceItemStacks[par1].stackSize <= par2)

            {

                itemstack = this.furnaceItemStacks[par1];

                this.furnaceItemStacks[par1] = null;

                this.eventHandler.onCraftMatrixChanged(this);

                return itemstack;

            }

            else

            {

                itemstack = this.furnaceItemStacks[par1].splitStack(par2);

 

                if (this.furnaceItemStacks[par1].stackSize == 0)

                {

                    this.furnaceItemStacks[par1] = null;

                }

 

                this.eventHandler.onCraftMatrixChanged(this);

                return itemstack;

            }

        }

        else

        {

            return null;

        }

    }

 

    /**

    * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).

    */

    public void setInventorySlotContents(int par1, ItemStack par2ItemStack)

    {

        this.furnaceItemStacks[par1] = par2ItemStack;

        this.eventHandler.onCraftMatrixChanged(this);

    }

 

    /**

    * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't

    * this more of a set than a get?*

    */

    public int getInventoryStackLimit()

    {

        return 1;

    }

 

    /**

    * Called when an the contents of an Inventory change, usually

    */

    public void onInventoryChanged() {}

 

    /**

    * Do not make give this method the name canInteractWith because it clashes with Container

    */

    public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)

    {

        return true;

    }

 

    public void openChest() {}

 

    public void closeChest() {}

 

    /**

    * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot.

    */

    public boolean isItemValidForSlot(int par1, ItemStack par2ItemStack)

    {

        return true;

    }

 

@Override

public void saveNBTData(NBTTagCompound compound) {

 

}

 

@Override

public void loadNBTData(NBTTagCompound compound) {

 

}

 

@Override

public void init(Entity entity, World world) {

 

}

}

 

 

Container Code

 

//TODO I just statrted converting the classes to have a better stucture, basically I need the container to handle all of the smelting because it is server side and ther inv needs to be clutter free and there was no definitive way to tell if the client or the server was calling the methods

 

 

package mod.xtronius.rc_mod.container;

 

import mod.xtronius.rc_mod.furnaceRecipies.RCCastFurnace1Recipes;

import mod.xtronius.rc_mod.furnaceRecipies.RCIngotFurnace1Recipes;

import mod.xtronius.rc_mod.inventory.InvFurnace1;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.entity.player.EntityPlayerMP;

import net.minecraft.entity.player.InventoryPlayer;

import net.minecraft.inventory.Container;

import net.minecraft.inventory.ICrafting;

import net.minecraft.inventory.Slot;

import net.minecraft.item.Item;

import net.minecraft.item.ItemStack;

import net.minecraft.item.crafting.FurnaceRecipes;

import net.minecraft.world.World;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class Furnace1Container extends Container

{

private InvFurnace1 invFurnace;

public int furnaceCookTime;

    private int lastCookTime;

    private World worldObj;

    private int xPos;

    private int yPos;

    private int zPos;

   

    private Item itemToBeSmelted;

    private boolean hasItemBeenSmelted = false;

   

    public static final int SMELT_INGOT = 0;

    public static final int SMELT_CAST = 1;

    public static int  SMELT_TYPE;

 

    public Furnace1Container(InventoryPlayer playerInv, World world, int x, int y, int z)

    {

    this.invFurnace = new InvFurnace1(this, world, playerInv.player, x, y, z);

   

    this.worldObj = world;

    this.xPos = x;

    this.yPos = y;

    this.xPos = z;

   

        this.addSlotToContainer(new Slot(this.invFurnace, 0, 60, 110));

        this.addSlotToContainer(new Slot(this.invFurnace, 1, 88, 110));

      // this.addSlotToContainer(new SlotFurnace1(playerInv.player, inv, 2, 156, 110));

       

        byte b0 = 36;

        short short1 = 137;

        int i;

 

        for (i = 0; i < 3; ++i)

        {

            for (int j = 0; j < 9; ++j)

            {

                this.addSlotToContainer(new Slot(playerInv, j + i * 9 + 9, b0 + j * 18, short1 + i * 18));

            }

        }

 

        for (i = 0; i < 9; ++i)

        {

            this.addSlotToContainer(new Slot(playerInv, i, b0 + i * 18, 58 + short1));

        }

    }

    public Item getItemToBeSmelted() {

if(this.itemToBeSmelted != null)

return itemToBeSmelted;

else return Item.arrow;

}

 

public void setItemToBeSmelted(Item item) {

if(item != null)

this.itemToBeSmelted = item;

}

    public InvFurnace1 getInv() {

    return this.invFurnace;

    }

 

    public void addCraftingToCrafters(ICrafting par1ICrafting)

    {

        super.addCraftingToCrafters(par1ICrafting);

        par1ICrafting.sendProgressBarUpdate(this, 0, this.furnaceCookTime);

    }

 

    /**

    * Looks for changes made in the container, sends them to every listener.

    */

    public void detectAndSendChanges()

    {

        super.detectAndSendChanges();

 

        for (int i = 0; i < this.crafters.size(); ++i)

        {

            ICrafting icrafting = (ICrafting)this.crafters.get(i);

 

            if (this.lastCookTime != this.furnaceCookTime)

            {

                icrafting.sendProgressBarUpdate(this, 0, this.furnaceCookTime);

            }

        }

 

        this.lastCookTime = this.furnaceCookTime;

    }

 

    @SideOnly(Side.CLIENT)

    public void updateProgressBar(int par1, int par2)

    {

        if (par1 == 0)

        {

            this.furnaceCookTime = par2;

        }

    }

 

    public boolean canInteractWith(EntityPlayer par1EntityPlayer)

    {

        return this.invFurnace.isUseableByPlayer(par1EntityPlayer);

    }

   

    public void onContainerClosed(EntityPlayer player)

    {

        super.onContainerClosed(player);

 

        if (!player.worldObj.isRemote)

        {

            for (int i = 0; i < 3; ++i)

            {

                ItemStack itemstack = this.invFurnace.getStackInSlotOnClosing(i);

 

                if (itemstack != null)

                {

                    player.dropPlayerItem(itemstack);

                }

            }

        }

    }

 

    /**

    * Called when a player shift-clicks on a slot. You must override this or you will crash when someone does that.

    */

    public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2)

    {

        ItemStack itemstack = null;

        Slot slot = (Slot)this.inventorySlots.get(par2);

 

        if (slot == null && !slot.getHasStack())

        {

            ItemStack itemstack1 = slot.getStack();

            itemstack = itemstack1.copy();

            return null;

        }

        return null;

    }

   

    public boolean hasStackInSlots() {

 

for (int i = 0; i < 3; i++) {

if(this.invFurnace.getStackInSlot(i) != null) {

return true;

}

}

return false;

}

   

    public int getCookProgressScaled(int par1)

    {

        return this.furnaceCookTime * par1 / 200;

    }

   

    private boolean canSmelt()

    {

        if (this.invFurnace.getStackInSlot(0) == null)

        {

            return false;

        }

        else

        {

        ItemStack itemstack = RCIngotFurnace1Recipes.smelting().getSmeltingResult(this.invFurnace.getStackInSlot(0));

    ItemStack itemstack2 = RCCastFurnace1Recipes.smelting().getSmeltingResult(this.invFurnace.getStackInSlot(1));

       

        if (this.invFurnace.getStackInSlot(0) != null && this.invFurnace.getStackInSlot(1) == null) {

        SMELT_TYPE = SMELT_INGOT;

        }

       

        if (this.invFurnace.getStackInSlot(0) != null && this.invFurnace.getStackInSlot(1) != null) {

        SMELT_TYPE = SMELT_CAST;

        }

 

        if (SMELT_TYPE == SMELT_INGOT) {

        if (itemstack != null) {

                if (this.invFurnace.getStackInSlot(2) != null && this.invFurnace.getStackInSlot(2).isItemEqual(itemstack)) {

                int result = this.invFurnace.getStackInSlot(2).stackSize + itemstack.stackSize;

                return (result <= this.invFurnace.getInventoryStackLimit() && result <= itemstack.getMaxStackSize());

                } else if(this.invFurnace.getStackInSlot(2) == null){

                return true;

                }

        }

        }

        else if (SMELT_TYPE == SMELT_CAST) {

       

        if(itemstack != null && itemstack2 != null) {

       

        if(itemstack == itemstack2) {

        if (this.invFurnace.getStackInSlot(2) == null) return true;

                    if (!this.invFurnace.getStackInSlot(2).isItemEqual(itemstack)) return false;

                    int result = this.invFurnace.getStackInSlot(2).stackSize + itemstack.stackSize;

                    return (result <= this.invFurnace.getInventoryStackLimit() && result <= itemstack.getMaxStackSize());

            }

            else if(itemstack != itemstack){

            if (this.invFurnace.getStackInSlot(2) == null) return true;

                        if (!this.invFurnace.getStackInSlot(2).isItemEqual(itemstack)) return false;

                        int result = this.invFurnace.getStackInSlot(20).stackSize + itemstack.stackSize;

                        return (result <= this.invFurnace.getInventoryStackLimit() && result <= itemstack.getMaxStackSize());

            }

        }

        }

        }

return false;

    }

 

    public void smeltItem(EntityPlayer player)

    {

    System.out.println(player.username);

        if (this.canSmelt())

        {

            ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.invFurnace.getStackInSlotOnClosing(0));

 

            this.setItemToBeSmelted(itemstack.getItem());

           

//            if (this.furnaceItemStacks[2] == null)

//            {

//                this.furnaceItemStacks[2] = itemstack.copy();

//            }

//            else if (this.furnaceItemStacks[2].isItemEqual(itemstack))

//            {

//                furnaceItemStacks[2].stackSize += itemstack.stackSize;

//            }

           

            if(!(player.inventory.getFirstEmptyStack() < 0)) {

            if(player != null && player.inventory != null && player.inventory.getStackInSlot(player.inventory.getFirstEmptyStack()) == null) {

                player.inventory.addItemStackToInventory(itemstack.copy());

                System.out.println("Num: 1");

                this.invFurnace.setInventorySlotContents(0, null);

                this.onCraftMatrixChanged(this.invFurnace);

            }

            else {

            this.invFurnace.setInventorySlotContents(2, itemstack.copy());

            System.out.println("Num: 2");

            this.onCraftMatrixChanged(this.invFurnace);

            }

            }

            else if (player.inventory.getFirstEmptyStack() < 0) {

            if(this.invFurnace.getStackInSlot(2) == null) {

            this.invFurnace.setInventorySlotContents(2, itemstack.copy());

            System.out.println("Num: 3");

            this.onCraftMatrixChanged(this.invFurnace);

            }

            }

        }

    }

   

    public void update(EntityPlayerMP player) {

if(this.invFurnace.getStackInSlot(2) != null && !(player.inventory.getFirstEmptyStack() < 0)) {

if(player != null && player.inventory != null && player.inventory.getStackInSlot(player.inventory.getFirstEmptyStack()) == null) {

player.inventory.addItemStackToInventory(this.invFurnace.getStackInSlot(2).copy());

this.invFurnace.setInventorySlotContents(2, null);

}

        }

        boolean flag = false;

 

            if (this.canSmelt())

            {

                ++this.furnaceCookTime;

 

                if (this.furnaceCookTime == 5)

                {

                    this.furnaceCookTime = 0;

                    this.smeltItem(player);

                    flag = true;

                }

            }

            else

                this.furnaceCookTime = 0;

           

            if(flag)

            this.hasItemBeenSmelted = true;

        }

}

 

 

 

Tick handler

 

package mod.xtronius.rc_mod.handlers;

 

import java.util.EnumSet;

import java.util.HashMap;

 

import mod.xtronius.rc_mod.commands.Tutorial;

import mod.xtronius.rc_mod.container.Furnace1Container;

import mod.xtronius.rc_mod.inventory.InvFurnace1;

import mod.xtronius.rc_mod.util.RCPlayer;

import mod.xtronius.rc_mod.util.event.EventBlockReplace;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.entity.player.EntityPlayerMP;

import cpw.mods.fml.common.ITickHandler;

import cpw.mods.fml.common.TickType;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class ServerTickHandler implements ITickHandler {

 

public static HashMap<EntityPlayer, Furnace1Container> furnace1ContainerMap = new HashMap<EntityPlayer, Furnace1Container>();

 

@Override

public void tickStart(EnumSet<TickType> type, Object... tickData) {

 

if (type.equals(EnumSet.of(TickType.PLAYER))) {

onEntityPlayerTick((EntityPlayer) tickData[0]);

onEntityPlayerMPTick((EntityPlayerMP) tickData[0]);

}

}

 

@Override

public void tickEnd(EnumSet<TickType> type, Object... tickData) {

}

 

@Override

public EnumSet<TickType> ticks() {

 

return EnumSet.of(TickType.PLAYER, TickType.SERVER, TickType.CLIENT);

}

 

@Override

public String getLabel() {

return null;

}

 

private void onEntityPlayerTick(EntityPlayer player) {

 

managePlayerXP(player);

}

 

private void tickFurnace1(EntityPlayerMP player) {

 

if(furnace1ContainerMap.get(player) != null) {

Furnace1Container container = furnace1ContainerMap.get(player);

if(container.hasStackInSlots()) {

container.update(player);

System.out.println("ticking");

}

}

}

 

 

 

private void onEntityPlayerMPTick(EntityPlayerMP player) {

 

if(!player.worldObj.isRemote) {

tickFurnace1(player);

}

}

 

 

 

I think that is all the code that is needed, but please ask if you need more!

 

Thank You!!!

 

[Mecblader]

Can some one please help me with my problem?

[delemberen12]

you put >= instead of <= in public ItemStack getStackInSlot

[Mecblader]

I don't think that that is the solution because I got the inv. code from the crafting table and that is what it had in the the class. Plus I tested it and it was returning null all the time because the slot number would always be less than 2, which is the number of slots, and that made it return null all of the time.

[Mecblader]

Does anyone have any other solutions that can work for my problem. I would really appreciate the help.

[MoxEmerald]

Sounds like the item is only being removed on the server side. If the client side thinks there is an item you'll still be able to retrieve it.