LiteLoader 1.6.4_02 - experimental - add Exposable interface and support for mod config via Gson

Mumfrey
1 parent 813a72f5
Showing 10 changed files with 625 additions and 84 deletions
java/com/mumfrey/liteloader/ExposeConfig.java
java/com/mumfrey/liteloader/LiteMod.java
java/com/mumfrey/liteloader/core/LiteLoader.java
java/com/mumfrey/liteloader/gui/GuiScreenModInfo.java
java/com/mumfrey/liteloader/modconfig/ConfigManager.java
java/com/mumfrey/liteloader/modconfig/ConfigPanelManager.java
java/com/mumfrey/liteloader/modconfig/ConfigStrategy.java
java/com/mumfrey/liteloader/modconfig/Exposable.java
java/com/mumfrey/liteloader/modconfig/ExposableConfigWriter.java
java/com/mumfrey/liteloader/util/PrivateFields.java
+package com.mumfrey.liteloader;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.mumfrey.liteloader.modconfig.ConfigStrategy;
+
+/**
+ * Annotation which can be a applied to mod classes to indicate they should be serialised with Gson
+ *
+ * @author Adam Mummery-Smith
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ExposeConfig
+{
+	/**
+	 * Configuration strategy to use
+	 */
+	ConfigStrategy strategy() default ConfigStrategy.Unversioned;
+	
+	/**
+	 * Config file name, if not specified the mod class name is used
+	 */
+	String filename() default "";
+}
@@ -2,12 +2,14 @@ package com.mumfrey.liteloader;
 import java.io.File;
+import com.mumfrey.liteloader.modconfig.Exposable;
+
 /**
  * Base interface for mods
  *
  * @author Adam Mummery-Smith
  */
