even with Blood asp experimental branch

25 files changed, 1858 insertions, 0 deletions

diff --git a/src/main/java/gregtech/api/gui/GT_Container.java b/src/main/java/gregtech/api/gui/GT_Container.java
new file mode 100644
index 0000000000..614d459cb9
--- /dev/null
+++ b/src/main/java/gregtech/api/gui/GT_Container.java
@@ -0,0 +1,559 @@
+package gregtech.api.gui;
+
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Utility;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ICrafting;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+import java.util.List;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * Main Container-Class, used for all my GUIs
+ */
+public class GT_Container extends Container {
+    public IGregTechTileEntity mTileEntity;
+    public InventoryPlayer mPlayerInventory;
+
+    public GT_Container(InventoryPlayer aPlayerInventory, IGregTechTileEntity aTileEntityInventory) {
+
+        mTileEntity = aTileEntityInventory;
+        mPlayerInventory = aPlayerInventory;
+    }
+
+    /**
+     * To add the Slots to your GUI
+     */
+    public void addSlots(InventoryPlayer aPlayerInventory) {
+        //
+    }
+
+    /**
+     * Amount of regular Slots in the GUI (so, non-HoloSlots)
+     */
+    public int getSlotCount() {
+        return 0;
+    }
+
+    /**
+     * Amount of ALL Slots in the GUI including HoloSlots and ArmorSlots, but excluding regular Player Slots
+     */
+    protected final int getAllSlotCount() {
+        if (inventorySlots != null) {
+            if (doesBindPlayerInventory()) return inventorySlots.size() - 36;
+            return inventorySlots.size();
+        }
+        return getSlotCount();
+    }
+
+    /**
+     * Start-Index of the usable Slots (the first non-HoloSlot)
+     */
+    public int getSlotStartIndex() {
+        return 0;
+    }
+
+    public int getShiftClickStartIndex() {
+        return getSlotStartIndex();
+    }
+
+    /**
+     * Amount of Slots in the GUI the player can Shift-Click into. Uses also getSlotStartIndex
+     */
+    public int getShiftClickSlotCount() {
+        return 0;
+    }
+
+    /**
+     * Is Player-Inventory visible?
+     */
+    public boolean doesBindPlayerInventory() {
+        return true;
+    }
+
+    /**
+     * Override this Function with something like "return mTileEntity.isUseableByPlayer(aPlayer);"
+     */
+    @Override
+    public boolean canInteractWith(EntityPlayer aPlayer) {
+        return false;
+    }
+
+    protected void bindPlayerInventory(InventoryPlayer aInventoryPlayer) {
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 9; j++) {
+                addSlotToContainer(new Slot(aInventoryPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));
+            }
+        }
+
+        for (int i = 0; i < 9; i++) {
+            addSlotToContainer(new Slot(aInventoryPlayer, i, 8 + i * 18, 142));
+        }
+    }
+
+    @Override
+    public ItemStack slotClick(int aSlotIndex, int aMouseclick, int aShifthold, EntityPlayer aPlayer) {
+        mTileEntity.markDirty();
+
+        if (aSlotIndex >= 0) {
+            if (inventorySlots.get(aSlotIndex) == null || inventorySlots.get(aSlotIndex) instanceof GT_Slot_Holo)
+                return null;
+            if (!(inventorySlots.get(aSlotIndex) instanceof GT_Slot_Armor)) if (aSlotIndex < getAllSlotCount())
+                if (aSlotIndex < getSlotStartIndex() || aSlotIndex >= getSlotStartIndex() + getSlotCount()) return null;
+        }
+
+        try {
+            return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+
+        ItemStack rStack = null;
+        InventoryPlayer aPlayerInventory = aPlayer.inventory;
+        Slot aSlot;
+        ItemStack tTempStack;
+        int tTempStackSize;
+        ItemStack aHoldStack;
+
+        if ((aShifthold == 0 || aShifthold == 1) && (aMouseclick == 0 || aMouseclick == 1)) {
+            if (aSlotIndex == -999) {
+                if (aPlayerInventory.getItemStack() != null && aSlotIndex == -999) {
+                    if (aMouseclick == 0) {
+                        aPlayer.dropPlayerItemWithRandomChoice(aPlayerInventory.getItemStack(), true);
+                        aPlayerInventory.setItemStack(null);
+                    }
+                    if (aMouseclick == 1) {
+                        aPlayer.dropPlayerItemWithRandomChoice(aPlayerInventory.getItemStack().splitStack(1), true);
+                        if (aPlayerInventory.getItemStack().stackSize == 0) {
+                            aPlayerInventory.setItemStack(null);
+                        }
+                    }
+                }
+            } else if (aShifthold == 1) {
+                aSlot = (Slot) this.inventorySlots.get(aSlotIndex);
+                if (aSlot != null && aSlot.canTakeStack(aPlayer)) {
+                    tTempStack = this.transferStackInSlot(aPlayer, aSlotIndex);
+                    if (tTempStack != null) {
+                        rStack = GT_Utility.copy(tTempStack);
+                        if (aSlot.getStack() != null && aSlot.getStack().getItem() == tTempStack.getItem()) {
+                            slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer);
+                        }
+                    }
+                }
+            } else {
+                if (aSlotIndex < 0) {
+                    return null;
+                }
+                aSlot = (Slot) this.inventorySlots.get(aSlotIndex);
+                if (aSlot != null) {
+                    tTempStack = aSlot.getStack();
+                    ItemStack var13 = aPlayerInventory.getItemStack();
+                    if (tTempStack != null) {
+                        rStack = GT_Utility.copy(tTempStack);
+                    }
+                    if (tTempStack == null) {
+                        if (var13 != null && aSlot.isItemValid(var13)) {
+                            tTempStackSize = aMouseclick == 0 ? var13.stackSize : 1;
+                            if (tTempStackSize > aSlot.getSlotStackLimit()) {
+                                tTempStackSize = aSlot.getSlotStackLimit();
+                            }
+                            aSlot.putStack(var13.splitStack(tTempStackSize));
+
+                            if (var13.stackSize == 0) {
+                                aPlayerInventory.setItemStack((ItemStack) null);
+                            }
+                        }
+                    } else if (aSlot.canTakeStack(aPlayer)) {
+                        if (var13 == null) {
+                            tTempStackSize = aMouseclick == 0 ? tTempStack.stackSize : (tTempStack.stackSize + 1) / 2;
+                            aHoldStack = aSlot.decrStackSize(tTempStackSize);
+                            aPlayerInventory.setItemStack(aHoldStack);
+                            if (tTempStack.stackSize == 0) {
+                                aSlot.putStack((ItemStack) null);
+                            }
+                            aSlot.onPickupFromSlot(aPlayer, aPlayerInventory.getItemStack());
+                        } else if (aSlot.isItemValid(var13)) {
+                            if (tTempStack.getItem() == var13.getItem() && tTempStack.getItemDamage() == var13.getItemDamage() && ItemStack.areItemStackTagsEqual(tTempStack, var13)) {
+                                tTempStackSize = aMouseclick == 0 ? var13.stackSize : 1;
+                                if (tTempStackSize > aSlot.getSlotStackLimit() - tTempStack.stackSize) {
+                                    tTempStackSize = aSlot.getSlotStackLimit() - tTempStack.stackSize;
+                                }
+                                if (tTempStackSize > var13.getMaxStackSize() - tTempStack.stackSize) {
+                                    tTempStackSize = var13.getMaxStackSize() - tTempStack.stackSize;
+                                }
+                                var13.splitStack(tTempStackSize);
+                                if (var13.stackSize == 0) {
+                                    aPlayerInventory.setItemStack((ItemStack) null);
+                                }
+                                tTempStack.stackSize += tTempStackSize;
+                            } else if (var13.stackSize <= aSlot.getSlotStackLimit()) {
+                                aSlot.putStack(var13);
+                                aPlayerInventory.setItemStack(tTempStack);
+                            }
+                        } else if (tTempStack.getItem() == var13.getItem() && var13.getMaxStackSize() > 1 && (!tTempStack.getHasSubtypes() || tTempStack.getItemDamage() == var13.getItemDamage()) && ItemStack.areItemStackTagsEqual(tTempStack, var13)) {
+                            tTempStackSize = tTempStack.stackSize;
+
+                            if (tTempStackSize > 0 && tTempStackSize + var13.stackSize <= var13.getMaxStackSize()) {
+                                var13.stackSize += tTempStackSize;
+                                tTempStack = aSlot.decrStackSize(tTempStackSize);
+
+                                if (tTempStack.stackSize == 0) {
+                                    aSlot.putStack((ItemStack) null);
+                                }
+
+                                aSlot.onPickupFromSlot(aPlayer, aPlayerInventory.getItemStack());
+                            }
+                        }
+                    }
+                    aSlot.onSlotChanged();
+                }
+            }
+        } else if (aShifthold == 2 && aMouseclick >= 0 && aMouseclick < 9) {
+            aSlot = (Slot) this.inventorySlots.get(aSlotIndex);
+
+            if (aSlot.canTakeStack(aPlayer)) {
+                tTempStack = aPlayerInventory.getStackInSlot(aMouseclick);
+                boolean var9 = tTempStack == null || aSlot.inventory == aPlayerInventory && aSlot.isItemValid(tTempStack);
+                tTempStackSize = -1;
+
+                if (!var9) {
+                    tTempStackSize = aPlayerInventory.getFirstEmptyStack();
+                    var9 |= tTempStackSize > -1;
+                }
+
+                if (aSlot.getHasStack() && var9) {
+                    aHoldStack = aSlot.getStack();
+                    aPlayerInventory.setInventorySlotContents(aMouseclick, aHoldStack);
+
+                    if ((aSlot.inventory != aPlayerInventory || !aSlot.isItemValid(tTempStack)) && tTempStack != null) {
+                        if (tTempStackSize > -1) {
+                            aPlayerInventory.addItemStackToInventory(tTempStack);
+                            aSlot.decrStackSize(aHoldStack.stackSize);
+                            aSlot.putStack((ItemStack) null);
+                            aSlot.onPickupFromSlot(aPlayer, aHoldStack);
+                        }
+                    } else {
+                        aSlot.decrStackSize(aHoldStack.stackSize);
+                        aSlot.putStack(tTempStack);
+                        aSlot.onPickupFromSlot(aPlayer, aHoldStack);
+                    }
+                } else if (!aSlot.getHasStack() && tTempStack != null && aSlot.isItemValid(tTempStack)) {
+                    aPlayerInventory.setInventorySlotContents(aMouseclick, (ItemStack) null);
+                    aSlot.putStack(tTempStack);
+                }
+            }
+        } else if (aShifthold == 3 && aPlayer.capabilities.isCreativeMode && aPlayerInventory.getItemStack() == null && aSlotIndex >= 0) {
+            aSlot = (Slot) this.inventorySlots.get(aSlotIndex);
+            if (aSlot != null && aSlot.getHasStack()) {
+                tTempStack = GT_Utility.copy(aSlot.getStack());
+                tTempStack.stackSize = tTempStack.getMaxStackSize();
+                aPlayerInventory.setItemStack(tTempStack);
+            }
+        }
+        return rStack;
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer aPlayer, int aSlotIndex) {
+        ItemStack stack = null;
+        Slot slotObject = (Slot) inventorySlots.get(aSlotIndex);
+
+        mTileEntity.markDirty();
+
+        //null checks and checks if the item can be stacked (maxStackSize > 1)
+        if (getSlotCount() > 0 && slotObject != null && slotObject.getHasStack() && !(slotObject instanceof GT_Slot_Holo)) {
+            ItemStack stackInSlot = slotObject.getStack();
+            stack = GT_Utility.copy(stackInSlot);
+
+            //TileEntity -> Player
+            if (aSlotIndex < getAllSlotCount()) {
+                if (doesBindPlayerInventory())
+                    if (!mergeItemStack(stackInSlot, getAllSlotCount(), getAllSlotCount() + 36, true)) {
+                        return null;
+                    }
+                //Player -> TileEntity
+            } else if (!mergeItemStack(stackInSlot, getShiftClickStartIndex(), getShiftClickStartIndex() + getShiftClickSlotCount(), false)) {
+                return null;
+            }
+
+            if (stackInSlot.stackSize == 0) {
+                slotObject.putStack(null);
+            } else {
+                slotObject.onSlotChanged();
+            }
+        }
+        return stack;
+    }
+
+    /**
+     * merges provided ItemStack with the first avaliable one in the container/player inventory
+     */
+    @Override
+    protected boolean mergeItemStack(ItemStack aStack, int aStartIndex, int aSlotCount, boolean par4) {
+        boolean var5 = false;
+        int var6 = aStartIndex;
+
+        mTileEntity.markDirty();
+
+        if (par4) {
+            var6 = aSlotCount - 1;
+        }
+
+        Slot var7;
+        ItemStack var8;
+
+        if (aStack.isStackable()) {
+            while (aStack.stackSize > 0 && (!par4 && var6 < aSlotCount || par4 && var6 >= aStartIndex)) {
+                var7 = (Slot) this.inventorySlots.get(var6);
+                var8 = var7.getStack();
+
+                if (!(var7 instanceof GT_Slot_Holo) && !(var7 instanceof GT_Slot_Output) && var8 != null && var8.getItem() == aStack.getItem() && (!aStack.getHasSubtypes() || aStack.getItemDamage() == var8.getItemDamage()) && ItemStack.areItemStackTagsEqual(aStack, var8)) {
+                    int var9 = var8.stackSize + aStack.stackSize;
+
+                    if (var9 <= aStack.getMaxStackSize()) {
+                        aStack.stackSize = 0;
+                        var8.stackSize = var9;
+                        var7.onSlotChanged();
+                        var5 = true;
+                    } else if (var8.stackSize < aStack.getMaxStackSize()) {
+                        aStack.stackSize -= aStack.getMaxStackSize() - var8.stackSize;
+                        var8.stackSize = aStack.getMaxStackSize();
+                        var7.onSlotChanged();
+                        var5 = true;
+                    }
+                }
+
+                if (par4) {
+                    --var6;
+                } else {
+                    ++var6;
+                }
+            }
+        }
+
+        if (aStack.stackSize > 0) {
+            if (par4) {
+                var6 = aSlotCount - 1;
+            } else {
+                var6 = aStartIndex;
+            }
+
+            while (!par4 && var6 < aSlotCount || par4 && var6 >= aStartIndex) {
+                var7 = (Slot) this.inventorySlots.get(var6);
+                var8 = var7.getStack();
+
+                if (var8 == null) {
+                    var7.putStack(GT_Utility.copy(aStack));
+                    var7.onSlotChanged();
+                    aStack.stackSize = 0;
+                    var5 = true;
+                    break;
+                }
+
+                if (par4) {
+                    --var6;
+                } else {
+                    ++var6;
+                }
+            }
+        }
+
+        return var5;
+    }
+
+    @Override
+    protected Slot addSlotToContainer(Slot par1Slot) {
+        try {
+            return super.addSlotToContainer(par1Slot);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return par1Slot;
+    }
+
+    @Override
+    public void addCraftingToCrafters(ICrafting par1ICrafting) {
+        try {
+            super.addCraftingToCrafters(par1ICrafting);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public List getInventory() {
+        try {
+            return super.getInventory();
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return null;
+    }
+
+    @Override
+    public void removeCraftingFromCrafters(ICrafting par1ICrafting) {
+        try {
+            super.removeCraftingFromCrafters(par1ICrafting);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        try {
+            super.detectAndSendChanges();
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public boolean enchantItem(EntityPlayer par1EntityPlayer, int par2) {
+        try {
+            return super.enchantItem(par1EntityPlayer, par2);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return false;
+    }
+
+    @Override
+    public Slot getSlotFromInventory(IInventory par1IInventory, int par2) {
+        try {
+            return super.getSlotFromInventory(par1IInventory, par2);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return null;
+    }
+
+    @Override
+    public Slot getSlot(int par1) {
+        try {
+            if (this.inventorySlots.size() > par1) return super.getSlot(par1);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return null;
+    }
+
+    @Override
+    public boolean func_94530_a(ItemStack par1ItemStack, Slot par2Slot) {
+        try {
+            return super.func_94530_a(par1ItemStack, par2Slot);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return true;
+    }
+
+    @Override
+    protected void retrySlotClick(int par1, int par2, boolean par3, EntityPlayer par4EntityPlayer) {
+        try {
+            super.retrySlotClick(par1, par2, par3, par4EntityPlayer);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void onContainerClosed(EntityPlayer par1EntityPlayer) {
+        try {
+            super.onContainerClosed(par1EntityPlayer);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void onCraftMatrixChanged(IInventory par1IInventory) {
+        try {
+            super.onCraftMatrixChanged(par1IInventory);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void putStackInSlot(int par1, ItemStack par2ItemStack) {
+        try {
+            super.putStackInSlot(par1, par2ItemStack);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void putStacksInSlots(ItemStack[] par1ArrayOfItemStack) {
+        try {
+            super.putStacksInSlots(par1ArrayOfItemStack);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void updateProgressBar(int par1, int par2) {
+        try {
+            super.updateProgressBar(par1, par2);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public short getNextTransactionID(InventoryPlayer par1InventoryPlayer) {
+        try {
+            return super.getNextTransactionID(par1InventoryPlayer);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean isPlayerNotUsingContainer(EntityPlayer par1EntityPlayer) {
+        try {
+            return super.isPlayerNotUsingContainer(par1EntityPlayer);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return true;
+    }
+
+    @Override
+    public void setPlayerIsPresent(EntityPlayer par1EntityPlayer, boolean par2) {
+        try {
+            super.setPlayerIsPresent(par1EntityPlayer, par2);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    protected void func_94533_d() {
+        try {
+            super.func_94533_d();
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public boolean canDragIntoSlot(Slot par1Slot) {
+        try {
+            return super.canDragIntoSlot(par1Slot);
+        } catch (Throwable e) {
+            e.printStackTrace(GT_Log.err);
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gregtech/api/gui/GT_ContainerMetaTile_Machine.java b/src/main/java/gregtech/api/gui/GT_ContainerMetaTile_Machine.java
new file mode 100644
index 0000000000..c2fa1ab8ad
--- /dev/null
+++ b/src/main/java/gregtech/api/gui/GT_ContainerMetaTile_Machine.java
@@ -0,0 +1,185 @@
+package gregtech.api.gui;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.ICrafting;
+
+import java.util.Iterator;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * The Container I use for all my MetaTileEntities
+ */
+public class GT_ContainerMetaTile_Machine extends GT_Container {
+
+    public int mActive = 0, mMaxProgressTime = 0, mProgressTime = 0, mEnergy = 0, mSteam = 0, mSteamStorage = 0, mStorage = 0, mOutput = 0, mInput = 0, mID = 0, mDisplayErrorCode = 0;
+    private int oActive = 0, oMaxProgressTime = 0, oProgressTime = 0, oEnergy = 0, oSteam = 0, oSteamStorage = 0, oStorage = 0, oOutput = 0, oInput = 0, oID = 0, oDisplayErrorCode = 0, mTimer = 0;
+
+
+    public GT_ContainerMetaTile_Machine(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) {
+        super(aInventoryPlayer, aTileEntity);
+
+        mTileEntity = aTileEntity;
+
+        if (mTileEntity != null && mTileEntity.getMetaTileEntity() != null) {
+            addSlots(aInventoryPlayer);
+            if (doesBindPlayerInventory()) bindPlayerInventory(aInventoryPlayer);
+            detectAndSendChanges();
+        } else {
+            aInventoryPlayer.player.openContainer = aInventoryPlayer.player.inventoryContainer;
+        }
+    }
+    public GT_ContainerMetaTile_Machine(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity, boolean doesBindInventory) {
+        super(aInventoryPlayer, aTileEntity);
+        mTileEntity = aTileEntity;
+
+        if (mTileEntity != null && mTileEntity.getMetaTileEntity() != null) {
+            addSlots(aInventoryPlayer);
+            if (doesBindPlayerInventory() && doesBindInventory) bindPlayerInventory(aInventoryPlayer);
+            detectAndSendChanges();
+        } else {
+            aInventoryPlayer.player.openContainer = aInventoryPlayer.player.inventoryContainer;
+        }
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        super.detectAndSendChanges();
+        if (mTileEntity.isClientSide() || mTileEntity.getMetaTileEntity() == null) return;
+        mStorage = (int) Math.min(Integer.MAX_VALUE, mTileEntity.getEUCapacity());
+        mEnergy = (int) Math.min(Integer.MAX_VALUE, mTileEntity.getStoredEU());
+        mSteamStorage = (int) Math.min(Integer.MAX_VALUE, mTileEntity.getSteamCapacity());
+        mSteam = (int) Math.min(Integer.MAX_VALUE, mTileEntity.getStoredSteam());
+        mOutput = (int) Math.min(Integer.MAX_VALUE, mTileEntity.getOutputVoltage());
+        mInput = (int) Math.min(Integer.MAX_VALUE, mTileEntity.getInputVoltage());
+        mDisplayErrorCode = mTileEntity.getErrorDisplayID();
+        mProgressTime = mTileEntity.getProgress();
+        mMaxProgressTime = mTileEntity.getMaxProgress();
+        mActive = mTileEntity.isActive() ? 1 : 0;
+        mTimer++;
+
+        Iterator var2 = this.crafters.iterator();
+        while (var2.hasNext()) {
+            ICrafting var1 = (ICrafting) var2.next();
+            if (mTimer % 500 == 10 || oEnergy != mEnergy) {
+                var1.sendProgressBarUpdate(this, 0, mEnergy & 65535);
+                var1.sendProgressBarUpdate(this, 1, mEnergy >>> 16);
+            }
+            if (mTimer % 500 == 10 || oStorage != mStorage) {
+                var1.sendProgressBarUpdate(this, 2, mStorage & 65535);
+                var1.sendProgressBarUpdate(this, 3, mStorage >>> 16);
+            }
+            if (mTimer % 500 == 10 || oOutput != mOutput) {
+                var1.sendProgressBarUpdate(this, 4, mOutput);
+            }
+            if (mTimer % 500 == 10 || oInput != mInput) {
+                var1.sendProgressBarUpdate(this, 5, mInput);
+            }
+            if (mTimer % 500 == 10 || oDisplayErrorCode != mDisplayErrorCode) {
+                var1.sendProgressBarUpdate(this, 6, mDisplayErrorCode);
+            }
+            if (mTimer % 500 == 10 || oProgressTime != mProgressTime) {
+                var1.sendProgressBarUpdate(this, 11, mProgressTime & 65535);
+                var1.sendProgressBarUpdate(this, 12, mProgressTime >>> 16);
+            }
+            if (mTimer % 500 == 10 || oMaxProgressTime != mMaxProgressTime) {
+                var1.sendProgressBarUpdate(this, 13, mMaxProgressTime & 65535);
+                var1.sendProgressBarUpdate(this, 14, mMaxProgressTime >>> 16);
+            }
+            if (mTimer % 500 == 10 || oID != mID) {
+                var1.sendProgressBarUpdate(this, 15, mID);
+            }
+            if (mTimer % 500 == 10 || oActive != mActive) {
+                var1.sendProgressBarUpdate(this, 16, mActive);
+            }
+            if (mTimer % 500 == 10 || oSteam != mSteam) {
+                var1.sendProgressBarUpdate(this, 17, mSteam & 65535);
+                var1.sendProgressBarUpdate(this, 18, mSteam >>> 16);
+            }
+            if (mTimer % 500 == 10 || oSteamStorage != mSteamStorage) {
+                var1.sendProgressBarUpdate(this, 19, mSteamStorage & 65535);
+                var1.sendProgressBarUpdate(this, 20, mSteamStorage >>> 16);
+            }
+        }
+
+        oID = mID;
+        oSteam = mSteam;
+        oInput = mInput;
+        oActive = mActive;
+        oOutput = mOutput;
+        oEnergy = mEnergy;
+        oStorage = mStorage;
+        oSteamStorage = mSteamStorage;
+        oProgressTime = mProgressTime;
+        oMaxProgressTime = mMaxProgressTime;
+        oDisplayErrorCode = mDisplayErrorCode;
+    }
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    public void updateProgressBar(int par1, int par2) {
+        super.updateProgressBar(par1, par2);
+        switch (par1) {
+            case 0:
+                mEnergy = mEnergy & -65536 | par2;
+                break;
+            case 1:
+                mEnergy = mEnergy & 65535 | par2 << 16;
+                break;
+            case 2:
+                mStorage = mStorage & -65536 | par2;
+                break;
+            case 3:
+                mStorage = mStorage & 65535 | par2 << 16;
+                break;
+            case 4:
+                mOutput = par2;
+                break;
+            case 5:
+                mInput = par2;
+                break;
+            case 6:
+                mDisplayErrorCode = par2;
+                break;
+            case 11:
+                mProgressTime = mProgressTime & -65536 | par2;
+                break;
+            case 12:
+                mProgressTime = mProgressTime & 65535 | par2 << 16;
+                break;
+            case 13:
+                mMaxProgressTime = mMaxProgressTime & -65536 | par2;
+                break;
+            case 14:
+                mMaxProgressTime = mMaxProgressTime & 65535 | par2 << 16;
+                break;
+            case 15:
+                mID = par2;
+                break;
+            case 16:
+                mActive = par2;
+                break;
+            case 17:
+                mSteam = mSteam & -65536 | par2;
+                break;
+            case 18:
+                mSteam = mSteam & 65535 | par2 << 1