Hi everyone,

 

I have created a gui where I have the players inventory and a custom inventory. I have run into the problem where If I click on an item which is inside a player inventory slot I cant seem to move it to my other inventory slots (not even from one player inventory slot to the next) and Im not sure what the issue is? here is my code:

 

Gui class

 

 

@SideOnly(Side.CLIENT)
public class GuiPlayerMiney extends InventoryEffectRenderer
{
    private GuiTextField mineyDepositTextField;
    private static ContainerMiney containerMiney;
    
    private ArrayList<GuiTextField> editControls = new ArrayList<GuiTextField>();
    private static final ResourceLocation guiTexture = new ResourceLocation("custommod:textures/gui/MineyGui.png");
    private boolean wasInitialized;	
   
    private Point lastClick = new Point();
    private Rectangle guiRect = new Rectangle(0,0, 256, 256); // initialized for relative coord system so that the GUI can be resized as the screen is resized
    private Rectangle guiCoords = new Rectangle(256/2 + -88,256/2 - 83, 256, 256);
    private final Rectangle textureCoords = new Rectangle(0, 0, 256, 256);
    private static final int TEXTURE_SIZE = 256;
    
   
  	public GuiPlayerMiney(InventoryPlayer invPlayer, InventoryMiney invMiney){
	super(new ContainerMiney(invPlayer,invMiney));
      	this.wasInitialized = false;
    }

    /**
     * Adds the buttons (and other controls) to the screen in question.
     */
    @Override
    public void initGui()
    {	super.initGui();
    	  
        if(this.wasInitialized)
        	return;
        this.wasInitialized = true;
        
        //edit controls
        this.editControls.clear();
        this.mineyDepositTextField = new GuiTextField(fontRendererObj, 100, 70, 50, 12);
        this.editControls.add(mineyDepositTextField);
       
    }

    @Override
public boolean doesGuiPauseGame(){
	return false;
}
    
    @Override
    public void onGuiClosed(){ }

       
    @Override
    protected void mouseClicked(int x, int y, int event){
        super.mouseClicked(x, y, event);
        lastClick.x = x;
    	lastClick.y = y;
    	screenToRelativeCoordinates(lastClick, guiRect);
    	
        for(GuiTextField textBox : this.editControls){
        	textBox.mouseClicked(x, y, event);
        }
    }
    
   @Override
protected void keyTyped(char key, int event){
    	super.keyTyped(key, event);
    	for(GuiTextField textBox : this.editControls){
        	textBox.textboxKeyTyped(key, event);
    	}
}

          
    private void sendUpdateToSpawner(TileEntitySpawner spawner){
    	int withdrawAmount = this.getTextboxValue(this.mineyDepositTextField.getText());
    	
    }
    
    //checks the string to see if it is an integer
    private boolean validateTextboxInt(String s){
    	int val = 0;
    	try{
    		val = Integer.valueOf(s);
    	}
    	catch(NumberFormatException e){
    		return false;
    	}
    	
    	return true;
    }
    
    private int getTextboxValue(String s){
    	if(validateTextboxInt(s)){
    		return Integer.valueOf(s);
    	}
    	return 0;
    }
    
    

