support for baking listener lists to classes

Mumfrey
1 parent 64ec9596
Showing 4 changed files with 547 additions and 230 deletions
java/client/com/mumfrey/liteloader/client/ClientEvents.java
java/common/com/mumfrey/liteloader/core/Events.java
java/common/com/mumfrey/liteloader/core/event/HandlerList.java
java/common/com/mumfrey/liteloader/core/runtime/Obf.java
 package com.mumfrey.liteloader.client;
-import java.util.LinkedList;
-
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityClientPlayerMP;
 import net.minecraft.client.gui.GuiNewChat;
@@ -29,6 +27,7 @@ import com.mumfrey.liteloader.core.ClientPluginChannels;
 import com.mumfrey.liteloader.core.Events;
 import com.mumfrey.liteloader.core.InterfaceRegistrationDelegate;
 import com.mumfrey.liteloader.core.LiteLoader;
+import com.mumfrey.liteloader.core.event.HandlerList;
 import com.mumfrey.liteloader.launch.LoaderProperties;
 import com.mumfrey.liteloader.transformers.event.EventInfo;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
@@ -76,95 +75,6 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 * 
 	 */
 	private boolean wasFullScreen = false;
-	
-	/**
-	 * 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 PostLoginListener and want to be notified post login
-	 */
-	private LinkedList<PostLoginListener> postLoginListeners = new LinkedList<PostLoginListener>();
-	
-	/**
-	 * List of mods which implement LoginListener interface and will receive
-	 * client login events
-	 */
-	private LinkedList<JoinGameListener> joinGameListeners = new LinkedList<JoinGameListener>();
-	
-	/**
-	 * List of mods which implement LoginListener interface and will receive
-	 * client login events
-	 */
-	private LinkedList<PreJoinGameListener> preJoinGameListeners = new LinkedList<PreJoinGameListener>();
-	
-	/**
-	 * List of mods which monitor outbound chat
-	 */
-	private LinkedList<OutboundChatListener> outboundChatListeners = new LinkedList<OutboundChatListener>();
-	
-	/**
-	 * List of mods which filter outbound chat
-	 */
-	private LinkedList<OutboundChatFilter> outboundChatFilters = new LinkedList<OutboundChatFilter>();
-
-	/**
-	 * List of mods which monitor changes in the viewport
-	 */
-	private LinkedList<ViewportListener> viewportListeners = new LinkedList<ViewportListener>();
-	
-	/**
-	 * List of mods which interact with the main minecraft FBO
-	 */
-	private LinkedList<FrameBufferListener> frameBufferListeners = new LinkedList<FrameBufferListener>();
 	/**
 	 * Hash code of the current world. We don't store the world reference here because we don't want
@@ -172,6 +82,23 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	private int worldHashCode = 0;
+	private HandlerList<Tickable>             tickListeners         = new HandlerList<Tickable>(Tickable.class);
+	private HandlerList<GameLoopListener>     loopListeners         = new HandlerList<GameLoopListener>(GameLoopListener.class);
+	private HandlerList<RenderListener>       renderListeners       = new HandlerList<RenderListener>(RenderListener.class);
+	private HandlerList<PostRenderListener>   postRenderListeners   = new HandlerList<PostRenderListener>(PostRenderListener.class);
+	private HandlerList<HUDRenderListener>    hudRenderListeners    = new HandlerList<HUDRenderListener>(HUDRenderListener.class);
+	private HandlerList<ChatRenderListener>   chatRenderListeners   = new HandlerList<ChatRenderListener>(ChatRenderListener.class);
+	private HandlerList<ChatListener>         chatListeners         = new HandlerList<ChatListener>(ChatListener.class);
+	private HandlerList<PostLoginListener>    postLoginListeners    = new HandlerList<PostLoginListener>(PostLoginListener.class);
+	private HandlerList<JoinGameListener>     joinGameListeners     = new HandlerList<JoinGameListener>(JoinGameListener.class);
+	private HandlerList<OutboundChatListener> outboundChatListeners = new HandlerList<OutboundChatListener>(OutboundChatListener.class);
+	private HandlerList<ViewportListener>     viewportListeners     = new HandlerList<ViewportListener>(ViewportListener.class);
+	private HandlerList<FrameBufferListener>  frameBufferListeners  = new HandlerList<FrameBufferListener>(FrameBufferListener.class);
+	private HandlerList<InitCompleteListener> initListeners         = new HandlerList<InitCompleteListener>(InitCompleteListener.class);
+	private HandlerList<ChatFilter>           chatFilters           = new HandlerList<ChatFilter>(ChatFilter.class);
+	private HandlerList<PreJoinGameListener>  preJoinGameListeners  = new HandlerList<PreJoinGameListener>(PreJoinGameListener.class);
+	private HandlerList<OutboundChatFilter>   outboundChatFilters   = new HandlerList<OutboundChatFilter>(OutboundChatFilter.class);
+
 	@SuppressWarnings("cast")
 	public ClientEvents(LiteLoader loader, GameEngineClient engine, LoaderProperties properties)
 	{
@@ -208,19 +135,20 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 		delegate.registerInterface(Tickable.class);
 		delegate.registerInterface(GameLoopListener.class);
-		delegate.registerInterface(InitCompleteListener.class);
 		delegate.registerInterface(RenderListener.class);
 		delegate.registerInterface(PostRenderListener.class);
-		delegate.registerInterface(ChatFilter.class);
-		delegate.registerInterface(ChatListener.class);
-		delegate.registerInterface(ChatRenderListener.class);
 		delegate.registerInterface(HUDRenderListener.class);
-		delegate.registerInterface(PreJoinGameListener.class);
+		delegate.registerInterface(ChatRenderListener.class);
+		delegate.registerInterface(ChatListener.class);
+		delegate.registerInterface(PostLoginListener.class);
 		delegate.registerInterface(JoinGameListener.class);
 		delegate.registerInterface(OutboundChatListener.class);
-		delegate.registerInterface(OutboundChatFilter.class);
 		delegate.registerInterface(ViewportListener.class);
 		delegate.registerInterface(FrameBufferListener.class);
+		delegate.registerInterface(InitCompleteListener.class);
+		delegate.registerInterface(ChatFilter.class);
+		delegate.registerInterface(PreJoinGameListener.class);
+		delegate.registerInterface(OutboundChatFilter.class);
 	}
 	/**
@@ -269,10 +197,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addTickListener(Tickable tickable)
 	{
-		if (!this.tickListeners.contains(tickable))
-		{
-			this.tickListeners.add(tickable);
-		}
+		this.tickListeners.add(tickable);
 	}
 	/**
@@ -280,10 +205,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addLoopListener(GameLoopListener loopListener)
 	{
-		if (!this.loopListeners.contains(loopListener))
-		{
-			this.loopListeners.add(loopListener);
-		}
+		this.loopListeners.add(loopListener);
 	}
 	/**
@@ -291,10 +213,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addInitListener(InitCompleteListener initCompleteListener)
 	{
-		if (!this.initListeners.contains(initCompleteListener))
-		{
-			this.initListeners.add(initCompleteListener);
-		}
+		this.initListeners.add(initCompleteListener);
 	}
 	/**
@@ -302,10 +221,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addRenderListener(RenderListener renderListener)
 	{
-		if (!this.renderListeners.contains(renderListener))
-		{
-			this.renderListeners.add(renderListener);
-		}
+		this.renderListeners.add(renderListener);
 	}
 	/**
@@ -313,10 +229,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addPostRenderListener(PostRenderListener postRenderListener)
 	{
-		if (!this.postRenderListeners.contains(postRenderListener))
-		{
-			this.postRenderListeners.add(postRenderListener);
-		}
+		this.postRenderListeners.add(postRenderListener);
 	}
 	/**
@@ -353,7 +266,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 		{
 			LiteLoaderLogger.warning("Interface error initialising mod '%1s'. A mod implementing ChatFilter and ChatListener is not supported! Remove one of these interfaces", chatListener.getName());
 		}
-		else if (!this.chatListeners.contains(chatListener))
+		else
 		{
 			this.chatListeners.add(chatListener);
 		}
@@ -364,10 +277,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addChatRenderListener(ChatRenderListener chatRenderListener)
 	{
-		if (!this.chatRenderListeners.contains(chatRenderListener))
-		{
-			this.chatRenderListeners.add(chatRenderListener);
-		}
+		this.chatRenderListeners.add(chatRenderListener);
 	}
 	/**
@@ -375,10 +285,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addHUDRenderListener(HUDRenderListener hudRenderListener)
 	{
-		if (!this.hudRenderListeners.contains(hudRenderListener))
-		{
-			this.hudRenderListeners.add(hudRenderListener);
-		}
+		this.hudRenderListeners.add(hudRenderListener);
 	}
 	/**
@@ -386,10 +293,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addPreJoinGameListener(PostLoginListener postLoginListener)
 	{
-		if (!this.postLoginListeners.contains(postLoginListener))
-		{
-			this.postLoginListeners.add(postLoginListener);
-		}
+		this.postLoginListeners.add(postLoginListener);
 	}
 	/**
@@ -397,10 +301,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addPreJoinGameListener(PreJoinGameListener joinGameListener)
 	{
-		if (!this.preJoinGameListeners.contains(joinGameListener))
-		{
-			this.preJoinGameListeners.add(joinGameListener);
-		}
+		this.preJoinGameListeners.add(joinGameListener);
 	}
 	/**
@@ -408,10 +309,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addJoinGameListener(JoinGameListener joinGameListener)
 	{
-		if (!this.joinGameListeners.contains(joinGameListener))
-		{
-			this.joinGameListeners.add(joinGameListener);
-		}
+		this.joinGameListeners.add(joinGameListener);
 	}
 	/**
@@ -419,10 +317,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addOutboundChatListener(OutboundChatListener outboundChatListener)
 	{
-		if (!this.outboundChatListeners.contains(outboundChatListener))
-		{
-			this.outboundChatListeners.add(outboundChatListener);
-		}
+		this.outboundChatListeners.add(outboundChatListener);
 	}
 	/**
@@ -430,10 +325,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addOutboundChatFiler(OutboundChatFilter outboundChatFilter)
 	{
-		if (!this.outboundChatFilters.contains(outboundChatFilter))
-		{
-			this.outboundChatFilters.add(outboundChatFilter);
-		}
+		this.outboundChatFilters.add(outboundChatFilter);
 	}
 	/**
@@ -441,10 +333,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addViewportListener(ViewportListener viewportListener)
 	{
-		if (!this.viewportListeners.contains(viewportListener))
-		{
-			this.viewportListeners.add(viewportListener);
-		}
+		this.viewportListeners.add(viewportListener);
 	}
 	/**
@@ -452,10 +341,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	public void addFrameBufferListener(FrameBufferListener frameBufferListener)
 	{
-		if (!this.frameBufferListeners.contains(frameBufferListener))
-		{
-			this.frameBufferListeners.add(frameBufferListener);
-		}
+		this.frameBufferListeners.add(frameBufferListener);
 	}
 	/**
@@ -499,14 +385,11 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 		if (this.wasFullScreen != minecraft.isFullScreen())
 		{
-			for (ViewportListener viewportListener : this.viewportListeners)
-				viewportListener.onFullScreenToggled(minecraft.isFullScreen());
+			this.viewportListeners.all().onFullScreenToggled(minecraft.isFullScreen());
 		}
 		this.wasFullScreen = minecraft.isFullScreen();
-		
-		for (ViewportListener viewportListener : this.viewportListeners)
-			viewportListener.onViewportResized(this.currentResolution, minecraft.displayWidth, minecraft.displayHeight);
+		this.viewportListeners.all().onViewportResized(this.currentResolution, minecraft.displayWidth, minecraft.displayHeight);
 	}
 	/**
@@ -514,8 +397,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	void onRender()
 	{
-		for (RenderListener renderListener : this.renderListeners)
-			renderListener.onRender();
+		this.renderListeners.all().onRender();
 	}
 	/**
@@ -524,9 +406,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	void postRenderEntities()
 	{
 		float partialTicks = (this.minecraftTimer != null) ? this.minecraftTimer.elapsedPartialTicks : 0.0F;
-		
-		for (PostRenderListener renderListener : this.postRenderListeners)
-			renderListener.onPostRenderEntities(partialTicks);
+		this.postRenderListeners.all().onPostRenderEntities(partialTicks);
 	}
 	/**
@@ -535,9 +415,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	void postRender()
 	{
 		float partialTicks = (this.minecraftTimer != null) ? this.minecraftTimer.elapsedPartialTicks : 0.0F;
-		
-		for (PostRenderListener renderListener : this.postRenderListeners)
-			renderListener.onPostRender(partialTicks);
+		this.postRenderListeners.all().onPostRender(partialTicks);
 	}
 	/**
@@ -549,8 +427,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 		if (!minecraft.skipRenderWorld && ref == (minecraft.theWorld == null ? 1 : 2))
 		{
-			for (RenderListener renderListener : this.renderListeners)
-				renderListener.onRenderGui(this.engineClient.getCurrentScreen());
+			this.renderListeners.all().onRenderGui(this.engineClient.getCurrentScreen());
 		}
 	}
@@ -559,8 +436,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	void onSetupCameraTransform()
 	{
-		for (RenderListener renderListener : this.renderListeners)
-			renderListener.onSetupCameraTransform();
+		this.renderListeners.all().onSetupCameraTransform();
 	}
 	/**
@@ -569,9 +445,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	void onRenderChat()
 	{
 		GuiNewChat chat = this.engineClient.getChatGUI();
-		
-		for (ChatRenderListener chatRenderListener : this.chatRenderListeners)
-			chatRenderListener.onPreRenderChat(this.screenWidth, this.screenHeight, chat);
+		this.chatRenderListeners.all().onPreRenderChat(this.screenWidth, this.screenHeight, chat);
 	}
 	/**
@@ -580,9 +454,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	void postRenderChat()
 	{
 		GuiNewChat chat = this.engineClient.getChatGUI();
-		
-		for (ChatRenderListener chatRenderListener : this.chatRenderListeners)
-			chatRenderListener.onPostRenderChat(this.screenWidth, this.screenHeight, chat);
+		this.chatRenderListeners.all().onPostRenderChat(this.screenWidth, this.screenHeight, chat);
 	}
 	/**
@@ -592,8 +464,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	{
 		if (!this.engineClient.hideGUI() || this.engineClient.getCurrentScreen() != null)
 		{
-			for (HUDRenderListener hudRenderListener : this.hudRenderListeners)
-				hudRenderListener.onPreRenderHUD(this.screenWidth, this.screenHeight);
+			this.hudRenderListeners.all().onPreRenderHUD(this.screenWidth, this.screenHeight);
 		}
 	}
@@ -604,8 +475,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	{
 		if (!this.engineClient.hideGUI() || this.engineClient.getCurrentScreen() != null)
 		{
-			for (HUDRenderListener hudRenderListener : this.hudRenderListeners)
-				hudRenderListener.onPostRenderHUD(this.screenWidth, this.screenHeight);
+			this.hudRenderListeners.all().onPostRenderHUD(this.screenWidth, this.screenHeight);
 		}
 	}
@@ -615,9 +485,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	void onTimerUpdate()
 	{
 		Minecraft minecraft = this.engine.getClient();
-		
-		for (GameLoopListener loopListener : this.loopListeners)
-			loopListener.onRunGameLoop(minecraft);
+		this.loopListeners.all().onRunGameLoop(minecraft);
 	}
 	/**
@@ -659,12 +527,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 		this.profiler.endSection();
 		// Iterate tickable mods
-		for (Tickable tickable : this.tickListeners)
-		{
-			this.profiler.startSection(tickable.getClass().getSimpleName().toLowerCase());
-			tickable.onTick(minecraft, partialTicks, inGame, clock);
-			this.profiler.endSection();
-		}
+		this.tickListeners.all().onTick(minecraft, partialTicks, inGame, clock);
 		// Detected world change
 		if (minecraft.theWorld != null)
@@ -714,8 +577,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 		}
 		// Chat listeners get the chat if no filter removed it
-		for (ChatListener chatListener : this.chatListeners)
-			chatListener.onChat(chat, message);
+		this.chatListeners.all().onChat(chat, message);
 		return true;
 	}
@@ -726,10 +588,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 	 */
 	void onSendChatMessage(C01PacketChatMessage packet, String message)
 	{
-		for (OutboundChatListener outboundChatListener : this.outboundChatListeners)
-		{
-			outboundChatListener.onSendChatMessage(packet, message);
-		}
+		this.outboundChatListeners.all().onSendChatMessage(packet, message);
 	}
 	/**
@@ -756,8 +615,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 			((ClientPluginChannelsClient)clientPluginChannels).onPostLogin(netHandler, loginPacket);
 		}
-		for (PostLoginListener loginListener : this.postLoginListeners)
-			loginListener.onPostLogin(netHandler, loginPacket);
+		this.postLoginListeners.all().onPostLogin(netHandler, loginPacket);
 	}
 	/**
@@ -796,25 +654,32 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 			((ClientPluginChannelsClient)clientPluginChannels).onJoinGame(netHandler, loginPacket);
 		}
-		for (JoinGameListener joinGameListener : this.joinGameListeners)
-			joinGameListener.onJoinGame(netHandler, loginPacket);
+		this.joinGameListeners.all().onJoinGame(netHandler, loginPacket);
 	}
+	/**
+	 * @param framebuffer
+	 */
 	void preRenderFBO(Framebuffer framebuffer)
 	{
-		for (FrameBufferListener frameBufferListener : this.frameBufferListeners)
-			frameBufferListener.preRenderFBO(framebuffer);
+		this.frameBufferListeners.all().preRenderFBO(framebuffer);
 	}
