Custom furnace whit random drop

[wi3zap]

Hi everyone!

I want add to my mod a custom furnace whit custom fuel. When i put items in i want to relase random items between "Item1" "Item2" "Item3" ect. I have NO idea on how to make i gui (i don't find a good guide...) Thanks to everyone!

[newboyhun]

Copy the original furnace files,and edit it.

 

GuiFurnace

ContainerFurnace

BlockFurnace

TileEntityFurnace

FurnaceRecipies

SlotFurnace

[wi3zap]

I have NO idea on how to make i gui (i don't find a good guide...)

And edit a gui...

[Kore]

Try to edit the class and just reply to this post all the problems you had and I will help you

[wi3zap]

Error are red

 

BlockCatcher code

///////////////////////

package firefly.common;

 

import net.minecraft.src.Block;

import net.minecraft.src.EntityItem;

import net.minecraft.src.EntityLiving;

import net.minecraft.src.ItemStack;

import net.minecraft.src.Material;

import net.minecraft.src.MathHelper;

import net.minecraft.src.NBTTagCompound;

import net.minecraft.src.TileEntity;

import net.minecraft.src.World;

 

public class BlockCatcher extends Block {

 

public BlockCatcher (int id, int texture, Material material) {

super(id, texture, material);

}

 

    @Override

    public int getBlockTextureFromSide(int i)

    {

            switch(i)

    {

            case 0: return 16; //Alto

            case 1: return 16; //Basso

            default: return 0; //Altro

    }

    }

 

@Override

public String getTextureFile () {

return CommonProxy.BLOCK_PNG;

}

 

/**

    * Returns a new instance of a block's tile entity class. Called on placing the block.

    */

    TileEntity createNewTileEntity(World par1World)

    {

        return new TileEntityCatcher();

    }

 

    /**

    * Called when the block is placed in the world.

    */

    public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLiving par5EntityLiving)

    {

        int var6 = MathHelper.floor_double((double)(par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

 

        if (var6 == 0)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 2);

        }

 

        if (var6 == 1)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 5);

        }

 

        if (var6 == 2)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 3);

        }

 

        if (var6 == 3)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 4);

        }

    }

 

    /**

    * ejects contained items into the world, and notifies neighbours of an update, as appropriate

    */

    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)

    {

        if (!keepFurnaceInventory)

        {

            TileEntityCatcher var7 = (TileEntityCatcher)par1World.getBlockTileEntity(par2, par3, par4);

 

            if (var7 != null)

            {

                for (int var8 = 0; var8 < var7.getSizeInventory(); ++var8)

                {

                    ItemStack var9 = var7.getStackInSlot(var8);

 

                    if (var9 != null)

                    {

                        float var10 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float var11 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float var12 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

 

                        while (var9.stackSize > 0)

                        {

                            int var13 = this.furnaceRand.nextInt(21) + 10;

 

                            if (var13 > var9.stackSize)

                            {

                                var13 = var9.stackSize;

                            }

 

                            var9.stackSize -= var13;

                            EntityItem var14 = new EntityItem(par1World, (double)((float)par2 + var10), (double)((float)par3 + var11), (double)((float)par4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));

 

                            if (var9.hasTagCompound())

                            {

                                var14.item.setTagCompound((NBTTagCompound)var9.getTagCompound().copy());

                            }

 

                            float var15 = 0.05F;

                            var14.motionX = (double)((float)this.furnaceRand.nextGaussian() * var15);

                            var14.motionY = (double)((float)this.furnaceRand.nextGaussian() * var15 + 0.2F);

                            var14.motionZ = (double)((float)this.furnaceRand.nextGaussian() * var15);

                            par1World.spawnEntityInWorld(var14);

                        }

                    }

                }

            }

        }

 

        super.breakBlock(par1World, par2, par3, par4, par5, par6);

    }

}

 

 

 

 

 

ContainerCatcher code

///////////////////////////////

 

package firefly.common;

 

import net.minecraft.src.Container;

import net.minecraft.src.EntityPlayer;

import net.minecraft.src.ICrafting;

import net.minecraft.src.InventoryPlayer;

import net.minecraft.src.ItemStack;

import net.minecraft.src.Slot;

import cpw.mods.fml.common.Side;

import cpw.mods.fml.common.asm.SideOnly;

 

public class ContainerCatcher extends Container

{

    private TileEntityCatcher furnace;

    private int lastCookTime = 0;

    private int lastBurnTime = 0;

    private int lastItemBurnTime = 0;

 

    public ContainerCatcher(InventoryPlayer par1InventoryPlayer, TileEntityCatcher par2TileEntityFurnace)

