Need Help with NullPointerException

[YoWazzup]

Hello, S I'm making a new Furnace with 5 input slots, but whenever I try to open the gui of the block it crashes the game and I get this error report:

 

java.lang.NullPointerException

at net.minecraft.src.Slot.getStack(Slot.java:77)

at net.minecraft.src.GuiContainer.drawSlotInventory(GuiContainer.java:202)

at net.minecraft.src.GuiContainer.drawScreen(GuiContainer.java:72)

at net.minecraft.src.EntityRenderer.updateCameraAndRender(EntityRenderer.java:972)

at net.minecraft.client.Minecraft.runGameLoop(Minecraft.java:873)

at net.minecraft.client.Minecraft.run(Minecraft.java:750)

at java.lang.Thread.run(Unknown Source)

 

i have no idea what I'm supposed to do with that.

 

Please don't hate on me if this is a simple fix, I just can't figure it out.

 

Also, if you need code, i will give it.

[jjw123]

we need code, also paste the full crashlog

[YoWazzup]

Code:

 

Here's the code. and that was the full Error log, minus the not needed stuff.

 

  Reveal hidden contents

 

Block file:

package net.minecraft.src.CocoCraft.Blocks;

import java.util.ArrayList;
import java.util.Random;

import net.minecraft.src.*;
import net.minecraft.src.CocoCraft.Misc.GuiAlloynizer;
import net.minecraft.src.CocoCraft.Misc.TileEntityAlloynizer;
import net.minecraft.src.CocoCraft.Misc.TileEntitySilverFurnace;