+	/**
+	 * @param framebuffer
+	 * @param width
+	 * @param height
+	 */
 	void onRenderFBO(Framebuffer framebuffer, int width, int height)
 	{
-		for (FrameBufferListener frameBufferListener : this.frameBufferListeners)
-			frameBufferListener.onRenderFBO(framebuffer, width, height);
+		this.frameBufferListeners.all().onRenderFBO(framebuffer, width, height);
 	}
+	/**
+	 * @param framebuffer
+	 */
 	void postRenderFBO(Framebuffer framebuffer)
 	{
-		for (FrameBufferListener frameBufferListener : this.frameBufferListeners)
-			frameBufferListener.postRenderFBO(framebuffer);
+		this.frameBufferListeners.all().postRenderFBO(framebuffer);
 	}
 }
 package com.mumfrey.liteloader.core;
-import java.util.LinkedList;
-
 import net.minecraft.client.resources.IResourceManager;
 import net.minecraft.client.resources.IResourceManagerReloadListener;
 import net.minecraft.command.ICommandManager;
@@ -30,6 +28,7 @@ import com.mumfrey.liteloader.api.InterfaceProvider;
 import com.mumfrey.liteloader.api.Listener;
 import com.mumfrey.liteloader.common.GameEngine;
 import com.mumfrey.liteloader.common.LoadingProgress;
