Merge pull request #734 from GTNewHorizons/patch-cover-nbt

convert cover data storage to a full nbt tag

4 files changed, 795 insertions, 52 deletions

diff --git a/src/main/java/gregtech/api/util/GT_CoverBehavior.java b/src/main/java/gregtech/api/util/GT_CoverBehavior.java
index 14c8cc1308..9972331eb3 100644
--- a/src/main/java/gregtech/api/util/GT_CoverBehavior.java
+++ b/src/main/java/gregtech/api/util/GT_CoverBehavior.java
@@ -3,21 +3,179 @@ package gregtech.api.util;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.net.GT_Packet_TileEntityCoverGUI;
-import gregtech.api.objects.GT_ItemStack;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
 import net.minecraftforge.fluids.Fluid;
 
 import static gregtech.api.enums.GT_Values.E;
 
 /**
- * For Covers with a special behavior.
+ * For Covers with a special behavior. Has fixed storage format of 4 byte. Not very convenient...
  */
-public abstract class GT_CoverBehavior {
+public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializableObject.LegacyCoverData> {
 
     public EntityPlayer lastPlayer = null;
 
+    public GT_CoverBehavior() {
+        super(ISerializableObject.LegacyCoverData.class);
+    }
+
+    private static int convert(ISerializableObject.LegacyCoverData data) {
+        return data == null ? 0 : data.get();
+    }
+
+    // region bridge the parent call to legacy calls
+
+    @Override
+    public final ISerializableObject.LegacyCoverData createDataObject() {
+        return new ISerializableObject.LegacyCoverData();
+    }
+
+    @Override
+    public ISerializableObject.LegacyCoverData createDataObject(int aLegacyData) {
+        return new ISerializableObject.LegacyCoverData(aLegacyData);
+    }
+
+    @Override
+    protected boolean isRedstoneSensitiveImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        return isRedstoneSensitive(aSide, aCoverID, aCoverVariable.get(), aTileEntity, aTimer);
+    }
+
+    @Override
+    protected ISerializableObject.LegacyCoverData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        if (aCoverVariable == null)
+            aCoverVariable = new ISerializableObject.LegacyCoverData();
+        aCoverVariable.set(doCoverThings(aSide, aInputRedstone, aCoverID, aCoverVariable.get(), aTileEntity, aTimer));
+        return aCoverVariable;
+    }
+
+    @Override
+    protected boolean onCoverRightClickImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return onCoverRightclick(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ);
+    }
+
+    @Override
+    protected ISerializableObject.LegacyCoverData onCoverScrewdriverClickImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (aCoverVariable == null)
+            aCoverVariable = new ISerializableObject.LegacyCoverData();
+        aCoverVariable.set(onCoverScrewdriverclick(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ));
+        return aCoverVariable;
+    }
+
+    @Override
+    protected boolean onCoverShiftRightClickImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) {
+        return onCoverShiftRightclick(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer);
+    }
+
+    @Override
+    protected Object getClientGUIImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, World aWorld) {
+        return getClientGUI(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean onCoverRemovalImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, boolean aForced) {
+        return onCoverRemoval(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aForced);
+    }
+
+    @Override
+    protected String getDescriptionImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return getDescription(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected float getBlastProofLevelImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return getBlastProofLevel(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsRedstoneGoInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return letsRedstoneGoIn(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsRedstoneGoOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return letsRedstoneGoOut(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsFibreGoInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return letsFibreGoIn(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsFibreGoOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return letsFibreGoOut(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsEnergyInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return letsEnergyIn(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsEnergyOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return letsEnergyOut(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean letsFluidInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return letsFluidIn(aSide, aCoverID, convert(aCoverVariable), aFluid, aTileEntity);
+    }
+
+    @Override
+    protected boolean letsFluidOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return letsFluidOut(aSide, aCoverID, convert(aCoverVariable), aFluid, aTileEntity);
+    }
+
+    @Override
+    protected boolean letsItemsInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return letsItemsIn(aSide, aCoverID, convert(aCoverVariable), aSlot, aTileEntity);
+    }
+
+    @Override
+    protected boolean letsItemsOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return letsItemsOut(aSide, aCoverID, convert(aCoverVariable), aSlot, aTileEntity);
+    }
+
+    @Override
+    protected boolean isGUIClickableImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return isGUIClickable(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return manipulatesSidedRedstoneOutput(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected boolean alwaysLookConnectedImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return alwaysLookConnected(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected byte getRedstoneInputImpl(byte aSide, byte aInputRedstone, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return getRedstoneInput(aSide, aInputRedstone, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected int getTickRateImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return getTickRate(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected byte getLensColorImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return getLensColor(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    @Override
+    protected ItemStack getDropImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) {
+        return getDrop(aSide, aCoverID, convert(aCoverVariable), aTileEntity);
+    }
+
+    // endregion
+
     public boolean isRedstoneSensitive(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) {
         return true;
     }
@@ -39,15 +197,6 @@ public abstract class GT_CoverBehavior {
     }
 
     /**
-     * Called when someone rightclicks this Cover Client Side
-     * <p/>
-     * return true, if something actually happens.
-     */
-    public boolean onCoverRightclickClient(byte aSide, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        return false;
-    }
-
-    /**
      * Called when someone rightclicks this Cover with a Screwdriver. Doesn't call @onCoverRightclick in this Case.
      * <p/>
      * return the new Value of the Cover Variable
@@ -68,22 +217,11 @@ public abstract class GT_CoverBehavior {
         return false;
     }
 
-    public boolean hasCoverGUI() {
-        return false;
-    }
-
     public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity) {
         return null;
     }
 
     /**
-     * Checks if the Cover can be placed on this.
-     */
-    public boolean isCoverPlaceable(byte aSide, GT_ItemStack aStack, ICoverable aTileEntity) {
-        return true;
-    }
-
-    /**
      * Removes the Cover if this returns true, or if aForced is true.
      * Doesn't get called when the Machine Block is getting broken, only if you break the Cover away from the Machine.
      */
@@ -219,13 +357,6 @@ public abstract class GT_CoverBehavior {
     }
 
     /**
-     * If this is a simple Cover, which can also be used on Bronze Machines and similar.
-     */
-    public boolean isSimpleCover() {
-        return false;
-    }
-
-    /**
      * The MC Color of this Lens. -1 for no Color (meaning this isn't a Lens then).
      */
     public byte getLensColor(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
@@ -238,15 +369,4 @@ public abstract class GT_CoverBehavior {
     public ItemStack getDrop(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return GT_OreDictUnificator.get(true, aTileEntity.getCoverItemAtSide(aSide));
     }
-
-    /**
-     * @return sets the Cover upon placement.
-     */
-    public void placeCover(byte aSide, ItemStack aCover, ICoverable aTileEntity) {
-        aTileEntity.setCoverIDAtSide(aSide, GT_Utility.stackToInt(aCover));
-    }
-    
-    public String trans(String aNr, String aEnglish){
-    	return GT_LanguageManager.addStringLocalization("Interaction_DESCRIPTION_Index_"+aNr, aEnglish, false);
-    }
 }
diff --git a/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java b/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java
new file mode 100644
index 0000000000..50ef2632d9
--- /dev/null
+++ b/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java
@@ -0,0 +1,482 @@
+package gregtech.api.util;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.net.GT_Packet_TileEntityCoverGUI;
+import gregtech.api.objects.GT_ItemStack;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.Fluid;
+
+import static gregtech.api.enums.GT_Values.E;
+
+/**
+ * For Covers with a special behavior.
+ *
+ * @author glease
+ */
+public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> {
+
+    public EntityPlayer lastPlayer = null;
+    private final Class<T> typeToken;
+
+    protected GT_CoverBehaviorBase(Class<T> typeToken) {
+        this.typeToken = typeToken;
+    }
+
+    public abstract T createDataObject(int aLegacyData);
+
+    public abstract T createDataObject();
+
+    public T createDataObject(NBTBase aNBT) {
+        T ret = createDataObject();
+        ret.loadDataFromNBT(aNBT);
+        return ret;
+    }
+
+    public final T cast(ISerializableObject aData) {
+        if (typeToken.isInstance(aData))
+            return forceCast(aData);
+        return null;
+    }
+
+    private T forceCast(ISerializableObject aData) {
+        return typeToken.cast(aData);
+    }
+
+    // region facade
+
+    public final boolean isRedstoneSensitive(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        return isRedstoneSensitiveImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aTimer);
+    }
+
+    /**
+     * Called by updateEntity inside the covered TileEntity. aCoverVariable is the Value you returned last time.
+     */
+    public final T doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        return doCoverThingsImpl(aSide, aInputRedstone, aCoverID, forceCast(aCoverVariable), aTileEntity, aTimer);
+    }
+
+    /**
+     * Called when someone rightclicks this Cover.
+     * <p/>
+     * return true, if something actually happens.
+     */
+    public final boolean onCoverRightClick(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return onCoverRightClickImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ);
+    }
+
+    /**
+     * Called when someone rightclicks this Cover with a Screwdriver. Doesn't call @onCoverRightclick in this Case.
+     * <p/>
+     * return the new Value of the Cover Variable
+     */
+    public final T onCoverScrewdriverClick(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return onCoverScrewdriverClickImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ);
+    }
+
+    /**
+     * Called when someone shift-rightclicks this Cover with no tool. Doesn't call @onCoverRightclick in this Case.
+     */
+    public final boolean onCoverShiftRightClick(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) {
+        return onCoverShiftRightClickImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer);
+    }
+
+    public final Object getClientGUI(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, World aWorld) {
+        return getClientGUIImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aWorld);
+    }
+
+    /**
+     * Removes the Cover if this returns true, or if aForced is true.
+     * Doesn't get called when the Machine Block is getting broken, only if you break the Cover away from the Machine.
+     */
+    public final boolean onCoverRemoval(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, boolean aForced) {
+        return onCoverRemovalImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aForced);
+    }
+
+    /**
+     * Gives a small Text for the status of the Cover.
+     */
+    public final String getDescription(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return getDescriptionImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * How Blast Proof the Cover is. 30 is normal.
+     */
+    public final float getBlastProofLevel(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return getBlastProofLevelImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets RS-Signals into the Block
+     * <p/>
+     * This is just Informative so that Machines know if their Redstone Input is blocked or not
+     */
+    public final boolean letsRedstoneGoIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return letsRedstoneGoInImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets RS-Signals out of the Block
+     */
+    public final boolean letsRedstoneGoOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return letsRedstoneGoOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets Fibre-Signals into the Block
+     * <p/>
+     * This is just Informative so that Machines know if their Redstone Input is blocked or not
+     */
+    public final boolean letsFibreGoIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return letsFibreGoInImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets Fibre-Signals out of the Block
+     */
+    public final boolean letsFibreGoOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return letsFibreGoOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets Energy into the Block
+     */
+    public final boolean letsEnergyIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return letsEnergyInImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets Energy out of the Block
+     */
+    public final boolean letsEnergyOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return letsEnergyOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * If it lets Liquids into the Block, aFluid can be null meaning if this is generally allowing Fluids or not.
+     */
+    public final boolean letsFluidIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return letsFluidInImpl(aSide, aCoverID, forceCast(aCoverVariable), aFluid, aTileEntity);
+    }
+
+    /**
+     * If it lets Liquids out of the Block, aFluid can be null meaning if this is generally allowing Fluids or not.
+     */
+    public final boolean letsFluidOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return letsFluidOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aFluid, aTileEntity);
+    }
+
+    /**
+     * If it lets Items into the Block, aSlot = -1 means if it is generally accepting Items (return false for no eraction at all), aSlot = -2 means if it would accept for all Slots Impl(return true to skip the Checks for each Slot).
+     */
+    public final boolean letsItemsIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return letsItemsInImpl(aSide, aCoverID, forceCast(aCoverVariable), aSlot, aTileEntity);
+    }
+
+    /**
+     * If it lets Items out of the Block, aSlot = -1 means if it is generally accepting Items (return false for no eraction at all), aSlot = -2 means if it would accept for all Slots Impl(return true to skip the Checks for each Slot).
+     */
+    public final boolean letsItemsOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return letsItemsOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aSlot, aTileEntity);
+    }
+
+    /**
+     * If it lets you rightclick the Machine normally
+     */
+    public final boolean isGUIClickable(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return isGUIClickableImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * Needs to return true for Covers, which have a Redstone Output on their Facing.
+     */
+    public final boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return manipulatesSidedRedstoneOutputImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * if this Cover should let Pipe Connections look connected even if it is not the case.
+     */
+    public final boolean alwaysLookConnected(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return alwaysLookConnectedImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * Called to determine the incoming Redstone Signal of a Machine.
+     * Returns the original Redstone per default.
+     * The Cover should @letsRedstoneGoIn or the aInputRedstone Parameter is always 0.
+     */
+    public final byte getRedstoneInput(byte aSide, byte aInputRedstone, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return getRedstoneInputImpl(aSide, aInputRedstone, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * Gets the Tick Rate for doCoverThings of the Cover
+     * <p/>
+     * 0 = No Ticks! Yes, 0 is Default, you have to override this
+     */
+    public final int getTickRate(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return getTickRateImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+
+    /**
+     * The MC Color of this Lens. -1 for no Color (meaning this isn't a Lens then).
+     */
+    public final byte getLensColor(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return getLensColorImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
+     * @return the ItemStack dropped by this Cover
+     */
+    public final ItemStack getDrop(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        return getDropImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+    // endregion
+
+    // region impl
+
+    protected boolean isRedstoneSensitiveImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        return true;
+    }
+
+    /**
+     * Called by updateEntity inside the covered TileEntity. aCoverVariable is the Value you returned last time.
+     */
+    protected T doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, T aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        return aCoverVariable;
+    }
+
+    /**
+     * Called when someone rightclicks this Cover.
+     * <p/>
+     * return true, if something actually happens.
+     */
+    protected boolean onCoverRightClickImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return false;
+    }
+
+    /**
+     * Called when someone rightclicks this Cover with a Screwdriver. Doesn't call @onCoverRightclick in this Case.
+     * <p/>
+     * return the new Value of the Cover Variable
+     */
+    protected T onCoverScrewdriverClickImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return aCoverVariable;
+    }
+
+    /**
+     * Called when someone shift-rightclicks this Cover with no tool. Doesn't call @onCoverRightclick in this Case.
+     */
+    protected boolean onCoverShiftRightClickImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) {
+        if (hasCoverGUI() && aPlayer instanceof EntityPlayerMP) {
+            lastPlayer = aPlayer;
+            GT_Values.NW.sendToPlayer(new GT_Packet_TileEntityCoverGUI(aSide, aCoverID, aCoverVariable, aTileEntity, (EntityPlayerMP) aPlayer), (EntityPlayerMP) aPlayer);
+            return true;
+        }
+        return false;
+    }
+
+    protected Object getClientGUIImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, World aWorld) {
+        return null;
+    }
+
+    /**
+     * Removes the Cover if this returns true, or if aForced is true.
+     * Doesn't get called when the Machine Block is getting broken, only if you break the Cover away from the Machine.
+     */
+    protected boolean onCoverRemovalImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, boolean aForced) {
+        return true;
+    }
+
+    /**
+     * Gives a small Text for the status of the Cover.
+     */
+    protected String getDescriptionImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return E;
+    }
+
+    /**
+     * How Blast Proof the Cover is. 30 is normal.
+     */
+    protected float getBlastProofLevelImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return 10.0F;
+    }
+
+    /**
+     * If it lets RS-Signals into the Block
+     * <p/>
+     * This is just Informative so that Machines know if their Redstone Input is blocked or not
+     */
+    protected boolean letsRedstoneGoInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets RS-Signals out of the Block
+     */
+    protected boolean letsRedstoneGoOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Fibre-Signals into the Block
+     * <p/>
+     * This is just Informative so that Machines know if their Redstone Input is blocked or not
+     */
+    protected boolean letsFibreGoInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Fibre-Signals out of the Block
+     */
+    protected boolean letsFibreGoOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Energy into the Block
+     */
+    protected boolean letsEnergyInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Energy out of the Block
+     */
+    protected boolean letsEnergyOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Liquids into the Block, aFluid can be null meaning if this is generally allowing Fluids or not.
+     */
+    protected boolean letsFluidInImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Liquids out of the Block, aFluid can be null meaning if this is generally allowing Fluids or not.
+     */
+    protected boolean letsFluidOutImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Items into the Block, aSlot = -1 means if it is generally accepting Items (return false for no Interaction at all), aSlot = -2 means if it would accept for all Slots (return true to skip the Checks for each Slot).
+     */
+    protected boolean letsItemsInImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets Items out of the Block, aSlot = -1 means if it is generally accepting Items (return false for no Interaction at all), aSlot = -2 means if it would accept for all Slots (return true to skip the Checks for each Slot).
+     */
+    protected boolean letsItemsOutImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * If it lets you rightclick the Machine normally
+     */
+    protected boolean isGUIClickableImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * Needs to return true for Covers, which have a Redstone Output on their Facing.
+     */
+    protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * if this Cover should let Pipe Connections look connected even if it is not the case.
+     */
+    protected boolean alwaysLookConnectedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    /**
+     * Called to determine the incoming Redstone Signal of a Machine.
+     * Returns the original Redstone per default.
+     * The Cover should @letsRedstoneGoIn or the aInputRedstone Parameter is always 0.
+     */
+    protected byte getRedstoneInputImpl(byte aSide, byte aInputRedstone, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return letsRedstoneGoIn(aSide, aCoverID, aCoverVariable, aTileEntity) ? aInputRedstone : 0;
+    }
+
+    /**
+     * Gets the Tick Rate for doCoverThings of the Cover
+     * <p/>
+     * 0 = No Ticks! Yes, 0 is Default, you have to override this
+     */
+    protected int getTickRateImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return 0;
+    }
+
+
+    /**
+     * The MC Color of this Lens. -1 for no Color (meaning this isn't a Lens then).
+     */
+    protected byte getLensColorImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return -1;
+    }
+
+    /**
+     * @return the ItemStack dropped by this Cover
+     */
+    protected ItemStack getDropImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return GT_OreDictUnificator.get(true, aTileEntity.getCoverItemAtSide(aSide));
+    }
+
+    //endregion
+
+    // region no data
+
+    /**
+     * Checks if the Cover can be placed on this.
+     */
+    public boolean isCoverPlaceable(byte aSide, GT_ItemStack aStack, ICoverable aTileEntity) {
+        return true;
+    }
+
+    public boolean hasCoverGUI() {
+        return false;
+    }
+
+    /**
+     * Called when someone rightclicks this Cover Client Side
+     * <p/>
+     * return true, if something actually happens.
+     */
+    public boolean onCoverRightclickClient(byte aSide, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return false;
+    }
+
+    /**
+     * If this is a simple Cover, which can also be used on Bronze Machines and similar.
+     */
+    public boolean isSimpleCover() {
+        return false;
+    }
+
+    /**
+     * sets the Cover upon placement.
+     */
+    public void placeCover(byte aSide, ItemStack aCover, ICoverable aTileEntity) {
+        aTileEntity.setCoverIDAtSide(aSide, GT_Utility.stackToInt(aCover));
+    }
+
+    public String trans(String aNr, String aEnglish) {
+        return GT_LanguageManager.addStringLocalization("Interaction_DESCRIPTION_Index_" + aNr, aEnglish, false);
+    }
+    // endregion
+}
diff --git a/src/main/java/gregtech/api/util/GT_Utility.java b/src/main/java/gregtech/api/util/GT_Utility.java
index 2ae09b6adf..a07868ec68 100644
--- a/src/main/java/gregtech/api/util/GT_Utility.java
+++ b/src/main/java/gregtech/api/util/GT_Utility.java
@@ -104,16 +104,7 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
@@ -2157,7 +2148,7 @@ public class GT_Utility {
             try {
                 if (tTileEntity instanceof ICoverable) {
                     rEUAmount += 300;
-                    String tString = ((ICoverable) tTileEntity).getCoverBehaviorAtSide((byte) aSide).getDescription((byte) aSide, ((ICoverable) tTileEntity).getCoverIDAtSide((byte) aSide), ((ICoverable) tTileEntity).getCoverDataAtSide((byte) aSide), (ICoverable) tTileEntity);
+                    String tString = ((ICoverable) tTileEntity).getCoverBehaviorAtSideNew((byte) aSide).getDescription((byte) aSide, ((ICoverable) tTileEntity).getCoverIDAtSide((byte) aSide), ((ICoverable) tTileEntity).getComplexCoverDataAtSide((byte) aSide), (ICoverable) tTileEntity);
                     if (tString != null && !tString.equals(E)) tList.add(tString);
                 }
             } catch (Throwable e) {
diff --git a/src/main/java/gregtech/api/util/ISerializableObject.java b/src/main/java/gregtech/api/util/ISerializableObject.java
new file mode 100644
index 0000000000..51fa40e55a
--- /dev/null
+++ b/src/main/java/gregtech/api/util/ISerializableObject.java
@@ -0,0 +1,150 @@
+package gregtech.api.util;
+
+import com.google.common.io.ByteArrayDataInput;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTSizeTracker;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagInt;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+/**
+ * We could well have used {@link java.io.Serializable}, but that's too slow and should generally be avoided
+ *
+ * @author glease
+ */
+public interface ISerializableObject {
+
+    @Nonnull
+    ISerializableObject copy();
+
+    @Nonnull
+    NBTBase saveDataToNBT();
+
+    /**
+     * Write data to given ByteBuf
+     * The data saved this way is intended to be stored for short amount of time over network.
+     * DO NOT store it to disks.
+     */
+    // the NBT is an unfortunate piece of tech. everything uses it but its API is not as efficient as could be
+    void writeToByteBuf(ByteBuf aBuf);
+
+    void loadDataFromNBT(NBTBase aNBT);
+
+    /**
+     * Read data from given parameter and return this.
+     * The data read this way is intended to be stored for short amount of time over network.
+     */
+    // the NBT is an unfortunate piece of tech. everything uses it but its API is not as efficient as could be
+    @Nonnull
+    ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer);
+
+    /**
+     * Reverse engineered and adapted {@link cpw.mods.fml.common.network.ByteBufUtils#readTag(ByteBuf)}
+     * Given buffer must contain a serialized NBTTagCompound in minecraft encoding
+     */
+    static NBTTagCompound readCompoundTagFromGreggyByteBuf(ByteArrayDataInput aBuf) {
+        short size = aBuf.readShort();
+        if (size < 0)
+            return null;
+        else  {
+            byte[] buf = new byte[size]; // this is shit, how many copies have we been doing?
+            aBuf.readFully(buf);
+            try {
+                return CompressedStreamTools.func_152457_a(buf, new NBTSizeTracker(2097152L));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    /**
+     * Reverse engineered and adapted {@link cpw.mods.fml.common.network.ByteBufUtils#readItemStack(ByteBuf)}
+     * Given buffer must contain a serialized ItemStack in minecraft encoding
+     */
+    static ItemStack readItemStackFromGreggyByteBuf(ByteArrayDataInput aBuf) {
+        ItemStack stack = null;
+        short id = aBuf.readShort();
+        if (id >= 0) {
+            byte size = aBuf.readByte();
+            short meta = aBuf.readShort();
+            stack = new ItemStack(Item.getItemById(id), size, meta);
+            stack.stackTagCompound = readCompoundTagFromGreggyByteBuf(aBuf);
+        }
+        return stack;
+    }
+
+    final class LegacyCoverData implements ISerializableObject {
+        private int mData;
+
+        public LegacyCoverData() {
+        }
+
+        public LegacyCoverData(int mData) {
+            this.mData = mData;
+        }
+
+        @Override
+        @Nonnull
+        public ISerializableObject copy() {
+            return new LegacyCoverData(mData);
+        }
+
+        @Override
+        @Nonnull
+        public NBTBase saveDataToNBT() {
+            return new NBTTagInt(mData);
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            aBuf.writeInt(mData);
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            mData = aNBT instanceof NBTBase.NBTPrimitive ? ((NBTBase.NBTPrimitive) aNBT).func_150287_d() : 0;
+        }
+
+        @Override
+        @Nonnull
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            mData = aBuf.readInt();
+            return this;
+        }
+
+        public int get() {
+            return mData;
+        }
+
+        public void set(int mData) {
+            this.mData = mData;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            LegacyCoverData that = (LegacyCoverData) o;
+
+            return mData == that.mData;
+        }
+
+        @Override
+        public int hashCode() {
+            return mData;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(mData);
+        }
+    }
+}