Liteloader 1.3.2_02

+ Optifine compatibility + Improved chat hook + Added late init interface + Added ModUtilities class with useful functions in it + Added PrivateFields reflection class from Macros + Improved error message verbosity + Fixed issue with writing server log file to launcher folder

Liteloader 1.3.2_02
+ Optifine compatibility + Improved chat hook + Added late init interface + Added ModUtilities class with useful functions in it + Added PrivateFields reflection class from Macros + Improved error message verbosity + Fixed issue with writing server log file to launcher folder
Mumfrey
1 parent decde838
Showing 7 changed files with 678 additions and 101 deletions
java/com/mumfrey/liteloader/InitCompleteListener.java
java/com/mumfrey/liteloader/LiteMod.java
java/com/mumfrey/liteloader/core/HookChat.java
java/com/mumfrey/liteloader/core/LiteLoader.java
java/com/mumfrey/liteloader/core/LiteLoaderHook.java
java/com/mumfrey/liteloader/util/ModUtilities.java
java/com/mumfrey/liteloader/util/PrivateFields.java
+package com.mumfrey.liteloader;
+
+import net.minecraft.client.Minecraft;
+
+import com.mumfrey.liteloader.core.LiteLoader;
+
+public interface InitCompleteListener extends Tickable
+{
+	public abstract void onInitCompleted(Minecraft minecraft, LiteLoader loader);
+}
 package com.mumfrey.liteloader;
  
+/**
+ * Base interface for mods
+ *
+ * @author Adam Mummery-Smith
+ */
 public interface LiteMod
 {
+	/**
+	 * Get the mod's display name
+	 * 
+	 * @return display name
+	 */
 	public abstract String getName();
  
+	/**
+	 * Get the mod version string
+	 * 
+	 * @return
+	 */
 	public abstract String getVersion();
  
+	/**
+	 * Do startup stuff here, minecraft is not fully initialised when this function is called so mods *must not*
+	 * interact with minecraft in any way here
+	 */
 	public abstract void init();
 }
 package com.mumfrey.liteloader.core;
  
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Map;
+
+import net.minecraft.src.IntHashMap;
 import net.minecraft.src.NetHandler;
+import net.minecraft.src.Packet;
 import net.minecraft.src.Packet3Chat;
  
