Updated SafeBlock GUI, Removed 2 unused buttons and their related code.

Playercache is now Active and caching playerdata, for use in GUIs and other places. ;)
Player Safe Blocks should now be 100% intruder safe.

10 files changed, 744 insertions, 0 deletions

diff --git a/src/Java/miscutil/MiscUtils.java b/src/Java/miscutil/MiscUtils.java
index 4455e38a57..d180cfb6c3 100644
--- a/src/Java/miscutil/MiscUtils.java
+++ b/src/Java/miscutil/MiscUtils.java
@@ -6,6 +6,7 @@ import java.awt.event.ActionListener;
 import miscutil.core.commands.CommandMath;
 import miscutil.core.common.CommonProxy;
 import miscutil.core.creativetabs.AddToCreativeTab;
+import miscutil.core.handler.XEventHandler;
 import miscutil.core.lib.CORE;
 import miscutil.core.lib.LoadedMods;
 import miscutil.core.util.Utils;
@@ -54,6 +55,7 @@ implements ActionListener
 		proxy.init(event);
 		proxy.registerOreDict();
 		MinecraftForge.EVENT_BUS.register(this);
+		MinecraftForge.EVENT_BUS.register(new XEventHandler());
 		FMLCommonHandler.instance().bus().register(this);
 		proxy.registerNetworkStuff();
 	}
diff --git a/src/Java/miscutil/core/handler/XEventHandler.java b/src/Java/miscutil/core/handler/XEventHandler.java
new file mode 100644
index 0000000000..3742f29e47
--- /dev/null
+++ b/src/Java/miscutil/core/handler/XEventHandler.java
@@ -0,0 +1,61 @@
+package miscutil.core.handler;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.metatileentity.BaseMetaTileEntity;
+import gregtech.api.metatileentity.BaseTileEntity;
+import miscutil.core.util.Utils;
+import miscutil.gregtech.metatileentity.implementations.base.GregtechMetaSafeBlockBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.event.world.BlockEvent.BreakEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class XEventHandler {
+	@SubscribeEvent
+	public void onBreakBlock(BreakEvent event) {
+		TileEntity entity = event.world.getTileEntity(event.x, event.y, event.z);
+		EntityPlayer playerInternal = event.getPlayer();
+
+		try{
+			if (entity instanceof BaseTileEntity){
+				IMetaTileEntity X = ((BaseMetaTileEntity)entity).getMetaTileEntity();
+				if (X instanceof GregtechMetaSafeBlockBase){
+					
+					String ownerUUID = ((GregtechMetaSafeBlockBase)X).ownerUUID;
+					String accessorUUID = playerInternal.getUniqueID().toString();
+					Utils.LOG_WARNING("Owner UUID: "+ownerUUID);
+					Utils.LOG_WARNING("Accessor UUID: "+accessorUUID);					
+					
+					if (((GregtechMetaSafeBlockBase)X).bUnbreakable){
+						if (accessorUUID.equals(ownerUUID)){							
+							Utils.messagePlayer(playerInternal, "Since you own this block, it has been destroyed.");
+							event.setCanceled(false);
+						}
+						else {
+							Utils.messagePlayer(playerInternal, "Since you do not own this block, it has not been destroyed.");
+							event.setCanceled(true);
+						}
+						//
+					}
+				}
+			}
+		}
+		catch (NullPointerException e) {
+			System.out.print("Caught a NullPointerException involving Safe Blocks. Cause: "+e.getCause());
+		}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	}
+}
diff --git a/src/Java/miscutil/core/lib/CORE.java b/src/Java/miscutil/core/lib/CORE.java
index 12be9e9a03..4acd30d4d8 100644
--- a/src/Java/miscutil/core/lib/CORE.java
+++ b/src/Java/miscutil/core/lib/CORE.java
@@ -1,5 +1,7 @@
 package miscutil.core.lib;
 