    {

        this.furnace = par2TileEntityFurnace;

        this.addSlotToContainer(new Slot(par2TileEntityFurnace, 0, 56, 17));

        this.addSlotToContainer(new Slot(par2TileEntityFurnace, 1, 56, 53));

        this.addSlotToContainer(new SlotCatcher(par1InventoryPlayer.player, par2TileEntityFurnace, 2, 116, 35));

        int var3;

 

        for (var3 = 0; var3 < 3; ++var3)

        {

            for (int var4 = 0; var4 < 9; ++var4)

            {

                this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18));

            }

        }

 

        for (var3 = 0; var3 < 9; ++var3)

        {

            this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142));

        }

    }

 

    public void addCraftingToCrafters(ICrafting par1ICrafting)

    {

        super.addCraftingToCrafters(par1ICrafting);

        par1ICrafting.updateCraftingInventoryInfo(this, 0, this.furnace.furnaceCookTime);

        par1ICrafting.updateCraftingInventoryInfo(this, 1, this.furnace.furnaceBurnTime);

        par1ICrafting.updateCraftingInventoryInfo(this, 2, this.furnace.currentItemBurnTime);

    }

 

    /**

    * Updates crafting matrix; called from onCraftMatrixChanged. Args: none

    */

    public void updateCraftingResults()

    {

        super.updateCraftingResults();

 

        for (int var1 = 0; var1 < this.crafters.size(); ++var1)

        {

            ICrafting var2 = (ICrafting)this.crafters.get(var1);

 

            if (this.lastCookTime != this.furnace.furnaceCookTime)

            {

                var2.updateCraftingInventoryInfo(this, 0, this.furnace.furnaceCookTime);

            }

 

            if (this.lastBurnTime != this.furnace.furnaceBurnTime)

            {

                var2.updateCraftingInventoryInfo(this, 1, this.furnace.furnaceBurnTime);

            }

 

            if (this.lastItemBurnTime != this.furnace.currentItemBurnTime)

            {

                var2.updateCraftingInventoryInfo(this, 2, this.furnace.currentItemBurnTime);

            }

        }

 

        this.lastCookTime = this.furnace.furnaceCookTime;

        this.lastBurnTime = this.furnace.furnaceBurnTime;

        this.lastItemBurnTime = this.furnace.currentItemBurnTime;

    }

 

    @SideOnly(Side.CLIENT)

    public void updateProgressBar(int par1, int par2)

    {

        if (par1 == 0)

        {

            this.furnace.furnaceCookTime = par2;

        }

 

        if (par1 == 1)

        {

            this.furnace.furnaceBurnTime = par2;

        }

 

        if (par1 == 2)

        {

            this.furnace.currentItemBurnTime = par2;

        }

    }

 

    public boolean canInteractWith(EntityPlayer par1EntityPlayer)

    {

        return this.furnace.isUseableByPlayer(par1EntityPlayer);

    }

 

    /**

    * Called when a player shift-clicks on a slot. You must override this or you will crash when someone does that.

    */

    public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2)

    {

        ItemStack var3 = null;

        Slot var4 = (Slot)this.inventorySlots.get(par2);

 

        if (var4 != null && var4.getHasStack())

        {

            ItemStack var5 = var4.getStack();

            var3 = var5.copy();

 

            if (par2 == 2)

            {

                if (!this.mergeItemStack(var5, 3, 39, true))

                {

                    return null;

                }

 

                var4.onSlotChange(var5, var3);

            }

            else if (par2 != 1 && par2 != 0)

            {

                if (CatcherRecipes.smelting().getSmeltingResult(var5) != null)

                {

                    if (!this.mergeItemStack(var5, 0, 1, false))

                    {

                        return null;

                    }

                }

                else if (TileEntityCatcher.isItemFuel(var5))

                {

                    if (!this.mergeItemStack(var5, 1, 2, false))

                    {

                        return null;

                    }

                }

                else if (par2 >= 3 && par2 < 30)

                {

                    if (!this.mergeItemStack(var5, 30, 39, false))

                    {

                        return null;

                    }

                }

                else if (par2 >= 30 && par2 < 39 && !this.mergeItemStack(var5, 3, 30, false))

                {

                    return null;

                }

            }

            else if (!this.mergeItemStack(var5, 3, 39, false))

            {

                return null;

            }

 

            if (var5.stackSize == 0)

            {

                var4.putStack((ItemStack)null);

            }

            else

            {

                var4.onSlotChanged();

            }

 

            if (var5.stackSize == var3.stackSize)

            {

                return null;

            }

 

            var4.onPickupFromSlot(par1EntityPlayer, var5);

        }

 

        return var3;

    }

 

@Override

public boolean canInteractWith(EntityPlayer var1) {

// TODO Auto-generated method stub

return false;

}

}

 

 

 

 

TileEnityCatcher code

////////////////////////////

 

package firefly.common;

 

import net.minecraft.src.Block;

import net.minecraft.src.EntityPlayer;

import net.minecraft.src.IInventory;

import net.minecraft.src.Item;

import net.minecraft.src.ItemBlock;

import net.minecraft.src.ItemHoe;

import net.minecraft.src.ItemStack;

import net.minecraft.src.ItemSword;

import net.minecraft.src.ItemTool;

import net.minecraft.src.Material;

import net.minecraft.src.NBTTagCompound;

import net.minecraft.src.NBTTagList;

import net.minecraft.src.TileEntity;

import net.minecraftforge.common.ISidedInventory;

import net.minecraftforge.common.ForgeDirection;

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

 

import cpw.mods.fml.common.Side;

import cpw.mods.fml.common.asm.SideOnly;

 

public class TileEntityCatcher extends TileEntity implements IInventory, ISidedInventory

{

    /**

    * The ItemStacks that hold the items currently being used in the furnace

    */

    private ItemStack[] furnaceItemStacks = new ItemStack[3];

 

    /** The number of ticks that the furnace will keep burning */

    public int furnaceBurnTime = 0;

 

    /**

    * The number of ticks that a fresh copy of the currently-burning item would keep the furnace burning for

    */