public class BlockAlloynizer extends BlockContainer{


private Random rand = new Random();
private final boolean isActive;
private static boolean keepFurnaceInventory = false;

public BlockAlloynizer(int id, boolean flag)
{
	super(id, Material.rock);
	isActive = flag;
}
public boolean isOpaqueCube()
{
	return false;
}
public boolean renderAsNormalBlock()
{
	return true;
}
public void addCreativeItems(ArrayList itemList)
{
	itemList.add(new ItemStack(this));
}
    
public void onBlockAdded(World world, int x, int y, int z)
{
	super.onBlockAdded(world, x, y, z);
	this.setDefaultDirection(world, x, y, z);
}
private void setDefaultDirection(World world, int x, int y, int z)
{
	if (!world.isRemote)
	{
		int var5 = world.getBlockId(x, y, z - 1);
		int var6 = world.getBlockId(x, y, z + 1);
		int var7 = world.getBlockId(x - 1, y, z);
		int var8 = world.getBlockId(x + 1, y, z);
		byte var9 = 3;

		if(Block.opaqueCubeLookup[var5] && !Block.opaqueCubeLookup[var6])
		{
			var9 = 3;
		}
		if(Block.opaqueCubeLookup[var6] && !Block.opaqueCubeLookup[var5])
		{
			var9 = 2;
		}
		if(Block.opaqueCubeLookup[var7] && !Block.opaqueCubeLookup[var8])
		{
			var9 = 5;
		}
		if(Block.opaqueCubeLookup[var8] && !Block.opaqueCubeLookup[var7])
		{
			var9 = 4;
		}

		world.setBlockMetadataWithNotify(x, y, z, var9);
	}
}
public int getBlockTexture(IBlockAccess block, int i, int j, int k, int l)
{
	if(l == 1)
	{
		return mod_CocoCraft.AlloynizerSide;
	}
	if(l == 0)
	{
		return mod_CocoCraft.AlloynizerSide;
	}
	int i1 = block.getBlockMetadata(i, j, k);
	if(l != i1)
	{
		return mod_CocoCraft.AlloynizerSide;
	}
	else
	{
		return mod_CocoCraft.AlloynizerFront;
	}
}
    public int getBlockTextureFromSide(int side)
    {
	if (side == 3)
	{
		return mod_CocoCraft.AlloynizerFront;
	}
	else
	{
		return mod_CocoCraft.AlloynizerSide;
	}
    }
    public boolean blockActivated(World world, int x, int y, int z, EntityPlayer entityplayer)
    {
    	if(world.isRemote)
    	{
    		return true;
    	}
    	else
    	{
    		TileEntityAlloynizer tile = (TileEntityAlloynizer)world.getBlockTileEntity(x, y, z);
    		
    		if(tile != null)
    		{
    			GuiAlloynizer GUI = new GuiAlloynizer(entityplayer.inventory, tile);
    			ModLoader.openGUI(entityplayer, GUI);
    		}
    		return true;
    	}
    }
public TileEntity getBlockEntity()
{	
	return new TileEntityAlloynizer();
}
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLiving entity)
    {
        int var6 = MathHelper.floor_double((double)(entity.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

        if (var6 == 0)
        {
            world.setBlockMetadataWithNotify(x, y, z, 2);
        }

        if (var6 == 1)
        {
            world.setBlockMetadataWithNotify(x, y, z, 5);
        }

        if (var6 == 2)
        {
            world.setBlockMetadataWithNotify(x, y, z, 3);
        }

        if (var6 == 3)
        {
            world.setBlockMetadataWithNotify(x, y, z, 4);
        }
    }
public void onBlockRemoval(World world, int x, int y, int z)
    {
        if (!keepFurnaceInventory)
        {
            TileEntitySilverFurnace tile = (TileEntitySilverFurnace)world.getBlockTileEntity(x, y, z);

            if (tile != null)
            {
                for (int var6 = 0; var6 < tile.getSizeInventory(); ++var6)
                {
                    ItemStack var7 = tile.getStackInSlot(var6);

                    if (var7 != null)
                    {
                        float var8 = this.rand.nextFloat() * 0.8F + 0.1F;
                        float var9 = this.rand.nextFloat() * 0.8F + 0.1F;
                        float var10 = this.rand.nextFloat() * 0.8F + 0.1F;

                        while (var7.stackSize > 0)
                        {
                            int var11 = this.rand.nextInt(21) + 10;

                            if (var11 > var7.stackSize)
                            {
                                var11 = var7.stackSize;
                            }

                            var7.stackSize -= var11;
                            EntityItem var12 = new EntityItem(world, (double)((float)x + var8), (double)((float)y + var9), (double)((float)z + var10), new ItemStack(var7.itemID, var11, var7.getItemDamage()));

                            if (var7.hasTagCompound())
                            {
                                var12.item.setTagCompound((NBTTagCompound)var7.getTagCompound().copy());
                            }

                            float var13 = 0.05F;
                            var12.motionX = (double)((float)this.rand.nextGaussian() * var13);
                            var12.motionY = (double)((float)this.rand.nextGaussian() * var13 + 0.2F);
                            var12.motionZ = (double)((float)this.rand.nextGaussian() * var13);
                            world.spawnEntityInWorld(var12);
                        }
                    }
                }
            }
        }

        super.onBlockRemoval(world, x, y, z);
    }
}

 

TileEntity:

package net.minecraft.src.CocoCraft.Misc;

import net.minecraft.src.*;
import net.minecraft.src.forge.ISidedInventory;

public class TileEntityAlloynizer extends TileEntity implements IInventory{

private ItemStack AlloynizerItemStacks[];
public int AlloynizerBurnTime = 0;
public int currentItemBurnTime = 0;
public int AlloynizerCookTime = 0;


public TileEntityAlloynizer()
{
	AlloynizerItemStacks = new ItemStack[5];
        AlloynizerBurnTime = 0;
        currentItemBurnTime = 0;
        AlloynizerCookTime = 0;
}

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

@Override
public ItemStack getStackInSlot(int var1) 
{
	return null;
}
    

@Override
public ItemStack decrStackSize(int par1, int par2)
{
	if (this.AlloynizerItemStacks[par1] != null)
        {
            ItemStack var3;

            if (this.AlloynizerItemStacks[par1].stackSize <= par2)
            {
                var3 = this.AlloynizerItemStacks[par1];
                this.AlloynizerItemStacks[par1] = null;
                return var3;
            }
            else
            {
                var3 = this.AlloynizerItemStacks[par1].splitStack(par2);

                if (this.AlloynizerItemStacks[par1].stackSize == 0)
                {
                    this.AlloynizerItemStacks[par1] = null;
                }

                return var3;
            }
        }
        else
        {
            return null;
        }
}

@Override
public ItemStack getStackInSlotOnClosing(int par1)
    {
        if (this.AlloynizerItemStacks[par1] != null)
        {
            ItemStack var2 = this.AlloynizerItemStacks[par1];
            this.AlloynizerItemStacks[par1] = null;
            return var2;
        }
        else
        {
            return null;
        }
    }

@Override
public void setInventorySlotContents(int par1, ItemStack par2ItemStack)
    {
        this.AlloynizerItemStacks[par1] = par2ItemStack;

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

@Override
public String getInvName() 
{
	return "Alloynizer";
}
public void readFromNBT(NBTTagCompound par1NBTTagCompound)
    {
        super.readFromNBT(par1NBTTagCompound);
        NBTTagList var2 = par1NBTTagCompound.getTagList("Items");
        this.AlloynizerItemStacks = new ItemStack[this.getSizeInventory()];

        for (int var3 = 0; var3 < var2.tagCount(); ++var3)
        {
            NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3);
            byte var5 = var4.getByte("Slot");

            if (var5 >= 0 && var5 < this.AlloynizerItemStacks.length)
            {
                this.AlloynizerItemStacks[var5] = ItemStack.loadItemStackFromNBT(var4);
            }
        }

        this.AlloynizerBurnTime = par1NBTTagCompound.getShort("BurnTime");
        this.AlloynizerCookTime = par1NBTTagCompound.getShort("CookTime");
        this.currentItemBurnTime = getItemBurnTime(this.AlloynizerItemStacks[1]);
    }
 public void writeToNBT(NBTTagCompound par1NBTTagCompound)
    {
        super.writeToNBT(par1NBTTagCompound);
        par1NBTTagCompound.setShort("BurnTime", (short)this.AlloynizerBurnTime);
        par1NBTTagCompound.setShort("CookTime", (short)this.AlloynizerCookTime);
        NBTTagList var2 = new NBTTagList();

        for (int var3 = 0; var3 < this.AlloynizerItemStacks.length; ++var3)
        {
            if (this.AlloynizerItemStacks[var3] != null)
            {
                NBTTagCompound var4 = new NBTTagCompound();
                var4.setByte("Slot", (byte)var3);
                this.AlloynizerItemStacks[var3].writeToNBT(var4);
                var2.appendTag(var4);
            }
        }

        par1NBTTagCompound.setTag("Items", var2);
    }
@Override
public int getInventoryStackLimit() 
{
	return 64;
}
public int getCookProgressScaled(int par1)
    {
        return this.AlloynizerCookTime * par1 / 200;
    }
public int getBurnTimeRemainingScaled(int par1)
    {
        if (this.currentItemBurnTime == 0)
        {
            this.currentItemBurnTime = 200;
        }

        return this.AlloynizerBurnTime * par1 / this.currentItemBurnTime;
    }
public boolean isBurning()
    {
        return this.AlloynizerBurnTime > 0;
    }
public void updateEntity()
    {
        boolean var1 = this.AlloynizerBurnTime > 0;
        boolean var2 = false;

        if (this.AlloynizerBurnTime > 0)
        {
            --this.AlloynizerBurnTime;
        }

        if (!this.worldObj.isRemote)
        {
            if (this.AlloynizerBurnTime == 0 && this.canSmelt())
            {
                this.currentItemBurnTime = this.AlloynizerBurnTime = getItemBurnTime(this.AlloynizerItemStacks[1]);

                if (this.AlloynizerBurnTime > 0)
                {
                    var2 = true;

                    if (this.AlloynizerItemStacks[1] != null)
                    {
                        if (this.AlloynizerItemStacks[1].getItem().func_46056_k())
                        {
                            this.AlloynizerItemStacks[1] = new ItemStack(this.AlloynizerItemStacks[1].getItem().setFull3D());
                        }
                        else
                        {
                            --this.AlloynizerItemStacks[1].stackSize;
                        }

                        if (this.AlloynizerItemStacks[1].stackSize == 0)
                        {
                            this.AlloynizerItemStacks[1] = null;
                        }
                    }
                }
            }

            if (this.isBurning() && this.canSmelt())
            {
                ++this.AlloynizerCookTime;

                if (this.AlloynizerCookTime == 200)
                {
                    this.AlloynizerCookTime = 0;
                    this.smeltItem();
                    var2 = true;
                }
            }
            else
            {
                this.AlloynizerCookTime = 0;
            }

            if (var1 != this.AlloynizerBurnTime > 0)
            {
                var2 = true;
                
            }
        }

        if (var2)
        {
            this.onInventoryChanged();
        }
    }
 private boolean canSmelt()
    {
        ItemStack result = getRecipe(AlloynizerItemStacks[0], AlloynizerItemStacks[3], AlloynizerItemStacks[2], AlloynizerItemStacks[1], AlloynizerItemStacks[4]);
        if(result == null) return false;
        if(AlloynizerItemStacks[2] == null) return true;
        if(AlloynizerItemStacks[2] != null && AlloynizerItemStacks[2].itemID == result.itemID&& AlloynizerItemStacks[2].stackSize < (AlloynizerItemStacks[2].getMaxStackSize() - (result.stackSize-1))) 
        	return true;
        
        return false;
    }
 public void smeltItem()
    {
        if (this.canSmelt())
        {
        	ItemStack itemstack = getRecipe(AlloynizerItemStacks[0], AlloynizerItemStacks[3], AlloynizerItemStacks[2], AlloynizerItemStacks[1], AlloynizerItemStacks[4]);

            if (AlloynizerItemStacks[2] == null)
            {
                AlloynizerItemStacks[2] = itemstack.copy();
            }
            else if (AlloynizerItemStacks[2].itemID == itemstack.itemID)
            {
                AlloynizerItemStacks[2].stackSize+= itemstack.stackSize;
            }
            if(AlloynizerItemStacks[0] != null){
                    AlloynizerItemStacks[0].stackSize--;
                if (AlloynizerItemStacks[0].stackSize <= 0)
                {
                    AlloynizerItemStacks[0] = null;
                }
            }
            if(AlloynizerItemStacks[3] != null){
                    AlloynizerItemStacks[3].stackSize--;
                if (AlloynizerItemStacks[3].stackSize <= 0)
                {
                    AlloynizerItemStacks[3] = null;
                } 
                
            }
        }
 }
 private int getItemBurnTime(ItemStack itemstack)
    {
        if (itemstack == null)
        {
            return 0;
        }
        int i = itemstack.getItem().shiftedIndex;
        if (i == mod_CocoCraft.MagicDust.shiftedIndex)
        {
            return 200;
        }
        else
        {
            return 0;
        }
    }
 public boolean isUseableByPlayer(EntityPlayer entityplayer)
    {
        if (worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this)
        {
            return false;
        }
        return entityplayer.getDistanceSq((double)xCoord + 0.5D, (double)yCoord + 0.5D, (double)zCoord + 0.5D) <= 64D;
    }
@Override
public void openChest() 
{		
}
@Override
public void closeChest() 
{
}
private ItemStack getRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, ItemStack itemstack3, ItemStack itemstack4)
{
	int i1, i2, i3, i4, i5;
	if(itemstack == null) i1 = 0; else i1 = itemstack.itemID;
	if(itemstack == null) i2 = 0; else i2 = itemstack1.itemID;
	if(itemstack == null) i3 = 0; else i3 = itemstack2.itemID;
	if(itemstack == null) i4 = 0; else i4 = itemstack3.itemID;
	if(itemstack == null) i5 = 0; else i5 = itemstack4.itemID;

	if(i1 == Item.diamond.shiftedIndex && i2 == mod_CocoCraft.CocoIngot.shiftedIndex && i3 == mod_CocoCraft.AmethystGem.shiftedIndex && i4 == mod_CocoCraft.MithrilIngot.shiftedIndex && i5 == mod_CocoCraft.SilverIngot.shiftedIndex) return new ItemStack(mod_CocoCraft.Alloy, 2);																



	return null;
}










}

 

