I'm trying to setup my machine to have an faster speed when a different fuel/item is given. Wouldn't I do an ItemStack comparison between the slots and the item I wish to compare. When I try it just gives me a null pointer. Here is my setup

package bigbaddevil7.supernova.tileentity;

import bigbaddevil7.supernova.SuperNova;
import bigbaddevil7.supernova.blocks.CarbonWeaver;
import bigbaddevil7.supernova.crafting.CarbonWeaverRecipes;
import bigbaddevil7.supernova.crafting.OreRecipes;
import bigbaddevil7.supernova.crafting.OxidizerRecipes;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.oredict.OreDictionary;

public class TileEntityCarbonWeaver extends TileEntity implements ISidedInventory{
    private String localizedName;

    private ItemStack[] slots = new ItemStack[4];

    public int Speed = 700;
    
    public int power;
    public final int  maxPower = 10000;

    public int cookTime;

    private static final int[] slots_top = new int[] {0};
    private static final int[] slots_bottom = new int[] {2, 1};
    private static final int[] slots_sides = new int[] {1};

    public String getInvName()
    {
        return this.isInvNameLocalized() ? this.localizedName : "container.carbonWeaver";
    }

    public boolean isInvNameLocalized()
    {
        return this.localizedName != null && this.localizedName.length() > 0;
    }

    public void setGuiDisplayName(String displayName)
    {
        this.localizedName = displayName;
    }

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

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

    @Override
    public ItemStack decrStackSize(int i, int j)
    {
        if (this.slots[i] != null)
        {
            ItemStack itemstack;

            if (this.slots[i].stackSize <= j)
            {
                itemstack = this.slots[i];
                this.slots[i] = null;
                return itemstack;
            }
            else
            {
                itemstack = this.slots[i].splitStack(j);

                if (this.slots[i].stackSize == 0)
                {
                    this.slots[i] = null;
                }

                return itemstack;
            }
        }

        return null;
    }

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

