+ Added another data storage object. Examine ReverseAutoMap.java for information.

$ Massive overhaul to the Chunk Loaders.
$ Hopefully added a way to check OreGen per dimension.
% Gave the BlockPos.java object a better UID.

10 files changed, 548 insertions, 138 deletions

diff --git a/src/Java/gtPlusPlus/GTplusplus.java b/src/Java/gtPlusPlus/GTplusplus.java
index d992539374..ff6edde476 100644
--- a/src/Java/gtPlusPlus/GTplusplus.java
+++ b/src/Java/gtPlusPlus/GTplusplus.java
@@ -115,7 +115,6 @@ public class GTplusplus implements ActionListener {
 		}
 		//Utils.LOG_INFO("User's Country: " + CORE.USER_COUNTRY);
 
-		// FirstCall();
 		Utils.registerEvent(new LoginEventHandler());
 		Utils.registerEvent(new MissingMappingsEvent());
 		Logger.INFO("Login Handler Initialized");
@@ -168,9 +167,7 @@ public class GTplusplus implements ActionListener {
 
 	@EventHandler
 	public void serverStarting(final FMLServerStartingEvent event) {
-
-		if (CORE.DEVENV)
-			event.registerServerCommand(new CommandMath());
+		event.registerServerCommand(new CommandMath());
 
 		//Chunk Loading
 		Timer h = ChunkManager.createChunkQueue();
@@ -244,15 +241,8 @@ public class GTplusplus implements ActionListener {
 			}
 		}
 
-		/*if (MiningUtils.findAndMapOreTypesFromGT()) {
-			int mapKey = 0;
-			for (AutoMap<GT_Worldgen_GT_Ore_Layer> g : MiningUtils.mOreMaps) {
-				for (GT_Worldgen_GT_Ore_Layer h : g) {
-					Logger.WORLD("Found Vein "+h.aTextWorldgen + " in map with key: "+mapKey);
-				}
-				mapKey++;
-			}
-		}*/
+		Logger.INFO("[Bedrock Miner] Initial OreType Scan");
+		MiningUtils.iterateAllOreTypes();
 
 	}
 
@@ -280,28 +270,26 @@ public class GTplusplus implements ActionListener {
 		new SegmentHelper();
 	}
 