+import com.mumfrey.liteloader.util.PrivateFields;
+
+/**
+ * Proxy packet which we will register in place of the original chat packet. The class will proxy the function calls
+ * through to the replaced class via reflection if the original (replaced) class is NOT the basic Packet3Chat (this
+ * is to maintain compatibility with things like WorldEditCUI. 
+ * 
+ * @author Adam Mummery-Smith
+ *
+ */
 public class HookChat extends Packet3Chat
 {
-	public static LiteLoader loader;
+	/**
+	 * True if this class was registered with the base class
+	 */
+	private static boolean registered = false;
  
+	/**
+	 * Handler module which is registered to handle inbound chat packets
+	 */
+	private static LiteLoader packetHandler; 
+	
+	/**
+	 * Class which was overridden and will be instanced for new packets
+	 */
+	private static Class<? extends Packet> proxyClass;
+	
+	/**
+	 * Instance of the proxy packet for this packet instance
+	 */
+	private Packet proxyPacket;
+	
+	/**
+	 * Create a new chat packet proxy
+	 */
 	public HookChat()
 	{
 		super();
+		
+		try
+		{
+			if (proxyClass != null)
+			{
+				proxyPacket = (Packet)proxyClass.newInstance();
+			}
+		}
+		catch (Exception ex) {}
 	}
  
-	public HookChat(String par1Str)
+	/**
+	 * Create a new chat proxy with the specified message
+	 * @param message
+	 */
+	public HookChat(String message)
 	{
-		super(par1Str);
+		super(message);
+
+		try
+		{
+			if (proxyClass != null)
+			{
+				proxyPacket = (Packet)proxyClass.newInstance();
+			}
+		}
+		catch (Exception ex) {}
 	}
-	
-	public HookChat(String par1Str, boolean par2)
+
+	@Override
+	public void readPacketData(DataInputStream datainputstream) throws IOException
+	{
+		if (proxyPacket != null)
+		{
+			proxyPacket.readPacketData(datainputstream);
+			this.message = ((Packet3Chat)proxyPacket).message;
+		}
+		else
+			super.readPacketData(datainputstream);
+	}
+
+	@Override
+	public void writePacketData(DataOutputStream dataoutputstream) throws IOException
 	{
-		super(par1Str, par2);
+		if (proxyPacket != null)
+			proxyPacket.writePacketData(dataoutputstream);
+		else
+			super.writePacketData(dataoutputstream);
 	}
  
-	/* (non-Javadoc)
-	 * @see net.minecraft.src.Packet3Chat#processPacket(net.minecraft.src.NetHandler)
-	 */
 	@Override
-	public void processPacket(NetHandler par1NetHandler)
+	public void processPacket(NetHandler nethandler)
 	{
-		if (loader == null || loader.onChat(this))
+		if (packetHandler == null || packetHandler.onChat(this))
 		{
-			super.processPacket(par1NetHandler);
+			if (proxyPacket != null)
+				proxyPacket.processPacket(nethandler);
+			else
+				super.processPacket(nethandler);
+		}
+	}
+
+	@Override
+	public int getPacketSize()
+	{
+		if (proxyPacket != null)
+			return proxyPacket.getPacketSize();
+		else
+			return super.getPacketSize();
+	}
+	
+	/**
+	 * Register the specified handler as the packet handler for this packet
+	 * @param handler
+	 */
+	public static void RegisterPacketHandler(LiteLoader handler)
+	{
+		packetHandler = handler;
+	}
+	
+	/**
+	 * Register this packet as the new packet for packet ID 3
+	 */
+    public static void Register()
+    {
+    	Register(false);
+    }
+
+    /**
+     * Register this packet as the new packet for packet ID 3 and optionally force re-registration even
+     * if registration was performed already.
+     * 
+     * @param force Force registration even if registration was already performed previously.
+     */
+    public static void Register(boolean force)
+	{
+    	System.out.println("LITELOADER REGISTER");
+		if (!registered || force)
+		{
+			try
+			{
+			    IntHashMap packetIdToClassMap = Packet.packetIdToClassMap;
+			    proxyClass = (Class)packetIdToClassMap.lookup(3);
+			    
+			    if (proxyClass.equals(Packet3Chat.class))
+			    {
+			    	proxyClass = null;
+			    }
+			    
+			    packetIdToClassMap.removeObject(3);
+			    packetIdToClassMap.addKey(3, HookChat.class);
+
+			    Map packetClassToIdMap = PrivateFields.StaticFields.packetClassToIdMap.Get();
+			    packetClassToIdMap.put(HookChat.class, Integer.valueOf(3));
+			    
+			    registered = true;
+			}
+			catch (Exception ex)
+			{
+				ex.printStackTrace();
+			}
 		}
 	}
 }
@@ -8,15 +8,16 @@ import java.io.FilenameFilter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.lang.reflect.Field;
+import java.io.PrintWriter;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
-import java.util.Map;
+import java.util.List;
 import java.util.logging.ConsoleHandler;
 import java.util.logging.FileHandler;
 import java.util.logging.Formatter;
@@ -28,33 +29,39 @@ import java.util.zip.ZipInputStream;
  
 import net.minecraft.client.Minecraft;
 import net.minecraft.src.ConsoleLogManager;
-import net.minecraft.src.IntHashMap;
 import net.minecraft.src.NetHandler;
-import net.minecraft.src.Packet;
 import net.minecraft.src.Packet1Login;
 import net.minecraft.src.Packet3Chat;
 import net.minecraft.src.Timer;
  
 import com.mumfrey.liteloader.ChatFilter;
 import com.mumfrey.liteloader.ChatListener;
+import com.mumfrey.liteloader.InitCompleteListener;
 import com.mumfrey.liteloader.LiteMod;
 import com.mumfrey.liteloader.LoginListener;
 import com.mumfrey.liteloader.Tickable;