    @Override
protected void drawGuiContainerForegroundLayer(int p_146979_1_, int p_146979_2_){
	int fontColor = 0x404040;	//RGB value of the text color
}
    
@Override
protected void drawGuiContainerBackgroundLayer(float x, int y, int z) {

	this.mc.getTextureManager().bindTexture(guiTexture);

	this.guiRect.x = (this.width - this.guiRect.width) / 2;
  		this.guiRect.y = (this.height - this.guiRect.height) / 2;
    	this.mc.getTextureManager().bindTexture(guiTexture);	//draws the dirt background texture
    	this.drawTexturedRect(this.guiRect, guiCoords, textureCoords, this.TEXTURE_SIZE);
    	
    	final String withdraw = "Withdraw";
        this.drawString(this.fontRendererObj, withdraw, this.width/2 - 80, this.height/2 - 74, 0xFFFFFF);
        
    	final String deposit = "Deposit";
        this.drawString(this.fontRendererObj, deposit, this.width/2 - 77,  this.height/2 - 26, 0xFFFFFF);
      
        final String total = "Total Miney";
        this.drawString(this.fontRendererObj, total, this.width/2 +9, this.height/2 - 78, 0xFFFFFF);
        
        final String miney = "" + (BattlePlayerProperties.get(Minecraft.getMinecraft().thePlayer).getMineyTotal() - this.getTextboxValue(this.mineyDepositTextField.getText()));
        this.drawString(this.fontRendererObj, miney, (this.width/2 + 12) + 50/2 - this.fontRendererObj.getStringWidth(miney)/2, this.height/2 - 66, 0xFFFFFF);
      
        
        //draw edit controls
        for(GuiTextField textBox : this.editControls){
        	textBox.width = 45;
        	textBox.xPosition = this.width/2 -81;		//so it stays in the same position when gui is scaled
        	textBox.yPosition = this.height/2 -64;
        	textBox.drawTextBox();
        }


}

private void drawTexturedRect(Rectangle guiRect, Rectangle drawRect, Rectangle textureRect, int textureSize){
	double textureScale = 1.0 / textureSize;
	double z = (double) this.zLevel;

	//x, y coords of the four corners of the rectangle on the screen
	double x0, x1, y0, y1;	
	x0 = (double) drawRect.x + guiRect.x;
	y0 = (double) drawRect.y  + guiRect.y;
	x1 = (double)(drawRect.x + drawRect.width  + guiRect.x);
	y1 = (double)(drawRect.y + drawRect.height  + guiRect.y);

	//texture coordinates
	double u0, v0, u1, v1;
	u0 = textureRect.x * textureScale;
	v0 = (double) textureRect.y * textureScale;
	u1 = (double) (textureRect.x + textureRect.width) * textureScale;
	v1 = (double) (textureRect.y + textureRect.height) * textureScale;

	Tessellator tessellator = Tessellator.instance;
	tessellator.startDrawingQuads();
	tessellator.addVertexWithUV(x0, y1, z, u0, v1);	//bottom left
	tessellator.addVertexWithUV(x1, y1, z, u1, v1);	//bottom right
	tessellator.addVertexWithUV(x1, y0, z, u1, v0);	//top right
	tessellator.addVertexWithUV(x0, y0, z, u0, v0);	//top left
	tessellator.draw();
}

  protected void screenToRelativeCoordinates(Point p, Rectangle guiRect){
    	p.x -= guiRect.x;
    	p.y -= guiRect.y;
    }
}

 

 

 

Container Class

 

 

public class ContainerMiney extends Container
{   
    private final int slotCols = 9;
    private int slotRows;
private InventoryMiney inventoryMiney;

public ContainerMiney(IInventory playerInventory, InventoryMiney inventoryMiney){

		this.inventoryMiney = inventoryMiney;
        this.slotRows = inventoryMiney.getSizeInventory() / this.slotCols;
        inventoryMiney.openInventory();
        
       
        int j;
        int k;
        
        //Miney Inventory
        this.addSlotToContainer(new Slot(inventoryMiney, 0, 56 , 17));
        this.addSlotToContainer(new Slot(inventoryMiney, 1, 56 , 53));

        //player's inventory
        for (j = 0; j < 3; ++j){
            for (k = 0; k < 9; ++k){
            	this.addSlotToContainer(new Slot(playerInventory, k + j * 9 + 9, 8 + k * 18, 84 + j * 18));
            }
        }
        //player's hotbar
        for (j = 0; j < 9; ++j){
        	this.addSlotToContainer(new Slot(playerInventory, j, 8 + j * 18, 142));
        }
    }

    /**
     * Called when the container is closed.
     */
    public void onContainerClosed(EntityPlayer player)
    {
        super.onContainerClosed(player);
        this.inventoryMiney.saveInventoryToPlayer(player);
      
    }
    
    @Override
    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();