-	private static final boolean setupMaterialBlacklist(){		
-		int ID = 0;
-		Material.invalidMaterials.put(ID++, Materials._NULL);
-		Material.invalidMaterials.put(ID++, Materials.Clay);
-		Material.invalidMaterials.put(ID++, Materials.Phosphorus);
-		Material.invalidMaterials.put(ID++, Materials.Steel);
-		Material.invalidMaterials.put(ID++, Materials.Bronze);
-		Material.invalidMaterials.put(ID++, Materials.Hydrogen);
+	private static final boolean setupMaterialBlacklist(){	
+		Material.invalidMaterials.put(Materials._NULL);
+		Material.invalidMaterials.put(Materials.Clay);
+		Material.invalidMaterials.put(Materials.Phosphorus);
+		Material.invalidMaterials.put(Materials.Steel);
+		Material.invalidMaterials.put(Materials.Bronze);
+		Material.invalidMaterials.put(Materials.Hydrogen);
 		//Infused TC stuff
-		Material.invalidMaterials.put(ID++, Materials.InfusedAir);	
-		Material.invalidMaterials.put(ID++, Materials.InfusedEarth);	
-		Material.invalidMaterials.put(ID++, Materials.InfusedFire);	
-		Material.invalidMaterials.put(ID++, Materials.InfusedWater);
-
+		Material.invalidMaterials.put(Materials.InfusedAir);	
+		Material.invalidMaterials.put(Materials.InfusedEarth);	
+		Material.invalidMaterials.put(Materials.InfusedFire);	
+		Material.invalidMaterials.put(Materials.InfusedWater);
 		//EIO Materials
-		Material.invalidMaterials.put(ID++, Materials.SoulSand);
-		Material.invalidMaterials.put(ID++, Materials.EnderPearl);
-		Material.invalidMaterials.put(ID++, Materials.EnderEye);
-		Material.invalidMaterials.put(ID++, Materials.Redstone);
-		Material.invalidMaterials.put(ID++, Materials.Glowstone);
-		Material.invalidMaterials.put(ID++, Materials.Soularium);
-		Material.invalidMaterials.put(ID++, Materials.PhasedIron);
+		Material.invalidMaterials.put(Materials.SoulSand);
+		Material.invalidMaterials.put(Materials.EnderPearl);
+		Material.invalidMaterials.put(Materials.EnderEye);
+		Material.invalidMaterials.put(Materials.Redstone);
+		Material.invalidMaterials.put(Materials.Glowstone);
+		Material.invalidMaterials.put(Materials.Soularium);
+		Material.invalidMaterials.put(Materials.PhasedIron);
 
 		if (Material.invalidMaterials.size() > 0){
 			return true;
diff --git a/src/Java/gtPlusPlus/api/objects/data/AutoMap.java b/src/Java/gtPlusPlus/api/objects/data/AutoMap.java
index e5b5ded0ad..de565ab95a 100644
--- a/src/Java/gtPlusPlus/api/objects/data/AutoMap.java
+++ b/src/Java/gtPlusPlus/api/objects/data/AutoMap.java
@@ -8,7 +8,7 @@ public class AutoMap<V> implements Iterable<V>, Cloneable, Serializable {
 	/**
 	 * The Internal Map
 	 */
-	private Map<Integer, V> mInternalMap = new HashMap<Integer, V>();
+	protected Map<Integer, V> mInternalMap = new HashMap<Integer, V>();
 	
 	/**
 	 * The Internal ID
@@ -80,5 +80,9 @@ public class AutoMap<V> implements Iterable<V>, Cloneable, Serializable {
 		V[] val = (V[]) col.toArray();		
 		return val;
 	}
+
+	public synchronized final int getInternalID() {
+		return mInternalID;
+	}
   
 }
diff --git a/src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java b/src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java
new file mode 100644
index 0000000000..dd50d456d2
--- /dev/null
+++ b/src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java
@@ -0,0 +1,157 @@
+package gtPlusPlus.api.objects.data;
+
+import java.util.*;
+
+public class ReverseAutoMap<N> extends AutoMap<N> {
+
+	/**
+	 * The Internal Map
+	 */
+	private Map<N, Integer> mInternalMapReverseLookup = new HashMap<N, Integer>();
+
+	/**
+	 * The Internal ID
+	 */
+	private int mInternalID = 0;
+	private static final long serialVersionUID = 3771412318075131790L;
+
+	@Override
+	public Iterator<N> iterator() {		
+		return values().iterator();
+	}
+
+	public synchronized boolean setValue(N object){
+		int mOriginalID = this.mInternalID;
+		put(object);		
+		if (this.mInternalMap.get(mOriginalID).equals(object) || mOriginalID > this.mInternalID){
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	@Override
+	public synchronized N put(N object){
+		return set(object);
+	}
+
+	@Override
+	public synchronized N set(N object){
+		raiseInternalID();
+		int newID = getNextFreeMapID();
+		mInternalMapReverseLookup.put(object, newID);
+		return mInternalMap.put(newID, object);
+	}
+
+	public synchronized int putToInternalMap(N object){
+		return setInternalMap(object);
+	}
+
+	public synchronized int setInternalMap(N object){
+		raiseInternalID();		
+		int newID = getNextFreeMapID();			
+		mInternalMap.put(newID, object);		
+		return mInternalMapReverseLookup.put(object, newID);
+	}
+
+	private boolean raiseInternalID() {
+		int mOld = mInternalID;
+		mInternalID++;
+		return mInternalID > mOld;
+	}
+
+	public synchronized int getNextFreeMapID() {
+		if (this.mInternalMap.size() < 1 || this.mInternalMapReverseLookup.size() < 1) {
+			return 0;
+		}
+		if (this.mInternalMap.size() == getInternalID()-1) {
+			return getInternalID();
+		}		
+		AutoMap<Integer> free = new AutoMap<Integer>();
+		values: for (int d : this.mInternalMapReverseLookup.values()) {
+			sequential: for (int m=0;m<this.mInternalMap.size();m++) {
+
+				//Counter is lower than current ID, keep counting.
+				if (m < d || m == d) {
+					continue sequential;
+				}
+				//Possible that d is missing in sequence i.e.  (m=0,1,2,3 & d=0,1,3,4)
+				else if (m > d) {
+					free.put(m);
+					continue values;
+				}
+			}
+		}		
+		if (free.isEmpty()) {
+			return 0;
+		}
+		else {
+			return free.get(0);
+		}
+	}
+
+	@Override
+	public synchronized N get(int id){		
+		return mInternalMap.get(id);
+	}
+
+	public synchronized int get(N key) {		
+		return mInternalMapReverseLookup.get(key);
+	}
+
+	@Override
+	public synchronized Collection<N> values(){
+		return mInternalMap.values();
+	}
+
+	@Override
+	public synchronized int size(){
+		return mInternalMap.size();
+	}
+
+	@Override
+	public synchronized int hashCode(){
+		return mInternalMap.hashCode()+mInternalMapReverseLookup.hashCode();
+	}
+
+	@Override
+	public synchronized boolean containsKey(int key){
+		return mInternalMap.containsKey(key);
+	}
+
+	@Override
+	public synchronized boolean containsValue(N value){
+		return mInternalMap.containsValue(value);
+	}
+
+	public synchronized boolean containsKey(N key){
+		return mInternalMapReverseLookup.containsKey(key);
+	}
+
+	public synchronized boolean containsValue(int value){
+		return mInternalMapReverseLookup.containsValue(value);
+	}
+
+	@Override
+	public synchronized boolean isEmpty(){
+		return mInternalMap.isEmpty() && mInternalMapReverseLookup.isEmpty();
+	}
+
+	@Override
+	public synchronized boolean clear(){
+		this.mInternalID = 0;
+		this.mInternalMap.clear();
+		this.mInternalMapReverseLookup.clear();
+		return true;
+	}
+
+	@Override
+	public synchronized N[] toArray() {		
+		Collection<N> col = this.mInternalMap.values();
+		@SuppressWarnings("unchecked")
+		N[] val = (N[]) col.toArray();		
+		return val;
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/api/objects/minecraft/BlockPos.java b/src/Java/gtPlusPlus/api/objects/minecraft/BlockPos.java
index 5f0d3a2117..634035d712 100644
--- a/src/Java/gtPlusPlus/api/objects/minecraft/BlockPos.java
+++ b/src/Java/gtPlusPlus/api/objects/minecraft/BlockPos.java
@@ -18,17 +18,22 @@ public class BlockPos implements Serializable{
 	public final int zPos;
 	public final int dim;
 	public final World world;
+	
+	public static BlockPos generateBlockPos(String sUUID) {
+		String[] s2 = sUUID.split("@");
+		return new BlockPos(s2);
+	}
+	
+	public BlockPos(String[] s){
+		this(Integer.parseInt(s[1]), Integer.parseInt(s[2]), Integer.parseInt(s[3]), Integer.parseInt(s[0]));
+	}
 
 	public BlockPos(int x, int y, int z){
 		this(x, y, z, 0);
 	}
 
 	public BlockPos(int x, int y, int z, int dim){
-		this.xPos = x;
-		this.yPos = y;
-		this.zPos = z;
-		this.dim = dim;
-		this.world = DimensionManager.getWorld(dim);
+		this(x, y, z, DimensionManager.getWorld(dim));
 	}
 
 	public BlockPos(int x, int y, int z, World dim){
@@ -42,6 +47,11 @@ public class BlockPos implements Serializable{
 	public String getLocationString() {
 		return "[X: "+this.xPos+"][Y: "+this.yPos+"][Z: "+this.zPos+"][Dim: "+this.dim+"]";
 	}
+	
+	public String getUniqueIdentifier() {
+		String S = ""+this.dim+"@"+this.xPos+"@"+this.yPos+"@"+this.zPos;
+		return S;
+	}	
 
 	@Override
 	public  int hashCode() {
diff --git a/src/Java/gtPlusPlus/api/objects/minecraft/ChunkManager.java b/src/Java/gtPlusPlus/api/objects/minecraft/ChunkManager.java
index 82f3adfc9e..ef180b05c5 100644
--- a/src/Java/gtPlusPlus/api/objects/minecraft/ChunkManager.java
+++ b/src/Java/gtPlusPlus/api/objects/minecraft/ChunkManager.java
@@ -15,15 +15,23 @@ import com.google.common.collect.LinkedListMultimap;
 import com.google.common.collect.ListMultimap;
 
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 
+import net.minecraft.block.Block;
 import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.ChunkCoordIntPair;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
 
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
 import gtPlusPlus.GTplusplus;
 import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.ReverseAutoMap;
 import gtPlusPlus.api.objects.data.Triplet;
+import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic.GregtechMetaTileEntityChunkLoader;
 import net.minecraftforge.common.ForgeChunkManager;
 import net.minecraftforge.common.ForgeChunkManager.*;
@@ -34,15 +42,125 @@ import net.minecraftforge.event.entity.EntityEvent;
  */
 public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, ForgeChunkManager.PlayerOrderedLoadingCallback {
 
-	private static ChunkManager instance;
+	private static final ChunkManager instance;
+	private static volatile long mInternalTickCounter = 0;	
+	private static ReverseAutoMap<String> mIdToUUIDMap = new ReverseAutoMap<String>();
+	
+	public static ConcurrentHashMap<String, Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos>> mChunkLoaderManagerMap = new ConcurrentHashMap<String, Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos>>();
+	
+	
 
-	public static ConcurrentHashMap<BlockPos, Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos>> mChunkLoaderManagerMap = new ConcurrentHashMap<BlockPos, Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos>>();
+	static {
+		instance = new ChunkManager();
+	}
 
+	public ChunkManager() {
+		Utils.registerEvent(this);
+	}
+	
+	public static int getIdFromUniqueString(String blockposString) {
+		if (mIdToUUIDMap.containsValue(blockposString)) {
+			return mIdToUUIDMap.get(blockposString);
+		}
+		else {
+			return mIdToUUIDMap.putToInternalMap(blockposString);
+		}
+	}
+	
+	public static String getUniqueStringFromID(int id) {
+		if (mIdToUUIDMap.containsKey(id)) {
+			return mIdToUUIDMap.get(id);
+		}
+		else {
+			return "0@0@0@0";
+		}
+	}
 
-	public static ChunkManager getInstance() {
-		if (instance == null) {
-			instance = new ChunkManager();
+
+	@SubscribeEvent
+	public void serverTick(TickEvent.ServerTickEvent e){
+		mInternalTickCounter++;
+		try {
+			if (mInternalTickCounter % (20*15) == 0) {
+				for (String g : mChunkLoaderManagerMap.keySet()) {	
+					BlockPos i = BlockPos.generateBlockPos(g);				
+					if (i == null) {
+						mChunkLoaderManagerMap.remove(g);
+						Logger.MACHINE_INFO("Bad Mapping: "+g);
+						continue;
+					}
+					else {
+						Logger.MACHINE_INFO("Good Mapping: "+i.getLocationString());					
+					}
+					Block mBlock = i.world.getBlock(i.xPos, i.yPos, i.zPos);
+					TileEntity mTile = i.world.getTileEntity(i.xPos, i.yPos, i.zPos);	
+					IGregTechTileEntity mGTile = null;
+					boolean remove = false;
+					if (((mTile = i.world.getTileEntity(i.xPos, i.yPos, i.zPos)) != null) && (mTile instanceof IGregTechTileEntity)){
+						mGTile = (IGregTechTileEntity) mTile; //943-945
+						if (mGTile instanceof GregtechMetaTileEntityChunkLoader || mGTile.getMetaTileID() == 943 || mGTile.getMetaTileID() == 944 || mGTile.getMetaTileID() == 945) {
+							Logger.MACHINE_INFO("Found Valid Chunk Loader Entity.");
+							continue;
+						}
+						else {
+							Logger.MACHINE_INFO("Found Valid GT Tile which was not a Chunk Loader Entity.");
+							remove = true;
+						}
+					}
+					else if ((mTile = i.world.getTileEntity(i.xPos, i.yPos, i.zPos)) != null){
+						Logger.MACHINE_INFO("Found Valid Tile Entity.");
+						remove = true;
+					}
+					else {
+						mTile = null;
+						remove = true;
+					}
+					if (mBlock == null || mGTile == null || mBlock != GregTech_API.sBlockMachines) {
+						remove = true;
+					}
+
+					if (remove) {						
+						//1
+						if (mBlock != null) {
+							Logger.MACHINE_INFO("Found Block.");
+							//2
+							if (mBlock == GregTech_API.sBlockMachines) {
+								Logger.MACHINE_INFO("Found GT Machine.");								
+								//3
+								if (mTile != null) {									
+									//4
+									if (GregtechMetaTileEntityChunkLoader.class.isInstance(mTile.getClass())) {
+										Logger.MACHINE_INFO("Found Valid Chunk Loader.");
+									}
+									else {
+										Logger.MACHINE_INFO("Tile Entity was not a Chunk Loader.");
+									}//4
+								}
+								else {
+									Logger.MACHINE_INFO("Tile Entity was Null though.");									
+								}//3
+							}
+							else {
+								Logger.MACHINE_INFO("Found Block that was not a GT Machine.");							
+							}//2
+						}
+						else {
+							Logger.MACHINE_INFO("Found Null Block.");							
+						}//1
+					}
+					mChunkLoaderManagerMap.remove(i.getUniqueIdentifier());
+					Logger.INFO("Removing invalid Chunk Loader. Mapping: "+i.getUniqueIdentifier());
+					continue;
+				}
+			}		
 		}
+		catch (Throwable t) {
+			t.printStackTrace();
+		}
+
+	}
+
+	public static ChunkManager getInstance() {
 		return instance;
 	}
 
@@ -142,7 +260,7 @@ public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, Fo
 
 		if (world.isRemote) return;
 
-		//        System.out.println("Callback 2");
+		System.out.println("Callback 2");
 		for (Ticket ticket : tickets) {
 			if (ticket.isPlayerTicket())
 				continue;
@@ -153,17 +271,16 @@ public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, Fo
 				int z = ticket.getModData().getInteger("zCoord");
 
 				if (y >= 0) {
-					BlockPos tile = new BlockPos(x, y, z);
-					
+					BlockPos tile = new BlockPos(x, y, z);					
 					Ticket H = tryForceLoadChunk(new DimChunkPos(world, tile).getChunk());
 
 					int jhg = 0;
 					while (jhg < 50) {
 						jhg++;
 					}
-					
+
 					if (!mChunkLoaderManagerMap.isEmpty()) {						
-						GregtechMetaTileEntityChunkLoader f = mChunkLoaderManagerMap.get(tile).getValue_2();
+						GregtechMetaTileEntityChunkLoader f = mChunkLoaderManagerMap.get(tile.getUniqueIdentifier()).getValue_2();
 						int timeout = 0;
 						while (f == null) {
 							if (timeout > 5000) {
@@ -173,7 +290,7 @@ public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, Fo
 							else {
 								GregtechMetaTileEntityChunkLoader g;
 								if (!mChunkLoaderManagerMap.isEmpty()) {
-									g = mChunkLoaderManagerMap.get(tile).getValue_2();
+									g = mChunkLoaderManagerMap.get(tile.getUniqueIdentifier()).getValue_2();
 									if (g == null) {
 										timeout++;
 									}
@@ -187,12 +304,9 @@ public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, Fo
 						}
 						try {
 							if (f != null) {
-								
-
 								if (H != null) {
 									ForgeChunkManager.releaseTicket(H);
-								}
-								
+								}								
 								f.forceChunkLoading(ticket);
 								printAnchor("Force Chunk Loading. Chunk Loader has ID of "+f.getLoaderID()+". ",x,y,z);
 							}
@@ -204,12 +318,12 @@ public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, Fo
 							t.printStackTrace();
 							Logger.INFO("Mild problem with chunk loading, nothing to worry about.");
 						}
-						
+
 
 						if (H != null) {
 							ForgeChunkManager.releaseTicket(H);
 						}
-						
+
 					}					
 
 					/*if (tile instanceof IGregTechTileEntity) {
@@ -258,14 +372,18 @@ public class ChunkManager implements LoadingCallback, OrderedLoadingCallback, Fo
 	public static Timer createChunkQueue() {
 		return ChunkTimerLoader();
 	}
-	
+
 	public static Ticket tryForceLoadChunk(Chunk c) {
 		Ticket T = getTicketFromForge(c.worldObj);
+		if (T == null) {
+			Logger.INFO("[Chunk Loader] Trying to force load a chunk that holds a chunkloader, however the Chunk Loading Ticket was null.");				
+			return null;
+		}
 		ForgeChunkManager.forceChunk(T, c.getChunkCoordIntPair());
 		Logger.INFO("[Chunk Loader] Trying to force load a chunk that holds a chunkloader.");	
 		return T;
 	}
-	
+
 	public static Ticket getTicketFromForge(World world) {
 		return ForgeChunkManager.requestTicket(GTplusplus.instance, world, Type.NORMAL);
 	}
diff --git a/src/Java/gtPlusPlus/core/commands/CommandMath.java b/src/Java/gtPlusPlus/core/commands/CommandMath.java
index 6ab0b2cbc6..8772af641b 100644
--- a/src/Java/gtPlusPlus/core/commands/CommandMath.java
+++ b/src/Java/gtPlusPlus/core/commands/CommandMath.java
@@ -6,12 +6,11 @@ import java.util.List;
 import net.minecraft.command.ICommand;
 import net.minecraft.command.ICommandSender;
 import net.minecraft.entity.Entity;
-import net.minecraft.entity.item.EntityItem;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.world.World;
 
-import gtPlusPlus.api.objects.data.AutoMap;
-import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.util.minecraft.MiningUtils;
 
 
 public class CommandMath implements ICommand
@@ -55,7 +54,12 @@ public class CommandMath implements ICommand
 	public void processCommand(final ICommandSender S, final String[] argString){
 		final World W = S.getEntityWorld();
 		final EntityPlayer P = CommandUtils.getPlayer(S);
-		if (!W.isRemote && P != null){
+		if (P.getDisplayName().equalsIgnoreCase("draknyte1")) {
+			Logger.INFO("[Bedrock Miner] OreType Scan");	
+			MiningUtils.iterateAllOreTypes();
+		}
+		
+		/*if (!W.isRemote && P != null){
 			if (P.getDisplayName().toLowerCase().equals("draknyte1") || P.getCommandSenderName().toLowerCase().equals("draknyte1")) {
 				String[] prefixes = new String[] {
 						"ingot",
@@ -94,7 +98,7 @@ public class CommandMath implements ICommand
 				}
 
 			}
-		}
+		}*/
 
 		/*else
 
diff --git a/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java b/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java
index ff61834276..4066592f88 100644
--- a/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java
+++ b/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java
@@ -103,7 +103,7 @@ public class COMPAT_HANDLER {
 			GregtechTeslaTower.run();
 			GregtechSuperTanks.run();
 			GregtechIndustrialFishPond.run();
-			//GregtechTieredChunkloaders.run();
+			GregtechTieredChunkloaders.run();
 			GregtechIndustrialExtruder.run();
 			GregtechIndustrialMultiMachine.run();
 			GregtechBedrockPlatforms.run();
diff --git a/src/Java/gtPlusPlus/core/material/Material.java b/src/Java/gtPlusPlus/core/material/Material.java
index 1b2ef19b53..13c7e99887 100644
--- a/src/Java/gtPlusPlus/core/material/Material.java
+++ b/src/Java/gtPlusPlus/core/material/Material.java
@@ -3,8 +3,6 @@ package gtPlusPlus.core.material;
 import static gregtech.api.enums.GT_Values.M;
 
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
 
 import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
@@ -72,7 +70,7 @@ public class Material {
 	private GTPP_Aspects[] vAspects;
 
 
-	public static Map<Integer, Materials> invalidMaterials = new HashMap<Integer, Materials>();
+	public static AutoMap<Materials> invalidMaterials = new AutoMap<Materials>();
 
 	public Material(String materialName, MaterialState defaultState, short[] rgba, int radiationLevel, MaterialStack[] materialStacks) {
 		this(materialName, defaultState, null, 0, rgba, -1, -1, -1, -1, false, "", radiationLevel, false, materialStacks);
diff --git a/src/Java/gtPlusPlus/core/util/minecraft/MiningUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/MiningUtils.java
index 82168503ae..43c77282bb 100644
--- a/src/Java/gtPlusPlus/core/util/minecraft/MiningUtils.java
+++ b/src/Java/gtPlusPlus/core/util/minecraft/MiningUtils.java
@@ -1,5 +1,7 @@
 package gtPlusPlus.core.util.minecraft;
 
+import java.util.HashMap;
+
 import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
 import net.minecraft.world.World;
@@ -139,6 +141,23 @@ public class MiningUtils {
 		}
 		
 	}
+	
+	public static void iterateAllOreTypes() {
+		HashMap<String, Integer> M = new HashMap<String, Integer>();		
+		if (MiningUtils.findAndMapOreTypesFromGT()) {
+			int mapKey = 0;
+			for (AutoMap<GT_Worldgen_GT_Ore_Layer> g : MiningUtils.mOreMaps) {
+				for (GT_Worldgen_GT_Ore_Layer h : g) {					
+					//if (M.containsKey(h.aTextWorldgen + h.mWorldGenName)) {
+						M.put(h.aTextWorldgen + h.mWorldGenName, mapKey);
+						Logger.INFO("Found Vein type: " + h.aTextWorldgen + h.mWorldGenName + " in map with key: "+mapKey);
+					//}					
+				}
+				mapKey++;
+			}
+		}
+	}
+	
 	public static AutoMap<GT_Worldgen_GT_Ore_Layer>[] mOreMaps = new AutoMap[7];
 	private static AutoMap<GT_Worldgen_GT_Ore_Layer> Ores_Overworld = new AutoMap<GT_Worldgen_GT_Ore_Layer>();
 	private static AutoMap<GT_Worldgen_GT_Ore_Layer> Ores_Nether = new AutoMap<GT_Worldgen_GT_Ore_Layer>();
@@ -151,7 +170,7 @@ public class MiningUtils {
 	public static boolean findAndMapOreTypesFromGT() {
 		//Gets Moon ID
 		try {
-			if (Class.forName("micdoodle8.mods.galacticraft.core.util.ConfigManagerCore") != null) {
+			if (Class.forName("micdoodle8.mods.galacticraft.core.util.ConfigManagerCore") != null && mMoonID == -99) {
 				mMoonID = ReflectionUtils.getField(Class.forName("micdoodle8.mods.galacticraft.core.util.ConfigManagerCore"), "idDimensionMoon").getInt(null);
 			}
 		}
@@ -159,7 +178,7 @@ public class MiningUtils {
 		
 		//Gets Mars ID
 		try {
-			if (Class.forName("micdoodle8.mods.galacticraft.planets.mars.ConfigManagerMars") != null) {
+			if (Class.forName("micdoodle8.mods.galacticraft.planets.mars.ConfigManagerMars") != null && mMarsID == -99) {
 				mMarsID = ReflectionUtils.getField(Class.forName("micdoodle8.mods.galacticraft.planets.mars.ConfigManagerMars"), "dimensionIDMars").getInt(null);
 			}
 		}
@@ -167,28 +186,33 @@ public class MiningUtils {
 		
 		//Get Comets ID
 		try {
-			if (Class.forName("micdoodle8.mods.galacticraft.planets.asteroids.ConfigManagerAsteroids") != null) {
+			if (Class.forName("micdoodle8.mods.galacticraft.planets.asteroids.ConfigManagerAsteroids") != null && mCometsID == -99) {
 				mCometsID = ReflectionUtils.getField(Class.forName("micdoodle8.mods.galacticraft.planets.asteroids.ConfigManagerAsteroids"), "dimensionIDAsteroids").getInt(null);
 			}
 		}
 		catch (ClassNotFoundException | IllegalArgumentException | IllegalAccessException | NoSuchFieldException e) {}
-		
+
+		//Clear Cache
+		Ores_Overworld.clear();
+		Ores_Nether.clear();
+		Ores_End.clear();
+		Ores_Misc.clear();
 		
 		for (GT_Worldgen_GT_Ore_Layer x : GT_Worldgen_GT_Ore_Layer.sList) {			
 			if (x.mEnabled) {
-				/*if (x.mOverworld) {
+				if (x.mOverworld) {
 					Ores_Overworld.put(x);
-					continue;
 				}
 				if (x.mNether) {
 					Ores_Nether.put(x);
-					continue;
 				}
 				if (x.mEnd || x.mEndAsteroid) {
 					Ores_End.put(x);
+				}
+				if (x.mOverworld || x.mNether || (x.mEnd || x.mEndAsteroid)) {
 					continue;
 				}
-				if (x.mMoon) {
+				/*if (x.mMoon) {
 					Ores_Moon.put(x);
 					continue;
 				}
@@ -202,8 +226,13 @@ public class MiningUtils {
 				}*/
 				Ores_Misc.put(x);
 				continue;
-			}			
+			}
+			else {
+				Ores_Comets.put(x);
+			}
 		}	
+		
+		
 		mOreMaps[0] = Ores_Overworld;
 		mOreMaps[1] = Ores_Nether;
 		mOreMaps[2] = Ores_End;
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java
index 034c2da487..b73daf3db6 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java
@@ -10,6 +10,7 @@ import java.util.Set;
 import java.util.UUID;
 
 import com.google.common.collect.MapMaker;
+import com.google.common.collect.Sets;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -39,16 +40,46 @@ import net.minecraftforge.common.ForgeChunkManager.Type;
 
 public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredMachineBlock implements IChunkLoader {
 
-	public int mRange = 16;
 	private long mTicksLeft = 0;
-	private UUID mUUID = UUID.randomUUID();
+	
+	private boolean hasTicket;
+	private boolean refreshTicket;
 
+	@SuppressWarnings("unused")
+	private final static int yMin = 0;
+	private final static int yMax = 254;
+	private final int xMin, xMax;
+	private final int zMin, zMax;
+	private int mChunkLoaderMapID = -1;
+	private boolean mHasID = false;	
+	private final short mMaxTicks = 100;	
+	private final UUID mUUID;	
+	private static final byte ANCHOR_RADIUS = 1;	
+	private static final Map<UUID, Ticket> tickets = new MapMaker().makeMap();
+	private Set<ChunkCoordIntPair> chunks;
+	
 	public GregtechMetaTileEntityChunkLoader(final int aID, final String aName, final String aNameRegional, final int aTier) {
 		super(aID, aName, aNameRegional, aTier, 0, "Loads chunks: " + (16 + (48 * aTier)) + " powered");
+		xMin = this.xCoord-47;
+		xMax = this.xCoord+47;
+		zMin = this.zCoord-47;
+		zMax = this.zCoord+47;
+		mUUID = UUID.randomUUID();
+		this.prevX = this.xCoord;
+		this.prevY = this.yCoord;
+		this.prevZ = this.zCoord;
 	}
 
 	public GregtechMetaTileEntityChunkLoader(final String aName, final int aTier, final int aInvSlotCount, final String aDescription, final ITexture[][][] aTextures) {
 		super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+		xMin = this.xCoord-47;
+		xMax = this.xCoord+47;
+		zMin = this.zCoord-47;
+		zMax = this.zCoord+47;
+		mUUID = UUID.randomUUID();
+		this.prevX = this.xCoord;
+		this.prevY = this.yCoord;
+		this.prevZ = this.zCoord;
 	}
 
 	@Override
@@ -65,34 +96,50 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 	private int prevX, prevY, prevZ;
 	@Override
 	public void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTimer) {
+
+		xCoord = aBaseMetaTileEntity.getXCoord();
+		yCoord = aBaseMetaTileEntity.getYCoord();
+		zCoord = aBaseMetaTileEntity.getZCoord();
+		
+
 		if (!aBaseMetaTileEntity.isServerSide()) {
 			return;
 		}
+		
+		if (aTimer % 300 == 0) {
+			if (!isRegistered() && this.getEUVar() > 0) {
+				registerLoader();
+			}
+			else if (isRegistered() && this.getEUVar() <= 0) {
+				releaseTicket();
+			}
+		}
 
-		if (aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.isServerSide()) {
-
-
+		if (!areChunksLoaded()) {
+			return;
+		}
 
+		if (aBaseMetaTileEntity.isAllowedToWork()) {
 			if (this.mTicksLeft > 0) {
 				this.mTicksLeft--;
 			}
 			else if (this.mTicksLeft < 0) {
 				this.mTicksLeft = 0;
 			}		
-			if (mTicksLeft < 10) {  
+			if (mTicksLeft < mMaxTicks) {  
 				long h = this.getEUVar();
 				if (h > 0) {
 					if (h >(this.maxEUInput()+this.getMinimumStoredEU())) {
 						this.setEUVar((this.getEUVar()-this.maxEUInput()));
-						this.mTicksLeft += 10;
+						this.mTicksLeft += 2;
 					}
 				}
-			}			
-
-			xCoord = aBaseMetaTileEntity.getXCoord();
-			yCoord = aBaseMetaTileEntity.getYCoord();
-			zCoord = aBaseMetaTileEntity.getZCoord();
+			}	
+			if (mTicksLeft > mMaxTicks) {
+				mTicksLeft = mMaxTicks;
+			}
 
+			//Somehow the Tile has moved, so lets release the ticket and update the previous xyz.
 			if (xCoord != prevX || yCoord != prevY || zCoord != prevZ) {
 				releaseTicket();
 				prevX = xCoord;
@@ -100,30 +147,26 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 				prevZ = zCoord;
 			}
 
+			//Tile has an active ticket, but either (1) the ticket is for a different dimension. (2) A ticket refresh has been queued or (3) the Tile is not allowed to work (Disabled via mallet)
 			if (hasActiveTicket() && (getTicket().world != aBaseMetaTileEntity.getWorld() || refreshTicket || !aBaseMetaTileEntity.isAllowedToWork())) {
 				releaseTicket();
-			}        
+			}			
 
+			//Tile does not have a ticket but has mTicksLeft, we had best create a ticket,
 			if (!hasActiveTicket() && this.mTicksLeft > 0) {
 				requestTicket();
 			}
-
-
 		}
-
-
-
-
 	}
 
 	@Override
 	public void onFirstTick(final IGregTechTileEntity aBaseMetaTileEntity) {
-		validate();
+		
 	}
 
 	@Override
 	public void onRemoval() {
-		ChunkManager.mChunkLoaderManagerMap.remove(new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId));
+		releaseTicket();
 	}
 
 	@Override
@@ -133,7 +176,7 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 
 	@Override
 	public boolean isFacingValid(final byte aFacing) {
-		return true;
+		return aFacing > 1;
 	}
 
 	@Override
@@ -189,11 +232,15 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 	@Override
 	public void saveNBTData(final NBTTagCompound aNBT) {
 		aNBT.setLong("mTicksLeft", getTicksRemaining());
+		aNBT.setBoolean("mHasID", mHasID);
+		aNBT.setInteger("mChunkLoaderMapID", mChunkLoaderMapID);
 	}
 
 	@Override
 	public void loadNBTData(final NBTTagCompound aNBT) {
 		this.mTicksLeft = aNBT.getLong("mTicksLeft");
+		this.mHasID = aNBT.getBoolean("mHasID");
+		this.mChunkLoaderMapID = aNBT.getInteger("mChunkLoaderMapID");
 	}
 
 
@@ -203,24 +250,32 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 	/**
 	 * Chunk Handling
 	 */
-	private static final Map<UUID, Ticket> tickets = new MapMaker().makeMap();
-	private static final byte ANCHOR_RADIUS = 1;
-	private boolean hasTicket;
-	private boolean refreshTicket;
-	private Set<ChunkCoordIntPair> chunks;
-	private short mChunkLoaderMapID = -1;
 
 	public void registerLoader() {
-		short mSize = (short) mChunkLoaderManagerMap.size();
-		this.mChunkLoaderMapID = mSize;
-		if (this != null && this.getBaseMetaTileEntity() != null) {		
-			if (!isRegistered()) {
-				if (this.xCoord != 0 && this.yCoord != 0 && this.zCoord != 0) {
-					BlockPos thisPos = new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId);
-					Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos> loaderData = new Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos>((int) this.mChunkLoaderMapID, this, new DimChunkPos(this.getBaseMetaTileEntity().getWorld(), thisPos));
-					mChunkLoaderManagerMap.put(thisPos, loaderData);
-					Logger.INFO("[Chunk Loader] Registered Chunk loader ["+this.mChunkLoaderMapID+"]"+thisPos.getLocationString());
-					//mChunkLoaders.put(new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId),this);
+		if (this.getBaseMetaTileEntity().getWorld().isRemote) {
+			return;
+		}		
+		//Logger.INFO("=======================[Chunkloader Registration]========================");
+		//Logger.INFO("Method Call [1]:"+ReflectionUtils.getMethodName(0));
+		//Logger.INFO("Method Call [2]:"+ReflectionUtils.getMethodName(1));
+		//Logger.INFO("Method Call [3]:"+ReflectionUtils.getMethodName(2));
+		if (this.getEUVar() <= 0) {
+			return;
+		}
+		
+		if (this.getBaseMetaTileEntity() != null && this.getBaseMetaTileEntity().getWorld() != null && this.getBaseMetaTileEntity().getWorld().getWorldTime() >= 100) {		
+			if (!mHasID) {
+				this.mChunkLoaderMapID = ChunkManager.getIdFromUniqueString(getUniqueID());
+				mHasID = true;
+			}
+			if (this != null && this.getBaseMetaTileEntity() != null) {		
+				if (!isRegistered() && !getUniqueID().equalsIgnoreCase("0@0@0@0")) {
+					Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos> loaderData = new Triplet<Integer, GregtechMetaTileEntityChunkLoader, DimChunkPos>((int) this.mChunkLoaderMapID, this, new DimChunkPos(this.getBaseMetaTileEntity().getWorld(), getPos()));
+					mChunkLoaderManagerMap.put(getUniqueID(), loaderData);
+					Logger.INFO("[Chunk Loader] Registered Chunk loader ["+this.mChunkLoaderMapID+"]"+getPos().getLocationString());
+				}
+				else {
+					Logger.INFO("Tried to re-register a Chunk-Loader. Loader located @ "+getPos().getLocationString());
 				}
 			}
 		}
@@ -229,22 +284,37 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 
 	public void unregisterLoader() {
 		if (this != null && this.getBaseMetaTileEntity() != null) {		
-			if (isRegistered()) {		
-				BlockPos thisPos = new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId);
-				mChunkLoaderManagerMap.remove(thisPos);
-				Logger.INFO("[Chunk Loader] Removed Chunk loader ["+this.mChunkLoaderMapID+"]"+thisPos.getLocationString());
-				//mChunkLoaders.put(new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId),this);
+			if (isRegistered()) {
+				mChunkLoaderManagerMap.remove(getUniqueID());
+				Logger.INFO("[Chunk Loader] Removed Chunk loader ["+this.mChunkLoaderMapID+"]"+getPos().getLocationString());
 			}
 		}
 	}
 
 	public boolean isRegistered() {
-		BlockPos j = new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId);
-		return mChunkLoaderManagerMap.containsKey(j);		
-		//return mChunkLoaders.containsValue(this);
+		return mChunkLoaderManagerMap.containsKey(getUniqueID());	
+	}
+
+	private BlockPos mCachedLocation;
+	public BlockPos getPos() {
+		if (mCachedLocation == null) {
+			mCachedLocation = new BlockPos(this.xCoord, this.yCoord, this.zCoord, this.getBaseMetaTileEntity().getWorld().provider.dimensionId);
+		}
+		else if (mCachedLocation.xPos == 0 && mCachedLocation.yPos == 0 && mCachedLocation.zPos == 0 && mCachedLocation.dim == 0) {
+			mCachedLocation = null;
+			return getPos();
+		}
+		return mCachedLocation;
+	}
+
+	public String getUniqueID() {
+		if (getPos() == null) {
+			return "InvalidChunkLoader";
+		}		
+		return getPos().getUniqueIdentifier();
 	}
 
-	public short getLoaderID() {
+	public int getLoaderID() {
 		return this.mChunkLoaderMapID;
 	}
 
@@ -253,19 +323,22 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 	}
 
 	public void invalidate() {
+		releaseTicket();	
+		super.inValidate();
 		refreshTicket = true;
-		unregisterLoader();
 	}
 
 	public void validate() {
 		if (!isRegistered()) {
 			registerLoader();
 		}
-		refreshTicket = true;
 	}
 
 	protected void releaseTicket() {
 		refreshTicket = false;
+		if (getTicket() != null) {
+			ForgeChunkManager.releaseTicket(getTicket());
+		}
 		setTicket(null);
 		unregisterLoader();
 	}
@@ -312,14 +385,14 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 					}
 					ForgeChunkManager.releaseTicket(ticket);
 				}
-				Logger.INFO("[Chunk Loader] "+"Removing Ticking. ["+this.getLoaderID()+"] @ [x: "+this.xCoord+"][y: "+this.yCoord+"][z: "+this.zCoord+"]");
+				Logger.INFO("[Chunk Loader] "+"Removing Ticket. ["+this.getLoaderID()+"] @ [x: "+this.xCoord+"][y: "+this.yCoord+"][z: "+this.zCoord+"]");
 				tickets.remove(mUUID);
 			}
 			changed = true;
 		}
-		hasTicket = t != null;
+		hasTicket = (t != null);
 		if (hasTicket) {
-			Logger.INFO("[Chunk Loader] "+"Putting Ticking. ["+this.getLoaderID()+"] @ [x: "+this.xCoord+"][y: "+this.yCoord+"][z: "+this.zCoord+"]");
+			Logger.INFO("[Chunk Loader] "+"Putting Ticket. ["+this.getLoaderID()+"] @ [x: "+this.xCoord+"][y: "+this.yCoord+"][z: "+this.zCoord+"]");
 			tickets.put(mUUID, t);
 		}
 		//if (changed)
@@ -327,22 +400,36 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 	}
 
 	public void forceChunkLoading(Ticket ticket) {
-		try {
+		try {			
 			setTicket(ticket);
-
-			setupChunks();
-
-			if (chunks != null) {
+			forceChunkLoading2(ticket);
+			//setupChunks();
+			/*if (chunks != null) {
 				for (ChunkCoordIntPair chunk : chunks) {
 					ForgeChunkManager.forceChunk(ticket, chunk);
 				}
-			}
+			}*/
 		}
 		catch (Throwable t){
 			t.printStackTrace();
 		}
 	}
 
+	public void forceChunkLoading2(Ticket ticket) {		
+		chunks = Sets.newHashSet();
+		ChunkCoordIntPair quarryChunk = new ChunkCoordIntPair(xCoord >> 4, zCoord >> 4);
+		chunks.add(quarryChunk);
+		ForgeChunkManager.forceChunk(ticket, quarryChunk);
+		for (int chunkX = xMin >> 4; chunkX <= xMax >> 4; chunkX++) {
+			for (int chunkZ = zMin >> 4; chunkZ <= zMax >> 4; chunkZ++) {
+				ChunkCoordIntPair chunk = new ChunkCoordIntPair(chunkX, chunkZ);
+				ForgeChunkManager.forceChunk(ticket, chunk);
+				chunks.add(chunk);
+			}
+		}
+
+	}
+
 	public void setupChunks() {
 		if (!hasTicket)
 			chunks = null;
@@ -412,7 +499,6 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 
 	@Override
 	public void onMachineBlockUpdate() {
-		validate();
 		super.onMachineBlockUpdate();
 	}
 
@@ -424,7 +510,7 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 
 	@Override
 	public void doExplosion(long aExplosionPower) {
-		this.releaseTicket();
+		releaseTicket();
 		super.doExplosion(aExplosionPower);
 	}
 
@@ -438,13 +524,12 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 		return new String[] {
 				this.getLocalName(),
 				"Ticks Left: "+this.mTicksLeft,
-				"mRange: "+this.mRange,
+				"mRange: "+(16 + (48 * mTier)),
 				"chunks: "+this.chunks.size()};
 	}
 
 	@Override
 	public void onCreated(ItemStack aStack, World aWorld, EntityPlayer aPlayer) {
-		validate();
 		super.onCreated(aStack, aWorld, aPlayer);
 	}
 
@@ -466,4 +551,21 @@ public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredM
 		super.onWorldSave(aSaveDirectory);
 	}
 
+	//Based on BC 7
+
+
+	private boolean hasCheckedChunks = false;
+	public boolean areChunksLoaded() {
+		if (hasCheckedChunks) {
+			return true;
+		}
+		World worldObj = this.getBaseMetaTileEntity().getWorld();
+		hasCheckedChunks = worldObj.blockExists(xMin, yMax, zMin)
+				&& worldObj.blockExists(xMax, yMax, zMin)
+				&& worldObj.blockExists(xMin, yMax, zMax)
+				&& worldObj.blockExists(xMax, yMax, zMax);
+		// Each chunk covers the full height, so we only check one of them per height.
+		return hasCheckedChunks;
+	}
+
 }