+import com.mumfrey.liteloader.core.event.HandlerList;
 import com.mumfrey.liteloader.launch.LoaderProperties;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
@@ -61,17 +60,17 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	/**
 	 * List of mods which can filter server chat
 	 */
-	private LinkedList<ServerChatFilter> serverChatFilters = new LinkedList<ServerChatFilter>();
+	private HandlerList<ServerChatFilter> serverChatFilters = new HandlerList<ServerChatFilter>(ServerChatFilter.class);
 	/**
 	 * List of mods which provide server commands
 	 */
-	private LinkedList<ServerCommandProvider> serverCommandProviders = new LinkedList<ServerCommandProvider>();
+	private HandlerList<ServerCommandProvider> serverCommandProviders = new HandlerList<ServerCommandProvider>(ServerCommandProvider.class);
 	/**
 	 * List of mods which monitor server player events
 	 */
-	private LinkedList<ServerPlayerListener> serverPlayerListeners = new LinkedList<ServerPlayerListener>();
+	private HandlerList<ServerPlayerListener> serverPlayerListeners = new HandlerList<ServerPlayerListener>(ServerPlayerListener.class);
 	/**
 	 * Package private ctor
@@ -169,10 +168,7 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	public void addServerCommandProvider(ServerCommandProvider serverCommandProvider)
 	{
-		if (!this.serverCommandProviders.contains(serverCommandProvider))
-		{
-			this.serverCommandProviders.add(serverCommandProvider);
-		}
+		this.serverCommandProviders.add(serverCommandProvider);
 	}
 	/**
@@ -180,10 +176,7 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	public void addServerPlayerListener(ServerPlayerListener serverPlayerListener)
 	{
-		if (!this.serverPlayerListeners.contains(serverPlayerListener))
-		{
-			this.serverPlayerListeners.add(serverPlayerListener);
-		}
+		this.serverPlayerListeners.add(serverPlayerListener);
 	}
 	@Override
@@ -227,9 +220,7 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 		if (commandManager instanceof ServerCommandManager)
 		{
 			ServerCommandManager serverCommandManager = (ServerCommandManager)commandManager;
-			
-			for (ServerCommandProvider commandProvider : this.serverCommandProviders)
-				commandProvider.provideCommands(serverCommandManager);
+			this.serverCommandProviders.all().provideCommands(serverCommandManager);
 		}
 		LiteLoader.getServerPluginChannels().onServerStartup();
@@ -242,8 +233,7 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	public void onSpawnPlayer(ServerConfigurationManager scm, EntityPlayerMP player, GameProfile profile)
 	{
-		for (ServerPlayerListener serverPlayerListener : this.serverPlayerListeners)
-			serverPlayerListener.onPlayerConnect(player, profile);
+		this.serverPlayerListeners.all().onPlayerConnect(player, profile);
 	}
 	/**
@@ -262,8 +252,7 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	public void onInitializePlayerConnection(ServerConfigurationManager scm, NetworkManager netManager, EntityPlayerMP player)
 	{
-		for (ServerPlayerListener serverPlayerListener : this.serverPlayerListeners)
-			serverPlayerListener.onPlayerLoggedIn(player);
+		this.serverPlayerListeners.all().onPlayerLoggedIn(player);
 	}
 	/**
@@ -275,8 +264,7 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	public void onRespawnPlayer(ServerConfigurationManager scm, EntityPlayerMP player, EntityPlayerMP oldPlayer, int dimension, boolean won)
 	{
-		for (ServerPlayerListener serverPlayerListener : this.serverPlayerListeners)
-			serverPlayerListener.onPlayerRespawn(player, oldPlayer, dimension, won);
+		this.serverPlayerListeners.all().onPlayerRespawn(player, oldPlayer, dimension, won);
 	}
 	/**
@@ -285,15 +273,24 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	public void onPlayerLogout(ServerConfigurationManager scm, EntityPlayerMP player)
 	{
-		for (ServerPlayerListener serverPlayerListener : this.serverPlayerListeners)
-			serverPlayerListener.onPlayerLogout(player);
+		this.serverPlayerListeners.all().onPlayerLogout(player);
 	}
+	/**
+	 * @param clock
+	 * @param partialTicks
+	 * @param inGame
+	 */
 	protected void onTick(boolean clock, float partialTicks, boolean inGame)
 	{
 		this.loader.onTick(clock, partialTicks, inGame);
 	}