    public int currentItemBurnTime = 0;

 

    /** The number of ticks that the current item has been cooking for */

    public int furnaceCookTime = 0;

 

    /**

    * Returns the number of slots in the inventory.

    */

    public int getSizeInventory()

    {

        return this.furnaceItemStacks.length;

    }

 

    /**

    * Returns the stack in slot i

    */

    public ItemStack getStackInSlot(int par1)

    {

        return this.furnaceItemStacks[par1];

    }

 

    /**

    * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a

    * new stack.

    */

    public ItemStack decrStackSize(int par1, int par2)

    {

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

        {

            ItemStack var3;

 

            if (this.furnaceItemStacks[par1].stackSize <= par2)

            {

                var3 = this.furnaceItemStacks[par1];

                this.furnaceItemStacks[par1] = null;

                return var3;

            }

            else

            {

                var3 = this.furnaceItemStacks[par1].splitStack(par2);

 

                if (this.furnaceItemStacks[par1].stackSize == 0)

                {

                    this.furnaceItemStacks[par1] = null;

                }

 

                return var3;

            }

        }

        else

        {

            return null;

        }

    }

 

    /**

    * When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem -

    * like when you close a workbench GUI.

    */

    public ItemStack getStackInSlotOnClosing(int par1)

    {

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

        {

            ItemStack var2 = this.furnaceItemStacks[par1];

            this.furnaceItemStacks[par1] = null;

            return var2;

        }

        else

        {

            return null;

        }

    }

 

    /**

    * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).

    */

    public void setInventorySlotContents(int par1, ItemStack par2ItemStack)

    {

        this.furnaceItemStacks[par1] = par2ItemStack;

 

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

        {

            par2ItemStack.stackSize = this.getInventoryStackLimit();

        }

    }

 

    /**

    * Returns the name of the inventory.

    */

    public String getInvName()

    {

        return "container.furnace";

    }

 

    /**

    * Reads a tile entity from NBT.

    */

    public void readFromNBT(NBTTagCompound par1NBTTagCompound)

    {

        super.readFromNBT(par1NBTTagCompound);

        NBTTagList var2 = par1NBTTagCompound.getTagList("Items");

        this.furnaceItemStacks = 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.furnaceItemStacks.length)