+import java.util.Map;
+
 import miscutil.core.creativetabs.AddToCreativeTab;
 
 public class CORE {
@@ -10,6 +12,7 @@ public class CORE {
 	public static final boolean DEBUG = true;	
 	public static final boolean LOAD_ALL_CONTENT = false;
 	public static final int GREG_FIRST_ID = 760;
+	public static Map PlayerCache;
 	
 	
 	public static final Class<AddToCreativeTab> TAB = AddToCreativeTab.class;
diff --git a/src/Java/miscutil/core/util/PlayerCache.java b/src/Java/miscutil/core/util/PlayerCache.java
new file mode 100644
index 0000000000..40f44e003a
--- /dev/null
+++ b/src/Java/miscutil/core/util/PlayerCache.java
@@ -0,0 +1,107 @@
+package miscutil.core.util;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Properties;
+
+import miscutil.core.lib.CORE;
+
+public class PlayerCache {
+
+	private static final File cache = new File("PlayerCache.dat");
+
+	public static void createPropertiesFile(String playerName, String playerUUIDasString) {
+		try {
+			Properties props = new Properties();
+			props.setProperty(playerName, playerUUIDasString);
+			OutputStream out = new FileOutputStream(cache);
+			props.store(out, "Player Cache.");
+		}
+		catch (Exception e ) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void appendParamChanges(String playerName, String playerUUIDasString) {
+		try {
+
+			Properties properties = new Properties();
+			try {
+				Utils.LOG_WARNING("Attempting to load "+cache.getName());
+				properties.load(new FileInputStream(cache));
+			} catch (IOException e) {
+				Utils.LOG_WARNING("No PlayerCache file found, creating one.");
+				createPropertiesFile(playerName, playerUUIDasString);
+			}
+
+			properties.setProperty(playerName, playerUUIDasString);
+			FileOutputStream fr=new FileOutputStream(cache);
+			properties.store(fr, "Player Cache.");
+			fr.close();
+		}
+		catch (Exception e ) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Reads a "properties" file, and returns it as a Map 
+	 * (a collection of key/value pairs).
+	 * 
+	 * Credit due to Alvin Alexander - http://alvinalexander.com/java/java-properties-file-map-example?nocache=1#comment-8215
+	 * Changed slightly as the filename and delimiter are constant in my case.
+	 * 
+	 * @param filename  The properties filename to read.
+	 * @param delimiter The string (or character) that separates the key 
+	 *                  from the value in the properties file.
+	 * @return The Map that contains the key/value pairs.
+	 * @throws Exception
+	 */
+	private static Map<String, String> readPropertiesFileAsMap() throws Exception {
+		String filename = cache.getName();
+		String delimiter = ":";
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		Map<String, String> map = new HashMap();
+		BufferedReader reader = new BufferedReader(new FileReader(filename));
+		String line;
+		while ((line = reader.readLine()) != null)
+		{
+			if (line.trim().length()==0) continue;
+			if (line.charAt(0)=='#') continue;
+			// assumption here is that proper lines are like "String : <a href="http://xxx.yyy.zzz/foo/bar"" title="http://xxx.yyy.zzz/foo/bar"">http://xxx.yyy.zzz/foo/bar"</a>,
+			// and the ":" is the delimiter
+			int delimPosition = line.indexOf(delimiter);
+			String key = line.substring(0, delimPosition-1).trim();
+			String value = line.substring(delimPosition+1).trim();
+			map.put(key, value);
+		}
+		reader.close();
+		CORE.PlayerCache = map;
+		return map;
+	}
+
+	public static String lookupPlayerByUUID(String UUID){
+		Map<String, String> map = null;
+		try {
+			map = readPropertiesFileAsMap();
+		} catch (Exception e) {
+			Utils.LOG_ERROR("Caught Exception"+e.toString());
+			e.printStackTrace();
+		}
+		for (Entry<String, String> entry : map.entrySet()) {
+			if (Objects.equals(UUID, entry.getValue())) {
+				return entry.getKey();
+			}
+		}
+		return null;
+	}
+}
diff --git a/src/Java/miscutil/gregtech/gui/CONTAINER_SafeBlock.java b/src/Java/miscutil/gregtech/gui/CONTAINER_SafeBlock.java
new file mode 100644
index 0000000000..09162fcda0
--- /dev/null
+++ b/src/Java/miscutil/gregtech/gui/CONTAINER_SafeBlock.java
@@ -0,0 +1,86 @@
+package miscutil.gregtech.gui;
+
+import gregtech.api.gui.GT_ContainerMetaTile_Machine;
+import gregtech.api.gui.GT_Slot_Holo;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Utility;
+import miscutil.core.util.PlayerCache;
+import miscutil.gregtech.metatileentity.implementations.GregtechMetaSafeBlock;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+public class CONTAINER_SafeBlock
+        extends GT_ContainerMetaTile_Machine {
+    public CONTAINER_SafeBlock(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) {
+        super(aInventoryPlayer, aTileEntity);
+    }
+    
+    public String UUID = ((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).ownerUUID;
+    public String ownerUUID = ((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).ownerUUID;
+
+    @Override
+	public void addSlots(InventoryPlayer aInventoryPlayer) {
+        for (int y = 0; y < 3; y++) {
+            for (int x = 0; x < 9; x++) {
+                addSlotToContainer(new Slot(this.mTileEntity, x + y * 9, 8 + x * 18, 5 + y * 18));
+            }
+        }
+        addSlotToContainer(new GT_Slot_Holo(this.mTileEntity, 27, 8, 63, false, true, 1));
+        addSlotToContainer(new GT_Slot_Holo(this.mTileEntity, 27, 26, 63, false, true, 1));
+        addSlotToContainer(new GT_Slot_Holo(this.mTileEntity, 27, 44, 63, false, true, 1));
+    }
+
+    @Override
+	public ItemStack slotClick(int aSlotIndex, int aMouseclick, int aShifthold, EntityPlayer aPlayer) {
+        if (aSlotIndex < 27) {
+            return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer);
+        }
+        Slot tSlot = (Slot) this.inventorySlots.get(aSlotIndex);
+        if (tSlot != null) {
+            if (this.mTileEntity.getMetaTileEntity() == null) {
+                return null;
+            }
+           /* if (aSlotIndex == 27) {
+                ((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bOutput = (!((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bOutput);
+                if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bOutput) {
+                    GT_Utility.sendChatToPlayer(aPlayer, "Emit Energy to Outputside");
+                } else {
+                    GT_Utility.sendChatToPlayer(aPlayer, "Don't emit Energy");
+                }
+                return null;
+            }
+            if (aSlotIndex == 28) {
+                ((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull = (!((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull);
+                if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull) {
+                    GT_Utility.sendChatToPlayer(aPlayer, "Emit Redstone if no Slot is free");
+                } else {
+                    GT_Utility.sendChatToPlayer(aPlayer, "Don't emit Redstone");
+                }
+                return null;
+            }*/
+            if (aSlotIndex == 29) {
+                ((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable = (!((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable);
+                if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable) {
+                    GT_Utility.sendChatToPlayer(aPlayer, "Block is now unbreakable.");
+                    PlayerCache.appendParamChanges(aPlayer.getDisplayName(), aPlayer.getUniqueID().toString());
+                } else {
+                    GT_Utility.sendChatToPlayer(aPlayer, "Block is now breakable.");
+                }
+                return null;
+            }
+        }
+        return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer);
+    }
+
+    @Override
+	public int getSlotCount() {
+        return 27;
+    }
+
+    @Override
+	public int getShiftClickSlotCount() {
+        return 27;
+    }
+}
diff --git a/src/Java/miscutil/gregtech/gui/GUI_SafeBlock.java b/src/Java/miscutil/gregtech/gui/GUI_SafeBlock.java
new file mode 100644
index 0000000000..c4b2d540ba
--- /dev/null
+++ b/src/Java/miscutil/gregtech/gui/GUI_SafeBlock.java
@@ -0,0 +1,37 @@
+package miscutil.gregtech.gui;
+
+import gregtech.api.gui.GT_GUIContainerMetaTile_Machine;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import miscutil.core.lib.CORE;
+import miscutil.core.util.PlayerCache;
+import net.minecraft.entity.player.InventoryPlayer;
+
+public class GUI_SafeBlock
+        extends GT_GUIContainerMetaTile_Machine {
+    public GUI_SafeBlock(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) {
+        super(new CONTAINER_SafeBlock(aInventoryPlayer, aTileEntity), CORE.MODID + ":" + "textures/gui/" + "SafeBlock.png");
+    }
+    
+    String UUID = ((CONTAINER_SafeBlock)this.mContainer).UUID;
+    private String tempPlayer = PlayerCache.lookupPlayerByUUID(UUID);
+    
+    @Override
+    protected void drawGuiContainerForegroundLayer(int par1, int par2)
+      {
+        this.fontRendererObj.drawString("Safe", 64, 64, 4210752);
+        if (!CORE.DEBUG){
+            this.fontRendererObj.drawString("Owner: "+ tempPlayer, 120, 80, 4210752);
+        }
+      }
+    
+    @Override
+	protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) {
+        super.drawGuiContainerBackgroundLayer(par1, par2, par3);
+        int x = (this.width - this.xSize) / 2;
+        int y = (this.height - this.ySize) / 2;
+        drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize);
+        /*String UUID = ((CONTAINER_SafeBlock)this.mContainer).UUID;
+        this.fontRendererObj.drawString("Owner UUID: "+ UUID, 8, 12, 4210752);*/
+        
+    }
+}
diff --git a/src/Java/miscutil/gregtech/init/machines/GregtechSafeBlock.java b/src/Java/miscutil/gregtech/init/machines/GregtechSafeBlock.java
new file mode 100644
index 0000000000..b38417f1df
--- /dev/null
+++ b/src/Java/miscutil/gregtech/init/machines/GregtechSafeBlock.java
@@ -0,0 +1,53 @@
+package miscutil.gregtech.init.machines;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OreDictNames;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_ModHandler;
+import miscutil.core.util.Utils;
+import miscutil.gregtech.enums.GregtechItemList;
+import miscutil.gregtech.metatileentity.implementations.GregtechMetaSafeBlock;
+
+public class GregtechSafeBlock
+{
+	public static void run()
+	{
+		if (miscutil.core.lib.LoadedMods.Gregtech){
+			Utils.LOG_INFO("MiscUtils: Gregtech5u Content | Registering Lockable Safe Blocks.");
+			run1();
+		}
+		
+	}
+
+	private static void run1()
+	{
+		
+		GregtechItemList.GT_Safe_ULV.set(new GregtechMetaSafeBlock(780, "protection.playersafe.tier.00", "Ultra Low Voltage Player Safe", 0).getStackForm(1L));
+		GregtechItemList.GT_Safe_LV.set(new GregtechMetaSafeBlock(781, "protection.playersafe.tier.01", "Low Voltage Player Safe", 1).getStackForm(1L));
+        GregtechItemList.GT_Safe_MV.set(new GregtechMetaSafeBlock(782, "protection.playersafe.tier.02", "Medium Voltage Player Safe", 2).getStackForm(1L));
+        GregtechItemList.GT_Safe_HV.set(new GregtechMetaSafeBlock(783, "protection.playersafe.tier.03", "High Voltage Player Safe", 3).getStackForm(1L));
+        GregtechItemList.GT_Safe_EV.set(new GregtechMetaSafeBlock(784, "protection.playersafe.tier.04", "Extreme Voltage Player Safe", 4).getStackForm(1L));
+        GregtechItemList.GT_Safe_IV.set(new GregtechMetaSafeBlock(785, "protection.playersafe.tier.05", "Insane Voltage Player Safe", 5).getStackForm(1L));
+        GregtechItemList.GT_Safe_LuV.set(new GregtechMetaSafeBlock(786, "protection.playersafe.tier.06", "Ludicrous Voltage Player Safe", 6).getStackForm(1L));
+        GregtechItemList.GT_Safe_ZPM.set(new GregtechMetaSafeBlock(787, "protection.playersafe.tier.07", "ZPM Voltage Player Safe", 7).getStackForm(1L));
+        GregtechItemList.GT_Safe_UV.set(new GregtechMetaSafeBlock(788, "protection.playersafe.tier.08", "Ultimate Voltage Player Safe", 8).getStackForm(1L));
+        GregtechItemList.GT_Safe_MAX.set(new GregtechMetaSafeBlock(789, "protection.playersafe.tier.09", "MAX Voltage Player Safe", 9).getStackForm(1L));
+
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_ULV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_ULV, Character.valueOf('V'), ItemList.Circuit_Basic, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Basic)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_LV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_LV, Character.valueOf('V'), ItemList.Circuit_Basic, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Basic)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_MV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_MV, Character.valueOf('V'), ItemList.Circuit_Good, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Basic)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_HV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_HV, Character.valueOf('V'), ItemList.Circuit_Good, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Basic)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_EV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_EV, Character.valueOf('V'), ItemList.Circuit_Advanced, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Basic)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_IV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_IV, Character.valueOf('V'), ItemList.Circuit_Advanced, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Advanced)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_LuV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_LuV, Character.valueOf('V'), ItemList.Circuit_Elite, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Advanced)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_ZPM.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_ZPM, Character.valueOf('V'), ItemList.Circuit_Elite, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Advanced)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_UV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_UV, Character.valueOf('V'), ItemList.Circuit_Master, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Advanced)});
+        GT_ModHandler.addCraftingRecipe(GregtechItemList.GT_Safe_MAX.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"CMV", " X ", Character.valueOf('M'), ItemList.Hull_MAX, Character.valueOf('V'), ItemList.Circuit_Master, Character.valueOf('C'), OreDictNames.craftingChest, Character.valueOf('X'), OrePrefixes.circuit.get(Materials.Advanced)});
+
+		
+		
+		
+
+	}
+}
diff --git a/src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaSafeBlock.java b/src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaSafeBlock.java
new file mode 100644
index 0000000000..4d635a91c6
--- /dev/null
+++ b/src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaSafeBlock.java
@@ -0,0 +1,76 @@
+package miscutil.gregtech.metatileentity.implementations;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import miscutil.gregtech.gui.CONTAINER_SafeBlock;
+import miscutil.gregtech.gui.GUI_SafeBlock;
+import miscutil.gregtech.metatileentity.implementations.base.GregtechMetaSafeBlockBase;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.EnumChatFormatting;
+
+public class GregtechMetaSafeBlock
+        extends GregtechMetaSafeBlockBase {
+	
+	@Override
+	public String[] getDescription() {
+		return new String[] {mDescription, "Added by: "	+ EnumChatFormatting.DARK_GREEN+"Alkalus"};
+	}
+	
+    public GregtechMetaSafeBlock(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 28, "Protecting your items from sticky fingers.");
+    }
+
+    public GregtechMetaSafeBlock(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription) {
+        super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription);
+    }
+
+    public GregtechMetaSafeBlock(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    @Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaSafeBlock(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures);
+    }
+
+    @Override
+	public ITexture getOverlayIcon() {
+        return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_SUPERBUFFER);
+    }
+
+    @Override
+	public boolean isValidSlot(int aIndex) {
+        return aIndex < this.mInventory.length - 1;
+    }
+
+    /*@Override
+	protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+        fillStacksIntoFirstSlots();
+        super.moveItems(aBaseMetaTileEntity, aTimer);
+        fillStacksIntoFirstSlots();
+    }*/
+
+    protected void fillStacksIntoFirstSlots() {
+        for (int i = 0; i < this.mInventory.length - 1; i++) {
+            for (int j = i + 1; j < this.mInventory.length - 1; j++) {
+                if ((this.mInventory[j] != null) && ((this.mInventory[i] == null) || (GT_Utility.areStacksEqual(this.mInventory[i], this.mInventory[j])))) {
+                    GT_Utility.moveStackFromSlotAToSlotB(getBaseMetaTileEntity(), getBaseMetaTileEntity(), j, i, (byte) 64, (byte) 1, (byte) 64, (byte) 1);
+                }
+            }
+        }
+    }
+
+    @Override
+	public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new CONTAINER_SafeBlock(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GUI_SafeBlock(aPlayerInventory, aBaseMetaTileEntity);
+    }
+}
diff --git a/src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java b/src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java
new file mode 100644
index 0000000000..d4fe9a70b6
--- /dev/null
+++ b/src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java
@@ -0,0 +1,319 @@
+package miscutil.gregtech.metatileentity.implementations.base;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import miscutil.core.util.Utils;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public abstract class GregtechMetaSafeBlockBase extends GT_MetaTileEntity_TieredMachineBlock {
+	public boolean bOutput = false, bRedstoneIfFull = false, bInvert = false, bUnbreakable = false;
+	public int mSuccess = 0, mTargetStackSize = 0;
+	public String ownerUUID = "";
+
+	public GregtechMetaSafeBlockBase(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription) {
+		super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription);
+	}
+
+	public GregtechMetaSafeBlockBase(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+		ITexture[][][] rTextures = new ITexture[6][17][];
+		ITexture tIcon = getOverlayIcon(), tOut = new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT), tUp = new GT_RenderedTexture(Textures.BlockIcons.ARROW_UP), tDown = new GT_RenderedTexture(Textures.BlockIcons.ARROW_DOWN), tLeft = new GT_RenderedTexture(Textures.BlockIcons.ARROW_LEFT), tRight = new GT_RenderedTexture(Textures.BlockIcons.ARROW_RIGHT);
+		for (byte i = -1; i < 16; i++) {
+			rTextures[0][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tOut};
+			rTextures[1][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tRight, tIcon};
+			rTextures[2][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tDown, tIcon};
+			rTextures[3][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tLeft, tIcon};
+			rTextures[4][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tUp, tIcon};
+			rTextures[5][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tIcon};
+		}
+		return rTextures;
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		if (aSide == aFacing) return mTextures[5][aColorIndex + 1];
+		if (GT_Utility.getOppositeSide(aSide) == aFacing) return mTextures[0][aColorIndex + 1];
+		switch (aFacing) {
+		case 0:
+			return mTextures[4][aColorIndex + 1];
+		case 1:
+			return mTextures[2][aColorIndex + 1];
+		case 2:
+			switch (aSide) {
+			case 0:
+				return mTextures[2][aColorIndex + 1];
+			case 1:
+				return mTextures[2][aColorIndex + 1];
+			case 4:
+				return mTextures[1][aColorIndex + 1];
+			case 5:
+				return mTextures[3][aColorIndex + 1];
+			}
+		case 3:
+			switch (aSide) {
+			case 0:
+				return mTextures[4][aColorIndex + 1];
+			case 1:
+				return mTextures[4][aColorIndex + 1];
+			case 4:
+				return mTextures[3][aColorIndex + 1];
+			case 5:
+				return mTextures[1][aColorIndex + 1];
+			}
+		case 4:
+			switch (aSide) {
+			case 0:
+				return mTextures[3][aColorIndex + 1];
+			case 1:
+				return mTextures[1][aColorIndex + 1];
+			case 2:
+				return mTextures[3][aColorIndex + 1];
+			case 3:
+				return mTextures[1][aColorIndex + 1];
+			}
+		case 5:
+			switch (aSide) {
+			case 0:
+				return mTextures[1][aColorIndex + 1];
+			case 1:
+				return mTextures[3][aColorIndex + 1];
+			case 2:
+				return mTextures[1][aColorIndex + 1];
+			case 3:
+				return mTextures[3][aColorIndex + 1];
+			}
+		}
+		return mTextures[5][aColorIndex + 1];
+	}
+
+	@Override
+	public boolean isSimpleMachine() {
+		return false;
+	}
+
+	@Override
+	public boolean isValidSlot(int aIndex) {
+		return aIndex < mInventory.length - 1;
+	}
+
+	@Override
+	public boolean isFacingValid(byte aFacing) {
+		return true;
+	}
+
+	@Override
+	public boolean isEnetInput() {
+		return true;
+	}
+
+	@Override
+	public boolean isEnetOutput() {
+		return true;
+	}
+
+	@Override
+	public boolean isInputFacing(byte aSide) {
+		return !isOutputFacing(aSide);
+	}
+
+	@Override
+	public boolean isOutputFacing(byte aSide) {
+		return getBaseMetaTileEntity().getBackFacing() == aSide;
+	}
+
+	@Override
+	public boolean isTeleporterCompatible() {
+		return false;
+	}
+
+	@Override
+	public long getMinimumStoredEU() {
+		return 512;
+	}
+
+	@Override
+	public long maxEUStore() {
+		return 512 + V[mTier] * 50;
+	}
+
+	@Override
+	public long maxEUInput() {
+		return V[mTier];
+	}
+
+	@Override
+	public long maxEUOutput() {
+		return bOutput ? V[mTier] : 0;
+	}
+
+	@Override
+	public long maxAmperesIn() {
+		return 1;
+	}
+
+	@Override
+	public long maxAmperesOut() {
+		return 1;
+	}
+
+	@Override
+	public boolean isAccessAllowed(EntityPlayer aPlayer) {
+		return true;
+	}
+
+	public abstract ITexture getOverlayIcon();
+
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+		String tempUUID = aPlayer.getUniqueID().toString();
+		if (aBaseMetaTileEntity.isClientSide()) {			
+			//Utils.LOG_WARNING("Clicky Clicky.");			
+			return true;
+
+		}
+		if (!aPlayer.equals(null)) {
+			if (ownerUUID.equals("")){
+				Utils.LOG_WARNING("No owner yet for this block.");
+			}
+			else {
+				Utils.LOG_WARNING("Current stored UUID : "+ownerUUID);
+			}
+			Utils.LOG_WARNING("Check if ownerUUID is Null");
+			if (ownerUUID.equals("")){
+				Utils.LOG_WARNING("OwnerUUID is Null, let's set it.");
+				Utils.LOG_WARNING("Accessing Players UUID is: "+tempUUID);
+				ownerUUID = tempUUID;
+				Utils.messagePlayer(aPlayer, "Owner of this safe, now set. Try accessing it again.");
+				Utils.LOG_WARNING("Block Owner is now set to: "+ownerUUID);
+			}
+			Utils.LOG_WARNING("Check who ownerUUID is if not Null");
+			if (!ownerUUID.equals(null)){
+				Utils.LOG_WARNING("ownerUUID is not Null, let's see if the player clicking can access the GUI.");
+				Utils.LOG_WARNING("Accessing Players UUID is: "+tempUUID);
+				if (ownerUUID.equals(tempUUID)){
+					Utils.LOG_WARNING("Clicking player is the owner, with a UUID of: "+ownerUUID);
+					aBaseMetaTileEntity.openGUI(aPlayer);
+					Utils.LOG_WARNING("GUI should now be open for you sir.");
+				}
+				else {
+					Utils.messagePlayer(aPlayer, "Access Denied, This does not belong to you.");
+					Utils.LOG_WARNING("Expecting UUID : "+ownerUUID);
+					Utils.LOG_ERROR("Access Denied.");
+					return true;
+				}
+
+			}
+
+			/*else {
+				Utils.LOG_ERROR("This is NOT good. Tell Draknyte1 your safe broke.");
+			}*/
+			/*Utils.LOG_WARNING("Clicky Clicky.");
+			Utils.messagePlayer(aPlayer, "Owner of this safe, now set.");
+			aBaseMetaTileEntity.openGUI(aPlayer);	*/
+
+		}
+		return true;
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		aNBT.setBoolean("bUnbreakable", bUnbreakable);
+		aNBT.setBoolean("bOutput", bOutput);
+		aNBT.setBoolean("bRedstoneIfFull", bRedstoneIfFull);
+		aNBT.setInteger("mTargetStackSize", mTargetStackSize);
+		aNBT.setString("ownerUUID", ownerUUID);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		bUnbreakable = aNBT.getBoolean("bUnbreakable");
+		bOutput = aNBT.getBoolean("bOutput");
+		bRedstoneIfFull = aNBT.getBoolean("bRedstoneIfFull");
+		mTargetStackSize = aNBT.getInteger("mTargetStackSize");
+		ownerUUID = aNBT.getString("ownerUUID");
+	}
+
+	@Override
+	public void setItemNBT(NBTTagCompound aNBT) {
+		super.setItemNBT(aNBT);
+		if (mTargetStackSize > 0) aNBT.setInteger("mTargetStackSize", mTargetStackSize);
+	}
+
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+		if (aSide == getBaseMetaTileEntity().getBackFacing()) {
+			mTargetStackSize = (byte) ((mTargetStackSize + (aPlayer.isSneaking()? -1 : 1)) % 65);
+			if (mTargetStackSize == 0) {
+				GT_Utility.sendChatToPlayer(aPlayer, "Do not regulate Item Stack Size");
+			} else {
+				GT_Utility.sendChatToPlayer(aPlayer, "Regulate Item Stack Size to: " + mTargetStackSize);
+			}
+		}
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+		/*if (aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isUniversalEnergyStored(getMinimumStoredEU()) && (aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified() || aTimer % 200 == 0 || mSuccess > 0)) {
+		 */
+		if (aBaseMetaTileEntity.isServerSide()  && (aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified() || aTimer % 200 == 0 || mSuccess > 0)) {
+
+			if (bUnbreakable = true){
+				//this.
+			}
+			else {
+				
+			}
+
+
+
+
+
+
+
+			/*mSuccess--;
+			moveItems(aBaseMetaTileEntity, aTimer);
+			aBaseMetaTileEntity.setGenericRedstoneOutput(bInvert);
+			if (bRedstoneIfFull) {
+				aBaseMetaTileEntity.setGenericRedstoneOutput(!bInvert);
+				for (int i = 0; i < mInventory.length; i++)
+					if (isValidSlot(i)) {
+						if (mInventory[i] == null) {
+							aBaseMetaTileEntity.setGenericRedstoneOutput(bInvert);
+							aBaseMetaTileEntity.decreaseStoredEnergyUnits(1, true);
+							break;
+						}
+					}
+			}
+		}*/
+		}
+	}
+
+	/*protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+		int tCost = GT_Utility.moveOneItemStack(aBaseMetaTileEntity, aBaseMetaTileEntity.getTileEntityAtSide(aBaseMetaTileEntity.getBackFacing()), aBaseMetaTileEntity.getBackFacing(), aBaseMetaTileEntity.getFrontFacing(), null, false, mTargetStackSize == 0 ? 64 : (byte) mTargetStackSize, mTargetStackSize == 0 ? 1 : (byte) mTargetStackSize, (byte) 64, (byte) 1);
+		if (tCost > 0 || aBaseMetaTileEntity.hasInventoryBeenModified()) {
+			mSuccess = 50;
+			aBaseMetaTileEntity.decreaseStoredEnergyUnits(Math.abs(tCost), true);
+		}
+	}*/
+
+	@Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return true;
+	}
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return aSide != aBaseMetaTileEntity.getBackFacing();
+	}
+}
\ No newline at end of file
diff --git a/src/resources/assets/miscutils/textures/gui/SafeBlock.png b/src/resources/assets/miscutils/textures/gui/SafeBlock.png
index 72174926a6..10eddcb040 100644
--- a/src/resources/assets/miscutils/textures/gui/SafeBlock.png
+++ b/src/resources/assets/miscutils/textures/gui/SafeBlock.png