+ 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.

4 files changed, 314 insertions, 25 deletions

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);
 	}