Gui:

package net.minecraft.src.CocoCraft.Misc;

import org.lwjgl.opengl.GL11;

import net.minecraft.src.*;
import net.minecraft.src.CocoCraft.Misc.TileEntityAlloynizer;

public class GuiAlloynizer extends GuiContainer{

public TileEntityAlloynizer furnaceInventory;

public GuiAlloynizer(InventoryPlayer inventoryPlayer, TileEntityAlloynizer tile)
{
	super(new ContainerAlloynizer(inventoryPlayer, tile));
	furnaceInventory = tile;
}
protected void drawGuiForeGroundLayer()
{
	fontRenderer.drawString("Alloynizer", 60, 6, 0x404040);
	fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040);
}
protected void drawGuiContainerBackgroundLayer(float f, int i, int j)
{
	int k = mc.renderEngine.getTexture("/CC/Gui/Alloynizer.png");
	GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
	mc.renderEngine.bindTexture(k);
	int l = (width - xSize) / 2;
	int i1 = (height - ySize) / 2;
	drawTexturedModalRect(l, i1, 0, 0, xSize, ySize);

	if (furnaceInventory.isBurning())
        {
            int j1 = furnaceInventory.getBurnTimeRemainingScaled(12);
            drawTexturedModalRect(l + 9, (i1 + 63 + 12) - j1, 176, 12 - j1, 14, j1 + 2);
        }
        int k1 = furnaceInventory.getCookProgressScaled(24);
        drawTexturedModalRect(l + 79, i1 + 34, 176, 14, k1 + 1, 16);
}


}

 