            {

                this.furnaceItemStacks[var5] = ItemStack.loadItemStackFromNBT(var4);

            }

        }

 

        this.furnaceBurnTime = par1NBTTagCompound.getShort("BurnTime");

        this.furnaceCookTime = par1NBTTagCompound.getShort("CookTime");

        this.currentItemBurnTime = getItemBurnTime(this.furnaceItemStacks[1]);

    }

 

    /**

    * Writes a tile entity to NBT.

    */

    public void writeToNBT(NBTTagCompound par1NBTTagCompound)

    {

        super.writeToNBT(par1NBTTagCompound);

        par1NBTTagCompound.setShort("BurnTime", (short)this.furnaceBurnTime);

        par1NBTTagCompound.setShort("CookTime", (short)this.furnaceCookTime);

        NBTTagList var2 = new NBTTagList();

 

        for (int var3 = 0; var3 < this.furnaceItemStacks.length; ++var3)

        {

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

            {

                NBTTagCompound var4 = new NBTTagCompound();

                var4.setByte("Slot", (byte)var3);

                this.furnaceItemStacks[var3].writeToNBT(var4);

                var2.appendTag(var4);

            }

        }

 

        par1NBTTagCompound.setTag("Items", var2);

    }

 

    /**

    * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't

    * this more of a set than a get?*

    */

    public int getInventoryStackLimit()

    {

        return 64;

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * Returns an integer between 0 and the passed value representing how close the current item is to being completely

    * cooked

    */

    public int getCookProgressScaled(int par1)

    {

        return this.furnaceCookTime * par1 / 200;

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * Returns an integer between 0 and the passed value representing how much burn time is left on the current fuel

    * item, where 0 means that the item is exhausted and the passed value means that the item is fresh

    */

    public int getBurnTimeRemainingScaled(int par1)

    {

        if (this.currentItemBurnTime == 0)

        {

            this.currentItemBurnTime = 200;

        }

 

        return this.furnaceBurnTime * par1 / this.currentItemBurnTime;

    }

 

    /**

    * Returns true if the furnace is currently burning

    */

    public boolean isBurning()

    {

        return this.furnaceBurnTime > 0;

    }

 

    /**

    * Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count

    * ticks and creates a new spawn inside its implementation.

    */

    public void updateEntity()

    {

        boolean var1 = this.furnaceBurnTime > 0;

        boolean var2 = false;

 

        if (this.furnaceBurnTime > 0)

        {

            --this.furnaceBurnTime;

        }

 

        if (!this.worldObj.isRemote)

        {

            if (this.furnaceBurnTime == 0 && this.canSmelt())

            {

                this.currentItemBurnTime = this.furnaceBurnTime = getItemBurnTime(this.furnaceItemStacks[1]);

 

                if (this.furnaceBurnTime > 0)

                {

                    var2 = true;

 

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

                    {

                        --this.furnaceItemStacks[1].stackSize;

 

                        if (this.furnaceItemStacks[1].stackSize == 0)

                        {

                            this.furnaceItemStacks[1] = this.furnaceItemStacks[1].getItem().getContainerItemStack(furnaceItemStacks[1]);

                        }

                    }

                }

            }

 

            if (this.isBurning() && this.canSmelt())

            {

                ++this.furnaceCookTime;

 

                if (this.furnaceCookTime == 200)

                {

                    this.furnaceCookTime = 0;

                    this.smeltItem();

                    var2 = true;

                }

            }

            else

            {

                this.furnaceCookTime = 0;

            }

 

            if (var1 != this.furnaceBurnTime > 0)

            {

                var2 = true;

                BlockCatcher.updateFurnaceBlockState(this.furnaceBurnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);

            }

        }

 

        if (var2)

        {

            this.onInventoryChanged();

        }

    }

 

    /**

    * Returns true if the furnace can smelt an item, i.e. has a source item, destination stack isn't full, etc.

    */

    private boolean canSmelt()

    {

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

        {

            return false;

        }

        else

        {

            ItemStack var1 = FurnaceRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

            if (var1 == null) return false;

            if (this.furnaceItemStacks[2] == null) return true;

            if (!this.furnaceItemStacks[2].isItemEqual(var1)) return false;

            int result = furnaceItemStacks[2].stackSize + var1.stackSize;

            return (result <= getInventoryStackLimit() && result <= var1.getMaxStackSize());

        }

    }

 

    /**

    * Turn one item from the furnace source stack into the appropriate smelted item in the furnace result stack

    */

    public void smeltItem()

    {

        if (this.canSmelt())

        {

            ItemStack var1 = CatcherRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

 

            if (this.furnaceItemStacks[2] == null)

            {

                this.furnaceItemStacks[2] = var1.copy();

            }

            else if (this.furnaceItemStacks[2].isItemEqual(var1))

            {

                furnaceItemStacks[2].stackSize += var1.stackSize;

            }

 

            --this.furnaceItemStacks[0].stackSize;

 

            if (this.furnaceItemStacks[0].stackSize <= 0)

            {

                this.furnaceItemStacks[0] = null;

            }

        }

    }

 

    /**

    * Returns the number of ticks that the supplied fuel item will keep the furnace burning, or 0 if the item isn't

    * fuel

    */

    public static int getItemBurnTime(ItemStack par0ItemStack)

    {

        if (par0ItemStack == null)

        {

            return 0;

        }

        else

        {

            int var1 = par0ItemStack.getItem().shiftedIndex;

            Item var2 = par0ItemStack.getItem();

 

            if (par0ItemStack.getItem() instanceof ItemBlock && Block.blocksList[var1] != null)

            {

                Block var3 = Block.blocksList[var1];

 

                if (var3 == Block.woodSingleSlab)

                {

                    return 150;

                }

 

                if (var3.blockMaterial == Material.wood)

                {

                    return 300;

                }

            }

            if (var2 instanceof ItemTool && ((ItemTool) var2).getToolMaterialName().equals("WOOD")) return 200;

            if (var2 instanceof ItemSword && ((ItemSword) var2).func_77825_f().equals("WOOD")) return 200;

            if (var2 instanceof ItemHoe && ((ItemHoe) var2).func_77842_f().equals("WOOD")) return 200;

            if (var1 == Item.stick.shiftedIndex) return 100;

            if (var1 == Item.coal.shiftedIndex) return 1600;

            if (var1 == Item.bucketLava.shiftedIndex) return 20000;

            if (var1 == Block.sapling.blockID) return 100;

            if (var1 == Item.blazeRod.shiftedIndex) return 2400;

            return GameRegistry.getFuelValue(par0ItemStack);

        }

    }

 

    /**

    * Return true if item is a fuel source (getItemBurnTime() > 0).

    */

    public static boolean isItemFuel(ItemStack par0ItemStack)

    {

        return getItemBurnTime(par0ItemStack) > 0;

    }

 

    /**

    * Do not make give this method the name canInteractWith because it clashes with Container

    */

    public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)

    {

        return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;

    }

 

    public void openChest() {}

 

    public void closeChest() {}

 

    @Override

    public int getStartInventorySide(ForgeDirection side)

    {

        if (side == ForgeDirection.DOWN) return 1;

        if (side == ForgeDirection.UP) return 0;

        return 2;

    }

 

    @Override

    public int getSizeInventorySide(ForgeDirection side)

    {

        return 1;

    }

 

@Override

public void setInventorySlotContents(int var1, ItemStack var2) {

// TODO Auto-generated method stub

 

}

 

@Override

public boolean isUseableByPlayer(EntityPlayer var1) {

// TODO Auto-generated method stub

return false;

}

}

 

 

i dont put the code on "spoiler" or " code" because don't appears the red color

 

Now, what is the cod for the random drop? Thanks

[Kore]

Inside BlockCatcher

 

 

