Every time I've asked for something, you've pointed out I can do it with existing features. Fine, using existing features is preferable. I only come here after I've exhausted everything. This time I don't think there's an easy alternative, but if you know one then please be gentle.

 

I need a call-back for the furnace. My mod requires smelting ore produces an effect: certain ores produce toxic gas. What I did was replace the furnace with a new one that extends BlockFurnace. It has exactly the same texture, exactly the same functions. It works exactly the same, except the gas. To do this and keep it general, I wrote an interface. The new furnace implements that interface. This also simplifies interaction between Block and TileEntity, so the TileEntity doesn't have to hard-code the Block that creates it.

 

Interface

 

import net.minecraft.item.Item;

import net.minecraft.world.World;

 

public interface CallbackFurnace

{

    public void updateFurnace(boolean isActive, World world, int x, int y, int z);

    public void onInventoryChanged(boolean isBurning, Item ore, World world, int x, int y, int z);

}

 

 

Block

 

public class BlockGasFurnace extends BlockFurnace implements CallbackFurnace

{

    private static CallbackFurnace callbackCommand = null;

 

    public static void updateFurnaceBlockState(boolean isActive, World world, int x, int y, int z)

    {

        int metadata = world.getBlockMetadata(x, y, z);

        TileEntity tileEntity = world.getBlockTileEntity(x, y, z);

        keepFurnaceInventory = true;

 

        if (isActive)

        {

            world.setBlock(x, y, z, MyMod.gasFurnaceActive.blockID);

        }

        else

        {

            world.setBlock(x, y, z, MyMod.gasFurnaceIdle.blockID);

        }

 

        keepFurnaceInventory = false;

        world.setBlockMetadataWithNotify(x, y, z, metadata, 2);

 

        if (tileEntity != null)

        {

            tileEntity.validate();

            world.setBlockTileEntity(x, y, z, tileEntity);

        }

 

        if (callbackCommand != null)

        {

            callbackCommand.updateFurnace(isActive, world, x, y, z);

        }

    }

 

    @Override

    public TileEntity createNewTileEntity(World world)

    {

        TileEntityGasFurnace tileEntity = new TileEntityGasFurnace();

        tileEntity.setCallback(this);

        return tileEntity;

    }

 

    @Override

    public void updateFurnace(boolean isActive, World world, int x, int y, int z)

    {

        this.updateFurnaceBlockState(isActive, world, x, y, z);

    }

 

    public void onInventoryChanged(boolean isBurning, Item ore, World world, int x, int y, int z)

    {

        if (callbackCommand != null)

        {

            callbackCommand.onInventoryChanged(isBurning, ore, world, x, y, z);

        }

    }

 

    public void setCallback(CallbackFurnace callback)

    {

        callbackCommand = callback;

    }

}

 

 

TileEntity

 

import net.minecraft.tileentity.TileEntityFurnace;

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;

 

public class TileEntityGasFurnace extends TileEntityFurnace

{

    private static CallbackFurnace callbackCommand = null;

 

    @Override

    public void updateEntity()

    {

        boolean flag = this.furnaceBurnTime > 0;

        boolean inventoryChanged = false;

        boolean cookingChanged = false;

        ...

        if (flag != this.furnaceBurnTime > 0)

        {

            inventoryChanged = true;

            cookingChanged = true;

 

            if (callbackCommand != null)

            {

                callbackCommand.updateFurnace(this.furnaceBurnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);

            }

        }

 

        if (inventoryChanged)

        {

            this.onInventoryChanged();

        }

 

        if (cookingChanged)

        {

            if (callbackCommand != null)

            {

                Item ore = null;

 

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

                {

                    ore = this.furnaceItemStacks[0].getItem();

                }

 

                callbackCommand.onInventoryChanged(this.isBurning(), ore, this.worldObj, this.xCoord, this.yCoord, this.zCoord);

            }

        }

    }

 

    public void setCallback(CallbackFurnace callback)

    {

        callbackCommand = callback;

    }

}

 

 

Mod

 

public class MyMod implements CallbackFurnace

{

    public void updateFurnace(boolean isActive, World world, int x, int y, int z) {}

    public void onInventoryChanged(boolean isBurning, Item ore, World world, int x, int y, int z)

    {

        /* what to do when inventory changes */

    }

}

 

 

I've found the CallbackFurnace interface very useful. But the key thing is BlockFurnace itself. To call a method in my mod when inventory changes. Also, I had to copy significant code for TileEntity due to private variables.

 

What I've done works. But the issue is replacing the furnace with a new block creates a new BlockID. This is only a problem when another mod wants to use the furnace as an ingredient for crafting. It creates an incompatibility. I have a few users asking for a resolution. A hook when inventory changes would resolve it.

 

Thanks

1) Your issue could be solved by simply making your new furnace replace the old one directly, using the same ID

2) Your callback is hardcoded to a single listener, this is not good. You should look into firing off an event instead of a singular callback.

3) You could just override the onInventoryChanged function in TileEntity and get the same information....

 

Not really seeing anything that is necessary for base class edits.

 

My understanding is overriding a block ID with the same ID causes Minecraft to crash.

Not if you do it correctly. Go do some research see if you can figure it out.