            if (par2 < this.slotRows * 9)
            {
                if (!this.mergeItemStack(itemstack1, this.slotRows * 9, this.inventorySlots.size(), true))
                {
                    return null;
                }
            }
            else if (!this.mergeItemStack(itemstack1, 0, this.slotRows * 9, false))
            {
                return null;
            }

            if (itemstack1.stackSize == 0)
            {
                slot.putStack((ItemStack)null);
            }
            else
            {
                slot.onSlotChanged();
            }
        }

        return itemstack;
    }

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

 

 

 

Inventory Class

 

 

public class InventoryMiney implements IInventory //extends InventoryBasic
{
private final int INV_SIZE = 2;
    private ItemStack[] inventory = new ItemStack[iNV_SIZE];

    public InventoryMiney(){
        //super("container.miney", false, 27);
    }

    //loads the player's PC inventory from NBT data
    public void loadInventoryFromPlayer(EntityPlayer player){
    	NBTTagCompound nbtCompound = player.getEntityData();
    	if(nbtCompound != null){
    		NBTTagList nbtTagList = nbtCompound.getTagList("custommod_Miney", 10);
    		this.loadInventoryFromNBT(nbtTagList);
    	}
    }
    
    //save the player's PC inventory to NBT
    public void saveInventoryToPlayer(EntityPlayer player){
    	NBTTagCompound nbtCompound = player.getEntityData();
    	NBTTagList nbtTagList = this.saveInventoryToNBT();
    	nbtCompound.setTag("custommod_Miney", nbtTagList);
    }
    
    //load,save to NBT copied from minecraft chest code
    public void loadInventoryFromNBT(NBTTagList par1NBTTagList)
    {
        int i;

        for (i = 0; i < this.getSizeInventory(); ++i)
        {
            this.setInventorySlotContents(i, (ItemStack)null);
        }

        for (i = 0; i < par1NBTTagList.tagCount(); ++i)
        {
            NBTTagCompound nbttagcompound = par1NBTTagList.getCompoundTagAt(i);
            int j = nbttagcompound.getByte("Slot") & 255;

            if (j >= 0 && j < this.getSizeInventory())
            {
                this.setInventorySlotContents(j, ItemStack.loadItemStackFromNBT(nbttagcompound));
            }
        }
    }

    //load,save to NBT copied from minecraft chest code
    public NBTTagList saveInventoryToNBT()
    {
        NBTTagList nbttaglist = new NBTTagList();

        for (int i = 0; i < this.getSizeInventory(); ++i)
        {
            ItemStack itemstack = this.getStackInSlot(i);

            if (itemstack != null)
            {
                NBTTagCompound nbttagcompound = new NBTTagCompound();
                nbttagcompound.setByte("Slot", (byte)i);
                itemstack.writeToNBT(nbttagcompound);
                nbttaglist.appendTag(nbttagcompound);
            }
        }
        return nbttaglist;
    }

    /**
     * Do not make give this method the name canInteractWith because it clashes with Container
     */
    @Override
    public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer){
        return true;
    }

    
    
    @Override
    public void markDirty(){
    	//if (getStackInSlot(i) != null && getStackInSlot(i).stackSize == 0)
    	//	this.inventory[i] = null;
    }

    @Override
    public void openInventory(){}
    
    @Override
    public void closeInventory(){}

@Override
public int getSizeInventory() {
	return this.INV_SIZE;
}

@Override
public ItemStack getStackInSlot(int slot) {
	return this.inventory[slot];
}

@Override
public ItemStack decrStackSize(int slot, int count) {
	if (this.inventory[slot] != null)
        {
            ItemStack itemstack;

            if (this.inventory[slot].stackSize <= count)
            {
                itemstack = this.inventory[slot];
                this.inventory[slot] = null;
                this.markDirty();
                return itemstack;
            }
            else
            {
                itemstack = this.inventory[slot].splitStack(count);

                if (this.inventory[slot].stackSize == 0){
                    this.inventory[slot] = null;
                }

                this.markDirty();
                return itemstack;
            }
        }
        else
        {
            return null;
        }
}

@Override
public ItemStack getStackInSlotOnClosing(int slot) {
	if (this.inventory[slot] != null){
            ItemStack itemstack = this.inventory[slot];
            this.inventory[slot] = null;
            return itemstack;
        }
        else{
            return null;
        }
}