+import com.mumfrey.liteloader.util.ModUtilities;
+import com.mumfrey.liteloader.util.PrivateFields;
  
 /**
  * LiteLoader is a simple loader which provides tick events to loaded mods 
  *
  * @author Adam Mummery-Smith
- * @version 1.3.2_01
+ * @version 1.3.2_02
  */
 public final class LiteLoader implements FilenameFilter
 {
 	/**
-	 * Minecraft version that we will load mods for, this will be compared
+	 * Liteloader version 
+	 */
+	private static final String LOADER_VERSION = "1.3.2_02";
+	
+	/**
+	 * Minecraft versions that we will load mods for, this will be compared
 	 * against the version.txt value in mod files to prevent outdated mods being
 	 * loaded!!!
 	 */
-	private static final String MINECRAFT_VERSION = "1.3.1";
+	private static final String[] SUPPORTED_VERSIONS = { "1.3.1", "1.3.2" };
  
 	/**
 	 * LiteLoader is a singleton, this is the singleton instance
@@ -64,7 +71,7 @@ public final class LiteLoader implements FilenameFilter
 	/**
 	 * Logger for LiteLoader events
 	 */
-	private static Logger logger = Logger.getLogger("liteloader");
+	public static Logger logger = Logger.getLogger("liteloader");
  
 	/**
 	 * "mods" folder which contains mods and config files
@@ -90,7 +97,12 @@ public final class LiteLoader implements FilenameFilter
 	 * List of mods which implement Tickable interface and will receive tick
 	 * events
 	 */
-	private LinkedList<Tickable> tickMods = new LinkedList<Tickable>();
+	private LinkedList<Tickable> tickListeners = new LinkedList<Tickable>();
+	
+	/**
+	 * 
+	 */
+	private LinkedList<InitCompleteListener> initListeners = new LinkedList<InitCompleteListener>();
  
 	/**
 	 * List of mods which implement ChatListener interface and will receive chat
@@ -114,6 +126,8 @@ public final class LiteLoader implements FilenameFilter
 	 */
 	private Method mAddUrl;
  
+	private boolean initDone = false;
+	
 	/**
 	 * Get the singleton instance of LiteLoader, initialises the loader if necessary
 	 * 
@@ -129,6 +143,11 @@ public final class LiteLoader implements FilenameFilter
 		return instance;
 	}
  
+	public static final Logger getLogger()
+	{
+		return logger;
+	}
+	
 	/**
 	 * LiteLoader constructor
 	 */
@@ -137,7 +156,7 @@ public final class LiteLoader implements FilenameFilter
 		// Set up loader, initialises any reflection methods needed
 		prepareLoader();
  
-		logger.info("Liteloader for " + MINECRAFT_VERSION + " starting up...");
+		logger.info("Liteloader " + LOADER_VERSION + " starting up...");
  
 		// Examines the class path and mods folder and locates loadable mods
 		prepareMods();
@@ -159,25 +178,37 @@ public final class LiteLoader implements FilenameFilter
 			// addURL method is used by the class loader to 
 			mAddUrl = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
 			mAddUrl.setAccessible(true);
-
-			ConsoleLogManager.func_73699_a();
-			Formatter minecraftLogFormatter = ConsoleLogManager.loggerLogManager.getHandlers()[0].getFormatter();
+			
+			Formatter minecraftLogFormatter = null;
+			
+			try
+			{
+				Class formatterClass = Minecraft.class.getClassLoader().loadClass(ModUtilities.getObfuscatedFieldName("net.minecraft.src.ConsoleLogFormatter", "em"));
+				Constructor defaultConstructor = formatterClass.getDeclaredConstructor();
+				defaultConstructor.setAccessible(true);
+				minecraftLogFormatter = (Formatter)defaultConstructor.newInstance();
+			}
+			catch (Exception ex)
+			{
+				ConsoleLogManager.func_73699_a();
+				minecraftLogFormatter = ConsoleLogManager.loggerLogManager.getHandlers()[0].getFormatter();
+			}
  
 			logger.setUseParentHandlers(false);
  
 			StreamHandler consoleHandler = new ConsoleHandler();
-			consoleHandler.setFormatter(minecraftLogFormatter);
+			if (minecraftLogFormatter != null) consoleHandler.setFormatter(minecraftLogFormatter);
 			logger.addHandler(consoleHandler);
  
 			FileHandler logFileHandler = new FileHandler(new File(Minecraft.getMinecraftDir(), "LiteLoader.txt").getAbsolutePath());
-			logFileHandler.setFormatter(minecraftLogFormatter);
+			if (minecraftLogFormatter != null) logFileHandler.setFormatter(minecraftLogFormatter);
 			logger.addHandler(logFileHandler);
  
 		}
 		catch (Exception ex)
 		{
-			// TODO Auto-generated catch block
-			ex.printStackTrace();
+			logger.severe(ex.toString());
+			logger.severe(ex.getStackTrace().toString());
 		}
  
 	}
