Preliminary commit for 1.6.3

+ Merged in launcher code + Refactored events and plugin channels into separate classes + Added HUDRenderListener + Added ClientBrandRetriever support + Added mod disablement support + Cross-thread check in profiler hook

Preliminary commit for 1.6.3
+ Merged in launcher code + Refactored events and plugin channels into separate classes + Added HUDRenderListener + Added ClientBrandRetriever support + Added mod disablement support + Cross-thread check in profiler hook
Mumfrey
1 parent 71879cd0
Showing 33 changed files with 2266 additions and 1159 deletions
.classpath
ant/build_liteloader.xml
java/com/mumfrey/liteloader/HUDRenderListener.java
java/com/mumfrey/liteloader/core/ClassPathMod.java
java/com/mumfrey/liteloader/core/EnabledModsList.java
java/com/mumfrey/liteloader/core/Events.java
java/com/mumfrey/liteloader/core/LiteLoader.java
java/com/mumfrey/liteloader/core/LiteLoaderVersion.java
java/com/mumfrey/liteloader/core/ModFile.java
java/com/mumfrey/liteloader/core/PluginChannels.java
java/com/mumfrey/liteloader/core/SoundManagerReloadInhibitor.java
java/com/mumfrey/liteloader/core/exceptions/ProfilerCrossThreadAccessException.java
java/com/mumfrey/liteloader/core/ProfilerStackCorruptionException.java → java/com/mumfrey/liteloader/core/exceptions/ProfilerStackCorruptionException.java
java/com/mumfrey/liteloader/core/HookChat.java → java/com/mumfrey/liteloader/core/hooks/HookChat.java
java/com/mumfrey/liteloader/core/HookLogin.java → java/com/mumfrey/liteloader/core/hooks/HookLogin.java
java/com/mumfrey/liteloader/core/HookPluginChannels.java → java/com/mumfrey/liteloader/core/hooks/HookPluginChannels.java
java/com/mumfrey/liteloader/core/HookProfiler.java → java/com/mumfrey/liteloader/core/hooks/HookProfiler.java
java/com/mumfrey/liteloader/gui/GuiControlsPaginated.java
java/com/mumfrey/liteloader/launch/LiteLoaderTransformer.java
java/com/mumfrey/liteloader/launch/LiteLoaderTweaker.java
@@ -8,5 +8,8 @@
 	<classpathentry kind="lib" path="/Client/jars/libraries/com/google/code/gson/gson/2.2.2/gson-2.2.2.jar"/>
 	<classpathentry kind="lib" path="/Client/jars/libraries/com/google/guava/guava/14.0/guava-14.0.jar"/>
 	<classpathentry kind="lib" path="/Client/jars/libraries/commons-io/commons-io/2.4/commons-io-2.4.jar"/>
+	<classpathentry kind="lib" path="lib/launchwrapper-1.7.jar"/>
+	<classpathentry kind="lib" path="lib/jopt-simple-4.5.jar"/>
+	<classpathentry kind="src" path="run"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
@@ -4,14 +4,14 @@
 	<taskdef resource="net/sf/antcontrib/antcontrib.properties"/>
  
     <!-- Versions !!IMPORTANT -->
-	<property name="version" value="1.6.2" />
-    <property name="mcversion" value="1.6.2" />
+	<property name="version" value="1.6.3" />
+    <property name="mcversion" value="1.6.3" />
     <property name="author" value="Mumfrey" />
  
     <!-- Project definitions and dependencies -->
-	<property name="upstream" value="LiteLoader,LegacyLauncher" />
-	<property name="project" value="LiteLoaderLauncher" />
-	<property name="md5set" value="legacylauncher" />
+	<property name="upstream" value="" />
+	<property name="project" value="LiteLoader" />
+	<property name="md5set" value="mcp" />
     <property name="outmd5set" value="liteloader" />
  
 	<property name="mcp.dir" location="../../.." />
@@ -21,6 +21,7 @@
     <property name="temp" location="${mcp.dir}/temp" />
     <property name="md5.dir" location="${mcp.dir}/md5" />
     <property name="mc.src" location="${mcp.dir}/src/mcp" />
+    <property name="libs" location="${mcp.dir}/lib" />
  
 	<property name="dist.dir" location="${build}/dist" />
 	<property name="stage.dir" location="${build}/stage/${ant.project.name}/${version}" />
@@ -62,6 +63,10 @@
 	<target name="prepare" description="Prepare source for MCP" depends="preparemd5">
         <echo level="info" message="Prepare sources for compile" />
  
+        <copy todir="${libs}" verbose="true" overwrite="true">
+            <fileset dir="${eclipse}/LiteLoader/lib" />
+        </copy>
+		
     	<copy todir="${src}" verbose="false" overwrite="true">
 			<fileset dir="${mc.src}" />
 		</copy>