public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)

    {

        if ([glow=red,2,300]!keepFurnaceInventory[/glow])//The weird chance that the game should not drop the inv ie. world.setBlock(x,y,z,0)

        {

            TileEntityCatcher var7 = (TileEntityCatcher)par1World.getBlockTileEntity(par2, par3, par4);

 

            if (var7 != null)

            {

                for (int var8 = 0; var8 < [glow=red,2,300]var7.getSizeInventory()[/glow]; ++var8)//This is cycling through the items so it will drop them all

                {

                    ItemStack var9 = [glow=red,2,300]var7.getStackInSlot(var8)[/glow];//Placing all the items as an itemstack to be dropped

 

                    if (var9 != null)

                    {

                      [glow=red,2,300]  float var10 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float var11 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float var12 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;[/glow]//Determining the velocity in which direction to shoot items

 

                        while (var9.stackSize > 0)

                        {

                            int var13 = [glow=red,2,300]this.furnaceRand.nextInt(21)[/glow] + 10;//Not completely sure

 

                            if (var13 > var9.stackSize)

                            {

                                var13 = var9.stackSize;

                            }

 

                            var9.stackSize -= var13;

                            EntityItem var14 = new EntityItem(par1World, (double)((float)par2 + var10), (double)((float)par3 + var11), (double)((float)par4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));

 

                            if (var9.hasTagCompound())

                            {

                                var14.item.setTagCompound((NBTTagCompound)var9.getTagCompound().copy());

                            }

 

                            float var15 = 0.05F;

                            var14.motionX = (double)((float)this.furnaceRand.nextGaussian() * var15);

                            var14.motionY = (double)((float)this.furnaceRand.nextGaussian() * var15 + 0.2F);

                            var14.motionZ = (double)((float)this.furnaceRand.nextGaussian() * var15);

                            par1World.spawnEntityInWorld(var14);

                        }

                    }

                }

            }

        }

 

        super.breakBlock(par1World, par2, par3, par4, par5, par6);

    }

 

 

ContainerCatcher

 

 

public boolean canInteractWith(EntityPlayer par1EntityPlayer)

    {

        [glow=red,2,300]return this.furnace.isUseableByPlayer(par1EntityPlayer);[/glow]//Makes sure you are close enough to interact

    }

 

@Override

  public boolean canInteractWith(EntityPlayer var1) {

      // TODO Auto-generated method stub

      return false;

  }

 

 

TileEnityCatcher

 

 

[glow=red,2,300]public void setInventorySlotContents(int par1, ItemStack par2ItemStack)

    {

        this.furnaceItemStacks[par1] = par2ItemStack;

 

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

        {

            par2ItemStack.stackSize = this.getInventoryStackLimit();

        }

    }[/glow]//Used when you place items in the Catcher

[glow=red,2,300]public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)

    {

        return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;

    }[/glow]//Made to check if you are close enough

 

@Override

  public void setInventorySlotContents(int var1, ItemStack var2) {

      // TODO Auto-generated method stub

     

  }

 

  @Override

  public boolean isUseableByPlayer(EntityPlayer var1) {

      // TODO Auto-generated method stub

      return false;

  }

 

 

[wi3zap]

in the code you've written is already integrated the random drop? (Thanks )

[Kore]

What do you mean by random drop?

A random item dropped when broken w/ the original block aswell

or A random block with the original items

or am I misunderstanding

[wi3zap]

Cook an item and you give a random item between "Item1" "Item2" "Item3" ecc

[Kore]

Oh then you need to edit the recipes class and make if input == ItemInput

ItemStack dropItem = null;

int i = rand.nextInt(3);

switch(i){

case 0:

    dropItem = new ItemStack(Item1, 1)

}

case 1:

    dropItem = new ItemStack(Item2, 1)

}

case 2:

    dropItem = new ItemStack(Item3, 1)

}

[wi3zap]

sorry for the stupid question, but where i put the random code? (you have a great patience asd)

[Kore]

Its fine and you would need to put it inside of your own furnaceRecipes, (Im assuming your block is sortof a furnacelike block) and have it in that and when the input is this then output this this or this as the code is below

[wi3zap]

im italian, i don't speak a good english...

i do this private

CatcherRecipes()

    {

if input == ItemInput

ItemStack dropItem = null;

int i = rand.nextInt(3);

switch(i){

case 0:

    dropItem = new ItemStack(Item1, 1)

}

case 1:

    dropItem = new ItemStack(Item2, 1)

}

case 2:

    dropItem = new ItemStack(Item3, 1)

}

}

and i get error... if you isn't noticed i'm denied about gui...

[Kore]

Poi parla italiano, mi metterò una traduzione migliore.

[wi3zap]

CatcherRecipes()

    {

if input == ItemInput

ItemStack dropItem = null;

int i = rand.nextInt(3);

switch(i){

case 0:

    dropItem = new ItemStack(Item1, 1)

}

case 1:

    dropItem = new ItemStack(Item2, 1)

}

case 2:

    dropItem = new ItemStack(Item3, 1)

}

}

i get error

[Kore]

Here is the furnace recipes class change this to your class and edit the recipes

 

 

package net.minecraft.item.crafting;

 

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import net.minecraft.block.Block;

import net.minecraft.item.Item;

import net.minecraft.item.ItemStack;

 

public class FurnaceRecipes

{

    private static final FurnaceRecipes smeltingBase = new FurnaceRecipes();

 

    [glow=red,2,300]Random rand = new Random()[/glow]

 

    /** The list of smelting results. */

    private Map smeltingList = new HashMap();

    private Map experienceList = new HashMap();

    private HashMap<List<Integer>, ItemStack> metaSmeltingList = new HashMap<List<Integer>, ItemStack>();

    private HashMap<List<Integer>, Float> metaExperience = new HashMap<List<Integer>, Float>();

 

    /**

    * Used to call methods addSmelting and getSmeltingResult.

    */

    public static final FurnaceRecipes smelting()

    {

        return smeltingBase;

    }

 

    private FurnaceRecipes()