+	/**
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 */
 	protected void onPostRender(int mouseX, int mouseY, float partialTicks)
 	{
 		this.loader.onPostRender(mouseX, mouseY, partialTicks);		
+package com.mumfrey.liteloader.core.event;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import net.minecraft.launchwrapper.Launch;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.*;
+
+import com.mumfrey.liteloader.core.runtime.Obf;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+import com.sun.xml.internal.ws.org.objectweb.asm.Opcodes;
+
+/**
+ * HandlerList is a generic class which supports baking a list of event handlers into a dynamic inner
+ * class for invokation at runtime.
+ * 
+ * @author Adam Mummery-Smith
+ *
+ * @param <T>
+ */
+public class HandlerList<T> extends LinkedList<T>
+{
+	private static final long serialVersionUID = 1L;
+
+	private static final int MAX_UNCOLLECTED_CLASSES = 5000;
+	
+	private static int uncollectedHandlerLists = 0;
+
+	/**
+	 * Type of the interface for objects in this handler list
+	 */
+	private Class<T> type;
+	
+	/**
+	 * Current baked handler list, we cook them at gas mark 5 for 30 minutes in a disposable classloader whic
+	 * also handles the transformation for us
+	 */
+	private BakedHandlerList<T> bakedHandler;
+	
+	/**
+	 * @param type
+	 */
+	public HandlerList(Class<T> type)
+	{
+		if (!type.isInterface())
+		{
+			throw new IllegalArgumentException("HandlerList type argument must be an interface");
+		}	
+		
+		this.type = type;
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#add(java.lang.Object)
+	 */
+	@Override
+	public boolean add(T listener)
+	{
+		if (!this.contains(listener))
+		{
+			super.add(listener);
+			this.invalidate();
+		}
+		
+		return true;
+	}
+
+	/**
+	 * Invalidate current baked list
+	 */
+	public void invalidate()
+	{
+		this.bakedHandler = null;
+		HandlerList.uncollectedHandlerLists++;
+		if (HandlerList.uncollectedHandlerLists > HandlerList.MAX_UNCOLLECTED_CLASSES)
+		{
+			System.gc();
+			HandlerList.uncollectedHandlerLists = 0;
+		}
+	}
+	
+	/**
+	 * Returns the baked list of all listeners
+	 * 
+	 * @return
+	 */
+	public T all()
+	{
+		if (this.bakedHandler == null)
+		{
+			HandlerListClassLoader<T> classLoader = new HandlerListClassLoader<T>(this.type, this.size());
+			this.bakedHandler = classLoader.newHandler();
+			this.bakedHandler.populate(this);
+		}
+		
+		return this.bakedHandler.get();
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#remove()
+	 */
+	@Override
+	public T remove()
+	{
+		throw new UnsupportedOperationException("'remove' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#remove(int)
+	 */
+	@Override
+	public T remove(int index)
+	{
+		throw new UnsupportedOperationException("'remove' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#remove(java.lang.Object)
+	 */
+	@Override
+	public boolean remove(Object o)
+	{
+		throw new UnsupportedOperationException("'remove' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.AbstractCollection#removeAll(java.util.Collection)
+	 */
+	@Override
+	public boolean removeAll(Collection<?> c)
+	{
+		throw new UnsupportedOperationException("'removeAll' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#removeFirst()
+	 */
+	@Override
+	public T removeFirst()
+	{
+		throw new UnsupportedOperationException("'removeFirst' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#removeFirstOccurrence(java.lang.Object)
+	 */
+	@Override
+	public boolean removeFirstOccurrence(Object o)
+	{
+		throw new UnsupportedOperationException("'removeFirstOccurrence' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#removeLast()
+	 */
+	@Override
+	public T removeLast()
+	{
+		throw new UnsupportedOperationException("'removeLast' is not supported for HandlerList");
+	}
+	
+	/* (non-Javadoc)
+	 * @see java.util.LinkedList#removeLastOccurrence(java.lang.Object)
+	 */
+	@Override
+	public boolean removeLastOccurrence(Object o)
+	{
+		throw new UnsupportedOperationException("'removeLastOccurrence' is not supported for HandlerList");
+	}
+	
+	/**
+	 * Base class for baked handler lists 
+	 * 
+	 * @author Adam Mummery-Smith
+	 *
+	 * @param <T>
+	 */
+	public static abstract class BakedHandlerList<T>
+	{
+		public abstract T get();
+
+		public abstract void populate(List<T> listeners);
+	}
+	
+	/**
+	 * ClassLoader which generates the baked handler list
+	 * 
+	 * @author Adam Mummery-Smith
+	 * @param <T>
+	 */
+	static class HandlerListClassLoader<T> extends URLClassLoader
+	{
+		/**
+		 * Unique index number, just to ensure no name clashes
+		 */
+		private static int handlerIndex;
+
+		private int lineNumber = 1;
+
+		private final Class<T> type;
+		
+		private final String typeRef;
+		
+		private int size;
+		
+		/**
+		 * @param type
+		 * @param size
+		 */
+		HandlerListClassLoader(Class<T> type, int size)
+		{
+			super(new URL[0], Launch.classLoader);
+			this.type = type;
+			this.typeRef = type.getName().replace('.', '/');
+			this.size = size;
+		}
+		
+		/**
+		 * Create and return a new baked handler list
+		 */
+		@SuppressWarnings("unchecked")
+		public BakedHandlerList<T> newHandler()
+		{
+			try
+			{
+				String className = this.getNextClassName();
+				Class<BakedHandlerList<T>> handlerClass = (Class<BakedHandlerList<T>>)this.loadClass(className);
+				Constructor<BakedHandlerList<T>> ctor = handlerClass.getDeclaredConstructor();
+				ctor.setAccessible(true);
+				return ctor.newInstance();
+			}
+			catch (Exception ex)
+			{
+				throw new RuntimeException(ex);
+			}
+		}
+
+		@Override
+		protected Class<?> findClass(String name) throws ClassNotFoundException
+		{
+			try
+			{
+				byte[] bytes = Launch.classLoader.getClassBytes(Obf.BakedHandlerList.name);
+				ClassReader classReader = new ClassReader(bytes);
+				ClassNode classNode = new ClassNode();
+				classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
+				
+				this.transform(name, classNode);
+				
+				ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+				classNode.accept(classWriter);
+				bytes = classWriter.toByteArray();
+				return this.defineClass(name, bytes, 0, bytes.length);
+			}
+			catch (Throwable th)
+			{
+				th.printStackTrace();
+				return null;
+			}
+		}
+
+		private void transform(String name, ClassNode classNode)
+		{
+			LiteLoaderLogger.info("Baking listener list for %s with %d listeners", this.type.getSimpleName(), this.size);
+			LiteLoaderLogger.debug("Generating: %s", name);
+			
+			this.populateClass(name, classNode);
+			this.transformMethods(name, classNode);
+			this.injectInterfaceMethods(name, classNode);
+		}
+
+		private void populateClass(String name, ClassNode classNode)
+		{
+			classNode.access = classNode.access & ~Opcodes.ACC_ABSTRACT;
+			classNode.name = name.replace('.', '/');
+			classNode.superName = Obf.BakedHandlerList.ref;
+			classNode.interfaces.add(this.type.getName().replace('.', '/'));
+			classNode.sourceFile = "Dynamic";
+
+			for (int i = 0; i < this.size; i++)
+			{
+				classNode.fields.add(new FieldNode(Opcodes.ACC_PRIVATE, "handler$" + i, "L" + this.typeRef + ";", null, null));
+			}
+		}
+
+		private void transformMethods(String name, ClassNode classNode)
+		{
+			for (Iterator<MethodNode> methodIterator = classNode.methods.iterator(); methodIterator.hasNext();)
+			{
+				MethodNode method = methodIterator.next();
+				if (Obf.constructor.name.equals(method.name))
+				{
+					this.processCtor(classNode, method);
+				}
+				else if ("get".equals(method.name))
+				{
+					this.processGet(classNode, method);
+				}
+				else if ("populate".equals(method.name))
+				{
+					this.processPopulate(classNode, method);
+				}
+			}
+		}
+		
+		private void processCtor(ClassNode classNode, MethodNode method)
+		{
+			for (Iterator<AbstractInsnNode> iter = method.instructions.iterator(); iter.hasNext();)
+			{
+				AbstractInsnNode insn = iter.next();
+				if (insn instanceof MethodInsnNode)
+				{
+					MethodInsnNode methodInsn = (MethodInsnNode)insn;
+					if (methodInsn.owner.equals("java/lang/Object"))
+					{
+						methodInsn.owner = Obf.BakedHandlerList.ref;
+					}
+				}
+			}
+		}
+
+		private void processGet(ClassNode classNode, MethodNode method)
+		{
+			method.access = method.access & ~Opcodes.ACC_ABSTRACT;
+			method.instructions.clear();
+
+			method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+			method.instructions.add(new InsnNode(Opcodes.ARETURN));
+		}
+
+		private void processPopulate(ClassNode classNode, MethodNode method)
+		{
+			method.access = method.access & ~Opcodes.ACC_ABSTRACT;
+			method.instructions.clear();
+			
+			for (int i = 0; i < this.size; i++)
+			{
+				method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+				method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 1));
+				method.instructions.add(new IntInsnNode(Opcodes.BIPUSH, i));
+				method.instructions.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;", true));
+				method.instructions.add(new TypeInsnNode(Opcodes.CHECKCAST, this.typeRef));
+				method.instructions.add(new FieldInsnNode(Opcodes.PUTFIELD, classNode.name, "handler$" + i, "L" + this.typeRef + ";"));
+			}		
+
+			method.instructions.add(new InsnNode(Opcodes.RETURN));
+		}
+
+		private void injectInterfaceMethods(String name, ClassNode classNode)
+		{
+			try
+			{
+				String interfaceName = this.type.getName(); 
+				this.injectInterfaceMethods(classNode, interfaceName);
+			}
+			catch (IOException ex)
+			{
+				ex.printStackTrace();
+			}
+		}
+
+		private void injectInterfaceMethods(ClassNode classNode, String interfaceName) throws IOException
+		{
+			ClassReader interfaceReader = new ClassReader(this.getInterfaceBytes(interfaceName));
+			ClassNode interfaceNode = new ClassNode();
+			interfaceReader.accept(interfaceNode, 0);
+			
+			for (MethodNode interfaceMethod : interfaceNode.methods)
+			{
+				classNode.methods.add(interfaceMethod);
+				this.populateInterfaceMethod(classNode, interfaceMethod);
+			}
+			
+			for (String parentInterface : interfaceNode.interfaces)
+			{
+				this.injectInterfaceMethods(classNode, parentInterface.replace('/', '.'));
+			}
+		}
+
+		private void populateInterfaceMethod(ClassNode classNode, MethodNode method)
+		{
+			Type returnType = Type.getReturnType(method.desc);
+			
+			if (returnType.equals(Type.VOID_TYPE))
+			{
+				Type[] args = Type.getArgumentTypes(method.desc);
+				method.access = Opcodes.ACC_PUBLIC;
+				
+				for (int i = 0; i < this.size; i++)
+				{
+					LabelNode lineNumberLabel = new LabelNode(new Label());
+					method.instructions.add(lineNumberLabel);
+					method.instructions.add(new LineNumberNode(++this.lineNumber, lineNumberLabel));
+					method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+					method.instructions.add(new FieldInsnNode(Opcodes.GETFIELD, classNode.name, "handler$" + i, "L" + this.typeRef + ";"));
+					this.invokeInterfaceMethod(method, args);
+				}		
+				
+				method.instructions.add(new InsnNode(Opcodes.RETURN));
+			}
+		}
+
+		private void invokeInterfaceMethod(MethodNode method, Type[] args)
+		{
+			int argNumber = 1;
+			for (Type type : args)
+			{
+				method.instructions.add(new VarInsnNode(type.getOpcode(Opcodes.ILOAD), argNumber));
+				argNumber += type.getSize();
+			}
+			
+			method.instructions.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, this.typeRef, method.name, method.desc, true));
+		}
+
+		private String getNextClassName()
+		{
+			return String.format("%s$%s$%s", Obf.HandlerList.name, this.type.getSimpleName(), HandlerListClassLoader.handlerIndex++);
+		}
+
+		private byte[] getInterfaceBytes(String name) throws IOException
+		{
+			byte[] bytes = Launch.classLoader.getClassBytes(name);
+
+			final List<IClassTransformer> transformers = Launch.classLoader.getTransformers();
+			
+			for (final IClassTransformer transformer : transformers)
+			{
+				try
+				{
+					bytes = transformer.transform(name, name, bytes);
+				}
+				catch (Exception ex)
+				{
+					ex.printStackTrace();
+				}
+			}
+			
+			return bytes;
+		}
+	}
+}
@@ -17,6 +17,8 @@ public class Obf
 	public static final Obf          CallbackProxyClient = new Obf("com.mumfrey.liteloader.client.CallbackProxyClient"                 );
 	public static final Obf          CallbackProxyServer = new Obf("com.mumfrey.liteloader.server.CallbackProxyServer"                 );
 	public static final Obf                   EventProxy = new Obf("com.mumfrey.liteloader.core.event.EventProxy"                      );
+	public static final Obf                  HandlerList = new Obf("com.mumfrey.liteloader.core.event.HandlerList"                     );
+	public static final Obf             BakedHandlerList = new Obf("com.mumfrey.liteloader.core.event.HandlerList$BakedHandlerList"    );
 	public static final Obf                   LoadingBar = new Obf("com.mumfrey.liteloader.client.gui.startup.LoadingBar"              );
 	public static final Obf                  GameProfile = new Obf("com.mojang.authlib.GameProfile"                                    );
 	public static final Obf                MinecraftMain = new Obf("net.minecraft.client.main.Main"                                    );