TileEntity/Block problem

[mar21]

So, hello ...

I created a Machine (Furnace based) and It require the Power Interface block at bottom.

It will only work if there is (more) 100 points of energy. I created a onBlockAdded in the InterfaceBlock but it not set the values of energyconsume and current energy. Classes are there too :

Interface Class

 

package mar21.omega.machine;

 

import net.minecraft.block.material.Material;

import net.minecraft.creativetab.CreativeTabs;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.world.World;

import mar21.omega.ModCore;

import mar21.omega.machine.tileEntity.TE_PowerInterface;

import mar21.omega.machine.tileEntity.TE_PoweredMelter;

import mar21.omega.mar21.Mar21Block;

 

public class MachinePowerInterface extends Mar21Block{

 

public MachinePowerInterface(int id, Material par2Material,

CreativeTabs par3CreativeTabs) {

super(id, par2Material, par3CreativeTabs);

}

 

    public TileEntity createNewTileEntity(World par1World)

    {

        return new TE_PowerInterface();

    }

   

    public void onBlockAdded(World par1World, int par2, int par3, int par4)

    {

        super.onBlockAdded(par1World, par2, par3, par4);

        par1World.scheduleBlockUpdate(par2, par3, par4, ModCore.machine_power_interface.blockID, 1);

        System.out.println("Power Interface Added to world at "+par2+" "+par3+" "+par4+" Coordinates");

        TE_PowerInterface te_pi = new TE_PowerInterface();

        te_pi.setEnergyConsume(0);

        te_pi.setEnergy(100);

        System.out.println("[Power Interface]Energy: "+te_pi.getEnergy());

        System.out.println("[Power Interface]Consume: "+te_pi.getEnergyConsume());

    }

 

}

 

 

Tile Entity of Interface:

 

package mar21.omega.machine.tileEntity;

 

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.tileentity.TileEntity;

 

public class TE_PowerInterface extends TileEntity{

private int currentEnergy;

private int energyConsume;

private int processSpeed = 200;

private int maxEnergy = 1000;

private int progressSpeed;

private int baseConsume = 100;

 

public void setEnergy(int Energy)//SETS CURRENT ENERGY HOLDING

{

if(this.currentEnergy + Energy >= this.maxEnergy)

{

this.currentEnergy = Energy;

}else{

this.currentEnergy = 0;

}

}

 

public void setBaseConsume(int Energy)

{

this.baseConsume = Energy;

}

 

public void setProcessSpeed(int Speed)

{

this.processSpeed = Speed;

}

 

public int sendEnergy(int Energy)//SENDS ENERGY TO CURRENT ENERGY HOLDING

{

if(this.currentEnergy + Energy > this.maxEnergy)

{

this.currentEnergy += Energy;

return this.currentEnergy;

}

return this.currentEnergy;

}

 

public int removeEnergy(int Energy)//REMOVE ENERGY FROM CURRENT ENERGY HOLDING

{

if(this.currentEnergy - Energy < 0)

{

this.currentEnergy -= Energy;

return this.currentEnergy;

}

if(this.currentEnergy < 0)

{

this.currentEnergy = 0;

return this.currentEnergy;

}

return this.currentEnergy;

}

 

public int getEnergy()//GETS CURRENT ENERGY HOLDING

{

return this.currentEnergy;

}

 

public void setProgressSpeed(int SpeedU)//SETS PROCESSING SPEED//TODO

{

this.progressSpeed = this.processSpeed-(SpeedU*20);

}

 

public void setEnergyConsume(int EnergyU)//SETS ENERGY REQUIRED FOR 1 PROCESS//TODO

{

this.energyConsume = this.baseConsume-(EnergyU*10);

}

 

public int getProgressSpeed()//GETS PROCESSNG SPEED//TODO

{

return this.progressSpeed;

}

 

public int getEnergyConsume()//GETS ENERGY REQUIRED FOR 1 PROCESS//TODO

{

return this.energyConsume;

}

 

@Override

public void readFromNBT(NBTTagCompound tagCompound)

{

super.readFromNBT(tagCompound);

this.currentEnergy = tagCompound.getInteger("energy");

this.progressSpeed = tagCompound.getInteger("speed");

this.energyConsume = tagCompound.getInteger("consume");

}

 

@Override

public void writeToNBT(NBTTagCompound tagCompound)

{

super.writeToNBT(tagCompound);

        tagCompound.setInteger("energy", this.currentEnergy);

        tagCompound.setInteger("speed", this.progressSpeed);

        tagCompound.setInteger("consume", this.energyConsume);

}

 

public boolean canConsume() {

if(this.currentEnergy >= this.baseConsume)

{

return true;

}

return false;

}

}

 

 

 

Things in the Machine class: (dont needed all thing in, it is lots(a lots of lots) lines  )

 

    public void onBlockAdded(World par1World, int par2, int par3, int par4)

    {

        super.onBlockAdded(par1World, par2, par3, par4);

        this.setDefaultDirection(par1World, par2, par3, par4);

        System.out.println("Powered Melter Added to world at "+par2+" "+par3+" "+par4+" Coordinates");

        if(ModCore.machine_power_interface.blockID == par1World.getBlockId(par2, par3-1, par4))

        {

            TE_PowerInterface te_bottom = new TE_PowerInterface();

            System.out.println("Power Interface attached to Powered Melter at "+par2+" "+par3+" "+par4+" Coordinates");

            System.out.println("[Attached Interface]Energy: "+te_bottom.getEnergy());

            System.out.println("[Attached Interface]Consume: "+te_bottom.getEnergyConsume());

        }

    }

 

TileEntity of Machine (I removed things that are unused in this problem)

 

package mar21.omega.machine.tileEntity;

 

