update

src/main/java/reobf/proghatches/block/ChunkTrackingGridCahce.java

@@ -45,12 +45,14 @@ public class ChunkTrackingGridCahce implements IChunkTrackingGridCahce{
 	public ChunkTrackingGridCahce(final IGrid g) {
 	        this.myGrid = g;
 	       // callbacks.put(this, null);
-	        cacheinst.add(new WeakReference<ChunkTrackingGridCahce>(this));
+
+	        if(!g.getPivot().getWorld().isRemote)
+	        cacheinst.add((this));
 	    }  
-	private final IGrid myGrid;
+	public final IGrid myGrid;
 
 	//public static WeakHashMap<ChunkTrackingGridCahce,Object> callbacks=new WeakHashMap<>();
-	public static ArrayList<WeakReference<ChunkTrackingGridCahce>> cacheinst=new ArrayList<>();
+	public static ArrayList<ChunkTrackingGridCahce> cacheinst=new ArrayList<>();
 
 
 	 public static class ChunkInfo implements Cloneable,Serializable{

src/main/java/reobf/proghatches/gt/metatileentity/multi/LargeProgrammingCircuitProvider.java

@@ -831,10 +831,10 @@ public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
 					postEvent();
 			}
 		} else {
-
+			if(patternCache.size()>0)postEvent();
 			patternCache.clear();
 			cacheState = CacheState.POWEROFF;
-			postEvent();
+
 
 		}
 

src/main/java/reobf/proghatches/main/CommandAnchor2.java

@@ -0,0 +1,53 @@
+package reobf.proghatches.main;
+
+import java.util.List;
+
+import com.google.common.collect.ImmutableList;
+
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.ChatComponentTranslation;
+import reobf.proghatches.block.ChunkTrackingGridCahce;
+import reobf.proghatches.main.MyMod.Prop;
+
+public class CommandAnchor2 extends CommandBase{
+
+	@Override
+	public String getCommandName() {
+
+		return "proghatch";
+	}
+
+	@Override
+	public List getCommandAliases() {
+
+		return ImmutableList.of();
+	}
+	@Override
+	public String getCommandUsage(ICommandSender sender) {
+
+		return "";
+	}
+@Override
+public int getRequiredPermissionLevel() {
+
+	return 0;
+}
+	@Override
+	public void processCommand(ICommandSender sender, String[] args) {
+		try{if(args[0].equals("tracking")){
+		MyMod.disable=!MyMod.disable;	
+		sender .addChatMessage(new ChatComponentText("tracking:"+!MyMod.disable));
+		sender .addChatMessage(new ChatComponentText("max caches:"+MyMod.max));
+		sender .addChatMessage(new ChatComponentText("current caches:"+ChunkTrackingGridCahce.cacheinst.size()));
+		}
+		}catch(Exception e){
+			sender .addChatMessage(new ChatComponentText("/proghatch tracking"));
+
+		}
+
+	}
+
+}

src/main/java/reobf/proghatches/main/MyMod.java

@@ -466,6 +466,7 @@ public void serverStarting(FMLServerStartingEvent event) {
 		// Just in case weak references are not GCed in time
 		// only useful for intergreted server?
 		event.registerServerCommand(new CommandAnchor());
+		event.registerServerCommand(new CommandAnchor2());
 	}
 
 	public static ItemStack tutorial() {
@@ -546,63 +547,95 @@ public void breakBlock(BlockEvent.BreakEvent b) {
 	}
 
 	@SubscribeEvent
-	public void onUnload(WorldEvent.Unload event) {
+	public void  onUnload(WorldEvent.Unload event) {
+		if(disable)return;
 		if (event.world.isRemote)
 			return;
 		// World unloading seems to not post ChunkEvent.Unload?
 		// Well, warning twice is better than not warning, right?
-		try {
+		try {//System.out.println(ChunkTrackingGridCahce.cacheinst.size());
+			max=Math.max(max, ChunkTrackingGridCahce.cacheinst.size());
 			ChunkTrackingGridCahce.cacheinst.removeIf((aa) -> {
-				ChunkTrackingGridCahce a = aa.get();
-				if(a==null)return true;
+				ChunkTrackingGridCahce a = aa;
+				if(a.myGrid.getPivot()==null){
+					//System.out.println(a.myGrid);
+
+				a=null;}
+				if(a==null){
+					return true;
+					}
 				if (a != null) {
 					a.unload(event.world);
 				}
 
 				return false;
-			});
+			});//System.out.println(ChunkTrackingGridCahce.cacheinst.size());
 		} catch (Throwable t) {
-			t.printStackTrace();
+			throw new AssertionError(t);
 		}
 
 	}
+	static int max=0;
+	static boolean disable=false;
 	@SubscribeEvent
 	public void onLoad(ChunkEvent.Load event) {
+		if(disable)return;
 		if (event.world.isRemote)
 			return;
 
 		try {
+			//System.out.println(ChunkTrackingGridCahce.cacheinst.size());
+			max=Math.max(max, ChunkTrackingGridCahce.cacheinst.size());
 			ChunkTrackingGridCahce.cacheinst.removeIf((aa) -> {
-				ChunkTrackingGridCahce a = aa.get();
-				if(a==null)return true;
+				ChunkTrackingGridCahce a = aa;
+				if(a.myGrid.getPivot()==null){
+				//	System.out.println(a.myGrid);
+				a=null;
+
+				}
+				if(a==null){
+					return true;
+					}
 				if (a != null) {
 					a.load(event.getChunk());
 				}
 
 				return false;
 			});
+			//System.out.println(ChunkTrackingGridCahce.cacheinst.size());
+
 		} catch (Throwable t) {
-			t.printStackTrace();
+			throw new AssertionError(t);
+
 		}
 	}
 	@SubscribeEvent
 	public void onUnload(ChunkEvent.Unload event) {
+		if(disable)return;
 		if (event.world.isRemote)
 			return;
 		// on client side, out-of-sight causes chunk unload! That's not what we
 		// want, so ignore it.
 		try {
+			max=Math.max(max, ChunkTrackingGridCahce.cacheinst.size());
+		//	System.out.println(ChunkTrackingGridCahce.cacheinst.size());
 			ChunkTrackingGridCahce.cacheinst.removeIf((aa) -> {
-				ChunkTrackingGridCahce a = aa.get();
-				if(a==null)return true;
+				ChunkTrackingGridCahce a = aa;
+				if(a.myGrid.getPivot()==null){
+					//System.out.println(a.myGrid);
+				a=null;
+				}
+				if(a==null){
+					return true;
+					}
 				if (a != null) {
 					a.load(event.getChunk());
 				}
 
 				return false;
-			});
+			});//System.out.println(ChunkTrackingGridCahce.cacheinst.size());
 		} catch (Throwable t) {
-			t.printStackTrace();
+			throw new AssertionError(t);
 		}
 	}