    {

        this.addSmelting(Block.oreIron.blockID, new ItemStack(Item.ingotIron), 0.7F);

        this.addSmelting(Block.oreGold.blockID, new ItemStack(Item.ingotGold), 1.0F);

        this.addSmelting(Block.oreDiamond.blockID, new ItemStack(Item.diamond), 1.0F);

        this.addSmelting(Block.sand.blockID, new ItemStack(Block.glass), 0.1F);

        this.addSmelting(Item.porkRaw.shiftedIndex, new ItemStack(Item.porkCooked), 0.35F);

        this.addSmelting(Item.beefRaw.shiftedIndex, new ItemStack(Item.beefCooked), 0.35F);

        this.addSmelting(Item.chickenRaw.shiftedIndex, new ItemStack(Item.chickenCooked), 0.35F);

        this.addSmelting(Item.fishRaw.shiftedIndex, new ItemStack(Item.fishCooked), 0.35F);

        this.addSmelting(Block.cobblestone.blockID, new ItemStack(Block.stone), 0.1F);

        this.addSmelting(Item.clay.shiftedIndex, new ItemStack(Item.brick), 0.3F);

        this.addSmelting(Block.cactus.blockID, new ItemStack(Item.dyePowder, 1, 2), 0.2F);

        this.addSmelting(Block.wood.blockID, new ItemStack(Item.coal, 1, 1), 0.15F);

        this.addSmelting(Block.oreEmerald.blockID, new ItemStack(Item.emerald), 1.0F);

        this.addSmelting(Item.potato.shiftedIndex, new ItemStack(Item.bakedPotato), 0.35F);

        this.addSmelting(Block.oreCoal.blockID, new ItemStack(Item.coal), 0.1F);

        this.addSmelting(Block.oreRedstone.blockID, new ItemStack(Item.redstone), 0.7F);

        this.addSmelting(Block.oreLapis.blockID, new ItemStack(Item.dyePowder, 1, 4), 0.2F);

    }

 

    /**

    * Adds a smelting recipe.

    */

    public void addSmelting(int par1, ItemStack par2ItemStack, float par3)

    {

        this.smeltingList.put(Integer.valueOf(par1), par2ItemStack);

        this.experienceList.put(Integer.valueOf(par2ItemStack.itemID), Float.valueOf(par3));

    }

 

    /**

    * Returns the smelting result of an item.

    * Deprecated in favor of a metadata sensitive version

    */

    @Deprecated

    public ItemStack getSmeltingResult(int par1)

    {

        //ADDED BY KORE

        [glow=red,2,300]if(par1==indexOfRecipe){

            int i = rand.nextInt(3);

            switch(i){

            case 0:

                dropItem = new ItemStack(Item1, 1)

                break;

            }

            case 1:

                dropItem = new ItemStack(Item2, 1)

                break;

            }

            case 2:

                dropItem = new ItemStack(Item3, 1)

                break;

            }

        }[/glow]

        return (ItemStack)this.smeltingList.get(Integer.valueOf(par1));

    }

 

    public Map getSmeltingList()

    {

        return this.smeltingList;

    }

 

    @Deprecated //In favor of ItemStack sensitive version

    public float getExperience(int par1)

    {

        return this.experienceList.containsKey(Integer.valueOf(par1)) ? ((Float)this.experienceList.get(Integer.valueOf(par1))).floatValue() : 0.0F;

    }

 

    /**

    * A metadata sensitive version of adding a furnace recipe.

    */

    public void addSmelting(int itemID, int metadata, ItemStack itemstack, float experience)

    {

        metaSmeltingList.put(Arrays.asList(itemID, metadata), itemstack);

        metaExperience.put(Arrays.asList(itemID, metadata), experience);

    }

 

    /**

    * Used to get the resulting ItemStack form a source ItemStack

    * @param item The Source ItemStack

    * @return The result ItemStack

    */

    public ItemStack getSmeltingResult(ItemStack item)

    {

        if (item == null)

        {

            return null;

        }

        ItemStack ret = (ItemStack)metaSmeltingList.get(Arrays.asList(item.itemID, item.getItemDamage()));

        if (ret != null)

        {

            return ret;

        }

        return (ItemStack)smeltingList.get(Integer.valueOf(item.itemID));

    }

 

    /**

    * Grabs the amount of base experience for this item to give when pulled from the furnace slot.

    */

    public float getExperience(ItemStack item)

    {

        if (item == null || item.getItem() == null)

        {

            return 0;

        }

        float ret = item.getItem().getSmeltingExperience(item);

        if (ret < 0 && metaExperience.containsKey(Arrays.asList(item.itemID, item.getItemDamage())))

        {

            ret = metaExperience.get(Arrays.asList(item.itemID, item.getItemDamage()));

        }

        if (ret < 0 && experienceList.containsKey(item.itemID))

        {

            ret = ((Float)experienceList.get(item.itemID)).floatValue();

        }

        return (ret < 0 ? 0 : ret);

    }

}

 

 

 

[wi3zap]

you are a good man 

tomorrow i put my code/errors

[wi3zap]

Errors are in red

 

CatcherRecipes

///////////////////

 

 

package firefly.common;

 

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Random;

 

import net.minecraft.src.ItemStack;

 

public class CatcherRecipes

{

    private static final CatcherRecipes smeltingBase = new CatcherRecipes();

   