        return null;
    }

    @Override
    public void setInventorySlotContents(int i, ItemStack itemstack)
    {
        this.slots[i] = itemstack;

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

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

    public void readFromNBT(NBTTagCompound nbt)
    {
        super.readFromNBT(nbt);
        NBTTagList list = nbt.getTagList("Items");
        this.slots = new ItemStack[this.getSizeInventory()];

        for (int i = 0; i < list.tagCount(); i++)
        {
            NBTTagCompound compound = (NBTTagCompound) list.tagAt(i);
            byte b = compound.getByte("Slot");

            if (b >= 0 &&  b < this.slots.length)
            {
                this.slots[b] = ItemStack.loadItemStackFromNBT(compound);
            }
        }

        this.power = nbt.getShort("BurnTime");
        this.cookTime = nbt.getShort("cookTime");

        if (nbt.hasKey("CustomName"))
        {
            this.localizedName = nbt.getString("CustomName");
        }
    }

    public void writeToNBT(NBTTagCompound nbt)
    {
        super.writeToNBT(nbt);
        nbt.setShort("BurnTime", (short)this.power);
        nbt.setShort("CookTime", (short)this.cookTime);
        NBTTagList list = new NBTTagList();

        for (int i = 0; i < this.slots.length; i++)
        {
            if (this.slots[i] != null)
            {
                NBTTagCompound compound = new NBTTagCompound();
                compound.setByte("Slot", (byte)i);
                this.slots[i].writeToNBT(compound);
                list.appendTag(compound);
            }
        }

        nbt.setTag("Items", list);

        if (this.isInvNameLocalized())
        {
            nbt.setString("CustomName", this.localizedName);
        }
    }

    @Override
    public boolean isUseableByPlayer(EntityPlayer entityplayer)
    {
        return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : entityplayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;
    }

    @Override
    public void openChest() {}

    @Override
    public void closeChest() {}

    public boolean hasPower()
    {
        return this.power > 0;
    }

    @Override
    public void updateEntity()
    {
        boolean flag = this.hasPower();
        boolean flag1 = false;

        if (hasPower() && this.isFragmenting())
        {
            this.power--;
        }

        if (!this.worldObj.isRemote){
            if (this.isItemPower(this.slots[1]) && this.power <= (this.maxPower - this.getPower(this.slots[1]))){
                if(!this.slots[1].isItemStackDamageable()){
            	this.power += getPower(this.slots[1]);

                if (this.slots[1] != null)
                {
                    flag1 = true;
                    this.slots[1].stackSize--;

                    if (this.slots[1].stackSize == 0)
                    {
                        this.slots[1] = this.slots[1].getItem().getContainerItemStack(this.slots[1]);
                    }
                }
            }else{
            	if(this.slots[1].getItemDamage() < this.slots[1].getMaxDamage()){
            		this.power += getPower(this.slots[1]);
            		this.slots[1] = new ItemStack(this.slots[1].getItem(), this.slots[1].stackSize, this.slots[1].getItemDamage()+1);
            	} 
            	
            }
       }

            if (this.hasPower() && this.canFragment())
            {
                this.cookTime++;
                
                
              /**=================================================================================================*/  
                
  
                
                if (this.cookTime == Speed)
                {
                    this.cookTime = 0;
                    this.fragmentItem();
                    flag1 = true;
                }
            }
            else
            {
                this.cookTime = 0;
            }

            if (flag != this.hasPower())
            {
                flag1 = true;
                CarbonWeaver.updateCarbonWeaverBlockState(this.hasPower(), this.worldObj, this.xCoord, this.yCoord, this.zCoord);
            }
        }

        if (flag1)
        {
            this.onInventoryChanged();
        }
    }
    
    String[] ores = OreDictionary.getOreNames();
    
    private boolean isOre(ItemStack itemstack){
    	for(int i = 0; i < ores.length; i++){
    		if(ores[i].contains("ore")){
    				for(int j = 0; j < OreDictionary.getOres(ores[i]).size(); j++){
    					if(OreDictionary.getOres(ores[i]).get(j).itemID == itemstack.itemID){
    						return true;
    					}
    				}
    			}
    	}
    	return false;
    }

    private boolean canFragment()
    {
        if (this.slots[0] == null)
        {
            return false;
        }
        else
        {
            //ItemStack itemstack = OreRecipes.getRecipes().smelting().getSmeltingResult(this.slots[0]);
        	ItemStack itemstack = CarbonWeaverRecipes.smelting().getSmeltingResult(this.slots[0]);
        	
            if (itemstack == null) return false;          
            if (!(this.slots[3].itemID == SuperNova.titaniumIngots.itemID)) return false;
            if (this.slots[2] == null) return true;
            if (!this.slots[2].isItemEqual(itemstack)) return false;
            
            int result = this.slots[2].stackSize + itemstack.stackSize * 2;
            
            return (result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize());
        }
    }

    public void fragmentItem()
    {
        if (this.canFragment())
        {
            //ItemStack itemstack = OreRecipes.getRecipes().smelting().getSmeltingResult(this.slots[0]);
        	ItemStack itemstack = CarbonWeaverRecipes.smelting().getSmeltingResult(this.slots[0]);
            if (this.slots[2] == null)
            {
                this.slots[2] = itemstack.copy();
                this.slots[2].stackSize *= 2;
            }
            else if (this.slots[2].isItemEqual(itemstack))
            {
                this.slots[2].stackSize += itemstack.stackSize * 2;
            }

            this.slots[0].stackSize--;

            if (this.slots[0].stackSize <= 0)
            {
                this.slots[0] = null;
            }
        }
    }

    public static int getPower(ItemStack itemstack)
    {
        if (itemstack == null)
        {
            return 0;
        }
        else
        {
            int i = itemstack.getItem().itemID;

            //if (i == Item.coal.itemID) return (int)Math.ceil(1371.4286 +(itemstack.stackSize * 228.5714));
            if (i == Item.redstone.itemID) return 10;
            if (i == Block.blockRedstone.blockID) return 90;
            if( i == SuperNova.carbonFuel.itemID) return 500;
            if( i == SuperNova.carbonBattery.itemID) return 10;


            return 0;
        }
    }

    public boolean isFragmenting()
    {
        return this.cookTime > 0;
    }

    public static boolean isItemPower(ItemStack itemstack)
    {
        return getPower(itemstack) > 0;
    }

    @Override
    public boolean isItemValidForSlot(int i, ItemStack itemstack)
    {
        return i == 2 ? false : (i == 1 ? isItemPower(itemstack) : true);
    }

    @Override
    public int[] getAccessibleSlotsFromSide(int var1)
    {
        return var1 == 0 ? slots_bottom : (var1 == 1 ? slots_top : slots_sides);
    }

    @Override
    public boolean canInsertItem(int i, ItemStack itemstack, int j)
    {
        return this.isItemValidForSlot(i, itemstack);
    }

    @Override
    public boolean canExtractItem(int i, ItemStack itemstack, int j)
    {
        return j != 0 || i != 1 || itemstack.itemID == Item.bucketEmpty.itemID;
    }

    public int getCookCarbonWeaverProgressScaled(int i)
    {
        return this.cookTime * i / this.Speed;
    }

    public int getPowerRemainingScaled(int i)
    {
        return this.power * i / this.maxPower;
    

    }
    
    public int hasUpgrade(){
    	if(getStackInSlot(3).isItemEqual(new ItemStack(SuperNova.titaniumIngots))){
    		return Speed = 350;
    	}
    	else{
    		return Speed = 700;
    	}
    }
}