@@ -249,6 +280,8 @@ public final class LiteLoader implements FilenameFilter
 	 */
 	protected void findModFiles(File modFolder, LinkedList<File> modFiles)
 	{
+		List<String> supportedVerions = Arrays.asList(SUPPORTED_VERSIONS);
+		
 		for (File modFile : modFolder.listFiles(this))
 		{
 			try
@@ -266,7 +299,7 @@ public final class LiteLoader implements FilenameFilter
 					versionReader.close();
  
 					// Only add the mod if the version matches and we were able to successfully add it to the class path
-					if (strVersion.equals(MINECRAFT_VERSION) && addURLToClassPath(modFile.toURI().toURL()))
+					if (supportedVerions.contains(strVersion) && addURLToClassPath(modFile.toURI().toURL()))
 					{
 						modFiles.add(modFile);
 					}
@@ -368,7 +401,8 @@ public final class LiteLoader implements FilenameFilter
 			}
 			catch (Throwable th)
 			{
-				logger.warning(th.getMessage());
+				logger.warning(th.toString());
+				th.printStackTrace();
 			}
 		}
 	}
@@ -384,11 +418,18 @@ public final class LiteLoader implements FilenameFilter
  
 			try
 			{
+				logger.info("Initialising mod " + mod.getName() + " version " + mod.getVersion());
+				
 				mod.init();
  
 				if (mod instanceof Tickable)
 				{
-					tickMods.add((Tickable)mod);
+					tickListeners.add((Tickable)mod);
+				}
+
+				if (mod instanceof InitCompleteListener)
+				{
+					initListeners.add((InitCompleteListener)mod);
 				}
  
 				if (mod instanceof ChatFilter)
@@ -408,7 +449,8 @@ public final class LiteLoader implements FilenameFilter
 			}
 			catch (Throwable th)
 			{
-				logger.warning("Error initialising mod '" + mod.getName() + "': " + th.getMessage());
+				logger.warning("Error initialising mod '" + mod.getName() + "': " + th.toString());
+				th.printStackTrace();
 				iter.remove();
 			}
 		}
@@ -424,32 +466,24 @@ public final class LiteLoader implements FilenameFilter
 			// Chat hook
 			if (chatListeners.size() > 0 || chatFilters.size() > 0)
 			{
-				registerPacketOverride(3, HookChat.class);
-				HookChat.loader = this;
+				HookChat.Register();
+				HookChat.RegisterPacketHandler(this);
 			}
  
 			// Login hook
 			if (loginListeners.size() > 0)
 			{
-				registerPacketOverride(1, HookLogin.class);
+				ModUtilities.registerPacketOverride(1, HookLogin.class);
 				HookLogin.loader = this;
 			}
  
 			// Tick hook
-			if (tickMods.size() > 0)
-			{
-				Field modifiers = Field.class.getDeclaredField("modifiers");
-				modifiers.setAccessible(true);
-				
-				Field profiler = Minecraft.class.getDeclaredField(getObfuscatedFieldName("mcProfiler", "I"));
-				modifiers.setInt(profiler, profiler.getModifiers() & ~Modifier.FINAL);
-				profiler.setAccessible(true);
-				profiler.set(minecraft, new LiteLoaderHook(this, logger));
-			}
+			PrivateFields.minecraftProfiler.SetFinal(minecraft, new LiteLoaderHook(this, logger));
 		}
 		catch (Exception ex)
 		{
-			logger.warning("Error creating hooks: " + ex.getMessage());
+			logger.warning("Error creating hooks: " + ex.toString());
+			ex.printStackTrace();
 		}
 	}
  
@@ -477,7 +511,8 @@ public final class LiteLoader implements FilenameFilter
 		}
 		catch (Throwable th)
 		{
-			logger.warning(th.getMessage());
+			logger.warning(th.toString());
+			th.printStackTrace();
 		}
  
 		return classes;