    Random rand = new Random()

   

    /** The list of smelting results. */

    private Map smeltingList = new HashMap();

    private Map experienceList = new HashMap();

    private HashMap<List<Integer>, ItemStack> metaSmeltingList = new HashMap<List<Integer>, ItemStack>();

    private HashMap<List<Integer>, Float> metaExperience = new HashMap<List<Integer>, Float>();

 

    /**

    * Used to call methods addSmelting and getSmeltingResult.

    */

    public static final CatcherRecipes smelting()

    {

        return smeltingBase;

    }

 

    private CatcherRecipes()

    {

        //this.addSmelting(Block.oreIron.blockID, new ItemStack(Item.ingotIron), 0.7F);

        //this.addSmelting(Block.oreGold.blockID, new ItemStack(Item.ingotGold), 1.0F);

    //this.addSmelting(Block.oreDiamond.blockID, new ItemStack(Item.diamond), 1.0F);

    //this.addSmelting(Block.sand.blockID, new ItemStack(Block.glass), 0.1F);

    //this.addSmelting(Item.porkRaw.shiftedIndex, new ItemStack(Item.porkCooked), 0.35F);

    //this.addSmelting(Item.beefRaw.shiftedIndex, new ItemStack(Item.beefCooked), 0.35F);

    //this.addSmelting(Item.chickenRaw.shiftedIndex, new ItemStack(Item.chickenCooked), 0.35F);

    //this.addSmelting(Item.fishRaw.shiftedIndex, new ItemStack(Item.fishCooked), 0.35F);

    //this.addSmelting(Block.cobblestone.blockID, new ItemStack(Block.stone), 0.1F);

    //this.addSmelting(Item.clay.shiftedIndex, new ItemStack(Item.brick), 0.3F);

    //this.addSmelting(Block.cactus.blockID, new ItemStack(Item.dyePowder, 1, 2), 0.2F);

    //this.addSmelting(Block.wood.blockID, new ItemStack(Item.coal, 1, 1), 0.15F);

    //this.addSmelting(Block.oreEmerald.blockID, new ItemStack(Item.emerald), 1.0F);

    //this.addSmelting(Item.potatoe.shiftedIndex, new ItemStack(Item.bakedPotato), 0.35F);

    //this.addSmelting(Block.oreCoal.blockID, new ItemStack(Item.coal), 0.1F);

    //this.addSmelting(Block.oreRedstone.blockID, new ItemStack(Item.redstone), 0.7F);

    //this.addSmelting(Block.oreLapis.blockID, new ItemStack(Item.dyePowder, 1, 4), 0.2F);

   

    }

 

    /**

    * Adds a smelting recipe.

    */

    public void addSmelting(int par1, ItemStack par2ItemStack, float par3)

    {

        this.smeltingList.put(Integer.valueOf(par1), par2ItemStack);

        this.experienceList.put(Integer.valueOf(par2ItemStack.itemID), Float.valueOf(par3));

    }

 

    /**

    * Returns the smelting result of an item.

    * Deprecated in favor of a metadata sensitive version

    */

    @Deprecated

    public ItemStack getSmeltingResult(int par1)

    {

        //ADDED BY KORE

        if(par1==indexOfRecipe){

            int i = rand.nextInt(3);

            switch(i){

            case 0:

                mod_firefly.FireflyNormalGirl = new ItemStack(mod_firefly.FireflyNormalBoy, 1)

                break;

            }

            case 1:

                dropItem = new ItemStack(Item2, 1)

                break;

            }

            case 2:

                dropItem = new ItemStack(Item3, 1)

                break;

            }

        }

        return (ItemStack)this.smeltingList.get(Integer.valueOf(par1));

    }

 

    public Map getSmeltingList()

    {

        return this.smeltingList;

    }

 

    @Deprecated //In favor of ItemStack sensitive version

    public float getExperience(int par1)

    {

        return this.experienceList.containsKey(Integer.valueOf(par1)) ? ((Float)this.experienceList.get(Integer.valueOf(par1))).floatValue() : 0.0F;

    }

 

    /**

    * Add a metadata-sensitive furnace recipe

    * @param itemID The Item ID

    * @param metadata The Item Metadata

    * @param itemstack The ItemStack for the result

    */

    @Deprecated //In favor of the exp version, will remove next major MC version.

    public void addSmelting(int itemID, int metadata, ItemStack itemstack)

    {

        addSmelting(itemID, metadata, itemstack, 0.0f);

    }

 

    /**

    * A metadata sensitive version of adding a furnace recipe.

    */

    public void addSmelting(int itemID, int metadata, ItemStack itemstack, float experience)

    {

        metaSmeltingList.put(Arrays.asList(itemID, metadata), itemstack);

        metaExperience.put(Arrays.asList(itemID, metadata), experience);

    }

 

    /**

    * Used to get the resulting ItemStack form a source ItemStack

    * @param item The Source ItemStack

    * @return The result ItemStack

    */

    public ItemStack getSmeltingResult(ItemStack item)

    {

        if (item == null)

        {

            return null;

        }

        ItemStack ret = (ItemStack)metaSmeltingList.get(Arrays.asList(item.itemID, item.getItemDamage()));

        if (ret != null)

        {

            return ret;

        }

        return (ItemStack)smeltingList.get(Integer.valueOf(item.itemID));

    }

 

    /**

    * Grabs the amount of base experience for this item to give when pulled from the furnace slot.

    */

    public float getExperience(ItemStack item)

    {

        if (item == null || item.getItem() == null)

        {

            return 0;

        }

        float ret = item.getItem().getSmeltingExperience(item);

        if (ret < 0 && metaExperience.containsKey(Arrays.asList(item.itemID, item.getItemDamage())))

        {

            ret = metaExperience.get(Arrays.asList(item.itemID, item.getItemDamage()));

        }

        if (ret < 0 && experienceList.containsKey(item.itemID))

        {

            ret = ((Float)experienceList.get(item.itemID)).floatValue();

        }

        return (ret < 0 ? 0 : ret);

    }

}

 

 

 

