[1.7.10][Unsolved][Help really needed!]Item duplicating in custom inventory

[Enginecrafter]

I am creating a block with inventory. It is nearly complete, but there is little bug. When I shift-click on item to move it to block's inventory it moves fine, but when I move it from block's inventory to my(Player's) invenotry, it duplicates.

 

Here is my code:

 

 

 

Block:

package com.ec.blocks;

import com.ec.Main.MainRegistry;
import com.ec.Main.TabTMPI;
import com.ec.handler.GuiHandler;
import com.ec.lib.RefStrings;
import com.ec.screen.ScreenTrialInventory;
import com.ec.tileentity.TileEntityTrialInventory;

import cpw.mods.fml.common.registry.GameRegistry;

import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;

public class BlockTrialInventory extends BlockContainer{

protected BlockTrialInventory()
{
	super(Material.glass);
	this.setCreativeTab(TabTMPI.tab);
	this.setBlockTextureName(RefStrings.MODID + ":BlockPlacer");
	this.setBlockName("blockTrialInventory");
}

public static Block block;

public static void mainRegistry()
{
	block = new BlockTrialInventory();
	GameRegistry.registerBlock(block, block.getUnlocalizedName());
}

@Override
public TileEntity createNewTileEntity(World world, int metadata)
{
	return new TileEntityTrialInventory();
}

@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int metadata, float what, float these, float are)
{
	TileEntityTrialInventory tileEntity = (TileEntityTrialInventory) world.getTileEntity(x, y, z);
	player.openGui(MainRegistry.instance, 0, world, x, y, z);
	return true;
}

}

 

TileEntity:(The TileEntityInventoryBase is only because tileEntity that is implementing IInventory is so hard to create. I extended it in this class.)

package com.ec.tileentity;

public class TileEntityTrialInventory extends TileEntityInventoryBase
{
@Override
public String getInvName()
{
	return "TileEntityTrialInventory";
}

@Override
public int getMaxStackLimit()
{
	return 64;
}

@Override
public int getInvSize()
{
	return 1;
}
}

 

TileEntityInventoryBase:

package com.ec.tileentity;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.Constants;

public class TileEntityInventoryBase extends TileEntity implements IInventory {
        
        public int invSize = getInvSize(); 
        public int invMaxStackLimit = getMaxStackLimit();
        public boolean isUseableByPlayer = getIfIsUseableByPlayer();
	public String invName;
	public ItemStack[] inv = new ItemStack[invSize];

        @Override
        public int getSizeInventory() {
                return invSize;
        }

        public int getInvSize()
        {
		return 1;
	}
        
        public int getMaxStackLimit()
        {
        	return 64;
        }
        
        public boolean getIfIsUseableByPlayer()
        {
        	return true;
        }
        
        public String getInvName()
        {
        	return null;
        }

	@Override
        public ItemStack getStackInSlot(int slot) {
                return inv[slot];
        }
        
        @Override
        public void setInventorySlotContents(int slot, ItemStack stack) {
                inv[slot] = stack;
                if (stack != null && stack.stackSize > getInventoryStackLimit()) {
                        stack.stackSize = getInventoryStackLimit();
                }               
        }

        @Override
        public ItemStack decrStackSize(int slot, int amt) {
                ItemStack stack = getStackInSlot(slot);
                if (stack != null) {
                        if (stack.stackSize <= amt) {
                                setInventorySlotContents(slot, null);
                        } else {
                                stack = stack.splitStack(amt);
                                if (stack.stackSize == 0) {
                                        setInventorySlotContents(slot, null);
                                }
                        }
                }
                return stack;
        }

        @Override
        public ItemStack getStackInSlotOnClosing(int slot) {
                ItemStack stack = getStackInSlot(slot);
                if (stack != null) {
                        setInventorySlotContents(slot, null);
                }
                return stack;
        }
        
        @Override
        public int getInventoryStackLimit() {
                return invMaxStackLimit;
        }

        @Override
        public boolean isUseableByPlayer(EntityPlayer player) {
                return isUseableByPlayer;
        }
        
        @Override
        public void readFromNBT(NBTTagCompound nbttagcompound)
        {
        	NBTTagList nbttaglist = nbttagcompound.getTagList("Items", Constants.NBT.TAG_COMPOUND);
            inv = new ItemStack[getSizeInventory()];
            for (int i = 0; i < nbttaglist.tagCount(); i++)
            {
                NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
                int j = nbttagcompound1.getByte("Slot") & 0xff;
                if (j >= 0 && j < inv.length)
                {
                    inv[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
                }
            }
            super.readFromNBT(nbttagcompound);
        }

        @Override
        public void writeToNBT(NBTTagCompound tagCompound)
        {
        	super.writeToNBT(tagCompound);
        	NBTTagList nbttaglist = new NBTTagList();
        	for (int i = 0; i < inv.length; i++)
        	{
        		if (inv[i] != null)
        		{
        			NBTTagCompound nbttagcompound1 = new NBTTagCompound();
        			nbttagcompound1.setByte("Slot", (byte) i);
        			inv[i].writeToNBT(nbttagcompound1);
        			nbttaglist.appendTag(nbttagcompound1);
        		}
        	}

        	tagCompound.setTag("Items", nbttaglist);
        }

			@Override
			public String getInventoryName()
			{
				return invName;
			}

			@Override
			public boolean hasCustomInventoryName()
			{
				boolean has = true;
				if(invName == null)
				{
					has = false;
				}
				return has;
			}

			@Override
			public void openInventory(){}

			@Override
			public void closeInventory(){}

			@Override
			public boolean isItemValidForSlot(int slot, ItemStack item)
			{
				return true;
			}
}

 

GuiContainer:

package com.ec.screen;

import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StatCollector;

import org.lwjgl.opengl.GL11;

import com.ec.container.ContainerTrialInventory;
import com.ec.lib.RefStrings;
import com.ec.tileentity.TileEntityTrialInventory;

public class ScreenTrialInventory extends GuiContainer {