import mar21.omega.ModCore;

import mar21.omega.machine.MachinePoweredMelter;

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.common.ForgeDirection;

import net.minecraftforge.common.ForgeDummyContainer;

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

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class TE_PoweredMelter extends TileEntity implements ISidedInventory, net.minecraftforge.common.ISidedInventory

{

    /**

    * Reads a tile entity from NBT.

    */

    public void readFromNBT(NBTTagCompound par1NBTTagCompound)

    {

        super.readFromNBT(par1NBTTagCompound);

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

        this.furnaceItemStacks = new ItemStack[this.getSizeInventory()];

 

        for (int i = 0; i < nbttaglist.tagCount(); ++i)

        {

            NBTTagCompound nbttagcompound1 = (NBTTagCompound)nbttaglist.tagAt(i);

            byte b0 = nbttagcompound1.getByte("Slot");

 

            if (b0 >= 0 && b0 < this.furnaceItemStacks.length)

            {

                this.furnaceItemStacks[b0] = ItemStack.loadItemStackFromNBT(nbttagcompound1);

            }

        }

 

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

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

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

 

        if (par1NBTTagCompound.hasKey("machine_powered_melter"))

        {

            this.field_94130_e = par1NBTTagCompound.getString("machine_powered_melter");

        }

    }

 

    /**

    * 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 nbttaglist = new NBTTagList();

 

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

        {

            if (this.furnaceItemStacks != null)

            {

                NBTTagCompound nbttagcompound1 = new NBTTagCompound();

                nbttagcompound1.setByte("Slot", (byte)i);

                this.furnaceItemStacks.writeToNBT(nbttagcompound1);

                nbttaglist.appendTag(nbttagcompound1);

            }

        }

 

        par1NBTTagCompound.setTag("Items", nbttaglist);

 

        if (this.isInvNameLocalized())

        {

            par1NBTTagCompound.setString("machine_powered_melter", this.field_94130_e);

        }

    }

 

    /**

    * 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 flag = this.furnaceBurnTime > 0;

        boolean flag1 = 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)

                {

                    flag1 = 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();

                    flag1 = true;

                }

            }

            else

            {

                this.furnaceCookTime = 0;

            }

 

            if (flag != this.furnaceBurnTime > 0)

            {

                flag1 = true;

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

            }

        }

 

        if (flag1)

        {

            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()

    {

    TE_PowerInterface te_bottom = new TE_PowerInterface();

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

        {

            return false;

        }

        else if(ModCore.machine_power_interface.blockID != worldObj.getBlockId(xCoord, yCoord-1, zCoord))

        {

        return false;

        }

        else if(te_bottom.getEnergy() < 100)

        {

        return false;

        }

        else

        {

            ItemStack itemstack = MachineMelterRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

 

            if (itemstack == null)

            {

                return false;

            }

 

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

            {

                return true;

            }

 

            if (!this.furnaceItemStacks[2].isItemEqual(itemstack))

            {

                return false;

            }

 

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

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

        }

    }

 

    /**

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

    */

    public void smeltItem()

    {

    TE_PowerInterface te_bottom = new TE_PowerInterface();

        if (this.canSmelt() && te_bottom.canConsume())

        {

        this.currentItemBurnTime += te_bottom.getEnergyConsume();

            ItemStack itemstack = MachineMelterRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

 

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

            {

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

            }

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

            {

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

            }

 

            --this.furnaceItemStacks[0].stackSize;

            te_bottom.removeEnergy(te_bottom.getEnergyConsume());

            System.out.println("Consuming 100p of energy at "+this.xCoord+" "+this.yCoord+" "+this.zCoord);

 

            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 i = par0ItemStack.getItem().itemID;

            Item item = par0ItemStack.getItem();

           

            if (i == ModCore.electrified_crystal.itemID)

            {

            return 1600;

            }

}

 

 

[Moritz]

cool idea^^ you should not use onAddedBlock.

Use onBlockPlacedBy because that onAddedBlock activatet everytime you place a block around him that would make a view problems.

 

hmmm and you could make a transferfunction, That would help to than you can transfer the energy into the furnacemachine. And the furnacemachine would do less lag.

 

I hope that helps

[mar21]

Yes, thanks ...

I created the sending/receiving function, but on the paper momentally

Thanks for the help. I write If this will working...

 

//EDIT

So, it doesnt work, now it doesnt do nothing. .. Any things on memory ?

[Moritz]

hmmm here:

 

Read the tileEntity and change it:

 

/**
 * Side Sensitive getBlockTileEntityFunction
 * @param par0 World
 * @param par1 xCoord
 * @param par2 yCoord
 * @param par3 zCoord
 * @param par4 Side
 * @return TileEntity of the tile entity
         */

now In your tile Entity Place something like that:

public void updateEntity()
{
     for(int i = 0; i<6;i++)
     {
           TileEntity tile = this.getTileEntity(worldObj, xCoord, yCoord, zCoord, i);
          if(tile != null && tile instanceof YourTile)
          {
                YourTile machine = (YourTile)tile;
                machine.fuel+= this.energy;
                this.energy-=this.energy;
          }
     }
}

 

so it is sending the whole energy to your machine.

This is only raw code. You have to make a view additions to it because that thing

will only sending power (if needed or not).

And by the way

[mar21]

Yes, I will try this, thanks...

I rewrited some functions, and I hope it will work as I need 

//EDIT

E, what tileEntity did you mean ?

the power interface or machine ?

///EDIT

More explanation: If I set the Energy to 100 in the TE_PowerInterface it works, but I cant do any operations with it:

It means: transfering and receiving energy... If I try to set the block energy when is placed ( .setEnergy(100) ) it dont work ...

[mar21]

Shift!