-public interface LiteMod
+public interface LiteMod extends Exposable
 {
 	/**
 	 * Get the mod's display name
@@ -40,7 +40,8 @@ import com.mumfrey.liteloader.crashreport.CallableLiteLoaderBrand;
 import com.mumfrey.liteloader.crashreport.CallableLiteLoaderMods;
 import com.mumfrey.liteloader.gui.GuiControlsPaginated;
 import com.mumfrey.liteloader.gui.GuiScreenModInfo;
-import com.mumfrey.liteloader.modconfig.ConfigPanelManager;
+import com.mumfrey.liteloader.modconfig.ConfigManager;
+import com.mumfrey.liteloader.modconfig.Exposable;
 import com.mumfrey.liteloader.permissions.PermissionsManagerClient;
 import com.mumfrey.liteloader.util.PrivateFields;
@@ -170,9 +171,9 @@ public final class LiteLoader
 	private final PermissionsManagerClient permissionsManager = PermissionsManagerClient.getInstance();
 	/**
-	 * Configuration panel manager/registry
+	 * Mod configuration manager
 	 */
-	private final ConfigPanelManager configPanelManager;
+	private final ConfigManager configManager;
 	/**
 	 * Flag which keeps track of whether late initialisation has been done
@@ -279,7 +280,7 @@ public final class LiteLoader
 		this.enabledModsList = EnabledModsList.createFrom(this.enabledModsFile);
 		this.enabledModsList.processModsList(bootstrap.getProfile(), modNameFilter);
-		this.configPanelManager = new ConfigPanelManager();
+		this.configManager = new ConfigManager();
 	}
 	/**
@@ -787,6 +788,37 @@ public final class LiteLoader
 	}
 	/**
+	 * @param modClass
+	 */
+	public void writeConfig(LiteMod mod)
+	{
+		if (mod != null)
+		{
+			this.writeConfig(mod.getClass());
+		}
+	}
+	
+	/**
+	 * @param exposableClass
+	 */
+	public void writeConfig(Class<? extends Exposable> exposableClass)
+	{
+		this.configManager.invalidateConfig(exposableClass);
+	}
+	
+	/**
+	 * Register an arbitrary Exposable
+	 * 
+	 * @param exposable Exposable object to register
+	 * @param fileName
+	 */
+	public void registerExposable(Exposable exposable, String fileName)
+	{
+		this.configManager.registerExposable(exposable, fileName, true);
+		this.configManager.initConfig(exposable);
+	}
+
+	/**
 	 * Create mod instances from the enumerated classes
 	 * 
 	 * @param modsToLoad List of mods to load
@@ -898,6 +930,9 @@ public final class LiteLoader
 	{
 		LiteLoader.logInfo("Initialising mod %s version %s", mod.getName(), mod.getVersion());
+		// register mod config panel if configurable
+		this.configManager.registerMod(mod);
+		
 		try
 		{
 			this.handleModVersionUpgrade(mod);
@@ -907,6 +942,9 @@ public final class LiteLoader
 			LiteLoader.logWarning("Error performing settings upgrade for %s. Settings may not be properly migrated", mod.getName());
 		}
+		// Init mod config if there is any
+		this.configManager.initConfig(mod);
+		
 		// initialise the mod
 		mod.init(this.commonConfigFolder); 
@@ -916,9 +954,6 @@ public final class LiteLoader
 		// add mod to permissions manager if permissible
 		this.permissionsManager.registerMod(mod);
-		// register mod config panel if configurable
-		this.configPanelManager.registerMod(mod);
-		
 		this.loadedMods.add(mod);
 		this.loadedModsList += String.format("\n          - %s version %s", mod.getName(), mod.getVersion());
 	}
@@ -934,6 +969,11 @@ public final class LiteLoader
 		if (LiteLoaderBootstrap.VERSION.getLoaderRevision() > lastModVersion.getLoaderRevision())
 		{
 			LiteLoader.logInfo("Performing config upgrade for mod %s. Upgrading %s to %s...", mod.getName(), lastModVersion, LiteLoaderBootstrap.VERSION);
+			
+			// Migrate versioned config if any is present
+			this.configManager.migrateModConfig(mod, this.versionConfigFolder, this.inflectVersionedConfigPath(lastModVersion));
+			
+			// Let the mod upgrade
 			mod.upgradeSettings(LiteLoaderBootstrap.VERSION.getMinecraftVersion(), this.versionConfigFolder, this.inflectVersionedConfigPath(lastModVersion));
 			this.bootstrap.storeLastKnownModRevision(modKey);
@@ -1038,7 +1078,7 @@ public final class LiteLoader
 			// If we're at the main menu, prepare the overlay
 			if (this.modInfoScreen == null || this.modInfoScreen.getMenu() != this.minecraft.currentScreen)
 			{
-				this.modInfoScreen = new GuiScreenModInfo(this.minecraft, (GuiMainMenu)this.minecraft.currentScreen, this, this.enabledModsList, this.configPanelManager);
+				this.modInfoScreen = new GuiScreenModInfo(this.minecraft, (GuiMainMenu)this.minecraft.currentScreen, this, this.enabledModsList, this.configManager);
 			}
 			this.modInfoScreen.drawScreen(mouseX, mouseY, partialTicks);
@@ -1051,7 +1091,7 @@ public final class LiteLoader
 		}
 		else if (this.minecraft.currentScreen instanceof GuiMainMenu && Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) && Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) && Keyboard.isKeyDown(Keyboard.KEY_TAB))
 		{
-			this.minecraft.displayGuiScreen(new GuiScreenModInfo(this.minecraft, (GuiMainMenu)this.minecraft.currentScreen, this, this.enabledModsList, this.configPanelManager));
+			this.minecraft.displayGuiScreen(new GuiScreenModInfo(this.minecraft, (GuiMainMenu)this.minecraft.currentScreen, this, this.enabledModsList, this.configManager));
 		}			
 	}
@@ -1064,14 +1104,30 @@ public final class LiteLoader
 		// Tick the permissions manager
 		this.permissionsManager.onTick(this.minecraft, partialTicks, inGame);
+		// Tick the config manager
+		this.configManager.onTick();
+		
 		this.checkAndStoreKeyBindings();
 		if (this.modInfoScreen != null && this.minecraft.currentScreen != this.modInfoScreen)
 		{
 			this.modInfoScreen.updateScreen();
 		}
+		
+		if (!PrivateFields.gameIsRunning.get(this.minecraft))
+		{
+			this.onShutDown();
+		}
 	}
-	
+
+	private void onShutDown()
+	{
+		LiteLoader.logInfo("LiteLoader is shutting down, syncing configuration");
+		
+		this.storeBindings();
+		this.configManager.syncConfig();
+	}
+
 	/**
 	 * Register a key for a mod
 	 * 
@@ -20,7 +20,7 @@ import com.mumfrey.liteloader.core.EnabledModsList;
 import com.mumfrey.liteloader.core.LiteLoader;
 import com.mumfrey.liteloader.core.ModFile;
 import com.mumfrey.liteloader.modconfig.ConfigPanel;
-import com.mumfrey.liteloader.modconfig.ConfigPanelManager;
+import com.mumfrey.liteloader.modconfig.ConfigManager;
 import net.minecraft.src.DynamicTexture;
 import net.minecraft.src.GuiButton;
@@ -136,7 +136,7 @@ public class GuiScreenModInfo extends GuiScreen
 	 */
 	private GuiCheckbox chkEnabled;
-	private ConfigPanelManager configPanelManager;
+	private ConfigManager configManager;
 	/**
 	 * Configuration panel
@@ -149,11 +149,11 @@ public class GuiScreenModInfo extends GuiScreen
 	 * @param loader
 	 * @param enabledModsList
 	 */
-	public GuiScreenModInfo(Minecraft minecraft, GuiMainMenu mainMenu, LiteLoader loader, EnabledModsList enabledModsList, ConfigPanelManager configPanelManager)
+	public GuiScreenModInfo(Minecraft minecraft, GuiMainMenu mainMenu, LiteLoader loader, EnabledModsList enabledModsList, ConfigManager configManager)
 	{
 		this.mc = minecraft;
 		this.mainMenu = mainMenu;
-		this.configPanelManager = configPanelManager;
+		this.configManager = configManager;
 		// Spawn the texture resource if we haven't already
 		if (aboutTexture == null)
@@ -484,7 +484,7 @@ public class GuiScreenModInfo extends GuiScreen
 			this.btnToggle.drawButton = true;
 			this.btnToggle.displayString = this.selectedMod.willBeEnabled() ? "Disable mod" : "Enable mod";
-			this.btnConfig.drawButton = this.configPanelManager.hasPanel(this.selectedMod.getModClass());
+			this.btnConfig.drawButton = this.configManager.hasPanel(this.selectedMod.getModClass());
 		}
 	}