+package com.mumfrey.liteloader;
+
+/**
+ * Interface for mods which want callbacks when the HUD is rendered
+ * 
+ * @author Adam Mummery-Smith
+ */
+public interface HUDRenderListener
+{
+	public abstract void onPreRenderHUD(int screenWidth, int screenHeight);
+	
+	public abstract void onPostRenderHUD(int screenWidth, int screenHeight);
+}
@@ -35,10 +35,12 @@ public class ClassPathMod extends ModFile
 		{
 			if (this.isDirectory())
 			{
+				LiteLoader.getLogger().info(String.format("Registering \"%s/%s\" as mod resource pack with identifier \"%s\"", this.getParentFile().getName(), this.getName(), name));
 				this.resourcePack = new ModResourcePackDir(name, this);
 			}
 			else
 			{
+				LiteLoader.getLogger().info(String.format("Registering \"%s\" as mod resource pack with identifier \"%s\"", this.getName(), name));
 				this.resourcePack = new ModResourcePack(name, this);
 			}
  
+package com.mumfrey.liteloader.core;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class EnabledModsList
+{
+	private static transient Gson gson = new GsonBuilder().setPrettyPrinting().create();
+	
+	private TreeMap<String, TreeMap<String, Boolean>> mods;
+	
+	private transient Boolean defaultEnabledValue = Boolean.TRUE;
+	
+	private transient boolean allowSave = true;
+	
+	private EnabledModsList()
+	{
+	}
+	
+	public boolean isEnabled(String profileName, String name)
+	{
+		Map<String, Boolean> profile = this.getProfile(profileName);
+		name = name.toLowerCase().trim();
+		
+		if (!profile.containsKey(name))
+		{
+			profile.put(name, this.defaultEnabledValue);
+		}
+		
+		return profile.get(name);
+	}
+
+	public void setEnabled(String profileName, String name, boolean enabled)
+	{
+		Map<String, Boolean> profile = this.getProfile(profileName);
+		profile.put(name.toLowerCase().trim(), Boolean.valueOf(enabled));
+
+		this.allowSave = true;
+	}
+
+	public void processModsList(String profileName, List<String> modNameFilter)
+	{
+		Map<String, Boolean> profile = this.getProfile(profileName);
+		
+		try
+		{
+			if (modNameFilter != null)
+			{
+				for (String modName : profile.keySet())
+				{
+					profile.put(modName, Boolean.FALSE);
+				}
+
+				this.defaultEnabledValue = Boolean.FALSE;
+				this.allowSave = false;
+				
+				for (String filterEntry : modNameFilter)
+				{
+					profile.put(filterEntry.toLowerCase().trim(), Boolean.TRUE);
+				}
+			}
+		}
+		catch (Exception ex)
+		{
+			this.defaultEnabledValue = Boolean.TRUE;
+			this.allowSave = true;
+		}
+	}
+
+	private Map<String, Boolean> getProfile(String profileName)
+	{
+		if (this.mods == null) this.mods = new TreeMap<String, TreeMap<String,Boolean>>();
+		
+		if (!this.mods.containsKey(profileName))
+		{
+			this.mods.put(profileName, new TreeMap<String, Boolean>());
+		}
+		
+		return this.mods.get(profileName);
+	}
+	
+	public static EnabledModsList createFrom(File file)
+	{
+		if (file.exists())
+		{
+			FileReader reader = null;
+			
+			try
+			{
+				reader = new FileReader(file);
+				EnabledModsList instance = gson.fromJson(reader, EnabledModsList.class);
+				return instance;
+			}
+			catch (Exception ex)
+			{
+				ex.printStackTrace();
+			}
+			finally
+			{
+				try
+				{
+					if (reader != null)
+						reader.close();
+				}
+				catch (IOException ex)
+				{
+					ex.printStackTrace();
+				}
+			}
+		}
+		
+		return new EnabledModsList();
+	}
+	
+	public void saveTo(File file)
+	{
+		if (!this.allowSave) return;
+		
+		FileWriter writer = null;
+		
+		try
+		{
+			writer = new FileWriter(file);
+			gson.toJson(this, writer);
+		}
+		catch (Exception ex)
+		{
+			ex.printStackTrace();
+		}
+		finally
+		{
+			try
+			{
+				if (writer != null)
+					writer.close();
+			}
+			catch (IOException ex)
+			{
+				ex.printStackTrace();
+			}
+		}
+	}
+}
+package com.mumfrey.liteloader.core;
+
+import java.util.LinkedList;
+import java.util.logging.Level;
+
+import net.minecraft.src.*;
+
+import com.mumfrey.liteloader.*;
+import com.mumfrey.liteloader.Tickable;
+import com.mumfrey.liteloader.core.hooks.HookChat;
+import com.mumfrey.liteloader.core.hooks.HookLogin;
+import com.mumfrey.liteloader.core.hooks.HookProfiler;
+import com.mumfrey.liteloader.util.ModUtilities;
+import com.mumfrey.liteloader.util.PrivateFields;
+
+/**
+ *
+ * @author Adam Mummery-Smith
+ */
+public class Events implements IPlayerUsage
+{
+	/**
+	 * Reference to the loader instance
+	 */
+	private LiteLoader loader;
+	
+	/**
+	 * Reference to the game
+	 */
+	private Minecraft minecraft;
+	
+	/**
+	 * Plugin channel manager
+	 */
+	private PluginChannels pluginChannels;
+	
+	/**
+	 * Reference to the minecraft timer
+	 */
+	private Timer minecraftTimer;
+	
+	/**
+	 * Flags which keep track of whether hooks have been applied
+	 */
+	private boolean hookInitDone, lateInitDone, chatHooked, loginHooked, tickHooked;
+	
+	/**
+	 * Profiler hook objects
+	 */
+	private HookProfiler profilerHook = new HookProfiler(this);
+	
+	/**
+	 * ScaledResolution used by the pre-chat and post-chat render callbacks
+	 */
+	private ScaledResolution currentResolution;
+	
+	/**
+	 * Current screen width
+	 */
+	private int screenWidth = 854;
+
+	/**
+	 * Current screen height
+	 */
+	private int screenHeight = 480;
+
+	
+	/**
+	 * List of mods which implement Tickable interface and will receive tick
+	 * events
+	 */
+	private LinkedList<Tickable> tickListeners = new LinkedList<Tickable>();
+	
+	/**
+	 * List of mods which implement the GameLoopListener interface and will
+	 * receive loop events
+	 */
+	private LinkedList<GameLoopListener> loopListeners = new LinkedList<GameLoopListener>();
+	
+	/**
+	 * 
+	 */
+	private LinkedList<InitCompleteListener> initListeners = new LinkedList<InitCompleteListener>();
+	
+	/**
+	 * List of mods which implement RenderListener interface and will receive
+	 * render events events
+	 */
+	private LinkedList<RenderListener> renderListeners = new LinkedList<RenderListener>();
+	
+	/**
+	 * List of mods which implement the PostRenderListener interface and want to
+	 * render entities
+	 */
+	private LinkedList<PostRenderListener> postRenderListeners = new LinkedList<PostRenderListener>();
+	
+	/**
+	 * List of mods which implement HUDRenderListener and want callbacks when HUD is rendered
+	 */
+	private LinkedList<HUDRenderListener> hudRenderListeners = new LinkedList<HUDRenderListener>();
+	
+	/**
+	 * List of mods which implement ChatRenderListener and want to know when
+	 * chat is rendered
+	 */
+	private LinkedList<ChatRenderListener> chatRenderListeners = new LinkedList<ChatRenderListener>();
+	
+	/**
+	 * List of mods which implement ChatListener interface and will receive chat
+	 * events
+	 */
+	private LinkedList<ChatListener> chatListeners = new LinkedList<ChatListener>();
+	
+	/**
+	 * List of mods which implement ChatFilter interface and will receive chat
+	 * filter events
+	 */
+	private LinkedList<ChatFilter> chatFilters = new LinkedList<ChatFilter>();
+	
+	/**
+	 * List of mods which implement LoginListener interface and will receive
+	 * client login events
+	 */
+	private LinkedList<LoginListener> loginListeners = new LinkedList<LoginListener>();
+	
+	/**
+	 * List of mods which implement LoginListener interface and will receive
+	 * client login events
+	 */
+	private LinkedList<PreLoginListener> preLoginListeners = new LinkedList<PreLoginListener>();
+
+	public Events(LiteLoader loader, Minecraft minecraft, PluginChannels pluginChannels)
+	{
+		this.loader = loader;
+		this.minecraft = minecraft;
+		this.pluginChannels = pluginChannels;
+	}
+
+	/**
+	 * Add a listener to the relevant listener lists
+	 * 
+	 * @param listener
+	 */
+	public void addListener(LiteMod listener)
+	{
+		if (listener instanceof Tickable)
+		{
+			this.addTickListener((Tickable)listener);
+		}
+		
+		if (listener instanceof GameLoopListener)
+		{
+			this.addLoopListener((GameLoopListener)listener);
+		}
+		
+		if (listener instanceof InitCompleteListener)
+		{
+			this.addInitListener((InitCompleteListener)listener);
+		}
+		
+		if (listener instanceof RenderListener)
+		{
+			this.addRenderListener((RenderListener)listener);
+		}
+		
+		if (listener instanceof PostRenderListener)
+		{
+			this.addPostRenderListener((PostRenderListener)listener);
+		}
+		
+		if (listener instanceof ChatFilter)
+		{
+			this.addChatFilter((ChatFilter)listener);
+		}
+		
+		if (listener instanceof ChatListener)
+		{
+			if (listener instanceof ChatFilter)
+			{
+				LiteLoader.getLogger().warning(String.format("Interface error initialising mod '%1s'. A mod implementing ChatFilter and ChatListener is not supported! Remove one of these interfaces", listener.getName()));
+			}
+			else
+			{
+				this.addChatListener((ChatListener)listener);
+			}
+		}
+		
+		if (listener instanceof ChatRenderListener)
+		{
+			this.addChatRenderListener((ChatRenderListener)listener);
+		}
+		
+		if (listener instanceof HUDRenderListener)
+		{
+			this.addHUDRenderListener((HUDRenderListener)listener);
+		}
+		
+		if (listener instanceof PreLoginListener)
+		{
+			this.addPreLoginListener((PreLoginListener)listener);
+		}
+		
+		if (listener instanceof LoginListener)
+		{
+			this.addLoginListener((LoginListener)listener);
+		}
+		
+		if (listener instanceof PluginChannelListener)
+		{
+			this.pluginChannels.addPluginChannelListener((PluginChannelListener)listener);
+		}
+	}
+
+	
+	/**
+	 * Initialise mod hooks
+	 */
+	public void initHooks()
+	{
+		try
+		{
+			LiteLoader.getLogger().info("Event manager is registering hooks");
+			
+			// Chat hook
+			if ((this.chatListeners.size() > 0 || this.chatFilters.size() > 0) && !this.chatHooked)
+			{
+				this.chatHooked = true;
+				HookChat.register();
+				HookChat.registerPacketHandler(this);
+			}
+			
+			// Login hook
+			if ((this.preLoginListeners.size() > 0 || this.loginListeners.size() > 0) && !this.loginHooked)
+			{
+				this.loginHooked = true;
+				ModUtilities.registerPacketOverride(1, HookLogin.class);
+				HookLogin.events = this;
+			}
+
+			// Tick hook
+			if (!this.tickHooked)
+			{
+				this.tickHooked = true;
+				PrivateFields.minecraftProfiler.setFinal(this.minecraft, this.profilerHook);
+			}
+			
+			// Sanity hook
+			PlayerUsageSnooper snooper = this.minecraft.getPlayerUsageSnooper();
+			PrivateFields.playerStatsCollector.setFinal(snooper, this);
+
+			this.pluginChannels.initHook();
+		}
+		catch (Exception ex)
+		{
+			LiteLoader.getLogger().log(Level.WARNING, "Error creating hooks", ex);
+			ex.printStackTrace();
+		}
+		
+		this.hookInitDone = true;
+	}
+	
+	/**
+	 * @param tickable
+	 */
+	public void addTickListener(Tickable tickable)
+	{
+		if (!this.tickListeners.contains(tickable))
+		{
+			this.tickListeners.add(tickable);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param loopListener
+	 */
+	public void addLoopListener(GameLoopListener loopListener)
+	{
+		if (!this.loopListeners.contains(loopListener))
+		{
+			this.loopListeners.add(loopListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param initCompleteListener
+	 */
+	public void addInitListener(InitCompleteListener initCompleteListener)
+	{
+		if (!this.initListeners.contains(initCompleteListener))
+		{
+			this.initListeners.add(initCompleteListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param renderListener
+	 */
+	public void addRenderListener(RenderListener renderListener)
+	{
+		if (!this.renderListeners.contains(renderListener))
+		{
+			this.renderListeners.add(renderListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param postRenderListener
+	 */
+	public void addPostRenderListener(PostRenderListener postRenderListener)
+	{
+		if (!this.postRenderListeners.contains(postRenderListener))
+		{
+			this.postRenderListeners.add(postRenderListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param chatFilter
+	 */
+	public void addChatFilter(ChatFilter chatFilter)
+	{
+		if (!this.chatFilters.contains(chatFilter))
+		{
+			this.chatFilters.add(chatFilter);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param chatListener
+	 */
+	public void addChatListener(ChatListener chatListener)
+	{
+		if (!this.chatListeners.contains(chatListener))
+		{
+			this.chatListeners.add(chatListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param chatRenderListener
+	 */
+	public void addChatRenderListener(ChatRenderListener chatRenderListener)
+	{
+		if (!this.chatRenderListeners.contains(chatRenderListener))
+		{
+			this.chatRenderListeners.add(chatRenderListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param hudRenderListener
+	 */
+	public void addHUDRenderListener(HUDRenderListener hudRenderListener)
+	{
+		if (!this.hudRenderListeners.contains(hudRenderListener))
+		{
+			this.hudRenderListeners.add(hudRenderListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param loginListener
+	 */
+	public void addPreLoginListener(PreLoginListener loginListener)
+	{
+		if (!this.preLoginListeners.contains(loginListener))
+		{
+			this.preLoginListeners.add(loginListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+	
+	/**
+	 * @param loginListener
+	 */
+	public void addLoginListener(LoginListener loginListener)
+	{
+		if (!this.loginListeners.contains(loginListener))
+		{
+			this.loginListeners.add(loginListener);
+			if (this.hookInitDone)
+				this.initHooks();
+		}
+	}
+
+	/**
+	 * Late initialisation callback
+	 */
+	public void onInit()
+	{
+		this.loader.refreshResources();
+		
+		if (!this.lateInitDone)
+		{
+			this.lateInitDone = true;
+			
+			for (InitCompleteListener initMod : this.initListeners)
+			{
+				try
+				{
+					LiteLoader.getLogger().info("Calling late init for mod " + initMod.getName());
+					initMod.onInitCompleted(this.minecraft, this.loader);
+				}
+				catch (Throwable th)
+				{
+					LiteLoader.getLogger().log(Level.WARNING, "Error initialising mod " + initMod.getName(), th);
+				}
+			}
+		}
+
+		this.loader.onInit();
+	}
+	
+	/**
+	 * Callback from the tick hook, pre render
+	 */
+	public void onRender()
+	{
+		this.loader.onRender();
+		
+		for (RenderListener renderListener : this.renderListeners)
+			renderListener.onRender();
+	}
+	
+	/**
+	 * Callback from the tick hook, post render entities
+	 */
+	public void postRenderEntities()
+	{
+		float partialTicks = (this.minecraftTimer != null) ? this.minecraftTimer.elapsedPartialTicks : 0.0F;
+		
+		for (PostRenderListener renderListener : this.postRenderListeners)
+			renderListener.onPostRenderEntities(partialTicks);
+	}
+	
+	/**
+	 * Callback from the tick hook, post render
+	 */
+	public void postRender()
+	{
+		float partialTicks = (this.minecraftTimer != null) ? this.minecraftTimer.elapsedPartialTicks : 0.0F;
+		
+		for (PostRenderListener renderListener : this.postRenderListeners)
+			renderListener.onPostRender(partialTicks);
+	}
+	
+	/**
+	 * Called immediately before the current GUI is rendered
+	 */
+	public void preRenderGUI()
+	{
+		for (RenderListener renderListener : this.renderListeners)
+			renderListener.onRenderGui(this.minecraft.currentScreen);
+	}
+	
+	/**
+	 * Called immediately after the world/camera transform is initialised
+	 */
+	public void onSetupCameraTransform()
+	{
+		for (RenderListener renderListener : this.renderListeners)
+			renderListener.onSetupCameraTransform();
+	}
+	
+	/**
+	 * Called immediately before the chat log is rendered
+	 */
+	public void onRenderChat()
+	{
+		GuiNewChat chat = this.minecraft.ingameGUI.getChatGUI();
+		
+		for (ChatRenderListener chatRenderListener : this.chatRenderListeners)
+			chatRenderListener.onPreRenderChat(this.screenWidth, this.screenHeight, chat);
+	}
+	
+	/**
+	 * Called immediately after the chat log is rendered
+	 */
+	public void postRenderChat()
+	{
+		GuiNewChat chat = this.minecraft.ingameGUI.getChatGUI();
+		
+		for (ChatRenderListener chatRenderListener : this.chatRenderListeners)
+			chatRenderListener.onPostRenderChat(this.screenWidth, this.screenHeight, chat);
+	}
+	
+	/**
+	 * Callback when about to render the HUD
+	 */
+	public void onRenderHUD()
+	{
+		this.currentResolution = new ScaledResolution(this.minecraft.gameSettings, this.minecraft.displayWidth, this.minecraft.displayHeight);
+		this.screenWidth = this.currentResolution.getScaledWidth();
+		this.screenHeight = this.currentResolution.getScaledHeight();
+		
+		if (!this.minecraft.gameSettings.hideGUI || this.minecraft.currentScreen != null)
+		{
+			for (HUDRenderListener hudRenderListener : this.hudRenderListeners)
+				hudRenderListener.onPreRenderHUD(this.screenWidth, this.screenHeight);
+		}
+	}
+	
+	/**
+	 * Callback when the HUD has just been rendered
+	 */
+	public void postRenderHUD()
+	{
+		if (!this.minecraft.gameSettings.hideGUI || this.minecraft.currentScreen != null)
+		{
+			for (HUDRenderListener hudRenderListener : this.hudRenderListeners)
+				hudRenderListener.onPostRenderHUD(this.screenWidth, this.screenHeight);
+		}
+	}
+	
+	/**
+	 * Callback from the tick hook, called every frame when the timer is updated
+	 */
+	public void onTimerUpdate()
+	{
+		for (GameLoopListener loopListener : this.loopListeners)
+			loopListener.onRunGameLoop(this.minecraft);
+	}
+	
+	/**
+	 * Callback from the tick hook, ticks all tickable mods
+	 * 
+	 * @param clock True if this is a new tick (otherwise it's just a new frame)
+	 */
+	public void onTick(Profiler profiler, boolean clock)
+	{
+		float partialTicks = 0.0F;
+		
+		// Try to get the minecraft timer object and determine the value of the
+		// partialTicks
+		if (clock || this.minecraftTimer == null)
+		{
+			this.minecraftTimer = PrivateFields.minecraftTimer.get(this.minecraft);
+		}
+		
+		// Hooray, we got the timer reference
+		if (this.minecraftTimer != null)
+		{
+			partialTicks = this.minecraftTimer.renderPartialTicks;
+			clock = this.minecraftTimer.elapsedTicks > 0;
+		}
+		
+		// Flag indicates whether we are in game at the moment
+		boolean inGame = this.minecraft.renderViewEntity != null && this.minecraft.renderViewEntity.worldObj != null;
+		
+		if (clock)
+		{
+			this.loader.onTick(partialTicks, inGame);
+		}
+		
+		// Iterate tickable mods
+		for (Tickable tickable : this.tickListeners)
+		{
+			profiler.startSection(tickable.getClass().getSimpleName());
+			tickable.onTick(this.minecraft, partialTicks, inGame, clock);
+			profiler.endSection();
+		}
+	}
+	
+	/**
+	 * Callback from the chat hook
+	 * 
+	 * @param chatPacket
+	 * @return
+	 */
+	public boolean onChat(Packet3Chat chatPacket)
+	{
+		if (chatPacket.message == null)
+			return true;
+		
+		ChatMessageComponent chat = ChatMessageComponent.createFromJson(chatPacket.message);
+		String message = chat.toStringWithFormatting(true);
+		
+		// Chat filters get a stab at the chat first, if any filter returns
+		// false the chat is discarded
+		for (ChatFilter chatFilter : this.chatFilters)
+		{
+			if (chatFilter.onChat(chatPacket, chat, message))
+			{
+				chat = ChatMessageComponent.createFromJson(chatPacket.message);
+				message = chat.toStringWithFormatting(true);
+			}
+			else
+			{
+				return false;
+			}
+		}
+		
+		// Chat listeners get the chat if no filter removed it
+		for (ChatListener chatListener : this.chatListeners)
+			chatListener.onChat(chat, message);
+		
+		return true;
+	}
+	
+	/**
+	 * Pre-login callback from the login hook
+	 * 
+	 * @param netHandler
+	 * @param hookLogin
+	 * @return
+	 */
+	public boolean onPreLogin(NetHandler netHandler, Packet1Login loginPacket)
+	{
+		boolean cancelled = false;
+		
+		for (PreLoginListener loginListener : this.preLoginListeners)
+		{
+			cancelled |= !loginListener.onPreLogin(netHandler, loginPacket);
+		}
+		
+		return !cancelled;
+	}
+	
+	/**
+	 * Callback from the login hook
+	 * 
+	 * @param netHandler
+	 * @param loginPacket
+	 */
+	public void onConnectToServer(NetHandler netHandler, Packet1Login loginPacket)
+	{
+		this.loader.onLogin(netHandler, loginPacket);
+		
+		for (LoginListener loginListener : this.loginListeners)
+			loginListener.onLogin(netHandler, loginPacket);
+		
+		this.pluginChannels.onConnectToServer(netHandler, loginPacket);
+	}
+	
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * net.minecraft.src.IPlayerUsage#addServerStatsToSnooper(net.minecraft.
+	 * src.PlayerUsageSnooper)
+	 */
+	@Override
+	public void addServerStatsToSnooper(PlayerUsageSnooper var1)
+	{
+		this.minecraft.addServerStatsToSnooper(var1);
+	}
+	
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * net.minecraft.src.IPlayerUsage#addServerTypeToSnooper(net.minecraft.src
+	 * .PlayerUsageSnooper)
+	 */
+	@Override
+	public void addServerTypeToSnooper(PlayerUsageSnooper var1)
+	{
+		this.sanityCheck();
+		this.minecraft.addServerTypeToSnooper(var1);
+	}
+	
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.IPlayerUsage#isSnooperEnabled()
+	 */
+	@Override
+	public boolean isSnooperEnabled()
+	{
+		return this.minecraft.isSnooperEnabled();
+	}
+	
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.IPlayerUsage#getLogAgent()
+	 */
+	@Override
+	public ILogAgent getLogAgent()
+	{
+		return this.minecraft.getLogAgent();
+	}
+	
+	/**
+	 * Check that the profiler hook hasn't been overridden by something else
+	 */
+	private void sanityCheck()
+	{
+		if (this.tickHooked && this.minecraft.mcProfiler != this.profilerHook)
+		{
+			PrivateFields.minecraftProfiler.setFinal(this.minecraft, this.profilerHook);
+		}
+	}
+}
 package com.mumfrey.liteloader.core;
  
 import java.io.*;
-import java.lang.reflect.Method;
+import java.lang.reflect.Field;
 import java.net.MalformedURLException;
 import java.net.URISyntaxException;
 import java.net.URL;
-import java.net.URLClassLoader;
 import java.net.URLDecoder;
-import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -30,24 +28,15 @@ import java.util.zip.ZipInputStream;
  
 import javax.activity.InvalidActivityException;
  
+import net.minecraft.client.ClientBrandRetriever;
+import net.minecraft.launchwrapper.LaunchClassLoader;
 import net.minecraft.src.*;
  
-import com.mumfrey.liteloader.ChatFilter;
-import com.mumfrey.liteloader.ChatListener;
-import com.mumfrey.liteloader.ChatRenderListener;
-import com.mumfrey.liteloader.GameLoopListener;
-import com.mumfrey.liteloader.InitCompleteListener;
-import com.mumfrey.liteloader.LiteMod;
-import com.mumfrey.liteloader.LoginListener;
-import com.mumfrey.liteloader.Permissible;
-import com.mumfrey.liteloader.PluginChannelListener;
-import com.mumfrey.liteloader.PostRenderListener;
-import com.mumfrey.liteloader.PreLoginListener;
-import com.mumfrey.liteloader.RenderListener;
+import com.mumfrey.liteloader.*;
 import com.mumfrey.liteloader.Tickable;
 import com.mumfrey.liteloader.gui.GuiControlsPaginated;
+import com.mumfrey.liteloader.log.LiteLoaderLogFormatter;
 import com.mumfrey.liteloader.permissions.PermissionsManagerClient;
-import com.mumfrey.liteloader.util.ModUtilities;
 import com.mumfrey.liteloader.util.PrivateFields;
  
 /**
@@ -55,14 +44,14 @@ import com.mumfrey.liteloader.util.PrivateFields;
  * lightweight mods
  * 
  * @author Adam Mummery-Smith
- * @version 1.6.2_04
+ * @version 1.6.3
  */
-public final class LiteLoader implements FilenameFilter, IPlayerUsage
+public final class LiteLoader implements FilenameFilter
 {
 	/**
 	 * Liteloader version
 	 */
-	private static final LiteLoaderVersion VERSION = LiteLoaderVersion.MC_1_6_2_R3;
+	private static final LiteLoaderVersion VERSION = LiteLoaderVersion.MC_1_6_3_R0;
  
 	/**
 	 * Maximum recursion depth for mod discovery
@@ -77,7 +66,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	/**
 	 * Logger for LiteLoader events
 	 */
-	public static Logger logger = Logger.getLogger("liteloader");
+	private static Logger logger = Logger.getLogger("liteloader");
  
 	/**
 	 * Use stdout rather than stderr
@@ -100,9 +89,14 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	private static String profile = "";
  
 	/**
+	 * Tweak system class loader 
+	 */
+	private static LaunchClassLoader classLoader;
+	
+	/**
 	 * List of mods passed into the command line
 	 */
-	private static List<String> modNameFilter = null;
+	private EnabledModsList enabledModsList = null;
  
 	/**
 	 * Mods folder which contains mods and legacy config files
@@ -126,6 +120,16 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	private File versionConfigFolder;
  
 	/**
+	 * JSON file containing the list of enabled/disabled mods by profile
+	 */
+	private File enabledModsFile;
+	
+	/**
+	 * File to write log entries to
+	 */
+	private File logFile;
+	
+	/**
 	 * Reference to the Minecraft game instance
 	 */
 	private Minecraft minecraft = Minecraft.getMinecraft();
@@ -158,11 +162,6 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	private boolean paginateControls = true;
  
 	/**
-	 * Reference to the minecraft timer
-	 */
-	private Timer minecraftTimer;
-	
-	/**
 	 * Classes to load, mapped by class name 
 	 */
 	private Map<String, Class<? extends LiteMod>> modsToLoad = new HashMap<String, Class<? extends LiteMod>>();
@@ -193,103 +192,29 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	private LinkedList<LiteMod> loadedMods = new LinkedList<LiteMod>();
  
 	/**
-	 * List of mods which implement Tickable interface and will receive tick
-	 * events
-	 */
-	private LinkedList<Tickable> tickListeners = new LinkedList<Tickable>();
-	
-	/**
-	 * List of mods which implement the GameLoopListener interface and will
-	 * receive loop events
-	 */
-	private LinkedList<GameLoopListener> loopListeners = new LinkedList<GameLoopListener>();
-	
-	/**
-	 * 
-	 */
-	private LinkedList<InitCompleteListener> initListeners = new LinkedList<InitCompleteListener>();
-	
-	/**
-	 * List of mods which implement RenderListener interface and will receive
-	 * render events events
-	 */
-	private LinkedList<RenderListener> renderListeners = new LinkedList<RenderListener>();
-	
-	/**
-	 * List of mods which implement the PostRenderListener interface and want to
-	 * render entities
-	 */
-	private LinkedList<PostRenderListener> postRenderListeners = new LinkedList<PostRenderListener>();
-	
-	/**
-	 * List of mods which implement ChatRenderListener and want to know when
-	 * chat is rendered
-	 */
-	private LinkedList<ChatRenderListener> chatRenderListeners = new LinkedList<ChatRenderListener>();
-	
-	/**
-	 * List of mods which implement ChatListener interface and will receive chat
-	 * events
-	 */
-	private LinkedList<ChatListener> chatListeners = new LinkedList<ChatListener>();
-	
-	/**
-	 * List of mods which implement ChatFilter interface and will receive chat
-	 * filter events
-	 */
-	private LinkedList<ChatFilter> chatFilters = new LinkedList<ChatFilter>();
-	
-	/**
-	 * List of mods which implement LoginListener interface and will receive
-	 * client login events
-	 */
-	private LinkedList<LoginListener> loginListeners = new LinkedList<LoginListener>();
-	
-	/**
-	 * List of mods which implement LoginListener interface and will receive
-	 * client login events
+	 * Mods which are loaded but disabled
 	 */
-	private LinkedList<PreLoginListener> preLoginListeners = new LinkedList<PreLoginListener>();
+	private LinkedList<ModFile> disabledMods = new LinkedList<ModFile>();
  
 	/**
-	 * List of mods which implement PluginChannelListener interface
+	 * Event manager
 	 */
-	private LinkedList<PluginChannelListener> pluginChannelListeners = new LinkedList<PluginChannelListener>();
+	private Events events;
  
 	/**
-	 * Mapping of plugin channel names to listeners
+	 * Plugin channel manager 
 	 */
-	private HashMap<String, LinkedList<PluginChannelListener>> pluginChannels = new HashMap<String, LinkedList<PluginChannelListener>>();
+	private PluginChannels pluginChannels;
  
 	/**
-	 * Reference to the addUrl method on URLClassLoader
+	 * Permission Manager
 	 */
-	private Method mAddUrl;
+	private PermissionsManagerClient permissionsManager = PermissionsManagerClient.getInstance();
  
 	/**
 	 * Flag which keeps track of whether late initialisation has been done
 	 */
-	private boolean loaderStartupDone, loaderStartupComplete, lateInitDone;
-	
-	/**
-	 * Flags which keep track of whether hooks have been applied
-	 */
-	private boolean chatHooked, loginHooked, pluginChannelHooked, tickHooked;
-	
-	/**
-	 * Profiler hook objects
-	 */
-	private HookProfiler profilerHook = new HookProfiler(this, logger);
-	
-	/**
-	 * ScaledResolution used by the pre-chat and post-chat render callbacks
-	 */
-	private ScaledResolution currentResolution;
-	
-	/**
-	 * Permission Manager
-	 */
-	private static PermissionsManagerClient permissionsManager = PermissionsManagerClient.getInstance();
+	private boolean loaderStartupDone, loaderStartupComplete;
  
 	/**
 	 * True while initialising mods if we need to do a resource manager reload once the process is completed
@@ -319,7 +244,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	/**
 	 * List of all registered mod keys
 	 */
-	private List<KeyBinding> modKeys = new ArrayList<KeyBinding>();
+	private List<KeyBinding> modKeyBindings = new ArrayList<KeyBinding>();
  
 	/**
 	 * Map of mod key bindings to their key codes, stored so that we don't need to cast from
@@ -327,99 +252,35 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	 */
 	private Map<KeyBinding, Integer> storedModKeyBindings = new HashMap<KeyBinding, Integer>();
  
-	public static final void init(File gameDirectory, File assetsDirectory, String profile, List<String> modNameFilter)
+	@SuppressWarnings("unused")
+	private static final void init(File gameDirectory, File assetsDirectory, String profile, List<String> modNameFilter, LaunchClassLoader classLoader)
 	{
-		if (instance == null)
+		if (LiteLoader.instance == null)
 		{
 			LiteLoader.gameDirectory = gameDirectory;
 			LiteLoader.assetsDirectory = assetsDirectory;
 			LiteLoader.profile = profile;
+			LiteLoader.classLoader = classLoader;
  
-			try
-			{
-				if (modNameFilter != null)
-				{
-					LiteLoader.modNameFilter = new ArrayList<String>();
-					for (String filterEntry : modNameFilter)
-					{
-						LiteLoader.modNameFilter.add(filterEntry.toLowerCase().trim());
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				LiteLoader.modNameFilter = null;
-			}
-			
-			instance = new LiteLoader();
-			instance.initLoader();
+			LiteLoader.instance = new LiteLoader(profile, modNameFilter);
+			LiteLoader.instance.initLoader();
 		}
-		
-	}
-	
-	/**
-	 * Get the singleton instance of LiteLoader, initialises the loader if
-	 * necessary
-	 * 
-	 * @param locationProvider
-	 * @return LiteLoader instance
-	 */
-	public static final LiteLoader getInstance()
-	{
-		return instance;
-	}
-	
-	/**
-	 * Get the LiteLoader logger object
-	 * 
-	 * @return
-	 */
-	public static final Logger getLogger()
-	{
-		return logger;
-	}
-	
-	/**
-	 * Get the output stream which we are using for console output
-	 * 
-	 * @return
-	 */
-	public static final PrintStream getConsoleStream()
-	{
-		return useStdOut ? System.out : System.err;
-	}
-	
-	/**
-	 * Get LiteLoader version
-	 * 
-	 * @return
-	 */
-	public static final String getVersion()
-	{
-		return VERSION.getLoaderVersion();
-	}
-	
-	/**
-	 * Get the loader revision
-	 * 
-	 * @return
-	 */
-	public static final int getRevision()
-	{
-		return VERSION.getLoaderRevision();
-	}
-	
-	public static final PermissionsManagerClient getPermissionsManager()
-	{
-		return permissionsManager;
 	}
-	
+
 	/**
 	 * LiteLoader constructor
+	 * @param profile 
+	 * @param modNameFilter 
 	 */
-	private LiteLoader()
+	private LiteLoader(String profile, List<String> modNameFilter)
 	{
 		this.initPaths();
+		
+		this.enabledModsList = EnabledModsList.createFrom(this.enabledModsFile);
+		this.enabledModsList.processModsList(profile, modNameFilter);
+		
+		this.pluginChannels = new PluginChannels(this);
+		this.events = new Events(this, this.minecraft, this.pluginChannels);
 	}
  
 	/**
@@ -439,6 +300,9 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 		if (!this.versionConfigFolder.exists()) this.versionConfigFolder.mkdirs();
  
 		this.propertiesFile = new File(this.configBaseFolder, "liteloader.properties");
+		this.enabledModsFile = new File(this.configBaseFolder, "liteloader.profiles.json");
+		this.logFile = new File(this.configBaseFolder, "liteloader.log");
+		this.keyMapSettingsFile = new File(this.configBaseFolder, "liteloader.keys.properties");
 	}
  
 	/**
@@ -466,15 +330,15 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 		// Set up loader, initialises any reflection methods needed
 		if (this.prepareLoader())
 		{
-			logger.info(String.format("LiteLoader %s starting up...", VERSION.getLoaderVersion()));
+			LiteLoader.getLogger().info(String.format("LiteLoader %s starting up...", VERSION.getLoaderVersion()));
  
 			// Print the branding version if any was provided
 			if (this.branding != null)
 			{
-				logger.info(String.format("Active Pack: %s", this.branding));
+				LiteLoader.getLogger().info(String.format("Active Pack: %s", this.branding));
 			}
  
-			logger.info(String.format("Java reports OS=\"%s\"", System.getProperty("os.name").toLowerCase()));
+			LiteLoader.getLogger().info(String.format("Java reports OS=\"%s\"", System.getProperty("os.name").toLowerCase()));
  
 			boolean searchMods = this.localProperties.getProperty("search.mods", "true").equalsIgnoreCase("true");
 			boolean searchProtectionDomain = this.localProperties.getProperty("search.jar", "true").equalsIgnoreCase("true");
@@ -482,7 +346,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
  
 			if (!searchMods && !searchProtectionDomain && !searchClassPath)
 			{
-				logger.warning("Invalid configuration, no search locations defined. Enabling all search locations.");
+				LiteLoader.getLogger().warning("Invalid configuration, no search locations defined. Enabling all search locations.");
  
 				this.localProperties.setProperty("search.mods", "true");
 				this.localProperties.setProperty("search.jar", "true");
@@ -496,18 +360,23 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			// Examines the class path and mods folder and locates loadable mods
 			this.prepareMods(searchMods, searchProtectionDomain, searchClassPath);
  
+			// Spawn mod instances
+			this.loadMods();
+			
 			// Initialises enumerated mods
 			this.initMods();
  
 			// Initialises the required hooks for loaded mods
-			this.initHooks();
-			
+			this.events.initHooks();
 			this.loaderStartupComplete = true;
  
 			this.writeProperties();
+			this.enabledModsList.saveTo(this.enabledModsFile);
+			
+			this.setBranding("LiteLoader");
 		}
 	}
-	
+
 	/**
 	 * Set up reflection methods required by the loader
 	 */
@@ -515,10 +384,6 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	{
 		try
 		{
-			// addURL method is used by the class loader to
-			this.mAddUrl = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
-			this.mAddUrl.setAccessible(true);
-			
 			// Prepare the properties
 			this.prepareProperties();
  
@@ -544,7 +409,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 		}
 		catch (Throwable th)
 		{
-			logger.log(Level.SEVERE, "Error initialising LiteLoader", th);
+			LiteLoader.getLogger().log(Level.SEVERE, "Error initialising LiteLoader", th);
 			return false;
 		}
  
@@ -559,16 +424,16 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	{
 		Formatter logFormatter = new LiteLoaderLogFormatter();
  
-		logger.setUseParentHandlers(false);
-		this.useStdOut = System.getProperty("liteloader.log", "stderr").equalsIgnoreCase("stdout") || this.localProperties.getProperty("log", "stderr").equalsIgnoreCase("stdout");
+		LiteLoader.getLogger().setUseParentHandlers(false);
+		LiteLoader.useStdOut = System.getProperty("liteloader.log", "stderr").equalsIgnoreCase("stdout") || this.localProperties.getProperty("log", "stderr").equalsIgnoreCase("stdout");
  
 		StreamHandler consoleHandler = useStdOut ? new com.mumfrey.liteloader.util.log.ConsoleHandler() : new java.util.logging.ConsoleHandler();
 		consoleHandler.setFormatter(logFormatter);
-		logger.addHandler(consoleHandler);
+		LiteLoader.getLogger().addHandler(consoleHandler);
  
-		FileHandler logFileHandler = new FileHandler(new File(this.configBaseFolder, "LiteLoader.txt").getAbsolutePath());
+		FileHandler logFileHandler = new FileHandler(this.logFile.getAbsolutePath());
 		logFileHandler.setFormatter(logFormatter);
-		logger.addHandler(logFileHandler);
+		LiteLoader.getLogger().addHandler(logFileHandler);
 	}
  
 	/**
@@ -607,8 +472,6 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			this.localProperties = new Properties(this.internalProperties);
 		}
  
-		this.keyMapSettingsFile = new File(this.configBaseFolder, "litemodkeys.properties");
-
 		if (this.keyMapSettingsFile.exists())
 		{
 			try
@@ -648,7 +511,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 		}
 		catch (Throwable th)
 		{
-			logger.log(Level.WARNING, "Error writing liteloader properties", th);
+			LiteLoader.getLogger().log(Level.WARNING, "Error writing liteloader properties", th);
 		}
 	}
  
@@ -661,7 +524,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	 */
 	public boolean registerModResourcePack(ResourcePack resourcePack)
 	{
-		if (!this.registeredResourcePacks.containsKey(resourcePack.func_130077_b())) // TODO adamsrc -> getName()
+		if (!this.registeredResourcePacks.containsKey(resourcePack.getPackName()))
 		{
 			this.pendingResourceReload = true;
  
@@ -669,7 +532,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			if (!defaultResourcePacks.contains(resourcePack))
 			{
 				defaultResourcePacks.add(resourcePack);
-				this.registeredResourcePacks.put(resourcePack.func_130077_b(), resourcePack); // TODO adamsrc -> getName()
+				this.registeredResourcePacks.put(resourcePack.getPackName(), resourcePack);
 				return true;
 			}
 		}
@@ -688,7 +551,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			this.pendingResourceReload = true;
  
 			List<ResourcePack> defaultResourcePacks = PrivateFields.defaultResourcePacks.get(this.minecraft);
-			this.registeredResourcePacks.remove(resourcePack.func_130077_b()); // TODO adamsrc -> getName()
+			this.registeredResourcePacks.remove(resourcePack.getPackName());
 			defaultResourcePacks.remove(resourcePack);
 			return true;
 		}
@@ -697,27 +560,107 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	}
  
 	/**
+	 * Get the singleton instance of LiteLoader, initialises the loader if
+	 * necessary
+	 * 
+	 * @param locationProvider
+	 * @return LiteLoader instance
+	 */
+	public static final LiteLoader getInstance()
+	{
+		return LiteLoader.instance;
+	}
+	
+	/**
+	 * Get the LiteLoader logger object
+	 * 
+	 * @return
+	 */
+	public static final Logger getLogger()
+	{
+		return LiteLoader.logger;
+	}
+	
+	/**
+	 * Get the output stream which we are using for console output
+	 * 
+	 * @return
+	 */
+	public static final PrintStream getConsoleStream()
+	{
+		return LiteLoader.useStdOut ? System.out : System.err;
+	}
+	
+	/**
+	 * Get LiteLoader version
+	 * 
+	 * @return
+	 */
+	public static final String getVersion()
+	{
+		return LiteLoader.VERSION.getLoaderVersion();
+	}
+	
+	/**
+	 * Get the loader revision
+	 * 
+	 * @return
+	 */
+	public static final int getRevision()
+	{
+		return LiteLoader.VERSION.getLoaderRevision();
+	}
+	
+	/**
+	 * @return
+	 */
+	public static PermissionsManagerClient getPermissionsManager()
+	{
+		return LiteLoader.getInstance().permissionsManager;
+	}
+	
+	/**
+	 * Get the event manager
+	 * 
+	 * @return
+	 */
+	public static Events getEvents()
+	{
+		return LiteLoader.getInstance().events;
+	}
+	
+	/**
+	 * Get the plugin channel manager
+	 * 
+	 * @return
+	 */
+	public static PluginChannels getPluginChannels()
+	{
+		return LiteLoader.getInstance().pluginChannels;
+	}
+
+	/**
 	 * Get the "mods" folder
 	 */
-	public File getModsFolder()
+	public static File getModsFolder()
 	{
-		return this.modsFolder;
+		return LiteLoader.getInstance().modsFolder;
 	}
  
 	/**
 	 * Get the common (version-independent) config folder
 	 */
-	public File getCommonConfigFolder()
+	public static File getCommonConfigFolder()
 	{
-		return this.commonConfigFolder;
+		return LiteLoader.getInstance().commonConfigFolder;
 	}
  
 	/**
 	 * Get the config folder for this version
 	 */
-	public File getConfigFolder()
+	public static File getConfigFolder()
 	{
-		return this.versionConfigFolder;
+		return LiteLoader.getInstance().versionConfigFolder;
 	}
  
 	/**
@@ -761,7 +704,15 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	{
 		return Collections.unmodifiableList(this.loadedMods);
 	}
-
+	
+	/**
+	 * Get a list containing all mod files which were NOT loaded
+	 */
+	public List<ModFile> getDisabledMods()
+	{
+		return Collections.unmodifiableList(this.disabledMods);
+	}
+	
 	/**
 	 * Used to get the name of the modpack being used
 	 * 
@@ -868,7 +819,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	}
  
 	/**
-	 * Get metadata for the specified mod, attempts to retrieve the mod by name first
+	 * Get a metadata value for the specified mod
 	 * 
 	 * @param mod
 	 * @param metaDataKey
@@ -893,24 +844,45 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	public String getModMetaData(LiteMod mod, String metaDataKey, String defaultValue)
 	{
 		if (mod == null || metaDataKey == null) return defaultValue;
-		
-		String modClassName = mod.getClass().getSimpleName();
-		if (!this.modFiles.containsKey(modClassName)) return defaultValue;
-		
-		ModFile modFile = this.modFiles.get(modClassName);
-		return modFile.getMetaValue(metaDataKey, defaultValue);
+		return this.getModMetaData(mod.getClass(), metaDataKey, defaultValue);
+	}
+
+	/**
+	 * Get a metadata value for the specified mod
+	 * 
+	 * @param modClassName
+	 * @param metaDataKey
+	 * @param defaultValue
+	 * @return
+	 */
+	public String getModMetaData(Class<? extends LiteMod> modClass, String metaDataKey, String defaultValue)
+	{
+		ModFile modFile = this.getModFile(modClass);
+		return modFile != null ? modFile.getMetaValue(metaDataKey, defaultValue) : defaultValue;
 	}
  
 	/**
 	 * @param mod
 	 * @return
 	 */
-	private ModFile getModFile(LiteMod mod)
+	private ModFile getModFile(Class<? extends LiteMod> modClass)
 	{
-		String modClassName = mod.getClass().getSimpleName();
-		return this.modFiles.containsKey(modClassName) ? this.modFiles.get(modClassName) : null;
+		return this.modFiles.get(modClass.getSimpleName());
 	}
-	
+
+	/**
+	 * Get the mod "name" metadata key, this is used for versioning, exclusivity, and enablement checks
+	 * 
+	 * @param modClass
+	 * @return
+	 */
+	public String getModMetaName(Class<? extends LiteMod> modClass)
+	{
+		String modClassName = modClass.getSimpleName();
+		if (!this.modFiles.containsKey(modClassName)) return null;
+		return this.modFiles.get(modClassName).getModName().toLowerCase();
+	}
+
 	/**
 	 * Enumerate the java class path and "mods" folder to find mod classes, then
 	 * load the classes
@@ -926,37 +898,35 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			File modFolder = this.getModsFolder();
 			if (modFolder.exists() && modFolder.isDirectory())
 			{
-				logger.info("Mods folder found, searching " + modFolder.getPath());
+				LiteLoader.getLogger().info("Mods folder found, searching " + modFolder.getPath());
 				this.findModFiles(modFolder, modFiles);
-				logger.info("Found " + modFiles.size() + " mod file(s)");
+				LiteLoader.getLogger().info("Found " + modFiles.size() + " mod file(s)");
 			}
 		}
  
 		try
 		{
-			logger.info("Enumerating class path...");
+			LiteLoader.getLogger().info("Enumerating class path...");
  
 			String classPath = System.getProperty("java.class.path");
 			String classPathSeparator = System.getProperty("path.separator");
 			String[] classPathEntries = classPath.split(classPathSeparator);
  
-			logger.info(String.format("Class path separator=\"%s\"", classPathSeparator));
-			logger.info(String.format("Class path entries=(\n   classpathEntry=%s\n)", classPath.replace(classPathSeparator, "\n   classpathEntry=")));
+			LiteLoader.getLogger().info(String.format("Class path separator=\"%s\"", classPathSeparator));
+			LiteLoader.getLogger().info(String.format("Class path entries=(\n   classpathEntry=%s\n)", classPath.replace(classPathSeparator, "\n   classpathEntry=")));
  
 			if (searchProtectionDomain || searchClassPath)
-				logger.info("Discovering mods on class path...");
+				getLogger().info("Discovering mods on class path...");
  
-			this.findModClasses(classPathEntries, modFiles, searchProtectionDomain, searchClassPath);
+			this.findModClasses(modFiles, searchProtectionDomain, searchClassPath, classPathEntries);
  
-			logger.info("Mod class discovery completed");
+			LiteLoader.getLogger().info("Mod class discovery completed");
 		}
 		catch (Throwable th)
 		{
-			logger.log(Level.WARNING, "Mod class discovery failed", th);
+			LiteLoader.getLogger().log(Level.WARNING, "Mod class discovery failed", th);
 			return;
 		}
-		
-		this.loadMods();
 	}
  
 	/**
@@ -978,11 +948,12 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 				// Check for a version file
 				ZipFile modZip = new ZipFile(modFile);
 				ZipEntry version = modZip.getEntry("litemod.json");
-				
-				if (version == null)
-				{
-					version = modZip.getEntry("version.txt");
-				}
+
+				// Not supporting this past 1.6.2
+//				if (version == null)
+//				{
+//					version = modZip.getEntry("version.txt");
+//				}
  
 				if (version != null)
 				{
@@ -1003,7 +974,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 					}
 					catch (Exception ex)
 					{
-						logger.warning("Error reading version data from " + modFile.getName());
+						LiteLoader.getLogger().warning("Error reading version data from " + modFile.getName());
 					}
 					finally
 					{
@@ -1020,10 +991,10 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 							// to successfully add it to the class path
 							if (LiteLoader.VERSION.isVersionSupported(modFileInfo.getVersion()))
 							{
-								if (!modFileInfo.isJson())
-								{
-									logger.warning("Missing or invalid litemod.json reading mod file: " + modFile.getAbsolutePath());
-								}
+//								if (!modFileInfo.isJson())
+//								{
+//									logger.warning("Missing or invalid litemod.json reading mod file: " + modFile.getAbsolutePath());
+//								}
  
 								if (!versionOrderingSets.containsKey(modFileInfo.getName()))
 								{
@@ -1034,18 +1005,26 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 							}
 							else
 							{
-								logger.info("Not adding invalid or outdated mod file: " + modFile.getAbsolutePath());
+								LiteLoader.getLogger().info("Not adding invalid or outdated mod file: " + modFile.getAbsolutePath());
 							}
 						}
 					}
 				}
+				else
+				{
+					ZipEntry legacyVersion = modZip.getEntry("version.txt");
+					if (legacyVersion != null)
+					{
+						LiteLoader.getLogger().warning("version.txt is no longer supported, ignoring outdated mod file: " + modFile.getAbsolutePath());
+					}
+				}
  
 				modZip.close();
 			}
 			catch (Exception ex)
 			{
 				ex.printStackTrace(System.err);
-				logger.warning("Error enumerating '" + modFile.getAbsolutePath() + "': Invalid zip file or error reading file");
+				LiteLoader.getLogger().warning("Error enumerating '" + modFile.getAbsolutePath() + "': Invalid zip file or error reading file");
 			}
 		}
  
@@ -1056,14 +1035,12 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
  
 			try
 			{
-				if (this.addURLToClassPath(newestVersion.toURI().toURL()))
-				{
-					modFiles.add(newestVersion);
-				}
+				LiteLoader.classLoader.addURL(newestVersion.toURI().toURL());
+				modFiles.add(newestVersion);
 			}
 			catch (Exception ex)
 			{
-				logger.warning("Error injecting '" + newestVersion.getAbsolutePath() + "' into classPath. The mod will not be loaded");
+				LiteLoader.getLogger().warning("Error injecting '" + newestVersion.getAbsolutePath() + "' into classPath. The mod will not be loaded");
 			}
 		}
 	}
@@ -1081,10 +1058,9 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
  
 	/**
 	 * Find mod classes in the class path and enumerated mod files list
-	 * 
 	 * @param classPathEntries Java class path split into string entries
 	 */
-	private void findModClasses(String[] classPathEntries, List<ModFile> modFiles, boolean searchProtectionDomain, boolean searchClassPath)
+	private void findModClasses(List<ModFile> modFiles, boolean searchProtectionDomain, boolean searchClassPath, String[] classPathEntries)
 	{
 		if (searchProtectionDomain)
 		{
@@ -1094,7 +1070,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			}
 			catch (Throwable th)
 			{
-				logger.warning("Error loading from local class path: " + th.getMessage());
+				LiteLoader.getLogger().warning("Error loading from local class path: " + th.getMessage());
 			}
 		}
  
@@ -1117,7 +1093,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	@SuppressWarnings("unchecked")
 	private void searchProtectionDomain() throws MalformedURLException, URISyntaxException, UnsupportedEncodingException
 	{
-		logger.info("Searching protection domain code source...");
+		LiteLoader.getLogger().info("Searching protection domain code source...");
  
 		File packagePath = null;
  
@@ -1152,14 +1128,14 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			{
 				if (this.modsToLoad.containsKey(mod.getSimpleName()))
 				{
-					logger.warning("Mod name collision for mod with class '" + mod.getSimpleName() + "', maybe you have more than one copy?");
+					LiteLoader.getLogger().warning("Mod name collision for mod with class '" + mod.getSimpleName() + "', maybe you have more than one copy?");
 				}
  
 				this.modsToLoad.put(mod.getSimpleName(), (Class<? extends LiteMod>)mod);
 			}
  
 			if (modClasses.size() > 0)
-				logger.info(String.format("Found %s potential matches", modClasses.size()));
+				LiteLoader.getLogger().info(String.format("Found %s potential matches", modClasses.size()));
 		}
 	}
  
@@ -1172,7 +1148,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	{
 		for (String classPathPart : classPathEntries)
 		{
-			logger.info(String.format("Searching %s...", classPathPart));
+			LiteLoader.getLogger().info(String.format("Searching %s...", classPathPart));
  
 			File packagePath = new File(classPathPart);
 			LinkedList<Class<?>> modClasses = getSubclassesFor(packagePath, Minecraft.class.getClassLoader(), LiteMod.class, "LiteMod");
@@ -1181,7 +1157,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			{
 				if (this.modsToLoad.containsKey(mod.getSimpleName()))
 				{
-					logger.warning("Mod name collision for mod with class '" + mod.getSimpleName() + "', maybe you have more than one copy?");
+					LiteLoader.getLogger().warning("Mod name collision for mod with class '" + mod.getSimpleName() + "', maybe you have more than one copy?");
 				}
  
 				this.modsToLoad.put(mod.getSimpleName(), (Class<? extends LiteMod>)mod);
@@ -1189,7 +1165,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			}
  
 			if (modClasses.size() > 0)
-				logger.info(String.format("Found %s potential matches", modClasses.size()));
+				LiteLoader.getLogger().info(String.format("Found %s potential matches", modClasses.size()));
 		}
 	}
  
@@ -1202,15 +1178,15 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	{
 		for (ModFile modFile : modFiles)
 		{
-			logger.info(String.format("Searching %s...", modFile.getAbsolutePath()));
+			LiteLoader.getLogger().info(String.format("Searching %s...", modFile.getAbsolutePath()));
  
-			LinkedList<Class<?>> modClasses = getSubclassesFor(modFile, Minecraft.class.getClassLoader(), LiteMod.class, "LiteMod");
+			LinkedList<Class<?>> modClasses = LiteLoader.getSubclassesFor(modFile, Minecraft.class.getClassLoader(), LiteMod.class, "LiteMod");
  
 			for (Class<?> mod : modClasses)
 			{
 				if (this.modsToLoad.containsKey(mod.getSimpleName()))
 				{
-					logger.warning("Mod name collision for mod with class '" + mod.getSimpleName() + "', maybe you have more than one copy?");
+					LiteLoader.getLogger().warning("Mod name collision for mod with class '" + mod.getSimpleName() + "', maybe you have more than one copy?");
 				}
  
 				this.modsToLoad.put(mod.getSimpleName(), (Class<? extends LiteMod>)mod);
@@ -1218,7 +1194,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			}
  
 			if (modClasses.size() > 0)
-				logger.info(String.format("Found %s potential matches", modClasses.size()));
+				LiteLoader.getLogger().info(String.format("Found %s potential matches", modClasses.size()));
 		}
 	}
  
@@ -1231,85 +1207,72 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	{
 		if (this.modsToLoad == null)
 		{
-			logger.info("Mod class discovery failed. Not loading any mods!");
+			LiteLoader.getLogger().info("Mod class discovery failed. Not loading any mods!");
 			return;
 		}
  
-		logger.info("Discovered " + this.modsToLoad.size() + " total mod(s)");
+		LiteLoader.getLogger().info("Discovered " + this.modsToLoad.size() + " total mod(s)");
  
 		this.pendingResourceReload = false;
-		this.soundManagerReloadInhibitor = new SoundManagerReloadInhibitor((SimpleReloadableResourceManager)minecraft.func_110442_L(), minecraft.sndManager); // TODO adamsrc -> getResourceManager
-		if (this.inhibitSoundManagerReload) this.soundManagerReloadInhibitor.inhibit();
+		this.soundManagerReloadInhibitor = new SoundManagerReloadInhibitor((SimpleReloadableResourceManager)this.minecraft.getResourceManager(), this.minecraft.sndManager);
+//		if (this.inhibitSoundManagerReload) this.soundManagerReloadInhibitor.inhibit();
  
 		for (Class<? extends LiteMod> mod : this.modsToLoad.values())
 		{
 			try
 			{
-				logger.info("Loading mod from " + mod.getName());
-				
-				LiteMod newMod = mod.newInstance();
-				
-				if (this.shouldAddMod(newMod))
+				String metaName = this.getModMetaName(mod);
+				if (metaName == null || this.enabledModsList.isEnabled(this.profile, metaName))
 				{
+					LiteLoader.getLogger().info(String.format("Loading mod from %s", mod.getName()));
+					
+					LiteMod newMod = mod.newInstance();
+					
 					this.mods.add(newMod);
-					logger.info("Successfully added mod " + newMod.getName() + " version " + newMod.getVersion());
+					LiteLoader.getLogger().info(String.format("Successfully added mod %s version %s", newMod.getName(), newMod.getVersion()));
  
 					// Get the mod file and register it as a resource pack if it exists
-					ModFile modFile = this.getModFile(newMod);
-					if (modFile != null && modFile.registerAsResourcePack(newMod.getName()))
+					ModFile modFile = this.getModFile(mod);
+					if (modFile != null)
 					{
-						logger.info("Adding " + modFile.getAbsolutePath() + " to resources list");
+						this.disabledMods.remove(modFile);
+						
+						if (modFile.registerAsResourcePack(newMod.getName()))
+						{
+							LiteLoader.getLogger().info(String.format("Successfully added \"%s\" to active resource pack set", modFile.getAbsolutePath()));
+						}
 					}
 				}
 				else
 				{
-					logger.info("Not loading mod " + newMod.getName() + ", excluded by filter");
+					LiteLoader.getLogger().info(String.format("Not loading mod %s, excluded by filter", metaName));
+					this.disabledMods.add(this.getModFile(mod));
 				}
 			}
 			catch (Throwable th)
 			{
-				logger.warning(th.toString());
+				LiteLoader.getLogger().warning(th.toString());
 				th.printStackTrace();
 			}
 		}
 	}
  
 	/**
-	 * @param name
-	 * @return
+	 * Initialise the mods which were loaded
 	 */
-	private boolean shouldAddMod(LiteMod mod)
+	private void initMods()
 	{
-		if (this.modNameFilter == null) return true;
+		this.loadedModsList = "";
+		int loadedModsCount = 0;
  
-		String modClassName = mod.getClass().getSimpleName();
-		if (!this.modFiles.containsKey(modClassName)) return true;
-
-		String metaName = this.modFiles.get(modClassName).getModName().toLowerCase();
-		if (this.modNameFilter.contains(metaName))
-		{
-			return true;
-		}
-		
-		return false;
-	}
-
-	/**
-	 * Initialise the mods which were loaded
-	 */
-	private void initMods()
-	{
-		this.loadedModsList = "";
-		int loadedModsCount = 0;
-		
-		for (Iterator<LiteMod> iter = this.mods.iterator(); iter.hasNext();)
+		for (Iterator<LiteMod> iter = this.mods.iterator(); iter.hasNext();)
 		{
 			LiteMod mod = iter.next();
 			String modName = mod.getName();
  
 			try
 			{
-				logger.info("Initialising mod " + modName + " version " + mod.getVersion());
+				LiteLoader.getLogger().info("Initialising mod " + modName + " version " + mod.getVersion());
  
 				try
 				{
@@ -1318,81 +1281,21 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
  
 					if (LiteLoader.VERSION.getLoaderRevision() > lastModVersion.getLoaderRevision())
 					{
-						logger.info("Performing config upgrade for mod " + modName + ". Upgrading " + lastModVersion + " to " + LiteLoader.VERSION + "...");
+						LiteLoader.getLogger().info("Performing config upgrade for mod " + modName + ". Upgrading " + lastModVersion + " to " + LiteLoader.VERSION + "...");
 						mod.upgradeSettings(VERSION.getMinecraftVersion(), this.versionConfigFolder, this.inflectVersionedConfigPath(lastModVersion));
  
 						this.storeLastKnownModRevision(modKey);
-						logger.info("Config upgrade succeeded for mod " + modName);
+						LiteLoader.getLogger().info("Config upgrade succeeded for mod " + modName);
 					}
 				}
 				catch (Throwable th)
 				{
-					logger.warning("Error performing settings upgrade for " + modName + ". Settings may not be properly migrated");
+					LiteLoader.getLogger().warning("Error performing settings upgrade for " + modName + ". Settings may not be properly migrated");
 				}
  
 				mod.init(this.modsFolder);
  
-				if (mod instanceof Tickable)
-				{
-					this.addTickListener((Tickable)mod);
-				}
-				
-				if (mod instanceof GameLoopListener)
-				{
-					this.addLoopListener((GameLoopListener)mod);
-				}
-				
-				if (mod instanceof InitCompleteListener)
-				{
-					this.addInitListener((InitCompleteListener)mod);
-				}
-				
-				if (mod instanceof RenderListener)
-				{
-					this.addRenderListener((RenderListener)mod);
-				}
-				
-				if (mod instanceof PostRenderListener)
-				{
-					this.addPostRenderListener((PostRenderListener)mod);
-				}
-				
-				if (mod instanceof ChatFilter)
-				{
-					this.addChatFilter((ChatFilter)mod);
-				}
-				
-				if (mod instanceof ChatListener)
-				{
-					if (mod instanceof ChatFilter)
-					{
-						this.logger.warning(String.format("Interface error initialising mod '%1s'. A mod implementing ChatFilter and ChatListener is not supported! Remove one of these interfaces", modName));
-					}
-					else
-					{
-						this.addChatListener((ChatListener)mod);
-					}
-				}
-				
-				if (mod instanceof ChatRenderListener)
-				{
-					this.addChatRenderListener((ChatRenderListener)mod);
-				}
-				
-				if (mod instanceof PreLoginListener)
-				{
-					this.addPreLoginListener((PreLoginListener)mod);
-				}
-				
-				if (mod instanceof LoginListener)
-				{
-					this.addLoginListener((LoginListener)mod);
-				}
-				
-				if (mod instanceof PluginChannelListener)
-				{
-					this.addPluginChannelListener((PluginChannelListener)mod);
-				}
+				this.events.addListener(mod);
  
 				if (mod instanceof Permissible)
 				{
@@ -1405,7 +1308,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			}
 			catch (Throwable th)
 			{
-				logger.log(Level.WARNING, "Error initialising mod '" + modName, th);
+				LiteLoader.getLogger().log(Level.WARNING, "Error initialising mod '" + modName, th);
 				iter.remove();
 			}
 		}
@@ -1414,198 +1317,6 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 	}
  
 	/**
-	 * Initialise mod hooks
-	 */
-	private void initHooks()
-	{
-		try
-		{
-			// Chat hook
-			if ((this.chatListeners.size() > 0 || this.chatFilters.size() > 0) && !this.chatHooked)
-			{
-				this.chatHooked = true;
-				HookChat.register();
-				HookChat.registerPacketHandler(this);
-			}
-			
-			// Login hook
-			if ((this.preLoginListeners.size() > 0 || this.loginListeners.size() > 0) && !this.loginHooked)
-			{
-				this.loginHooked = true;
-				ModUtilities.registerPacketOverride(1, HookLogin.class);
-				HookLogin.loader = this;
-			}
-			
-			// Plugin channels hook
-			if (this.pluginChannelListeners.size() > 0 && !this.pluginChannelHooked)
-			{
-				this.pluginChannelHooked = true;
-				HookPluginChannels.register();
-				HookPluginChannels.registerPacketHandler(this);
-			}
-			
-			// Tick hook
-			if (!this.tickHooked)
-			{
-				this.tickHooked = true;
-				PrivateFields.minecraftProfiler.setFinal(this.minecraft, this.profilerHook);
-			}
-			
-			// Sanity hook
-			PlayerUsageSnooper snooper = this.minecraft.getPlayerUsageSnooper();
-			PrivateFields.playerStatsCollector.setFinal(snooper, this);
-		}
-		catch (Exception ex)
-		{
-			logger.log(Level.WARNING, "Error creating hooks", ex);
-			ex.printStackTrace();
-		}
-	}
-	
-	/**
-	 * @param tickable
-	 */
-	public void addTickListener(Tickable tickable)
-	{
-		if (!this.tickListeners.contains(tickable))
-		{
-			this.tickListeners.add(tickable);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param loopListener
-	 */
-	public void addLoopListener(GameLoopListener loopListener)
-	{
-		if (!this.loopListeners.contains(loopListener))
-		{
-			this.loopListeners.add(loopListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param initCompleteListener
-	 */
-	public void addInitListener(InitCompleteListener initCompleteListener)
-	{
-		if (!this.initListeners.contains(initCompleteListener))
-		{
-			this.initListeners.add(initCompleteListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param tickable
-	 */
-	public void addRenderListener(RenderListener tickable)
-	{
-		if (!this.renderListeners.contains(tickable))
-		{
-			this.renderListeners.add(tickable);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param tickable
-	 */
-	public void addPostRenderListener(PostRenderListener tickable)
-	{
-		if (!this.postRenderListeners.contains(tickable))
-		{
-			this.postRenderListeners.add(tickable);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param chatFilter
-	 */
-	public void addChatFilter(ChatFilter chatFilter)
-	{
-		if (!this.chatFilters.contains(chatFilter))
-		{
-			this.chatFilters.add(chatFilter);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param chatListener
-	 */
-	public void addChatListener(ChatListener chatListener)
-	{
-		if (!this.chatListeners.contains(chatListener))
-		{
-			this.chatListeners.add(chatListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param chatRenderListener
-	 */
-	public void addChatRenderListener(ChatRenderListener chatRenderListener)
-	{
-		if (!this.chatRenderListeners.contains(chatRenderListener))
-		{
-			this.chatRenderListeners.add(chatRenderListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param loginListener
-	 */
-	public void addPreLoginListener(PreLoginListener loginListener)
-	{
-		if (!this.preLoginListeners.contains(loginListener))
-		{
-			this.preLoginListeners.add(loginListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param loginListener
-	 */
-	public void addLoginListener(LoginListener loginListener)
-	{
-		if (!this.loginListeners.contains(loginListener))
-		{
-			this.loginListeners.add(loginListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
-	 * @param pluginChannelListener
-	 */
-	public void addPluginChannelListener(PluginChannelListener pluginChannelListener)
-	{
-		if (!this.pluginChannelListeners.contains(pluginChannelListener))
-		{
-			this.pluginChannelListeners.add(pluginChannelListener);
-			if (this.loaderStartupComplete)
-				this.initHooks();
-		}
-	}
-	
-	/**
 	 * Enumerate classes on the classpath which are subclasses of the specified
 	 * class
 	 * 
@@ -1629,7 +1340,7 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 		}
 		catch (Throwable th)
 		{
-			logger.log(Level.WARNING, "Enumeration error", th);
+			LiteLoader.getLogger().log(Level.WARNING, "Enumeration error", th);
 		}
  
 		return classes;
@@ -1747,72 +1458,32 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 		}
 		catch (Throwable th)
 		{
-			logger.log(Level.WARNING, "checkAndAddClass error", th);
+			LiteLoader.getLogger().log(Level.WARNING, "checkAndAddClass error", th);
 		}
 	}
-	
-	/**
-	 * Add a URL to the Minecraft classloader class path
-	 * 
-	 * @param classUrl URL of the resource to add
-	 */
-	private boolean addURLToClassPath(URL classUrl)
+
+	public void refreshResources()
 	{
-		try
-		{
-			if (Minecraft.class.getClassLoader() instanceof URLClassLoader && this.mAddUrl != null && this.mAddUrl.isAccessible())
-			{
-				URLClassLoader classLoader = (URLClassLoader)Minecraft.class.getClassLoader();
-				this.mAddUrl.invoke(classLoader, classUrl);
-				return true;
-			}
-		}
-		catch (Throwable th)
+		if (this.pendingResourceReload)
 		{
-			logger.log(Level.WARNING, "Error adding class path entry", th);
+			this.pendingResourceReload = false;
+			this.minecraft.refreshResources();
 		}
-		
-		return false;
 	}
  
-	/**
-	 * Late initialisation callback
-	 */
 	public void onInit()
 	{
-		if (this.pendingResourceReload)
-		{
-			this.pendingResourceReload = false;
-			this.minecraft.func_110436_a(); // TODO adamsrc -> refreshResourcePacks
-		}
-		
-		if (!this.lateInitDone)
-		{
-			this.lateInitDone = true;
-			
-			for (InitCompleteListener initMod : this.initListeners)
-			{
-				try
-				{
-					logger.info("Calling late init for mod " + initMod.getName());
-					initMod.onInitCompleted(this.minecraft, this);
-				}
-				catch (Throwable th)
-				{
-					logger.log(Level.WARNING, "Error initialising mod " + initMod.getName(), th);
-				}
-			}
-		}
-
 		if (this.soundManagerReloadInhibitor != null && this.soundManagerReloadInhibitor.isInhibited())
 		{
 			this.soundManagerReloadInhibitor.unInhibit(true);
 		}
 	}
-	
-	/**
-	 * Callback from the tick hook, pre render
-	 */
+
+	public void onLogin(NetHandler netHandler, Packet1Login loginPacket)
+	{
+		this.permissionsManager.onLogin(netHandler, loginPacket);
+	}
+
 	public void onRender()
 	{
 		if (this.paginateControls && this.minecraft.currentScreen != null && this.minecraft.currentScreen.getClass().equals(GuiControls.class))
@@ -1827,431 +1498,191 @@ public final class LiteLoader implements FilenameFilter, IPlayerUsage
 			{
 			}
 		}
-		
-		for (RenderListener renderListener : this.renderListeners)
-			renderListener.onRender();
 	}
-	
-	/**
-	 * Callback from the tick hook, post render entities
-	 */
-	public void postRenderEntities()
-	{
-		float partialTicks = (this.minecraftTimer != null) ? this.minecraftTimer.elapsedPartialTicks : 0.0F;
-		
-		for (PostRenderListener renderListener : this.postRenderListeners)
-			renderListener.onPostRenderEntities(partialTicks);
-	}
-	
-	/**
-	 * Callback from the tick hook, post render
-	 */
-	public void postRender()
-	{
-		float partialTicks = (this.minecraftTimer != null) ? this.minecraftTimer.elapsedPartialTicks : 0.0F;
-		
-		for (PostRenderListener renderListener : this.postRenderListeners)
-			renderListener.onPostRender(partialTicks);
-	}
-	
-	/**
-	 * Called immediately before the current GUI is rendered
-	 */
-	public void onBeforeGuiRender()
-	{
-		for (RenderListener renderListener : this.renderListeners)
-			renderListener.onRenderGui(this.minecraft.currentScreen);
-	}
-	
-	/**
-	 * Called immediately after the world/camera transform is initialised
-	 */
-	public void onSetupCameraTransform()
-	{
-		for (RenderListener renderListener : this.renderListeners)
-			renderListener.onSetupCameraTransform();
-	}
-	
-	/**
-	 * Called immediately before the chat log is rendered
-	 */
-	public void onBeforeChatRender()
-	{
-		this.currentResolution = new ScaledResolution(this.minecraft.gameSettings, this.minecraft.displayWidth, this.minecraft.displayHeight);
-		int screenWidth = this.currentResolution.getScaledWidth();
-		int screenHeight = this.currentResolution.getScaledHeight();
-		
-		GuiNewChat chat = this.minecraft.ingameGUI.getChatGUI();
-		
-		for (ChatRenderListener chatRenderListener : this.chatRenderListeners)
-			chatRenderListener.onPreRenderChat(screenWidth, screenHeight, chat);
-	}
-	
-	/**
-	 * Called immediately after the chat log is rendered
-	 */
-	public void onAfterChatRender()
+
+	public void onTick(float partialTicks, boolean inGame)
 	{
-		int screenWidth = this.currentResolution.getScaledWidth();
-		int screenHeight = this.currentResolution.getScaledHeight();
-		
-		GuiNewChat chat = this.minecraft.ingameGUI.getChatGUI();
+		// Tick the permissions manager
+		permissionsManager.onTick(this.minecraft, partialTicks, inGame);
  
-		for (ChatRenderListener chatRenderListener : this.chatRenderListeners)
-			chatRenderListener.onPostRenderChat(screenWidth, screenHeight, chat);
+		this.checkAndStoreKeyBindings();
 	}
  
-	/**
-	 * Callback from the tick hook, called every frame when the timer is updated
-	 */
-	public void onTimerUpdate()
-	{
-		for (GameLoopListener loopListener : this.loopListeners)
-			loopListener.onRunGameLoop(this.minecraft);
-	}
-	
-	/**
-	 * Callback from the tick hook, ticks all tickable mods
-	 * 
-	 * @param tick True if this is a new tick (otherwise it's just a new frame)
-	 */
-	public void onTick(Profiler profiler, boolean tick)
+	public void registerModKey(KeyBinding binding)
 	{
-		float partialTicks = 0.0F;
-		
-		// Try to get the minecraft timer object and determine the value of the
-		// partialTicks
-		if (tick || this.minecraftTimer == null)
-		{
-			this.minecraftTimer = PrivateFields.minecraftTimer.get(this.minecraft);
-		}
-		
-		// Hooray, we got the timer reference
-		if (this.minecraftTimer != null)
-		{
-			partialTicks = this.minecraftTimer.renderPartialTicks;
-			tick = this.minecraftTimer.elapsedTicks > 0;
-		}
-		
-		// Flag indicates whether we are in game at the moment
-		boolean inGame = this.minecraft.renderViewEntity != null && this.minecraft.renderViewEntity.worldObj != null;
+		LinkedList<KeyBinding> keyBindings = new LinkedList<KeyBinding>();
+		keyBindings.addAll(Arrays.asList(this.minecraft.gameSettings.keyBindings));
  
-		if (tick)
+		if (!keyBindings.contains(binding))
 		{
-			// Tick the permissions manager
-			permissionsManager.onTick(this.minecraft, partialTicks, inGame);
+			if (this.keyMapSettings.containsKey(binding.keyDescription))
+			{
+				try
+				{
+					binding.keyCode = Integer.parseInt(this.keyMapSettings.getProperty(binding.keyDescription, String.valueOf(binding.keyCode)));
+				}
+				catch (NumberFormatException ex) {}
+			}
+
+			keyBindings.add(binding);
+			this.minecraft.gameSettings.keyBindings = keyBindings.toArray(new KeyBinding[0]);
+			this.modKeyBindings.add(binding);
  
-			this.checkAndStoreKeyBindings();
-		}
-		
-		// Iterate tickable mods
-		for (Tickable tickable : this.tickListeners)
-		{
-			profiler.startSection(tickable.getClass().getSimpleName());
-			tickable.onTick(this.minecraft, partialTicks, inGame, tick);
-			profiler.endSection();
+			this.updateBinding(binding);
+			this.storeBindings();
 		}
 	}
  
 	/**
-	 * Callback from the chat hook
-	 * 
-	 * @param chatPacket
-	 * @return
+	 * Checks for changed mod keybindings and stores any that have changed 
 	 */
-	public boolean onChat(Packet3Chat chatPacket)
+	private void checkAndStoreKeyBindings()
 	{
-		if (chatPacket.message == null)
-			return true;
-		
-		ChatMessageComponent chat = ChatMessageComponent.func_111078_c(chatPacket.message);
-		String message = chat.func_111068_a(true);
+		boolean updated = false;
  
-		// Chat filters get a stab at the chat first, if any filter returns
-		// false the chat is discarded
-		for (ChatFilter chatFilter : this.chatFilters)
+		for (KeyBinding binding : this.modKeyBindings)
 		{
-			if (chatFilter.onChat(chatPacket, chat, message))
-			{
-				chat = ChatMessageComponent.func_111078_c(chatPacket.message);
-				message = chat.func_111068_a(true);
-			}
-			else
+			if (binding.keyCode != this.storedModKeyBindings.get(binding))
 			{
-				return false;
+				this.updateBinding(binding);
+				updated = true;
 			}
 		}
  
-		// Chat listeners get the chat if no filter removed it
-		for (ChatListener chatListener : this.chatListeners)
-			chatListener.onChat(chat, message);
-		
-		return true;
+		if (updated)
+			this.storeBindings();
 	}
  
 	/**
-	 * Pre-login callback from the login hook
-	 * 
-	 * @param netHandler
-	 * @param hookLogin
-	 * @return
+	 * @param binding
 	 */
-	public boolean onPreLogin(NetHandler netHandler, Packet1Login loginPacket)
+	private void updateBinding(KeyBinding binding)
 	{
-		boolean cancelled = false;
-		
-		for (PreLoginListener loginListener : this.preLoginListeners)
-		{
-			cancelled |= !loginListener.onPreLogin(netHandler, loginPacket);
-		}
-		
-		return !cancelled;
+		this.keyMapSettings.setProperty(binding.keyDescription, String.valueOf(binding.keyCode));
+		this.storedModKeyBindings.put(binding, Integer.valueOf(binding.keyCode));
 	}
-	
+
 	/**
-	 * Callback from the login hook
-	 * 
-	 * @param netHandler
-	 * @param loginPacket
+	 * Writes mod bindings to disk
 	 */
-	public void onConnectToServer(NetHandler netHandler, Packet1Login loginPacket)
+	protected void storeBindings()
 	{
-		permissionsManager.onLogin(netHandler, loginPacket);
-		
-		for (LoginListener loginListener : this.loginListeners)
-			loginListener.onLogin(netHandler, loginPacket);
-		
-		this.setupPluginChannels();
+		try
+		{
+			this.keyMapSettings.store(new FileWriter(this.keyMapSettingsFile), "Mod key mappings for LiteLoader mods, stored here to avoid losing settings stored in options.txt");
+		}
+		catch (IOException ex) {}
 	}
  
 	/**
-	 * Callback for the plugin channel hook
+	 * Set the brand in ClientBrandRetriever to the specified brand 
 	 * 
-	 * @param hookPluginChannels
+	 * @param brand
 	 */
-	public void onPluginChannelMessage(HookPluginChannels hookPluginChannels)
+	private void setBranding(String brand)
 	{
-		if (hookPluginChannels != null && hookPluginChannels.channel != null && this.pluginChannels.containsKey(hookPluginChannels.channel))
+		try
 		{
-			try
-			{
-				permissionsManager.onCustomPayload(hookPluginChannels.channel, hookPluginChannels.length, hookPluginChannels.data);
-			}
-			catch (Exception ex)
-			{
-			}
+			String oldBrand = ClientBrandRetriever.getClientModName();
  
-			for (PluginChannelListener pluginChannelListener : this.pluginChannels.get(hookPluginChannels.channel))
+			if (oldBrand.equals("vanilla"))
 			{
+				char[] newValue = brand.toCharArray();
+				
+				Field stringValue = String.class.getDeclaredField("value");
+				stringValue.setAccessible(true);
+				stringValue.set(oldBrand, newValue);
+				
 				try
 				{
-					pluginChannelListener.onCustomPayload(hookPluginChannels.channel, hookPluginChannels.length, hookPluginChannels.data);
-				}
-				catch (Exception ex)
-				{
+					Field stringCount = String.class.getDeclaredField("count");
+					stringCount.setAccessible(true);
+					stringCount.set(oldBrand, newValue.length);
 				}
+				catch (NoSuchFieldException ex) {} // java 1.7 doesn't have this member
 			}
 		}
+		catch (Exception ex)
+		{
+			LiteLoader.getLogger().log(Level.WARNING, "Setting branding failed", ex);
+		}
 	}
+
+	// -----------------------------------------------------------------------------------------------------------
+	// TODO Remove delegates below after 1.6.3
+	// -----------------------------------------------------------------------------------------------------------
  
 	/**
-	 * Delegate to ModUtilities.sendPluginChannelMessage
+	 * Delegate to PluginChannels.sendMessage. Deprecated and will be removed
 	 * 
 	 * @param channel Channel to send data to
 	 * @param data Data to send
+	 * 
+	 * @deprecated User PluginChannels.sendMessage(channel, data) instead.
 	 */
+	@Deprecated
 	public void sendPluginChannelMessage(String channel, byte[] data)
 	{
-		ModUtilities.sendPluginChannelMessage(channel, data);
+		PluginChannels.sendMessage(channel, data);
 	}
-	
-	/**
-	 * Query loaded mods for registered channels
-	 */
-	protected void setupPluginChannels()
+
+	@Deprecated
+	public void addTickListener(Tickable tickable)
 	{
-		// Clear any channels from before
-		this.pluginChannels.clear();
-		
-		// Add the permissions manager channels
-		this.addPluginChannelsFor(permissionsManager);
-		
-		// Enumerate mods for plugin channels
-		for (PluginChannelListener pluginChannelListener : this.pluginChannelListeners)
-		{
-			this.addPluginChannelsFor(pluginChannelListener);
-		}
-		
-		// If any mods have registered channels, send the REGISTER packet
-		if (this.pluginChannels.keySet().size() > 0)
-		{
-			StringBuilder channelList = new StringBuilder();
-			boolean separator = false;
-			
-			for (String channel : this.pluginChannels.keySet())
-			{
-				if (separator)
-					channelList.append("\u0000");
-				channelList.append(channel);
-				separator = true;
-			}
-			
-			byte[] registrationData = channelList.toString().getBytes(Charset.forName("UTF8"));
-			
-			this.sendPluginChannelMessage("REGISTER", registrationData);
-		}
+		this.events.addTickListener(tickable);
 	}
  
-	/**
-	 * Adds plugin channels for the specified listener to the local channels
-	 * collection
-	 * 
-	 * @param pluginChannelListener
-	 */
-	private void addPluginChannelsFor(PluginChannelListener pluginChannelListener)
+	@Deprecated
+	public void addLoopListener(GameLoopListener loopListener)
 	{
-		List<String> channels = pluginChannelListener.getChannels();
-		
-		if (channels != null)
-		{
-			for (String channel : channels)
-			{
-				if (channel.length() > 16 || channel.toUpperCase().equals("REGISTER") || channel.toUpperCase().equals("UNREGISTER"))
-					continue;
-				
-				if (!this.pluginChannels.containsKey(channel))
-				{
-					this.pluginChannels.put(channel, new LinkedList<PluginChannelListener>());
-				}
-				
-				this.pluginChannels.get(channel).add(pluginChannelListener);
-			}
-		}
+		this.events.addLoopListener(loopListener);
 	}
  
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see
-	 * net.minecraft.src.IPlayerUsage#addServerStatsToSnooper(net.minecraft.
-	 * src.PlayerUsageSnooper)
-	 */
-	@Override
-	public void addServerStatsToSnooper(PlayerUsageSnooper var1)
+	@Deprecated
+	public void addInitListener(InitCompleteListener initCompleteListener)
 	{
-		this.minecraft.addServerStatsToSnooper(var1);
+		this.events.addInitListener(initCompleteListener);
 	}
  
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see
-	 * net.minecraft.src.IPlayerUsage#addServerTypeToSnooper(net.minecraft.src
-	 * .PlayerUsageSnooper)
-	 */
-	@Override
-	public void addServerTypeToSnooper(PlayerUsageSnooper var1)
+	@Deprecated
+	public void addRenderListener(RenderListener renderListener)
 	{
-		this.sanityCheck();
-		this.minecraft.addServerTypeToSnooper(var1);
+		this.events.addRenderListener(renderListener);
 	}
  
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see net.minecraft.src.IPlayerUsage#isSnooperEnabled()
-	 */
-	@Override
-	public boolean isSnooperEnabled()
+	@Deprecated
+	public void addPostRenderListener(PostRenderListener postRenderListener)
 	{
-		return this.minecraft.isSnooperEnabled();
+		this.events.addPostRenderListener(postRenderListener);
 	}
  
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see net.minecraft.src.IPlayerUsage#getLogAgent()
-	 */
-	@Override
-	public ILogAgent getLogAgent()
+	@Deprecated
+	public void addChatFilter(ChatFilter chatFilter)
 	{
-		return this.minecraft.getLogAgent();
+		this.events.addChatFilter(chatFilter);
 	}
  
-	/**
-	 * Check that the profiler hook hasn't been overridden by something else
-	 */
-	private void sanityCheck()
+	@Deprecated
+	public void addChatListener(ChatListener chatListener)
 	{
-		if (this.tickHooked && this.minecraft.mcProfiler != this.profilerHook)
-		{
-			PrivateFields.minecraftProfiler.setFinal(this.minecraft, this.profilerHook);
-		}
-	}
-
-	public void registerModKey(KeyBinding binding)
-	{
-		LinkedList<KeyBinding> keyBindings = new LinkedList<KeyBinding>();
-		keyBindings.addAll(Arrays.asList(this.minecraft.gameSettings.keyBindings));
-		
-		if (!keyBindings.contains(binding))
-		{
-			if (this.keyMapSettings.containsKey(binding.keyDescription))
-			{
-				try
-				{
-					binding.keyCode = Integer.parseInt(this.keyMapSettings.getProperty(binding.keyDescription, String.valueOf(binding.keyCode)));
-				}
-				catch (NumberFormatException ex) {}
-			}
-
-			keyBindings.add(binding);
-			this.minecraft.gameSettings.keyBindings = keyBindings.toArray(new KeyBinding[0]);
-			this.modKeys.add(binding);
-			
-			this.updateBinding(binding);
-			this.storeBindings();
-		}
+		this.events.addChatListener(chatListener);
 	}
  
-	/**
-	 * Checks for changed mod keybindings and stores any that have changed 
-	 */
-	private void checkAndStoreKeyBindings()
+	@Deprecated
+	public void addChatRenderListener(ChatRenderListener chatRenderListener)
 	{
-		boolean updated = false;
-		
-		for (KeyBinding binding : this.modKeys)
-		{
-			if (binding.keyCode != this.storedModKeyBindings.get(binding))
-			{
-				this.updateBinding(binding);
-				updated = true;
-			}
-		}
-		
-		if (updated)
-			this.storeBindings();
+		this.events.addChatRenderListener(chatRenderListener);
 	}
  
-	/**
-	 * @param binding
-	 */
-	private void updateBinding(KeyBinding binding)
+	@Deprecated
+	public void addPreLoginListener(PreLoginListener loginListener)
 	{
-		this.keyMapSettings.setProperty(binding.keyDescription, String.valueOf(binding.keyCode));
-		this.storedModKeyBindings.put(binding, Integer.valueOf(binding.keyCode));
+		this.events.addPreLoginListener(loginListener);
 	}
  
-	/**
-	 * Writes mod bindings to disk
-	 */
-	protected void storeBindings()
+	@Deprecated
+	public void addLoginListener(LoginListener loginListener)
 	{
-		try
-		{
-			this.keyMapSettings.store(new FileWriter(this.keyMapSettingsFile), "Mod key mappings for LiteLoader mods, stored here to avoid losing settings stored in options.txt");
-		}
-		catch (IOException ex) {}
+		this.events.addLoginListener(loginListener);
 	}
 }
 \ No newline at end of file
@@ -7,7 +7,7 @@ import java.util.Set;
  * LiteLoader version table
  *
  * @author Adam Mummery-Smith
- * @version 1.6.2_04
+ * @version 1.6.3
  */
 public enum LiteLoaderVersion
 {
@@ -17,8 +17,9 @@ public enum LiteLoaderVersion
 	MC_1_6_1_R0(11, "1.6.1", "1.6.1", "1.6.1", "1.6.r1"),
 	MC_1_6_2_R0(12, "1.6.2", "1.6.2", "1.6.2", "1.6.r2"),
 	MC_1_6_2_R1(13, "1.6.2", "1.6.2_02", "1.6.2", "1.6.r2"),
-	MC_1_6_2_R2(13, "1.6.2", "1.6.2_03", "1.6.2", "1.6.r2"),
-	MC_1_6_2_R3(13, "1.6.2", "1.6.2_04", "1.6.2", "1.6.r2");
+	MC_1_6_2_R2(14, "1.6.2", "1.6.2_03", "1.6.2", "1.6.r2"),
+	MC_1_6_2_R3(15, "1.6.2", "1.6.2_04", "1.6.2", "1.6.r2"),
+	MC_1_6_3_R0(16, "1.6.3", "1.6.3", "1.6.3", "1.6.r3");
  
 	private int revision;
  
@@ -34,7 +34,7 @@ public class ModFile extends File
 	/**
 	 * True if parsed from JSON, false if fallback mode using legacy version.txt
 	 */
-	protected boolean json = false;
+//	protected boolean json = false;
  
 	/**
 	 * Name of the mod specified in the JSON file, this can be any string but should be the same between mod versions
@@ -88,8 +88,8 @@ public class ModFile extends File
 	protected void parseVersionFile(String strVersionData)
 	{
 		// Assume that it's json if the file starts with a brace
-		if (strVersionData.trim().startsWith("{"))
-		{
+//		if (strVersionData.trim().startsWith("{"))
+//		{
 			try
 			{
 				this.metaData = ModFile.gson.fromJson(strVersionData, HashMap.class);
@@ -120,14 +120,14 @@ public class ModFile extends File
 			}
  
 			this.valid = true;
-			this.json = true;
-		}
-		else
-		{
-			// Legacy version.txt file
-			this.version = strVersionData;
-			this.valid = true;
-		}
+//			this.json = true;
+//		}
+//		else
+//		{
+//			// Legacy version.txt file
+//			this.version = strVersionData;
+//			this.valid = true;
+//		}
  
 		if (this.modName == null)
 		{
@@ -145,10 +145,10 @@ public class ModFile extends File
 		return this.valid;
 	}
  
-	public boolean isJson()
-	{
-		return this.json;
-	}
+//	public boolean isJson()
+//	{
+//		return this.json;
+//	}
  
 	public String getVersion()
 	{
@@ -180,6 +180,7 @@ public class ModFile extends File
 	{
 		if (this.resourcePack == null)
 		{
+			LiteLoader.getLogger().info(String.format("Registering \"%s\" as mod resource pack with identifier \"%s\"", this.getName(), name));
 			this.resourcePack = new ModResourcePack(name, this);
 			return LiteLoader.getInstance().registerModResourcePack(this.resourcePack);
 		}
+package com.mumfrey.liteloader.core;
+
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.src.Minecraft;
+import net.minecraft.src.NetHandler;
+import net.minecraft.src.Packet1Login;
+import net.minecraft.src.Packet250CustomPayload;
+
+import com.mumfrey.liteloader.PluginChannelListener;
+import com.mumfrey.liteloader.core.hooks.HookPluginChannels;
+import com.mumfrey.liteloader.permissions.PermissionsManagerClient;
+
+/**
+ * Manages plugin channel connections and subscriptions for LiteLoader
+ *
+ * @author Adam Mummery-Smith
+ */
+public class PluginChannels
+{
+	// reserved channel consts
+	private static final String CHANNEL_REGISTER = "REGISTER";
+	private static final String CHANNEL_UNREGISTER = "UNREGISTER";
+
+	/**
+	 * Reference to the loader
+	 */
+	private LiteLoader loader;
+	
+	/**
+	 * True if we have initialised the hook
+	 */
+	private boolean hookInitDone;
+	
+	/**
+	 * Mapping of plugin channel names to listeners
+	 */
+	private HashMap<String, LinkedList<PluginChannelListener>> pluginChannels = new HashMap<String, LinkedList<PluginChannelListener>>();
+	
+	/**
+	 * List of mods which implement PluginChannelListener interface
+	 */
+	private LinkedList<PluginChannelListener> pluginChannelListeners = new LinkedList<PluginChannelListener>();
+
+	/**
+	 * @param loader
+	 */
+	public PluginChannels(LiteLoader loader)
+	{
+		this.loader = loader;
+	}
+
+	/**
+	 * 
+	 */
+	public void initHook()
+	{
+		// Plugin channels hook
+		if (this.pluginChannelListeners.size() > 0 && !this.hookInitDone)
+		{
+			HookPluginChannels.register();
+			HookPluginChannels.registerPacketHandler(this);
+			this.hookInitDone = true;
+		}
+	}
+	
+	
+	/**
+	 * @param pluginChannelListener
+	 */
+	public void addPluginChannelListener(PluginChannelListener pluginChannelListener)
+	{
+		if (!this.pluginChannelListeners.contains(pluginChannelListener))
+		{
+			this.pluginChannelListeners.add(pluginChannelListener);
+			if (this.hookInitDone)
+				this.initHook();
+		}
+	}
+
+	/**
+	 * @param netHandler
+	 * @param loginPacket
+	 */
+	public void onConnectToServer(NetHandler netHandler, Packet1Login loginPacket)
+	{
+		this.setupPluginChannels();
+	}
+
+	/**
+	 * Callback for the plugin channel hook
+	 * 
+	 * @param customPayload
+	 */
+	public void onPluginChannelMessage(Packet250CustomPayload customPayload)
+	{
+		if (customPayload != null && customPayload.channel != null && this.pluginChannels.containsKey(customPayload.channel))
+		{
+			try
+			{
+				PermissionsManagerClient permissionsManager = this.loader.getPermissionsManager();
+				if (permissionsManager != null)
+				{
+					permissionsManager.onCustomPayload(customPayload.channel, customPayload.length, customPayload.data);
+				}
+			}
+			catch (Exception ex) {}
+			
+			for (PluginChannelListener pluginChannelListener : this.pluginChannels.get(customPayload.channel))
+			{
+				try
+				{
+					pluginChannelListener.onCustomPayload(customPayload.channel, customPayload.length, customPayload.data);
+				}
+				catch (Exception ex) {}
+			}
+		}
+	}
+	
+	/**
+	 * Query loaded mods for registered channels
+	 */
+	protected void setupPluginChannels()
+	{
+		// Clear any channels from before
+		this.pluginChannels.clear();
+		
+		// Add the permissions manager channels
+		this.addPluginChannelsFor(this.loader.getPermissionsManager());
+		
+		// Enumerate mods for plugin channels
+		for (PluginChannelListener pluginChannelListener : this.pluginChannelListeners)
+		{
+			this.addPluginChannelsFor(pluginChannelListener);
+		}
+		
+		// If any mods have registered channels, send the REGISTER packet
+		if (this.pluginChannels.keySet().size() > 0)
+		{
+			StringBuilder channelList = new StringBuilder();
+			boolean separator = false;
+			
+			for (String channel : this.pluginChannels.keySet())
+			{
+				if (separator) channelList.append("\u0000");
+				channelList.append(channel);
+				separator = true;
+			}
+			
+			byte[] registrationData = channelList.toString().getBytes(Charset.forName("UTF8"));
+			PluginChannels.sendMessage(CHANNEL_REGISTER, registrationData);
+		}
+	}
+	
+	/**
+	 * Adds plugin channels for the specified listener to the local channels
+	 * collection
+	 * 
+	 * @param pluginChannelListener
+	 */
+	private void addPluginChannelsFor(PluginChannelListener pluginChannelListener)
+	{
+		List<String> channels = pluginChannelListener.getChannels();
+		
+		if (channels != null)
+		{
+			for (String channel : channels)
+			{
+				if (channel.length() > 16 || channel.toUpperCase().equals(CHANNEL_REGISTER) || channel.toUpperCase().equals(CHANNEL_UNREGISTER))
+					continue;
+				
+				if (!this.pluginChannels.containsKey(channel))
+				{
+					this.pluginChannels.put(channel, new LinkedList<PluginChannelListener>());
+				}
+				
+				this.pluginChannels.get(channel).add(pluginChannelListener);
+			}
+		}
+	}
+	
+	public static void sendMessage(String channel, byte[] data)
+	{
+		if (channel == null || channel.length() > 16)
+			throw new RuntimeException("Invalid channel name specified"); 
+		
+		try
+		{
+			Minecraft minecraft = Minecraft.getMinecraft();
+			
+			if (minecraft.thePlayer != null && minecraft.thePlayer.sendQueue != null)
+			{
+				Packet250CustomPayload payload = new Packet250CustomPayload(channel, data);
+				minecraft.thePlayer.sendQueue.addToSendQueue(payload);
+			}
+		}
+		catch (Exception ex) {}
+	}
+}
@@ -103,7 +103,7 @@ public class SoundManagerReloadInhibitor
 					if (reload)
 					{
 						LiteLoader.getLogger().info("Reloading sound manager");
-						this.soundManager.func_110549_a(this.resourceManager); // TODO adamsrc -> onReload
+						this.soundManager.onResourceManagerReload(this.resourceManager);
 					}
  
 					this.inhibited = false;
+package com.mumfrey.liteloader.core.exceptions;
+
+/**
+ * Exception to throw if startSection or endSection are called from a thread other than 
+ * the Minecraft main thread. This should NEVER happen and is an attempt to identify the
+ * culprit of some profiler stack corruption causes.
+ *
+ * @author Adam Mummery-Smith
+ */
+public class ProfilerCrossThreadAccessException extends RuntimeException
+{
+	private static final long serialVersionUID = 3225047722943528251L;
+	
+	public ProfilerCrossThreadAccessException(String message)
+	{
+		super("Calling thread name \"" + message + "\"");
+	}
+}
-package com.mumfrey.liteloader.core;
+package com.mumfrey.liteloader.core.exceptions;
  
 /**
  * Exception to throw when a mod corrupts the profiler stack, this avoids throwing a
-package com.mumfrey.liteloader.core;
+package com.mumfrey.liteloader.core.hooks;
  
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -10,6 +10,7 @@ import net.minecraft.src.NetHandler;
 import net.minecraft.src.Packet;
 import net.minecraft.src.Packet3Chat;
  
+import com.mumfrey.liteloader.core.Events;
 import com.mumfrey.liteloader.util.PrivateFields;
  
 /**
@@ -30,7 +31,7 @@ public class HookChat extends Packet3Chat
 	/**
 	 * Handler module which is registered to handle inbound chat packets
 	 */
-	private static LiteLoader packetHandler; 
+	private static Events events; 
  
 	/**
 	 * Class which was overridden and will be instanced for new packets
@@ -106,7 +107,7 @@ public class HookChat extends Packet3Chat
 	@Override
 	public void processPacket(NetHandler nethandler)
 	{
-		if (packetHandler == null || packetHandler.onChat(this))
+		if (events == null || events.onChat(this))
 		{
 			if (proxyPacket != null)
 				proxyPacket.processPacket(nethandler);
@@ -128,9 +129,9 @@ public class HookChat extends Packet3Chat
 	 * Register the specified handler as the packet handler for this packet
 	 * @param handler
 	 */
-	public static void registerPacketHandler(LiteLoader handler)
+	public static void registerPacketHandler(Events handler)
 	{
-		packetHandler = handler;
+		events = handler;
 	}
  
 	/**
-package com.mumfrey.liteloader.core;
+package com.mumfrey.liteloader.core.hooks;
+
+import com.mumfrey.liteloader.core.Events;
  
 import net.minecraft.src.EnumGameType;
 import net.minecraft.src.NetHandler;
@@ -7,7 +9,7 @@ import net.minecraft.src.WorldType;
  
 public class HookLogin extends Packet1Login
 {
-	public static LiteLoader loader;
+	public static Events events;
  
 	public HookLogin()
 	{
@@ -25,11 +27,11 @@ public class HookLogin extends Packet1Login
 	@Override
 	public void processPacket(NetHandler par1NetHandler)
 	{
-		if (loader == null || loader.onPreLogin(par1NetHandler, this))
+		if (events == null || events.onPreLogin(par1NetHandler, this))
 		{
 			super.processPacket(par1NetHandler);
  
-			if (loader != null) loader.onConnectToServer(par1NetHandler, this);
+			if (events != null) events.onConnectToServer(par1NetHandler, this);
 		}
 	}
 }
-package com.mumfrey.liteloader.core;
+package com.mumfrey.liteloader.core.hooks;
  
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -10,6 +10,7 @@ import net.minecraft.src.NetHandler;
 import net.minecraft.src.Packet;
 import net.minecraft.src.Packet250CustomPayload;
  
+import com.mumfrey.liteloader.core.PluginChannels;
 import com.mumfrey.liteloader.util.PrivateFields;
  
 public class HookPluginChannels extends Packet250CustomPayload
@@ -22,7 +23,7 @@ public class HookPluginChannels extends Packet250CustomPayload
 	/**
 	 * Handler module which is registered to handle inbound chat packets
 	 */
-	private static LiteLoader packetHandler; 
+	private static PluginChannels events; 
  
 	/**
 	 * Class which was overridden and will be instanced for new packets
@@ -40,9 +41,9 @@ public class HookPluginChannels extends Packet250CustomPayload
  
 		try
 		{
-			if (proxyClass != null)
+			if (HookPluginChannels.proxyClass != null)
 			{
-				proxyPacket = proxyClass.newInstance();
+				proxyPacket = HookPluginChannels.proxyClass.newInstance();
 			}
 		}
 		catch (Exception ex) {}
@@ -54,9 +55,9 @@ public class HookPluginChannels extends Packet250CustomPayload
  
 		try
 		{
-			if (proxyClass != null)
+			if (HookPluginChannels.proxyClass != null)
 			{
-				proxyPacket = proxyClass.newInstance();
+				proxyPacket = HookPluginChannels.proxyClass.newInstance();
  
 				if (proxyPacket instanceof Packet250CustomPayload)
 				{
@@ -101,9 +102,9 @@ public class HookPluginChannels extends Packet250CustomPayload
 		else
 			super.processPacket(nethandler);
  
-		if (packetHandler != null)
+		if (HookPluginChannels.events != null)
 		{
-			packetHandler.onPluginChannelMessage(this);
+			HookPluginChannels.events.onPluginChannelMessage(this);
 		}
 	}
  
@@ -120,9 +121,9 @@ public class HookPluginChannels extends Packet250CustomPayload
 	 * Register the specified handler as the packet handler for this packet
 	 * @param handler
 	 */
-	public static void registerPacketHandler(LiteLoader handler)
+	public static void registerPacketHandler(PluginChannels handler)
 	{
-		packetHandler = handler;
+		HookPluginChannels.events = handler;
 	}
  
 	/**
@@ -142,25 +143,26 @@ public class HookPluginChannels extends Packet250CustomPayload
 	@SuppressWarnings({ "unchecked", "rawtypes" })
 	public static void register(boolean force)
 	{
-		if (!registered || force)
+		if (!HookPluginChannels.registered || force)
 		{
 			try
 			{
+				int packetId = 250;
 				IntHashMap packetIdToClassMap = Packet.packetIdToClassMap;
-				proxyClass = (Class<? extends Packet>)packetIdToClassMap.lookup(250);
+				HookPluginChannels.proxyClass = (Class<? extends Packet>)packetIdToClassMap.lookup(packetId);
  
-				if (proxyClass.equals(Packet250CustomPayload.class))
+				if (HookPluginChannels.proxyClass.equals(Packet250CustomPayload.class))
 				{
-					proxyClass = null;
+					HookPluginChannels.proxyClass = null;
 				}
  
-				packetIdToClassMap.removeObject(250);
-				packetIdToClassMap.addKey(250, HookPluginChannels.class);
+				packetIdToClassMap.removeObject(packetId);
+				packetIdToClassMap.addKey(packetId, HookPluginChannels.class);
  
 				Map packetClassToIdMap = PrivateFields.StaticFields.packetClassToIdMap.get();
-				packetClassToIdMap.put(HookPluginChannels.class, Integer.valueOf(250));
+				packetClassToIdMap.put(HookPluginChannels.class, Integer.valueOf(packetId));
  
-				registered = true;
+				HookPluginChannels.registered = true;
 			}
 			catch (Exception ex)
 			{
-package com.mumfrey.liteloader.core;
+package com.mumfrey.liteloader.core.hooks;
  
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
@@ -6,6 +6,11 @@ import java.util.LinkedList;
 import java.util.NoSuchElementException;
 import java.util.logging.Logger;
  
+import com.mumfrey.liteloader.core.Events;
+import com.mumfrey.liteloader.core.LiteLoader;
+import com.mumfrey.liteloader.core.exceptions.ProfilerCrossThreadAccessException;
+import com.mumfrey.liteloader.core.exceptions.ProfilerStackCorruptionException;
+
 import net.minecraft.src.Minecraft;
 import net.minecraft.src.GameSettings;
 import net.minecraft.src.Profiler;
@@ -18,14 +23,19 @@ import net.minecraft.src.Profiler;
 public class HookProfiler extends Profiler
 {
 	/**
+	 * Cross-thread sanity check 
+	 */
+	private final Thread minecraftThread;
+	
+	/**
 	 * Logger instance
 	 */
 	private Logger logger;
  
 	/**
-	 * LiteLoader instance which will receive callbacks
+	 * Event manager instance which will receive callbacks
 	 */
-	private LiteLoader loader;
+	private Events events;
  
 	/**
 	 * Section list, used as a kind of stack to determine where we are in the profiler stack
@@ -55,18 +65,20 @@ public class HookProfiler extends Profiler
 	/**
 	 * .ctor
 	 * 
-	 * @param core LiteLoader object which will get callbacks
+	 * @param events LiteLoader object which will get callbacks
 	 * @param logger Logger instance
 	 */
-	public HookProfiler(LiteLoader core, Logger logger)
+	public HookProfiler(Events events)
 	{
 		this.mc = Minecraft.getMinecraft();
  
-		this.loader = core;
-		this.logger = logger;
+		this.events = events;
+		this.logger = LiteLoader.getLogger();
  
 		// Detect optifine (duh!)
 		this.detectOptifine();
+		
+		this.minecraftThread = Thread.currentThread();
 	}
  
 	/**
@@ -126,35 +138,40 @@ public class HookProfiler extends Profiler
 	@Override
 	public void startSection(String sectionName)
 	{
+		if (Thread.currentThread() != this.minecraftThread)
+		{
+			throw new ProfilerCrossThreadAccessException(Thread.currentThread().getName());
+		}
+		
 		if (!this.initDone)
 		{
 			this.initDone = true;
-			this.loader.onInit();
+			this.events.onInit();
 		}
  
 		if ("gameRenderer".equals(sectionName) && "root".equals(this.sectionStack.getLast()))
 		{
-			this.loader.onRender();
+			this.events.onRender();
 		}
-
-		if ("frustrum".equals(sectionName) && "level".equals(this.sectionStack.getLast()))
+		else if ("frustrum".equals(sectionName) && "level".equals(this.sectionStack.getLast()))
 		{
-			this.loader.onSetupCameraTransform();
+			this.events.onSetupCameraTransform();
 		}
-		
-		if ("litParticles".equals(sectionName))
+		else if ("litParticles".equals(sectionName))
 		{
-			this.loader.postRenderEntities();
+			this.events.postRenderEntities();
 		}
-		
-		if ("tick".equals(sectionName) && "root".equals(this.sectionStack.getLast()))
+		else if ("tick".equals(sectionName) && "root".equals(this.sectionStack.getLast()))
 		{
-			this.loader.onTimerUpdate();
+			this.events.onTimerUpdate();
 		}
-		
-		if ("chat".equals(sectionName))
+		else if ("chat".equals(sectionName))
 		{
-			this.loader.onBeforeChatRender();
+			this.events.onRenderChat();
+		}
+		else if ("gui".equals(sectionName) && "gameRenderer".equals(this.sectionStack.getLast()))
+		{
+			this.events.onRenderHUD();
 		}
  
 		if ("animateTick".equals(sectionName)) this.tick = true;
@@ -184,6 +201,11 @@ public class HookProfiler extends Profiler
 	@Override
 	public void endSection()
 	{
+		if (Thread.currentThread() != this.minecraftThread)
+		{
+			throw new ProfilerCrossThreadAccessException(Thread.currentThread().getName());
+		}
+		
 		super.endSection();
  
 		try
@@ -191,26 +213,34 @@ public class HookProfiler extends Profiler
 			String endingSection = this.sectionStack.size() > 0 ? this.sectionStack.removeLast() : null;
 			String nextSection = this.sectionStack.size() > 0 ? this.sectionStack.getLast() : null;
  
-			if ("gameRenderer".equals(endingSection) && "root".equals(this.sectionStack.getLast()))
+			if ("gameRenderer".equals(endingSection) && "root".equals(nextSection))
 			{
 				super.startSection("litetick");
  
-				this.loader.onTick(this, this.tick);
+				this.events.onTick(this, this.tick);
 				this.tick = false;
  
 				super.endSection();
 			}
-			else if (("mouse".equals(endingSection) && "gameRenderer".equals(nextSection) && (this.mc.skipRenderWorld || this.mc.theWorld == null)) || ("gui".equals(endingSection) && "gameRenderer".equals(nextSection) && this.mc.theWorld != null))
-			{
-				this.loader.onBeforeGuiRender();
-			}
-			else if ("hand".equals(endingSection) && "level".equals(this.sectionStack.getLast()))
+			else
 			{
-				this.loader.postRender();
-			}
-			else if ("chat".equals(endingSection))
-			{
-				this.loader.onAfterChatRender();
+				if ("gui".equals(endingSection) && "gameRenderer".equals(nextSection) && this.mc.theWorld != null)
+				{
+					this.events.postRenderHUD();
+					this.events.preRenderGUI();
+				}
+				else if ("mouse".equals(endingSection) && "gameRenderer".equals(nextSection) && (this.mc.skipRenderWorld || this.mc.theWorld == null))
+				{
+					this.events.preRenderGUI();
+				}
+				else if ("hand".equals(endingSection) && "level".equals(nextSection))
+				{
+					this.events.postRender();
+				}
+				else if ("chat".equals(endingSection))
+				{
+					this.events.postRenderChat();
+				}
 			}
 		}
 		catch (NoSuchElementException ex)
@@ -219,4 +249,14 @@ public class HookProfiler extends Profiler
 			throw new ProfilerStackCorruptionException("Corrupted Profiler stack detected");
 		}
 	}
+//	
+//	@Override
+//	public void dumpState()
+//	{
+//		String endingSection = this.sectionStack.size() > 0 ? this.sectionStack.getLast() : null;
+//		String nextSection = this.sectionStack.size() > 1 ? this.sectionStack.get(sectionStack.size() - 2) : null;
+//		
+//		System.out.println("endingSection=" + endingSection + "   nextSection=" + nextSection);
+//	}
+
 }
@@ -105,17 +105,17 @@ public class GuiControlsPaginated extends GuiScreen
 		{
 			this.getLegacyControlList().add(this.btnNext = new GuiButton(201, this.getWidth() / 2 - 51, buttonY, 50, 20, ">>"));
 			this.getLegacyControlList().add(this.btnPrevious = new GuiButton(202, this.getWidth() / 2 - 103, buttonY, 50, 20, "<<"));
-			this.getLegacyControlList().add(new GuiButton(200, this.getWidth() / 2 + 1, buttonY, 100, 20, I18n.func_135053_a("gui.done"))); // TODO adamsrc -> translate 
+			this.getLegacyControlList().add(new GuiButton(200, this.getWidth() / 2 + 1, buttonY, 100, 20, I18n.getString("gui.done"))); 
  
 			this.btnNext.enabled = this.startIndex < this.endIndex;
 			this.btnPrevious.enabled = this.startIndex > 0;
 		}
 		else
 		{
-			this.getLegacyControlList().add(new GuiButton(200, this.getWidth() / 2 - 100, buttonY, I18n.func_135053_a("gui.done"))); // TODO adamsrc -> translate
+			this.getLegacyControlList().add(new GuiButton(200, this.getWidth() / 2 - 100, buttonY, I18n.getString("gui.done")));
 		}
  
-		this.screenTitle = I18n.func_135053_a("controls.title"); // TODO adamsrc -> translate
+		this.screenTitle = I18n.getString("controls.title");
 	}
  
 	/**
+package com.mumfrey.liteloader.launch;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import net.minecraft.launchwrapper.LaunchClassLoader;
+
+public class LiteLoaderTransformer implements IClassTransformer
+{
+	private static final String classMappingRenderLightningBolt = "net.minecraft.src.RenderLightningBolt";
+	
+	// TODO Obfuscation 1.6.3
+	private static final String classMappingRenderLightningBoltObf = "bha";
+
+	private static Logger logger = Logger.getLogger("liteloader");
+	
+	public static LaunchClassLoader launchClassLoader;
+
+	public static List<String> modsToLoad;
+	
+	public static File gameDirectory;
+	
+	public static File assetsDirectory;
+	
+	public static String profile;
+	
+	@Override
+	public byte[] transform(String name, String transformedName, byte[] basicClass)
+	{
+		if (classMappingRenderLightningBolt.equals(name) || classMappingRenderLightningBoltObf.equals(name))
+		{
+			logger.info("Beginning LiteLoader Init...");
+			
+			try
+			{
+				Class<?> loaderClass = Class.forName("com.mumfrey.liteloader.core.LiteLoader", false, LiteLoaderTransformer.launchClassLoader);
+				Method mInit = loaderClass.getDeclaredMethod("init", File.class, File.class, String.class, List.class, LaunchClassLoader.class);
+				mInit.setAccessible(true);
+				mInit.invoke(null, LiteLoaderTransformer.gameDirectory, LiteLoaderTransformer.assetsDirectory, LiteLoaderTransformer.profile, LiteLoaderTransformer.modsToLoad, LiteLoaderTransformer.launchClassLoader);
+			}
+			catch (Throwable th)
+			{
+				logger.log(Level.SEVERE, String.format("Error initialising LiteLoader: %s", th.getMessage()), th);
+			}
+		}
+		
+		return basicClass;
+	}
+}
+package com.mumfrey.liteloader.launch;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import joptsimple.ArgumentAcceptingOptionSpec;
+import joptsimple.NonOptionArgumentSpec;
+import joptsimple.OptionParser;
+import joptsimple.OptionSet;
+import net.minecraft.launchwrapper.ITweaker;
+import net.minecraft.launchwrapper.Launch;
+import net.minecraft.launchwrapper.LaunchClassLoader;
+
+/**
+ *
+ * @author Adam Mummery-Smith
+ */
+public class LiteLoaderTweaker implements ITweaker
+{
+	public static final String VERSION = "1.6.3";
+
+	private File gameDirectory;
+	
+	private File assetsDirectory;
+	
+	private String profile;
+
+	private List<String> unClassifiedArgs = new ArrayList<String>();
+	
+	private Map<String, String> classifiedArgs = new HashMap<String, String>();
+	
+	private ArgumentAcceptingOptionSpec<String> modsOption;
+	private OptionSet parsedOptions;
+	
+	private List<String> passThroughArgs;
+	
+	@Override
+	public void acceptOptions(List<String> args, File gameDirectory, File assetsDirectory, String profile)
+	{
+		this.gameDirectory = gameDirectory;
+		this.assetsDirectory = assetsDirectory;
+		this.profile = profile;
+		
+		LiteLoaderTransformer.gameDirectory = gameDirectory;
+		LiteLoaderTransformer.assetsDirectory = assetsDirectory;
+		LiteLoaderTransformer.profile = profile;
+		
+		OptionParser optionParser = new OptionParser();
+		this.modsOption = optionParser.accepts("mods", "Comma-separated list of mods to load").withRequiredArg().ofType(String.class).withValuesSeparatedBy(',');
+		optionParser.allowsUnrecognizedOptions();
+		NonOptionArgumentSpec<String> nonOptions = optionParser.nonOptions();
+		
+		this.parsedOptions = optionParser.parse(args.toArray(new String[args.size()]));
+		this.passThroughArgs = this.parsedOptions.valuesOf(nonOptions);
+		
+		// Parse out the arguments ourself because joptsimple doesn't really provide a good way to
+		// add arguments to the unparsed argument list after parsing
+		this.parseArgs(this.passThroughArgs);
+		
+		// Put required arguments to the blackboard if they don't already exist there
+		this.provideRequiredArgs(gameDirectory, assetsDirectory);
+		
+		if (this.parsedOptions.has(this.modsOption))
+		{
+			LiteLoaderTransformer.modsToLoad = this.modsOption.values(this.parsedOptions);
+		}
+	}
+
+	/**
+	 * @param gameDirectory
+	 * @param assetsDirectory
+	 */
+	public void provideRequiredArgs(File gameDirectory, File assetsDirectory)
+	{
+		@SuppressWarnings("unchecked")
+		final List<String> argumentList = (List<String>)Launch.blackboard.get("ArgumentList");
+		
+		if (argumentList != null)
+		{
+			if (!argumentList.contains("--version"))
+			{
+				argumentList.add("--version");
+				argumentList.add(this.VERSION);
+			}
+			
+			if (!argumentList.contains("--gameDir") && gameDirectory != null)
+			{
+				argumentList.add("--gameDir");
+				argumentList.add(gameDirectory.getAbsolutePath());
+			}
+			
+			if (!argumentList.contains("--assetsDir") && assetsDirectory != null)
+			{
+				argumentList.add("--assetsDir");
+				argumentList.add(assetsDirectory.getAbsolutePath());
+			}
+		}
+	}
+
+	private void parseArgs(List<String> args)
+	{
+		String classifier = null;
+		
+		for (String arg : args)
+		{
+			if (arg.startsWith("-"))
+			{
+				if (classifier != null)
+					classifier = this.addClassifiedArg(classifier, "");
+				else if (arg.contains("="))
+					classifier = this.addClassifiedArg(arg.substring(0, arg.indexOf('=')), arg.substring(arg.indexOf('=') + 1));
+				else
+					classifier = arg;
+			}
+			else
+			{
+				if (classifier != null)
+					classifier = this.addClassifiedArg(classifier, arg);
+				else
+					this.unClassifiedArgs.add(arg);
+			}
+		}
+	}
+
+	private String addClassifiedArg(String classifiedArg, String arg)
+	{
+		this.classifiedArgs.put(classifiedArg, arg);
+		return null;
+	}
+
+	@Override
+	public void injectIntoClassLoader(LaunchClassLoader classLoader)
+	{
+		LiteLoaderTransformer.launchClassLoader = classLoader;
+		classLoader.registerTransformer("com.mumfrey.liteloader.launch.LiteLoaderTransformer");
+	}
+
+	@Override
+	public String getLaunchTarget()
+	{
+		return "net.minecraft.client.main.Main";
+	}
+
+	@Override
+	public String[] getLaunchArguments()
+	{
+		List<String> args = new ArrayList<String>();
+		
+		for (String unClassifiedArg : this.unClassifiedArgs)
+			args.add(unClassifiedArg);
+		
+		for (Entry<String, String> classifiedArg : this.classifiedArgs.entrySet())
+		{
+			args.add(classifiedArg.getKey().trim());
+			args.add(classifiedArg.getValue().trim());
+		}
+		
+		return args.toArray(new String[args.size()]);
+	}
+
+	public File getGameDirectory()
+	{
+		return this.gameDirectory;
+	}
+
+	public File getAssetsDirectory()
+	{
+		return this.assetsDirectory;
+	}
+	
+	public String getProfile()
+	{
+		return this.profile;
+	}
+}
-package com.mumfrey.liteloader.core;
+package com.mumfrey.liteloader.log;
  
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -7,7 +7,7 @@ import java.util.logging.Formatter;
 import java.util.logging.Level;
 import java.util.logging.LogRecord;
  
-final class LiteLoaderLogFormatter extends Formatter
+public class LiteLoaderLogFormatter extends Formatter
 {
 	private SimpleDateFormat simpleDateFormatLogFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  
@@ -29,9 +29,9 @@ final class LiteLoaderLogFormatter extends Formatter
  
 		if (th != null)
 		{
-			StringWriter var5 = new StringWriter();
-			th.printStackTrace(new PrintWriter(var5));
-			sb.append(var5.toString());
+			StringWriter stringWriter = new StringWriter();
+			th.printStackTrace(new PrintWriter(stringWriter));
+			sb.append(stringWriter.toString());
 		}
  
 		return sb.toString();
@@ -16,7 +16,7 @@ import net.minecraft.src.Packet1Login;
  
 import com.mumfrey.liteloader.Permissible;
 import com.mumfrey.liteloader.PluginChannelListener;
-import com.mumfrey.liteloader.util.ModUtilities;
+import com.mumfrey.liteloader.core.PluginChannels;
  
 /**
  * This class manages permissions on the client, it is a singleton class which can manage permissions for multiple 
@@ -220,7 +220,7 @@ public class PermissionsManagerClient implements PermissionsManager, PluginChann
 				if (!query.modName.equals("all") || query.permissions.size() > 0)
 				{
 					byte[] data = query.getBytes();
-					ModUtilities.sendPluginChannelMessage(ReplicatedPermissionsContainer.CHANNEL, data);
+					PluginChannels.sendMessage(ReplicatedPermissionsContainer.CHANNEL, data);
 				}
 			}
 		}
@@ -28,29 +28,29 @@ public class ModResourcePack extends FileResourcePack
 		super(modFile);
 		this.name = name;
 	}
-    
-    /* (non-Javadoc)
-     * @see net.minecraft.src.AbstractResourcePack#getMetadataSection(net.minecraft.src.MetadataSerializer, java.lang.String)
-     */
-    @Override
-    public MetadataSection func_135058_a(MetadataSerializer metadataSerializer, String metadataSectionName) throws IOException // TODO adamsrc -> getMetadataSection
-    {
-    	try
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.AbstractResourcePack#getMetadataSection(net.minecraft.src.MetadataSerializer, java.lang.String)
+	 */
+	@Override
+	public MetadataSection getPackMetadata(MetadataSerializer metadataSerializer, String metadataSectionName) throws IOException
+	{
+		try
 		{
-    		// This will fail when fetching pack.mcmeta if there isn't one in the mod file, since we don't care we
-    		// just catch the exception and return null instead
-			return super.func_135058_a(metadataSerializer, metadataSectionName); // TODO adamsrc -> getMetadataSection
+			// This will fail when fetching pack.mcmeta if there isn't one in the mod file, since we don't care we
+			// just catch the exception and return null instead
+			return super.getPackMetadata(metadataSerializer, metadataSectionName);
 		}
 		catch (Exception ex) {}
-    	
-    	return null;
-    }
+		
+		return null;
+	}
  
 	/* (non-Javadoc)
 	 * @see net.minecraft.src.AbstractResourcePack#getName()
 	 */
 	@Override
-	public String func_130077_b() // TODO adamsrc -> getName()
+	public String getPackName()
 	{
 		return this.name;
 	}
@@ -28,29 +28,29 @@ public class ModResourcePackDir extends FolderResourcePack
 		super(modFile);
 		this.name = name;
 	}
-    
-    /* (non-Javadoc)
-     * @see net.minecraft.src.AbstractResourcePack#getMetadataSection(net.minecraft.src.MetadataSerializer, java.lang.String)
-     */
-    @Override
-    public MetadataSection func_135058_a(MetadataSerializer metadataSerializer, String metadataSectionName) throws IOException // TODO adamsrc -> getMetadataSection
-    {
-    	try
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.AbstractResourcePack#getMetadataSection(net.minecraft.src.MetadataSerializer, java.lang.String)
+	 */
+	@Override
+	public MetadataSection getPackMetadata(MetadataSerializer metadataSerializer, String metadataSectionName) throws IOException
+	{
+		try
 		{
-    		// This will fail when fetching pack.mcmeta if there isn't one in the mod file, since we don't care we
-    		// just catch the exception and return null instead
-			return super.func_135058_a(metadataSerializer, metadataSectionName); // TODO adamsrc -> getMetadataSection
+			// This will fail when fetching pack.mcmeta if there isn't one in the mod file, since we don't care we
+			// just catch the exception and return null instead
+			return super.getPackMetadata(metadataSerializer, metadataSectionName);
 		}
 		catch (Exception ex) {}
-    	
-    	return null;
-    }
+		
+		return null;
+	}
  
 	/* (non-Javadoc)
 	 * @see net.minecraft.src.AbstractResourcePack#getName()
 	 */
 	@Override
-	public String func_130077_b() // TODO adamsrc -> getName()
+	public String getPackName()
 	{
 		return this.name;
 	}
@@ -7,9 +7,9 @@ import java.util.Map;
 import java.util.Set;
  
 import com.mumfrey.liteloader.core.LiteLoader;
+import com.mumfrey.liteloader.core.PluginChannels;
  
 import net.minecraft.client.ClientBrandRetriever;
-import net.minecraft.src.Minecraft;
 import net.minecraft.src.*;
  
 public abstract class ModUtilities
@@ -27,7 +27,7 @@ public abstract class ModUtilities
 	static
 	{
 		// Check for FML
-		forgeModLoader = ClientBrandRetriever.getClientModName().contains("fml");
+		ModUtilities.forgeModLoader = ClientBrandRetriever.getClientModName().contains("fml");
 	}
  
 	/**
@@ -53,6 +53,11 @@ public abstract class ModUtilities
 	@SuppressWarnings("unchecked")
 	public static boolean registerPacketOverride(int packetId, Class<? extends Packet> newPacket)
 	{
+		if (packetId == 250)
+		{
+			throw new RuntimeException("Cannot override packet 250, register a plugin channel listener instead");
+		}
+		
 		if (overriddenPackets.contains(Integer.valueOf(packetId)))
 		{
 			LiteLoader.getLogger().warning(String.format("Packet with ID %s was already overridden by another mod, one or mods may not function correctly", packetId));
@@ -72,7 +77,7 @@ public abstract class ModUtilities
 		}
 		catch (Exception ex)
 		{
-			LiteLoader.logger.warning("Error registering packet override for packet id " + packetId + ": " + ex.getMessage());
+			LiteLoader.getLogger().warning("Error registering packet override for packet id " + packetId + ": " + ex.getMessage());
 			return false;
 		}
 	}
@@ -82,23 +87,13 @@ public abstract class ModUtilities
 	 * 
 	 * @param channel Channel to send the data
 	 * @param data
+	 * 
+	 * @deprecated User PluginChannels.sendMessage(channel, data) instead.
 	 */
+	@Deprecated
 	public static void sendPluginChannelMessage(String channel, byte[] data)
 	{
-		if (channel == null || channel.length() > 16)
-			throw new RuntimeException("Invalid channel name specified"); 
-		
-		try
-		{
-			Minecraft minecraft = Minecraft.getMinecraft();
-			
-			if (minecraft.thePlayer != null)
-			{
-				Packet250CustomPayload payload = new Packet250CustomPayload(channel, data);
-				minecraft.thePlayer.sendQueue.addToSendQueue(payload);
-			}
-		}
-		catch (Exception ex) {}
+		PluginChannels.sendMessage(channel, data);
 	}
  
 	/**
@@ -15,7 +15,7 @@ import net.minecraft.src.*;
  * @param <P> Parent class type, the type of the class that owns the field
  * @param <T> Field type, the type of the field value
  * 
- * TODO Obfuscation - updated 1.6.2
+ * TODO Obfuscation - updated 1.6.3
  */
 @SuppressWarnings("rawtypes")
 public class PrivateFields<P, T>
@@ -147,6 +147,6 @@ public class PrivateFields&lt;P, T&gt;
 	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
-	public static final PrivateFields<SimpleReloadableResourceManager, List<ResourceManagerReloadListener>> reloadListeners = new PrivateFields<SimpleReloadableResourceManager, List<ResourceManagerReloadListener>>(SimpleReloadableResourceManager.class, "field_110546_b", "c", "field_110546_b");   // SimpleReloadableResourceManager/field_110546_b
+	public static final PrivateFields<SimpleReloadableResourceManager, List<ResourceManagerReloadListener>> reloadListeners = new PrivateFields<SimpleReloadableResourceManager, List<ResourceManagerReloadListener>>(SimpleReloadableResourceManager.class, "reloadListeners", "c", "field_110546_b");   // SimpleReloadableResourceManager/reloadListeners
 }
  
@@ -24,15 +24,13 @@ public class ConsoleHandler extends StreamHandler
 	 * initialized the <tt>LogRecord</tt> and forwarded it here.
 	 * <p>
 	 * 
-	 * @param record
-	 *            description of the log event. A null record is silently
-	 *            ignored and is not published
+	 * @param record description of the log event. A null record is silently ignored and is not published
 	 */
 	@Override
 	public synchronized void publish(LogRecord record)
 	{
 		super.publish(record);
-		flush();
+		this.flush();
 	}
  
 	/**
@@ -42,6 +40,6 @@ public class ConsoleHandler extends StreamHandler
 	@Override
 	public synchronized void close()
 	{
-		flush();
+		this.flush();
 	}
 }
@@ -11,48 +11,48 @@ import com.mumfrey.liteloader.core.CallableLiteLoaderMods;
  
 class CallableJVMFlags implements Callable<String>
 {
-    /** Reference to the CrashReport object. */
-    final CrashReport theCrashReport;
-
-    CallableJVMFlags(CrashReport par1CrashReport)
-    {
-        this.theCrashReport = par1CrashReport;
-        par1CrashReport.func_85056_g().addCrashSectionCallable("Mod Pack", new CallableLiteLoaderBrand(par1CrashReport));
-        par1CrashReport.func_85056_g().addCrashSectionCallable("LiteLoader Mods", new CallableLiteLoaderMods(par1CrashReport));
-    }
-
-    /**
-     * Returns the number of JVM Flags along with the passed JVM Flags.
-     */
-    public String getJVMFlagsAsString()
-    {
-        RuntimeMXBean var1 = ManagementFactory.getRuntimeMXBean();
-        List<String> var2 = var1.getInputArguments();
-        int var3 = 0;
-        StringBuilder var4 = new StringBuilder();
-        Iterator<String> var5 = var2.iterator();
-
-        while (var5.hasNext())
-        {
-            String var6 = var5.next();
-
-            if (var6.startsWith("-X"))
-            {
-                if (var3++ > 0)
-                {
-                    var4.append(" ");
-                }
-
-                var4.append(var6);
-            }
-        }
-
-        return String.format("%d total; %s", new Object[] {Integer.valueOf(var3), var4.toString()});
-    }
-
-    @Override
+	/** Reference to the CrashReport object. */
+	final CrashReport theCrashReport;
+	
+	CallableJVMFlags(CrashReport par1CrashReport)
+	{
+		this.theCrashReport = par1CrashReport;
+		par1CrashReport.getCategory().addCrashSectionCallable("Mod Pack", new CallableLiteLoaderBrand(par1CrashReport));
+		par1CrashReport.getCategory().addCrashSectionCallable("LiteLoader Mods", new CallableLiteLoaderMods(par1CrashReport));
+	}
+	
+	/**
+	 * Returns the number of JVM Flags along with the passed JVM Flags.
+	 */
+	public String getJVMFlagsAsString()
+	{
+		RuntimeMXBean var1 = ManagementFactory.getRuntimeMXBean();
+		List<String> var2 = var1.getInputArguments();
+		int var3 = 0;
+		StringBuilder var4 = new StringBuilder();
+		Iterator<String> var5 = var2.iterator();
+		
+		while (var5.hasNext())
+		{
+			String var6 = var5.next();
+			
+			if (var6.startsWith("-X"))
+			{
+				if (var3++ > 0)
+				{
+					var4.append(" ");
+				}
+				
+				var4.append(var6);
+			}
+		}
+		
+		return String.format("%d total; %s", new Object[] {Integer.valueOf(var3), var4.toString()});
+	}
+	
+	@Override
 	public String call()
-    {
-        return this.getJVMFlagsAsString();
-    }
+	{
+		return this.getJVMFlagsAsString();
+	}
 }
+package com.mumfrey.liteloader.debug;
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.security.PublicKey;
+import java.security.cert.Certificate;
+
+import javax.net.ssl.HttpsURLConnection;
+
+import com.mumfrey.liteloader.launch.LiteLoaderTweaker;
+
+import net.minecraft.launchwrapper.Launch;
+
+/**
+ * Wrapper class for LaunchWrapper Main class, which logs into minecraft.net first so that online shizzle can be tested
+ * 
+ * @author Adam Mummery-Smith
+ * @version 0.4
+ */
+public abstract class Start
+{
+	/**
+	 * Username specified on the command line
+	 */
+	public static String userName = "";
+	
+	/**
+	 * Latest minecraft version as recieved from minecraft.net
+	 */
+	public static String latestVersion = "";
+	
+	/**
+	 * Download ticket issued to us by minecraft.net
+	 */
+	public static String downloadTicket = "";
+	
+	/**
+	 * Session ID retrieved during login ("-" means no session, eg. offline)
+	 */
+	public static String sessionId = "-";
+	
+	/**
+	 * Encoded certificate data in case the user forgets to extract minecraft.key !
+	 */
+	private static int[] certificateData = {
+		0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
+		0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xc6, 0xf3, 0xde,
+		0xfd, 0xef, 0xa9, 0x62, 0x9c, 0xe0, 0x51, 0x28, 0x9b, 0xfb, 0x46, 0xbc, 0xf4, 0x1a, 0x03, 0x0d, 0x6f, 0x69,
+		0xf1, 0x98, 0x2a, 0xa6, 0x35, 0xb9, 0x62, 0xd6, 0x36, 0x6b, 0x64, 0x53, 0x87, 0x93, 0xd6, 0xa9, 0xd3, 0x46,
+		0xd7, 0x93, 0x4f, 0x1d, 0x8e, 0x50, 0x50, 0x7d, 0x51, 0x80, 0xd1, 0x29, 0x8f, 0x83, 0x37, 0xb6, 0x67, 0xfd,
+		0xde, 0xa3, 0xdf, 0x02, 0xda, 0x52, 0xba, 0x1c, 0x3a, 0x3e, 0x6f, 0xe4, 0xb6, 0xc8, 0x55, 0x75, 0x91, 0xf8,
+		0x6b, 0x2a, 0x51, 0x5a, 0xad, 0xf6, 0x26, 0x9b, 0xff, 0xcf, 0x67, 0x15, 0xa0, 0xb9, 0x5a, 0xb8, 0xca, 0xaf,
+		0x8f, 0xef, 0x9a, 0x15, 0x45, 0x9f, 0x87, 0xd0, 0x82, 0x89, 0x55, 0x45, 0x91, 0x7e, 0x90, 0x03, 0x84, 0x45,
+		0x6b, 0xdf, 0xeb, 0xa4, 0x95, 0x71, 0x74, 0xbd, 0x0f, 0x8b, 0xf7, 0xa8, 0xc4, 0xfa, 0xd5, 0x7d, 0x6f, 0xff,
+		0x01, 0xc0, 0x4a, 0x64, 0xd2, 0x73, 0x02, 0xf1, 0x4f, 0x72, 0x87, 0x48, 0x80, 0xa2, 0x0c, 0x9c, 0x3c, 0xd5,
+		0xad, 0xbe, 0xfb, 0xf0, 0x38, 0x34, 0xaf, 0x25, 0x10, 0xef, 0x96, 0xaf, 0x8c, 0x3d, 0xfa, 0x48, 0x54, 0x5f,
+		0xe4, 0x11, 0x43, 0xa2, 0x74, 0xe9, 0xc4, 0x28, 0xa9, 0x06, 0x3d, 0xcc, 0xbd, 0xc0, 0xbe, 0x48, 0xb4, 0x22,
+		0xd6, 0xd2, 0x34, 0xee, 0x2f, 0x07, 0x76, 0xe7, 0x33, 0x9f, 0x0d, 0xe5, 0x9e, 0x34, 0x8a, 0xc6, 0xec, 0x2b,
+		0x75, 0x15, 0x3a, 0x2f, 0xa8, 0xa6, 0x9a, 0x77, 0x68, 0x17, 0xf2, 0x90, 0x65, 0x5b, 0xef, 0x52, 0x33, 0xaa,
+		0x4b, 0x05, 0xf3, 0x08, 0x80, 0x0e, 0xdf, 0x0d, 0xfb, 0x8b, 0x67, 0x0e, 0x17, 0x54, 0x25, 0x9f, 0x75, 0xa9,
+		0xf8, 0x66, 0x28, 0xeb, 0x70, 0x31, 0x49, 0xac, 0xe3, 0x9d, 0xb1, 0x10, 0xc8, 0xfd, 0xfd, 0x8d, 0x23, 0x6c,
+		0xef, 0x02, 0x03, 0x01, 0x00, 0x01
+	};
+	
+	/**
+	 * Entry point. Validates the parameters and performs the login
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args)
+	{
+		// Check we have enough arguments
+		if (args.length < 2)
+		{
+			Start.showError("Invalid parameters specified for start, use: <username> <password> to log in to minecraft.net");
+			userName = args.length < 1 ? System.getProperty("user.name") : args[0];
+		}
+		else
+		{
+			// Assign username as the first argument
+			userName = args[0];			
+			
+			// Perform the login if the second parameter is not "-" (indicating offline)
+			if (!args[1].equals("-") && login(args[0], args[1], 13, true))
+			{
+				Start.showMessage(String.format("Successfully logged in as %s with session ID %s", userName, sessionId));
+				args[0] = userName;
+				args[1] = sessionId;
+			}
+		}
+
+		Start.showMessage(String.format("Launching game as %s", userName));
+		
+		File gameDir = new File(System.getProperty("user.dir"));
+		File assetsDir = new File(gameDir, "assets");
+		
+		args = new String[] {
+			"--tweakClass", LiteLoaderTweaker.class.getName(),
+			"--username",   userName,
+			"--session",    sessionId,
+			"--version",    "mcp",
+			"--gameDir",    gameDir.getAbsolutePath(),
+			"--assetsDir",  assetsDir.getAbsolutePath()
+		};
+		
+		Launch.main(args);
+	}
+
+	/**
+	 * Do login to minecraft.net. Based on the login method in the Launcher
+	 * 
+	 * @param user Username
+	 * @param password Password
+	 * @param masqueradeLauncher Version Launcher version to masquerade as 
+	 * @param validateCertificate True to validate the minecraft.net certificate. False if you can't be bothered or don't care :) 
+	 * @return True if the login succeeded
+	 */
+	private static boolean login(String user, String password, int masqueradeLauncherVersion, boolean validateCertificate)
+	{
+		try
+		{
+			String parameters = String.format("user=%s&password=%s&version=%s",URLEncoder.encode(user, "UTF-8"), URLEncoder.encode(password, "UTF-8"), masqueradeLauncherVersion);
+		 
+			Start.showMessage("Attempting to login to minecraft.net...");
+			String result = excutePost("https://login.minecraft.net/", parameters, validateCertificate);
+			
+			if (result == null)
+			{
+				Start.showError("Can't connect to minecraft.net");
+				return false;
+			}
+			
+			if (!result.contains(":"))
+			{
+				Start.showError(result);
+				return false;
+			}
+			
+			try
+			{
+				String values[] = result.split(":");
+				
+				latestVersion  = values[0].trim();
+				downloadTicket = values[1].trim();
+				userName	   = values[2].trim();
+				sessionId	  = values[3].trim();
+				
+				return true;
+			}
+			catch(Exception e)
+			{
+				e.printStackTrace();
+				return false;
+			}
+		}
+		catch (UnsupportedEncodingException e)
+		{
+			Start.showError("Error encoding POST data, check your parameters");
+			return false;
+		}
+	}
+	
+	/**
+	 * Execute a HTTPS POST. Based on code in the Minecraft launcher
+	 * 
+	 * @param targetURL POST url
+	 * @param postData POST query string
+	 * @param validateCertificate True if the certificate should be validated against the local cache
+	 * @return Response data or null if the query fails
+	 */
+	private static String excutePost(String targetURL, String postData, boolean validateCertificate)
+	{
+		HttpsURLConnection https = null;
+		String responseData;
+		
+		try
+		{
+			URL url = new URL(targetURL);
+			
+			// Play that funky music white boy
+			https = (HttpsURLConnection)url.openConnection();
+			https.setRequestMethod("POST");
+			https.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
+			https.setRequestProperty("Content-Length", Integer.toString(postData.getBytes().length));
+			https.setRequestProperty("Content-Language", "en-US");
+			https.setUseCaches(false);
+			https.setDoInput(true);
+			https.setDoOutput(true);
+			https.setConnectTimeout(1000);
+			https.connect();
+			
+			// Validate the cert we received with the HTTPS response, if the user wants to
+			if (validateCertificate)
+			{
+				Certificate certificates[] = https.getServerCertificates();
+				
+				byte bytes[] = new byte[294];
+				
+				try
+				{
+					DataInputStream keyReaderStream = new DataInputStream(Start.class.getResourceAsStream("/minecraft.key"));
+					keyReaderStream.readFully(bytes);
+					keyReaderStream.close();
+				}
+				catch (NullPointerException ex)
+				{
+					// Error loading from the key file (probably the user forgot to put minecraft.key in the bin folder)
+					Start.showError("Missing minecraft.key, reverting to internal cache");
+					
+					for (int certIndex = 0; certIndex < 294; certIndex++)
+						bytes[certIndex] = (byte)(certificateData[certIndex] & 0xFF);
+				}
+				
+				PublicKey publicKey = certificates[0].getPublicKey();
+				byte data[] = publicKey.getEncoded();
+				
+				for (int i = 0; i < data.length; i++)
+				{
+					if(data[i] != bytes[i])
+					{
+						Start.showError("Public key mismatch on " + targetURL);
+						return null;
+					}
+				}
+				
+				Start.showMessage("Certificate validated ok for " + targetURL);
+			}
+			
+			// Write ze postdata to ze server
+			DataOutputStream postDataStream = new DataOutputStream(https.getOutputStream());
+			postDataStream.writeBytes(postData);
+			postDataStream.flush();
+			postDataStream.close();
+			
+			// Get and concat the response
+			BufferedReader reader = new BufferedReader(new InputStreamReader(https.getInputStream()));
+			StringBuffer responseBuffer = new StringBuffer();
+			
+			String readLine;
+			while((readLine = reader.readLine()) != null) 
+			{
+				responseBuffer.append(readLine);
+				responseBuffer.append('\r');
+			}
+
+			reader.close();
+			responseData = responseBuffer.toString();
+			
+			https.disconnect();
+			https = null;
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+			
+			if(https != null)
+				https.disconnect();
+			
+			return null;
+		}
+		finally
+		{
+			if(https != null)
+			{
+				https.disconnect();
+			}
+		}
+		
+		return responseData;
+	}
+	
+	/**
+	 * Show a message on stdout
+	 * 
+	 * @param message
+	 */
+	private static void showMessage(String message)
+	{
+		System.out.println("[START] [INFO] " + message);
+	}
+
+	/**
+	 * Show a message on stderr
+	 * 
+	 * @param message
+	 */
+	private static void showError(String message)
+	{
+		System.err.println("[START] [ERROR] " + message);
+	}
+}