UpdateEntity MC

package firstetestmod;

import java.util.List;
import java.util.Random;

import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.prefab.BasicSink;
import ic2.api.energy.tile.IEnergySink;
import ic2.api.energy.tile.IEnergyTile;
import ic2.api.info.Info;
import ic2.api.network.INetworkDataProvider;
import ic2.api.network.INetworkTileEntityEventListener;
import ic2.api.network.INetworkUpdateListener;
import ic2.api.tile.IWrenchable;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityTNTPrimed;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
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.MinecraftForge;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class TileEntityPlateMachine extends BasicSink implements
        ISidedInventory, IWrenchable, IEnergyTile, IInventory, IEnergySink {
        public TileEntityPlateMachine(TileEntity TileEntityPlateMachine, int maxPower, int tier1) {
        super(TileEntityPlateMachine, maxPower, tier1);

    }

    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 };

    /**
     * The ItemStacks that hold the items currently being used in the furnace
     */
    private ItemStack[] slots = new ItemStack[3];

    /**
     * the speed of this furnace, 200 is normal / how many ticks it takes : 30
     * ticks = 1 second
     */
    public int maceratingSpeed = 500;

    /** Power */
    public double power = 0.0D;
    /** Max Power */
    public double maxPower = 32000.0D;
    public boolean addedToEnet;

    /** The number of ticks that the current item has been cooking for */
    public int cookTime;

    private String field_94130_e;
    private String PlateMachineName;
    private Object field_145850_b;

    public void PlateMachineName(String string) {
        this.PlateMachineName = string;
    }

    /**
     * Returns the number of slots in the inventory.
     */
    public int getSizeInventory() {
        return this.slots.length;
    }

    /**
     * Returns the stack in slot i
     */
    public ItemStack getStackInSlot(int par1) {
        return this.slots[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.slots[par1] != null) {
            ItemStack itemstack;

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

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

                return itemstack;
            }
        } 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.slots[par1] != null) {
            ItemStack itemstack = this.slots[par1];
            this.slots[par1] = null;
            return itemstack;
        } 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.slots[par1] = par2ItemStack;

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

    /**
     * Returns the name of the inventory.
     */
    public String getInvName() {
        return this.isInvNameLocalized() ? this.field_94130_e
                : "container.PlateMachine";
    }

    /**
     * If this returns false, the inventory name will be used as an unlocalized
     * name, and translated into the player's language. Otherwise it will be
     * used directly.
     */
    public boolean isInvNameLocalized() {
        return this.field_94130_e != null && this.field_94130_e.length() > 0;
    }

    @Override
    public String getInventoryName() {
        return this.hasCustomInventoryName() ? this.field_94130_e
                : "container.PlateMachine";
    }

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

    /**
     * Sets the custom display name to use when opening a GUI linked to this
     * tile entity.
     */
    public void setGuiDisplayName(String par1Str) {
        this.field_94130_e = par1Str;
    }

    /**
     * Reads a tile entity from NBT.
     */
    public void readFromNBT(NBTTagCompound par1NBTTagCompound) {
        super.readFromNBT(par1NBTTagCompound);

        if (par1NBTTagCompound.hasKey("power")) {
            this.power = par1NBTTagCompound.getDouble("power");
        }

        NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items", 10);
        this.slots = new ItemStack[this.getSizeInventory()];

        for (int i = 0; i < nbttaglist.tagCount(); ++i) {
            NBTTagCompound nbttagcompound1 = (NBTTagCompound) nbttaglist
                    .getCompoundTagAt(i);
            byte b0 = nbttagcompound1.getByte("Slot");

            if (b0 >= 0 && b0 < this.slots.length) {
                this.slots[b0] = ItemStack
                        .loadItemStackFromNBT(nbttagcompound1);
            }
        }
        this.cookTime = par1NBTTagCompound.getShort("CookTime");

        if (par1NBTTagCompound.hasKey("container.PlateMachineName")) {
            this.PlateMachineName = par1NBTTagCompound
                    .getString("container.PlateMachineName");
        }
    }

    /**
     * Writes a tile entity to NBT.
     */
    public void writeToNBT(NBTTagCompound par1NBTTagCompound) {
        super.writeToNBT(par1NBTTagCompound);

        par1NBTTagCompound.setDouble("power", this.power);
        par1NBTTagCompound.setShort("power", (short) this.power);
        par1NBTTagCompound.setShort("CookTime", (short) this.cookTime);
        NBTTagList nbttaglist = new NBTTagList();

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

        if (this.isInventoryName()) {
            par1NBTTagCompound.setString("container.PlateMachineName",
                    this.PlateMachineName);
        }
    }

    /**
     * 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.cookTime * par1 / this.maceratingSpeed;
    }

    public double getPowerRemainingScaled(double par1) {
        return this.power * par1 / this.maxPower;
    }

    /**
     * Returns true if the furnace is currently burning
     */
    public boolean hasPower() {
        return this.power > 0;
    }

    public boolean isMacerating() {
        return this.cookTime > 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 flag = this.power > 0;
        boolean flag1 = false;
        if (hasPower() && isMacerating()) {
            this.power--;
        }
        if (!this.worldObj.isRemote) {

            if (this.canSmelt()) {
                ++this.cookTime;

                if (this.cookTime == this.maceratingSpeed) {
                    this.cookTime = 0;
                    this.smeltItem();
                    flag1 = true;
                }
            } else {
                this.cookTime = 0;
            }

            if (this.isMacerating()) {
                flag1 = true;
                PlateMachine.updateFurnaceBlockState(this.cookTime > 0,this.worldObj, this.xCoord, this.yCoord, this.zCoord);

            }
        }


        if (flag1) {
            this.markDirty();
        }
        {
            if (!addedToEnet) onLoaded();
            }
    }

    /**
     * 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.slots[0] == null) {
            return false;
        } else if(this.power > 0) {
            ItemStack itemstack = PlateMachineRecipe
                    .getPlateMachineResult(this.slots[0].getItem());
            if (itemstack == null)
                return false;
            if (this.slots[2] == null)
                return true;
            if (!this.slots[2].isItemEqual(itemstack))
                return false;

            return slots[2].stackSize < itemstack.getMaxStackSize();
        }
        return false;
    }

    /**
     * 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 itemstack = PlateMachineRecipe.getPlateMachineResult(this.slots[0].getItem());

            if (this.slots[2] == null) {
                this.slots[2] = itemstack.copy();
            } else if (this.slots[2].isItemEqual(itemstack)) {
                slots[2].stackSize += (itemstack.stackSize);
            }

            --this.slots[0].stackSize;

            if (this.slots[0].stackSize <= 0) {
                this.slots[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
     * @deprecated
     */
    public static double getItemPower(ItemStack itemstack) {
        if (itemstack == null) {
            return 0;
        } else {
            Item item = itemstack.getItem();

            if (item == Items.redstone)
                return 10.0D;
            if (item == Items.nether_star)
                return 50.0D;
            if (item == firsttestmodmain.LacirisItem)
                return 500.0D;
            if (item == firsttestmodmain.UniversalMatter)
                return 1000.0D;
            return 0.0D;
        }
    }

    /**
     * Return true if item is a fuel source (getItempower() > 0).
     * @deprecated
     */
    public static boolean isItemFuel(ItemStack par0ItemStack) {
        return getItemPower(par0ItemStack) > 0;
    }

    /**
     * Do not make give this method the name canInteractWith because it clashes
     * with Container
     */
    public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) {
        return this.worldObj.getTileEntity(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() {
    }

    /**
     * Returns true if automation is allowed to insert the given stack (ignoring
     * stack size) into the given slot.
     */
    public boolean isItemValidForSlot(int par1, ItemStack par2ItemStack) {
        return par1 == 2 ? false : (par1 == 1 ? isItemFuel(par2ItemStack)
                : true);
    }

    /**
     * Returns an array containing the indices of the slots that can be accessed
     * by automation on the given side of this block.
     */
    public int[] getAccessibleSlotsFromSide(int par1) {
        return par1 == 0 ? slots_bottom : (par1 == 1 ? slots_top : slots_sides);
    }

    /**
     * Returns true if automation can insert the given item in the given slot
     * from the given side. Args: Slot, item, side
     */
    public boolean canInsertItem(int par1, ItemStack par2ItemStack, int par3) {
        return this.isItemValidForSlot(par1, par2ItemStack);
    }

    /**
     * Returns true if automation can extract the given item in the given slot
     * from the given side. Args: Slot, item, side
     */
    public boolean canExtractItem(int par1, ItemStack par2ItemStack, int par3) {
        return par3 != 0 || par1 != 1
                || par2ItemStack.getItem() == Items.bucket;
    }

    public boolean wrenchCanRemove(EntityPlayer entityPlayer) {
        return true;
    }

    public float getWrenchDropRate() {
        return 1.0F;
    }

    @Override
    public boolean hasCustomInventoryName() {
        return false;
    }

    @Override
    public void openInventory() {

    }

    @Override
    public void closeInventory() {

    }

    @Override
    public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) {
        return false;
    }

    @Override
    public short getFacing() {
        return 0;
    }

    @Override
    public void setFacing(short facing) {

    }

    @Override
    public ItemStack getWrenchDrop(EntityPlayer entityPlayer) {
        return null;
    }

    @Override
    public boolean acceptsEnergyFrom(TileEntity emitter,
            ForgeDirection direction) {
        return true;
    }

    @Override
    public double getDemandedEnergy() {
        return this.maxPower - this.power;
    }

    @Override
    public int getSinkTier() {
        return 1;
    }

    @Override
    public double injectEnergy(ForgeDirection forgeDirection, double v,
            double v2) {
        if (this.power >= this.maxPower) {
            return v;
        }
        this.power += v;

        return 0.0D;
    }


    @Override
    public void invalidate() {
        super.invalidate();

        onChunkUnload();
    }

    public void onLoaded() {
        if (!addedToEnet && !FMLCommonHandler.instance().getEffectiveSide().isClient() && Info.isIc2Available()) {
        MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
        this.addedToEnet = true;

        }
    }
    @Override
    public void onChunkUnload() {
        if (addedToEnet && Info.isIc2Available()) {
            MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));

            addedToEnet = false;
        }
    }



    public boolean isAddedToEnergyNet() {
        return this.addedToEnet;
    }
}