Merge addon sources

7 files changed, 1074 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaCustomCoverItem.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaCustomCoverItem.java
new file mode 100644
index 0000000000..8edb8c2cf9
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaCustomCoverItem.java
@@ -0,0 +1,222 @@
+package gtPlusPlus.xmod.gregtech.common.items;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+import org.apache.commons.lang3.StringUtils;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.objects.GT_MultiTexture;
+import gregtech.api.objects.GT_RenderedTexture;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.sys.KeyboardUtils;
+import gtPlusPlus.xmod.gregtech.common.covers.GTPP_Cover_ToggleVisual;
+
+public class MetaCustomCoverItem extends Item {
+
+    protected final IIcon[] icons;
+    private final String mModID;
+    private final String mTextureSetName;
+    protected final IIconContainer[] mTextures;
+    private final short[][] mRGB;
+
+    public MetaCustomCoverItem(String aModId, int aTextureCount, String aTextureSetName, IIconContainer[] aTextures,
+        short[][] aRGB) {
+        super();
+        icons = new IIcon[aTextureCount];
+        mModID = aModId;
+        mTextureSetName = Utils.sanitizeString(aTextureSetName);
+        mTextures = aTextures;
+        mRGB = aRGB;
+        this.setTextureName(GTPlusPlus.ID + ":" + "itemPlate");
+        this.setHasSubtypes(true);
+        String unlocalizedName = "itemCustomMetaCover." + mModID + "." + mTextureSetName;
+        this.setUnlocalizedName(unlocalizedName);
+        this.setCreativeTab(AddToCreativeTab.tabMisc);
+        this.setMaxStackSize(1);
+        GameRegistry.registerItem(this, unlocalizedName);
+        registerCover();
+        Logger.INFO(
+            "[Covers] Generated Custom covers for " + mModID
+                + " using "
+                + aTextureCount
+                + " textures from "
+                + mTextureSetName
+                + ".");
+    }
+
+    public boolean hide() {
+        return true;
+    }
+
+    private void registerCover() {
+        // CommonProxy.registerItemRendererGlobal(this, new CustomItemBlockRenderer());
+        for (int i = 0; i < icons.length; i++) {
+            ItemStack thisStack = ItemUtils.simpleMetaStack(this, i, 1);
+            if (i > 0 && hide()) {
+                ItemUtils.hideItemFromNEI(thisStack);
+            }
+            GregTech_API.registerCover(
+                thisStack,
+                new GT_MultiTexture(new ITexture[] { new GT_RenderedTexture(mTextures[i]) }),
+                new GTPP_Cover_ToggleVisual());
+        }
+    }
+
+    /*
+     * @Override public void registerIcons(IIconRegister reg) { for (int i = 0; i < icons.length; i++) { this.icons[i] =
+     * mTextures[i].getIcon(); } }
+     * @Override public IIcon getIconFromDamage(int meta) { return this.icons[meta]; }
+     */
+
+    @Override
+    public void getSubItems(Item item, CreativeTabs tab, List list) {
+        for (int i = 0; i < icons.length; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack) {
+        return this.getUnlocalizedName() + "_" + stack.getItemDamage();
+    }
+
+    @Override
+    public String getItemStackDisplayName(final ItemStack tItem) {
+        return StringUtils.capitalize(mTextureSetName) + " (" + tItem.getItemDamage() + ")"; // super.getItemStackDisplayName(tItem);
+    }
+
+    private static boolean createNBT(ItemStack rStack) {
+        final NBTTagCompound tagMain = new NBTTagCompound();
+        final NBTTagCompound tagNBT = new NBTTagCompound();
+        tagNBT.setLong("Damage", 0);
+        tagNBT.setBoolean("AllowConnections", false);
+        tagMain.setTag("CustomCoverMeta", tagNBT);
+        rStack.setTagCompound(tagMain);
+        return true;
+    }
+
+    public static final long getCoverDamage(final ItemStack aStack) {
+        NBTTagCompound aNBT = aStack.getTagCompound();
+        if (aNBT != null) {
+            aNBT = aNBT.getCompoundTag("CustomCoverMeta");
+            if (aNBT != null) {
+                return aNBT.getLong("Damage");
+            }
+        } else {
+            createNBT(aStack);
+        }
+        return 0L;
+    }
+
+    public static final boolean setCoverDamage(final ItemStack aStack, final long aDamage) {
+        NBTTagCompound aNBT = aStack.getTagCompound();
+        if (aNBT != null) {
+            aNBT = aNBT.getCompoundTag("CustomCoverMeta");
+            if (aNBT != null) {
+                aNBT.setLong("Damage", aDamage);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static final boolean getCoverConnections(final ItemStack aStack) {
+        NBTTagCompound aNBT = aStack.getTagCompound();
+        if (aNBT != null) {
+            aNBT = aNBT.getCompoundTag("CustomCoverMeta");
+            if (aNBT != null) {
+                return aNBT.getBoolean("AllowConnections");
+            }
+        } else {
+            createNBT(aStack);
+        }
+        return false;
+    }
+
+    public static final boolean setCoverConnections(final ItemStack aStack, final boolean aConnections) {
+        NBTTagCompound aNBT = aStack.getTagCompound();
+        if (aNBT != null) {
+            aNBT = aNBT.getCompoundTag("CustomCoverMeta");
+            if (aNBT != null) {
+                aNBT.setBoolean("AllowConnections", aConnections);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public double getDurabilityForDisplay(ItemStack stack) {
+        if (stack.getTagCompound() == null) {
+            createNBT(stack);
+        }
+        double currentDamage = getCoverDamage(stack);
+        double meta = stack.getItemDamage() == 0 ? 50 : 2500;
+        double durabilitypercent = currentDamage / meta;
+        return durabilitypercent;
+    }
+
+    @Override
+    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
+        if (KeyboardUtils.isShiftKeyDown()) {
+            boolean con = getCoverConnections(stack);
+            if (con) {
+                setCoverConnections(stack, false);
+            } else {
+                setCoverConnections(stack, true);
+            }
+        }
+        return stack;
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean bool) {
+        boolean cons = getCoverConnections(stack);
+        list.add(EnumChatFormatting.GRAY + "Allows Connections: " + cons);
+        list.add(EnumChatFormatting.GRAY + "Shift Rmb to change state before applying");
+        super.addInformation(stack, player, list, bool);
+    }
+
+    @Override
+    public boolean showDurabilityBar(ItemStack stack) {
+        return false;
+    }
+
+    @Override
+    public Item setFull3D() {
+        // TODO Auto-generated method stub
+        return super.setFull3D();
+    }
+
+    @Override
+    public boolean isFull3D() {
+        // TODO Auto-generated method stub
+        return super.isFull3D();
+    }
+
+    @Override
+    public int getColorFromItemStack(final ItemStack stack, final int HEX_OxFFFFFF) {
+        if (this.mRGB == null) {
+            return super.getColorFromItemStack(stack, HEX_OxFFFFFF);
+        }
+        int aMeta = stack.getItemDamage();
+        return Utils.rgbtoHexValue(mRGB[aMeta][0], mRGB[aMeta][1], mRGB[aMeta][2]);
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
new file mode 100644
index 0000000000..8173a868aa
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
@@ -0,0 +1,292 @@
+package gtPlusPlus.xmod.gregtech.common.items;
+
+import static gregtech.client.GT_TooltipHandler.Tier.EV;
+import static gregtech.client.GT_TooltipHandler.registerTieredTooltip;
+import static gtPlusPlus.core.util.Utils.getTcAspectStack;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TC_Aspects;
+import gregtech.api.enums.Textures;
+import gregtech.api.objects.GT_MultiTexture;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.data.StringUtils;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+import gtPlusPlus.xmod.gregtech.api.items.Gregtech_MetaItem_X32;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import gtPlusPlus.xmod.gregtech.common.covers.GTPP_Cover_Overflow;
+
+public class MetaGeneratedGregtechItems extends Gregtech_MetaItem_X32 {
+
+    public static final MetaGeneratedGregtechItems INSTANCE;
+
+    static {
+        INSTANCE = new MetaGeneratedGregtechItems();
+    }
+
+    public MetaGeneratedGregtechItems() {
+        super("MU-metaitem.01", new OrePrefixes[] { null });
+    }
+
+    public void generateMetaItems() {
+        int tLastID = 0;
+
+        // Extruder Shape
+        GregtechItemList.Shape_Extruder_WindmillShaft
+            .set(this.addItem(40, "Extruder Shape (Shaft)", "Extruder Shape for making Windmill Shafts"));
+
+        // Batteries
+        GregtechItemList.Battery_RE_EV_Sodium.set(
+            this.addItem(
+                tLastID = 50,
+                "Quad Cell Sodium Battery",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 2L),
+                getTcAspectStack(TC_Aspects.METALLUM, 2L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 2L)));
+        this.setElectricStats(32000 + tLastID, 3200000L, GT_Values.V[4], 4L, -3L, true);
+        registerTieredTooltip(GregtechItemList.Battery_RE_EV_Sodium.get(1), EV);
+
+        GregtechItemList.Battery_RE_EV_Cadmium.set(
+            this.addItem(
+                tLastID = 52,
+                "Quad Cell Cadmium Battery",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 1L),
+                getTcAspectStack(TC_Aspects.METALLUM, 1L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 1L)));
+        this.setElectricStats(32000 + tLastID, 4800000L, GT_Values.V[4], 4L, -3L, true);
+        registerTieredTooltip(GregtechItemList.Battery_RE_EV_Cadmium.get(1), EV);
+
+        GregtechItemList.Battery_RE_EV_Lithium.set(
+            this.addItem(
+                tLastID = 54,
+                "Quad Cell Lithium Battery",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 3L),
+                getTcAspectStack(TC_Aspects.METALLUM, 3L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 3L)));
+        this.setElectricStats(32000 + tLastID, 6400000L, GT_Values.V[4], 4L, -3L, true);
+        registerTieredTooltip(GregtechItemList.Battery_RE_EV_Lithium.get(1), EV);
+
+        /**
+         * Power Gems
+         */
+        GregtechItemList.Battery_Gem_1.set(
+            this.addItem(
+                tLastID = 66,
+                "Proton Cell",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 8L),
+                getTcAspectStack(TC_Aspects.METALLUM, 24L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 16L)));
+        this.setElectricStats(32000 + tLastID, GT_Values.V[6] * 20 * 300 / 4, GT_Values.V[6], 6L, -3L, false);
+        GregtechItemList.Battery_Gem_2.set(
+            this.addItem(
+                tLastID = 68,
+                "Electron Cell",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 16L),
+                getTcAspectStack(TC_Aspects.METALLUM, 32L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 32L)));
+        this.setElectricStats(32000 + tLastID, GT_Values.V[7] * 20 * 300 / 4, GT_Values.V[7], 7L, -3L, false);
+        GregtechItemList.Battery_Gem_3.set(
+            this.addItem(
+                tLastID = 70,
+                "Quark Entanglement",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 32L),
+                getTcAspectStack(TC_Aspects.METALLUM, 48L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 64L)));
+        this.setElectricStats(32000 + tLastID, GT_Values.V[8] * 20 * 300 / 4, GT_Values.V[8], 8L, -3L, false);
+
+        // RTG Pellet
+        GregtechItemList.Pellet_RTG_PU238.set(
+            this.addItem(
+                41,
+                StringUtils.superscript("238") + "Pu Pellet",
+                "",
+                getTcAspectStack(TC_Aspects.RADIO, 4L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 2L),
+                getTcAspectStack(TC_Aspects.METALLUM, 2L)));
+        GregtechItemList.Pellet_RTG_SR90.set(
+            this.addItem(
+                42,
+                StringUtils.superscript("90") + "Sr Pellet",
+                "",
+                getTcAspectStack(TC_Aspects.RADIO, 4L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 2L),
+                getTcAspectStack(TC_Aspects.METALLUM, 2L)));
+        GregtechItemList.Pellet_RTG_PO210.set(
+            this.addItem(
+                43,
+                StringUtils.superscript("210") + "Po Pellet",
+                "",
+                getTcAspectStack(TC_Aspects.RADIO, 4L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 2L),
+                getTcAspectStack(TC_Aspects.METALLUM, 2L)));
+        GregtechItemList.Pellet_RTG_AM241.set(
+            this.addItem(
+                44,
+                StringUtils.superscript("241") + "Am Pellet",
+                "",
+                getTcAspectStack(TC_Aspects.RADIO, 4L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 2L),
+                getTcAspectStack(TC_Aspects.METALLUM, 2L)));
+
+        CORE.RA.addFuelForRTG(GregtechItemList.Pellet_RTG_PU238.get(1), MathUtils.roundToClosestInt(87.7f), 64);
+        CORE.RA.addFuelForRTG(GregtechItemList.Pellet_RTG_SR90.get(1), MathUtils.roundToClosestInt(28.8f), 32);
+        CORE.RA.addFuelForRTG(GregtechItemList.Pellet_RTG_PO210.get(1), 1, 512);
+        CORE.RA.addFuelForRTG(GregtechItemList.Pellet_RTG_AM241.get(1), 216, 16);
+        CORE.RA.addFuelForRTG(GT_ModHandler.getIC2Item("RTGPellets", 1), MathUtils.roundToClosestInt(2.6f), 8);
+
+        // Computer Cube
+        GregtechItemList.Gregtech_Computer_Cube.set(
+            this.addItem(
+                tLastID = 55,
+                "Gregtech Computer Cube",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 8L),
+                getTcAspectStack(TC_Aspects.METALLUM, 8L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 8L)));
+        this.setElectricStats(32000 + tLastID, GT_Values.V[6] * 10 * 60 * 20, GT_Values.V[5], 5L, -3L, false);
+
+        GregtechItemList.Cover_Overflow_LV.set(
+            this.addItem(
+                72,
+                "Overflow Valve (LV)",
+                "Maximum void amount: 64,000",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 1L),
+                getTcAspectStack(TC_Aspects.MACHINA, 1L),
+                getTcAspectStack(TC_Aspects.ITER, 1L),
+                getTcAspectStack(TC_Aspects.AQUA, 1L)));
+        GregtechItemList.Cover_Overflow_MV.set(
+            this.addItem(
+                73,
+                "Overflow Valve (MV)",
+                "Maximum void amount: 512,000",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 1L),
+                getTcAspectStack(TC_Aspects.MACHINA, 1L),
+                getTcAspectStack(TC_Aspects.ITER, 1L),
+                getTcAspectStack(TC_Aspects.AQUA, 1L)));
+        GregtechItemList.Cover_Overflow_HV.set(
+            this.addItem(
+                74,
+                "Overflow Valve (HV)",
+                "Maximum void amount: 4,096,000",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 1L),
+                getTcAspectStack(TC_Aspects.MACHINA, 1L),
+                getTcAspectStack(TC_Aspects.ITER, 1L),
+                getTcAspectStack(TC_Aspects.AQUA, 1L)));
+        GregtechItemList.Cover_Overflow_EV.set(
+            this.addItem(
+                75,
+                "Overflow Valve (EV)",
+                "Maximum void amount: 32,768,000",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 1L),
+                getTcAspectStack(TC_Aspects.MACHINA, 1L),
+                getTcAspectStack(TC_Aspects.ITER, 1L),
+                getTcAspectStack(TC_Aspects.AQUA, 1L)));
+        GregtechItemList.Cover_Overflow_IV.set(
+            this.addItem(
+                76,
+                "Overflow Valve (IV)",
+                "Maximum void amount: 262,144,000",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 1L),
+                getTcAspectStack(TC_Aspects.MACHINA, 1L),
+                getTcAspectStack(TC_Aspects.ITER, 1L),
+                getTcAspectStack(TC_Aspects.AQUA, 1L)));
+
+        GregTech_API.registerCover(
+            GregtechItemList.Cover_Overflow_LV.get(1L),
+            new GT_MultiTexture(
+                Textures.BlockIcons.MACHINE_CASINGS[4][0],
+                new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
+            new GTPP_Cover_Overflow(64));
+        GregTech_API.registerCover(
+            GregtechItemList.Cover_Overflow_MV.get(1L),
+            new GT_MultiTexture(
+                Textures.BlockIcons.MACHINE_CASINGS[5][0],
+                new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
+            new GTPP_Cover_Overflow(512));
+        GregTech_API.registerCover(
+            GregtechItemList.Cover_Overflow_HV.get(1L),
+            new GT_MultiTexture(
+                Textures.BlockIcons.MACHINE_CASINGS[5][0],
+                new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
+            new GTPP_Cover_Overflow(4096));
+        GregTech_API.registerCover(
+            GregtechItemList.Cover_Overflow_EV.get(1L),
+            new GT_MultiTexture(
+                Textures.BlockIcons.MACHINE_CASINGS[8][0],
+                new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
+            new GTPP_Cover_Overflow(32768));
+        GregTech_API.registerCover(
+            GregtechItemList.Cover_Overflow_IV.get(1L),
+            new GT_MultiTexture(
+                Textures.BlockIcons.MACHINE_CASINGS[8][0],
+                new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
+            new GTPP_Cover_Overflow(262144));
+
+        // Fusion Reactor MK4 Singularity
+        GregtechItemList.Compressed_Fusion_Reactor.set(
+            this.addItem(
+                100,
+                "Hypervisor Matrix (Fusion)",
+                "A memory unit containing an RI (Restricted Intelligence)"));
+
+        GregtechItemList.Laser_Lens_Special
+            .set(this.addItem(105, "Quantum Anomaly", "Probably should shoot it with lasers"));
+
+        GregtechItemList.Battery_Casing_Gem_1.set(this.addItem(106, "Containment Unit I", "Used in crafting"));
+        GregtechItemList.Battery_Casing_Gem_2.set(this.addItem(107, "Containment Unit II", "Used in crafting"));
+        GregtechItemList.Battery_Casing_Gem_3.set(this.addItem(108, "Advanced Containment Unit", "Used in crafting"));
+        GregtechItemList.Battery_Casing_Gem_4.set(this.addItem(109, "Exotic Containment Unit", "Used in crafting"));
+
+        GregtechItemList.Battery_Gem_4.set(
+            this.addItem(
+                tLastID = 110,
+                "Graviton Anomaly",
+                "Reusable",
+                getTcAspectStack(TC_Aspects.ELECTRUM, 64L),
+                getTcAspectStack(TC_Aspects.METALLUM, 64L),
+                getTcAspectStack(TC_Aspects.POTENTIA, 64L)));
+        this.setElectricStats(32000 + tLastID, (64000000000L * 16), GT_Values.V[9], 9L, -3L, false);
+
+        /*
+         * High Tier 'Saws' for the tree Farm
+         */
+
+        GregtechItemList.Laser_Lens_WoodsGlass.set(
+            this.addItem(140, "Wood's Glass Lens", "Allows UV & IF to pass through, blocks visible light spectrums"));
+
+        // 141 now unused, was the ulv transmission component
+        int aStartID = 142;
+        GregtechItemList[] aTransParts = new GregtechItemList[] { GregtechItemList.TransmissionComponent_LV,
+            GregtechItemList.TransmissionComponent_MV, GregtechItemList.TransmissionComponent_HV,
+            GregtechItemList.TransmissionComponent_EV, GregtechItemList.TransmissionComponent_IV,
+            GregtechItemList.TransmissionComponent_LuV, GregtechItemList.TransmissionComponent_ZPM,
+            GregtechItemList.TransmissionComponent_UV, GregtechItemList.TransmissionComponent_UHV, };
+        for (int tier = 1; tier < aTransParts.length + 1; tier++) {
+            aTransParts[tier - 1].set(
+                this.addItem(
+                    aStartID++,
+                    "Transmission Component (" + GT_Values.VN[tier] + ")",
+                    "",
+                    getTcAspectStack(TC_Aspects.ELECTRUM, tier),
+                    getTcAspectStack(TC_Aspects.MACHINA, tier),
+                    getTcAspectStack(TC_Aspects.MAGNETO, tier)));
+        }
+
+        // Distillus Chip
+        GregtechItemList.Distillus_Upgrade_Chip
+            .set(this.addItem(151, "Distillus Upgrade Chip", "Used to upgrade Distillus to Tier 2"));
+        GregtechItemList.Maceration_Upgrade_Chip
+            .set(this.addItem(152, "Maceration Upgrade Chip", "Used to upgrade Maceration Stack to Tier 2"));
+    }
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechTools.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechTools.java
new file mode 100644
index 0000000000..30250a46f3
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechTools.java
@@ -0,0 +1,54 @@
+package gtPlusPlus.xmod.gregtech.common.items;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.TC_Aspects;
+import gregtech.api.enums.ToolDictNames;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechToolDictNames;
+import gtPlusPlus.xmod.gregtech.common.tools.TOOL_Gregtech_AngleGrinder;
+import gtPlusPlus.xmod.gregtech.common.tools.TOOL_Gregtech_ElectricSnips;
+
+public class MetaGeneratedGregtechTools extends GT_MetaGenerated_Tool {
+
+    public static final short ANGLE_GRINDER = 7834;
+    public static final short ELECTRIC_SNIPS = 7934;
+    public static GT_MetaGenerated_Tool INSTANCE;
+
+    static {
+        INSTANCE = new MetaGeneratedGregtechTools();
+    }
+
+    public static GT_MetaGenerated_Tool getInstance() {
+        return INSTANCE;
+    }
+
+    private MetaGeneratedGregtechTools() {
+        super("plusplus.metatool.01");
+
+        // Electric File
+        this.addTool(
+            ANGLE_GRINDER,
+            "Angle Grinder",
+            "Hand-held electric filing device",
+            new TOOL_Gregtech_AngleGrinder(),
+            GregtechToolDictNames.craftingToolAngleGrinder,
+            ToolDictNames.craftingToolFile,
+            new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L),
+            new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L),
+            new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L));
+
+        // Electric Wire Cutter
+        GregTech_API.registerWireCutter(
+            this.addTool(
+                ELECTRIC_SNIPS,
+                "Automatic Snips",
+                "Hand-held electric wire cutter",
+                new TOOL_Gregtech_ElectricSnips(),
+                GregtechToolDictNames.craftingToolElectricSnips,
+                ToolDictNames.craftingToolWireCutter,
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 4L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 4L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 4L)));
+
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Choocher.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Choocher.java
new file mode 100644
index 0000000000..f85822750d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Choocher.java
@@ -0,0 +1,91 @@
+package gtPlusPlus.xmod.gregtech.common.items.behaviours;
+
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.items.GT_MetaBase_Item;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.common.items.behaviors.Behaviour_None;
+import gregtech.common.items.behaviors.Behaviour_Wrench;
+import gtPlusPlus.core.util.minecraft.NBTUtils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+
+public class Behaviour_Choocher extends Behaviour_None {
+
+    private boolean isWrench = true;
+    private final Behaviour_Wrench wrench = new Behaviour_Wrench(150);
+    private final Behaviour_Prospecting_Ex prospecting = new Behaviour_Prospecting_Ex(10, 1250);
+    private final String mTooltip1 = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.choochering1", "Current tool mode: ");
+    private final String mTooltip2 = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.choochering2", "Change tool mode using Shift+Rightclick.");
+    private final String mTooltipH = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.prospectingEx", "Usable for Prospecting large areas.");
+    private final String mTooltipW = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.wrench", "Rotates Blocks on Rightclick.");
+
+    public Behaviour_Choocher() {}
+
+    @Override
+    public boolean onItemUseFirst(final GT_MetaBase_Item aItem, final ItemStack aStack, final EntityPlayer aPlayer,
+        final World aWorld, final int aX, final int aY, final int aZ, final ForgeDirection side, final float hitX,
+        final float hitY, final float hitZ) {
+        if (aWorld.isRemote) {
+            return false;
+        }
+
+        boolean inWrenchMode;
+        if (NBTUtils.hasKey(aStack, "aMode")) {
+            inWrenchMode = NBTUtils.getBoolean(aStack, "aMode");
+        } else {
+            aStack.getTagCompound()
+                .setBoolean("aMode", true);
+            inWrenchMode = true;
+        }
+
+        if (aPlayer.isSneaking()) {
+            boolean aModeNew = !inWrenchMode;
+            aStack.getTagCompound()
+                .setBoolean("aMode", aModeNew);
+            PlayerUtils.messagePlayer(aPlayer, "Mode: " + (aModeNew ? "Wrench" : "Hammer"));
+            return true;
+        } else {
+            if (inWrenchMode) {
+                return this.wrench.onItemUseFirst(aItem, aStack, aPlayer, aWorld, aX, aY, aZ, side, hitZ, hitZ, hitZ);
+            } else {
+                return this.prospecting
+                    .onItemUseFirst(aItem, aStack, aPlayer, aWorld, aX, aY, aZ, side, hitX, hitY, hitZ);
+            }
+        }
+    }
+
+    @Override
+    public List<String> getAdditionalToolTips(final GT_MetaBase_Item aItem, final List<String> aList,
+        final ItemStack aStack) {
+
+        boolean inWrenchMode;
+        if (NBTUtils.hasKey(aStack, "aMode")) {
+            inWrenchMode = NBTUtils.getBoolean(aStack, "aMode");
+        } else {
+            NBTUtils.setBoolean(aStack, "aMode", true);
+            aStack.getTagCompound()
+                .setBoolean("aMode", true);
+            inWrenchMode = true;
+        }
+
+        if (inWrenchMode) {
+            aList.add(this.mTooltip1 + "Wrench");
+            aList.add(this.mTooltipW);
+        } else {
+            aList.add(this.mTooltip1 + "Prospecting");
+            aList.add(this.mTooltipH);
+        }
+        aList.add(this.mTooltip2);
+
+        return aList;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java
new file mode 100644
index 0000000000..f3d7f87a86
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java
@@ -0,0 +1,225 @@
+package gtPlusPlus.xmod.gregtech.common.items.behaviours;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import codechicken.lib.math.MathHelper;
+import gregtech.api.enums.SoundResource;
+import gregtech.api.items.GT_MetaBase_Item;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.behaviors.Behaviour_None;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.entity.projectile.EntityLightningAttack;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.NBTUtils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.common.helpers.ChargingHelper;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
+import ic2.api.item.IElectricItemManager;
+
+public class Behaviour_Electric_Lighter extends Behaviour_None {
+
+    private final String mTooltip = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.lighter.tooltip", "Can light things on Fire");
+    private final String mTooltipUses = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.lighter.uses", "Remaining Uses:");
+    private final String mTooltipUnstackable = GT_LanguageManager
+        .addStringLocalization("gt.behaviour.unstackable", "Not usable when stacked!");
+
+    public Behaviour_Electric_Lighter() {}
+
+    @Override
+    public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) {
+        if (!aPlayer.worldObj.isRemote && aStack != null && aStack.stackSize == 1) {
+            boolean rOutput = false;
+            if (aEntity instanceof EntityCreeper) {
+                if (this.prepare(aStack) || aPlayer.capabilities.isCreativeMode) {
+                    GT_Utility.sendSoundToPlayers(
+                        aPlayer.worldObj,
+                        SoundResource.FIRE_IGNITE,
+                        1.0F,
+                        1.0F,
+                        MathHelper.floor_double(aEntity.posX),
+                        MathHelper.floor_double(aEntity.posY),
+                        MathHelper.floor_double(aEntity.posZ));
+                    ((EntityCreeper) aEntity).func_146079_cb();
+                    rOutput = true;
+                }
+            }
+            return rOutput;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean onItemUse(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX,
+        int aY, int aZ, int ordinalSide, float hitX, float hitY, float hitZ) {
+        if (!aWorld.isRemote && aStack != null && aStack.stackSize == 1) {
+            if (aPlayer.isSneaking()) {
+                Logger.INFO("Changing Mode");
+                boolean aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMode");
+                Logger.INFO("Is currently in Fireball mode? " + aCurrentMode);
+                boolean aNewMode = !aCurrentMode;
+                Logger.INFO("Is now set to Fireball mode? " + aNewMode);
+                aStack.getTagCompound()
+                    .setBoolean("aFireballMod", aNewMode);
+                // NBTUtils.setBoolean(aStack, "aFireballMode", aNewMode);
+                PlayerUtils.messagePlayer(
+                    aPlayer,
+                    "Current Mode: " + EnumChatFormatting.RED + (aNewMode ? "Projectile" : "Fire Starter"));
+            } else {
+                boolean aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMode");
+                if (aCurrentMode) {
+                    // Shoot Lightning Attack
+                    aWorld
+                        .playSoundAtEntity(aPlayer, "random.bow", 0.5F, 0.4F / (CORE.RANDOM.nextFloat() * 0.4F + 0.8F));
+                    if (!aWorld.isRemote) {
+                        aWorld.spawnEntityInWorld(new EntityLightningAttack(aWorld, aPlayer, hitX, hitY, hitZ));
+                    }
+                } else {
+                    // Lights Fires Mode
+                    Logger.WARNING("Preparing Lighter a");
+                    boolean rOutput = false;
+                    ForgeDirection tDirection = ForgeDirection.getOrientation(ordinalSide);
+                    aX += tDirection.offsetX;
+                    aY += tDirection.offsetY;
+                    aZ += tDirection.offsetZ;
+                    if (GT_Utility.isBlockAir(aWorld, aX, aY, aZ)
+                        && aPlayer.canPlayerEdit(aX, aY, aZ, ordinalSide, aStack)) {
+                        Logger.WARNING("Preparing Lighter b");
+                        if (this.prepare(aStack) || aPlayer.capabilities.isCreativeMode) {
+                            Logger.WARNING("Preparing Lighter c");
+                            GT_Utility.sendSoundToPlayers(aWorld, SoundResource.FIRE_IGNITE, 1.0F, 1.0F, aX, aY, aZ);
+                            aWorld.setBlock(aX, aY, aZ, Blocks.fire);
+                            rOutput = true;
+                            // ItemNBT.setLighterFuel(aStack, tFuelAmount);
+                            return rOutput;
+                        }
+                    }
+                }
+            }
+        }
+        Logger.WARNING("Preparing Lighter z");
+        return false;
+    }
+
+    public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX,
+        int aY, int aZ, int ordinalSide, float hitX, float hitY, float hitZ) {
+        if (!aWorld.isRemote && aStack != null && aStack.stackSize == 1) {
+            if (aPlayer.isSneaking()) {
+                Logger.INFO("Changing Mode");
+                boolean aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMode");
+                Logger.INFO("Is currently in Fireball mode? " + aCurrentMode);
+                boolean aNewMode = !aCurrentMode;
+                Logger.INFO("Is now set to Fireball mode? " + aNewMode);
+                aStack.getTagCompound()
+                    .setBoolean("aFireballMode", aNewMode);
+                // NBTUtils.setBoolean(aStack, "aFireballMode", aNewMode);
+                PlayerUtils.messagePlayer(
+                    aPlayer,
+                    "Current Mode: " + EnumChatFormatting.RED + (aNewMode ? "Projectile" : "Fire Starter"));
+            } else {
+                boolean aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMode");
+                if (aCurrentMode) {
+                    // Shoot Lightning Attack
+                    aWorld
+                        .playSoundAtEntity(aPlayer, "random.bow", 0.5F, 0.4F / (CORE.RANDOM.nextFloat() * 0.4F + 0.8F));
+                    if (!aWorld.isRemote) {
+                        aWorld.spawnEntityInWorld(new EntityLightningAttack(aWorld, aPlayer, hitX, hitY, hitZ));
+                    }
+                } else {
+                    // Lights Fires Mode
+                    Logger.WARNING("Preparing Lighter a");
+                    boolean rOutput = false;
+                    ForgeDirection tDirection = ForgeDirection.getOrientation(ordinalSide);
+                    aX += tDirection.offsetX;
+                    aY += tDirection.offsetY;
+                    aZ += tDirection.offsetZ;
+                    if (GT_Utility.isBlockAir(aWorld, aX, aY, aZ)
+                        && aPlayer.canPlayerEdit(aX, aY, aZ, ordinalSide, aStack)) {
+                        Logger.WARNING("Preparing Lighter b");
+                        if (this.prepare(aStack) || aPlayer.capabilities.isCreativeMode) {
+                            Logger.WARNING("Preparing Lighter c");
+                            GT_Utility.sendSoundToPlayers(aWorld, SoundResource.FIRE_IGNITE, 1.0F, 1.0F, aX, aY, aZ);
+                            aWorld.setBlock(aX, aY, aZ, Blocks.fire);
+                            rOutput = true;
+                            // ItemNBT.setLighterFuel(aStack, tFuelAmount);
+                            return rOutput;
+                        }
+                    }
+                }
+            }
+        }
+        Logger.WARNING("Preparing Lighter z");
+        return false;
+    }
+
+    private boolean prepare(ItemStack aStack) {
+        if (aStack != null) {
+            Logger.WARNING("Preparing Lighter 1");
+            if (aStack.getItem() instanceof MetaGeneratedGregtechTools) {
+                Logger.WARNING("Preparing Lighter 2");
+                if (ChargingHelper.isItemValid(aStack)) {
+                    Logger.WARNING("Preparing Lighter 3");
+                    if (aStack.getItem() instanceof IElectricItemManager aItemElec) {
+                        Logger.WARNING("Preparing Lighter 4");
+                        double aCharge = aItemElec.getCharge(aStack);
+                        long aEuCost = 4096 * 2;
+                        if (aCharge >= aEuCost) {
+                            Logger.WARNING("Preparing Lighter 5");
+                            aItemElec.discharge(aStack, aEuCost, 3, true, true, false);
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        Logger.WARNING("Preparing Lighter 0");
+        return false;
+    }
+
+    private void useUp(ItemStack aStack) {}
+
+    @Override
+    public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) {
+        aList.add(this.mTooltip);
+        int aUses = 0;
+        if (aStack != null) {
+            if (aStack.getItem() instanceof MetaGeneratedGregtechTools) {
+                if (ChargingHelper.isItemValid(aStack)) {
+                    if (aStack.getItem() instanceof IElectricItemManager aItemElec) {
+                        double aCharge = aItemElec.getCharge(aStack);
+                        long aEuCost = 4096 * 2;
+                        aUses = (int) (aCharge / aEuCost);
+                    }
+                }
+                boolean aCurrentMode;
+                if (!NBTUtils.hasTagCompound(aStack)) {
+                    NBTUtils.createEmptyTagCompound(aStack);
+                }
+                if (NBTUtils.hasKey(aStack, "aFireballMode")) {
+                    aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMode");
+                } else {
+                    aStack.getTagCompound()
+                        .setBoolean("aFireballMode", false);
+                    aCurrentMode = false;
+                }
+                aList.add("Current Mode: " + EnumChatFormatting.RED + (aCurrentMode ? "Projectile" : "Fire Starter"));
+            }
+        }
+
+        aList.add(this.mTooltipUses + " " + aUses);
+        aList.add(this.mTooltipUnstackable);
+        return aList;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Prospecting_Ex.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Prospecting_Ex.java
new file mode 100644
index 0000000000..5749204296
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Prospecting_Ex.java
@@ -0,0 +1,140 @@
+package gtPlusPlus.xmod.gregtech.common.items.behaviours;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.IFluidBlock;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.SoundResource;
+import gregtech.api.items.GT_MetaBase_Item;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.api.objects.ItemData;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.blocks.GT_Block_Ores;
+import gregtech.common.blocks.GT_TileEntity_Ores;
+import gregtech.common.items.behaviors.Behaviour_Prospecting;
+
+public class Behaviour_Prospecting_Ex extends Behaviour_Prospecting {
+
+    private final int mVanillaCosts;
+    private final int mEUCosts;
+
+    public Behaviour_Prospecting_Ex(final int aVanillaCosts, final int aEUCosts) {
+        super(aVanillaCosts, aEUCosts);
+        this.mVanillaCosts = aVanillaCosts;
+        this.mEUCosts = aEUCosts;
+    }
+
+    @Override
+    public boolean onItemUseFirst(final GT_MetaBase_Item aItem, final ItemStack aStack, final EntityPlayer aPlayer,
+        final World aWorld, final int aX, final int aY, final int aZ, final ForgeDirection side, final float hitX,
+        final float hitY, final float hitZ) {
+        if (aWorld.isRemote) {
+            return false;
+        }
+        final Block aBlock = aWorld.getBlock(aX, aY, aZ);
+        if (aBlock == null) {
+            return false;
+        }
+        final byte aMeta = (byte) aWorld.getBlockMetadata(aX, aY, aZ);
+
+        ItemData tAssotiation = GT_OreDictUnificator.getAssociation(new ItemStack(aBlock, 1, aMeta));
+        if ((tAssotiation != null) && (tAssotiation.mPrefix.toString()
+            .startsWith("ore"))) {
+            GT_Utility
+                .sendChatToPlayer(aPlayer, "This is " + tAssotiation.mMaterial.mMaterial.mDefaultLocalName + " Ore.");
+            GT_Utility.sendSoundToPlayers(aWorld, SoundResource.RANDOM_ANVIL_USE, 1.0F, -1.0F, aX, aY, aZ);
+            return true;
+        }
+        if ((aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.stone))
+            || (aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, GregTech_API.sBlockGranites))
+            || (aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.netherrack))
+            || (aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.end_stone))
+            || (aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.dirt))
+            || (aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.grass))) {
+            if (GT_ModHandler.damageOrDechargeItem(aStack, this.mVanillaCosts, this.mEUCosts, aPlayer)) {
+                GT_Utility.sendSoundToPlayers(aWorld, SoundResource.RANDOM_ANVIL_USE, 1.0F, -1.0F, aX, aY, aZ);
+                int tX = aX;
+                int tY = aY;
+                int tZ = aZ;
+                int tMetaID = 0;
+                final int tQuality = ((aItem instanceof GT_MetaGenerated_Tool)
+                    ? ((GT_MetaGenerated_Tool) aItem).getHarvestLevel(aStack, "")
+                    : 0) * 3;
+
+                int i = 0;
+                for (final int j = 6 + tQuality; i < j; i++) {
+                    tX -= side.offsetX;
+                    tY -= side.offsetY;
+                    tZ -= side.offsetZ;
+
+                    final Block tBlock = aWorld.getBlock(tX, tY, tZ);
+                    if ((tBlock == Blocks.lava) || (tBlock == Blocks.flowing_lava)) {
+                        GT_Utility.sendChatToPlayer(aPlayer, "There is Lava behind this Block.");
+                        break;
+                    }
+                    if ((tBlock == Blocks.water) || (tBlock == Blocks.flowing_water)
+                        || ((tBlock instanceof IFluidBlock))) {
+                        GT_Utility.sendChatToPlayer(aPlayer, "There is a Liquid behind this Block.");
+                        break;
+                    }
+                    if ((tBlock == Blocks.monster_egg) || (!GT_Utility.hasBlockHitBox(aWorld, tX, tY, tZ))) {
+                        GT_Utility.sendChatToPlayer(aPlayer, "There is an Air Pocket behind this Block.");
+                        break;
+                    }
+                    if (tBlock != aBlock) {
+                        if (i >= 4) {
+                            break;
+                        }
+                        GT_Utility.sendChatToPlayer(aPlayer, "Material is changing behind this Block.");
+                        break;
+                    }
+                }
+                final Random tRandom = new Random(aX ^ aY ^ aZ ^ side.ordinal());
+                i = 0;
+                for (final int j = 9 + (2 * tQuality); i < j; i++) {
+                    tX = (aX - 4 - tQuality) + tRandom.nextInt(j);
+                    tY = (aY - 4 - tQuality) + tRandom.nextInt(j);
+                    tZ = (aZ - 4 - tQuality) + tRandom.nextInt(j);
+                    final Block tBlock = aWorld.getBlock(tX, tY, tZ);
+                    if ((tBlock instanceof GT_Block_Ores)) {
+                        final TileEntity tTileEntity = aWorld.getTileEntity(tX, tY, tZ);
+                        if ((tTileEntity instanceof GT_TileEntity_Ores)) {
+                            final Materials tMaterial = GregTech_API.sGeneratedMaterials[(((GT_TileEntity_Ores) tTileEntity).mMetaData
+                                % 1000)];
+                            if ((tMaterial != null) && (tMaterial != Materials._NULL)) {
+                                GT_Utility.sendChatToPlayer(
+                                    aPlayer,
+                                    "Found traces of " + tMaterial.mDefaultLocalName + " Ore.");
+                                return true;
+                            }
+                        }
+                    } else {
+                        tMetaID = aWorld.getBlockMetadata(tX, tY, tZ);
+                        tAssotiation = GT_OreDictUnificator.getAssociation(new ItemStack(tBlock, 1, tMetaID));
+                        if ((tAssotiation != null) && (tAssotiation.mPrefix.toString()
+                            .startsWith("ore"))) {
+                            GT_Utility.sendChatToPlayer(
+                                aPlayer,
+                                "Found traces of " + tAssotiation.mMaterial.mMaterial.mDefaultLocalName + " Ore.");
+                            return true;
+                        }
+                    }
+                }
+                GT_Utility.sendChatToPlayer(aPlayer, "No Ores found.");
+            }
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/covers/MetaItemCoverCasings.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/covers/MetaItemCoverCasings.java
new file mode 100644
index 0000000000..987924952a
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/covers/MetaItemCoverCasings.java
@@ -0,0 +1,50 @@
+package gtPlusPlus.xmod.gregtech.common.items.covers;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.StatCollector;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Textures;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.xmod.gregtech.common.items.MetaCustomCoverItem;
+
+public class MetaItemCoverCasings extends MetaCustomCoverItem {
+
+    public MetaItemCoverCasings() {
+        super(
+            GTPlusPlus.ID,
+            Textures.BlockIcons.MACHINECASINGS_SIDE.length,
+            "Gt Machine Casings",
+            Textures.BlockIcons.MACHINECASINGS_SIDE,
+            null);
+    }
+
+    @Override
+    public void registerIcons(IIconRegister reg) {
+        for (int i = 0; i < icons.length; i++) {
+            this.icons[i] = reg.registerIcon(GTPlusPlus.ID + ":" + "covers/" + i);
+        }
+    }
+
+    @Override
+    public boolean hide() {
+        return false;
+    }
+
+    @Override
+    public IIcon getIconFromDamage(int meta) {
+        return this.icons[MathUtils.balance(meta, 0, 15)];
+    }
+
+    @Override
+    public String getItemStackDisplayName(final ItemStack tItem) {
+        return EnumChatFormatting.LIGHT_PURPLE + StatCollector.translateToLocalFormatted(
+            "item.itemCustomMetaCover.miscutils.GtMachineCasings",
+            GT_Values.VOLTAGE_NAMES[MathUtils.balance(tItem.getItemDamage(), 0, GT_Values.VOLTAGE_NAMES.length - 1)]); // super.getItemStackDisplayName(tItem);
+    }
+}