@@ -591,50 +626,12 @@ public final class LiteLoader implements FilenameFilter
 		}
 		catch (Throwable th)
 		{
-			logger.warning(th.getMessage());
-		}
-	}
-	
-	/**
-	 * Register a packet override
-	 * 
-	 * @param packetId
-	 * @param newPacket
-	 */
-	private static boolean registerPacketOverride(int packetId, Class newPacket)
-	{
-		try
-		{
-			IntHashMap packetIdToClassMap = Packet.packetIdToClassMap;
-			Field fPacketClassToIdMap = Packet.class.getDeclaredField(getObfuscatedFieldName("packetClassToIdMap", "a"));
-			fPacketClassToIdMap.setAccessible(true);
-			Map packetClassToIdMap = (Map)fPacketClassToIdMap.get(null);
-			
-			packetIdToClassMap.removeObject(packetId);
-			packetIdToClassMap.addKey(packetId, newPacket);
-			packetClassToIdMap.put(newPacket, Integer.valueOf(packetId));
-			
-			return true;
-		}
-		catch (Exception ex)
-		{
-			logger.warning("Error registering packet override for packet id " + packetId + ": " + ex.getMessage());
-			return false;
+			logger.warning(th.toString());
+			th.printStackTrace();
 		}
 	}
  
 	/**
-	 * Abstraction helper function
-	 * 
-	 * @param fieldName Name of field to get, returned unmodified if in debug mode
-	 * @return Obfuscated field name if present
-	 */
-	private static String getObfuscatedFieldName(String fieldName, String obfuscatedFieldName)
-	{
-		return (!net.minecraft.src.Tessellator.instance.getClass().getSimpleName().equals("Tessellator")) ? obfuscatedFieldName : fieldName;
-	}
-	
-	/**
 	 * Add a URL to the Minecraft classloader class path
 	 * 
 	 * @param classUrl URL of the resource to add
@@ -652,11 +649,36 @@ public final class LiteLoader implements FilenameFilter
 		}
 		catch (Throwable th)
 		{
-			logger.warning("Error adding class path entry: " + th.getMessage());
+			logger.warning("Error adding class path entry: " + th.toString());
+			th.printStackTrace();
 		}
  
 		return false;
 	}
+
+	/**
+	 * Late initialisation callback
+	 */
+	public void onInit()
+	{
+		if (!initDone)
+		{
+			initDone = true;
+			
+			for (InitCompleteListener initMod : initListeners)
+			{
+				try
+				{
+					logger.info("Calling late init for mod " + initMod.getName());
+					initMod.onInitCompleted(minecraft, this);
+				}
+				catch (Throwable th)
+				{
+					logger.warning("Error initialising mod " + initMod.getName() + ": " + th.getClass().getSimpleName() + " - " + th.getMessage());
+				}
+			}
+		}
+	}
  
 	/**
 	 * Callback from the tick hook, ticks all tickable mods
@@ -670,14 +692,7 @@ public final class LiteLoader implements FilenameFilter
 		// Try to get the minecraft timer object and determine the value of the partialTicks
 		if (tick || minecraftTimer == null)
 		{
-			try
-			{
-				Field fTimer = Minecraft.class.getDeclaredField(getObfuscatedFieldName("Timer", "T"));
-				fTimer.setAccessible(true);
-				minecraftTimer = (Timer)fTimer.get(minecraft);
-				
-			}
-			catch (Exception ex) {}
+			minecraftTimer = PrivateFields.minecraftTimer.Get(minecraft);
  
 			// Hooray, we got the timer reference
 			if (minecraftTimer != null)
@@ -690,7 +705,7 @@ public final class LiteLoader implements FilenameFilter
 		boolean inGame = minecraft.renderViewEntity != null && minecraft.renderViewEntity.worldObj != null;
  
 		// Iterate tickable mods
-		for (Tickable tickable : tickMods)
+		for (Tickable tickable : tickListeners)
 		{
 			tickable.onTick(minecraft, partialTicks, inGame, tick);
 		}
 package com.mumfrey.liteloader.core;
  
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.LinkedList;
 import java.util.logging.Logger;
  
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.GameSettings;
 import net.minecraft.src.Profiler;
  
+/**
+ * Main LiteLoader tick hook 
+ *
+ * @author Adam Mummery-Smith
+ */
 public class LiteLoaderHook extends Profiler
 {
+	/**
+	 * Logger instance
+	 */
 	private Logger logger;
  
+	/**
+	 * LiteLoader instance which will receive callbacks
+	 */
 	private LiteLoader core;
  
+	/**
+	 * Section list, used as a kind of stack to determine where we are in the profiler stack
+	 */
 	private LinkedList<String> sections = new LinkedList<String>();
+
+	/**
+	 * Initialisation done
+	 */
+	private boolean initDone = false;
  
+	/**
+	 * Tick clock, sent as a flag to the core onTick so that mods know it's a new tick
+	 */
 	private boolean tick;
  
+	/**
+	 * Optifine compatibility, pointer to the "Profiler" setting so we can enable it if it's disabled
+	 */
+	private Field ofProfiler;
+	
+	/**
+	 * Minecraft reference, only set if optifine compatibility is enabled 
+	 */
+	private Minecraft mc;
+	
+	/**
+	 * .ctor
+	 * 
+	 * @param core LiteLoader object which will get callbacks
+	 * @param logger Logger instance
+	 */
 	public LiteLoaderHook(LiteLoader core, Logger logger)
 	{
 		this.core = core;
 		this.logger = logger;
+		
+		// Detect optifine (duh!)
+		DetectOptifine();
 	}
  
+	/**
+	 * Try to detect optifine using reflection
+	 * 
+	 * @param logger
+	 */
+	private void DetectOptifine()
+	{
+		try
+		{
+			ofProfiler = GameSettings.class.getDeclaredField("ofProfiler");
+		}
+		catch (SecurityException ex) {}
+		catch (NoSuchFieldException ex)
+		{
+			logger.info("Optifine not detected");
+		}
+		finally
+		{
+			if (ofProfiler != null)
+			{
+				logger.info(String.format("Optifine version %s detected, enabling compatibility check", GetOptifineVersion()));
+				mc = Minecraft.getMinecraft();
+			}
+		}
+	}
+	
+	/**
+	 * Try to get the optifine version using reflection
+	 * 
+	 * @return
+	 */
+	private String GetOptifineVersion()
+	{
+		try
+		{
+			Class config = Class.forName("Config");
+			
+			if (config != null)
+			{
+				Method getVersion = config.getDeclaredMethod("getVersion");
+				
+				if (getVersion != null)
+				{
+					return (String)getVersion.invoke(null);
+				}
+			}
+		}
+		catch (Exception ex) {}
+		
+		return "Unknown";
+	}
+	
 	/* (non-Javadoc)
 	 * @see net.minecraft.src.Profiler#startSection(java.lang.String)
 	 */
 	@Override
 	public void startSection(String sectionName)
 	{
+		if (!initDone)
+		{
+			initDone = true;
+			core.onInit();
+		}
+		
 		if (sectionName.equals("animateTick")) tick = true;
 		sections.add(sectionName);
 		super.startSection(sectionName);
+		
+		if (ofProfiler != null)
+		{
+			try
+			{
+				ofProfiler.set(mc.gameSettings, true);
+			}
+			catch (IllegalArgumentException ex)
+			{
+				ofProfiler = null;
+			}
+			catch (IllegalAccessException ex)
+			{
+				ofProfiler = null;
+			}
+		}
 	}
  
 	/* (non-Javadoc)
@@ -39,7 +158,7 @@ public class LiteLoaderHook extends Profiler
 	public void endSection()
 	{
 		super.endSection();
-
+		
 		String endingSection = sections.removeLast();
  
 		if (endingSection.equalsIgnoreCase("gameRenderer") && sections.getLast().equalsIgnoreCase("root"))
@@ -52,5 +171,4 @@ public class LiteLoaderHook extends Profiler
 			super.endSection();
 		}
 	}
-
 }
+package com.mumfrey.liteloader.util;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Map;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.IntHashMap;
+import net.minecraft.src.KeyBinding;
+import net.minecraft.src.Packet;
+import net.minecraft.src.Render;
+import net.minecraft.src.RenderManager;
+import net.minecraft.src.Tessellator;
+
+import com.mumfrey.liteloader.core.LiteLoader;
+
+public abstract class ModUtilities
+{
+    /**
+     * Add a renderer map entry for the specified entity class
+     * 
+     * @param entityClass
+     * @param renderer
+     */
+    public static void addRenderer(Class entityClass, Render renderer)
+    {
+    	Map entityRenderMap = PrivateFields.entityRenderMap.Get(RenderManager.instance);
+    	entityRenderMap.put(entityClass, renderer);
+    	renderer.setRenderManager(RenderManager.instance);
+    }
+
+	/**
+	 * Register a packet override
+	 * 
+	 * @param packetId
+	 * @param newPacket
+	 */
+	public static boolean registerPacketOverride(int packetId, Class newPacket)
+	{
+		try
+		{
+	    	IntHashMap packetIdToClassMap = Packet.packetIdToClassMap;
+	    	PrivateFields.StaticFields.packetClassToIdMap.Get();
+			Map packetClassToIdMap = PrivateFields.StaticFields.packetClassToIdMap.Get();
+			
+		    packetIdToClassMap.removeObject(packetId);
+		    packetIdToClassMap.addKey(packetId, newPacket);
+	        packetClassToIdMap.put(newPacket, Integer.valueOf(packetId));
+			
+			return true;
+		}
+		catch (Exception ex)
+		{
+			LiteLoader.logger.warning("Error registering packet override for packet id " + packetId + ": " + ex.getMessage());
+			return false;
+		}
+	}
+
+	/**
+	 * Abstraction helper function
+	 * 
+	 * @param fieldName Name of field to get, returned unmodified if in debug mode
+	 * @return Obfuscated field name if present
+	 */
+	public static String getObfuscatedFieldName(String fieldName, String obfuscatedFieldName)
+	{
+		return (!net.minecraft.src.Tessellator.instance.getClass().getSimpleName().equals("Tessellator")) ? obfuscatedFieldName : fieldName;
+	}
+
+	/**
+	 * Registers a keybind with the game settings class so that it is configurable in the "controls" screen
+	 * 
+	 * @param newBinding key binding to add
+	 */
+	public static void registerKey(KeyBinding newBinding)
+	{
+		Minecraft mc = Minecraft.getMinecraft();
+		
+		if (mc == null || mc.gameSettings == null) return;
+		
+	    LinkedList<KeyBinding> keyBindings = new LinkedList<KeyBinding>();
+	    keyBindings.addAll(Arrays.asList(mc.gameSettings.keyBindings));
+	    
+	    if (!keyBindings.contains(newBinding))
+	    {
+	    	keyBindings.add(newBinding);
+	    	mc.gameSettings.keyBindings = keyBindings.toArray(new KeyBinding[0]);
+	    }
+	}
+
+	/**
+	 * Unregisters a registered keybind with the game settings class, thus removing it from the "controls" screen
+	 * 
+	 * @param removeBinding
+	 */
+	public static void unRegisterKey(KeyBinding removeBinding)
+	{
+		Minecraft mc = Minecraft.getMinecraft();
+		
+		if (mc == null || mc.gameSettings == null) return;
+	
+		LinkedList<KeyBinding> keyBindings = new LinkedList<KeyBinding>();
+	    keyBindings.addAll(Arrays.asList(mc.gameSettings.keyBindings));
+	    
+	    if (keyBindings.contains(removeBinding))
+	    {
+	        keyBindings.remove(removeBinding);
+	        mc.gameSettings.keyBindings = keyBindings.toArray(new KeyBinding[0]);
+	    }
+	}
+}
+package com.mumfrey.liteloader.util;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Map;
+import java.util.Properties;
+import java.util.zip.ZipFile;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.GuiButton;
+import net.minecraft.src.GuiIngame;
+import net.minecraft.src.GuiScreen;
+import net.minecraft.src.GuiSlot;
+import net.minecraft.src.GuiTexturePacks;
+import net.minecraft.src.NetClientHandler;
+import net.minecraft.src.NetworkManager;
+import net.minecraft.src.Packet;
+import net.minecraft.src.Profiler;
+import net.minecraft.src.RenderEngine;
+import net.minecraft.src.RenderGlobal;
+import net.minecraft.src.RenderManager;
+import net.minecraft.src.SoundManager;
+import net.minecraft.src.SoundPool;
+import net.minecraft.src.StringTranslate;
+import net.minecraft.src.TexturePackCustom;
+import net.minecraft.src.TexturePackImplementation;
+import net.minecraft.src.TexturePackList;
+import net.minecraft.src.TileEntity;
+import net.minecraft.src.Timer;
+import net.minecraft.src.WorldInfo;
+import net.minecraft.src.WorldRenderer;
+import net.minecraft.src.WorldType;
+
+/**
+ * Wrapper for obf/mcp reflection-accessed private fields, mainly added to centralise the locations I have to update the obfuscated field names
+ * 
+ * @author Adam Mummery-Smith
+ *
+ * @param <P> Parent class type, the type of the class that owns the field
+ * @param <T> Field type, the type of the field value
+ */
+public class PrivateFields<P, T>
+{
+	/**
+	 * Class to which this field belongs
+	 */
+	public final Class parentClass;
+
+	/**
+	 * MCP name for this field
+	 */
+	public final String mcpName;
+
+	/**
+	 * Real (obfuscated) name for this field
+	 */
+	public final String name;
+	
+	/**
+	 * Name used to access the field, determined at init
+	 */
+	private final String fieldName;
+	
+	/**
+	 * Creates a new private field entry
+	 * 
+	 * @param owner
+	 * @param mcpName
+	 * @param name
+	 */
+	private PrivateFields(Class owner, String mcpName, String name)
+	{
+		this.parentClass = owner;
+		this.mcpName = mcpName;
+		this.name = name;
+		
+		this.fieldName = ModUtilities.getObfuscatedFieldName(mcpName, name);
+	}
+	
+	/**
+	 * Get the current value of this field on the instance class supplied
+	 * 
+	 * @param instance Class to get the value of
+	 * @return field value or null if errors occur
+	 */
+	public T Get(P instance)
+	{
+		try
+		{
+			Field field = parentClass.getDeclaredField(fieldName);
+			field.setAccessible(true);
+			return (T)field.get(instance);
+		}
+		catch (Exception ex)
+		{
+			return null;
+		}
+	}
+	
+	/**
+	 * Set the value of this field on the instance class supplied
+	 * 
+	 * @param instance Object to set the value of the field on
+	 * @param value value to set
+	 * @return value
+	 */
+	public T Set(P instance, T value)
+	{
+		try
+		{
+			Field field = parentClass.getDeclaredField(fieldName);
+			field.setAccessible(true);
+			field.set(instance, value);
+		}
+		catch (Exception ex) {}
+		
+		return value;
+	}
+	
+	/**
+	 * Set the value of this FINAL field on the instance class supplied
+	 * 
+	 * @param instance Object to set the value of the field on
+	 * @param value value to set
+	 * @return value
+	 */
+	public T SetFinal(P instance, T value)
+	{
+		try
+		{
+			Field modifiers = Field.class.getDeclaredField("modifiers");
+			modifiers.setAccessible(true);
+			
+			Field field = parentClass.getDeclaredField(fieldName);
+			modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+			field.setAccessible(true);
+			field.set(instance, value);
+		}
+		catch (Exception ex) {}
+		
+		return value;
+	}
+	
+	/**
+	 * Static private fields
+	 *
+	 * @param <P> Parent class type, the type of the class that owns the field
+	 * @param <T> Field type, the type of the field value
+	 */
+	public static final class StaticFields<P, T> extends PrivateFields<P, T>
+	{
+		public StaticFields(Class owner, String mcpName, String name) { super(owner, mcpName, name); }
+		public T Get() { return Get(null); }
+		public void Set(T value) { Set(null, value); }
+		
+		public static final StaticFields<Packet, Map>           packetClassToIdMap = new StaticFields<Packet, Map>     (Packet.class,     "packetClassToIdMap", "a");
+		public static final StaticFields<TileEntity, Map> tileEntityNameToClassMap = new StaticFields<TileEntity, Map> (TileEntity.class, "nameToClassMap",     "a");
+	}
+
+	public static final PrivateFields<Minecraft, Timer>       minecraftTimer = new PrivateFields<Minecraft, Timer>    (Minecraft.class,     "timer",           "T");
+	public static final PrivateFields<RenderManager, Map>    entityRenderMap = new PrivateFields<RenderManager, Map>  (RenderManager.class, "entityRenderMap", "o");
+	public static final PrivateFields<Minecraft, Profiler> minecraftProfiler = new PrivateFields<Minecraft, Profiler> (Minecraft.class,     "mcProfiler",      "I");
+}
+