@@ -679,7 +679,7 @@ public class GuiScreenModInfo extends GuiScreen
 	{
 		if (this.selectedMod != null && this.selectedMod.getModClass() != null)
 		{
-			ConfigPanel panel = this.configPanelManager.getPanel(this.selectedMod.getModClass());
+			ConfigPanel panel = this.configManager.getPanel(this.selectedMod.getModClass());
 			if (panel != null)
 			{
 				if (this.configPanel != null)
+package com.mumfrey.liteloader.modconfig;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Strings;
+import com.google.common.io.Files;
+import com.mumfrey.liteloader.Configurable;
+import com.mumfrey.liteloader.LiteMod;
+import com.mumfrey.liteloader.ExposeConfig;
+
+/**
+ * Registry where we keep the mod config panel classes
+ *
+ * @author Adam Mummery-Smith
+ */
+public class ConfigManager
+{
+	/**
+	 * Mod config panel classes
+	 */
+	private Map<Class<? extends LiteMod>, Class<? extends ConfigPanel>> configPanels = new HashMap<Class<? extends LiteMod>, Class<? extends ConfigPanel>>();
+	
+	/**
+	 * Mod config writers
+	 */
+	private Map<Class<? extends Exposable>, ExposableConfigWriter> configWriters = new HashMap<Class<? extends Exposable>, ExposableConfigWriter>();
+	
+	/**
+	 * List of config writers, for faster iteration in onTick
+	 */
+	private List<ExposableConfigWriter> configWriterList = new LinkedList<ExposableConfigWriter>();
+	
+	/**
+	 * Register a mod, adds the config panel class to the map if the mod implements Configurable
+	 */
+	public void registerMod(LiteMod mod)
+	{
+		if (mod instanceof Configurable)
+		{
+			Class<? extends ConfigPanel> panelClass = ((Configurable)mod).getConfigPanelClass();
+			if (panelClass != null) this.configPanels.put(mod.getClass(), panelClass);
+		}
+		
+		this.registerExposable(mod, null, false);
+	}
+
+	/**
+	 * @param exposable
+	 */
+	public void registerExposable(Exposable exposable, String fileName, boolean force)
+	{
+		ExposeConfig exposeConfig = exposable.getClass().<ExposeConfig>getAnnotation(ExposeConfig.class);
+		if (exposeConfig != null)
+		{
+			if (fileName == null) exposeConfig.filename();
+			this.initConfigWriter(exposable, fileName, exposeConfig.strategy());
+		}
+		else if (force)
+		{
+			this.initConfigWriter(exposable, fileName, ConfigStrategy.Versioned);
+		}
+	}
+
+	/**
+	 * Create a config writer instance for the specified mod
+	 * 
+	 * @param exposable
+	 * @param fileName
+	 * @param strategy
+	 */
+	private void initConfigWriter(Exposable exposable, String fileName, ConfigStrategy strategy)
+	{
+		if (this.configWriters.containsKey(exposable.getClass()))
+		{
+			throw new IllegalArgumentException("Cannot register multiple Exposable instances of the same class or the Exposable already registered");
+		}
+		
+		if (Strings.isNullOrEmpty(fileName))
+		{
+			fileName = exposable.getClass().getSimpleName().toLowerCase();
+			
+			if (fileName.startsWith("litemod"))
+				fileName = fileName.substring(7);
+		}
+		
+		ExposableConfigWriter configWriter = ExposableConfigWriter.create(exposable, strategy, fileName);
+		if (configWriter != null)
+		{
+			this.configWriters.put(exposable.getClass(), configWriter);
+			this.configWriterList.add(configWriter);
+		}
+	}
+
+	/**
+	 * Initialise the config writer for the specified mod
+	 * 
+	 * @param exposable
+	 */
+	public void initConfig(Exposable exposable)
+	{
+		Class<? extends Exposable> exposableClass = exposable.getClass();
+		if (exposableClass != null && this.configWriters.containsKey(exposableClass))
+		{
+			this.configWriters.get(exposableClass).init();
+		}
+	}
+	
+	/**
+	 * If the specified mod has a versioned config strategy, attempt to copy the config
+	 * 
+	 * @param mod
+	 * @param newConfigPath
+	 * @param oldConfigPath
+	 */
+	public void migrateModConfig(LiteMod mod, File newConfigPath, File oldConfigPath)
+	{
+		Class<? extends Exposable> exposableClass = mod.getClass();
+		if (exposableClass != null && this.configWriters.containsKey(exposableClass))
+		{
+			ExposableConfigWriter writer = this.configWriters.get(exposableClass);
+			if (writer.isVersioned())
+			{
+				File newConfigFile = writer.getConfigFile();
+				File legacyConfigFile = new File(oldConfigPath, newConfigFile.getName());
+				
+				if (legacyConfigFile.exists() && !newConfigFile.exists())
+				{
+					try
+					{
+						Files.copy(legacyConfigFile, newConfigFile);
+					}
+					catch (IOException ex)
+					{
+						ex.printStackTrace();
+					}
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Check whether a config panel is available for the specified class
+	 * 
+	 * @param modClass
+	 * @return
+	 */
+	public boolean hasPanel(Class<? extends LiteMod> modClass)
+	{
+		return modClass != null && this.configPanels.containsKey(modClass);
+	}
+	
+	/**
+	 * Instance a new config panel for the specified mod class if one is available
+	 * 
+	 * @param modClass
+	 * @return
+	 */
+	public ConfigPanel getPanel(Class<? extends LiteMod> modClass)
+	{
+		if (modClass != null && this.configPanels.containsKey(modClass))
+		{
+			try
+			{
+				return this.configPanels.get(modClass).newInstance();
+			}
+			catch (InstantiationException ex) {}
+			catch (IllegalAccessException ex) {}
+			
+			// If instantiation fails, remove the panel
+			this.configPanels.remove(modClass);
+		}
+		
+		return null;
+	}
+
+	/**
+	 * Invalidate the specified mod config, cause it to be written to disk or scheduled for writing
+	 * if it has been written recent
+	 * 
+	 * @param exposableClass
+	 */
+	public void invalidateConfig(Class<? extends Exposable> exposableClass)
+	{
+		if (exposableClass != null && this.configWriters.containsKey(exposableClass))
+		{
+			this.configWriters.get(exposableClass).invalidate();
+		}
+	}
+	
+	/**
+	 * Tick all of the configuration writers, handles latent writes for anti-hammer strategy
+	 */
+	public void onTick()
+	{
+		for (ExposableConfigWriter writer : this.configWriterList)
+		{
+			writer.onTick();
+		}
+	}
+	
+	/**
+	 * Force all mod configs to be flushed to disk
+	 */
+	public void syncConfig()
+	{
+		for (ExposableConfigWriter writer : this.configWriterList)
+		{
+			writer.sync();
+		}
+	}
+}
-package com.mumfrey.liteloader.modconfig;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import com.mumfrey.liteloader.Configurable;
-import com.mumfrey.liteloader.LiteMod;
-
-/**
- * Registry where we keep the mod config panel classes
- *
- * @author Adam Mummery-Smith
- */
-public class ConfigPanelManager
-{
-	/**
-	 * Mod config panel classes
-	 */
-	private Map<Class<? extends LiteMod>, Class<? extends ConfigPanel>> configPanels = new HashMap<Class<? extends LiteMod>, Class<? extends ConfigPanel>>();
-	
-	/**
-	 * Register a mod, adds the config panel class to the map if the mod implements Configurable
-	 */
-	public void registerMod(LiteMod mod)
-	{
-		if (mod instanceof Configurable)
-		{
-			Class<? extends ConfigPanel> panelClass = ((Configurable)mod).getConfigPanelClass();
-			if (panelClass != null) this.configPanels.put(mod.getClass(), panelClass);
-		}
-	}
-	
-	/**
-	 * Check whether a config panel is available for the specified class
-	 * 
-	 * @param modClass
-	 * @return
-	 */
-	public boolean hasPanel(Class<? extends LiteMod> modClass)
-	{
-		return modClass != null && this.configPanels.containsKey(modClass);
-	}
-	
-	/**
-	 * Instance a new config panel for the specified mod class if one is available
-	 * 
-	 * @param modClass
-	 * @return
-	 */
-	public ConfigPanel getPanel(Class<? extends LiteMod> modClass)
-	{
-		if (modClass != null && this.configPanels.containsKey(modClass))
-		{
-			try
-			{
-				return this.configPanels.get(modClass).newInstance();
-			}
-			catch (InstantiationException ex) {}
-			catch (IllegalAccessException ex) {}
-			
-			// If instantiation fails, remove the panel
-			this.configPanels.remove(modClass);
-		}
-		
-		return null;
-	}
-}
+package com.mumfrey.liteloader.modconfig;
+
+import java.io.File;
+
+import com.mumfrey.liteloader.core.LiteLoader;
+
+/**
+ * Configuration management strategy
+ * 
+ * @author Adam Mummery-Smith
+ */
+public enum ConfigStrategy
+{
+	/**
+	 * Use the unversioned "common" config folder
+	 */
+	Unversioned,
+	
+	/**
+	 * Use the versioned config folder 
+	 */
+	Versioned;
+	
+	public File getFileForStrategy(String fileName)
+	{
+		if (this == ConfigStrategy.Versioned)
+		{
+			return new File(LiteLoader.getConfigFolder(), fileName);
+		}
+		
+		return new File(LiteLoader.getCommonConfigFolder(), fileName);
+	}
+}
+package com.mumfrey.liteloader.modconfig;
+
+/**
+ * Base interface for objects which can support the ExposeConfig annotations
+ * 
+ * @author Adam Mummery-Smith
+ */
+public interface Exposable
+{
+}
+package com.mumfrey.liteloader.modconfig;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.InstanceCreator;
+
+/**
+ * Manages serialisation of exposable properties to a JSON config file via Gson 
+ *
+ * @author Adam Mummery-Smith
+ */
+public final class ExposableConfigWriter implements InstanceCreator<Exposable>
+{
+	/**
+	 * Minimum number of milliseconds that must elapse between writes
+	 */
+	private static final long ANTI_HAMMER_DELAY = 1000L;
+	
+	/**
+	 * Exposable instance which we will serialise exposed properties 
+	 */
+	private final Exposable exposable;
+	
+	/**
+	 * JSON file to write to
+	 */
+	private final File configFile;
+	
+	/**
+	 * True if this is a versioned config strategy
+	 */
+	private final boolean versioned;
+	
+	/**
+	 * Gson instance
+	 */
+	private final Gson gson;
+	
+	/**
+	 * True if a config write has been requested but anti-hammer has prevented the write from occurring
+	 */
+	private volatile boolean dirty = false;
+	
+	/**
+	 * Last time the config was written, used for anti-hammer
+	 */
+	private volatile long lastWrite = 0L;
+	
+	/**
+	 * It's possible that writes may be requested from different threads, lock object to prevent cross-thread derp
+	 */
+	private Object readWriteLock = new Object();
+
+	/**
+	 * @param exposable
+	 * @param configFile
+	 */
+	private ExposableConfigWriter(Exposable exposable, File configFile, boolean versioned)
+	{
+		this.exposable = exposable;
+		this.configFile = configFile;
+		this.versioned = versioned;
+		
+		GsonBuilder gsonBuilder = new GsonBuilder();
+		gsonBuilder.setPrettyPrinting();
+		gsonBuilder.serializeNulls();
+		gsonBuilder.excludeFieldsWithoutExposeAnnotation();
+		gsonBuilder.registerTypeAdapter(exposable.getClass(), this);
+		
+		this.gson = gsonBuilder.create();
+	}
+	
+	/**
+	 * Get the config file underlying this writer
+	 */
+	File getConfigFile()
+	{
+		return this.configFile;
+	}
+
+	/**
+	 * Returns true if this writer is using a versioned strategy
+	 */
+	boolean isVersioned()
+	{
+		return this.versioned;
+	}
+	
+	/**
+	 * Returns true if this writer has been invalidated but not yet been flushed to disk
+	 */
+	boolean isDirty()
+	{
+		return this.dirty;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.google.gson.InstanceCreator#createInstance(java.lang.reflect.Type)
+	 */
+	@Override
+	public Exposable createInstance(Type type)
+	{
+		return this.exposable;
+	}
+	
+	/**
+	 * Initialise the config, reads from file and writes the initial config file if not present
+	 */
+	void init()
+	{
+		// Read the config
+		this.read();
+		
+		// If the config doesn't exist yet, seed the config
+		if (!this.configFile.exists())
+		{
+			this.write();
+		}
+	}
+	
+	/**
+	 * Read the config from the file
+	 */
+	void read()
+	{
+		synchronized (this.readWriteLock)
+		{
+			if (this.configFile.exists())
+			{
+				FileReader reader = null;
+				
+				try
+				{
+					reader = new FileReader(this.configFile);
+					
+					// Normally GSON would produce a new object by calling the default constructor, but we
+					// trick it into deserialising properties on the existing object instance by implementing
+					// an InstanceCreator which just returns the object instance which we already have
+					this.gson.fromJson(reader, this.exposable.getClass());
+				}
+				catch (Exception ex)
+				{
+					ex.printStackTrace();
+				}
+				finally
+				{
+					try
+					{
+						if (reader != null)
+							reader.close();
+					}
+					catch (IOException ex)
+					{
+						ex.printStackTrace();
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Write the config to the file
+	 */
+	void write()
+	{
+		synchronized (this.readWriteLock)
+		{
+			FileWriter writer = null;
+			try
+			{
+				writer = new FileWriter(this.configFile);
+				this.gson.toJson(this.exposable, writer);
+				
+				this.dirty = false;
+				this.lastWrite = System.currentTimeMillis();
+			}
+			catch (Exception ex)
+			{
+				ex.printStackTrace();
+			}
+			finally
+			{
+				try
+				{
+					if (writer != null)
+						writer.close();
+				}
+				catch (IOException ex)
+				{
+					ex.printStackTrace();
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Write the config to file, respecting anti-hammer and queuing the write if not
+	 * enough time has elapsed
+	 */
+	void invalidate()
+	{
+		long sinceLastWrite = System.currentTimeMillis() - this.lastWrite;
+		if (sinceLastWrite < ANTI_HAMMER_DELAY)
+		{
+			this.dirty = true;
+			return;
+		}
+		
+		this.write();
+	}
+	
+	/**
+	 * Handle latent writes if the config was previously invalidated
+	 */
+	void onTick()
+	{
+		if (this.dirty)
+		{
+			long sinceLastWrite = System.currentTimeMillis() - this.lastWrite;
+			if (sinceLastWrite >= ANTI_HAMMER_DELAY)
+			{
+				this.write();
+			}
+		}		
+	}
+	
+	/**
+	 * Force a write if dirty
+	 */
+	void sync()
+	{
+		if (this.dirty)
+		{
+			this.write();
+		}
+	}
+	
+	/**
+	 * Factory method which creates and intialises a new ExposableConfigWriter for the specified exposable object and strategy
+	 * 
+	 * @param exposable
+	 * @param strategy
+	 * @param fileName
+	 * @return
+	 */
+	static ExposableConfigWriter create(Exposable exposable, ConfigStrategy strategy, String fileName)
+	{
+		if (!fileName.toLowerCase().endsWith(".json"))
+			fileName = fileName + ".json";
+		
+		File configFile = strategy.getFileForStrategy(fileName);
+		ExposableConfigWriter writer = new ExposableConfigWriter(exposable, configFile, strategy == ConfigStrategy.Versioned);
+
+		return writer;
+	}
+}
 \ No newline at end of file
@@ -144,6 +144,7 @@ public class PrivateFields&lt;P, T&gt;
 	public static final PrivateFields<Minecraft, Timer>                       minecraftTimer = new PrivateFields<Minecraft, Timer>                (Minecraft.class,          "timer",                "S",  "field_71428_T");   // Minecraft/timer
 	public static final PrivateFields<Minecraft, Profiler>                 minecraftProfiler = new PrivateFields<Minecraft, Profiler>             (Minecraft.class,          "mcProfiler",           "C",  "field_71424_I");   // Minecraft/mcProfiler
 	public static final PrivateFields<Minecraft, List<ResourcePack>>    defaultResourcePacks = new PrivateFields<Minecraft, List<ResourcePack>>   (Minecraft.class,          "defaultResourcePacks", "aq", "field_110449_ao"); // Minecraft/defaultResourcePacks
+	public static final PrivateFields<Minecraft, Boolean>                      gameIsRunning = new PrivateFields<Minecraft, Boolean>              (Minecraft.class,          "running",              "D",  "field_71425_J");   // Minecraft/running
 	public static final PrivateFields<RenderManager, Map>                    entityRenderMap = new PrivateFields<RenderManager, Map>              (RenderManager.class,      "entityRenderMap",      "q",  "field_78729_o");   // RenderManager/entityRenderMap
 	public static final PrivateFields<GuiControls, GuiScreen>        guiControlsParentScreen = new PrivateFields<GuiControls, GuiScreen>          (GuiControls.class,        "parentScreen",         "b",  "field_73909_b");   // GuiControls/parentScreen
 	public static final PrivateFields<PlayerUsageSnooper, IPlayerUsage> playerStatsCollector = new PrivateFields<PlayerUsageSnooper, IPlayerUsage>(PlayerUsageSnooper.class, "playerStatsCollector", "d",  "field_76478_d");   // PlayerUsageSnooper/playerStatsCollector