Slot:

package net.minecraft.src.CocoCraft.Misc;

import net.minecraft.src.*;

public class SlotAlloynizer extends Slot 
{
    
    private EntityPlayer thePlayer;
    private int field_48437_f;

    public SlotAlloynizer(EntityPlayer par1EntityPlayer, IInventory par2IInventory, int par3, int par4, int par5)
    {
        super(par2IInventory, par3, par4, par5);
        this.thePlayer = par1EntityPlayer;
    }
    public boolean isItemValid(ItemStack par1ItemStack)
    {
        return false;
    }
    public ItemStack decrStackSize(int par1)
    {
        if (this.getHasStack())
        {
            this.field_48437_f += Math.min(par1, getStack().stackSize);
        }

        return super.decrStackSize(par1);
    }
    
    
    public void onPickupFromSlot(ItemStack par1ItemStack)
    {
        this.func_48434_c(par1ItemStack);
        super.onPickupFromSlot(par1ItemStack);
    }

    protected void func_48435_a(ItemStack par1ItemStack, int par2)
    {
        this.field_48437_f += par2;
        this.func_48434_c(par1ItemStack);
    }
}

 

Container:

package net.minecraft.src.CocoCraft.Misc;

import net.minecraft.src.*;

public class ContainerAlloynizer extends Container{

private TileEntityAlloynizer alloynizer;
private int lastCookTime;
private int lastBurnTime;
private int lastItemBurnTime;
private final int slotIndex;

public ContainerAlloynizer(InventoryPlayer inventoryplayer, TileEntityAlloynizer tile)
{
	lastCookTime = 0;
	lastBurnTime = 0;
	lastItemBurnTime = 0;
	slotIndex = 0;
	tile = alloynizer;
	addSlot(new Slot(tile, 0, 11, 17));//input 1
	addSlot(new Slot(tile, 1, 33, 17));//input 2
	addSlot(new Slot(tile, 3, 56, 17));//input 3
	addSlot(new Slot(tile, 4, 22, 36));//input 4
	addSlot(new Slot(tile, 5, 44, 36));//input 5

	addSlot(new Slot(tile, 2, 116, 35));//output
	addSlot(new Slot(tile, 6, 45, 53));//fuel input

	for(int i = 0; i < 3; i++)
	{
		for(int k = 0; k < 9; k++)
		{
			addSlot(new Slot(inventoryplayer, k + i * 9 + 9, 8 + k * 18, 84 + i * 18));
		}
	}
	for(int j = 0; j < 9; j++)
	{
		addSlot(new Slot(inventoryplayer, j, 8 + j * 18, 142));
	}
}
public void updateCraftingResult()
{
	super.updateCraftingResults();
	for(int i = 0; i < crafters.size(); i++)
	{
		ICrafting icrafting = (ICrafting)crafters.get(i);
		if (lastCookTime != alloynizer.AlloynizerCookTime)
            {
                icrafting.updateCraftingInventoryInfo(this, 0, alloynizer.AlloynizerCookTime);
            }
            if (lastBurnTime != alloynizer.AlloynizerBurnTime)
            {
                icrafting.updateCraftingInventoryInfo(this, 1, alloynizer.AlloynizerBurnTime);
            }
            if (lastItemBurnTime != alloynizer.currentItemBurnTime)
            {
                icrafting.updateCraftingInventoryInfo(this, 2, alloynizer.currentItemBurnTime);
            }
        }

        lastCookTime = alloynizer.AlloynizerCookTime;
        lastBurnTime = alloynizer.AlloynizerBurnTime;
        lastItemBurnTime = alloynizer.currentItemBurnTime;
    
}
public void updateProgressBar(int i, int j)
{
	if(i == 0)
	{
		alloynizer.AlloynizerCookTime = j;
	}
	if (i == 1)
	{
		alloynizer.AlloynizerBurnTime = j;
	}
	if(i == 2)
	{
		alloynizer.currentItemBurnTime = j;
	}
}

public ItemStack transferStackInSlot(int i)
    {
        ItemStack itemstack = null;
        Slot slot = (Slot)inventorySlots.get(i);
        if (slot != null && slot.getHasStack())
        {
            ItemStack itemstack1 = slot.getStack();
            itemstack = itemstack1.copy();
            if (i == 2)
            {
                if (!mergeItemStack(itemstack1, 3, 39, true))
                {
                    return null;
                }
            }
            else if (i >= 3 && i < 30)
            {
                if (!mergeItemStack(itemstack1, 30, 39, false))
                {
                    return null;
                }
            }
            else if (i >= 30 && i < 39)
            {
                if (!mergeItemStack(itemstack1, 3, 30, false))
                {
                    return null;
                }
            }
            else if (!mergeItemStack(itemstack1, 3, 39, false))
            {
                return null;
            }
            if (itemstack1.stackSize == 0)
            {
                slot.putStack(null);
            }
            else
            {
                slot.onSlotChanged();
            }
            if (itemstack1.stackSize != itemstack.stackSize)
            {
                slot.onPickupFromSlot(itemstack1);
            }
            else
            {
                return null;
            }
        }
        return itemstack;
    }
@Override
public boolean canInteractWith(EntityPlayer var1) 
{
	return true;
}








}

 

 

[LexManos]

Somehow, you're having a different Slot class then I.

But it looks like somehow the slot inventory is null.

Figure out how you created a clot with a null inventory.

[YoWazzup]

  On 7/9/2012 at 8:58 PM, LexManos said:

Somehow, you're having a different Slot class then I.

But it looks like somehow the slot inventory is null.

Figure out how you created a clot with a null inventory.

 

hmm, seems legit, but I can't figure out where, though.....

[atrain99]

Put a system.out.println() after every line.

PS, the exception occured around line 77.