What would be the best way to alter it to achieve the goal?

From your code, it looks like you are consuming all available fuel into a power bar that you decrement as the fuel is used.

 

One way you can make the bar move faster: decrement

this.power

by more than 1, e.g., in updateEntity()

// test with this.power -= 2;
this.power -= this.itemBurnRate; // instead of this.power-- in updateEntity()

 

You would set itemBurnRate according to the kind of fuel you are adding to power. This would have to be done around here:

this.power += getPower(this.slots[1]);

 

You could make a function to return the itemBurnRate depending on the fuel type.

 

It looks like you might have to add some kind of way to keep track of the fuel types you have added if you want to distinguish which fuel added what amount to the total 'power' available.

 

I hope this helps a little! Your idea looks cool!

That is the power though. I need the one that adjusts the speed at which the furnace smelts an item.

 

Referenced in these spots

public int Speed = 700;

 

                if (this.cookTime == Speed)
                {
                    this.cookTime = 0;
                    this.fragmentItem();
                    flag1 = true;
                }

 

 

You're right! Sorry!

 

Maybe we can apply the same idea to cookTime to get to the end faster.

 

 if (this.hasPower() && this.canFragment())
            {
                this.cookTime+=this.cookRate;  // this.cookTime++;

 

You may need to change your if statement like this:

if (this.cookTime >= Speed)

 

 

Im so close to getting it. This is what I have done so far with your help of course.

            if (this.hasPower() && this.canFragment())
            {
            	if(this.slots[3] != null){
            		cookRate = 2;	
            	}else{
            		cookRate = 1;
            	}
                
                this.cookTime += cookRate;
                
  
                
                if (this.cookTime >= Speed)
                {
                    this.cookTime = 0;
                    this.fragmentItem();
                    flag1 = true;
                }
            }

 

This tells if there is an item in the slot.

            	if(this.slots[3] != null){
            		cookRate = 2;	
            	}else{
            		cookRate = 1;
            	}

 

The only problem I'm having is if I try to compare it to an item it gives me a null pointer. I think I"m just comparing it wrong.

 

Is your hasUpgrade() function (at the bottom of your TileEntityCarbonWeaver code) working? Or is that where you need the help comparing?

Its not working. In fact forgot to remove that piece for when I put this up, but that was the function I was going to use to compare. I just need help with the comparison whether it uses that method or if I have to make a new one. If I try to do a comparison with that if statement in the hasUpgrade() it just throws me a Null Pointer. So.. I believe I'm comparing it wrong.

if(getStackInSlot(3).isItemEqual(new ItemStack(SuperNova.titaniumIngots))){
return Speed = 350;
}

If getStackInSlot(3) is ever empty and your hasUpgrade method gets called, that line will throw null because you are trying to access the isItemEqual method with a null object.

 

Also, you don't need to create a new ItemStack just for this comparison, because the way you create it the stack has size 1, damage 0, and no NBT, which means you only need to compare the Item:

ItemStack stack = getStackInSlot(3);
// null check to avoid crashing, then compare the item
if (stack != null && stack.getItem() == SuperNova.titaniumIngots) {
return 350;
}

*slams face into desk* Of course not only what you said makes sense, but as soon as I read I remembered listening to someone saying that exact thing, to check for null first so it doesn't throw a pointer. Well now I can get to work on my container to start allowing for upgrades in my machines. Thanks a you guys.