@Override
public void setInventorySlotContents(int slot, ItemStack itemStack) {
	this.inventory[slot] = itemStack;

        if (itemStack != null && itemStack.stackSize > this.getInventoryStackLimit()){
        	itemStack.stackSize = this.getInventoryStackLimit();
        }

        this.markDirty();
}

@Override
public String getInventoryName() {
	return "container.miney";
}

@Override
public boolean hasCustomInventoryName() {
	return false;
}

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

@Override
public boolean isItemValidForSlot(int var1, ItemStack var2) {
	return true;
}
}

 

 

 

gui Handler class (I removed the other guis cause I have alot of them in there this is just the stuff pertaining to my custom one with the mouse issues)

 

 

public static final int PLAYER_MINEY_GUI_ID = 9;


@Override
public Object getServerGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) {
       
        if(guiId == PLAYER_MINEY_GUI_ID){
        	InventoryMiney inventoryMiney = new InventoryMiney();
        	inventoryMiney.loadInventoryFromPlayer(player);
		return new ContainerMiney(player.inventory, inventoryMiney);
	}
        return null;
}

@Override
public Object getClientGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) {		
	if (guiId == PLAYER_MINEY_GUI_ID){
        	InventoryMiney inventoryMiney = new InventoryMiney();
        	inventoryMiney.loadInventoryFromPlayer(player);
        	return new GuiPlayerMiney(player.inventory, inventoryMiney);
        }
        return null;
}	
}

[/spoiler

The entire texture is 256x256 but the drawn portion is exact same size as the furnace gui

176 X 166 pixels is the visible bit

When I click on an item it appears to be grabbed by the mouse but then immediately jumps back into the slot I grabbed it from so I cannot move it

Key is pressed

public class KeyMiney extends KeyBinding
{
private static int index= 1;	

public KeyMiney()
{
	super("key.keyMoney", Keyboard.KEY_M, "key.categories.custommod");
}

@SubscribeEvent
public void keyDown(InputEvent.KeyInputEvent event)
{
	if (isPressed())  {
		PacketOverlord.sendToServer(new PacketC2SMineyKeyPressed());
		}
}
}

 

that key press sends a packet to server which then sends a packet back to client that opens the gui

public class PacketC2SMineyKeyPressed extends AbstractMessageToServer<PacketC2SMineyKeyPressed> {
public PacketC2SMineyKeyPressed() {}

@Override
protected void read(PacketBuffer buffer) throws IOException {
}

@Override
protected void write(PacketBuffer buffer) throws IOException {
}

@Override
public void process(EntityPlayer player, Side side) {
		PacketOverlord.sendTo(new PacketS2COpenMineyGui((EntityPlayer) player, (int)player.posX, (int)player.posY, (int)player.posZ),(EntityPlayerMP) player);
}

}

 

packet that actually opens the gui client side

public class PacketS2COpenMineyGui extends AbstractMessageToClient<PacketS2COpenMineyGui> {
int xPos;
int yPos;
int zPos;

public PacketS2COpenMineyGui() {}
public PacketS2COpenMineyGui(EntityPlayer player, int xPos, int yPos, int zPos) {

	this.xPos = xPos;
	this.yPos = yPos;
	this.zPos = zPos;

}

@Override
protected void read(PacketBuffer buffer) throws IOException {
xPos = buffer.readInt();
yPos = buffer.readInt();
zPos = buffer.readInt();

}

@Override
protected void write(PacketBuffer buffer) throws IOException {
	buffer.writeInt(xPos);
	buffer.writeInt(yPos);
	buffer.writeInt(zPos);
}

@Override
public void process(EntityPlayer player, Side side) {

   if(player.worldObj.isRemote){ //player is only the client side player here using if(!player.worldObj.isRemote) does not work nothing is called

    player.openGui(CustomMod.instance, 9, player.worldObj, xPos, yPos, zPos);
   }
   }
   }

not sure why the item movement stuff is so very broken

thanks that worked