BlockCatcher

/////////////////////

 

 

package firefly.common;

 

import net.minecraft.src.Block;

import net.minecraft.src.EntityItem;

import net.minecraft.src.EntityLiving;

import net.minecraft.src.ItemStack;

import net.minecraft.src.Material;

import net.minecraft.src.MathHelper;

import net.minecraft.src.NBTTagCompound;

import net.minecraft.src.TileEntity;

import net.minecraft.src.World;

 

public class BlockCatcher extends Block {

 

private Object furnaceRand;

 

public BlockCatcher (int id, int texture, Material material) {

super(id, texture, material);

}

 

    @Override

    public int getBlockTextureFromSide(int i)

    {

            switch(i)

    {

            case 0: return 16; //Alto

            case 1: return 16; //Basso

            default: return 0; //Altro

    }

    }

 

@Override

public String getTextureFile () {

return CommonProxy.BLOCK_PNG;

}

 

/**

    * Returns a new instance of a block's tile entity class. Called on placing the block.

    */

    TileEntity createNewTileEntity(World par1World)

    {

        return new TileEntityCatcher();

    }

 

    /**

    * Called when the block is placed in the world.

    */

    public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLiving par5EntityLiving)

    {

        int var6 = MathHelper.floor_double((double)(par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

 

        if (var6 == 0)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 2);

        }

 

        if (var6 == 1)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 5);

        }

 

        if (var6 == 2)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 3);

        }

 

        if (var6 == 3)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 4);

        }

    }

 

    /**

    * ejects contained items into the world, and notifies neighbours of an update, as appropriate

    */

    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)

    {

        if (!keepFurnaceInventory)//The weird chance that the game should not drop the inv ie. world.setBlock(x,y,z,0)

        {

            TileEntityCatcher var7 = (TileEntityCatcher)par1World.getBlockTileEntity(par2, par3, par4);

 

            if (var7 != null)

            {

                for (int var8 = 0; var8 < var7.getSizeInventory(); ++var8)//This is cycling through the items so it will drop them all

                {

                    ItemStack var9 = var7.getStackInSlot(var8);//Placing all the items as an itemstack to be dropped

 

                    if (var9 != null)

                    {

                        float var10 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float var11 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float var12 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;//Determining the velocity in which direction to shoot items

 

                        while (var9.stackSize > 0)

                        {

                            int var13 = this.furnaceRand.nextInt(21) + 10;//Not completely sure

 

                            if (var13 > var9.stackSize)

                            {

                                var13 = var9.stackSize;

                            }

 

                            var9.stackSize -= var13;

                            EntityItem var14 = new EntityItem(par1World, (double)((float)par2 + var10), (double)((float)par3 + var11), (double)((float)par4 + var12), new ItemStack(var9.itemID, var13, var9.getItemDamage()));

 

                            if (var9.hasTagCompound())

                            {

                                var14.item.setTagCompound((NBTTagCompound)var9.getTagCompound().copy());

                            }

 

                            float var15 = 0.05F;

                            var14.motionX = (double)((float)this.furnaceRand.nextGaussian() * var15);

                            var14.motionY = (double)((float)this.furnaceRand.nextGaussian() * var15 + 0.2F);

                            var14.motionZ = (double)((float)this.furnaceRand.nextGaussian() * var15);

                            par1World.spawnEntityInWorld(var14);

                        }

                    }

                }

            }

        }

 

        super.breakBlock(par1World, par2, par3, par4, par5, par6);

    }

 

 

}

[Kore]

 

 

    [glow=green,2,300]if(par1 == indexOfRecipe)//indexOfRecipe is the recipes number in the order you register it[/glow]

 

        //ADDED BY KORE

        ItemStack dropItem = new ItemStack(null, 0);/Used so incase of game error it doesnt drop anything

        if(par1==indexOfRecipe){

            int i = rand.nextInt(3);

            switch(i){

            case 0:

                [glow=green,2,300]dropItem = new ItemStack(mod_firefly.FireflyNormalBoy, 1)//dropItem is a temp variable;[/glow]

                break;

            }

            case 1:

                dropItem = new ItemStack(mod_firefly.FireflyNormalGirl, 1)

                break;

            }

            case 2:

                dropItem = new ItemStack(mod_firefly.FireflyNormal, 1)

                break;

            }

        }

 

 

    [glow=green,2,300]

private CatcherRecipes()

    {

        this.addSmelting(mod_firefly.FireflyNormal, new ItemStack(mod_firefly.FireflyNormalBoy), 0.7F);//id of 0 because it is first

        //        input(whatever you are smelting    output(doesn't matter if you use the random)    amount of exp

     

    }[/glow]