	ResourceLocation texture = new ResourceLocation(RefStrings.MODID, "textures/gui/ScreenPlacer.png");
	private int screenWidth = 194;
	private int screenHeight = 168;

        public ScreenTrialInventory (InventoryPlayer inventoryPlayer, TileEntityTrialInventory tileEntity)
        {
                super(new ContainerTrialInventory(inventoryPlayer, tileEntity));
        }

        @Override
        protected void drawGuiContainerForegroundLayer(int param1, int param2)
        {
                fontRendererObj.drawString("Tiny", 8, 6, 4210752);
                fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, ySize - 96 + 2, 4210752);
        }

        @Override
        protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
        {
        	int screenX = (width - screenWidth ) / 2;
    		int screenY = (height - screenHeight) / 2;
    		
    		GL11.glColor4f(1, 1, 1, 1);
    		drawDefaultBackground();
    		
    		mc.renderEngine.bindTexture(texture);
    		drawTexturedModalRect(screenX, screenY, 0, 0, screenWidth, screenHeight);
        }

}

 

GuiHandler:

package com.ec.handler;

import com.ec.container.ContainerTrialInventory;
import com.ec.screen.ScreenTrialInventory;
import com.ec.tileentity.TileEntityTrialInventory;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.World;
import cpw.mods.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)
{
	TileEntityTrialInventory trialInventory = (TileEntityTrialInventory)world.getTileEntity(x, y, z);
	if(trialInventory instanceof TileEntityTrialInventory)
	{
		return new ContainerTrialInventory(player.inventory, (TileEntityTrialInventory)trialInventory);
	}
	return null;
}

@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world,	int x, int y, int z)
{
	TileEntityTrialInventory trialInventory = (TileEntityTrialInventory)world.getTileEntity(x, y, z);
	if(trialInventory instanceof TileEntityTrialInventory)
	{
		return new ScreenTrialInventory(player.inventory, trialInventory);
	}
	return null;
}

}

 

Container:

package com.ec.container;

import com.ec.tileentity.TileEntityTrialInventory;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;

public class ContainerTrialInventory extends Container {

        protected TileEntityTrialInventory tileEntity;

        public ContainerTrialInventory (InventoryPlayer inventoryPlayer, TileEntityTrialInventory te){
                tileEntity = te;
                /*for (int i = 0; i < 1; i++) {
                        for (int j = 0; j < 1; j++)
                        {
                                addSlotToContainer(new Slot(tileEntity, j + i * 3, 62 + j * 18, 17 + i * 18));
                        }
                }*/
                
                addSlotToContainer(new Slot(tileEntity, 0, 93, 35));
                bindPlayerInventory(inventoryPlayer);
        }

        @Override
        public boolean canInteractWith(EntityPlayer player)
        {
                return true;
        }


        protected void bindPlayerInventory(InventoryPlayer inventoryPlayer) {
                for (int i = 0; i < 3; i++) {
                        for (int j = 0; j < 9; j++) {
                                addSlotToContainer(new Slot(inventoryPlayer, j + i * 9 + 9, 8 + j * 18, 85 + i * 18));
                        }
                }

                for (int i = 0; i < 9; i++) {
                        addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 142));
                }
        }

        @Override
        public ItemStack transferStackInSlot(EntityPlayer player, int slot) {
                ItemStack stack = null;
                Slot slotObject = (Slot)inventorySlots.get(slot);
                
                if (slotObject != null && slotObject.getHasStack()) {
                        ItemStack stackInSlot = slotObject.getStack();
                        stack = stackInSlot.copy();
                        
                        if (slot < 9)
                        {
                                if (!this.mergeItemStack(stackInSlot, 0, 35, true)) {
                                        return null;
                                }
                        }
                        
                        else if (!this.mergeItemStack(stackInSlot, 0, 9, false)) {
                                return null;
                        }

                        if (stackInSlot.stackSize == 0) {
                                slotObject.putStack(null);
                        } else {
                                slotObject.onSlotChanged();
                        }

                        if (stackInSlot.stackSize == stack.stackSize) {
                                return null;
                        }
                        slotObject.onPickupFromSlot(player, stackInSlot);
                }
                return stack;
        }
}