Update version to 4.0.0 for release

Fixes #204

.github/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+Contributing to ProtocolLib
+===========================
+This page will detail specific things that must be done if you intend to contribute to this project.
+
+## Updating ProtocolLib to a New Protocol Version
+#### Before we get started:
+1. **When do we need to update the protocol version?**
+    _A Minecraft protocol version is a number for each specification of the Minecraft protocol.
+    This means it is incremented when there is a change to the [Protocol Specification](http://wiki.vg/Protocol),
+    but not necessarily for each Minecraft version update. If the latest Minecraft version contains a protocol change,
+    that means ProtocolLib needs to be updated._
+2. **When do we need to update other parts of ProtocolLib?**
+    _When the package version guard changes. The package version guard is the version string inserted
+    into the package identifier for CraftBukkit and net.minecraft.server (e.g. v1_9_R2). It is incremented
+    by Spigot if there is a major breaking change in the internal server code. This is to encourage plugins
+    that interact directly with CraftBukkit/nms code to update more specifically. However, since most of
+    ProtocolLib uses reflection, and the structure of packet classes is generally static, one will have
+    to go through the code and change imports from nms/CraftBukkit._
+
+#### Ready? Let's get started!
+1. Read the [Protocol Changes](http://wiki.vg/Protocol_History). Always make sure the list is both
+complete and correct. If you're unsure, don't hesitate to ask in #mcdevs (the people who maintain wiki.vg) on [freenode.net](http://freenode.net)
+or #spigot on [irc.spi.gt](http://irc.spi.gt) ([webchat](https://irc.spi.gt/iris/?channels=spigot)).
+2. Search for usages of the now-defunct NMS package guard and change them.
+3. The class `com.comphenix.protocol.PacketType` contains a list of all the packets. If any packets were added or removed
+(or had their ID changed), make sure to update this list. If a packet was removed
+in favor of usage of another packet, instead of removing it, move it to the bottom of the list
+in its section, add a deprecation warning to it, and redirect it to the packet that replaced it.
+4. `mvn` in the root directory to build the project.
+5. If tests fail in the maven build, go through the tests to make sure you removed references to any removed packets
+and changed the NMS version guards.
+6. Increment the package version in `com.comphenix.protocol.utility.Constants`.
+7. `com.comphenix.protocol.ProtocolLibrary` contains several constants that must be updated, including the Minecraft version
+and the release date.
+8. `com.comphenix.protocol.utility.MinecraftProtocolVersion` contains a map of all the protocol version integers.
+If the protocol version has been incremented, add a new line to the map.
+9. `mvn` in root directory again. If it builds successfully, test on the appropriate version of a Spigot server. If
+the build fails, debug!

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,10 @@
+_Follow this template except for feature requests. Use pastebin when providing /protocol dump and any relevant errors._
+
+Make sure you've done the following:
+- [ ] You're using the latest build for your server version
+- [ ] This isn't an issue caused by another plugin
+- [ ] You've checked for duplicate issues
+
+Debug paste link:
+
+Description and relevant errors:

.gitignore

@@ -0,0 +1,178 @@
+#################
+## Eclipse
+#################
+
+# Generic project files
+.project
+.classpath
+.settings/
+bin/
+.idea/
+.iml
+.ipr
+.iws
+
+*.pydevproject
+.metadata
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.loadpath
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# CDT-specific
+.cproject
+
+# PDT-specific
+.buildpath
+
+#################
+## Maven
+#################
+
+target/
+dependency-reduced-pom.xml
+
+#################
+## Visual Studio
+#################
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.sln.docstates
+
+# Build results
+[Dd]ebug/
+[Rr]elease/
+*_i.c
+*_p.c
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.vspscc
+.builds
+*.dotCover
+
+## TODO: If you have NuGet Package Restore enabled, uncomment this
+#packages/
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+
+# Visual Studio profiler
+*.psess
+*.vsp
+
+# ReSharper is a .NET coding add-in
+_ReSharper*
+
+# Installshield output folder
+[Ee]xpress
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish
+
+# Others
+[Bb]in
+[Oo]bj
+sql
+TestResults
+*.Cache
+ClientBin
+stylecop.*
+~$*
+*.dbmdl
+Generated_Code #added for RIA/Silverlight projects
+
+# Backup & report files from converting an old project file to a newer
+# Visual Studio version. Backup files are not needed, because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+
+
+
+############
+## Windows
+############
+
+# Windows image file caches
+Thumbs.db
+
+# Folder config file
+Desktop.ini
+
+
+#############
+## Python
+#############
+
+*.py[co]
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+
+# Mac crap
+.DS_Store
+
+# Log4J files
+logs/

.travis.yml

@@ -0,0 +1,13 @@
+language: java
+jdk:
+  - oraclejdk8
+  - oraclejdk7
+script: mvn clean test
+#before_install: cd ProtocolLib
+install: true
+notifications:
+  email:
+    recipients:
+      - "dmulloy2@live.com"
+    on_success: change
+    on_failure: always

ItemDisguise/.classpath

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
-	<classpathentry kind="lib" path="D:/Games/Minecraft/Server Mods/API/bukkit-1.3.1-R2.0.jar"/>
-	<classpathentry kind="lib" path="/ProtocolLib/bin/ProtocolLib.jar"/>
-	<classpathentry kind="output" path="class"/>
-</classpath>

ItemDisguise/.project

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>ItemDisguise</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

ItemDisguise/.settings/org.eclipse.jdt.core.prefs

@@ -1,11 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.7
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.7

ItemDisguise/src/com/comphenix/itemdisguise/HideEnchantmentsListener.java

@@ -1,119 +0,0 @@
-/*
- *  ItemDisguise - A simple Bukkit plugin that illustrates how to use ProtocolLib.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.itemdisguise;
-
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.bukkit.Server;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.events.ConnectionSide;
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.reflect.FieldAccessException;
-
-public class HideEnchantmentsListener {
-
-	private final Server server;
-	private final Logger logger;
-	
-	public HideEnchantmentsListener(Server server, Logger logger) {
-		this.server = server;
-		this.logger = logger;
-	}
-	
-	public void addListener(ProtocolManager protocolManager, JavaPlugin plugin) {
-
-		// Hide all enchantments
-		protocolManager.addPacketListener(new PacketAdapter(plugin, ConnectionSide.SERVER_SIDE, 0x67, 0x68, 0x3E) {
-			@Override
-			public void onPacketSending(PacketEvent event) {
-				PacketContainer packet = event.getPacket();
-				
-				try {
-					// Item packets
-					switch (event.getPacketID()) {
-					case 0x67: // Set slot
-						removeEnchantments(packet.getItemModifier().read(0));
-						break;
-						
-					case 0x68: // Set Window Items
-						ItemStack[] elements = packet.getItemArrayModifier().read(0);
-	
-						for (int i = 0; i < elements.length; i++) {
-							if (elements[i] != null) {
-								removeEnchantments(elements[i]);
-							}
-						}
-						break;
-						
-					case 0x3E: // Sound effect
-						event.setCancelled(true);
-						break;
-					}
-				
-				} catch (FieldAccessException e) {
-					logger.log(Level.SEVERE, "Couldn't access field.", e);
-				}
-			}
-		});
-		
-		// Censor
-		protocolManager.addPacketListener(new PacketAdapter(plugin, ConnectionSide.CLIENT_SIDE, 0x3) {
-			@Override
-			public void onPacketReceiving(PacketEvent event) {
-				if (event.getPacketID() == 0x3) {
-					try {
-						String message = event.getPacket().
-											getSpecificModifier(String.class).read(0);
-						
-						if (message.contains("shit") || message.contains("fuck")) {
-							event.setCancelled(true);
-							event.getPlayer().sendMessage("Bad manners!");
-						}
-						
-					} catch (FieldAccessException e) {
-						logger.log(Level.SEVERE, "Couldn't access field.", e);
-					}
-				}
-			}
-		});
-	}
-	
-	public Server getServer() {
-		return server;
-	}
-	
-	public void removeListener(ProtocolManager protocolManager, JavaPlugin plugin) {
-		// Just remove every adapter with this plugin
-		protocolManager.removePacketListeners(plugin);
-	}
-	
-	private void removeEnchantments(ItemStack stack) {
-		Object[] copy = stack.getEnchantments().keySet().toArray();
-		
-		for (Object enchantment : copy) {
-			stack.removeEnchantment((Enchantment) enchantment);
-		}
-	}
-}

ItemDisguise/src/com/comphenix/itemdisguise/ItemDisguiseMod.java

@@ -1,99 +0,0 @@
-/*
- *  ItemDisguise - A simple Bukkit plugin that illustrates how to use ProtocolLib.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.itemdisguise;
-
-import java.util.logging.Logger;
-
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.events.PacketContainer;
-
-public class ItemDisguiseMod extends JavaPlugin {
-	
-	private ProtocolManager protocolManager;
-	private Logger logger;
-	
-	private HideEnchantmentsListener enchantmentsListener;
-	
-	@Override
-	public void onEnable() {
-
-		logger = getLoggerSafely();
-		protocolManager = ProtocolLibrary.getProtocolManager();
-		
-		enchantmentsListener = new HideEnchantmentsListener(getServer(), logger);
-		enchantmentsListener.addListener(protocolManager, this);
-	}
-
-	@Override
-	public void onDisable() {
-		enchantmentsListener.removeListener(protocolManager, this);
-	}
-	
-	@Override
-	public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-		if (sender instanceof Player) {
-		
-			Player player = (Player) sender;
-			
-			if (label.equalsIgnoreCase("explosion")) {
-				PacketContainer fakeExplosion = protocolManager.createPacket(0x3C);
-				
-				// Set the coordinates
-				try {
-					fakeExplosion.getSpecificModifier(double.class).
-					    write(0, player.getLocation().getX()).
-					    write(1, player.getLocation().getY()).
-					    write(2, player.getLocation().getZ());
-					fakeExplosion.getSpecificModifier(float.class).
-						write(0, 3.0F);
-
-					protocolManager.sendServerPacket(player, fakeExplosion);
-					
-				} catch (Exception e) {
-					e.printStackTrace();
-				}
-			}
-			
-			return true;
-		}
-		
-		return false;
-	}
-	
-	// Get the Bukkit logger first, before we try to create our own
-	private Logger getLoggerSafely() {
-		
-		Logger log = null;
-	
-		try {
-			log = getLogger();
-		} catch (Throwable e) {
-			// We'll handle it
-		}
-		
-		if (log == null)
-			log = Logger.getLogger("Minecraft");
-		return log;
-	}
-}

ItemDisguise/src/plugin.yml

@@ -1,14 +0,0 @@
-name: ItemDisguiseMod
-version: 1.0.0
-description: Change the appearance of inventory items.
-author: Comphenix
-website: http://www.comphenix.net/ItemDisguise
-
-main: com.comphenix.itemdisguise.ItemDisguiseMod
-depends: [ProtocolLib]
-database: false
-
-commands:
-   explosion:
-      description: Creates a fake explosion around the caller.
-      usage: /<command>

License.txt

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

ProtocolLib/.classpath

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" output="class_test" path="test"/>
-	<classpathentry kind="lib" path="D:/Games/Minecraft/Server Mods/Server/craftbukkit-1.3.1-R2.0.jar"/>
-	<classpathentry kind="lib" path="lib/cglib-nodep-2.2.3.jar">
-		<attributes>
-			<attribute name="javadoc_location" value="jar:file:/D:/Kristian/Programmer/Binaries/cglib.2.2.3/cglib-docs-2.2.3.jar!/"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jre6"/>
-	<classpathentry kind="output" path="class"/>
-</classpath>

ProtocolLib/.project

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>ProtocolLib</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

ProtocolLib/.settings/org.eclipse.jdt.core.prefs

@@ -1,11 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.6

ProtocolLib/Java.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<project default="compile" name="Project ItemDisguise" basedir=".">
-    <!--ANT 1.7 is required                                        -->
-    <target name="compile">
-        <jar destfile="bin/ProtocolLib.jar" filesetmanifest="mergewithoutmain" excludes="test/*">
-            <manifest>
-                <attribute name="Main-Class" value="com.comphenix.itemdisguise.Application"/>
-                <attribute name="Class-Path" value="."/>
-            </manifest>
-            <fileset dir="class"/>
-            <zipfileset excludes="META-INF/*.SF" src="lib/cglib-nodep-2.2.3.jar"/>
-        </jar>
-    </target>
-</project>

ProtocolLib/src/com/comphenix/protocol/AsynchronousManager.java

@@ -1,77 +0,0 @@
-package com.comphenix.protocol;
-
-import java.util.Set;
-import java.util.logging.Logger;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.async.AsyncListenerHandler;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-
-/**
- * Represents a asynchronous packet handler.
- * 
- * @author Kristian
- */
-public interface AsynchronousManager {
-
-	/**
-	 * Registers an asynchronous packet handler.
-	 * <p>
-	 * To start listening asynchronously, pass the getListenerLoop() runnable to a different thread.
-	 * @param listener - the packet listener that will recieve these asynchronous events.
-	 * @return An asynchrouns handler.
-	 */
-	public abstract AsyncListenerHandler registerAsyncHandler(PacketListener listener);
-
-	/**
-	 * Unregisters and closes the given asynchronous handler.
-	 * @param handler - asynchronous handler.
-	 */
-	public abstract void unregisterAsyncHandler(AsyncListenerHandler handler);
-
-	/**
-	 * Unregisters every asynchronous handler associated with this plugin.
-	 * @param plugin - the original plugin.
-	 */
-	public void unregisterAsyncHandlers(Plugin plugin);
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the sent server packets that will be 
-	 * observed by the asynchronous listeners.
-	 * @return Every filtered server packet.
-	 */
-	public abstract Set<Integer> getSendingFilters();
-
-	/**
-	 * Retrieves a immutable set containing the ID of the recieved client packets that will be
-	 * observed by the asynchronous listeners.
-	 * @return Every filtered client packet.
-	 */
-	public abstract Set<Integer> getReceivingFilters();
-
-	/**
-	 * Determine if a given synchronous packet has asynchronous listeners.
-	 * @param packet - packet to test.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public abstract boolean hasAsynchronousListeners(PacketEvent packet);
-
-	/**
-	 * Retrieve the default packet stream.
-	 * @return Default packet stream.
-	 */
-	public abstract PacketStream getPacketStream();
-
-	/**
-	 * Retrieve the default error logger.
-	 * @return Default logger.
-	 */
-	public abstract Logger getLogger();
-
-	/**
-	 * Remove listeners, close threads and transmit every delayed packet.
-	 */
-	public abstract void cleanupAll();
-}

ProtocolLib/src/com/comphenix/protocol/PacketStream.java

@@ -1,55 +0,0 @@
-package com.comphenix.protocol;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.events.PacketContainer;
-
-/**
- * Represents a object capable of sending or receiving packets.
- * 
- * @author Kristian
- */
-public interface PacketStream {
-	
-	/**
-	 * Send a packet to the given player.
-	 * @param reciever - the reciever.
-	 * @param packet - packet to send.
-	 * @throws InvocationTargetException - if an error occured when sending the packet.
-	 */
-	public void sendServerPacket(Player reciever, PacketContainer packet) 
-			throws InvocationTargetException;
-
-	/**
-	 * Send a packet to the given player.
-	 * @param reciever - the reciever.
-	 * @param packet - packet to send.
-	 * @param filters - whether or not to invoke any packet filters.
-	 * @throws InvocationTargetException - if an error occured when sending the packet.
-	 */
-	public void sendServerPacket(Player reciever, PacketContainer packet, boolean filters)
-			throws InvocationTargetException;
-
-	/**
-	 * Simulate recieving a certain packet from a given player.
-	 * @param sender - the sender.
-	 * @param packet - the packet that was sent.
-	 * @throws InvocationTargetException If the reflection machinery failed.
-	 * @throws IllegalAccessException If the underlying method caused an error.
-	 */
-	public void recieveClientPacket(Player sender, PacketContainer packet) 
-			throws IllegalAccessException, InvocationTargetException;
-
-	/**
-	 * Simulate recieving a certain packet from a given player.
-	 * @param sender - the sender.
-	 * @param packet - the packet that was sent.
-	 * @param filters - whether or not to invoke any packet filters.
-	 * @throws InvocationTargetException If the reflection machinery failed.
-	 * @throws IllegalAccessException If the underlying method caused an error.
-	 */
-	public void recieveClientPacket(Player sender, PacketContainer packet, boolean filters)
-			throws IllegalAccessException, InvocationTargetException;
-}

ProtocolLib/src/com/comphenix/protocol/ProtocolLibrary.java

@@ -1,180 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol;
-
-import java.io.IOException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.bukkit.Server;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import com.comphenix.protocol.async.AsyncFilterManager;
-import com.comphenix.protocol.injector.PacketFilterManager;
-import com.comphenix.protocol.metrics.Statistics;
-import com.comphenix.protocol.reflect.compiler.BackgroundCompiler;
-
-public class ProtocolLibrary extends JavaPlugin {
-	
-	// There should only be one protocol manager, so we'll make it static
-	private static PacketFilterManager protocolManager;
-	
-	// Error logger
-	private Logger logger;
-	
-	// Metrics and statistisc
-	private Statistics statistisc;
-	
-	// Structure compiler
-	private BackgroundCompiler backgroundCompiler;
-	
-	// Used to clean up server packets that have expired. 
-	// But mostly required to simulate recieving client packets.
-	private int asyncPacketTask = -1;
-	private int tickCounter = 0;
-	private static final int ASYNC_PACKET_DELAY = 1;
-	
-	@Override
-	public void onLoad() {
-		logger = getLoggerSafely();
-		protocolManager = new PacketFilterManager(getClassLoader(), getServer(), logger);
-	}
-	
-	@Override
-	public void onEnable() {
-		Server server = getServer();
-		PluginManager manager = server.getPluginManager();
-		
-		// Initialize background compiler
-		if (backgroundCompiler == null) {
-			backgroundCompiler = new BackgroundCompiler(getClassLoader());
-			BackgroundCompiler.setInstance(backgroundCompiler);
-		}
-
-		// Notify server managers of incompatible plugins
-		checkForIncompatibility(manager);
-		
-		// Player login and logout events
-		protocolManager.registerEvents(manager, this);
-		
-		// Inject our hook into already existing players
-		protocolManager.initializePlayers(server.getOnlinePlayers());
-		
-		// Timeout
-		createAsyncTask(server);
-		
-		// Try to enable statistics
-		try {
-			statistisc = new Statistics(this);
-		} catch (IOException e) {
-			logger.log(Level.SEVERE, "Unable to enable metrics.", e);
-		} catch (Throwable e) {
-			logger.log(Level.SEVERE, "Metrics cannot be enabled. Incompatible Bukkit version.", e);
-		}
-	}
-	
-	private void createAsyncTask(Server server) {
-		try {
-			if (asyncPacketTask >= 0)
-				throw new IllegalStateException("Async task has already been created");
-			
-			// Attempt to create task
-			asyncPacketTask = server.getScheduler().scheduleSyncRepeatingTask(this, new Runnable() {
-				@Override
-				public void run() {
-					AsyncFilterManager manager = (AsyncFilterManager) protocolManager.getAsynchronousManager();
-					
-					// We KNOW we're on the main thread at the moment
-					manager.sendProcessedPackets(tickCounter++, true);
-				}
-			}, ASYNC_PACKET_DELAY, ASYNC_PACKET_DELAY);
-		
-		} catch (Throwable e) {
-			if (asyncPacketTask == -1) {
-				logger.log(Level.SEVERE, "Unable to create packet timeout task.", e);
-			}
-		}
-	}
-	
-	private void checkForIncompatibility(PluginManager manager) {
-		// Plugin authors: Notify me to remove these
-		String[] incompatiblePlugins = {};
-		
-		for (String plugin : incompatiblePlugins) {
-			if (manager.getPlugin(plugin) != null) {
-				// Check for versions, ect.
-				logger.severe("Detected incompatible plugin: " + plugin);
-			}
-		}
-	}
-	
-	@Override
-	public void onDisable() {
-		// Disable compiler
-		if (backgroundCompiler != null) {
-			backgroundCompiler.shutdownAll();
-			backgroundCompiler = null;
-			BackgroundCompiler.setInstance(null);
-		}
-		
-		// Clean up
-		if (asyncPacketTask >= 0) {
-			getServer().getScheduler().cancelTask(asyncPacketTask);
-			asyncPacketTask = -1;
-		}
-		
-		protocolManager.close();
-		protocolManager = null;
-		statistisc = null;
-	}
-	
-	/**
-	 * Retrieves the packet protocol manager.
-	 * @return Packet protocol manager, or NULL if it has been disabled.
-	 */
-	public static ProtocolManager getProtocolManager() {
-		return protocolManager;
-	}
-	
-	/**
-	 * Retrieve the metrics instance used to measure users of this library.
-	 * <p>
-	 * Note that this method may return NULL when the server is reloading or shutting down.
-	 * @return Metrics instance container.
-	 */
-	public Statistics getStatistics() {
-		return statistisc;
-	}
-	
-	// Get the Bukkit logger first, before we try to create our own
-	private Logger getLoggerSafely() {
-		
-		Logger log = null;
-	
-		try {
-			log = getLogger();
-		} catch (Throwable e) {
-			// We'll handle it
-		}
-		
-		if (log == null)
-			log = Logger.getLogger("Minecraft");
-		return log;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/ProtocolManager.java

@@ -1,131 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol;
-
-import java.util.List;
-import java.util.Set;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.PacketConstructor;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.google.common.collect.ImmutableSet;
-
-/**
- * Represents an API for accessing the Minecraft protocol.
- * @author Kristian
- */
-public interface ProtocolManager extends PacketStream {
-
-	/**
-	 * Retrieves a list of every registered packet listener.
-	 * @return Every registered packet listener.
-	 */
-	public ImmutableSet<PacketListener> getPacketListeners();
-
-	/**
-	 * Adds a packet listener. 
-	 * <p>
-	 * Adding an already registered listener has no effect. If you need to change the packets 
-	 * the current listener is observing, you must first remove the packet listener before you 
-	 * can register it again.
-	 * @param listener - new packet listener.
-	 */
-	public void addPacketListener(PacketListener listener);
-
-	/**
-	 * Removes a given packet listener. 
-	 * <p>
-	 * Attempting to remove a listener that doesn't exist has no effect.
-	 * @param listener - the packet listener to remove.
-	 */
-	public void removePacketListener(PacketListener listener);
-
-	/**
-	 * Removes every listener associated with the given plugin.
-	 * @param plugin - the plugin to unload.
-	 */
-	public void removePacketListeners(Plugin plugin);
-
-	/**
-	 * Constructs a new encapsulated Minecraft packet with the given ID.
-	 * @param id - packet ID.
-	 * @return New encapsulated Minecraft packet.
-	 */
-	public PacketContainer createPacket(int id);
-	
-	/**
-	 * Constructs a new encapsulated Minecraft packet with the given ID.
-	 * <p>
-	 * If set to true, the <i>forceDefaults</i> option will force the system to automatically 
-	 * give non-primitive fields in the packet sensible default values. For instance, certain
-	 * packets - like Packet60Explosion - require a List or Set to be non-null. If the
-	 * forceDefaults option is true, the List or Set will be automatically created.
-	 * 
-	 * @param id - packet ID.
-	 * @param forceDefaults - TRUE to use sensible defaults in most fields, FALSE otherwise.
-	 * @return New encapsulated Minecraft packet.
-	 */
-	public PacketContainer createPacket(int id, boolean forceDefaults);
-
-	/**
-	 * Construct a packet using the special builtin Minecraft constructors.
-	 * @param id - the packet ID.
-	 * @param arguments - arguments that will be passed to the constructor.
-	 * @return The packet constructor.
-	 */
-	public PacketConstructor createPacketConstructor(int id, Object... arguments);
-	
-	/**
-	 * Completely refresh all clients about an entity.
-	 * <p>
-	 * Note that this method is NOT thread safe. If you call this method from anything 
-	 * but the main thread, it will throw an exception.
-	 * @param entity - entity to refresh.
-	 * @param observers - the clients to update.
-	 */
-	public void updateEntity(Entity entity, List<Player> observers) throws FieldAccessException;
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the sent server packets that will be observed by listeners.
-	 * @return Every filtered server packet.
-	 */
-	public Set<Integer> getSendingFilters();
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the recieved client packets that will be observed by listeners.
-	 * @return Every filtered client packet.
-	 */
-	public Set<Integer> getReceivingFilters();
-	
-	/**
-	 * Determines whether or not this protocol mananger has been disabled. 
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean isClosed();
-
-	/**
-	 * Retrieve the current asyncronous packet manager.
-	 * @return Asyncronous packet manager.
-	 */
-	public AsynchronousManager getAsynchronousManager();
-}

ProtocolLib/src/com/comphenix/protocol/async/AsyncFilterManager.java

@@ -1,305 +0,0 @@
-package com.comphenix.protocol.async;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Logger;
-
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitScheduler;
-
-import com.comphenix.protocol.AsynchronousManager;
-import com.comphenix.protocol.PacketStream;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.PacketFilterManager;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.google.common.base.Objects;
-
-/**
- * Represents a filter manager for asynchronous packets.
- * 
- * @author Kristian
- */
-public class AsyncFilterManager implements AsynchronousManager {
-
-	private PacketProcessingQueue serverProcessingQueue;
-	private PacketSendingQueue serverQueue;
-	
-	private PacketProcessingQueue clientProcessingQueue;
-	private PacketSendingQueue clientQueue;
-	
-	private Logger logger;
-	
-	// The likely main thread
-	private Thread mainThread;
-	
-	// Default scheduler
-	private BukkitScheduler scheduler;
-	
-	// Our protocol manager
-	private ProtocolManager manager;
-	
-	// Current packet index
-	private AtomicInteger currentSendingIndex = new AtomicInteger();
-	
-	// Whether or not we're currently cleaning up
-	private volatile boolean cleaningUp;
-	
-	public AsyncFilterManager(Logger logger, BukkitScheduler scheduler, ProtocolManager manager) {
-		
-		// Server packets are synchronized already
-		this.serverQueue = new PacketSendingQueue(false);
-		
-		// Client packets must be synchronized
-		this.clientQueue = new PacketSendingQueue(true); 
-		
-		this.serverProcessingQueue = new PacketProcessingQueue(serverQueue);
-		this.clientProcessingQueue = new PacketProcessingQueue(clientQueue);
-		
-		this.scheduler = scheduler;
-		this.manager = manager;
-		
-		this.logger = logger;
-		this.mainThread = Thread.currentThread();
-	}
-	
-	@Override
-	public AsyncListenerHandler registerAsyncHandler(PacketListener listener) {
-		return registerAsyncHandler(listener, true);
-	}
-	
-	/**
-	 * Registers an asynchronous packet handler.
-	 * <p>
-	 * To start listening asynchronously, pass the getListenerLoop() runnable to a different thread.
-	 * <p>
-	 * Asynchronous events will only be executed if a synchronous listener with the same packets is registered.
-	 * If you already have a synchronous event, call this method with autoInject set to FALSE.
-	 * 
-	 * @param listener - the packet listener that will recieve these asynchronous events.
-	 * @param autoInject - whether or not to automatically create the corresponding synchronous listener,
-	 * @return An asynchrouns handler.
-	 */
-	public AsyncListenerHandler registerAsyncHandler(PacketListener listener, boolean autoInject) {
-		AsyncListenerHandler handler = new AsyncListenerHandler(mainThread, this, listener);
-		
-		ListeningWhitelist sendingWhitelist = listener.getSendingWhitelist();
-		ListeningWhitelist receivingWhitelist = listener.getReceivingWhitelist();
-		
-		// Add listener to either or both processing queue
-		if (hasValidWhitelist(sendingWhitelist)) {
-			PacketFilterManager.verifyWhitelist(listener, sendingWhitelist);
-			serverProcessingQueue.addListener(handler, sendingWhitelist);
-		}
-		
-		if (hasValidWhitelist(receivingWhitelist)) {
-			PacketFilterManager.verifyWhitelist(listener, receivingWhitelist);
-			clientProcessingQueue.addListener(handler, receivingWhitelist);
-		}
-		
-		// We need a synchronized listener to get the ball rolling
-		if (autoInject) {
-			handler.setNullPacketListener(new NullPacketListener(listener));
-			manager.addPacketListener(handler.getNullPacketListener());
-		}
-		
-		return handler;
-	}
-	
-	private boolean hasValidWhitelist(ListeningWhitelist whitelist) {
-		return whitelist != null && whitelist.getWhitelist().size() > 0;
-	}
-	
-	@Override
-	public void unregisterAsyncHandler(AsyncListenerHandler handler) {
-		if (handler == null)
-			throw new IllegalArgumentException("listenerToken cannot be NULL");
-		
-		handler.cancel();	
-	}
-	
-	// Called by AsyncListenerHandler
-	void unregisterAsyncHandlerInternal(AsyncListenerHandler handler) {
-		
-		PacketListener listener = handler.getAsyncListener();
-		boolean synchronusOK = onMainThread();
-		
-		// Unregister null packet listeners
-		if (handler.getNullPacketListener() != null) {
-			manager.removePacketListener(handler.getNullPacketListener());
-		}
-		
-		// Just remove it from the queue(s)
-		if (hasValidWhitelist(listener.getSendingWhitelist())) {
-			List<Integer> removed = serverProcessingQueue.removeListener(handler, listener.getSendingWhitelist());
-			
-			// We're already taking care of this, so don't do anything
-			if (!cleaningUp)
-				serverQueue.signalPacketUpdate(removed, synchronusOK);
-		}
-		
-		if (hasValidWhitelist(listener.getReceivingWhitelist())) {
-			List<Integer> removed = clientProcessingQueue.removeListener(handler, listener.getReceivingWhitelist());
-			
-			if (!cleaningUp)
-				clientQueue.signalPacketUpdate(removed, synchronusOK);
-		}
-	}
-	
-	/**
-	 * Determine if we're running on the main thread.
-	 * @return TRUE if we are, FALSE otherwise.
-	 */
-	private boolean onMainThread() {
-		return Thread.currentThread().getId() == mainThread.getId();
-	}
-	
-	@Override
-	public void unregisterAsyncHandlers(Plugin plugin) {
-		unregisterAsyncHandlers(serverProcessingQueue, plugin);
-		unregisterAsyncHandlers(clientProcessingQueue, plugin);
-	}
-	
-	private void unregisterAsyncHandlers(PacketProcessingQueue processingQueue, Plugin plugin) {
-		
-		// Iterate through every packet listener
-		for (PrioritizedListener<AsyncListenerHandler> listener : processingQueue.values()) {			
-			// Remove the listener
-			if (Objects.equal(listener.getListener().getPlugin(), plugin)) {
-				unregisterAsyncHandler(listener.getListener());
-			}
-		}
-	}
-	
-	/**
-	 * Enqueue a packet for asynchronous processing.
-	 * @param syncPacket - synchronous packet event.
-	 * @param asyncMarker - the asynchronous marker to use.
-	 */
-	public void enqueueSyncPacket(PacketEvent syncPacket, AsyncMarker asyncMarker) {
-		PacketEvent newEvent = PacketEvent.fromSynchronous(syncPacket, asyncMarker);
-		
-		// Start the process
-		getSendingQueue(syncPacket).enqueue(newEvent);
-		
-		// We know this is occuring on the main thread, so pass TRUE
-		getProcessingQueue(syncPacket).enqueue(newEvent, true);
-	}
-	
-	@Override
-	public Set<Integer> getSendingFilters() {
-		return serverProcessingQueue.keySet();
-	}
-	
-	@Override
-	public Set<Integer> getReceivingFilters() {
-		return clientProcessingQueue.keySet();
-	}
-	
-	/**
-	 * Used to create a default asynchronous task.
-	 * @param plugin - the calling plugin.
-	 * @param runnable - the runnable.
-	 */
-	public void scheduleAsyncTask(Plugin plugin, Runnable runnable) {
-		scheduler.scheduleAsyncDelayedTask(plugin, runnable);
-	}
-	
-	@Override
-	public boolean hasAsynchronousListeners(PacketEvent packet) {
-		 Collection<?> list = getProcessingQueue(packet).getListener(packet.getPacketID());
-		 return list != null && list.size() > 0;
-	}
-	
-	/**
-	 * Construct a asynchronous marker with all the default values.
-	 * @return Asynchronous marker.
-	 */
-	public AsyncMarker createAsyncMarker() {
-		return createAsyncMarker(AsyncMarker.DEFAULT_SENDING_DELTA, AsyncMarker.DEFAULT_TIMEOUT_DELTA);
-	}
-	
-	/**
-	 * Construct an async marker with the given sending priority delta and timeout delta.
-	 * @param sendingDelta - how many packets we're willing to wait.
-	 * @param timeoutDelta - how long (in ms) until the packet expire.
-	 * @return An async marker.
-	 */
-	public AsyncMarker createAsyncMarker(long sendingDelta, long timeoutDelta) {
-		return createAsyncMarker(sendingDelta, timeoutDelta, 
-								 currentSendingIndex.incrementAndGet(), System.currentTimeMillis());
-	}
-	
-	// Helper method
-	private AsyncMarker createAsyncMarker(long sendingDelta, long timeoutDelta, long sendingIndex, long currentTime) {
-		return new AsyncMarker(manager, sendingIndex, sendingDelta, System.currentTimeMillis(), timeoutDelta);
-	}
-	
-	@Override
-	public PacketStream getPacketStream() {
-		return manager;
-	}
-
-	@Override
-	public Logger getLogger() {
-		return logger;
-	}
-
-	@Override
-	public void cleanupAll() {
-		cleaningUp = true;
-		serverProcessingQueue.cleanupAll();
-		serverQueue.cleanupAll();
-	}
-
-	/**
-	 * Signal that a packet is ready to be transmitted.
-	 * @param packet - packet to signal.
-	 */
-	public void signalPacketUpdate(PacketEvent packet) {
-		getSendingQueue(packet).signalPacketUpdate(packet, onMainThread());
-	}
-
-	/**
-	 * Retrieve the sending queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @return The server or client sending queue the packet belongs to.
-	 */
-	private PacketSendingQueue getSendingQueue(PacketEvent packet) {
-		return packet.isServerPacket() ? serverQueue : clientQueue;
-	}
-	
-	/**
-	 * Signal that a packet has finished processing.
-	 * @param packet - packet to signal.
-	 */
-	public void signalProcessingDone(PacketEvent packet) {
-		getProcessingQueue(packet).signalProcessingDone();
-	}
-	
-	/**
-	 * Retrieve the processing queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @return The server or client sending processing the packet belongs to.
-	 */
-	private PacketProcessingQueue getProcessingQueue(PacketEvent packet) {
-		return packet.isServerPacket() ? serverProcessingQueue : clientProcessingQueue;
-	}
-
-	/**
-	 * Send any due packets, or clean up packets that have expired.
-	 */
-	public void sendProcessedPackets(int tickCounter, boolean onMainThread) {
-		
-		// The server queue is unlikely to need checking that often
-		if (tickCounter % 10 == 0) {
-			serverQueue.trySendPackets(onMainThread);
-		}
-
-		clientQueue.trySendPackets(onMainThread);
-	}
-}

ProtocolLib/src/com/comphenix/protocol/async/AsyncListenerHandler.java

@@ -1,391 +0,0 @@
-package com.comphenix.protocol.async;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-
-/**
- * Represents a handler for an asynchronous event.
- * 
- * @author Kristian
- */
-public class AsyncListenerHandler {
-
-	/**
-	 * Signal an end to packet processing.
-	 */
-	private static final PacketEvent INTERUPT_PACKET = new PacketEvent(new Object());
-	
-	/**
-	 * Called when the threads have to wake up for something important.
-	 */
-	private static final PacketEvent WAKEUP_PACKET = new PacketEvent(new Object());
-	
-	// Unique worker ID
-	private static final AtomicInteger nextID = new AtomicInteger();
-	
-	// Default queue capacity
-	private static int DEFAULT_CAPACITY = 1024;
-	
-	// Cancel the async handler
-	private volatile boolean cancelled;
-	
-	// Number of worker threads
-	private final AtomicInteger started = new AtomicInteger();
-	
-	// The packet listener
-	private PacketListener listener;
-
-	// The filter manager
-	private AsyncFilterManager filterManager;
-	private NullPacketListener nullPacketListener;
-	
-	// List of queued packets
-	private ArrayBlockingQueue<PacketEvent> queuedPackets = new ArrayBlockingQueue<PacketEvent>(DEFAULT_CAPACITY);
-
-	// List of cancelled tasks
-	private final Set<Integer> stoppedTasks = new HashSet<Integer>();
-	private final Object stopLock = new Object();
-	
-	// Minecraft main thread
-	private Thread mainThread;
-	
-	public AsyncListenerHandler(Thread mainThread, AsyncFilterManager filterManager, PacketListener listener) {
-		if (filterManager == null)
-			throw new IllegalArgumentException("filterManager cannot be NULL");
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL");
-
-		this.mainThread = mainThread;
-		this.filterManager = filterManager;
-		this.listener = listener;
-	}
-	
-	public boolean isCancelled() {
-		return cancelled;
-	}
-
-	public PacketListener getAsyncListener() {
-		return listener;
-	}
-
-	/**
-	 * Set the synchronized listener that has been automatically created.
-	 * @param nullPacketListener - automatically created listener.
-	 */
-	void setNullPacketListener(NullPacketListener nullPacketListener) {
-		this.nullPacketListener = nullPacketListener;
-	}
-
-	/**
-	 * Retrieve the synchronized listener that was automatically created.
-	 * @return Automatically created listener.
-	 */
-	PacketListener getNullPacketListener() {
-		return nullPacketListener;
-	}
-	
-	private String getPluginName() {
-		return PacketAdapter.getPluginName(listener);
-	}
-
-	/**
-	 * Retrieve the plugin associated with this async listener.
-	 * @return The plugin.
-	 */
-	public Plugin getPlugin() {
-		return listener != null ? listener.getPlugin() : null;
-	}
-	
-	/**
-	 * Cancel the handler.
-	 */
-	public void cancel() {
-		// Remove the listener as quickly as possible
-		close();
-	}
-
-	/**
-	 * Queue a packet for processing.
-	 * @param packet - a packet for processing.
-	 * @throws IllegalStateException If the underlying packet queue is full.
-	 */
-	public void enqueuePacket(PacketEvent packet) {
-		if (packet == null)
-			throw new IllegalArgumentException("packet is NULL");
-		
-		queuedPackets.add(packet);
-	}
-	
-	/**
-	 * Create a worker that will initiate the listener loop. Note that using stop() to
-	 * close a specific worker is less efficient than stopping an arbitrary worker.
-	 * <p>
-	 * <b>Warning</b>: Never call the run() method in the main thread.
-	 */
-	public AsyncRunnable getListenerLoop() {
-		return new AsyncRunnable() {
-
-			private final AtomicBoolean firstRun = new AtomicBoolean();
-			private final AtomicBoolean finished = new AtomicBoolean();
-			private final int id = nextID.incrementAndGet();
-			
-			@Override
-			public int getID() {
-				return id;
-			}
-			
-			@Override
-			public void run() {
-				// Careful now
-				if (firstRun.compareAndSet(false, true)) {
-					listenerLoop(id);
-					
-					synchronized (stopLock) {
-						stoppedTasks.remove(id);
-						stopLock.notifyAll();
-						finished.set(true);
-					}
-					
-				} else {
-					if (finished.get())
-						throw new IllegalStateException(
-							"This listener has already been run. Create a new instead.");
-					else
-						throw new IllegalStateException(
-							"This listener loop has already been started. Create a new instead.");
-				}
-			}
-			
-			@Override
-			public boolean stop() throws InterruptedException {
-				synchronized (stopLock) {
-					if (!isRunning())
-						return false;
-
-					stoppedTasks.add(id);
-			
-					// Wake up threads - we have a listener to stop
-					for (int i = 0; i < getWorkers(); i++) {
-						queuedPackets.offer(WAKEUP_PACKET);
-					}
-					
-					finished.set(true);
-					waitForStops();
-					return true;
-				}
-			}
-
-			@Override
-			public boolean isRunning() {
-				return firstRun.get() && !finished.get();
-			}
-			
-			@Override
-			public boolean isFinished() {
-				return finished.get();
-			}
-		};
-	}
-	
-	/**
-	 * Start a singler worker thread handling the asynchronous.
-	 */
-	public synchronized void start() {
-		if (listener.getPlugin() == null)
-			throw new IllegalArgumentException("Cannot start task without a valid plugin.");
-		if (cancelled)
-			throw new IllegalStateException("Cannot start a worker when the listener is closing.");
-		
-		filterManager.scheduleAsyncTask(listener.getPlugin(), getListenerLoop());
-	}
-	
-	/**
-	 * Start multiple worker threads for this listener.
-	 * @param count - number of worker threads to start.
-	 */
-	public synchronized void start(int count) {
-		for (int i = 0; i < count; i++)
-			start();
-	}
-	
-	/**
-	 * Stop a worker thread.
-	 */
-	public synchronized void stop() {
-		queuedPackets.add(INTERUPT_PACKET);
-	}
-	
-	/**
-	 * Stop the given amount of worker threads.
-	 * @param count - number of threads to stop.
-	 */
-	public synchronized void stop(int count) {
-		for (int i = 0; i < count; i++)
-			stop();
-	}
-	
-	/**
-	 * Set the current number of workers. 
-	 * <p>
-	 * This method can only be called with a count of zero when the listener is closing.
-	 * @param count - new number of workers.
-	 */
-	public synchronized void setWorkers(int count) {
-		if (count < 0)
-			throw new IllegalArgumentException("Number of workers cannot be less than zero.");
-		if (count > DEFAULT_CAPACITY)
-			throw new IllegalArgumentException("Cannot initiate more than " + DEFAULT_CAPACITY + " workers");
-		if (cancelled && count > 0)
-			throw new IllegalArgumentException("Cannot add workers when the listener is closing.");
-		
-		long time = System.currentTimeMillis();
-		
-		// Try to get to the correct count
-		while (started.get() != count) {
-			if (started.get() < count)
-				start();
-			else
-				stop();
-			
-			// May happen if another thread is doing something similar to "setWorkers"
-			if ((System.currentTimeMillis() - time) > 1000)
-				throw new RuntimeException("Failed to set worker count.");
-		}
-	}
-	
-	/**
-	 * Retrieve the current number of registered workers.
-	 * <p>
-	 * Note that the returned value may be out of data.
-	 * @return Number of registered workers.
-	 */
-	public synchronized int getWorkers() {
-		return started.get();
-	}
-	
-	/**
-	 * Wait until every tasks scheduled to stop has actually stopped.
-	 * @return TRUE if the current listener should stop, FALSE otherwise.
-	 * @throws InterruptedException - If the current thread was interrupted.
-	 */
-	private boolean waitForStops() throws InterruptedException {
-		synchronized (stopLock) {
-			while (stoppedTasks.size() > 0 && !cancelled) {
-				stopLock.wait();
-			}
-			return cancelled;
-		}
-	}
-	
-	// DO NOT call this method from the main thread
-	private void listenerLoop(int workerID) {
-		
-		// Danger, danger!
-		if (Thread.currentThread().getId() == mainThread.getId()) 
-			throw new IllegalStateException("Do not call this method from the main thread.");
-		if (cancelled)
-			throw new IllegalStateException("Listener has been cancelled. Create a new listener instead.");
-
-		try {
-			// Wait if certain threads are stopping
-			if (waitForStops())
-				return;
-			
-			// Proceed
-			started.incrementAndGet();
-			
-			mainLoop:
-			while (!cancelled) {
-				PacketEvent packet = queuedPackets.take();
-				AsyncMarker marker = packet.getAsyncMarker();
-				
-				// Handle cancel requests
-				if (packet == null || marker == null || packet == INTERUPT_PACKET) {
-					return;
-					
-				} else if (packet == WAKEUP_PACKET) {
-					// This is a bit slow, but it should be safe
-					synchronized (stopLock) {
-						// Are we the one who is supposed to stop?
-						if (stoppedTasks.contains(workerID)) 
-							return;
-						if (waitForStops())
-							return;
-					}
-				}
-				
-				// Here's the core of the asynchronous processing
-				try {
-					marker.setListenerHandler(this);
-					marker.setWorkerID(workerID);
-					
-					if (packet.isServerPacket())
-						listener.onPacketSending(packet);
-					else
-						listener.onPacketReceiving(packet);
-					
-				} catch (Throwable e) {
-					// Minecraft doesn't want your Exception.
-					filterManager.getLogger().log(Level.SEVERE, 
-							"Unhandled exception occured in onAsyncPacket() for " + getPluginName(), e);
-				}
-				
-				// Now, get the next non-cancelled listener
-				for (; marker.getListenerTraversal().hasNext(); ) {
-					AsyncListenerHandler handler = marker.getListenerTraversal().next().getListener();
-					
-					if (!handler.isCancelled()) {
-						handler.enqueuePacket(packet);
-						continue mainLoop;
-					}
-				}
-				
-				// There are no more listeners - queue the packet for transmission
-				filterManager.signalPacketUpdate(packet);
-				filterManager.signalProcessingDone(packet);
-			}
-			
-		} catch (InterruptedException e) {
-			// We're done
-		} finally {
-			// Clean up
-			started.decrementAndGet();
-			close();
-		}
-	}
-	
-	private synchronized void close() {
-		// Remove the listener itself
-		if (!cancelled) {
-			filterManager.unregisterAsyncHandlerInternal(this);
-			cancelled = true;
-			
-			// Tell every uncancelled thread to end
-			stopThreads();
-		}
-	}
-	
-	/**
-	 * Use the poision pill method to stop every worker thread.
-	 */
-	private void stopThreads() {
-		// Poison Pill Shutdown
-		queuedPackets.clear();
-		stop(started.get());
-		
-		// Individual shut down is irrelevant now
-		synchronized (stopLock) {
-			stopLock.notifyAll();
-		}
-	}
-}

ProtocolLib/src/com/comphenix/protocol/async/AsyncRunnable.java

@@ -1,35 +0,0 @@
-package com.comphenix.protocol.async;
-
-/**
- * A runnable representing a asynchronous event listener.
- * 
- * @author Kristian
- */
-public interface AsyncRunnable extends Runnable {
-	
-	/**
-	 * Retrieve a unique worker ID.
-	 * @return Unique worker ID.
-	 */
-	public int getID();
-	
-	/**
-	 * Stop the given runnable.
-	 * <p>
-	 * This may not occur right away.
-	 * @return TRUE if the thread was stopped, FALSE if it was already stopped.
-	 */
-	public boolean stop() throws InterruptedException;
-	
-	/**
-	 * Determine if we're running or not.
-	 * @return TRUE if we're running, FALSE otherwise.
-	 */
-	public boolean isRunning();
-
-	/**
-	 * Determine if this runnable has already run its course.
-	 * @return TRUE if it has been stopped, FALSE otherwise.
-	 */
-	boolean isFinished();
-}

ProtocolLib/src/com/comphenix/protocol/async/PacketEventHolder.java

@@ -1,40 +0,0 @@
-package com.comphenix.protocol.async;
-
-import com.comphenix.protocol.events.PacketEvent;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ComparisonChain;
-
-/**
- * Provides a comparable to a packet event.
- * 
- * @author Kristian
- */
-class PacketEventHolder implements Comparable<PacketEventHolder> {
-
-	private PacketEvent event;
-
-	/**
-	 * A wrapper that ensures the packet event is ordered by sending index.
-	 * @param event - packet event to wrap.
-	 */
-	public PacketEventHolder(PacketEvent event) {
-		this.event = Preconditions.checkNotNull(event, "Event must be non-null");
-	}
-
-	/**
-	 * Retrieve the stored event.
-	 * @return The stored event.
-	 */
-	public PacketEvent getEvent() {
-		return event;
-	}
-	
-	@Override
-	public int compareTo(PacketEventHolder other) {
-		AsyncMarker marker = other != null ? other.getEvent().getAsyncMarker() : null;
-		
-		return ComparisonChain.start().
-			   compare(event.getAsyncMarker(), marker).
-			   result();
-	}
-}

ProtocolLib/src/com/comphenix/protocol/async/PacketSendingQueue.java

@@ -1,187 +0,0 @@
-package com.comphenix.protocol.async;
-
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.PriorityBlockingQueue;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.reflect.FieldAccessException;
-
-/**
- * Represents packets ready to be transmitted to a client.
- * @author Kristian
- */
-class PacketSendingQueue {
-
-	public static final int INITIAL_CAPACITY = 64;
-	
-	private PriorityBlockingQueue<PacketEventHolder> sendingQueue;
-	
-	// Whether or not packet transmission can only occur on the main thread
-	private final boolean synchronizeMain;
-	
-	/**
-	 * Number of packet events in the queue.
-	 * @return The number of packet events in the queue.
-	 */
-	public int size() {
-		return sendingQueue.size();
-	}
-	
-	/**
-	 * Create a packet sending queue.
-	 * @param synchronizeMain - whether or not to synchronize with the main thread.
-	 */
-	public PacketSendingQueue(boolean synchronizeMain) {
-		this.sendingQueue = new PriorityBlockingQueue<PacketEventHolder>(INITIAL_CAPACITY);
-		this.synchronizeMain = synchronizeMain;
-	}
-	
-	/**
-	 * Enqueue a packet for sending. 
-	 * @param packet
-	 */
-	public void enqueue(PacketEvent packet) {
-		sendingQueue.add(new PacketEventHolder(packet));
-	}
-	
-	/**
-	 * Invoked when one of the packets have finished processing.
-	 * @param packetUpdated - the packet that has now been updated.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public synchronized void signalPacketUpdate(PacketEvent packetUpdated, boolean onMainThread) {
-		// Mark this packet as finished
-		packetUpdated.getAsyncMarker().setProcessed(true);
-		trySendPackets(onMainThread);
-	}
-
-	/***
-	 * Invoked when a list of packet IDs are no longer associated with any listeners.
-	 * @param packetsRemoved - packets that no longer have any listeners.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public synchronized void signalPacketUpdate(List<Integer> packetsRemoved, boolean onMainThread) {
-		
-		Set<Integer> lookup = new HashSet<Integer>(packetsRemoved);
-		
-		// Note that this is O(n), so it might be expensive
-		for (PacketEventHolder holder : sendingQueue) {
-			PacketEvent event = holder.getEvent();
-			
-			if (lookup.contains(event.getPacketID())) {
-				event.getAsyncMarker().setProcessed(true);
-			}
-		}
-		
-		// This is likely to have changed the situation a bit
-		trySendPackets(onMainThread);
-	}
-	
-	/**
-	 * Attempt to send any remaining packets.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public void trySendPackets(boolean onMainThread) {
-				
-		// Transmit as many packets as we can
-		while (true) {
-			PacketEventHolder holder = sendingQueue.peek();
-					
-			if (holder != null) {
-				PacketEvent current = holder.getEvent();
-				AsyncMarker marker = current.getAsyncMarker();
-				
-				// Abort if we're not on the main thread
-				if (synchronizeMain) {
-					try {
-						boolean wantAsync = marker.isMinecraftAsync(current);
-						boolean wantSync = !wantAsync;
-						
-						// Quit if we haven't fulfilled our promise
-						if ((onMainThread && wantAsync) || (!onMainThread && wantSync))
-							return;
-						
-					} catch (FieldAccessException e) {
-						e.printStackTrace();
-						return;
-					}
-				}
-				
-				if (marker.isProcessed() || marker.hasExpired()) {
-					if (marker.isProcessed() && !current.isCancelled()) {
-						// Silently skip players that have logged out
-						if (isOnline(current.getPlayer())) {
-							sendPacket(current);
-						}
-					}
-					
-					sendingQueue.poll();
-					continue;
-				}
-			}
-			
-			// Only repeat when packets are removed
-			break;
-		}
-	}
-	
-	private boolean isOnline(Player player) {
-		return player != null && player.isOnline();
-	}
-	
-	/**
-	 * Send every packet, regardless of the processing state.
-	 */
-	private void forceSend() {
-		while (true) {
-			PacketEventHolder holder = sendingQueue.poll();
-			
-			if (holder != null) {
-				sendPacket(holder.getEvent());
-			} else {
-				break;
-			}
-		}
-	}
-	
-	/**
-	 * Whether or not the packet transmission must synchronize with the main thread.
-	 * @return TRUE if it must, FALSE otherwise.
-	 */
-	public boolean isSynchronizeMain() {
-		return synchronizeMain;
-	}
-
-	/**
-	 * Transmit a packet, if it hasn't already.
-	 * @param event - the packet to transmit.
-	 */
-	private void sendPacket(PacketEvent event) {
-		
-		AsyncMarker marker = event.getAsyncMarker();
-		
-		try {
-			// Don't send a packet twice
-			if (marker != null && !marker.isTransmitted()) {
-				marker.sendPacket(event);
-			}
-			
-		} catch (IOException e) {
-			// Just print the error
-			e.printStackTrace();
-		}
-	}
-
-	/**
-	 * Automatically transmits every delayed packet.
-	 */
-	public void cleanupAll() {
-		// Note that the cleanup itself will always occur on the main thread
-		forceSend();
-	}
-}

ProtocolLib/src/com/comphenix/protocol/events/ListeningWhitelist.java

@@ -1,127 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.events;
-
-import java.util.Set;
-
-import com.google.common.base.Objects;
-import com.google.common.collect.Sets;
-
-/**
- * Determines which packets will be observed by a listener, and with what priority.
-
- * @author Kristian 
- */
-public class ListeningWhitelist {
-
-	/**
-	 * A whitelist with no packets - indicates that the listener shouldn't observe any packets.
-	 */
-	public static ListeningWhitelist EMPTY_WHITELIST = new ListeningWhitelist(ListenerPriority.LOW);
-	
-	private ListenerPriority priority;
-	private Set<Integer> whitelist;
-
-	/**
-	 * Creates a packet whitelist for a given priority with a set of packet IDs.
-	 * @param priority - the listener priority.
-	 * @param whitelist - set of IDs to observe/enable. 
-	 */
-	public ListeningWhitelist(ListenerPriority priority, Set<Integer> whitelist) {
-		this.priority = priority;
-		this.whitelist = whitelist;
-	}
-	
-	/**
-	 * Creates a packet whitelist of a given priority for a list of packets.
-	 * @param priority - the listener priority.
-	 * @param whitelist - list of packet IDs to observe/enable.
-	 */
-	public ListeningWhitelist(ListenerPriority priority, Integer... whitelist) {
-		this.priority = priority;
-		this.whitelist = Sets.newHashSet(whitelist);
-	}
-	
-	/**
-	 * Whether or not this whitelist has any enabled packets.
-	 * @return TRUE if there are any packets, FALSE otherwise.
-	 */
-	public boolean isEnabled() {
-		return whitelist != null && whitelist.size() > 0;
-	}
-	
-	/**
-	 * Retrieve the priority in the execution order of the packet listener. Highest priority will be executed last.
-	 * @return Execution order in terms of priority.
-	 */
-	public ListenerPriority getPriority() {
-		return priority;
-	}
-	
-	/**
-	 * Retrieves the list of packets that will be observed by the listeners.
-	 * @return Packet whitelist.
-	 */
-	public Set<Integer> getWhitelist() {
-		return whitelist;
-	}
-	
-	@Override
-	public int hashCode(){
-	    return Objects.hashCode(priority, whitelist);
-	}
-
-	/**
-	 * Determine if any of the given IDs can be found in the whitelist.
-	 * @param whitelist - whitelist to test.
-	 * @param idList - list of packet IDs to find. 
-	 * @return TRUE if any of the packets in the list can be found in the whitelist, FALSE otherwise.
-	 */
-	public static boolean containsAny(ListeningWhitelist whitelist, int... idList) {
-		if (whitelist != null) {
-			for (int i = 0; i < idList.length; i++) {
-				if (whitelist.getWhitelist().contains(idList[i]))
-					return true;
-			}
-		}
-		
-		return false;
-	}
-	
-	@Override
-	public boolean equals(final Object obj){
-	    if(obj instanceof ListeningWhitelist){
-	        final ListeningWhitelist other = (ListeningWhitelist) obj;
-	        return Objects.equal(priority, other.priority)
-	            && Objects.equal(whitelist, other.whitelist);
-	    } else{
-	        return false;
-	    }
-	}
-	
-	@Override
-	public String toString() {
-		if (this == EMPTY_WHITELIST)
-			return "EMPTY_WHITELIST";
-		else
-			return Objects.toStringHelper(this)
-				.add("priority", priority)
-				.add("packets", whitelist).toString();
-	}
-	
-}

ProtocolLib/src/com/comphenix/protocol/events/PacketAdapter.java

@@ -1,124 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.events;
-
-import org.bukkit.plugin.Plugin;
-
-/**
- * Represents a packet listener with useful constructors.
- * 
- * @author Kristian
- */
-public abstract class PacketAdapter implements PacketListener {
-	
-	protected Plugin plugin;
-	protected ConnectionSide connectionSide;
-	protected ListeningWhitelist receivingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
-	protected ListeningWhitelist sendingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
-
-	/**
-	 * Initialize a packet listener with default priority.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, Integer... packets) {
-		this(plugin, connectionSide, ListenerPriority.NORMAL, packets);
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param listenerPriority - the event priority.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Integer... packets) {
-		if (plugin == null)
-			throw new IllegalArgumentException("plugin cannot be null");
-		if (connectionSide == null)
-			throw new IllegalArgumentException("connectionSide cannot be null");
-		if (listenerPriority == null)
-			throw new IllegalArgumentException("listenerPriority cannot be null");
-		if (packets == null)
-			throw new IllegalArgumentException("packets cannot be null");
-		
-		// Add whitelists
-		if (connectionSide.isForServer())
-			sendingWhitelist = new ListeningWhitelist(listenerPriority, packets);
-		if (connectionSide.isForClient())
-			receivingWhitelist = new ListeningWhitelist(listenerPriority, packets);
-		
-		this.plugin = plugin;
-		this.connectionSide = connectionSide;
-	}
-	
-	@Override
-	public void onPacketReceiving(PacketEvent event) {
-		// Default is to do nothing
-	}
-	
-	@Override
-	public void onPacketSending(PacketEvent event) {
-		// And here too
-	}
-	
-	@Override
-	public ListeningWhitelist getReceivingWhitelist() {
-		return receivingWhitelist;
-	}
-	
-	@Override
-	public ListeningWhitelist getSendingWhitelist() {
-		return sendingWhitelist;
-	}
-	
-	@Override
-	public Plugin getPlugin() {
-		return plugin;
-	}
-	
-	/**
-	 * Retrieves the name of the plugin that has been associated with the listener.
-	 * @return Name of the associated plugin.
-	 */
-	public static String getPluginName(PacketListener listener) {
-		
-		Plugin plugin = listener.getPlugin();
-		
-		// Try to get the plugin name
-		try {
-			if (plugin == null)
-				return "UNKNOWN";
-			else
-				return plugin.getName();
-			
-		} catch (NoSuchMethodError e) {
-			return plugin.toString();
-		}
-	}
-	
-	@Override
-	public String toString() {		
-		// This is used by the error reporter 
-		return String.format("PacketAdapter[plugin=%s, sending=%s, receiving=%s]", 
-				getPluginName(this), 
-				sendingWhitelist,
-				receivingWhitelist);
-	}
-}

ProtocolLib/src/com/comphenix/protocol/events/PacketContainer.java

@@ -1,365 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.events;
-
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import org.bukkit.World;
-import org.bukkit.WorldType;
-import org.bukkit.craftbukkit.CraftWorld;
-import org.bukkit.craftbukkit.inventory.CraftItemStack;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-import com.comphenix.protocol.injector.StructureCache;
-import com.comphenix.protocol.reflect.EquivalentConverter;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.reflect.StructureModifier;
-
-import net.minecraft.server.Packet;
-
-/**
- * Represents a Minecraft packet indirectly.
- * 
- * @author Kristian
- */
-public class PacketContainer implements Serializable {
-
-	/**
-	 * Generated by Eclipse.
-	 */
-	private static final long serialVersionUID = 2074805748222377230L;
-	
-	protected int id;
-	protected transient Packet handle;
-
-	// Current structure modifier
-	protected transient StructureModifier<Object> structureModifier;
-		
-	// Check whether or not certain classes exists
-	private static boolean hasWorldType = false;
-	
-	// The getEntity method
-	private static Method getEntity;
-	
-	// Support for serialization
-	private static Method writeMethod;
-	private static Method readMethod;
-	
-	static {
-		try {
-			Class.forName("net.minecraft.server.WorldType");
-			hasWorldType = true;
-		} catch (ClassNotFoundException e) {
-		}
-	}
-	
-	/**
-	 * Creates a packet container for a new packet.
-	 * @param id - ID of the packet to create.
-	 */
-	public PacketContainer(int id) {
-		this(id, StructureCache.newPacket(id));
-	}
-	
-	/**
-	 * Creates a packet container for an existing packet.
-	 * @param id - ID of the given packet.
-	 * @param handle - contained packet.
-	 */
-	public PacketContainer(int id, Packet handle) {
-		this(id, handle, StructureCache.getStructure(id).withTarget(handle));
-	}
-	
-	/**
-	 * Creates a packet container for an existing packet.
-	 * @param id - ID of the given packet.
-	 * @param handle - contained packet.
-	 * @param structure - structure modifier.
-	 */
-	public PacketContainer(int id, Packet handle, StructureModifier<Object> structure) {
-		if (handle == null)
-			throw new IllegalArgumentException("handle cannot be null.");
-		
-		this.id = id;
-		this.handle = handle;
-		this.structureModifier = structure;
-	}
-	
-	/**
-	 * Retrieves the underlying Minecraft packet. 
-	 * @return Underlying Minecraft packet.
-	 */
-	public Packet getHandle() {
-		return handle;
-	}
-	
-	/**
-	 * Retrieves the generic structure modifier for this packet.
-	 * @return Structure modifier.
-	 */
-	public StructureModifier<Object> getModifier() {
-		return structureModifier;
-	}
-	
-	/**
-	 * Retrieves a read/write structure for every field with the given type.
-	 * @param primitiveType - the type to find.
-	 * @return A modifier for this specific type.
-	 */
-	public <T> StructureModifier<T> getSpecificModifier(Class<T> primitiveType) {
-		return structureModifier.withType(primitiveType);
-	}
-	
-	/**
-	 * Retrieves a read/write structure for ItemStack.
-	 * <p>
-	 * This modifier will automatically marshall between the Bukkit ItemStack and the
-	 * internal Minecraft ItemStack.
-	 * @return A modifier for ItemStack fields.
-	 */
-	public StructureModifier<ItemStack> getItemModifier() {
-		// Convert from and to the Bukkit wrapper
-		return structureModifier.<ItemStack>withType(net.minecraft.server.ItemStack.class, new EquivalentConverter<ItemStack>() {
-			public Object getGeneric(ItemStack specific) {
-				return ((CraftItemStack) specific).getHandle();
-			}
-			
-			@Override
-			public ItemStack getSpecific(Object generic) {
-				return new CraftItemStack((net.minecraft.server.ItemStack) generic);
-			}
-			
-			@Override
-			public Class<ItemStack> getSpecificType() {
-				return ItemStack.class;
-			}
-		});
-	}
-	
-	/**
-	 * Retrieves a read/write structure for arrays of ItemStacks.
-	 * <p>
-	 * This modifier will automatically marshall between the Bukkit ItemStack and the
-	 * internal Minecraft ItemStack.
-	 * @return A modifier for ItemStack array fields.
-	 */
-	public StructureModifier<ItemStack[]> getItemArrayModifier() {
-		// Convert to and from the Bukkit wrapper
-		return structureModifier.<ItemStack[]>withType(net.minecraft.server.ItemStack[].class, new EquivalentConverter<ItemStack[]>() {
-			public Object getGeneric(ItemStack[] specific) {
-				net.minecraft.server.ItemStack[] result = new net.minecraft.server.ItemStack[specific.length];
-				
-				// Unwrap every item
-				for (int i = 0; i < result.length; i++) {
-					result[i] = ((CraftItemStack) specific[i]).getHandle();
-				}
-				return result;
-			}
-			
-			@Override
-			public ItemStack[] getSpecific(Object generic) {
-				net.minecraft.server.ItemStack[] input = (net.minecraft.server.ItemStack[]) generic;
-				ItemStack[] result = new ItemStack[input.length];
-				
-				// Add the wrapper
-				for (int i = 0; i < result.length; i++) {
-					result[i] = new CraftItemStack(input[i]);
-				}
-				return result;
-			}
-			
-			@Override
-			public Class<ItemStack[]> getSpecificType() {
-				return ItemStack[].class;
-			}
-		});
-	}
-	
-	/**
-	 * Retrieves a read/write structure for the world type enum.
-	 * <p>
-	 * This modifier will automatically marshall between the Bukkit world type and the
-	 * internal Minecraft world type.
-	 * @return A modifier for world type fields.
-	 */
-	public StructureModifier<WorldType> getWorldTypeModifier() {
-	
-		if (!hasWorldType) {
-			// We couldn't find the Minecraft equivalent
-			return structureModifier.withType(null);
-		}
-		
-		// Convert to and from the Bukkit wrapper
-		return structureModifier.<WorldType>withType(net.minecraft.server.WorldType.class, new EquivalentConverter<WorldType>() {
-			@Override
-			public Object getGeneric(WorldType specific) {
-				return net.minecraft.server.WorldType.getType(specific.getName());
-			}
-			
-			@Override
-			public WorldType getSpecific(Object generic) {
-				net.minecraft.server.WorldType type = (net.minecraft.server.WorldType) generic;
-				return WorldType.getByName(type.name());
-			}
-			
-			@Override
-			public Class<WorldType> getSpecificType() {
-				return WorldType.class;
-			}
-		});
-	}
-	
-	/**
-	 * Retrieves a read/write structure for entity objects.
-	 * <p>
-	 * Note that entities are transmitted by integer ID, and the type may not be enough
-	 * to distinguish between entities and other values. Thus, this structure modifier
-	 * MAY return null or invalid entities for certain fields. Using the correct index 
-	 * is essential.
-	 * 
-	 * @return A modifier entity types.
-	 */
-	public StructureModifier<Entity> getEntityModifier(World world) {
-	
-		final Object worldServer = ((CraftWorld) world).getHandle();
-		final Class<?> nmsEntityClass = net.minecraft.server.Entity.class;
-		final World worldCopy = world;
-		
-		if (getEntity == null)
-			getEntity = FuzzyReflection.fromObject(worldServer).getMethodByParameters(
-					"getEntity", nmsEntityClass, new Class[] { int.class });
-		
-		// Convert to and from the Bukkit wrapper
-		return structureModifier.<Entity>withType(int.class, new EquivalentConverter<Entity>() {
-			@Override
-			public Object getGeneric(Entity specific) {
-				// Simple enough
-				return specific.getEntityId();
-			}
-			
-			@Override
-			public Entity getSpecific(Object generic) {
-				try {
-					net.minecraft.server.Entity nmsEntity = (net.minecraft.server.Entity) 
-							getEntity.invoke(worldServer, generic);
-					Integer id = (Integer) generic;
-					
-					// Attempt to get the Bukkit entity
-					if (nmsEntity != null) {
-						return nmsEntity.getBukkitEntity();
-					} else {
-						// Maybe it's a player that's just logged in? Try a search
-						for (Player player : worldCopy.getPlayers()) {
-							if (player.getEntityId() == id) {
-								return player;
-							}
-						}
-						
-						System.out.println("Entity doesn't exist.");
-						return null;
-					}
-					
-				} catch (IllegalArgumentException e) {
-					throw new RuntimeException("Incorrect arguments detected.", e);
-				} catch (IllegalAccessException e) {
-					throw new RuntimeException("Cannot read field due to a security limitation.", e);
-				} catch (InvocationTargetException e) {
-					throw new RuntimeException("Error occured in Minecraft method.", e.getCause());
-				}
-			}
-			
-			@Override
-			public Class<Entity> getSpecificType() {
-				return Entity.class;
-			}
-		});
-	}
-	
-	/**
-	 * Retrieves the ID of this packet.
-	 * @return Packet ID.
-	 */
-	public int getID() {
-		return id;
-	}
-	
-	private void writeObject(ObjectOutputStream output) throws IOException {
-	    // Default serialization 
-		output.defaultWriteObject();
-
-		// We'll take care of NULL packets as well
-		output.writeBoolean(handle != null);
-		
-		// Retrieve the write method by reflection
-		if (writeMethod == null)
-			writeMethod = FuzzyReflection.fromObject(handle).getMethodByParameters("write", DataOutputStream.class);
-		
-		try {
-			// Call the write-method
-			writeMethod.invoke(handle, new DataOutputStream(output));
-		} catch (IllegalArgumentException e) {
-			throw new IOException("Minecraft packet doesn't support DataOutputStream", e);
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException("Insufficient security privileges.", e);
-		} catch (InvocationTargetException e) {
-			throw new IOException("Could not serialize Minecraft packet.", e);
-		}
-	}
-
-	private void readObject(ObjectInputStream input) throws ClassNotFoundException, IOException {
-	    // Default deserialization
-		input.defaultReadObject();
-		
-		// Get structure modifier
-		structureModifier = StructureCache.getStructure(id);
-
-	    // Don't read NULL packets
-	    if (input.readBoolean()) {
-	    	
-	    	// Create a default instance of the packet
-	    	handle = StructureCache.newPacket(id);
-	    	
-			// Retrieve the read method by reflection
-			if (readMethod == null)
-				readMethod = FuzzyReflection.fromObject(handle).getMethodByParameters("read", DataInputStream.class);
-	    	
-			// Call the read method
-			try {
-				readMethod.invoke(handle, new DataInputStream(input));
-			} catch (IllegalArgumentException e) {
-				throw new IOException("Minecraft packet doesn't support DataInputStream", e);
-			} catch (IllegalAccessException e) {
-				throw new RuntimeException("Insufficient security privileges.", e);
-			} catch (InvocationTargetException e) {
-				throw new IOException("Could not deserialize Minecraft packet.", e);
-			}
-			
-			// And we're done
-			structureModifier = structureModifier.withTarget(handle);
-	    }
-	}
-}

ProtocolLib/src/com/comphenix/protocol/events/PacketEvent.java

@@ -1,214 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.events;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.util.EventObject;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-import com.comphenix.protocol.async.AsyncMarker;
-
-public class PacketEvent extends EventObject implements Cancellable {
-	/**
-	 * Automatically generated by Eclipse.
-	 */
-	private static final long serialVersionUID = -5360289379097430620L;
-
-	private transient Player player;
-	private PacketContainer packet;
-	private boolean serverPacket;
-	private boolean cancel;
-	
-	private AsyncMarker asyncMarker;
-	private boolean asynchronous;
-	
-	/**
-	 * Use the static constructors to create instances of this event.
-	 * @param source - the event source.
-	 */
-	public PacketEvent(Object source) {
-		super(source);
-	}
-
-	private PacketEvent(Object source, PacketContainer packet, Player player, boolean serverPacket) {
-		super(source);
-		this.packet = packet;
-		this.player = player;
-		this.serverPacket = serverPacket;
-	}
-	
-	private PacketEvent(PacketEvent origial, AsyncMarker asyncMarker) {
-		super(origial.source);
-		this.packet = origial.packet;
-		this.player = origial.player;
-		this.cancel = origial.cancel;
-		this.serverPacket = origial.serverPacket;
-		this.asyncMarker = asyncMarker;
-		this.asynchronous = true;
-	}
-
-	/**
-	 * Creates an event representing a client packet transmission.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param client - the client that sent the packet.
-	 * @return The event.
-	 */
-	public static PacketEvent fromClient(Object source, PacketContainer packet, Player client) {
-		return new PacketEvent(source, packet, client, false);
-	}
-	
-	/**
-	 * Creates an event representing a server packet transmission.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param recipient - the client that will receieve the packet.
-	 * @return The event.
-	 */
-	public static PacketEvent fromServer(Object source,  PacketContainer packet, Player recipient) {
-		return new PacketEvent(source, packet, recipient, true);
-	}
-	
-	/**
-	 * Create an asynchronous packet event from a synchronous event and a async marker.
-	 * @param event - the original synchronous event.
-	 * @param marker - the asynchronous marker.
-	 * @return The new packet event.
-	 */
-	public static PacketEvent fromSynchronous(PacketEvent event, AsyncMarker marker) {
-		return new PacketEvent(event, marker);
-	}
-	
-	/**
-	 * Retrieves the packet that will be sent to the player.
-	 * @return Packet to send to the player.
-	 */
-	public PacketContainer getPacket() {
-		return packet;
-	}
-
-	/**
-	 * Replace the packet that will be sent to the player.
-	 * @param packet - the packet that will be sent instead.
-	 */
-	public void setPacket(PacketContainer packet) {
-		this.packet = packet;
-	}
-
-	/**
-	 * Retrieves the packet ID.
-	 * @return The current packet ID.
-	 */
-	public int getPacketID() {
-		return packet.getID();
-	}
-	
-	/**
-	 * Retrieves whether or not the packet should be cancelled.
-	 * @return TRUE if it should be cancelled, FALSE otherwise.
-	 */
-	public boolean isCancelled() {
-		return cancel;
-	}
-
-	/**
-	 * Sets whether or not the packet should be cancelled.
-	 * @param cancel - TRUE if it should be cancelled, FALSE otherwise.
-	 */
-	public void setCancelled(boolean cancel) {
-		this.cancel = cancel;
-	}
-
-	/**
-	 * Retrieves the player that has sent the packet or is recieving it.
-	 * @return The player associated with this event.
-	 */
-	public Player getPlayer() {
-		return player;
-	}
-	
-	/**
-	 * Whether or not this packet was created by the server.
-	 * <p>
-	 * Most listeners can deduce this by noting which listener method was invoked.
-	 * @return TRUE if the packet was created by the server, FALSE if it was created by a client.
-	 */
-	public boolean isServerPacket() {
-		return serverPacket;
-	}
-	
-	/**
-	 * Retrieve the asynchronous marker.
-	 * <p>
-	 * If the packet is synchronous, this marker will be used to schedule an asynchronous event. In the following
-	 * asynchronous event, the marker is used to correctly pass the packet around to the different threads.
-	 * <p>
-	 * Note that if there are no asynchronous events that can receive this packet, the marker is NULL.
-	 * @return The current asynchronous marker, or NULL.
-	 */
-	public AsyncMarker getAsyncMarker() {
-		return asyncMarker;
-	}
-	/**
-	 * Set the asynchronous marker. 
-	 * <p>
-	 * If the marker is non-null at the end of an synchronous event processing, the packet will be scheduled
-	 * to be processed asynchronously with the given settings.
-	 * <p>
-	 * Note that if there are no asynchronous events that can receive this packet, the marker should be NULL. 
-	 * @param asyncMarker - the new asynchronous marker, or NULL.
-	 * @throws IllegalStateException If the current event is asynchronous.
-	 */
-	public void setAsyncMarker(AsyncMarker asyncMarker) {
-		if (isAsynchronous())
-			throw new IllegalStateException("The marker is immutable for asynchronous events");
-		this.asyncMarker = asyncMarker;
-	}
-
-	/**
-	 * Determine if the packet event has been executed asynchronously or not.
-	 * @return TRUE if this packet event is asynchronous, FALSE otherwise.
-	 */
-	public boolean isAsynchronous() {
-		return asynchronous;
-	}
-	
-	private void writeObject(ObjectOutputStream output) throws IOException {
-	    // Default serialization 
-		output.defaultWriteObject();
-
-		// Write the name of the player (or NULL if it's not set)
-		output.writeObject(player != null ? new SerializedOfflinePlayer(player) : null);
-	}
-
-	private void readObject(ObjectInputStream input) throws ClassNotFoundException, IOException {
-	    // Default deserialization
-		input.defaultReadObject();
-
-		final SerializedOfflinePlayer offlinePlayer = (SerializedOfflinePlayer) input.readObject();
-		
-	    if (offlinePlayer != null) {
-	    	// Better than nothing
-	    	player = offlinePlayer.getPlayer();
-	    }
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/ListenerInvoker.java

@@ -1,27 +0,0 @@
-package com.comphenix.protocol.injector;
-
-import net.minecraft.server.Packet;
-
-import com.comphenix.protocol.events.PacketEvent;
-
-public interface ListenerInvoker {
-
-	/**
-	 * Invokes the given packet event for every registered listener.
-	 * @param event - the packet event to invoke.
-	 */
-	public abstract void invokePacketRecieving(PacketEvent event);
-
-	/**
-	 * Invokes the given packet event for every registered listener.
-	 * @param event - the packet event to invoke.
-	 */
-	public abstract void invokePacketSending(PacketEvent event);
-
-	/**
-	 * Retrieve the associated ID of a packet.
-	 * @param packet - the packet.
-	 * @return The packet ID.
-	 */
-	public abstract int getPacketID(Packet packet);
-}

ProtocolLib/src/com/comphenix/protocol/injector/MinecraftRegistry.java

@@ -1,104 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.injector;
-
-import java.lang.reflect.Field;
-import java.util.HashMap;
-import java.util.Map;
-
-import net.minecraft.server.Packet;
-
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.google.common.base.Objects;
-
-/**
- * Static registries in Minecraft.
- * 
- * @author Kristian
- */
-@SuppressWarnings("rawtypes")
-class MinecraftRegistry {
-
-	// The packet class to packet ID translator
-	private static Map<Class, Integer> packetToID;
-	
-	// New proxy values
-	private static Map<Integer, Class> overwrittenPackets = new HashMap<Integer, Class>();
-	
-	// Vanilla packets
-	private static Map<Integer, Class> previousValues = new HashMap<Integer, Class>();
-	
-	@SuppressWarnings({ "unchecked" })
-	public static Map<Class, Integer> getPacketToID() {
-		// Initialize it, if we haven't already
-		if (packetToID == null) {
-			try {
-				Field packetsField = FuzzyReflection.fromClass(Packet.class, true).getFieldByType("packetsField", Map.class);
-				packetToID = (Map<Class, Integer>) FieldUtils.readStaticField(packetsField, true);
-				
-			} catch (IllegalAccessException e) {
-				throw new RuntimeException("Unable to retrieve the packetClassToIdMap", e);
-			}
-		}
-		
-		return packetToID;
-	}
-	
-	public static Map<Integer, Class> getOverwrittenPackets() {
-		return overwrittenPackets;
-	}
-	
-	public static Map<Integer, Class> getPreviousPackets() {
-		return previousValues;
-	}
-	
-	/**
-	 * Retrieves the correct packet class from a given packet ID.
-	 * @param packetID - the packet ID.
-	 * @return The associated class.
-	 */
-	public static Class getPacketClassFromID(int packetID) {
-		return getPacketClassFromID(packetID, false);
-	}
-	
-	/**
-	 * Retrieves the correct packet class from a given packet ID.
-	 * @param packetID - the packet ID.
- 	 * @param vanilla - whether or not to look for vanilla classes, not injected classes.
-	 * @return The associated class.
-	 */
-	public static Class getPacketClassFromID(int packetID, boolean forceVanilla) {
-		
-		Map<Integer, Class> lookup = forceVanilla ? previousValues : overwrittenPackets;
-		
-		// Optimized lookup
-		if (lookup.containsKey(packetID)) {
-			return lookup.get(packetID);
-		}
-
-		// Will most likely not be used
-		for (Map.Entry<Class, Integer> entry : getPacketToID().entrySet()) {
-			if (Objects.equal(entry.getValue(), packetID)) {
-				return entry.getKey();
-			}
-		}
-		
-		throw new IllegalArgumentException("The packet ID " + packetID + " is not registered.");
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/PacketConstructor.java

@@ -1,231 +0,0 @@
-package com.comphenix.protocol.injector;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import net.minecraft.server.Packet;
-
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-
-/**
- * A packet constructor that uses an internal Minecraft.
- * @author Kristian
- *
- */
-public class PacketConstructor {
-
-	/**
-	 * A packet constructor that automatically converts Bukkit types to their NMS conterpart. 
-	 * <p>
-	 * Remember to call withPacket().
-	 */
-	public static PacketConstructor DEFAULT = new PacketConstructor(null);
-	
-	// The constructor method that's actually responsible for creating the packet
-	private Constructor<?> constructorMethod;
-	
-	// The packet ID
-	private int packetID;
-	
-	// Used to unwrap Bukkit objects
-	private List<Unwrapper> unwrappers;
-	
-	private PacketConstructor(Constructor<?> constructorMethod) {
-		this.constructorMethod = constructorMethod;
-		this.unwrappers = Lists.newArrayList((Unwrapper) new BukkitUnwrapper());
-	}
-	
-	private PacketConstructor(int packetID, Constructor<?> constructorMethod, List<Unwrapper> unwrappers) {
-		this.packetID = packetID;
-		this.constructorMethod = constructorMethod;
-		this.unwrappers = unwrappers;
-	}
-	
-	public ImmutableList<Unwrapper> getUnwrappers() {
-		return ImmutableList.copyOf(unwrappers);
-	}
-	
-	/**
-	 * Retrieve the id of the packets this constructor creates.
-	 * @return The ID of the packets this constructor will create.
-	 */
-	public int getPacketID() {
-		return packetID;
-	}
-	
-	/**
-	 * Return a copy of the current constructor with a different list of unwrappers.
-	 * @param unwrappers - list of unwrappers that convert Bukkit wrappers into the equivalent NMS classes.
-	 * @return A constructor with a different set of unwrappers.
-	 */
-	public PacketConstructor withUnwrappers(List<Unwrapper> unwrappers) {
-		return new PacketConstructor(packetID, constructorMethod, unwrappers);
-	}
-
-	/**
-	 * Create a packet constructor that creates packets using the given types.
-	 * @param id - packet ID.
-	 * @param types - types to create.
-	 * @return A packet constructor with these types.
-	 * @throws IllegalArgumentException If no packet constructor could be created with these types.
-	 */
-	public PacketConstructor withPacket(int id, Object[] values) {
-		
-		Class<?>[] types = new Class<?>[values.length];
-		
-		for (int i = 0; i < types.length; i++) {
-			// Default type
-			if (values[i] != null) {
-				types[i] = values[i].getClass();
-				
-				for (Unwrapper unwrapper : unwrappers) {
-					Object result = unwrapper.unwrapItem(values[i]);
-					
-					// Update type we're searching for
-					if (result != null) {
-						types[i] = result.getClass();
-						break;
-					}
-				}
-			
-			} else {
-				// Try it
-				types[i] = Object.class;
-			}
-		}
-		
-		Class<?> packetType = MinecraftRegistry.getPacketClassFromID(id);
-		
-		if (packetType == null)
-			throw new IllegalArgumentException("Could not find a packet by the id " + id);
-		
-		// Find the correct constructor
-		for (Constructor<?> constructor : packetType.getConstructors()) {
-			Class<?>[] params = constructor.getParameterTypes();
-
-			if (isCompatible(types, params)) {
-				// Right, we've found our type
-				return new PacketConstructor(id, constructor, unwrappers);
-			}
-		}
-		
-		throw new IllegalArgumentException("No suitable constructor could be found.");
-	}
-	
-	/**
-	 * Construct a packet using the special builtin Minecraft constructors.
-	 * @param values - values containing Bukkit wrapped items to pass to Minecraft.
-	 * @return The created packet.
-	 * @throws FieldAccessException Failure due to a security limitation.
-	 * @throws IllegalArgumentException Arguments doesn't match the constructor.
-	 * @throws RuntimeException Minecraft threw an exception.
-	 */
-	public PacketContainer createPacket(Object... values) throws FieldAccessException {
-		
-		try {
-			// Convert types
-			for (int i = 0; i < values.length; i++) {
-				for (Unwrapper unwrapper : unwrappers) {
-					Object converted = unwrapper.unwrapItem(values[i]);
-					
-					if (converted != null) {
-						values[i] = converted;
-						break;
-					}
-				}
-			}
-			
-			Packet nmsPacket = (Packet) constructorMethod.newInstance(values);
-			return new PacketContainer(packetID, nmsPacket);
-			
-		} catch (IllegalArgumentException e) {
-			throw e;
-		} catch (InstantiationException e) {
-			throw new FieldAccessException("Cannot construct an abstract packet.", e);
-		} catch (IllegalAccessException e) {
-			throw new FieldAccessException("Cannot construct packet due to a security limitation.", e);
-		} catch (InvocationTargetException e) {
-			throw new RuntimeException("Minecraft error.", e);
-		}
-	}
-	
-	// Determine if a method with the types 'params' can be called with 'types'
-	private static boolean isCompatible(Class<?>[] types, Class<?>[] params) {
-		
-		// Determine if the types are similar
-		if (params.length == types.length) {
-			for (int i = 0; i < params.length; i++) {
-				if (!params[i].isAssignableFrom(types[i])) {
-					return false;
-				}
-			}
-			
-			return true;
-		}
-		
-		// Parameter count must match
-		return false;
-	}
-
-	public static class BukkitUnwrapper implements Unwrapper {
-	
-		private static Map<Class<?>, Method> cache = new ConcurrentHashMap<Class<?>, Method>();
-	
-		@Override
-		public Object unwrapItem(Object wrappedObject) {
-
-			Class<?> currentClass = wrappedObject.getClass();
-			Method cachedMethod = initializeCache(currentClass);
-			
-			try {
-				// Retrieve the handle
-				if (cachedMethod != null)
-					return cachedMethod.invoke(wrappedObject);
-				else
-					return null;
-				
-			} catch (IllegalArgumentException e) {
-				// Impossible
-				return null;
-			} catch (IllegalAccessException e) {
-				return null;
-			} catch (InvocationTargetException e) {
-				// This is REALLY bad
-				throw new RuntimeException("Minecraft error.", e);
-			}
-		}
-		
-		private Method initializeCache(Class<?> type) {
-			
-			// See if we're already determined this
-			if (cache.containsKey(type)) {
-				// We will never remove from the cache, so this ought to be thread safe
-				return cache.get(type);
-			}
-			
-			try {
-				Method find = type.getMethod("getHandle");
-				
-				// It's thread safe, as getMethod should return the same handle 
-				cache.put(type, find);
-				return find;
-				
-			} catch (SecurityException e) {
-				return null;
-			} catch (NoSuchMethodException e) {
-				return null;
-			}
-		}
-	}
-	
-	public static interface Unwrapper {
-		public Object unwrapItem(Object wrappedObject);
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/PacketFilterManager.java

@@ -1,601 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.injector;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import net.minecraft.server.Packet;
-import net.sf.cglib.proxy.Enhancer;
-import net.sf.cglib.proxy.MethodInterceptor;
-import net.sf.cglib.proxy.MethodProxy;
-
-import org.bukkit.Server;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.server.PluginDisableEvent;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginManager;
-
-import com.comphenix.protocol.AsynchronousManager;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.async.AsyncFilterManager;
-import com.comphenix.protocol.async.AsyncMarker;
-import com.comphenix.protocol.events.*;
-import com.comphenix.protocol.injector.player.PlayerInjectionHandler;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.google.common.base.Objects;
-import com.google.common.collect.ImmutableSet;
-
-public final class PacketFilterManager implements ProtocolManager, ListenerInvoker {
-
-	/**
-	 * Sets the inject hook type. Different types allow for maximum compatibility.
-	 * @author Kristian
-	 */
-	public enum PlayerInjectHooks {
-		/**
-		 * Override the packet queue lists in NetworkHandler. 
-		 * <p>
-		 * Cannot intercept MapChunk packets. 
-		 */
-		NETWORK_HANDLER_FIELDS,
-		
-		/**
-		 * Override the network handler object itself. Only works in 1.3.
-		 * <p>
-		 * Cannot intercept MapChunk packets. 
-		 */
-		NETWORK_MANAGER_OBJECT,
-		
-		/**
-		 * Override the server handler object. Versatile, but a tad slower.
-		 */
-		NETWORK_SERVER_OBJECT;
-	}
-	
-	// Create a concurrent set
-	private Set<PacketListener> packetListeners = 
-			Collections.newSetFromMap(new ConcurrentHashMap<PacketListener, Boolean>());
-		
-	// Packet injection
-	private PacketInjector packetInjector;
-	
-	// Player injection
-	private PlayerInjectionHandler playerInjection;
-	
-	// The two listener containers
-	private SortedPacketListenerList recievedListeners = new SortedPacketListenerList();
-	private SortedPacketListenerList sendingListeners = new SortedPacketListenerList();
-	
-	// Whether or not this class has been closed
-	private volatile boolean hasClosed;
-	
-	// The default class loader
-	private ClassLoader classLoader;
-		
-	// Error logger
-	private Logger logger;
-	
-	// The async packet handler
-	private AsyncFilterManager asyncFilterManager;
-	
-	/**
-	 * Only create instances of this class if protocol lib is disabled.
-	 */
-	public PacketFilterManager(ClassLoader classLoader, Server server, Logger logger) {
-		if (logger == null)
-			throw new IllegalArgumentException("logger cannot be NULL.");
-		if (classLoader == null)
-			throw new IllegalArgumentException("classLoader cannot be NULL.");
-		
-		try {
-			// Initialize values
-			this.classLoader = classLoader;
-			this.logger = logger;
-			this.playerInjection = new PlayerInjectionHandler(classLoader, logger, this, server);
-			this.packetInjector = new PacketInjector(classLoader, this, playerInjection);
-			this.asyncFilterManager = new AsyncFilterManager(logger, server.getScheduler(), this);
-		} catch (IllegalAccessException e) {
-			logger.log(Level.SEVERE, "Unable to initialize packet injector.", e);
-		}
-	}
-	
-	@Override
-	public AsynchronousManager getAsynchronousManager() {
-		return asyncFilterManager;
-	}
-	
-	/**
-	 * Retrieves how the server packets are read.
-	 * @return Injection method for reading server packets.
-	 */
-	public PlayerInjectHooks getPlayerHook() {
-		return playerInjection.getPlayerHook();
-	}
-
-	/**
-	 * Sets how the server packets are read.
-	 * @param playerHook - the new injection method for reading server packets.
-	 */
-	public void setPlayerHook(PlayerInjectHooks playerHook) {
-		playerInjection.setPlayerHook(playerHook);
-		
-		// Make sure the current listeners are compatible
-		playerInjection.checkListener(packetListeners);
-	}
-
-	public Logger getLogger() {
-		return logger;
-	}
-	
-	@Override
-	public ImmutableSet<PacketListener> getPacketListeners() {
-		return ImmutableSet.copyOf(packetListeners);
-	}
-
-	@Override
-	public void addPacketListener(PacketListener listener) {
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL.");
-		
-		// A listener can only be added once
-		if (packetListeners.contains(listener))
-			return;
-		
-		ListeningWhitelist sending = listener.getSendingWhitelist();
-		ListeningWhitelist receiving = listener.getReceivingWhitelist();
-		boolean hasSending = sending != null && sending.isEnabled();
-		boolean hasReceiving = receiving != null && receiving.isEnabled();
-		
-		if (hasSending || hasReceiving) {
-			// Add listeners and hooks
-			if (hasSending) {
-				verifyWhitelist(listener, sending);
-				sendingListeners.addListener(listener, sending);
-				enablePacketFilters(ConnectionSide.SERVER_SIDE, sending.getWhitelist());
-				
-				// Make sure this is possible
-				playerInjection.checkListener(listener);
-			}
-			if (hasReceiving) {
-				verifyWhitelist(listener, receiving);
-				recievedListeners.addListener(listener, receiving);
-				enablePacketFilters(ConnectionSide.CLIENT_SIDE, receiving.getWhitelist());
-			}
-			
-			// Inform our injected hooks
-			packetListeners.add(listener);
-		}
-	}
-	
-	/**
-	 * Determine if the packet IDs in a whitelist is valid.
-	 * @param listener - the listener that will be mentioned in the error.
-	 * @param whitelist - whitelist of packet IDs.
-	 * @throws IllegalArgumentException If the whitelist is illegal.
-	 */
-	public static void verifyWhitelist(PacketListener listener, ListeningWhitelist whitelist) {
-		for (Integer id : whitelist.getWhitelist()) {
-			if (id >= 256 || id < 0) {
-				throw new IllegalArgumentException(String.format("Invalid packet id %s in listener %s.", 
-							id, PacketAdapter.getPluginName(listener))
-				);
-			}
-		}
-	}
-		
-	@Override
-	public void removePacketListener(PacketListener listener) {
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL");
-
-		List<Integer> sendingRemoved = null;
-		List<Integer> receivingRemoved = null;
-		
-		ListeningWhitelist sending = listener.getSendingWhitelist();
-		ListeningWhitelist receiving = listener.getReceivingWhitelist();
-		
-		// Remove from the overal list of listeners
-		if (!packetListeners.remove(listener))
-			return;
-		
-		// Add listeners
-		if (sending != null && sending.isEnabled())
-			sendingRemoved = sendingListeners.removeListener(listener, sending);
-		if (receiving != null && receiving.isEnabled())
-			receivingRemoved = recievedListeners.removeListener(listener, receiving);
-		
-		// Remove hooks, if needed
-		if (sendingRemoved != null && sendingRemoved.size() > 0)
-			disablePacketFilters(ConnectionSide.SERVER_SIDE, sendingRemoved);
-		if (receivingRemoved != null && receivingRemoved.size() > 0)
-			disablePacketFilters(ConnectionSide.CLIENT_SIDE, receivingRemoved);
-	}
-	
-	@Override
-	public void removePacketListeners(Plugin plugin) {
-		
-		// Iterate through every packet listener
-		for (PacketListener listener : packetListeners) {			
-			// Remove the listener
-			if (Objects.equal(listener.getPlugin(), plugin)) {
-				removePacketListener(listener);
-			}
-		}
-		
-		// Do the same for the asynchronous events
-		asyncFilterManager.unregisterAsyncHandlers(plugin);
-	}
-	
-	@Override
-	public void invokePacketRecieving(PacketEvent event) {
-		handlePacket(recievedListeners, event, false);
-	}
-
-	@Override
-	public void invokePacketSending(PacketEvent event) {
-		handlePacket(sendingListeners, event, true);
-	}
-	
-	/**
-	 * Handle a packet sending or receiving event.
-	 * <p>
-	 * Note that we also handle asynchronous events.
-	 * @param packetListeners - packet listeners that will receive this event.
-	 * @param event - the evnet to broadcast.
-	 */
-	private void handlePacket(SortedPacketListenerList packetListeners, PacketEvent event, boolean sending) {
-		
-		// By default, asynchronous packets are queued for processing
-		if (asyncFilterManager.hasAsynchronousListeners(event)) {
-			event.setAsyncMarker(asyncFilterManager.createAsyncMarker());
-		}
-		
-		// Process synchronous events
-		if (sending)
-			packetListeners.invokePacketSending(logger, event);
-		else
-			packetListeners.invokePacketRecieving(logger, event);
-		
-		// To cancel asynchronous processing, use the async marker
-		if (!event.isCancelled() && !hasAsyncCancelled(event.getAsyncMarker())) {
-			asyncFilterManager.enqueueSyncPacket(event, event.getAsyncMarker());
-
-			// The above makes a copy of the event, so it's safe to cancel it
-			event.setCancelled(true);
-		}
-	}
-	
-	// NULL marker mean we're dealing with no asynchronous listeners 
-	private boolean hasAsyncCancelled(AsyncMarker marker) {
-		return marker == null || marker.isAsyncCancelled();
-	}
-	
-	/**
-	 * Enables packet events for a given packet ID.
-	 * <p>
-	 * Note that all packets are disabled by default.
-	 * 
-	 * @param side - which side the event will arrive from.
-	 * @param packets - the packet id(s).
-	 */
-	private void enablePacketFilters(ConnectionSide side, Iterable<Integer> packets) {
-		if (side == null)
-			throw new IllegalArgumentException("side cannot be NULL.");
-		
-		for (int packetID : packets) {
-			if (side.isForServer()) 
-				playerInjection.addPacketHandler(packetID);
-			if (side.isForClient() && packetInjector != null) 
-				packetInjector.addPacketHandler(packetID);
-		}
-	}
-
-	/**
-	 * Disables packet events from a given packet ID.
-	 * @param packets - the packet id(s).
-	 * @param side - which side the event no longer should arrive from.
-	 */
-	private void disablePacketFilters(ConnectionSide side, Iterable<Integer> packets) {
-		if (side == null)
-			throw new IllegalArgumentException("side cannot be NULL.");
-		
-		for (int packetID : packets) {
-			if (side.isForServer())
-				playerInjection.removePacketHandler(packetID);
-			if (side.isForClient() && packetInjector != null) 
-				packetInjector.removePacketHandler(packetID);
-		}
-	}
-	
-	@Override
-	public void sendServerPacket(Player reciever, PacketContainer packet) throws InvocationTargetException {
-		sendServerPacket(reciever, packet, true);
-	}
-	
-	@Override
-	public void sendServerPacket(Player reciever, PacketContainer packet, boolean filters) throws InvocationTargetException {
-		if (reciever == null)
-			throw new IllegalArgumentException("reciever cannot be NULL.");
-		if (packet == null)
-			throw new IllegalArgumentException("packet cannot be NULL.");
-		
-		playerInjection.sendServerPacket(reciever, packet, filters);
-	}
-
-	@Override
-	public void recieveClientPacket(Player sender, PacketContainer packet) throws IllegalAccessException, InvocationTargetException {
-		recieveClientPacket(sender, packet, true);
-	}
-	
-	@Override
-	public void recieveClientPacket(Player sender, PacketContainer packet, boolean filters) throws IllegalAccessException, InvocationTargetException {
-		
-		if (sender == null)
-			throw new IllegalArgumentException("sender cannot be NULL.");
-		if (packet == null)
-			throw new IllegalArgumentException("packet cannot be NULL.");
-		
-		Packet mcPacket = packet.getHandle();
-		
-		// Make sure the packet isn't cancelled
-		packetInjector.undoCancel(packet.getID(), mcPacket);
-		
-		if (filters) {
-			PacketEvent event  = packetInjector.packetRecieved(packet, sender);
-			
-			if (!event.isCancelled())
-				mcPacket = event.getPacket().getHandle();
-			else
-				return;
-		}
-		
-		playerInjection.processPacket(sender, mcPacket);
-	}
-	
-	@Override
-	public PacketContainer createPacket(int id) {
-		return createPacket(id, true);
-	}
-	
-	@Override
-	public PacketContainer createPacket(int id, boolean forceDefaults) {
-		PacketContainer packet = new PacketContainer(id);
-		
-		// Use any default values if possible
-		if (forceDefaults) {
-			try {
-				packet.getModifier().writeDefaults();
-			} catch (FieldAccessException e) {
-				throw new RuntimeException("Security exception.", e);
-			}
-		}
-		
-		return packet;
-	}
-	
-	@Override
-	public PacketConstructor createPacketConstructor(int id, Object... arguments) {
-		return PacketConstructor.DEFAULT.withPacket(id, arguments);
-	}
-
-	@Override
-	public Set<Integer> getSendingFilters() {
-		return playerInjection.getSendingFilters();
-	}
-	
-	@Override
-	public Set<Integer> getReceivingFilters() {
-		return ImmutableSet.copyOf(packetInjector.getPacketHandlers());
-	}
-	
-	@Override
-	public void updateEntity(Entity entity, List<Player> observers) throws FieldAccessException {
-		EntityUtilities.updateEntity(entity, observers);
-	}
-	
-	/**
-	 * Initialize the packet injection for every player.
-	 * @param players - list of players to inject. 
-	 */
-	public void initializePlayers(Player[] players) {
-		for (Player player : players)
-			playerInjection.injectPlayer(player);
-	}
-		
-	/**
-	 * Register this protocol manager on Bukkit.
-	 * @param manager - Bukkit plugin manager that provides player join/leave events.
-	 * @param plugin - the parent plugin.
-	 */
-	public void registerEvents(PluginManager manager, final Plugin plugin) {
-		
-		try {
-			manager.registerEvents(new Listener() {
-				
-				@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-			    public void onPlayerJoin(PlayerJoinEvent event) {
-					playerInjection.injectPlayer(event.getPlayer());
-			    }
-				
-				@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-			    public void onPlayerQuit(PlayerQuitEvent event) {
-					playerInjection.uninjectPlayer(event.getPlayer());
-			    }
-				
-				@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-			    public void onPluginDisabled(PluginDisableEvent event) {
-					// Clean up in case the plugin forgets
-					if (event.getPlugin() != plugin) {
-						removePacketListeners(event.getPlugin());
-					}
-			    }
-				
-			}, plugin);
-		
-		} catch (NoSuchMethodError e) {
-			// Oh wow! We're running on 1.0.0 or older.
-			registerOld(manager, plugin);
-		}
-	}
-	
-	@Override
-	public int getPacketID(Packet packet) {
-		if (packet == null)
-			throw new IllegalArgumentException("Packet cannot be NULL.");
-		
-		return MinecraftRegistry.getPacketToID().get(packet.getClass());
-	}
-	
-	// Yes, this is crazy.
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	private void registerOld(PluginManager manager, Plugin plugin) {
-		
-		try {
-			ClassLoader loader = manager.getClass().getClassLoader();
-			
-			// The different enums we are going to need
-			Class eventTypes = loader.loadClass("org.bukkit.event.Event$Type");
-			Class eventPriority = loader.loadClass("org.bukkit.event.Event$Priority");
-			
-			// Get the priority
-			Object priorityNormal = Enum.valueOf(eventPriority, "Highest");
-			
-			// Get event types
-			Object playerJoinType = Enum.valueOf(eventTypes, "PLAYER_JOIN");
-			Object playerQuitType = Enum.valueOf(eventTypes, "PLAYER_QUIT");
-			Object pluginDisabledType = Enum.valueOf(eventTypes, "PLUGIN_DISABLE");
-			
-			// The player listener! Good times.
-			Class<?> playerListener = loader.loadClass("org.bukkit.event.player.PlayerListener");
-			Class<?> serverListener = loader.loadClass("org.bukkit.event.server.ServerListener");
-			
-			// Find the register event method
-			Method registerEvent = FuzzyReflection.fromObject(manager).getMethodByParameters("registerEvent", 
-					eventTypes, Listener.class, eventPriority, Plugin.class);
-
-			Enhancer playerEx = new Enhancer();
-			Enhancer serverEx = new Enhancer();
-			
-			playerEx.setSuperclass(playerListener);
-			playerEx.setClassLoader(classLoader);
-			playerEx.setCallback(new MethodInterceptor() {
-				@Override
-				public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
-					// Must have a parameter
-					if (args.length == 1) {
-						Object event = args[0];
-						
-						// Check for the correct event
-						if (event instanceof PlayerJoinEvent)
-							playerInjection.injectPlayer(((PlayerJoinEvent) event).getPlayer());
-						else if (event instanceof PlayerQuitEvent)
-							playerInjection.uninjectPlayer(((PlayerQuitEvent) event).getPlayer());
-					}
-					return null;
-				}
-			});
-			
-			serverEx.setSuperclass(serverListener);
-			serverEx.setClassLoader(classLoader);
-			serverEx.setCallback(new MethodInterceptor() {
-				@Override
-				public Object intercept(Object obj, Method method, Object[] args,
-						MethodProxy proxy) throws Throwable {
-					// Must have a parameter
-					if (args.length == 1) {
-						Object event = args[0];
-						
-						if (event instanceof PluginDisableEvent)
-							removePacketListeners(((PluginDisableEvent) event).getPlugin());
-					}
-					return null;
-				}
-			});
-			
-			// Create our listener
-			Object playerProxy = playerEx.create();
-			Object serverProxy = serverEx.create();
-			
-			registerEvent.invoke(manager, playerJoinType, playerProxy, priorityNormal, plugin);
-			registerEvent.invoke(manager, playerQuitType, playerProxy, priorityNormal, plugin);
-			registerEvent.invoke(manager, pluginDisabledType, serverProxy, priorityNormal, plugin);
-			
-			// A lot can go wrong
-		} catch (ClassNotFoundException e1) {
-			e1.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			e.printStackTrace();
-		} catch (InvocationTargetException e) {
-			e.printStackTrace();
-		}
-	}
-		
-	/**
-	 * Retrieves the current plugin class loader.
-	 * @return Class loader.
-	 */
-	public ClassLoader getClassLoader() {
-		return classLoader;
-	}
-	
-	@Override
-	public boolean isClosed() {
-		return hasClosed;
-	}
-	
-	public void close() {
-		// Guard
-		if (hasClosed)
-			return;
-
-		// Remove packet handlers
-		if (packetInjector != null)
-			packetInjector.cleanupAll();
-		
-		// Remove server handler
-		playerInjection.close();
-		hasClosed = true;
-		
-		// Remove listeners
-		packetListeners.clear();
-		
-		// Clean up async handlers. We have to do this last.
-		asyncFilterManager.cleanupAll();
-	}
-	
-	@Override
-	protected void finalize() throws Throwable {
-		close();
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/PacketInjector.java

@@ -1,229 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.injector;
-
-import java.io.DataInputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.bukkit.entity.Player;
-
-import net.minecraft.server.Packet;
-import net.sf.cglib.proxy.Callback;
-import net.sf.cglib.proxy.Enhancer;
-
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.player.PlayerInjectionHandler;
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-
-/**
- * This class is responsible for adding or removing proxy objects that intercepts recieved packets.
- * 
- * @author Kristian
- */
-class PacketInjector {
-
-	// The "put" method that associates a packet ID with a packet class
-	private static Method putMethod;
-	private static Object intHashMap;
-	
-	// The packet filter manager
-	private ListenerInvoker manager;
-	
-	// Allows us to determine the sender
-	private PlayerInjectionHandler playerInjection;
-	
-	// Allows us to look up read packet injectors
-	private Map<Integer, ReadPacketModifier> readModifier;
-	
-	// Class loader
-	private ClassLoader classLoader;
-			
-	public PacketInjector(ClassLoader classLoader, ListenerInvoker manager, 
-						  PlayerInjectionHandler playerInjection) throws IllegalAccessException {
-		
-		this.classLoader = classLoader;
-		this.manager = manager;
-		this.playerInjection = playerInjection;
-		this.readModifier = new ConcurrentHashMap<Integer, ReadPacketModifier>();
-		initialize();
-	}
-	
-	/**
-	 * Undo a packet cancel.
-	 * @param id - the id of the packet.
-	 * @param packet - packet to uncancel.
-	 */
-	public void undoCancel(Integer id, Packet packet) {
-		ReadPacketModifier modifier = readModifier.get(id);
-		
-		// Cancelled packets are represented with NULL
-		if (modifier != null && modifier.getOverride(packet) == null) {
-			modifier.removeOverride(packet);
-		}
-	}
-	
-	private void initialize() throws IllegalAccessException {
-		if (intHashMap == null) {
-			// We're looking for the first static field with a Minecraft-object. This should be a IntHashMap.
-			Field intHashMapField = FuzzyReflection.fromClass(Packet.class, true).getFieldByType(FuzzyReflection.MINECRAFT_OBJECT);
-			
-			try {
-				intHashMap = FieldUtils.readField(intHashMapField, (Object) null, true);
-			} catch (IllegalArgumentException e) {
-				throw new RuntimeException("Minecraft is incompatible.", e);
-			}
-			
-			// Now, get the "put" method.
-			putMethod = FuzzyReflection.fromObject(intHashMap).getMethodByParameters("put", int.class, Object.class);
-		}
-	}
-	
-	@SuppressWarnings("rawtypes")
-	public boolean addPacketHandler(int packetID) {
-		if (hasPacketHandler(packetID))
-			return false;
-		
-		Enhancer ex = new Enhancer();
-		
-		// Unfortunately, we can't easily distinguish between these two functions:
-		//   * Object lookup(int par1)
-		//   * Object removeObject(int par1)
-		
-		// So, we'll use the classMapToInt registry instead.
-		Map<Integer, Class> overwritten = MinecraftRegistry.getOverwrittenPackets();
-		Map<Integer, Class> previous = MinecraftRegistry.getPreviousPackets();
-		Map<Class, Integer> registry = MinecraftRegistry.getPacketToID();
-		Class old = MinecraftRegistry.getPacketClassFromID(packetID);
-		
-		// Check for previous injections
-		if (!old.getName().startsWith("net.minecraft.")) {
-			throw new IllegalStateException("Packet " + packetID + " has already been injected.");
-		}
-		
-		// Subclass the specific packet class
-		ex.setSuperclass(old);
-		ex.setCallbackType(ReadPacketModifier.class);
-		ex.setUseCache(false);
-		ex.setClassLoader(classLoader);
-		Class proxy = ex.createClass();
-		
-		// Create the proxy handler
-		ReadPacketModifier modifier = new ReadPacketModifier(packetID, this);
-		readModifier.put(packetID, modifier);
-		
-		// Add a static reference
-		Enhancer.registerStaticCallbacks(proxy, new Callback[] { modifier });
-		
-		try {
-			// Override values
-			putMethod.invoke(intHashMap, packetID, proxy);
-			previous.put(packetID, old);
-			registry.put(proxy, packetID);
-			overwritten.put(packetID, proxy);
-			return true;
-			
-		} catch (IllegalArgumentException e) {
-			throw new RuntimeException("Illegal argument.", e);
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException("Cannot access method.", e);
-		} catch (InvocationTargetException e) {
-			throw new RuntimeException("Exception occured in IntHashMap.put.", e);
-		}
-	}
-	
-	@SuppressWarnings("rawtypes")
-	public boolean removePacketHandler(int packetID) {
-		if (!hasPacketHandler(packetID))
-			return false;
-		
-		Map<Class, Integer> registry = MinecraftRegistry.getPacketToID();
-		Map<Integer, Class> previous = MinecraftRegistry.getPreviousPackets();
-		Map<Integer, Class> overwritten = MinecraftRegistry.getOverwrittenPackets();
-		
-		// Use the old class definition
-		try {
-			Class old = previous.get(packetID);
-			Class proxy = MinecraftRegistry.getPacketClassFromID(packetID);
-			
-			putMethod.invoke(intHashMap, packetID, old);
-			previous.remove(packetID);
-			readModifier.remove(packetID);
-			registry.remove(proxy);
-			overwritten.remove(packetID);
-			return true;
-			
-			// Handle some problems
-		} catch (IllegalArgumentException e) {
-			return false;
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException("Cannot access method.", e);
-		} catch (InvocationTargetException e) {
-			throw new RuntimeException("Exception occured in IntHashMap.put.", e);
-		}
-	}
-	
-	public boolean hasPacketHandler(int packetID) {
-		return MinecraftRegistry.getPreviousPackets().containsKey(packetID);
-	}
-	
-	public Set<Integer> getPacketHandlers() {
-		return MinecraftRegistry.getPreviousPackets().keySet();
-	}
-	
-	// Called from the ReadPacketModified monitor
-	PacketEvent packetRecieved(PacketContainer packet, DataInputStream input) {
-		
-		Player client = playerInjection.getPlayerByConnection(input);
-		return packetRecieved(packet, client);
-	}
-	
-	/**
-	 * Let the packet listeners process the given packet.
-	 * @param packet - a packet to process.
-	 * @param client - the client that sent the packet.
-	 * @return The resulting packet event.
-	 */
-	public PacketEvent packetRecieved(PacketContainer packet, Player client) {
-	
-		PacketEvent event = PacketEvent.fromClient((Object) manager, packet, client);
-		
-		manager.invokePacketRecieving(event);
-		return event;
-	}
-	
-	@SuppressWarnings("rawtypes")
-	public void cleanupAll() {
-		Map<Integer, Class> overwritten = MinecraftRegistry.getOverwrittenPackets();
-		Map<Integer, Class> previous = MinecraftRegistry.getPreviousPackets();
-		
-		// Remove every packet handler
-		for (Integer id : previous.keySet()) {
-			removePacketHandler(id);
-		}
-		
-		overwritten.clear();
-		previous.clear();
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/ReadPacketModifier.java

@@ -1,122 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.injector;
-
-import java.io.DataInputStream;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.WeakHashMap;
-
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-
-import net.minecraft.server.Packet;
-import net.sf.cglib.proxy.MethodInterceptor;
-import net.sf.cglib.proxy.MethodProxy;
-
-class ReadPacketModifier implements MethodInterceptor {
-
-	@SuppressWarnings("rawtypes")
-	private static Class[] parameters = { DataInputStream.class };
-
-	// Common for all packets of the same type
-	private PacketInjector packetInjector;
-	private int packetID;
-	
-	// Whether or not a packet has been cancelled
-	private static WeakHashMap<Object, Object> override = new WeakHashMap<Object, Object>();
-	
-	public ReadPacketModifier(int packetID, PacketInjector packetInjector) {
-		this.packetID = packetID;
-		this.packetInjector = packetInjector;
-	}
-	
-	/**
-	 * Remove any packet overrides.
-	 * @param packet - the packet to rever
-	 */
-	public void removeOverride(Packet packet) {
-		override.remove(packet);
-	}
-	
-	/**
-	 * Retrieve the packet that overrides the methods of the given packet.
-	 * @param packet - the given packet.
-	 * @return Overriden object.
-	 */
-	public Object getOverride(Packet packet) {
-		return override.get(packet);
-	}
-
-	@Override
-	public Object intercept(Object thisObj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
-		
-		Object returnValue = null;
-		String methodName = method.getName();
-
-		// We always pass these down (otherwise, we'll end up with a infinite loop)
-		if (methodName.equals("hashCode") || methodName.equals("equals") || methodName.equals("toString")) {
-			return proxy.invokeSuper(thisObj, args);
-		}
-		
-		if (override.containsKey(thisObj)) {
-			Object overridenObject = override.get(thisObj);
-			
-			// This packet has been cancelled
-			if (overridenObject == null) {
-				// So, cancel all void methods
-				if (method.getReturnType().equals(Void.TYPE))
-					return null;
-				else // Revert to normal for everything else
-					overridenObject = thisObj;
-			}
-			
-			returnValue = proxy.invokeSuper(overridenObject, args);
-		} else {
-			returnValue = proxy.invokeSuper(thisObj, args);
-		}
-		
-		// Is this a readPacketData method?
-		if (returnValue == null && 
-				Arrays.equals(method.getParameterTypes(), parameters)) {
-			
-			// We need this in order to get the correct player
-			DataInputStream input = (DataInputStream) args[0];
-
-			// Let the people know
-			PacketContainer container = new PacketContainer(packetID, (Packet) thisObj);
-			PacketEvent event = packetInjector.packetRecieved(container, input);
-			Packet result = event.getPacket().getHandle();
-			
-			// Handle override
-			if (event != null) {
-				if (event.isCancelled()) {
-					override.put(thisObj, null);
-				} else if (!objectEquals(thisObj, result)) {
-					override.put(thisObj, result);
-				}
-			}
-		}
-		
-		return returnValue;
-	}
-	
-	private boolean objectEquals(Object a, Object b) {
-		return System.identityHashCode(a) != System.identityHashCode(b);
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/SortedPacketListenerList.java

@@ -1,66 +0,0 @@
-package com.comphenix.protocol.injector;
-
-import java.util.Collection;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import com.comphenix.protocol.concurrency.AbstractConcurrentListenerMultimap;
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-
-/**
- * Registry of synchronous packet listeners.
- * 
- * @author Kristian
- */
-class SortedPacketListenerList extends AbstractConcurrentListenerMultimap<PacketListener> {
-	
-	/**
-	 * Invokes the given packet event for every registered listener.
-	 * @param logger - the logger that will be used to inform about listener exceptions.
-	 * @param event - the packet event to invoke.
-	 */
-	public void invokePacketRecieving(Logger logger, PacketEvent event) {
-		Collection<PrioritizedListener<PacketListener>> list = getListener(event.getPacketID());
-		
-		if (list == null)
-			return;
-
-		// The returned list is thread-safe
-		for (PrioritizedListener<PacketListener> element : list) {
-			try {
-				element.getListener().onPacketReceiving(event);
-			} catch (Throwable e) {
-				// Minecraft doesn't want your Exception.
-				logger.log(Level.SEVERE, 
-						"Exception occured in onPacketReceiving() for " + 
-							PacketAdapter.getPluginName(element.getListener()), e);
-			}
-		}
-	}
-	
-	/**
-	 * Invokes the given packet event for every registered listener.
-	 * @param logger - the logger that will be used to inform about listener exceptions.
-	 * @param event - the packet event to invoke.
-	 */
-	public void invokePacketSending(Logger logger, PacketEvent event) {
-		Collection<PrioritizedListener<PacketListener>> list = getListener(event.getPacketID());
-		
-		if (list == null)
-			return;
-		
-		for (PrioritizedListener<PacketListener> element : list) {
-			try {
-				element.getListener().onPacketSending(event);
-			} catch (Throwable e) {
-				// Minecraft doesn't want your Exception.
-				logger.log(Level.SEVERE, 
-						"Exception occured in onPacketSending() for " + 
-							PacketAdapter.getPluginName(element.getListener()), e);
-			}
-		}
-	}
-	
-}

ProtocolLib/src/com/comphenix/protocol/injector/StructureCache.java

@@ -1,113 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.injector;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import net.minecraft.server.Packet;
-
-import com.comphenix.protocol.reflect.StructureModifier;
-import com.comphenix.protocol.reflect.compiler.BackgroundCompiler;
-import com.comphenix.protocol.reflect.compiler.CompileListener;
-import com.comphenix.protocol.reflect.compiler.CompiledStructureModifier;
-
-/**
- * Caches structure modifiers.
- * @author Kristian
- */
-public class StructureCache {
-	// Structure modifiers
-	private static ConcurrentMap<Integer, StructureModifier<Object>> structureModifiers = 
-			new ConcurrentHashMap<Integer, StructureModifier<Object>>();
-	
-	private static Set<Integer> compiling = new HashSet<Integer>();
-	
-	/**
-	 * Creates an empty Minecraft packet of the given ID.
-	 * @param id - packet ID.
-	 * @return Created packet.
-	 */
-	public static Packet newPacket(int id) {
-		try {
-			return (Packet) MinecraftRegistry.getPacketClassFromID(id, true).newInstance();
-		} catch (InstantiationException e) {
-			return null;
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException("Access denied.", e);
-		}
-	}
-	
-	/**
-	 * Retrieve a cached structure modifier for the given packet id.
-	 * @param id - packet ID.
-	 * @return A structure modifier.
-	 */
-	public static StructureModifier<Object> getStructure(int id) {
-		// Compile structures by default
-		return getStructure(id, true);
-	}
-	
-	/**
-	 * Retrieve a cached structure modifier for the given packet id.
-	 * @param id - packet ID.
-	 * @param compile - whether or not to asynchronously compile the structure modifier.
-	 * @return A structure modifier.
-	 */
-	public static StructureModifier<Object> getStructure(int id, boolean compile) {
-		
-		StructureModifier<Object> result = structureModifiers.get(id);
-
-		// We don't want to create this for every lookup
-		if (result == null) {
-			// Use the vanilla class definition
-			final StructureModifier<Object> value = new StructureModifier<Object>(
-					MinecraftRegistry.getPacketClassFromID(id, true), Packet.class, true);
-			
-			result = structureModifiers.putIfAbsent(id, value);
-			
-			// We may end up creating multiple modifiers, but we'll agree on which to use
-			if (result == null) {
-				result = value;
-			}
-		}
-		
-		// Automatically compile the structure modifier
-		if (compile && !(result instanceof CompiledStructureModifier)) {
-			// Compilation is many orders of magnitude slower than synchronization
-			synchronized (compiling) {
-				final int idCopy = id;
-				final BackgroundCompiler compiler = BackgroundCompiler.getInstance();
-				
-				if (!compiling.contains(id) && compiler != null) {
-					compiler.scheduleCompilation(result, new CompileListener<Object>() {
-						@Override
-						public void onCompiled(StructureModifier<Object> compiledModifier) {
-							structureModifiers.put(idCopy, compiledModifier);
-						}
-					});
-					compiling.add(id);
-				}
-			}
-		}
-		
-		return result;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/InjectedArrayList.java

@@ -1,115 +0,0 @@
-package com.comphenix.protocol.injector.player;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Set;
-
-import com.comphenix.protocol.injector.player.NetworkFieldInjector.FakePacket;
-
-import net.minecraft.server.Packet;
-import net.sf.cglib.proxy.Enhancer;
-import net.sf.cglib.proxy.MethodInterceptor;
-import net.sf.cglib.proxy.MethodProxy;
-
-/**
- * The array list that notifies when packets are sent by the server.
- * 
- * @author Kristian
- */
-class InjectedArrayList extends ArrayList<Packet> {
-
-	/**
-	 * Silly Eclipse.
-	 */
-	private static final long serialVersionUID = -1173865905404280990L;
-	
-	private PlayerInjector injector;
-	private Set<Packet> ignoredPackets;
-	private ClassLoader classLoader;
-	
-	public InjectedArrayList(ClassLoader classLoader, PlayerInjector injector, Set<Packet> ignoredPackets) {
-		this.classLoader = classLoader;
-		this.injector = injector;
-		this.ignoredPackets = ignoredPackets;
-	}
-
-	@Override
-	public boolean add(Packet packet) {
-
-		Packet result = null;
-		
-		// Check for fake packets and ignored packets
-		if (packet instanceof FakePacket) {
-			return true;
-		} else if (ignoredPackets.contains(packet)) {
-			ignoredPackets.remove(packet);
-		} else {
-			result = injector.handlePacketRecieved(packet);
-		}
-		
-		// A NULL packet indicate cancelling
-		try {
-			if (result != null) {
-				super.add(result);
-			} else {
-				// We'll use the FakePacket marker instead of preventing the filters
-				injector.sendServerPacket(createNegativePacket(packet), true);
-			}
-			
-			// Collection.add contract
-			return true;
-			
-		} catch (InvocationTargetException e) {
-			throw new RuntimeException("Reverting cancelled packet failed.", e.getTargetException());
-		}
-	}
-	
-	/**
-	 * Used by a hack that reverses the effect of a cancelled packet. Returns a packet
-	 * whereby every int method's return value is inverted (a => -a).
-	 * 
-	 * @param source - packet to invert.
-	 * @return The inverted packet.
-	 */
-	Packet createNegativePacket(Packet source) {
-		Enhancer ex = new Enhancer();
-		Class<?> type = source.getClass();
-		
-		// We want to subtract the byte amount that were added to the running
-		// total of outstanding packets. Otherwise, cancelling too many packets
-		// might cause a "disconnect.overflow" error.
-		//
-		// We do that by constructing a special packet of the same type that returns 
-		// a negative integer for all zero-parameter integer methods. This includes the
-		// size() method, which is used by the queue method to count the number of
-		// bytes to add.
-		//
-		// Essentially, we have:
-		//
-		//   public class NegativePacket extends [a packet] {
-		//      @Override
-		//      public int size() {
-		//         return -super.size();
-		//      }
-		//   ect.
-		//   }
-		ex.setInterfaces(new Class[] { FakePacket.class } );
-		ex.setUseCache(true);
-		ex.setClassLoader(classLoader);
-		ex.setSuperclass(type);
-		ex.setCallback(new MethodInterceptor() {
-			@Override
-			public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
-				if (method.getReturnType().equals(int.class) && args.length == 0) {
-					Integer result = (Integer) proxy.invokeSuper(obj, args);
-					return -result;
-				} else {
-					return proxy.invokeSuper(obj, args);
-				}
-			}
-		});
-		
-		return (Packet) ex.create();
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/InjectedServerConnection.java

@@ -1,207 +0,0 @@
-package com.comphenix.protocol.injector.player;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import net.sf.cglib.proxy.Factory;
-
-import org.bukkit.Server;
-
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.reflect.ObjectCloner;
-import com.comphenix.protocol.reflect.VolatileField;
-
-/**
- * Used to ensure that the 1.3 server is referencing the correct server handler.
- * 
- * @author Kristian
- */
-class InjectedServerConnection {
-	
-	private static Field listenerThreadField;
-	private static Field minecraftServerField;
-	private static Method serverConnectionMethod;
-	private static Field listField;
-	
-	private List<VolatileField> listFields;
-	private List<ReplacedArrayList<Object>> replacedLists;
-	
-	private Server server;
-	private Logger logger;
-	private boolean hasAttempted;
-	private boolean hasSuccess;
-	
-	private Object minecraftServer = null;
-	
-	public InjectedServerConnection(Logger logger, Server server) {
-		this.listFields = new ArrayList<VolatileField>();
-		this.replacedLists = new ArrayList<ReplacedArrayList<Object>>();
-		this.logger = logger;
-		this.server = server;
-	}
-
-	public void injectList() {
-
-		// Only execute this method once
-		if (!hasAttempted)
-			hasAttempted = true;
-		else
-			return;
-		
-		if (minecraftServerField == null)
-			minecraftServerField = FuzzyReflection.fromObject(server, true).getFieldByType(".*MinecraftServer");
-
-		try {
-			minecraftServer = FieldUtils.readField(minecraftServerField, server, true);
-		} catch (IllegalAccessException e1) {
-			logger.log(Level.WARNING, "Cannot extract minecraft server from Bukkit.");
-			return;
-		}
-		
-		try {
-			if (serverConnectionMethod == null)
-				serverConnectionMethod = FuzzyReflection.fromClass(minecraftServerField.getType()).
-											getMethodByParameters("getServerConnection", ".*ServerConnection", new String[] {});
-			// We're using Minecraft 1.3.1
-			injectServerConnection();
-		
-		} catch (RuntimeException e) {
-			
-			// Minecraft 1.2.5 or lower
-			injectListenerThread();
-		}
-	}
-	
-	private void injectListenerThread() {
-	
-		try {
-		
-		if (listenerThreadField == null)
-			listenerThreadField = FuzzyReflection.fromClass(minecraftServerField.getType()).
-				getFieldByType(".*NetworkListenThread");
-		} catch (RuntimeException e) {
-			logger.log(Level.SEVERE, "Cannot find listener thread in MinecraftServer.");
-			return;
-		}
-
-		Object listenerThread = null;
-		
-		// Attempt to get the thread
-		try {
-			listenerThread = listenerThreadField.get(minecraftServer);
-		} catch (Exception e) {
-			logger.log(Level.WARNING, "Unable to read the listener thread.");
-			return;
-		}
-		
-		// Ok, great. Get every list field
-		List<Field> lists = FuzzyReflection.fromClass(listenerThreadField.getType()).getFieldListByType(List.class);
-		
-		for (Field list : lists) {
-			injectIntoList(listenerThread, list);
-		}
-		
-		hasSuccess = true;
-	}
-	
-	private void injectServerConnection() {
-		
-		Object serverConnection = null;
-		
-		// Careful - we might fail
-		try {
-			serverConnection = serverConnectionMethod.invoke(minecraftServer);
-		} catch (Exception ex) {
-			logger.log(Level.WARNING, "Unable to retrieve server connection", ex);
-			return;
-		}
-		
-		if (listField == null)
-			listField = FuzzyReflection.fromClass(serverConnectionMethod.getReturnType(), true).
-							getFieldByType("serverConnection", List.class);
-		injectIntoList(serverConnection, listField);
-		hasSuccess = true;
-	}
-	
-	@SuppressWarnings("unchecked")
-	private void injectIntoList(Object instance, Field field) {
-		VolatileField listFieldRef = new VolatileField(listField, instance, true);
-		List<Object> list = (List<Object>) listFieldRef.getValue();
-
-		// Careful not to inject twice
-		if (list instanceof ReplacedArrayList) {
-			replacedLists.add((ReplacedArrayList<Object>) list);
-		} else {
-			replacedLists.add(createReplacement(list));
-			listFieldRef.setValue(replacedLists.get(0));
-			listFields.add(listFieldRef);
-		}
-	}
-	
-	// Hack to avoid the "moved to quickly" error
-	private ReplacedArrayList<Object> createReplacement(List<Object> list) {
-		return new ReplacedArrayList<Object>(list) {
-			@Override
-			protected void onReplacing(Object inserting, Object replacement) {
-				// Is this a normal Minecraft object?
-				if (!(inserting instanceof Factory)) {
-					// If so, copy the content of the old element to the new
-					ObjectCloner.copyTo(inserting, replacement, inserting.getClass());
-				}
-			}
-		};
-	}
-	
-	/**
-	 * Replace the server handler instance kept by the "keep alive" object.
-	 * @param oldHandler - old server handler.
-	 * @param newHandler - new, proxied server handler.
-	 */
-	public void replaceServerHandler(Object oldHandler, Object newHandler) {
-		
-		if (!hasAttempted) {
-			injectList();
-		}
-		
-		if (hasSuccess) {
-			for (ReplacedArrayList<Object> replacedList : replacedLists) {
-				replacedList.addMapping(oldHandler, newHandler);
-			}
-		}
-	}
-	
-	/**
-	 * Revert to the old vanilla server handler, if it has been replaced.
-	 * @param oldHandler - old vanilla server handler.
-	 */
-	public void revertServerHandler(Object oldHandler) {
-		if (hasSuccess) {
-			for (ReplacedArrayList<Object> replacedList : replacedLists) {
-				replacedList.removeMapping(oldHandler);
-			}
-		}
-	}
-	
-	/**
-	 * Undoes everything.
-	 */
-	public void cleanupAll() {
-		if (replacedLists.size() > 0) {
-			// Repair the underlying lists
-			for (ReplacedArrayList<Object> replacedList : replacedLists) {
-				replacedList.revertAll();
-			}
-			for (VolatileField field : listFields) {
-				field.revertValue();
-			}
-			
-			listFields.clear();
-			replacedLists.clear();
-		}
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/NetworkObjectInjector.java

@@ -1,126 +0,0 @@
-package com.comphenix.protocol.injector.player;
-
-import java.lang.reflect.InvocationTargetException;
-
-import net.minecraft.server.Packet;
-
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Proxy;
-import java.lang.reflect.Method;
-import java.util.Set;
-import java.util.logging.Logger;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.Packets;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.ListenerInvoker;
-
-/**
- * Injection method that overrides the NetworkHandler itself, and it's sendPacket-method.
- * 
- * @author Kristian
- */
-class NetworkObjectInjector extends PlayerInjector {
-	// Determine if we're listening
-	private Set<Integer> sendingFilters;
-	
-	public NetworkObjectInjector(Logger logger, Player player, ListenerInvoker invoker, Set<Integer> sendingFilters) throws IllegalAccessException {
-		super(logger, player, invoker);
-		this.sendingFilters = sendingFilters;
-	}
-
-	@Override
-	protected boolean hasListener(int packetID) {
-		return sendingFilters.contains(packetID);
-	}
-	
-	@Override
-	public void sendServerPacket(Packet packet, boolean filtered) throws InvocationTargetException {
-		Object networkDelegate = filtered ? networkManagerRef.getValue() : networkManagerRef.getOldValue();
-		
-		if (networkDelegate != null) {
-			try {
-				// Note that invocation target exception is a wrapper for a checked exception
-				queueMethod.invoke(networkDelegate, packet);
-				
-			} catch (IllegalArgumentException e) {
-				throw e;
-			} catch (InvocationTargetException e) {
-				throw e;
-			} catch (IllegalAccessException e) {
-				throw new IllegalStateException("Unable to access queue method.", e);
-			}
-		} else {
-			throw new IllegalStateException("Unable to load network mananager. Cannot send packet.");
-		}
-	}
-	
-	@Override
-	public void checkListener(PacketListener listener) {
-		// Unfortunately, we don't support chunk packets
-		if (ListeningWhitelist.containsAny(listener.getSendingWhitelist(), 
-				Packets.Server.MAP_CHUNK, Packets.Server.MAP_CHUNK_BULK)) {
-			throw new IllegalStateException("The NETWORK_FIELD_INJECTOR hook doesn't support map chunk listeners.");
-		}
-	}
-	
-	@Override
-	public void injectManager() {
-		
-		if (networkManager != null) {
-			final Class<?> networkInterface = networkManagerField.getType();
-			final Object networkDelegate = networkManagerRef.getOldValue();
-			
-			if (!networkInterface.isInterface()) {
-				throw new UnsupportedOperationException(
-						"Must use CraftBukkit 1.3.0 or later to inject into into NetworkMananger.");
-			}
-			
-			// Create our proxy object
-			Object networkProxy = Proxy.newProxyInstance(networkInterface.getClassLoader(), 
-					new Class<?>[] { networkInterface }, new InvocationHandler() {
-				
-				@Override
-				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-					// OH OH! The queue method!
-					if (method.equals(queueMethod)) {
-						Packet packet = (Packet) args[0];
-						
-						if (packet != null) {
-							packet = handlePacketRecieved(packet);
-							
-							// A NULL packet indicate cancelling
-							if (packet != null)
-								args[0] = packet;
-							else
-								return null;
-						}
-					}
-					
-					// Delegate to our underlying class
-					try {
-						return method.invoke(networkDelegate, args);
-					} catch (InvocationTargetException e) {
-						throw e.getCause();
-					}
-				}
-			});
-		
-			// Inject it, if we can.
-			networkManagerRef.setValue(networkProxy);
-		}
-	}
-	
-	@Override
-	public void cleanupAll() {
-		// Clean up
-		networkManagerRef.revertValue();
-	}
-
-	@Override
-	public boolean canInject() {
-		return true;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/NetworkServerInjector.java

@@ -1,249 +0,0 @@
-package com.comphenix.protocol.injector.player;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Set;
-import java.util.logging.Logger;
-
-import net.minecraft.server.Packet;
-import net.sf.cglib.proxy.Callback;
-import net.sf.cglib.proxy.CallbackFilter;
-import net.sf.cglib.proxy.Enhancer;
-import net.sf.cglib.proxy.Factory;
-import net.sf.cglib.proxy.MethodInterceptor;
-import net.sf.cglib.proxy.MethodProxy;
-import net.sf.cglib.proxy.NoOp;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.ListenerInvoker;
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.reflect.ObjectCloner;
-import com.comphenix.protocol.reflect.VolatileField;
-import com.comphenix.protocol.reflect.instances.DefaultInstances;
-import com.comphenix.protocol.reflect.instances.ExistingGenerator;
-
-/**
- * Represents a player hook into the NetServerHandler class. 
- * 
- * @author Kristian
- */
-public class NetworkServerInjector extends PlayerInjector {
-
-	private static Method sendPacketMethod;
-	private InjectedServerConnection serverInjection;
-	
-	// Determine if we're listening
-	private Set<Integer> sendingFilters;
-	
-	// Used to create proxy objects
-	private ClassLoader classLoader;
-	
-	public NetworkServerInjector(
-			ClassLoader classLoader, Logger logger, Player player, 
-			ListenerInvoker invoker, Set<Integer> sendingFilters, 
-			InjectedServerConnection serverInjection) throws IllegalAccessException {
-		
-		super(logger, player, invoker);
-		this.classLoader = classLoader;
-		this.sendingFilters = sendingFilters;
-		this.serverInjection = serverInjection;
-	}
-	
-	@Override
-	protected boolean hasListener(int packetID) {
-		return sendingFilters.contains(packetID);
-	}
-	
-	@Override
-	public void initialize() throws IllegalAccessException {
-		super.initialize();
-		
-		// Get the send packet method!
-		if (hasInitialized) {
-			if (sendPacketMethod == null)
-				sendPacketMethod = FuzzyReflection.fromObject(serverHandler).getMethodByName("sendPacket.*");
-		}
-	}
-
-	@Override
-	public void sendServerPacket(Packet packet, boolean filtered) throws InvocationTargetException {
-		Object serverDeleage = filtered ? serverHandlerRef.getValue() : serverHandlerRef.getOldValue();
-		
-		if (serverDeleage != null) {
-			try {
-				// Note that invocation target exception is a wrapper for a checked exception
-				sendPacketMethod.invoke(serverDeleage, packet);
-				
-			} catch (IllegalArgumentException e) {
-				throw e;
-			} catch (InvocationTargetException e) {
-				throw e;
-			} catch (IllegalAccessException e) {
-				throw new IllegalStateException("Unable to access send packet method.", e);
-			}
-		} else {
-			throw new IllegalStateException("Unable to load server handler. Cannot send packet.");
-		}
-	}
-
-	@Override
-	public void injectManager() {
-		
-		if (serverHandlerRef == null)
-			throw new IllegalStateException("Cannot find server handler.");
-		// Don't inject twice
-		if (serverHandlerRef.getValue() instanceof Factory)
-			return;
-		
-		if (!tryInjectManager()) {
-			
-			// Try to override the proxied object
-			if (proxyServerField != null) {
-				serverHandlerRef = new VolatileField(proxyServerField, serverHandler, true);
-				serverHandler = serverHandlerRef.getValue();
-				
-				if (serverHandler == null)
-					throw new RuntimeException("Cannot hook player: Inner proxy object is NULL.");
-				
-				// Try again
-				if (tryInjectManager()) {
-					// It worked - probably
-					return;
-				}
-			}
-			
-			throw new RuntimeException(
-					"Cannot hook player: Unable to find a valid constructor for the NetServerHandler object.");
-		}
-	}
-	
-	private boolean tryInjectManager() {
-		Class<?> serverClass = serverHandler.getClass();
-		
-		Enhancer ex = new Enhancer();
-		Callback sendPacketCallback = new MethodInterceptor() {
-			@Override
-			public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
-
-				Packet packet = (Packet) args[0];
-				
-				if (packet != null) {
-					packet = handlePacketRecieved(packet);
-					
-					// A NULL packet indicate cancelling
-					if (packet != null)
-						args[0] = packet;
-					else
-						return null;
-				}
-				
-				// Call the method directly
-				return proxy.invokeSuper(obj, args);
-			};
-		};
-		Callback noOpCallback = NoOp.INSTANCE;
-
-		ex.setClassLoader(classLoader);
-		ex.setSuperclass(serverClass);
-		ex.setCallbacks(new Callback[] { sendPacketCallback, noOpCallback });
-		ex.setCallbackFilter(new CallbackFilter() {
-			@Override
-			public int accept(Method method) {
-				if (method.equals(sendPacketMethod))
-					return 0;
-				else
-					return 1;
-			}
-		});
-		
-		// Find the Minecraft NetServerHandler superclass
-		Class<?> minecraftSuperClass = getFirstMinecraftSuperClass(serverHandler.getClass());
-		ExistingGenerator generator = ExistingGenerator.fromObjectFields(serverHandler, minecraftSuperClass);
-		DefaultInstances serverInstances = null;
-		
-		// Maybe the proxy instance can help?
-		Object proxyInstance = getProxyServerHandler();
-		
-		// Use the existing server proxy when we create one
-		if (proxyInstance != null && proxyInstance != serverHandler) {
-			serverInstances = DefaultInstances.fromArray(generator, 
-					ExistingGenerator.fromObjectArray(new Object[] { proxyInstance }));
-		} else {
-			serverInstances = DefaultInstances.fromArray(generator);
-		}
-		
-		serverInstances.setNonNull(true);
-		serverInstances.setMaximumRecursion(1);
-		
-		Object proxyObject = serverInstances.forEnhancer(ex).getDefault(serverClass);
-		
-		// Inject it now
-		if (proxyObject != null) {
-			// This will be done by InjectedServerConnection instead
-			//copyTo(serverHandler, proxyObject);
-			serverInjection.replaceServerHandler(serverHandler, proxyObject);
-			serverHandlerRef.setValue(proxyObject);
-			return true;
-		} else {
-			return false;
-		}
-	}
-	
-	private Object getProxyServerHandler() {
-		if (proxyServerField != null && !proxyServerField.equals(serverHandlerRef.getField())) {
-			try {
-				return FieldUtils.readField(proxyServerField, serverHandler, true);
-			} catch (Throwable e) {
-				// Oh well
-			}
-		}
-		
-		return null;
-	}
-	
-	private Class<?> getFirstMinecraftSuperClass(Class<?> clazz) {
-		if (clazz.getName().startsWith("net.minecraft.server."))
-			return clazz;
-		else if (clazz.equals(Object.class))
-			return clazz;
-		else
-			return getFirstMinecraftSuperClass(clazz.getSuperclass());
-	}
-		
-	@Override
-	public void cleanupAll() {
-		if (serverHandlerRef != null && serverHandlerRef.isCurrentSet()) {
-			ObjectCloner.copyTo(serverHandlerRef.getValue(), serverHandlerRef.getOldValue(), serverHandler.getClass());
-			serverHandlerRef.revertValue();
-			
-			try {
-				if (getNetHandler() != null) {
-					// Restore packet listener
-					try {
-						FieldUtils.writeField(netHandlerField, networkManager, serverHandlerRef.getOldValue(), true);
-					} catch (IllegalAccessException e) {
-						// Oh well
-						e.printStackTrace();
-					}
-				}
-			} catch (IllegalAccessException e) {
-				e.printStackTrace();
-			}
-		}
-
-		serverInjection.revertServerHandler(serverHandler);
-	}
-	
-	@Override
-	public void checkListener(PacketListener listener) {
-		// We support everything
-	}
-
-	@Override
-	public boolean canInject() {
-		return true;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/PlayerInjectionHandler.java

@@ -1,311 +0,0 @@
-package com.comphenix.protocol.injector.player;
-
-import java.io.DataInputStream;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import net.minecraft.server.Packet;
-
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.ListenerInvoker;
-import com.comphenix.protocol.injector.PlayerLoggedOutException;
-import com.comphenix.protocol.injector.PacketFilterManager.PlayerInjectHooks;
-import com.google.common.collect.ImmutableSet;
-
-/**
- * Responsible for injecting into a player's sendPacket method.
- * 
- * @author Kristian
- */
-public class PlayerInjectionHandler {
-
-	// Server connection injection
-	private InjectedServerConnection serverInjection;
-	
-	// The last successful player hook
-	private PlayerInjector lastSuccessfulHook;
-	
-	// Player injection
-	private Map<DataInputStream, Player> connectionLookup = new ConcurrentHashMap<DataInputStream, Player>();
-	private Map<Player, PlayerInjector> playerInjection = new HashMap<Player, PlayerInjector>();
-	
-	// Player injection type
-	private PlayerInjectHooks playerHook = PlayerInjectHooks.NETWORK_SERVER_OBJECT;
-	
-	// Error logger
-	private Logger logger;
-	
-	// Whether or not we're closing
-	private boolean hasClosed;
-
-	// Used to invoke events
-	private ListenerInvoker invoker;
-	
-	// Enabled packet filters
-	private Set<Integer> sendingFilters = Collections.newSetFromMap(new ConcurrentHashMap<Integer, Boolean>());
-	
-	// The class loader we're using
-	private ClassLoader classLoader;
-	
-	public PlayerInjectionHandler(ClassLoader classLoader, Logger logger, ListenerInvoker invoker, Server server) {
-		this.classLoader = classLoader;
-		this.logger = logger;
-		this.invoker = invoker;
-		this.serverInjection = new InjectedServerConnection(logger, server);
-	}
-
-	/**
-	 * Retrieves how the server packets are read.
-	 * @return Injection method for reading server packets.
-	 */
-	public PlayerInjectHooks getPlayerHook() {
-		return playerHook;
-	}
-
-	/**
-	 * Add an underlying packet handler of the given ID.
-	 * @param packetID - packet ID to register.
-	 */
-	public void addPacketHandler(int packetID) {
-		sendingFilters.add(packetID);
-	}
-	
-	/**
-	 * Remove an underlying packet handler of ths ID.  
-	 * @param packetID - packet ID to unregister.
-	 */
-	public void removePacketHandler(int packetID) {
-		sendingFilters.remove(packetID);
-	}
-	
-	/**
-	 * Sets how the server packets are read.
-	 * @param playerHook - the new injection method for reading server packets.
-	 */
-	public void setPlayerHook(PlayerInjectHooks playerHook) {
-		this.playerHook = playerHook;
-	}
-	
-	/**
-	 * Used to construct a player hook.
-	 * @param player - the player to hook.
-	 * @param hook - the hook type.
-	 * @return A new player hoook
-	 * @throws IllegalAccessException Unable to do our reflection magic.
-	 */
-	private PlayerInjector getHookInstance(Player player, PlayerInjectHooks hook) throws IllegalAccessException {
-		// Construct the correct player hook
-		switch (hook) {
-		case NETWORK_HANDLER_FIELDS: 
-			return new NetworkFieldInjector(classLoader, logger, player, invoker, sendingFilters);
-		case NETWORK_MANAGER_OBJECT: 
-			return new NetworkObjectInjector(logger, player, invoker, sendingFilters);
-		case NETWORK_SERVER_OBJECT:
-			return new NetworkServerInjector(classLoader, logger, player, invoker, sendingFilters, serverInjection);
-		default:
-			throw new IllegalArgumentException("Cannot construct a player injector.");
-		}
-	}
-	
-	public Player getPlayerByConnection(DataInputStream inputStream) {
-		return connectionLookup.get(inputStream);
-	}
-	
-	/**
-	 * Initialize a player hook, allowing us to read server packets.
-	 * @param manager - the main packet filter manager.
-	 * @param player - player to hook.
-	 */
-	public void injectPlayer(Player player) {
-		
-		PlayerInjector injector = null;
-		PlayerInjectHooks currentHook = playerHook;
-		boolean firstPlayer = lastSuccessfulHook == null;
-		
-		// Don't inject if the class has closed
-		if (!hasClosed && player != null && !playerInjection.containsKey(player)) {
-			while (true) {
-				try {
-					injector = getHookInstance(player, currentHook);
-					injector.initialize();
-					injector.injectManager();
-					
-					DataInputStream inputStream = injector.getInputStream(false);
-					
-					if (!player.isOnline() || inputStream == null) {
-						throw new PlayerLoggedOutException();
-					}
-					
-					playerInjection.put(player, injector);
-					connectionLookup.put(inputStream, player);
-					break;
-					
-					
-				} catch (PlayerLoggedOutException e) {
-					throw e;
-					
-				} catch (Exception e) {
-
-					// Mark this injection attempt as a failure
-					logger.log(Level.SEVERE, "Player hook " + currentHook.toString() + " failed.", e);
-					
-					// Clean up as much as possible
-					try {
-						if (injector != null)
-							injector.cleanupAll();
-					} catch (Exception e2) {
-						logger.log(Level.WARNING, "Cleaing up after player hook failed.", e);
-					}
-					
-					if (currentHook.ordinal() > 0) {
-
-						// Choose the previous player hook type
-						currentHook = PlayerInjectHooks.values()[currentHook.ordinal() - 1];
-						logger.log(Level.INFO, "Switching to " + currentHook.toString() + " instead.");
-					} else {
-						// UTTER FAILURE
-						playerInjection.put(player, null);
-						return;
-					}
-				}
-			}
-			
-			// Update values
-			if (injector != null)
-				lastSuccessfulHook = injector;
-			if (currentHook != playerHook || firstPlayer) 
-				setPlayerHook(currentHook);
-		}
-	}
-	
-	/**
-	 * Unregisters the given player.
-	 * @param player - player to unregister.
-	 */
-	public void uninjectPlayer(Player player) {
-		if (!hasClosed && player != null) {
-			
-			PlayerInjector injector = playerInjection.get(player);
-			
-			if (injector != null) {
-				DataInputStream input = injector.getInputStream(true);
-				injector.cleanupAll();
-				
-				playerInjection.remove(player);
-				connectionLookup.remove(input);
-			}
-		}	
-	}
-	
-	public void sendServerPacket(Player reciever, PacketContainer packet, boolean filters) throws InvocationTargetException {
-		getInjector(reciever).sendServerPacket(packet.getHandle(), filters);
-	}
-	
-	private PlayerInjector getInjector(Player player) {
-		if (!playerInjection.containsKey(player)) {
-			// What? Try to inject again.
-			injectPlayer(player);
-		}
-		
-		PlayerInjector injector = playerInjection.get(player);
-		
-		// Check that the injector was sucessfully added
-		if (injector != null)
-			return injector;
-		else
-			throw new IllegalArgumentException("Player has no injected handler.");
-	}
-	
-	/**
-	 * Determine if the given listeners are valid.
-	 * @param listeners - listeners to check.
-	 */
-	public void checkListener(Set<PacketListener> listeners) {
-		// Make sure the current listeners are compatible
-		if (lastSuccessfulHook != null) {
-			for (PacketListener listener : listeners) {
-				try {
-					checkListener(listener);
-				} catch (IllegalStateException e) {
-					logger.log(Level.WARNING, "Unsupported listener.", e);
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Determine if a listener is valid or not.
-	 * @param listener - listener to check.
-	 * @throws IllegalStateException If the given listener's whitelist cannot be fulfilled.
-	 */
-	public void checkListener(PacketListener listener) {
-		try {
-			if (lastSuccessfulHook != null)
-				lastSuccessfulHook.checkListener(listener);
-		} catch (Exception e) {
-			throw new IllegalStateException("Registering listener " + PacketAdapter.getPluginName(listener) + " failed", e);
-		}
-	}
-
-	/**
-	 * Process a packet as if it were sent by the given player.
-	 * @param player - the sender.
-	 * @param mcPacket - the packet to process.
-	 * @throws IllegalAccessException If the reflection machinery failed.
-	 * @throws InvocationTargetException If the underlying method caused an error.
-	 */
-	public void processPacket(Player player, Packet mcPacket) throws IllegalAccessException, InvocationTargetException {
-		
-		PlayerInjector injector = getInjector(player);
-		injector.processPacket(mcPacket);
-	}
-	
-	/**
-	 * Retrieve the current list of registered sending listeners.
-	 * @return List of the sending listeners's packet IDs.
-	 */
-	public Set<Integer> getSendingFilters() {
-		return ImmutableSet.copyOf(sendingFilters);
-	}
-	
-	/**
-	 * Retrieve the current logger.
-	 * @return Error logger.
-	 */
-	public Logger getLogger() {
-		return logger;
-	}
-
-	public void close() {
-		
-		// Guard
-		if (hasClosed || playerInjection == null)
-			return;
-
-		// Remove everything
-		for (PlayerInjector injection : playerInjection.values()) {
-			if (injection != null) {
-				injection.cleanupAll();
-			}
-		}
-		
-		// Remove server handler
-		serverInjection.cleanupAll();
-		hasClosed = true;
-		
-		playerInjection.clear();
-		connectionLookup.clear();
-		invoker = null;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/PlayerInjector.java

@@ -1,340 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.injector.player;
-
-import java.io.DataInputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import net.minecraft.server.EntityPlayer;
-import net.minecraft.server.Packet;
-import net.sf.cglib.proxy.Factory;
-
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.ListenerInvoker;
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.reflect.StructureModifier;
-import com.comphenix.protocol.reflect.VolatileField;
-
-abstract class PlayerInjector {
-	
-	// Cache previously retrieved fields
-	protected static Field serverHandlerField;
-	protected static Field proxyServerField;
-	
-	protected static Field networkManagerField;
-	protected static Field inputField;
-	protected static Field netHandlerField;
-	
-	// Whether or not we're using a proxy type
-	private static boolean hasProxyType;
-	
-	// To add our injected array lists
-	protected static StructureModifier<Object> networkModifier;
-	
-	// And methods
-	protected static Method queueMethod;
-	protected static Method processMethod;
-		
-	protected Player player;
-	protected boolean hasInitialized;
-	
-	// Reference to the player's network manager
-	protected VolatileField networkManagerRef;
-	protected VolatileField serverHandlerRef;
-	protected Object networkManager;
-	
-	// Current net handler
-	protected Object serverHandler;
-	protected Object netHandler;
-	
-	// The packet manager and filters
-	protected ListenerInvoker invoker;
-	
-	// Previous data input
-	protected DataInputStream cachedInput;
-	
-	// Handle errors
-	protected Logger logger;
-
-	public PlayerInjector(Logger logger, Player player, ListenerInvoker invoker) throws IllegalAccessException {
-		this.logger = logger;
-		this.player = player;
-		this.invoker = invoker;
-	}
-
-	/**
-	 * Retrieve the notch (NMS) entity player object.
-	 * @return Notch player object.
-	 */
-	protected EntityPlayer getEntityPlayer() {
-		CraftPlayer craft = (CraftPlayer) player;
-		return craft.getHandle();
-	}
-	
-	/**
-	 * Initialize all fields for this player injector, if it hasn't already.
-	 * @throws IllegalAccessException An error has occured.
-	 */
-	public void initialize() throws IllegalAccessException {
-	
-		EntityPlayer notchEntity = getEntityPlayer();
-		
-		if (!hasInitialized) {
-			// Do this first, in case we encounter an exception
-			hasInitialized = true;
-			
-			// Retrieve the server handler
-			if (serverHandlerField == null) {
-				serverHandlerField = FuzzyReflection.fromObject(notchEntity).getFieldByType(".*NetServerHandler");
-				proxyServerField = getProxyField(notchEntity, serverHandlerField);
-			}
-			
-			// Yo dawg
-			serverHandlerRef = new VolatileField(serverHandlerField, notchEntity);
-			serverHandler = serverHandlerRef.getValue();
-
-			// Next, get the network manager 
-			if (networkManagerField == null) 
-				networkManagerField = FuzzyReflection.fromObject(serverHandler).getFieldByType(".*NetworkManager");
-			networkManagerRef = new VolatileField(networkManagerField, serverHandler);
-			networkManager = networkManagerRef.getValue();
-
-			// Create the network manager modifier from the actual object type
-			if (networkManager != null && networkModifier == null)
-				networkModifier = new StructureModifier<Object>(networkManager.getClass(), null, false);
-			
-			// And the queue method
-			if (queueMethod == null)
-				queueMethod = FuzzyReflection.fromClass(networkManagerField.getType()).
-								getMethodByParameters("queue", Packet.class );
-			
-			// And the data input stream that we'll use to identify a player
-			if (inputField == null)
-				inputField = FuzzyReflection.fromObject(networkManager, true).
-								getFieldByType("java\\.io\\.DataInputStream");
-		}
-	}
-	
-	/**
-	 * Retrieve whether or not the server handler is a proxy object.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	protected boolean hasProxyServerHandler() {
-		return hasProxyType;
-	}
-	
-	private Field getProxyField(EntityPlayer notchEntity, Field serverField) {
-
-		try {
-			Object handler = FieldUtils.readField(serverHandlerField, notchEntity, true);
-			
-			// Is this a Minecraft hook?
-			if (handler != null && !handler.getClass().getName().startsWith("net.minecraft.server")) {
-				
-				// This is our proxy object
-				if (handler instanceof Factory)
-					return null;
-				
-				hasProxyType = true;
-				logger.log(Level.WARNING, "Detected server handler proxy type by another plugin. Conflict may occur!");
-				
-				// No? Is it a Proxy type?
-				try {
-					FuzzyReflection reflection = FuzzyReflection.fromObject(handler, true);
-					
-					// It might be
-					return reflection.getFieldByType(".*NetServerHandler");
-					
-				} catch (RuntimeException e) {
-					// Damn
-				}
-			}
-			
-		} catch (IllegalAccessException e) {
-			logger.warning("Unable to load server handler from proxy type.");
-		}
-
-		// Nope, just go with it
-		return null;
-	}
-	
-	/**
-	 * Retrieves the current net handler for this player.
-	 * @return Current net handler.
-	 * @throws IllegalAccessException Unable to find or retrieve net handler.
-	 */
-	protected Object getNetHandler() throws IllegalAccessException {
-		
-		// What a mess
-		try {
-			if (netHandlerField == null)
-				netHandlerField = FuzzyReflection.fromClass(networkManager.getClass(), true).
-									getFieldByType("net\\.minecraft\\.NetHandler");
-		} catch (RuntimeException e1) {
-			// Swallow it
-		}
-		
-		// Second attempt
-		if (netHandlerField == null) {
-			try {
-				// Well, that sucks. Try just Minecraft objects then.
-				netHandlerField = FuzzyReflection.fromClass(networkManager.getClass(), true).
-									 getFieldByType(FuzzyReflection.MINECRAFT_OBJECT);
-				
-			} catch (RuntimeException e2) {
-				throw new IllegalAccessException("Cannot locate net handler. " + e2.getMessage());
-			}
-		}
-		
-		// Get the handler
-		if (netHandler == null)
-			netHandler = FieldUtils.readField(netHandlerField, networkManager, true);
-		return netHandler;
-	}
-	
-	/**
-	 * Processes the given packet as if it was transmitted by the current player.
-	 * @param packet - packet to process.
-	 * @throws IllegalAccessException If the reflection machinery failed.
-	 * @throws InvocationTargetException If the underlying method caused an error.
-	 */
-	public void processPacket(Packet packet) throws IllegalAccessException, InvocationTargetException {
-		
-		Object netHandler = getNetHandler();
-		
-		// Get the process method
-		if (processMethod == null) {
-			try {
-				processMethod = FuzzyReflection.fromClass(Packet.class).
-						getMethodByParameters("processPacket", netHandlerField.getType());
-			} catch (RuntimeException e) {
-				throw new IllegalArgumentException("Cannot locate process packet method: " + e.getMessage());
-			}
-		}
-	
-		// We're ready
-		try {
-			processMethod.invoke(packet, netHandler);
-		} catch (IllegalArgumentException e) {
-			throw new IllegalArgumentException("Method " + processMethod.getName() + " is not compatible.");
-		} catch (InvocationTargetException e) {
-			throw e;
-		}
-	}
-	
-	/**
-	 * Send a packet to the client.
-	 * @param packet - server packet to send.
-	 * @param filtered - whether or not the packet will be filtered by our listeners.
-	 * @param InvocationTargetException If an error occured when sending the packet.
-	 */
-	public abstract void sendServerPacket(Packet packet, boolean filtered) throws InvocationTargetException;
-	
-	/**
-	 * Inject a hook to catch packets sent to the current player.
-	 */
-	public abstract void injectManager();
-	
-	/**
-	 * Remove all hooks and modifications.
-	 */
-	public abstract void cleanupAll();
-	
-	/**
-	 * Determine if this inject method can even be attempted.
-	 * @return TRUE if can be attempted, though possibly with failure, FALSE otherwise.
-	 */
-	public abstract boolean canInject();
-	
-	/**
-	 * Invoked before a new listener is registered.
-	 * <p>
-	 * The player injector should throw an exception if this listener cannot be properly supplied with packet events. 
-	 * @param listener - the listener that is about to be registered.
-	 */
-	public abstract void checkListener(PacketListener listener);
-	
-	/**
-	 * Allows a packet to be recieved by the listeners.
-	 * @param packet - packet to recieve.
-	 * @return The given packet, or the packet replaced by the listeners.
-	 */
-	public Packet handlePacketRecieved(Packet packet) {
-		// Get the packet ID too
-		Integer id = invoker.getPacketID(packet);
-
-		// Make sure we're listening
-		if (id != null && hasListener(id)) {
-			// A packet has been sent guys!
-			PacketContainer container = new PacketContainer(id, packet);
-			PacketEvent event = PacketEvent.fromServer(invoker, container, player);
-			invoker.invokePacketSending(event);
-			
-			// Cancelling is pretty simple. Just ignore the packet.
-			if (event.isCancelled())
-				return null;
-			
-			// Right, remember to replace the packet again
-			return event.getPacket().getHandle();
-		}
-		
-		return packet;
-	}
-	
-	/**
-	 * Determine if the given injector is listening for this packet ID.
-	 * @param packetID - packet ID to check.
-	 * @return TRUE if it is, FALSE oterhwise.
-	 */
-	protected abstract boolean hasListener(int packetID);
-	
-	/**
-	 * Retrieve the current player's input stream.
-	 * @param cache - whether or not to cache the result of this method.
-	 * @return The player's input stream.
-	 */
-	public DataInputStream getInputStream(boolean cache) {
-		if (inputField == null)
-			throw new IllegalStateException("Input field is NULL.");
-		if (networkManager == null)
-				throw new IllegalStateException("Network manager is NULL.");
-		
-		// Get the associated input stream
-		try {
-			if (cache && cachedInput != null)
-				return cachedInput;
-			
-			// Save to cache
-			cachedInput = (DataInputStream) FieldUtils.readField(inputField, networkManager, true);
-			return cachedInput;
-			
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException("Unable to read input stream.", e);
-		}
-	}
-}

ProtocolLib/src/com/comphenix/protocol/injector/player/ReplacedArrayList.java

@@ -1,153 +0,0 @@
-package com.comphenix.protocol.injector.player;
-
-import java.util.Collection;
-import java.util.List;
-
-import com.google.common.base.Objects;
-import com.google.common.collect.BiMap;
-import com.google.common.collect.ForwardingList;
-import com.google.common.collect.HashBiMap;
-
-/**
- * Represents an array list that wraps another list, while automatically replacing one element with another.
- * <p>
- * The replaced elements can be recovered. 
- * 
- * @author Kristian
- * @param <TKey> - type of the elements we're replacing.
- */
-class ReplacedArrayList<TKey> extends ForwardingList<TKey> {
-	private BiMap<TKey, TKey> replaceMap = HashBiMap.create();
-	private List<TKey> underlyingList;
-	
-	public ReplacedArrayList(List<TKey> underlyingList) {
-		this.underlyingList = underlyingList;
-	}
-	
-	/**
-	 * Invoked when a element inserted is replaced.
-	 * @param inserting - the element inserted.
-	 * @param replacement - the element that it should replace.
-	 */
-	protected void onReplacing(TKey inserting, TKey replacement) {
-		// Default is to do nothing.
-	}
-	
-	@Override
-	public boolean add(TKey element) {
-		if (replaceMap.containsKey(element)) {
-			TKey replacement = replaceMap.get(element);
-			onReplacing(element, replacement);
-			return super.add(replacement);
-		} else {
-			return super.add(element);
-		}
-	}
-	
-	@Override
-	public void add(int index, TKey element) {
-		if (replaceMap.containsKey(element)) {
-			TKey replacement = replaceMap.get(element);
-			onReplacing(element, replacement);
-			super.add(index, replacement);
-		} else {
-			super.add(index, element);
-		}
-	}
-	
-	@Override
-	public boolean addAll(Collection<? extends TKey> collection) {
-		int oldSize = size();
-		
-		for (TKey element : collection)
-			add(element);
-		return size() != oldSize;
-	}
-	
-	@Override
-	public boolean addAll(int index, Collection<? extends TKey> elements) {
-		int oldSize = size();
-		
-		for (TKey element : elements)
-			add(index++, element);
-		return size() != oldSize;
-	}
-	
-	@Override
-	protected List<TKey> delegate() {
-		return underlyingList;
-	}
-
-	/**
-	 * Add a replace rule.
-	 * <p>
-	 * This automatically replaces every existing element.
-	 * @param target - instance to find.
-	 * @param replacement - instance to replace with.
-	 */
-	public synchronized void addMapping(TKey target, TKey replacement) {
-		replaceMap.put(target, replacement);
-
-		// Replace existing elements
-		replaceAll(target, replacement);
-	}
-	
-	/**
-	 * Revert the given mapping.
-	 * @param target - the instance we replaced.
-	 */
-	public synchronized void removeMapping(TKey target) {
-		// Make sure the mapping exist
-		if (replaceMap.containsKey(target)) {
-			TKey replacement = replaceMap.get(target);
-			replaceMap.remove(target);
-	
-			// Revert existing elements
-			replaceAll(replacement, target);
-		}
-	}
-	
-	/**
-	 * Replace all instances of the given object.
-	 * @param find - object to find.
-	 * @param replace - object to replace it with.
-	 */
-	public synchronized void replaceAll(TKey find, TKey replace) {
-		for (int i = 0; i < underlyingList.size(); i++) {
-			if (Objects.equal(underlyingList.get(i), find)) {
-				onReplacing(find, replace);
-				underlyingList.set(i, replace);
-			}
-		}
-	}
-	
-	/**
-	 * Undo all replacements.
-	 */
-	public synchronized void revertAll() {
-		
-		// No need to do anything else
-		if (replaceMap.size() < 1)
-			return;
-		
-		BiMap<TKey, TKey> inverse = replaceMap.inverse();
-		
-		for (int i = 0; i < underlyingList.size(); i++) {
-			TKey replaced = underlyingList.get(i);
-			
-			if (inverse.containsKey(replaced)) {
-				TKey original = inverse.get(replaced);
-				onReplacing(replaced, original);
-				underlyingList.set(i, original);
-			}
-		}
-		
-		replaceMap.clear();
-	}
-	
-	@Override
-	protected void finalize() throws Throwable {
-		revertAll();
-		super.finalize();
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/FuzzyReflection.java

@@ -1,390 +0,0 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.reflect;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.regex.Pattern;
-
-/**
- * Retrieves fields and methods by signature, not just name.
- * 
- * @author Kristian
- */
-public class FuzzyReflection {
-
-	/**
-	 * Matches a Minecraft object.
-	 */
-	public static String MINECRAFT_OBJECT = "net\\.minecraft(\\.\\w+)+";
-	
-	// The class we're actually representing
-	private Class<?> source;
-
-	// Whether or not to lookup private members
-	private boolean forceAccess;
-
-	public FuzzyReflection(Class<?> source, boolean forceAccess) {
-		this.source = source;
-		this.forceAccess = forceAccess;
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from a given class.
-	 * @param source - the class we'll use.
-	 * @return A fuzzy reflection instance.
-	 */
-	public static FuzzyReflection fromClass(Class<?> source) {
-		return fromClass(source, false);
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from a given class.
-	 * @param source - the class we'll use.
-	 * @param forceAccess - whether or not to override scope restrictions.
-	 * @return A fuzzy reflection instance.
-	 */
-	public static FuzzyReflection fromClass(Class<?> source, boolean forceAccess) {
-		return new FuzzyReflection(source, forceAccess);
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from an object.
-	 * @param reference - the object we'll use.
-	 * @return A fuzzy reflection instance that uses the class of the given object.
-	 */
-	public static FuzzyReflection fromObject(Object reference) {
-		return new FuzzyReflection(reference.getClass(), false);
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from an object.
-	 * @param reference - the object we'll use.
-	 * @param forceAccess - whether or not to override scope restrictions.
-	 * @return A fuzzy reflection instance that uses the class of the given object.
-	 */
-	public static FuzzyReflection fromObject(Object reference, boolean forceAccess) {
-		return new FuzzyReflection(reference.getClass(), forceAccess);
-	}
-	
-	/**
-	 * Retrieves the underlying class.
-	 */
-	public Class<?> getSource() {
-		return source;
-	}
-	
-	/**
-	 * Retrieves a method by looking at its name.
-	 * @param nameRegex -  regular expression that will match method names.
-	 * @return The first method that satisfies the regular expression.
-	 * @throws RuntimeException If the method cannot be found.
-	 */
-	public Method getMethodByName(String nameRegex) {
-		
-		Pattern match = Pattern.compile(nameRegex);
-		
-		for (Method method : getMethods()) {
-			if (match.matcher(method.getName()).matches()) {
-				// Right - this is probably it. 
-				return method;
-			}
-		}
-
-		throw new RuntimeException("Unable to find a method with the pattern " + 
-									nameRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves a method by looking at the parameter types only.
-	 * @param name - potential name of the method. Only used by the error mechanism.
-	 * @param args - parameter types of the method to find.
-	 * @return The first method that satisfies the parameter types.
-	 */
-	public Method getMethodByParameters(String name, Class<?>... args) {
-		
-		// Find the correct method to call
-		for (Method method : getMethods()) {
-			if (Arrays.equals(method.getParameterTypes(), args)) {
-				return method;
-			}
-		}
-		
-		// That sucks
-		throw new RuntimeException("Unable to find " + name + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves a method by looking at the parameter types and return type only.
-	 * @param name - potential name of the method. Only used by the error mechanism.
-	 * @param returnType - return type of the method to find.
-	 * @param args - parameter types of the method to find.
-	 * @return The first method that satisfies the parameter types.
-	 */
-	public Method getMethodByParameters(String name, Class<?> returnType, Class<?>[] args) {
-		// Find the correct method to call
-		List<Method> methods = getMethodListByParameters(returnType, args);
-		
-		if (methods.size() > 0) {
-			return methods.get(0);
-		} else {
-			// That sucks
-			throw new RuntimeException("Unable to find " + name + " in " + source.getName());
-		}
-	}
-	
-	/**
-	 * Retrieves a method by looking at the parameter types and return type only.
-	 * @param name - potential name of the method. Only used by the error mechanism.
-	 * @param returnType - regular expression matching the return type of the method to find.
-	 * @param args - regular expressions of the matching parameter types.
-	 * @return The first method that satisfies the parameter types.
-	 */
-	public Method getMethodByParameters(String name, String returnTypeRegex, String[] argsRegex) {
-	
-		Pattern match = Pattern.compile(returnTypeRegex);
-		Pattern[] argMatch = new Pattern[argsRegex.length];
-		
-		for (int i = 0; i < argsRegex.length; i++) {
-			argMatch[i] = Pattern.compile(argsRegex[i]);
-		}
-		
-		// Find the correct method to call
-		for (Method method : getMethods()) {
-			if (match.matcher(method.getReturnType().getName()).matches()) {
-				if (matchParameters(argMatch, method.getParameterTypes()))
-					return method;
-			}
-		}
-		
-		// That sucks
-		throw new RuntimeException("Unable to find " + name + " in " + source.getName());
-	}
-	
-	private boolean matchParameters(Pattern[] parameterMatchers, Class<?>[] argTypes) {
-		if (parameterMatchers.length != argTypes.length)
-			throw new IllegalArgumentException("Arrays must have the same cardinality.");
-		
-		// Check types against the regular expressions
-		for (int i = 0; i < argTypes.length; i++) {
-			if (!parameterMatchers[i].matcher(argTypes[i].getName()).matches())
-				return false;
-		}
-		
-		return true;
-	}
-	
-	/**
-	 * Retrieves every method that has the given parameter types and return type.
-	 * @param returnType - return type of the method to find.
-	 * @param args - parameter types of the method to find.
-	 * @return Every method that satisfies the given constraints.
-	 */
-	public List<Method> getMethodListByParameters(Class<?> returnType, Class<?>[] args) {
-	
-		List<Method> methods = new ArrayList<Method>();
-		
-		// Find the correct method to call
-		for (Method method : getMethods()) {
-			if (method.getReturnType().equals(returnType) && Arrays.equals(method.getParameterTypes(), args)) {
-				methods.add(method);
-			}
-		}
-		
-		return methods;
-	}
-	
-	/**
-	 * Retrieves a field by name.
-	 * @param nameRegex - regular expression that will match a field name.
-	 * @return The first field to match the given expression.
-	 */
-	public Field getFieldByName(String nameRegex) {
-		
-		Pattern match = Pattern.compile(nameRegex);
-		
-		for (Field field : getFields()) {
-			if (match.matcher(field.getName()).matches()) {
-				// Right - this is probably it. 
-				return field;
-			}
-		}
-		
-		// Looks like we're outdated. Too bad.
-		throw new RuntimeException("Unable to find a field with the pattern " + 
-									nameRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves the first field with a type equal to or more specific to the given type.
-	 * @param name - name the field probably is given. This will only be used in the error message.
-	 * @param type - type of the field to find.
-	 * @return The first field with a type that is an instance of the given type.
-	 */
-	public Field getFieldByType(String name, Class<?> type) {
-		
-		List<Field> fields = getFieldListByType(type);
-		
-		if (fields.size() > 0) {
-			return fields.get(0);
-		} else {
-			// Looks like we're outdated. Too bad.
-			throw new RuntimeException(String.format("Unable to find a field %s with the type %s in %s",
-					name, type.getName(), source.getName())
-			);
-		}
-	}
-	
-	/**
-	 * Retrieves every field with a type equal to or more specific to the given type.
-	 * @param type - type of the fields to find.
-	 * @return Every field with a type that is an instance of the given type.
-	 */
-	public List<Field> getFieldListByType(Class<?> type) {
-		
-		List<Field> fields = new ArrayList<Field>();
-		
-		// Field with a compatible type
-		for (Field field : getFields()) {
-			// A assignable from B -> B instanceOf A
-			if (type.isAssignableFrom(field.getType())) {
-				fields.add(field);
-			}
-		}
-		
-		return fields;
-	}
-	
-	/**
-	 * Retrieves a field by type.
-	 * <p>
-	 * Note that the type is matched using the full canonical representation, i.e.: 
-	 * <ul>
-	 *     <li>java.util.List</li>
-	 *     <li>net.comphenix.xp.ExperienceMod</li>
-	 * </ul>
-	 * @param typeRegex - regular expression that will match the field type.
-	 * @return The first field with a type that matches the given regular expression.
-	 */
-	public Field getFieldByType(String typeRegex) {
-		
-		Pattern match = Pattern.compile(typeRegex);
-		
-		// Like above, only here we test the field type
-		for (Field field : getFields()) {
-			String name = field.getType().getName();
-			
-			if (match.matcher(name).matches()) {
-				return field;
-			}
-		}
-		
-		// Looks like we're outdated. Too bad.
-		throw new RuntimeException("Unable to find a field with the type " + 
-									typeRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves a field by type.
-	 * <p>
-	 * Note that the type is matched using the full canonical representation, i.e.: 
-	 * <ul>
-	 *     <li>java.util.List</li>
-	 *     <li>net.comphenix.xp.ExperienceMod</li>
-	 * </ul>
-	 * @param typeRegex - regular expression that will match the field type.
-	 * @param ignored - types to ignore.
-	 * @return The first field with a type that matches the given regular expression.
-	 */
-	@SuppressWarnings("rawtypes")
-	public Field getFieldByType(String typeRegex, Set<Class> ignored) {
-		
-		Pattern match = Pattern.compile(typeRegex);
-		
-		// Like above, only here we test the field type
-		for (Field field : getFields()) {
-			Class type = field.getType();
-			
-			if (!ignored.contains(type) && match.matcher(type.getName()).matches()) {
-				return field;
-			}
-		}
-		
-		// Looks like we're outdated. Too bad.
-		throw new RuntimeException("Unable to find a field with the type " + 
-									typeRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves all private and public fields in declared order (after JDK 1.5).
-	 * @return Every field.
-	 */
-	public Set<Field> getFields() {
-		// We will only consider private fields in the declared class
-		if (forceAccess)
-			return setUnion(source.getDeclaredFields(), source.getFields());
-		else
-			return setUnion(source.getFields());
-	}
-	
-	/**
-	 * Retrieves all private and public methods in declared order (after JDK 1.5).
-	 * @return Every method.
-	 */
-	public Set<Method> getMethods() {
-		// We will only consider private methods in the declared class
-		if (forceAccess)
-			return setUnion(source.getDeclaredMethods(), source.getMethods());
-		else
-			return setUnion(source.getMethods());
-	}
-	
-	// Prevent duplicate fields
-	private static <T> Set<T> setUnion(T[]... array) {
-		Set<T> result = new LinkedHashSet<T>();
-		
-		for (T[] elements : array) {
-			for (T element : elements) {
-				result.add(element);
-			}
-		}
-		
-		return result;
-	}
-	
-	/**
-	 * Retrieves whether or not not to override any scope restrictions.
-	 * @return TRUE if we override scope, FALSE otherwise.
-	 */
-	public boolean isForceAccess() {
-		return forceAccess;
-	}
-
-	/**
-	 * Sets whether or not not to override any scope restrictions.
-	 * @param forceAccess - TRUE if we override scope, FALSE otherwise.
-	 */
-	public void setForceAccess(boolean forceAccess) {
-		this.forceAccess = forceAccess;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/ObjectCloner.java

@@ -1,70 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-
-/**
- * Can copy an object field by field.
- * 
- * @author Kristian
- */
-public class ObjectCloner {
-
-	// Cache structure modifiers
-	@SuppressWarnings("rawtypes")
-	private static ConcurrentMap<Class, StructureModifier<Object>> cache =
-			new ConcurrentHashMap<Class, StructureModifier<Object>>();
-	
-	/**
-	 * Copy every field in object A to object B.
-	 * <p>
-	 * The two objects must have the same number of fields of the same type.
-	 * @param source - fields to copy.
-	 * @param destination - fields to copy to.
-	 * @param commonType - type containing each field to copy.
-	 */
-	public static void copyTo(Object source, Object destination, Class<?> commonType) {
-		
-		if (source == null)
-			throw new IllegalArgumentException("Source cannot be NULL");
-		if (destination == null)
-			throw new IllegalArgumentException("Destination cannot be NULL");
-		
-		StructureModifier<Object> modifier = cache.get(commonType);
-
-		// Create the structure modifier if we haven't already
-		if (modifier == null) {
-			StructureModifier<Object> value = new StructureModifier<Object>(commonType, null, false);
-			modifier = cache.putIfAbsent(commonType, value);
-			
-			if (modifier == null)
-				modifier = value;
-		}
-		
-		// Add target
-		StructureModifier<Object> modifierSource = modifier.withTarget(source);
-		StructureModifier<Object> modifierDest = modifier.withTarget(destination);
-		
-		// Copy every field
-		try {
-			for (int i = 0; i < modifierSource.size(); i++) {
-				Object value = modifierSource.read(i);
-				modifierDest.write(i, value);
-				
-				// System.out.println(String.format("Writing value %s to %s", 
-				//		value, modifier.getFields().get(i).getName()));
-			}
-			
-			// Copy private fields underneath
-			Class<?> superclass = commonType.getSuperclass();
-			
-			if (!superclass.equals(Object.class)) {
-				copyTo(source, destination, superclass);
-			}
-			
-		} catch (FieldAccessException e) {
-			throw new RuntimeException("Unable to copy fields from " + commonType.getName(), e);
-		}
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/PrimitiveUtils.java

@@ -1,124 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.lang.reflect.Type;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Contains static utility methods pertaining to primitive types and their
- * corresponding wrapper types.
- * 
- * @author Kevin Bourrillion
- */
-public final class PrimitiveUtils {
-	private PrimitiveUtils() {
-	}
-
-	/** A map from primitive types to their corresponding wrapper types. */
-	private static final Map<Class<?>, Class<?>> PRIMITIVE_TO_WRAPPER_TYPE;
-
-	/** A map from wrapper types to their corresponding primitive types. */
-	private static final Map<Class<?>, Class<?>> WRAPPER_TO_PRIMITIVE_TYPE;
-
-	// Sad that we can't use a BiMap. :(
-	static {
-		Map<Class<?>, Class<?>> primToWrap = new HashMap<Class<?>, Class<?>>(16);
-		Map<Class<?>, Class<?>> wrapToPrim = new HashMap<Class<?>, Class<?>>(16);
-
-		add(primToWrap, wrapToPrim, boolean.class, Boolean.class);
-		add(primToWrap, wrapToPrim, byte.class, Byte.class);
-		add(primToWrap, wrapToPrim, char.class, Character.class);
-		add(primToWrap, wrapToPrim, double.class, Double.class);
-		add(primToWrap, wrapToPrim, float.class, Float.class);
-		add(primToWrap, wrapToPrim, int.class, Integer.class);
-		add(primToWrap, wrapToPrim, long.class, Long.class);
-		add(primToWrap, wrapToPrim, short.class, Short.class);
-		add(primToWrap, wrapToPrim, void.class, Void.class);
-
-		PRIMITIVE_TO_WRAPPER_TYPE = Collections.unmodifiableMap(primToWrap);
-		WRAPPER_TO_PRIMITIVE_TYPE = Collections.unmodifiableMap(wrapToPrim);
-	}
-
-	private static void add(Map<Class<?>, Class<?>> forward,
-			Map<Class<?>, Class<?>> backward, Class<?> key, Class<?> value) {
-		forward.put(key, value);
-		backward.put(value, key);
-	}
-
-	/**
-	 * Returns true if this type is a primitive.
-	 */
-	public static boolean isPrimitive(Type type) {
-		return PRIMITIVE_TO_WRAPPER_TYPE.containsKey(type);
-	}
-
-	/**
-	 * Returns {@code true} if {@code type} is one of the nine primitive-wrapper
-	 * types, such as {@link Integer}.
-	 * 
-	 * @see Class#isPrimitive
-	 */
-	public static boolean isWrapperType(Type type) {
-		return WRAPPER_TO_PRIMITIVE_TYPE.containsKey(checkNotNull(type));
-	}
-
-	/**
-	 * Returns the corresponding wrapper type of {@code type} if it is a
-	 * primitive type; otherwise returns {@code type} itself. Idempotent.
-	 * 
-	 * <pre>
-	 *     wrap(int.class) == Integer.class
-	 *     wrap(Integer.class) == Integer.class
-	 *     wrap(String.class) == String.class
-	 * </pre>
-	 */
-	public static <T> Class<T> wrap(Class<T> type) {
-		// cast is safe: long.class and Long.class are both of type Class<Long>
-		@SuppressWarnings("unchecked")
-		Class<T> wrapped = (Class<T>) PRIMITIVE_TO_WRAPPER_TYPE
-				.get(checkNotNull(type));
-		return (wrapped == null) ? type : wrapped;
-	}
-
-	/**
-	 * Returns the corresponding primitive type of {@code type} if it is a
-	 * wrapper type; otherwise returns {@code type} itself. Idempotent.
-	 * 
-	 * <pre>
-	 *     unwrap(Integer.class) == int.class
-	 *     unwrap(int.class) == int.class
-	 *     unwrap(String.class) == String.class
-	 * </pre>
-	 */
-	public static <T> Class<T> unwrap(Class<T> type) {
-		// cast is safe: long.class and Long.class are both of type Class<Long>
-		@SuppressWarnings("unchecked")
-		Class<T> unwrapped = (Class<T>) WRAPPER_TO_PRIMITIVE_TYPE
-				.get(checkNotNull(type));
-		return (unwrapped == null) ? type : unwrapped;
-	}
-	
-	public static <T> T checkNotNull(T obj) {
-		if (obj == null) {
-			throw new NullPointerException();
-		}
-		return obj;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/compiler/BackgroundCompiler.java

@@ -1,183 +0,0 @@
-package com.comphenix.protocol.reflect.compiler;
-
-import java.util.Map;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import com.comphenix.protocol.reflect.StructureModifier;
-
-/**
- * Compiles structure modifiers on a background thread.
- * <p>
- * This is necessary as we cannot block the main thread.
- * 
- * @author Kristian
- */
-public class BackgroundCompiler {
-
-	// How long to wait for a shutdown
-	public static final int SHUTDOWN_DELAY_MS = 2000;
-	
-	// The single background compiler we're using
-	private static BackgroundCompiler backgroundCompiler;
-	
-	private StructureCompiler compiler;
-	private boolean enabled;
-	private boolean shuttingDown;
-	
-	private ExecutorService executor;
-	
-	/**
-	 * Retrieves the current background compiler.
-	 * @return Current background compiler.
-	 */
-	public static BackgroundCompiler getInstance() {
-		return backgroundCompiler;
-	}
-	
-	/**
-	 * Sets the single background compiler we're using.
-	 * @param backgroundCompiler - current background compiler, or NULL if the library is not loaded.
-	 */
-	public static void setInstance(BackgroundCompiler backgroundCompiler) {
-		BackgroundCompiler.backgroundCompiler = backgroundCompiler;
-	}
-	
-	/**
-	 * Initialize a background compiler.
-	 * @param loader - class loader from Bukkit.
-	 */
-	public BackgroundCompiler(ClassLoader loader) {
-		this(loader, Executors.newSingleThreadExecutor());
-	}
-
-	/**
-	 * Initialize a background compiler utilizing the given thread pool.
-	 * @param loader - class loader from Bukkit.
-	 * @param executor - thread pool we'll use.
-	 */
-	public BackgroundCompiler(ClassLoader loader, ExecutorService executor) {
-		if (loader == null)
-			throw new IllegalArgumentException("loader cannot be NULL");
-		if (executor == null)
-			throw new IllegalArgumentException("executor cannot be NULL");
-		
-		this.compiler = new StructureCompiler(loader);
-		this.executor = executor;
-		this.enabled = true;
-	}
-	
-	/**
-	 * Ensure that the indirectly given structure modifier is eventually compiled.
-	 * @param cache - store of structure modifiers.
-	 * @param key - key of the structure modifier to compile.
-	 */
-	@SuppressWarnings("rawtypes")
-	public void scheduleCompilation(final Map<Class, StructureModifier> cache, final Class key) {
-		
-		@SuppressWarnings("unchecked")
-		final StructureModifier<Object> uncompiled = cache.get(key);
-		
-		if (uncompiled != null) {
-			scheduleCompilation(uncompiled, new CompileListener<Object>() {
-				@Override
-				public void onCompiled(StructureModifier<Object> compiledModifier) {
-					// Update cache
-					cache.put(key, compiledModifier);
-				}
-			});
-		}
-	}
-	
-	/**
-	 * Ensure that the given structure modifier is eventually compiled.
-	 * @param uncompiled - structure modifier to compile.
-	 * @param listener - listener responsible for responding to the compilation.
-	 */
-	public <TKey> void scheduleCompilation(final StructureModifier<TKey> uncompiled, final CompileListener<TKey> listener) {
-
-		// Only schedule if we're enabled
-		if (enabled && !shuttingDown) {
-			
-			// Don't try to schedule anything
-			if (executor == null || executor.isShutdown())
-				return;
-			
-			try {
-				executor.submit(new Callable<Object>() {
-					@Override
-					public Object call() throws Exception {
-		
-						StructureModifier<TKey> modifier = uncompiled;
-						
-						// Do our compilation
-						modifier = compiler.compile(modifier);
-						listener.onCompiled(modifier);
-						
-						// We'll also return the new structure modifier
-						return modifier;
-					}
-				});
-			} catch (RejectedExecutionException e) {
-				// Occures when the underlying queue is overflowing. Since the compilation  
-				// is only an optmization and not really essential we'll just log this failure 
-				// and move on.
-				Logger.getLogger("Minecraft").log(Level.WARNING, "Unable to schedule compilation task.", e);
-			}
-		}
-	}
-	
-	/**
-	 * Clean up after ourselves using the default timeout.
-	 */
-	public void shutdownAll() {
-		shutdownAll(SHUTDOWN_DELAY_MS, TimeUnit.MILLISECONDS);
-	}
-	
-	/**
-	 * Clean up after ourselves.
-	 * @param timeout - the maximum time to wait.
-	 * @param unit - the time unit of the timeout argument.
-	 */
-	public void shutdownAll(long timeout, TimeUnit unit) {
-		setEnabled(false);
-		shuttingDown = true;
-		executor.shutdown();
-		
-		try {
-			executor.awaitTermination(timeout, unit);
-		} catch (InterruptedException e) {
-			// Unlikely to ever occur.
-			e.printStackTrace();
-		}
-	}
-	
-	/**
-	 * Retrieve whether or not the background compiler is enabled.
-	 * @return TRUE if it is enabled, FALSE otherwise.
-	 */
-	public boolean isEnabled() {
-		return enabled;
-	}
-
-	/**
-	 * Sets whether or not the background compiler is enabled.
-	 * @param enabled - TRUE to enable it, FALSE otherwise.
-	 */
-	public void setEnabled(boolean enabled) {
-		this.enabled = enabled;
-	}
-
-	/**
-	 * Retrieve the current structure compiler.
-	 * @return Current structure compiler.
-	 */
-	public StructureCompiler getCompiler() {
-		return compiler;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/compiler/CompileListener.java

@@ -1,17 +0,0 @@
-package com.comphenix.protocol.reflect.compiler;
-
-import com.comphenix.protocol.reflect.StructureModifier;
-
-/**
- * Used to save the result of an compilation.
- * 
- * @author Kristian
- * @param <TKey> - type of the structure modifier field.
- */
-public interface CompileListener<TKey> {
-	/**
-	 * Invoked when a structure modifier has been successfully compiled.
-	 * @param compiledModifier - the compiled structure modifier.
-	 */
-	public void onCompiled(StructureModifier<TKey> compiledModifier);
-}

ProtocolLib/src/com/comphenix/protocol/reflect/compiler/CompiledStructureModifier.java

@@ -1,73 +0,0 @@
-package com.comphenix.protocol.reflect.compiler;
-
-import java.lang.reflect.Field;
-import java.util.Map;
-
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.reflect.StructureModifier;
-import com.comphenix.protocol.reflect.instances.DefaultInstances;
-
-/**
- * Represents a compiled structure modifier.
- * 
- * @author Kristian
- * @param <TField> Field type.
- */
-public abstract class CompiledStructureModifier<TField> extends StructureModifier<TField> {
-	// Used to compile instances of structure modifiers
-	protected StructureCompiler compiler;
-	
-	public CompiledStructureModifier() {
-		super();
-		customConvertHandling = true;
-	}
-	
-	// Speed up the default writer
-	@SuppressWarnings("unchecked")
-	@Override
-	public StructureModifier<TField> writeDefaults() throws FieldAccessException {
-		
-		DefaultInstances generator = DefaultInstances.DEFAULT;
-		
-		// Write a default instance to every field
-		for (Map.Entry<Field, Integer> entry  : defaultFields.entrySet()) {
-			Integer index = entry.getValue();
-			Field field = entry.getKey();
-			
-			write(index, (TField) generator.getDefault(field.getType()));
-		}
-		
-		return this;
-	}
-	
-	@SuppressWarnings("unchecked")
-	@Override
-	public final TField read(int fieldIndex) throws FieldAccessException {
-		Object result = readGenerated(fieldIndex);
-		
-		if (converter != null)
-			return converter.getSpecific(result);
-		else
-			return (TField) result;
-	}
-	
-	protected abstract Object readGenerated(int fieldIndex) throws FieldAccessException;
-
-	@SuppressWarnings("unchecked")
-	@Override
-	public StructureModifier<TField> write(int index, Object value) throws FieldAccessException {
-		if (converter != null)
-			value = converter.getGeneric((TField) value);
-		return writeGenerated(index, value);
-	}
-	
-	protected abstract StructureModifier<TField> writeGenerated(int index, Object value) throws FieldAccessException;
-	
-	@Override
-	public StructureModifier<TField> withTarget(Object target) {
-		if (compiler != null)
-			return compiler.compile(super.withTarget(target));
-		else
-			return super.withTarget(target);
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/instances/ExistingGenerator.java

@@ -1,111 +0,0 @@
-package com.comphenix.protocol.reflect.instances;
-
-import java.lang.reflect.Field;
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.annotation.Nullable;
-
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-
-/**
- * Provides instance constructors using a list of existing values.
- * <p>
- * Only one instance per individual class.
- * @author Kristian
- */
-public class ExistingGenerator implements InstanceProvider {
-
-	private Map<String, Object> existingValues = new HashMap<String, Object>();
-	
-	private ExistingGenerator() {
-		// Only accessible to the constructors
-	}
-	
-	/**
-	 * Automatically create an instance provider from a objects public and private fields.
-	 * <p>
-	 * If two or more fields share the same type, the last declared non-null field will take
-	 * precedent.
-	 * @param object - object to create an instance generator from.
-	 * @return The instance generator.
-	 */
-	public static ExistingGenerator fromObjectFields(Object object) {
-		if (object == null)
-			throw new IllegalArgumentException("Object cannot be NULL.");
-		
-		return fromObjectFields(object, object.getClass());
-	}
-	
-	/**
-	 * Automatically create an instance provider from a objects public and private fields.
-	 * <p>
-	 * If two or more fields share the same type, the last declared non-null field will take
-	 * precedent.
-	 * @param object - object to create an instance generator from.
-	 * @param type - the type to cast the object.
-	 * @return The instance generator.
-	 */
-	public static ExistingGenerator fromObjectFields(Object object, Class<?> type) {
-		ExistingGenerator generator = new ExistingGenerator();
-		
-		// Possible errors
-		if (object == null)
-			throw new IllegalArgumentException("Object cannot be NULL.");
-		if (type == null)
-			throw new IllegalArgumentException("Type cannot be NULL.");
-		if (!type.isAssignableFrom(object.getClass()))
-			throw new IllegalArgumentException("Type must be a superclass or be the same type.");
-		
-		// Read instances from every field.
-		for (Field field : FuzzyReflection.fromClass(type, true).getFields()) {
-			try {
-				Object value = FieldUtils.readField(field, object, true);
-
-				// Use the type of the field, not the object itself
-				if (value != null)
-					generator.addObject(field.getType(), value);
-				
-			} catch (Exception e) {
-				// Yes, swallow it. No, really.
-			}
-		}
-
-		return generator;
-	}
-	
-	/**
-	 * Create an instance generator from a pre-defined array of values.
-	 * @param values - values to provide.
-	 * @return An instance provider that uses these values.
-	 */
-	public static ExistingGenerator fromObjectArray(Object[] values) {
-		ExistingGenerator generator = new ExistingGenerator();
-		
-		for (Object value : values)
-			 generator.addObject(value);
-		
-		return generator;
-	}
-	
-	private void addObject(Object value) {
-		if (value == null)
-			throw new IllegalArgumentException("Value cannot be NULL.");
-		
-		existingValues.put(value.getClass().getName(), value);
-	}
-
-	private void addObject(Class<?> type, Object value) {
-		existingValues.put(type.getName(), value);
-	}
-	
-	@Override
-	public Object create(@Nullable Class<?> type) {
-		
-		Object value = existingValues.get(type.getName());
-
-		// NULL values indicate that the generator failed
-		return value;
-	}
-}

ProtocolLib/src/com/comphenix/protocol/reflect/instances/InstanceProvider.java

@@ -1,18 +0,0 @@
-package com.comphenix.protocol.reflect.instances;
-
-import javax.annotation.Nullable;
-
-/**
- * Represents a type generator for specific types.
- * 
- * @author Kristian
- */
-public interface InstanceProvider {
-
-	/**
-	 * Create an instance given a type, if possible.
-	 * @param type - type to create.
-	 * @return The instance, or NULL if the type cannot be created.
-	 */
-	public abstract Object create(@Nullable Class<?> type);
-}

ProtocolLib/src/plugin.yml

@@ -1,8 +0,0 @@
-name: ProtocolLib
-version: 1.3.0
-description: Provides read/write access to the Minecraft protocol.
-author: Comphenix
-website: http://www.comphenix.net/ProtocolLib
-
-main: com.comphenix.protocol.ProtocolLibrary
-database: false

ProtocolLib/test/com/comphenix/protocol/reflect/StructureModifierTest.java

@@ -1,26 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-import static org.junit.Assert.*;
-
-import net.minecraft.server.Packet103SetSlot;
-
-import org.junit.Test;
-
-import com.avaje.ebeaninternal.server.cluster.Packet;
-import com.comphenix.protocol.reflect.StructureModifier;
-
-public class StructureModifierTest {
-
-	@Test
-	public void test() throws FieldAccessException {
-
-		Packet103SetSlot move = new Packet103SetSlot();
-		StructureModifier<Object> modifier = new StructureModifier<Object>(
-				Packet103SetSlot.class, Packet.class, true);
-
-		move.a = 1;
-		int value = (Integer) modifier.withTarget(move).withType(int.class).read(0);
-		
-		assertEquals(1, value);
-	}
-}

Readme.md

@@ -1,131 +1,163 @@
-ProtocolLib 
-===========
-
-Certain tasks are impossible to perform with the standard Bukkit API, and may require 
-working with and even modify Minecraft directly. A common technique is to modify incoming 
-and outgoing [packets](http://www.wiki.vg/Protocol), or inject custom packets into the
-stream. This is quite cumbersome to do, however, and most implementations will break 
-as soon as a new version of Minecraft has been released, mostly due to obfuscation.
-
-Critically, different plugins that use this approach may _hook_ into the same classes, 
-with unpredictable outcomes. More than often this causes plugins to crash, but it may also 
-lead to more subtle bugs.
-
-
-### Resources
-
-* [JavaDoc](http://aadnk.github.com/ProtocolLib/Javadoc/) 
-
-
-A new API
----------
-
-__ProtocolLib__ attempts to solve this problem by providing a event API, much like Bukkit, 
-that allow plugins to monitor, modify or cancel packets sent and received. But more importantly, 
-the API also hides all the gritty, obfuscated classes with a simple index based read/write system. 
-You no longer have to reference CraftBukkit!
-
-
-### Using ProtocolLib
-
-To use the library, first add ProtocolLib.jar to your Java build path. Then, add ProtocolLib
-as a dependency (or soft-dependency, if you can live without it) to your plugin.yml file:
-
-    depends: [ProtocolLib]
-
-Then get a reference to ProtocolManager in onLoad() and you're good to go.
-
-    private ProtocolManager protocolManager;
-    
-    public void onLoad() {
-        protocolManager = ProtocolLibrary.getProtocolManager();
-    }
-
-To listen for packets sent by the server to a client, add a server-side listener:
-
-    // Disable all sound effects
-    protocolManager.addPacketListener(
-      new PacketAdapter(this, ConnectionSide.SERVER_SIDE, ListenerPriority.NORMAL, 0x3E) {
-        @Override
-        public void onPacketSending(PacketEvent event) {
-            // Item packets
-            switch (event.getPacketID()) {
-            case 0x3E: // Sound effect
-                event.setCancelled(true);
-                break;
-            }
-        }
-    });
-
-
-It's also possible to read and modify the content of these packets. For instance, you can create a global
-censor by listening for Packet3Chat events:
-
-    // Censor
-    protocolManager.addPacketListener(
-      new PacketAdapter(this, ConnectionSide.CLIENT_SIDE, ListenerPriority.NORMAL, 0x03) {
-        @Override
-        public void onPacketReceiving(PacketEvent event) {
-            if (event.getPacketID() == 0x03) {
-                try {
-                    PacketContainer packet = event.getPacket();
-                    String message = packet.getSpecificModifier(String.class).read(0);
-                    
-                    if (message.contains("shit") || message.contains("damn")) {
-                        event.setCancelled(true);
-                        event.getPlayer().sendMessage("Bad manners!");
-                    }
-                    		
-                } catch (FieldAccessException e) {
-                    getLogger().log(Level.SEVERE, "Couldn't access field.", e);
-                }
-            }
-        }
-    });
-
-
-### Sending packets
-
-Normally, you might have to do something ugly like the following:
-
-    Packet60Explosion fakeExplosion = new Packet60Explosion();
-    	
-    fakeExplosion.a = player.getLocation().getX();
-    fakeExplosion.b = player.getLocation().getY();
-    fakeExplosion.c = player.getLocation().getZ();
-    fakeExplosion.d = 3.0F;
-    fakeExplosion.e = new ArrayList<Object>();
-
-    ((CraftPlayer) player).getHandle().netServerHandler.sendPacket(fakeExplosion);
-
-But with ProtocolLib, you can turn that into something more manageable. Notice that 
-you don't have to create an ArrayList this version:
-
-    PacketContainer fakeExplosion = protocolManager.createPacket(60);
-    
-    fakeExplosion.getSpecificModifier(double.class).
-        write(0, player.getLocation().getX()).
-        write(1, player.getLocation().getY()).
-        write(2, player.getLocation().getZ());
-    fakeExplosion.getSpecificModifier(float.class).
-        write(0, 3.0F);
-    
-    protocolManager.sendServerPacket(player, fakeExplosion);
-
-
-Compatiblity
-------------
-
-One of the main goals of this project was to achive maximum compatibility with craftBukkit. And the end
-result is quite flexible - in tests I successfully ran an unmodified ProtocolLib on CraftBukkit 1.8.0, and
-it should be resiliant against future changes. It's likely that I won't have to update ProtocolLib for
-anything but bug and performance fixes. 
-
-How is this possible? It all comes down to reflection in the end. Essentially, no name is hard coded - 
-every field, method and class is deduced by looking at field types, package names or parameter
-types. It's remarkably consistent across different versions.
-
-
-### Incompatiblity
-
-The following plugins (to be expanded) are not compatible with ProtocolLib:
+# ProtocolLib [![Travis Status](https://travis-ci.org/dmulloy2/ProtocolLib.svg?branch=master)](https://travis-ci.org/dmulloy2/ProtocolLib)
+
+Certain tasks are impossible to perform with the standard Bukkit API, and may require 
+working with and even modify Minecraft directly. A common technique is to modify incoming 
+and outgoing [packets](http://www.wiki.vg/Protocol), or inject custom packets into the
+stream. This is quite cumbersome to do, however, and most implementations will break 
+as soon as a new version of Minecraft has been released, mostly due to obfuscation.
+
+Critically, different plugins that use this approach may _hook_ into the same classes, 
+with unpredictable outcomes. More than often this causes plugins to crash, but it may also 
+lead to more subtle bugs.
+
+Currently maintained by dmulloy2 on behalf of [Spigot](http://www.spigotmc.org/).
+
+### Resources
+
+* [Resource Page](http://www.spigotmc.org/resources/protocollib.1997/)
+* [Dev Builds](http://ci.dmulloy2.net/job/ProtocolLib)
+* [JavaDoc](http://ci.dmulloy2.net/job/ProtocolLib/javadoc)
+
+### Compilation
+
+ProtocolLib is built with Maven and requires Spigot and SpigotAPI, which can be found [here](http://www.spigotmc.org/wiki/buildtools/).
+
+### A new API
+
+__ProtocolLib__ attempts to solve this problem by providing a event API, much like Bukkit, 
+that allows plugins to monitor, modify, or cancel packets sent and received. But, more importantly, 
+the API also hides all the gritty, obfuscated classes with a simple index based read/write system. 
+You no longer have to reference CraftBukkit!
+
+### Using ProtocolLib
+
+To use this library, first add ProtocolLib.jar to your Java build path. Then, add ProtocolLib
+as a dependency or soft dependency to your plugin.yml file like any other plugin:
+
+````yml
+depend: [ProtocolLib]
+````
+
+You can also add ProtocolLib as a Maven dependency:
+
+````xml
+<repositories>
+  <repository>
+    <id>dmulloy2-repo</id>
+    <url>http://repo.dmulloy2.net/content/groups/public/</url>
+  </repository>
+  ...
+</repository>
+
+<dependencies>
+  <dependency>
+    <groupId>com.comphenix.protocol</groupId>
+    <artifactId>ProtocolLib</artifactId>
+    <version>3.6.5</version>
+  </dependency>
+</dependencies>
+````
+
+Then get a reference to ProtocolManager in onLoad() or onEnable() and you're good to go.
+
+````java
+private ProtocolManager protocolManager;
+
+public void onLoad() {
+    protocolManager = ProtocolLibrary.getProtocolManager();
+}
+````
+
+To listen for packets sent by the server to a client, add a server-side listener:
+
+````java
+// Disable all sound effects
+protocolManager.addPacketListener(
+  new PacketAdapter(this, ListenerPriority.NORMAL, 
+          PacketType.Play.Server.NAMED_SOUND_EFFECT) {
+    @Override
+    public void onPacketSending(PacketEvent event) {
+        // Item packets (id: 0x29)
+        if (event.getPacketType() == 
+                PacketType.Play.Server.NAMED_SOUND_EFFECT) {
+            event.setCancelled(true);
+        }
+    }
+});
+````
+
+It's also possible to read and modify the content of these packets. For instance, you can create a global
+censor by listening for Packet3Chat events:
+
+````java
+// Censor
+protocolManager.addPacketListener(new PacketAdapter(this,
+        ListenerPriority.NORMAL, 
+        PacketType.Play.Client.CHAT) {
+    @Override
+    public void onPacketReceiving(PacketEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CHAT) {
+            PacketContainer packet = event.getPacket();
+            String message = packet.getStrings().read(0);
+
+            if (message.contains("shit")
+                    || message.contains("damn")) {
+                event.setCancelled(true);
+                event.getPlayer().sendMessage("Bad manners!");
+            }
+        }
+    }
+});
+````
+
+### Sending packets
+
+Normally, you might have to do something ugly like the following:
+
+````java
+Packet60Explosion fakeExplosion = new Packet60Explosion();
+	
+fakeExplosion.a = player.getLocation().getX();
+fakeExplosion.b = player.getLocation().getY();
+fakeExplosion.c = player.getLocation().getZ();
+fakeExplosion.d = 3.0F;
+fakeExplosion.e = new ArrayList<Object>();
+
+((CraftPlayer) player).getHandle().netServerHandler.sendPacket(fakeExplosion);
+````
+
+But with ProtocolLib, you can turn that into something more manageable. Notice that 
+you don't have to create an ArrayList with this version:
+
+````java
+
+PacketContainer fakeExplosion = new PacketContainer(PacketType.Play.Server.EXPLOSION);
+fakeExplosion.getDoubles().
+    write(0, player.getLocation().getX()).
+    write(1, player.getLocation().getY()).
+    write(2, player.getLocation().getZ());
+fakeExplosion.getFloat().write(0, 3.0F);
+
+try {
+    protocolManager.sendServerPacket(player, fakeExplosion);
+} catch (InvocationTargetException e) {
+    throw new RuntimeException(
+        "Cannot send packet " + fakeExplosion, e);
+}
+````
+
+### Compatibility
+
+One of the main goals of this project was to achieve maximum compatibility with CraftBukkit. And the end
+result is quite flexible. Aside from netty package changes, it should be resilient against future changes.
+It's likely that I won't have to update ProtocolLib for anything but bug fixes and new features.
+
+How is this possible? It all comes down to reflection in the end. Essentially, no name is hard coded - 
+every field, method and class is deduced by looking at field types, package names or parameter
+types. It's remarkably consistent across different versions.
+
+
+### Incompatibility
+
+The following plugins (to be expanded) are not compatible with ProtocolLib:
+* TagAPI

modules/API/pom.xml

@@ -0,0 +1,245 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>ProtocolLib-API</artifactId>
+  <name>ProtocolLib-API</name>
+  <version>4.0</version>
+
+  <description>Provides read/write access to the Minecraft protocol.</description>
+  <url>http://www.spigotmc.org/resources/protocollib.1997/</url>
+  <packaging>jar</packaging>
+
+  <parent>
+    <groupId>com.comphenix.protocol</groupId>
+    <artifactId>ProtocolLib-Parent</artifactId>
+    <version>v4-SNAPSHOT</version>
+    <relativePath>../../</relativePath>
+  </parent>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <project.build.number></project.build.number>
+  </properties>
+
+  <build>
+    <defaultGoal>clean install</defaultGoal>
+    <sourceDirectory>src/main/java</sourceDirectory>
+    <testSourceDirectory>src/test/java</testSourceDirectory>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>true</filtering>
+        <excludes>
+          <exclude>**/*.java</exclude>
+        </excludes>
+      </resource>
+    </resources>
+
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.5.1</version>
+        <configuration>
+          <source>1.7</source>
+          <target>1.7</target>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.6</version>
+        <configuration>
+          <archive>
+            <manifestEntries>
+              <Main-Class>com.comphenix.protocol.Application</Main-Class>
+              <Implementation-Title>ProtocolLib</Implementation-Title>
+              <Implementation-Version>${project.version}${project.build.number}</Implementation-Version>
+              <Implementation-Vendor>dmulloy2</Implementation-Vendor>
+            </manifestEntries>
+          </archive>
+          <finalName>ProtocolLib</finalName>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.10</version>
+        <configuration>
+          <systemProperties>
+            <property>
+              <name>projectVersion</name>
+              <value>${project.version}</value>
+            </property>
+          </systemProperties>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+  <profiles>
+    <profile>
+      <id>jenkins</id>
+      <activation>
+        <property>
+          <name>env.BUILD_NUMBER</name>
+        </property>
+      </activation>
+      <properties>
+        <project.build.number>-b${env.BUILD_NUMBER}</project.build.number>
+      </properties>
+    </profile>
+
+    <profile>
+      <id>release-sign-artifacts</id>
+      <activation>
+        <property>
+          <name>performRelease</name>
+          <value>true</value>
+        </property>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-source-plugin</artifactId>
+            <version>3.0.0</version>
+            <executions>
+              <execution>
+                <id>attach-sources</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <version>2.10.3</version>
+            <executions>
+              <execution>
+                <id>attach-javadocs</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-gpg-plugin</artifactId>
+            <version>1.6</version>
+            <executions>
+              <execution>
+                <id>sign-artifacts</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>sign</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+
+  <scm>
+    <connection>scm:git:git://github.com/dmulloy2/ProtocolLib.git</connection>
+    <developerConnection>scm:git:git@github.com:dmulloy2/ProtocolLib.git</developerConnection>
+    <url>https://github.com/dmulloy2/ProtocolLib</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>GNU GENERAL PUBLIC LICENSE - Version 2, June 1991</name>
+      <url>http://www.gnu.org/licenses/gpl-2.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>dmulloy2</id>
+      <name>Dan Mulloy</name>
+      <url>http://dmulloy2.net/</url>
+      <roles>
+        <role>developer</role>
+        <role>maintainer</role>
+      </roles>
+    </developer>
+    <developer>
+      <id>aadnk</id>
+      <name>Kristian S. Stangeland</name>
+      <email>kr_stang@hotmail.com</email>
+      <url>http://comphenix.net/</url>
+      <roles>
+        <role>former author</role>
+      </roles>
+      <timezone>1</timezone>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <!-- Included with Minecraft
+    <dependency>
+	  <groupId>io.netty</groupId>
+	  <artifactId>netty-all</artifactId>
+	  <version>4.0.23.Final</version>
+    </dependency>
+    -->
+    <dependency>
+      <groupId>org.spigotmc</groupId>
+      <artifactId>spigot-api</artifactId>
+      <version>1.9.4-R0.1-SNAPSHOT</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.spigotmc</groupId>
+      <artifactId>spigot</artifactId>
+      <version>1.9.4-R0.1-SNAPSHOT</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>cglib</groupId>
+      <artifactId>cglib-nodep</artifactId>
+      <version>2.2.2</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.comphenix.executors</groupId>
+      <artifactId>BukkitExecutors</artifactId>
+      <version>1.1-SNAPSHOT</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.10</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-all</artifactId>
+      <version>1.8.4</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.powermock</groupId>
+      <artifactId>powermock-module-junit4</artifactId>
+      <version>1.5</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.powermock</groupId>
+      <artifactId>powermock-api-mockito</artifactId>
+      <version>1.5</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

modules/API/src/main/java/com/comphenix/protocol/AsynchronousManager.java

@@ -0,0 +1,155 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol;
+
+import java.util.Set;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.async.AsyncListenerHandler;
+import com.comphenix.protocol.async.AsyncMarker;
+import com.comphenix.protocol.error.ErrorReporter;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.events.PacketListener;
+
+/**
+ * Represents a asynchronous packet handler.
+ * 
+ * @author Kristian
+ */
+public interface AsynchronousManager {
+	/**
+	 * Registers an asynchronous packet handler.
+	 * <p>
+	 * Use {@link AsyncMarker#incrementProcessingDelay()} to delay a packet until its ready to be transmitted.
+	 * <p>
+	 * To start listening asynchronously, pass the getListenerLoop() runnable to a different thread.
+	 * @param listener - the packet listener that will receive these asynchronous events.
+	 * @return An asynchronous handler.
+	 */
+	public abstract AsyncListenerHandler registerAsyncHandler(PacketListener listener);
+
+	/**
+	 * Unregisters and closes the given asynchronous handler.
+	 * @param handler - asynchronous handler.
+	 */
+	public abstract void unregisterAsyncHandler(AsyncListenerHandler handler);
+
+	/**
+	 * Unregisters and closes the first asynchronous handler associated with the given listener.
+	 * @param listener - asynchronous listener
+	 */
+	public abstract void unregisterAsyncHandler(PacketListener listener);
+	
+	/**
+	 * Unregisters every asynchronous handler associated with this plugin.
+	 * @param plugin - the original plugin.
+	 */
+	public void unregisterAsyncHandlers(Plugin plugin);
+	
+	/**
+	 * Retrieves a immutable set containing the ID of the sent server packets that will be
+	 * observed by the asynchronous listeners.
+	 * <p>
+	 * Deprecated: Use {@link #getSendingTypes()} instead.
+	 * @return Every filtered server packet.
+	 */
+	@Deprecated
+	public abstract Set<Integer> getSendingFilters();
+
+	/**
+	 * Retrieves a immutable set containing the types of the sent server packets that will be
+	 * observed by the asynchronous listeners.
+	 * @return Every filtered server packet.
+	 */
+	public abstract Set<PacketType> getSendingTypes();
+	
+	/**
+	 * Retrieves a immutable set containing the ID of the recieved client packets that will be
+	 * <p>
+	 * Deprecated: Use {@link #getReceivingTypes()} instead.
+	 * observed by the asynchronous listeners.
+	 * @return Every filtered client packet.
+	 */
+	@Deprecated
+	public abstract Set<Integer> getReceivingFilters();
+	
+	/**
+	 * Retrieves a immutable set containing the types of the received client packets that will be
+	 * observed by the asynchronous listeners.
+	 * @return Every filtered client packet.
+	 */
+	public abstract Set<PacketType> getReceivingTypes();
+
+	/**
+	 * Determine if a given synchronous packet has asynchronous listeners.
+	 * @param packet - packet to test.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	public abstract boolean hasAsynchronousListeners(PacketEvent packet);
+
+	/**
+	 * Retrieve the default packet stream.
+	 * @return Default packet stream.
+	 */
+	public abstract PacketStream getPacketStream();
+
+	/**
+	 * Retrieve the default error reporter.
+	 * @return Default reporter.
+	 */
+	public abstract ErrorReporter getErrorReporter();
+
+	/**
+	 * Remove listeners, close threads and transmit every delayed packet.
+	 */
+	public abstract void cleanupAll();
+
+	/**
+	 * Signal that a packet is ready to be transmitted.
+	 * <p>
+	 * This should only be called if {@link com.comphenix.protocol.async.AsyncMarker#incrementProcessingDelay() AsyncMarker.incrementProcessingDelay()}
+	 * has been called previously.
+	 * @param packet - packet to signal.
+	 */
+	public abstract void signalPacketTransmission(PacketEvent packet);
+
+	/**
+	 * Register a synchronous listener that handles packets when they time out.
+	 * @param listener - synchronous listener that will handle timed out packets.
+	 */
+	public abstract void registerTimeoutHandler(PacketListener listener);
+	
+	/**
+	 * Unregisters a given timeout listener.
+	 * @param listener - the timeout listener to unregister.
+	 */
+	public abstract void unregisterTimeoutHandler(PacketListener listener);
+
+	/**
+	 * Get a immutable set of every registered timeout handler.
+	 * @return Set of every registered timeout handler.
+	 */
+	public abstract Set<PacketListener> getTimeoutHandlers();
+
+	/**
+	 * Get an immutable set of every registered asynchronous packet listener.
+	 * @return Set of every asynchronous packet listener.
+	 */
+	public abstract Set<PacketListener> getAsyncHandlers();
+}

modules/API/src/main/java/com/comphenix/protocol/PacketStream.java

@@ -0,0 +1,114 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.bukkit.entity.Player;
+
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.NetworkMarker;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.netty.WirePacket;
+
+/**
+ * Represents a object capable of sending or receiving packets.
+ * 
+ * @author Kristian
+ */
+public interface PacketStream {
+	/**
+	 * Send a packet to the given player.
+	 * @param receiver - the reciever.
+	 * @param packet - packet to send.
+	 * @throws InvocationTargetException - if an error occured when sending the packet.
+	 */
+	public void sendServerPacket(Player receiver, PacketContainer packet)
+			throws InvocationTargetException;
+
+	/**
+	 * Send a packet to the given player.
+	 * @param receiver - the reciever.
+	 * @param packet - packet to send.
+	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
+	 * @throws InvocationTargetException - if an error occured when sending the packet.
+	 */
+	public void sendServerPacket(Player receiver, PacketContainer packet, boolean filters)
+			throws InvocationTargetException;
+	
+	/**
+	 * Send a packet to the given player.
+	 * @param receiver - the receiver.
+	 * @param packet - packet to send.
+	 * @param marker - the network marker to use.
+	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
+	 * @throws InvocationTargetException - if an error occured when sending the packet.
+	 */
+	public void sendServerPacket(Player receiver, PacketContainer packet, NetworkMarker marker, boolean filters)
+			throws InvocationTargetException;
+
+	/**
+	 * Send a wire packet to the given player.
+	 * @param receiver - the receiver.
+	 * @param id - packet id.
+	 * @param bytes - packet bytes.
+	 * @throws InvocationTargetException if an error occured when sending the packet.
+	 */
+	public void sendWirePacket(Player receiver, int id, byte[] bytes) throws InvocationTargetException;
+
+	/**
+	 * Send a wire packet to the given player.
+	 * @param receiver - the receiver.
+	 * @param packet - packet to send.
+	 * @throws InvocationTargetException if an error occured when sending the packet.
+	 */
+	public void sendWirePacket(Player receiver, WirePacket packet) throws InvocationTargetException;
+
+	/**
+	 * Simulate recieving a certain packet from a given player.
+	 * @param sender - the sender.
+	 * @param packet - the packet that was sent.
+	 * @throws InvocationTargetException If the reflection machinery failed.
+	 * @throws IllegalAccessException If the underlying method caused an error.
+	 */
+	public void recieveClientPacket(Player sender, PacketContainer packet)
+			throws IllegalAccessException, InvocationTargetException;
+
+	/**
+	 * Simulate recieving a certain packet from a given player.
+	 * @param sender - the sender.
+	 * @param packet - the packet that was sent.
+	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
+	 * @throws InvocationTargetException If the reflection machinery failed.
+	 * @throws IllegalAccessException If the underlying method caused an error.
+	 */
+	public void recieveClientPacket(Player sender, PacketContainer packet, boolean filters)
+			throws IllegalAccessException, InvocationTargetException;
+	
+	/**
+	 * Simulate recieving a certain packet from a given player.
+	 * @param sender - the sender.
+	 * @param packet - the packet that was sent.
+	 * @param marker - the network marker to use.
+	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
+	 * @throws InvocationTargetException If the reflection machinery failed.
+	 * @throws IllegalAccessException If the underlying method caused an error.
+	 */
+	public void recieveClientPacket(Player sender, PacketContainer packet, NetworkMarker marker, boolean filters)
+			throws IllegalAccessException, InvocationTargetException;
+}

modules/API/src/main/java/com/comphenix/protocol/PacketTypeLookup.java

@@ -0,0 +1,187 @@
+package com.comphenix.protocol;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.comphenix.protocol.PacketType.Protocol;
+import com.comphenix.protocol.PacketType.Sender;
+import com.comphenix.protocol.collections.IntegerMap;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+
+/**
+ * Retrieve a packet type based on its version and ID, optionally with protocol and sender too.
+ * @author Kristian
+ */
+class PacketTypeLookup {
+	public static class ProtocolSenderLookup {
+		// Unroll lookup for performance reasons
+		public final IntegerMap<PacketType> HANDSHAKE_CLIENT = IntegerMap.newMap();
+		public final IntegerMap<PacketType> HANDSHAKE_SERVER = IntegerMap.newMap();
+		public final IntegerMap<PacketType> GAME_CLIENT = IntegerMap.newMap();
+		public final IntegerMap<PacketType> GAME_SERVER = IntegerMap.newMap();
+		public final IntegerMap<PacketType> STATUS_CLIENT = IntegerMap.newMap();
+		public final IntegerMap<PacketType> STATUS_SERVER = IntegerMap.newMap();
+		public final IntegerMap<PacketType> LOGIN_CLIENT = IntegerMap.newMap();
+		public final IntegerMap<PacketType> LOGIN_SERVER = IntegerMap.newMap();
+		
+		/**
+		 * Retrieve the correct integer map for a specific protocol and sender.
+		 * @param protocol - the protocol.
+		 * @param sender - the sender.
+		 * @return The integer map of packets.
+		 */
+		public IntegerMap<PacketType> getMap(Protocol protocol, Sender sender) {
+			switch (protocol) {
+				case HANDSHAKING: 
+					return sender == Sender.CLIENT ? HANDSHAKE_CLIENT : HANDSHAKE_SERVER;
+				case PLAY:
+					return sender == Sender.CLIENT ? GAME_CLIENT : GAME_SERVER;
+				case STATUS:
+					return sender == Sender.CLIENT ? STATUS_CLIENT : STATUS_SERVER;
+				case LOGIN:
+					return sender == Sender.CLIENT ? LOGIN_CLIENT : LOGIN_SERVER;
+				default:
+					throw new IllegalArgumentException("Unable to find protocol " + protocol);
+			}
+		}
+	}
+
+	public static class ClassLookup {
+		// Unroll lookup for performance reasons
+		public final Map<String, PacketType> HANDSHAKE_CLIENT = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> HANDSHAKE_SERVER = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> GAME_CLIENT = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> GAME_SERVER = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> STATUS_CLIENT = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> STATUS_SERVER = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> LOGIN_CLIENT = new ConcurrentHashMap<String, PacketType>();
+		public final Map<String, PacketType> LOGIN_SERVER = new ConcurrentHashMap<String, PacketType>();
+		
+		/**
+		 * Retrieve the correct integer map for a specific protocol and sender.
+		 * @param protocol - the protocol.
+		 * @param sender - the sender.
+		 * @return The integer map of packets.
+		 */
+		public Map<String, PacketType> getMap(Protocol protocol, Sender sender) {
+			switch (protocol) {
+				case HANDSHAKING: 
+					return sender == Sender.CLIENT ? HANDSHAKE_CLIENT : HANDSHAKE_SERVER;
+				case PLAY:
+					return sender == Sender.CLIENT ? GAME_CLIENT : GAME_SERVER;
+				case STATUS:
+					return sender == Sender.CLIENT ? STATUS_CLIENT : STATUS_SERVER;
+				case LOGIN:
+					return sender == Sender.CLIENT ? LOGIN_CLIENT : LOGIN_SERVER;
+				default:
+					throw new IllegalArgumentException("Unable to find protocol " + protocol);
+			}
+		}
+	}
+	
+	// Packet IDs from 1.6.4 and below
+	private final IntegerMap<PacketType> legacyLookup = new IntegerMap<PacketType>();
+	private final IntegerMap<PacketType> serverLookup = new IntegerMap<PacketType>();
+	private final IntegerMap<PacketType> clientLookup = new IntegerMap<PacketType>();
+	
+	// Packets for 1.7.2
+	private final ProtocolSenderLookup idLookup = new ProtocolSenderLookup();
+
+	// Packets for 1.8+
+	private final ClassLookup classLookup = new ClassLookup();
+
+	// Packets based on name
+	private final Multimap<String, PacketType> nameLookup = HashMultimap.create();
+
+	/**
+	 * Add a collection of packet types to the lookup.
+	 * @param types - the types to add.
+	 */
+	public PacketTypeLookup addPacketTypes(Iterable<? extends PacketType> types) {
+		Preconditions.checkNotNull(types, "types cannot be NULL");
+		
+		for (PacketType type : types) {
+			int legacy = type.getLegacyId();
+			
+			// Skip unknown legacy packets
+			if (legacy != PacketType.UNKNOWN_PACKET) {
+				if (type.isServer())
+					serverLookup.put(type.getLegacyId(), type);
+				if (type.isClient())
+					clientLookup.put(type.getLegacyId(), type);
+				legacyLookup.put(type.getLegacyId(), type);
+			}
+			// Skip unknown current packets
+			if (type.getCurrentId() != PacketType.UNKNOWN_PACKET) {
+				idLookup.getMap(type.getProtocol(), type.getSender()).put(type.getCurrentId(), type);
+				classLookup.getMap(type.getProtocol(), type.getSender()).put(type.getClassNames()[0], type);
+			}
+			nameLookup.put(type.name(), type);
+		}
+		return this;
+	}
+	
+	/**
+	 * Retrieve a packet type from a legacy (1.6.4 and below) packet ID.
+	 * @param packetId - the legacy packet ID.
+	 * @return The corresponding packet type, or NULL if not found.
+	 */
+	public PacketType getFromLegacy(int packetId) {
+		return legacyLookup.get(packetId);
+	}
+	
+	/**
+	 * Retrieve an unmodifiable view of all the packet types with this name.
+	 * @param name - the name.
+	 * @return The packet types, usually one.
+	 */
+	public Collection<PacketType> getFromName(String name) {
+		return Collections.unmodifiableCollection(nameLookup.get(name));
+	}
+	
+	/**
+	 * Retrieve a packet type from a legacy (1.6.4 and below) packet ID.
+	 * @param packetId - the legacy packet ID.
+	 * @param preference - which packet type to look for first.
+	 * @return The corresponding packet type, or NULL if not found.
+	 */
+	public PacketType getFromLegacy(int packetId, Sender preference) {	
+		if (preference == Sender.CLIENT)
+			return getFirst(packetId, clientLookup, serverLookup);
+		else
+			return getFirst(packetId, serverLookup, clientLookup);
+	}
+	
+	// Helper method for looking up in two sets
+	private <T> T getFirst(int packetId, IntegerMap<T> first, IntegerMap<T> second) {
+		if (first.containsKey(packetId))
+			return first.get(packetId);
+		else
+			return second.get(packetId);
+	}
+	
+	/**
+	 * Retrieve a packet type from a protocol, sender and packet ID.
+	 * @param protocol - the current protocol.
+	 * @param sender - the sender.
+	 * @param packetId - the packet ID.
+	 * @return The corresponding packet type, or NULL if not found.
+	 * @deprecated IDs are no longer reliable
+	 */
+	@Deprecated
+	public PacketType getFromCurrent(Protocol protocol, Sender sender, int packetId) {
+		return idLookup.getMap(protocol, sender).get(packetId);
+	}
+
+	public PacketType getFromCurrent(Protocol protocol, Sender sender, String name) {
+		return classLookup.getMap(protocol, sender).get(name);
+	}
+
+	public ClassLookup getClassLookup() {
+		return classLookup;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/Packets.java

@@ -1,198 +1,300 @@
-package com.comphenix.protocol;
-
-import com.comphenix.protocol.reflect.IntEnum;
-
-/**
- * List of known packet IDs since 1.3.2.
- * 
- * @author Kristian
- */
-public final class Packets {
-	
-	/**
-	 * List of packets sent only by the server.
-	 * @author Kristian
-	 */
-	public static final class Server extends IntEnum {
-		/**
-		 * The singleton instance. Can also be retrieved from the parent class.
-		 */
-		private static Server INSTANCE = new Server();
-		
-		public static final int KEEP_ALIVE = 0;
-		public static final int LOGIN = 1;
-		public static final int CHAT = 3;
-		public static final int UPDATE_TIME = 4;
-		public static final int ENTITY_EQUIPMENT = 5;
-		public static final int SPAWN_POSITION = 6;
-		public static final int UPDATE_HEALTH = 8;
-		public static final int RESPAWN = 9;
-		public static final int FLYING = 10;
-		public static final int PLAYER_POSITION = 11;
-		public static final int PLAYER_LOOK = 12;
-		public static final int PLAYER_LOOK_MOVE = 13;
-		public static final int ENTITY_LOCATION_ACTION = 17;
-		public static final int ARM_ANIMATION = 18;
-		public static final int NAMED_ENTITY_SPAWN = 20;
-		public static final int PICKUP_SPAWN = 21;
-		public static final int COLLECT = 22;
-		public static final int VEHICLE_SPAWN = 23;
-		public static final int MOB_SPAWN = 24;
-		public static final int ENTITY_PAINTING = 25;
-		public static final int ADD_EXP_ORB = 26;
-		public static final int ENTITY_VELOCITY = 28;
-		public static final int DESTROY_ENTITY = 29;
-		public static final int ENTITY = 30;
-		public static final int REL_ENTITY_MOVE = 31;
-		public static final int ENTITY_LOOK = 32;
-		public static final int REL_ENTITY_MOVE_LOOK = 33;
-		public static final int ENTITY_TELEPORT = 34;
-		public static final int ENTITY_HEAD_ROTATION = 35;
-		public static final int ENTITY_STATUS = 38;
-		public static final int ATTACH_ENTITY = 39;
-		public static final int ENTITY_METADATA = 40;
-		public static final int MOB_EFFECT = 41;
-		public static final int REMOVE_MOB_EFFECT = 42;
-		public static final int SET_EXPERIENCE = 43;
-		public static final int MAP_CHUNK = 51;
-		public static final int MULTI_BLOCK_CHANGE = 52;
-		public static final int BLOCK_CHANGE = 53;
-		public static final int PLAY_NOTE_BLOCK = 54;
-		public static final int BLOCK_BREAK_ANIMATION = 55;
-		public static final int MAP_CHUNK_BULK = 56;
-		public static final int EXPLOSION = 60;
-		public static final int WORLD_EVENT = 61;
-		public static final int NAMED_SOUND_EFFECT = 62;
-		public static final int BED = 70;
-		public static final int WEATHER = 71;
-		public static final int OPEN_WINDOW = 100;
-		public static final int CLOSE_WINDOW = 101;
-		public static final int SET_SLOT = 103;
-		public static final int WINDOW_ITEMS = 104;
-		public static final int CRAFT_PROGRESS_BAR = 105;
-		public static final int TRANSACTION = 106;
-		public static final int SET_CREATIVE_SLOT = 107;
-		public static final int UPDATE_SIGN = 130;
-		public static final int ITEM_DATA = 131;
-		public static final int TILE_ENTITY_DATA = 132;
-		public static final int STATISTIC = 200;
-		public static final int PLAYER_INFO = 201;
-		public static final int ABILITIES = 202;
-		public static final int TAB_COMPLETE = 203;
-		public static final int CUSTOM_PAYLOAD = 250;
-		public static final int KEY_RESPONSE = 252;
-		public static final int KEY_REQUEST = 253;
-		public static final int KICK_DISCONNECT = 255;
-		
-		/**
-		 * A registry that parses between names and packet IDs.
-		 * @return The current server registry.
-		 */
-		public static Server getRegistry() {
-			return INSTANCE;
-		}
-		
-		// We only allow a single instance of this class
-	    private Server() {
-			super();
-		}
-	}
-	
-	/**
-	 * List of packets sent by the client.
-	 * @author Kristian
-	 */
-	public static class Client extends IntEnum {
-		/**
-		 * The singleton instance. Can also be retrieved from the parent class.
-		 */
-		private static Client INSTANCE = new Client();
-		
-		public static final int KEEP_ALIVE = 0;
-		public static final int LOGIN = 1;
-		public static final int HANDSHAKE = 2;
-		public static final int CHAT = 3;
-		public static final int USE_ENTITY = 7;
-		public static final int RESPAWN = 9;
-		public static final int FLYING = 10;
-		public static final int PLAYER_POSITION = 11;
-		public static final int PLAYER_LOOK = 12;
-		public static final int PLAYER_LOOK_MOVE = 13;
-		public static final int BLOCK_DIG = 14;
-		public static final int PLACE = 15;
-		public static final int BLOCK_ITEM_SWITCH = 16;
-		public static final int ARM_ANIMATION = 18;
-		public static final int ENTITY_ACTION = 19;
-		public static final int CLOSE_WINDOW = 101;
-		public static final int WINDOW_CLICK = 102;
-		public static final int TRANSACTION = 106;
-		public static final int SET_CREATIVE_SLOT = 107;
-		public static final int BUTTON_CLICK = 108;
-		public static final int UPDATE_SIGN = 130;
-		public static final int ABILITIES = 202;
-		public static final int TAB_COMPLETE = 203;
-		public static final int LOCALE_AND_VIEW_DISTANCE = 204;
-		public static final int CLIENT_COMMAND = 205;
-		public static final int CUSTOM_PAYLOAD = 250;
-		public static final int KEY_RESPONSE = 252;
-		public static final int GET_INFO = 254;
-		public static final int KICK_DISCONNECT = 255;
-		
-		/**
-		 * A registry that parses between names and packet IDs.
-		 * @return The current client registry.
-		 */
-		public static Client getRegistry() {
-			return INSTANCE;
-		}
-		
-		// Like above
-		private Client() {
-			super();
-		}
-	}
-	
-	/**
-	 * A registry that parses between names and packet IDs.
-	 * @return The current client registry.
-	 */
-	public static Server getServerRegistry() {
-		return Server.getRegistry();
-	}
-
-	/**
-	 * A registry that parses between names and packet IDs.
-	 * @return The current server registry.
-	 */
-	public static Client getClientRegistry() {
-		return Client.INSTANCE;
-	}
-	
-	/**
-	 * Find a packet by name. Must be capitalized and use underscores.
-	 * @param name - name of packet to find.
-	 * @return The packet ID found.
-	 */
-	public static int valueOf(String name) {
-		Integer serverAttempt = Server.INSTANCE.valueOf(name);
-		
-		if (serverAttempt != null)
-			return serverAttempt;
-		else
-			return Client.INSTANCE.valueOf(name);
-	}
-	
-	/**
-	 * Retrieves the name of a packet.
-	 * @param packetID - packet to retrieve name.
-	 * @return The name, or NULL if unable to find such a packet.
-	 */
-	public static String getDeclaredName(int packetID) {
-		String serverAttempt = Server.INSTANCE.getDeclaredName(packetID);
-		
-		if (serverAttempt != null)
-			return serverAttempt;
-		else
-			return Client.INSTANCE.getDeclaredName(packetID);
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol;
+
+import com.comphenix.protocol.reflect.IntEnum;
+
+/**
+ * List of known packet IDs since 1.3.2.
+ * <p>
+ * Deprecated: Use {@link PacketType} instead.
+ * @author Kristian
+ */
+@Deprecated
+public final class Packets {
+	
+	/**
+	 * The highest possible packet ID. It's unlikely that this value will ever change.
+	 */
+	public static final int MAXIMUM_PACKET_ID = 255;
+	
+	/**
+	 * The maximum number of unique packet IDs. It's unlikely this will ever change.
+	 */
+	public static final int PACKET_COUNT = 256;
+	
+	/**
+	 * List of packets sent only by the server.
+	 * <p>
+	 * Deprecated: Use {@link PacketType} instead.
+	 * @author Kristian
+	 */
+	@Deprecated
+	public static final class Server extends IntEnum {
+		/**
+		 * The singleton instance. Can also be retrieved from the parent class.
+		 */
+		private static Server INSTANCE = new Server();
+		
+		public static final int KEEP_ALIVE = 0;
+		public static final int LOGIN = 1;
+		public static final int CHAT = 3;
+		public static final int UPDATE_TIME = 4;
+		public static final int ENTITY_EQUIPMENT = 5;
+		public static final int SPAWN_POSITION = 6;
+		public static final int UPDATE_HEALTH = 8;
+		public static final int RESPAWN = 9;
+		public static final int FLYING = 10;
+		public static final int PLAYER_POSITION = 11;
+		public static final int PLAYER_LOOK = 12;
+		public static final int PLAYER_LOOK_MOVE = 13;
+		/**
+		 * Made bi-directional in 1.4.6.
+		 */
+		public static final int BLOCK_ITEM_SWITCH = 16;
+		public static final int ENTITY_LOCATION_ACTION = 17;
+		public static final int ARM_ANIMATION = 18;
+		public static final int NAMED_ENTITY_SPAWN = 20;
+		/**
+		 * Removed in 1.4.6 and replaced with VEHICLE_SPAWN. 
+		 * @see <a href="http://www.wiki.vg/Protocol_History#2012-12-20">Protocol History - MinecraftCoalition</a>
+		 */
+		@Deprecated()
+		public static final int PICKUP_SPAWN = 21;
+		public static final int COLLECT = 22;
+		public static final int VEHICLE_SPAWN = 23;
+		public static final int MOB_SPAWN = 24;
+		public static final int ENTITY_PAINTING = 25;
+		public static final int ADD_EXP_ORB = 26;
+		public static final int ENTITY_VELOCITY = 28;
+		public static final int DESTROY_ENTITY = 29;
+		public static final int ENTITY = 30;
+		public static final int REL_ENTITY_MOVE = 31;
+		public static final int ENTITY_LOOK = 32;
+		public static final int REL_ENTITY_MOVE_LOOK = 33;
+		public static final int ENTITY_TELEPORT = 34;
+		public static final int ENTITY_HEAD_ROTATION = 35;
+		public static final int ENTITY_STATUS = 38;
+		public static final int ATTACH_ENTITY = 39;
+		
+		/**
+		 * Sent when an entities DataWatcher is updated.
+		 * <p>
+		 * Remember to clone the packet if you are modifying it.
+		 */
+		public static final int ENTITY_METADATA = 40;
+		public static final int MOB_EFFECT = 41;
+		public static final int REMOVE_MOB_EFFECT = 42;
+		public static final int SET_EXPERIENCE = 43;
+		public static final int UPDATE_ATTRIBUTES = 44;
+		public static final int MAP_CHUNK = 51;
+		public static final int MULTI_BLOCK_CHANGE = 52;
+		public static final int BLOCK_CHANGE = 53;
+		public static final int PLAY_NOTE_BLOCK = 54;
+		public static final int BLOCK_BREAK_ANIMATION = 55;
+		public static final int MAP_CHUNK_BULK = 56;
+		public static final int EXPLOSION = 60;
+		public static final int WORLD_EVENT = 61;
+		public static final int NAMED_SOUND_EFFECT = 62;
+		public static final int WORLD_PARTICLES = 63;
+		public static final int BED = 70;
+		public static final int WEATHER = 71;
+		public static final int OPEN_WINDOW = 100;
+		public static final int CLOSE_WINDOW = 101;
+		public static final int SET_SLOT = 103;
+		public static final int WINDOW_ITEMS = 104;
+		public static final int CRAFT_PROGRESS_BAR = 105;
+		public static final int TRANSACTION = 106;
+		public static final int SET_CREATIVE_SLOT = 107;
+		public static final int UPDATE_SIGN = 130;
+		public static final int ITEM_DATA = 131;
+		
+		/**
+		 * Sent the first time a tile entity (chest inventory, etc.) is withing range of the player, or has been updated.
+		 * <p>
+		 * Remember to clone the packet if you are modifying it.
+		 */
+		public static final int TILE_ENTITY_DATA = 132;
+		public static final int OPEN_TILE_ENTITY = 133;
+		public static final int STATISTIC = 200;
+		public static final int PLAYER_INFO = 201;
+		public static final int ABILITIES = 202;
+		public static final int TAB_COMPLETE = 203;
+		public static final int SCOREBOARD_OBJECTIVE = 206;
+		public static final int UPDATE_SCORE  = 207;
+		public static final int DISPLAY_SCOREBOARD = 208;
+		public static final int TEAMS = 209;
+		public static final int CUSTOM_PAYLOAD = 250;
+		public static final int KEY_RESPONSE = 252;
+		public static final int KEY_REQUEST = 253;
+		public static final int KICK_DISCONNECT = 255;
+		
+		/**
+		 * This packet was introduced in 1.7.2.
+		 */
+		public static final int PING_TIME = 230;
+		
+		/**
+		 * This packet was introduced in 1.7.2.
+		 */
+		public static final int LOGIN_SUCCESS = 232;
+		
+		/**
+		 * A registry that parses between names and packet IDs.
+		 * @return The current server registry.
+		 */
+		public static Server getRegistry() {
+			return INSTANCE;
+		}
+
+		// We only allow a single instance of this class
+	    private Server() {
+			super();
+		}
+	}
+	
+	/**
+	 * List of packets sent by the client.
+	 * <p>
+	 * Deprecated: Use {@link PacketType} instead.
+	 * @author Kristian
+	 */
+	@Deprecated
+	public static class Client extends IntEnum {
+		/**
+		 * The singleton instance. Can also be retrieved from the parent class.
+		 */
+		private static Client INSTANCE = new Client();
+		
+		public static final int KEEP_ALIVE = 0;
+		public static final int LOGIN = 1;
+		public static final int HANDSHAKE = 2;
+		public static final int CHAT = 3;
+		public static final int USE_ENTITY = 7;
+		
+		/**
+		 * Since 1.3.1, the client no longer sends a respawn packet. Moved to CLIENT_COMMAND.
+		 */
+		@Deprecated
+		public static final int RESPAWN = 9;
+		
+		public static final int FLYING = 10;
+		public static final int PLAYER_POSITION = 11;
+		public static final int PLAYER_LOOK = 12;
+		public static final int PLAYER_LOOK_MOVE = 13;
+		public static final int BLOCK_DIG = 14;
+		public static final int PLACE = 15;
+		public static final int BLOCK_ITEM_SWITCH = 16;
+		public static final int ARM_ANIMATION = 18;
+		public static final int ENTITY_ACTION = 19;
+		public static final int PLAYER_INPUT = 27;
+		public static final int CLOSE_WINDOW = 101;
+		public static final int WINDOW_CLICK = 102;
+		public static final int TRANSACTION = 106;
+		public static final int SET_CREATIVE_SLOT = 107;
+		public static final int BUTTON_CLICK = 108;
+		public static final int UPDATE_SIGN = 130;
+		public static final int ABILITIES = 202;
+		public static final int TAB_COMPLETE = 203;
+		public static final int LOCALE_AND_VIEW_DISTANCE = 204;
+		public static final int CLIENT_COMMAND = 205;
+		public static final int CUSTOM_PAYLOAD = 250;
+		public static final int KEY_RESPONSE = 252;
+		public static final int GET_INFO = 254;
+		public static final int KICK_DISCONNECT = 255;
+		
+		/**
+		 * This packet was introduced in 1.7.2.
+		 */
+		public static final int PING_TIME = 230;
+		
+		/**
+		 * This packet was introduced in 1.7.2.
+		 */
+		public static final int LOGIN_START = 231;
+		
+		/**
+		 * A registry that parses between names and packet IDs.
+		 * @return The current client registry.
+		 */
+		public static Client getRegistry() {
+			return INSTANCE;
+		}
+
+		// Like above
+		private Client() {
+			super();
+		}
+	}
+	
+	/**
+	 * A registry that parses between names and packet IDs.
+	 * <p>
+	 * Deprecated: Use {@link PacketType} instead.
+	 * @return The current client registry.
+	 */
+	@Deprecated
+	public static Server getServerRegistry() {
+		return Server.getRegistry();
+	}
+
+	/**
+	 * A registry that parses between names and packet IDs.
+	 * <p>
+	 * Deprecated: Use {@link PacketType} instead.
+	 * @return The current server registry.
+	 */
+	@Deprecated
+	public static Client getClientRegistry() {
+		return Client.INSTANCE;
+	}
+	
+	/**
+	 * Find a packet by name. Must be capitalized and use underscores.
+	 * <p>
+	 * Deprecated: Use {@link PacketType} instead.
+	 * @param name - name of packet to find.
+	 * @return The packet ID found.
+	 */
+	@Deprecated
+	public static int valueOf(String name) {
+		Integer serverAttempt = Server.INSTANCE.valueOf(name);
+		
+		if (serverAttempt != null)
+			return serverAttempt;
+		else
+			return Client.INSTANCE.valueOf(name);
+	}
+	
+	/**
+	 * Retrieves the name of a packet.
+	 * <p>
+	 * Deprecated: Use {@link PacketType} instead.
+	 * @param packetID - packet to retrieve name.
+	 * @return The name, or NULL if unable to find such a packet.
+	 */
+	@Deprecated
+	public static String getDeclaredName(int packetID) {
+		String serverAttempt = Server.INSTANCE.getDeclaredName(packetID);
+		
+		if (serverAttempt != null)
+			return serverAttempt;
+		else
+			return Client.INSTANCE.getDeclaredName(packetID);
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/ProtocolConfig.java

@@ -0,0 +1,500 @@
+/**
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+package com.comphenix.protocol;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.configuration.Configuration;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.injector.PlayerInjectHooks;
+import com.google.common.base.Charsets;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.io.Files;
+
+/**
+ * Represents the configuration of ProtocolLib.
+ * 
+ * @author Kristian
+ */
+public class ProtocolConfig {
+	private static final String LAST_UPDATE_FILE = "lastupdate";
+
+	private static final String SECTION_GLOBAL = "global";
+	private static final String SECTION_AUTOUPDATER = "auto updater";
+
+	private static final String METRICS_ENABLED = "metrics";
+
+	private static final String IGNORE_VERSION_CHECK = "ignore version check";
+	private static final String BACKGROUND_COMPILER_ENABLED = "background compiler";
+
+	private static final String DEBUG_MODE_ENABLED = "debug";
+	private static final String DETAILED_ERROR = "detailed error";
+	private static final String INJECTION_METHOD = "injection method";
+
+	private static final String SCRIPT_ENGINE_NAME = "script engine";
+	private static final String SUPPRESSED_REPORTS = "suppressed reports";
+
+	private static final String UPDATER_NOTIFY = "notify";
+	private static final String UPDATER_DOWNLAD = "download";
+	private static final String UPDATER_DELAY = "delay";
+
+	// Defaults
+	private static final long DEFAULT_UPDATER_DELAY = 43200;
+
+	private Plugin plugin;
+	private Configuration config;
+	private boolean loadingSections;
+
+	private ConfigurationSection global;
+	private ConfigurationSection updater;
+
+	// Last update time
+	private long lastUpdateTime;
+	private boolean configChanged;
+	private boolean valuesChanged;
+
+	// Modifications
+	private int modCount;
+
+	public ProtocolConfig(Plugin plugin) {
+		this.plugin = plugin;
+		reloadConfig();
+	}
+
+	/**
+	 * Reload configuration file.
+	 */
+	public void reloadConfig() {
+		// Reset
+		configChanged = false;
+		valuesChanged = false;
+		modCount++;
+
+		this.config = plugin.getConfig();
+		this.lastUpdateTime = loadLastUpdate();
+		loadSections(!loadingSections);
+	}
+
+	/**
+	 * Load the last update time stamp from the file system.
+	 * 
+	 * @return Last update time stamp.
+	 */
+	private long loadLastUpdate() {
+		File dataFile = getLastUpdateFile();
+
+		if (dataFile.exists()) {
+			try {
+				return Long.parseLong(Files.toString(dataFile, Charsets.UTF_8));
+			} catch (NumberFormatException e) {
+				plugin.getLogger().warning("Cannot parse " + dataFile + " as a number.");
+			} catch (IOException e) {
+				plugin.getLogger().warning("Cannot read " + dataFile);
+			}
+		}
+		// Default last update
+		return 0;
+	}
+
+	/**
+	 * Store the given time stamp.
+	 * 
+	 * @param value - time stamp to store.
+	 */
+	private void saveLastUpdate(long value) {
+		File dataFile = getLastUpdateFile();
+
+		// The data folder must exist
+		dataFile.getParentFile().mkdirs();
+
+		if (dataFile.exists())
+			dataFile.delete();
+
+		try {
+			Files.write(Long.toString(value), dataFile, Charsets.UTF_8);
+		} catch (IOException e) {
+			throw new RuntimeException("Cannot write " + dataFile, e);
+		}
+	}
+
+	/**
+	 * Retrieve the file that is used to store the update time stamp.
+	 * 
+	 * @return File storing the update time stamp.
+	 */
+	private File getLastUpdateFile() {
+		return new File(plugin.getDataFolder(), LAST_UPDATE_FILE);
+	}
+
+	/**
+	 * Load data sections.
+	 * 
+	 * @param copyDefaults - whether or not to copy configuration defaults.
+	 */
+	private void loadSections(boolean copyDefaults) {
+		if (config != null) {
+			global = config.getConfigurationSection(SECTION_GLOBAL);
+		}
+		if (global != null) {
+			updater = global.getConfigurationSection(SECTION_AUTOUPDATER);
+		}
+
+		// Automatically copy defaults
+		if (copyDefaults && (!getFile().exists() || global == null || updater == null)) {
+			loadingSections = true;
+
+			if (config != null)
+				config.options().copyDefaults(true);
+			plugin.saveDefaultConfig();
+			plugin.reloadConfig();
+			loadingSections = false;
+
+			// Inform the user
+			plugin.getLogger().info("Created default configuration.");
+		}
+	}
+
+	/**
+	 * Set a particular configuration key value pair.
+	 * 
+	 * @param section - the configuration root.
+	 * @param path - the path to the key.
+	 * @param value - the value to set.
+	 */
+	private void setConfig(ConfigurationSection section, String path, Object value) {
+		configChanged = true;
+		section.set(path, value);
+	}
+
+	@SuppressWarnings("unchecked")
+	private <T> T getGlobalValue(String path, T def) {
+		try {
+			return (T) global.get(path, def);
+		} catch (Throwable ex) {
+			return def;
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private <T> T getUpdaterValue(String path, T def) {
+		try {
+			return (T) updater.get(path, def);
+		} catch (Throwable ex) {
+			return def;
+		}
+	}
+
+	/**
+	 * Retrieve a reference to the configuration file.
+	 * 
+	 * @return Configuration file on disk.
+	 */
+	public File getFile() {
+		return new File(plugin.getDataFolder(), "config.yml");
+	}
+
+	/**
+	 * Determine if detailed error reporting is enabled. Default FALSE.
+	 * 
+	 * @return TRUE if it is enabled, FALSE otherwise.
+	 */
+	public boolean isDetailedErrorReporting() {
+		return getGlobalValue(DETAILED_ERROR, false);
+	}
+
+	/**
+	 * Set whether or not detailed error reporting is enabled.
+	 * 
+	 * @param value - TRUE if it is enabled, FALSE otherwise.
+	 */
+	public void setDetailedErrorReporting(boolean value) {
+		global.set(DETAILED_ERROR, value);
+	}
+
+	/**
+	 * Retrieve whether or not ProtocolLib should determine if a new version has been released.
+	 * 
+	 * @return TRUE if it should do this automatically, FALSE otherwise.
+	 */
+	public boolean isAutoNotify() {
+		return getUpdaterValue(UPDATER_NOTIFY, true);
+	}
+
+	/**
+	 * Set whether or not ProtocolLib should determine if a new version has been released.
+	 * 
+	 * @param value - TRUE to do this automatically, FALSE otherwise.
+	 */
+	public void setAutoNotify(boolean value) {
+		setConfig(updater, UPDATER_NOTIFY, value);
+		modCount++;
+	}
+
+	/**
+	 * Retrieve whether or not ProtocolLib should automatically download the new version.
+	 * 
+	 * @return TRUE if it should, FALSE otherwise.
+	 */
+	public boolean isAutoDownload() {
+		return updater != null && getUpdaterValue(UPDATER_DOWNLAD, true);
+	}
+
+	/**
+	 * Set whether or not ProtocolLib should automatically download the new version.
+	 * 
+	 * @param value - TRUE if it should. FALSE otherwise.
+	 */
+	public void setAutoDownload(boolean value) {
+		setConfig(updater, UPDATER_DOWNLAD, value);
+		modCount++;
+	}
+
+	/**
+	 * Determine whether or not debug mode is enabled.
+	 * <p>
+	 * This grants access to the filter command.
+	 * 
+	 * @return TRUE if it is, FALSE otherwise.
+	 */
+	public boolean isDebug() {
+		return getGlobalValue(DEBUG_MODE_ENABLED, false);
+	}
+
+	/**
+	 * Set whether or not debug mode is enabled.
+	 * 
+	 * @param value - TRUE if it is enabled, FALSE otherwise.
+	 */
+	public void setDebug(boolean value) {
+		setConfig(global, DEBUG_MODE_ENABLED, value);
+		modCount++;
+	}
+
+	/**
+	 * Retrieve an immutable list of every suppressed report type.
+	 * 
+	 * @return Every suppressed report type.
+	 */
+	public ImmutableList<String> getSuppressedReports() {
+		return ImmutableList.copyOf(getGlobalValue(SUPPRESSED_REPORTS, new ArrayList<String>()));
+	}
+
+	/**
+	 * Set the list of suppressed report types,
+	 * 
+	 * @param reports - suppressed report types.
+	 */
+	public void setSuppressedReports(List<String> reports) {
+		global.set(SUPPRESSED_REPORTS, Lists.newArrayList(reports));
+		modCount++;
+	}
+
+	/**
+	 * Retrieve the amount of time to wait until checking for a new update.
+	 * 
+	 * @return The amount of time to wait.
+	 */
+	public long getAutoDelay() {
+		// Note that the delay must be greater than 59 seconds
+		return Math.max(getUpdaterValue(UPDATER_DELAY, 0), DEFAULT_UPDATER_DELAY);
+	}
+
+	/**
+	 * Set the amount of time to wait until checking for a new update.
+	 * <p>
+	 * This time must be greater than 59 seconds.
+	 * 
+	 * @param delaySeconds - the amount of time to wait.
+	 */
+	public void setAutoDelay(long delaySeconds) {
+		// Silently fix the delay
+		if (delaySeconds < DEFAULT_UPDATER_DELAY)
+			delaySeconds = DEFAULT_UPDATER_DELAY;
+		setConfig(updater, UPDATER_DELAY, delaySeconds);
+		modCount++;
+	}
+
+	/**
+	 * The version of Minecraft to ignore the built-in safety feature.
+	 * 
+	 * @return The version to ignore ProtocolLib's satefy.
+	 */
+	public String getIgnoreVersionCheck() {
+		return getGlobalValue(IGNORE_VERSION_CHECK, "");
+	}
+
+	/**
+	 * Sets under which version of Minecraft the version safety feature will be ignored.
+	 * <p>
+	 * This is useful if a server operator has tested and verified that a version of ProtocolLib works, but doesn't want or can't upgrade to a newer version.
+	 * 
+	 * @param ignoreVersion - the version of Minecraft where the satefy will be disabled.
+	 */
+	public void setIgnoreVersionCheck(String ignoreVersion) {
+		setConfig(global, IGNORE_VERSION_CHECK, ignoreVersion);
+		modCount++;
+	}
+
+	/**
+	 * Retrieve whether or not metrics is enabled.
+	 * 
+	 * @return TRUE if metrics is enabled, FALSE otherwise.
+	 */
+	public boolean isMetricsEnabled() {
+		return getGlobalValue(METRICS_ENABLED, true);
+	}
+
+	/**
+	 * Set whether or not metrics is enabled.
+	 * <p>
+	 * This setting will take effect next time ProtocolLib is started.
+	 * 
+	 * @param enabled - whether or not metrics is enabled.
+	 */
+	public void setMetricsEnabled(boolean enabled) {
+		setConfig(global, METRICS_ENABLED, enabled);
+		modCount++;
+	}
+
+	/**
+	 * Retrieve whether or not the background compiler for structure modifiers is enabled or not.
+	 * 
+	 * @return TRUE if it is enabled, FALSE otherwise.
+	 */
+	public boolean isBackgroundCompilerEnabled() {
+		return getGlobalValue(BACKGROUND_COMPILER_ENABLED, true);
+	}
+
+	/**
+	 * Set whether or not the background compiler for structure modifiers is enabled or not.
+	 * <p>
+	 * This setting will take effect next time ProtocolLib is started.
+	 * 
+	 * @param enabled - TRUE if is enabled/running, FALSE otherwise.
+	 */
+	public void setBackgroundCompilerEnabled(boolean enabled) {
+		setConfig(global, BACKGROUND_COMPILER_ENABLED, enabled);
+		modCount++;
+	}
+
+	/**
+	 * Retrieve the last time we updated, in seconds since 1970.01.01 00:00.
+	 * 
+	 * @return Last update time.
+	 */
+	public long getAutoLastTime() {
+		return lastUpdateTime;
+	}
+
+	/**
+	 * Set the last time we updated, in seconds since 1970.01.01 00:00.
+	 * <p>
+	 * Note that this is not considered to modify the configuration, so the modification count will not be incremented.
+	 * 
+	 * @param lastTimeSeconds - new last update time.
+	 */
+	public void setAutoLastTime(long lastTimeSeconds) {
+		this.valuesChanged = true;
+		this.lastUpdateTime = lastTimeSeconds;
+	}
+
+	/**
+	 * Retrieve the unique name of the script engine to use for filtering.
+	 * 
+	 * @return Script engine to use.
+	 */
+	public String getScriptEngineName() {
+		return getGlobalValue(SCRIPT_ENGINE_NAME, "JavaScript");
+	}
+
+	/**
+	 * Set the unique name of the script engine to use for filtering.
+	 * <p>
+	 * This setting will take effect next time ProtocolLib is started.
+	 * 
+	 * @param name - name of the script engine to use.
+	 */
+	public void setScriptEngineName(String name) {
+		setConfig(global, SCRIPT_ENGINE_NAME, name);
+		modCount++;
+	}
+
+	/**
+	 * Retrieve the default injection method.
+	 * 
+	 * @return Default method.
+	 */
+	public PlayerInjectHooks getDefaultMethod() {
+		return PlayerInjectHooks.NETWORK_SERVER_OBJECT;
+	}
+
+	/**
+	 * Retrieve the injection method that has been set in the configuration, or use a default value.
+	 * 
+	 * @return Injection method to use.
+	 * @throws IllegalArgumentException If the configuration option is malformed.
+	 */
+	public PlayerInjectHooks getInjectionMethod() throws IllegalArgumentException {
+		String text = global.getString(INJECTION_METHOD);
+
+		// Default hook if nothing has been set
+		PlayerInjectHooks hook = getDefaultMethod();
+
+		if (text != null)
+			hook = PlayerInjectHooks.valueOf(text.toUpperCase().replace(" ", "_"));
+		return hook;
+	}
+
+	/**
+	 * Set the starting injection method to use.
+	 * 
+	 * @return Injection method.
+	 */
+	public void setInjectionMethod(PlayerInjectHooks hook) {
+		setConfig(global, INJECTION_METHOD, hook.name());
+		modCount++;
+	}
+
+	/**
+	 * Retrieve the number of modifications made to this configuration.
+	 * 
+	 * @return The number of modifications.
+	 */
+	public int getModificationCount() {
+		return modCount;
+	}
+
+	/**
+	 * Save the current configuration file.
+	 */
+	public void saveAll() {
+		if (valuesChanged)
+			saveLastUpdate(lastUpdateTime);
+		if (configChanged)
+			plugin.saveConfig();
+
+		// And we're done
+		valuesChanged = false;
+		configChanged = false;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/ProtocolLibrary.java

@@ -0,0 +1,144 @@
+/**
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2016 dmulloy2
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+package com.comphenix.protocol;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.error.BasicErrorReporter;
+import com.comphenix.protocol.error.ErrorReporter;
+import com.google.common.util.concurrent.ListeningScheduledExecutorService;
+
+/**
+ * The main entry point for ProtocolLib.
+ * @author dmulloy2
+ */
+public class ProtocolLibrary {
+	/**
+	 * The minimum version ProtocolLib has been tested with.
+	 */
+	public static final String MINIMUM_MINECRAFT_VERSION = "1.9";
+
+	/**
+	 * The maximum version ProtocolLib has been tested with.
+	 */
+	public static final String MAXIMUM_MINECRAFT_VERSION = "1.9.4";
+
+	/**
+	 * The date (with ISO 8601 or YYYY-MM-DD) when the most recent version (1.9.4) was released.
+	 */
+	public static final String MINECRAFT_LAST_RELEASE_DATE = "2016-05-10";
+
+	/**
+	 * Plugins that are currently incompatible with ProtocolLib.
+	 */
+	public static final List<String> INCOMPATIBLE = Arrays.asList("TagAPI");
+
+	private static Plugin plugin;
+	private static ProtocolConfig config;
+	private static ProtocolManager manager;
+	private static ErrorReporter reporter = new BasicErrorReporter();
+
+	private static ListeningScheduledExecutorService executorAsync;
+	private static ListeningScheduledExecutorService executorSync;
+
+	private static boolean updatesDisabled;
+	private static boolean initialized;
+
+	protected static void init(Plugin plugin, ProtocolConfig config, ProtocolManager manager, ErrorReporter reporter,
+			ListeningScheduledExecutorService executorAsync, ListeningScheduledExecutorService executorSync) {
+		Validate.isTrue(!initialized, "ProtocolLib has already been initialized.");
+		ProtocolLibrary.plugin = plugin;
+		ProtocolLibrary.config = config;
+		ProtocolLibrary.manager = manager;
+		ProtocolLibrary.reporter = reporter;
+		ProtocolLibrary.executorAsync = executorAsync;
+		ProtocolLibrary.executorSync = executorSync;
+		ProtocolLogger.init(plugin);
+		initialized = true;
+	}
+
+	/**
+	 * Gets the ProtocolLib plugin instance.
+	 * @return The plugin instance
+	 */
+	public static Plugin getPlugin() {
+		return plugin;
+	}
+
+	/**
+	 * Gets ProtocolLib's configuration
+	 * @return The config
+	 */
+	public static ProtocolConfig getConfig() {
+		return config;
+	}
+
+	/**
+	 * Retrieves the packet protocol manager.
+	 * @return Packet protocol manager
+	 */
+	public static ProtocolManager getProtocolManager() {
+		return manager;
+	}
+
+	/**
+	 * Retrieve the current error reporter.
+	 * @return Current error reporter.
+	 */
+	public static ErrorReporter getErrorReporter() {
+		return reporter;
+	}
+
+	/**
+	 * Retrieve an executor service for performing asynchronous tasks on the behalf of ProtocolLib.
+	 * <p>
+	 * Note that this service is NULL if ProtocolLib has not been initialized yet.
+	 * @return The executor service, or NULL.
+	 */
+	public static ListeningScheduledExecutorService getExecutorAsync() {
+		return executorAsync;
+	}
+
+	/**
+	 * Retrieve an executor service for performing synchronous tasks (main thread) on the behalf of ProtocolLib.
+	 * <p>
+	 * Note that this service is NULL if ProtocolLib has not been initialized yet.
+	 * @return The executor service, or NULL.
+	 */
+	public static ListeningScheduledExecutorService getExecutorSync() {
+		return executorSync;
+	}
+
+	/**
+	 * Disables the ProtocolLib update checker.
+	 */
+	public static void disableUpdates() {
+		updatesDisabled = true;
+	}
+
+	/**
+	 * Whether or not updates are currently disabled.
+	 * @return True if it is, false if not
+	 */
+	public static boolean updatesDisabled() {
+		return updatesDisabled;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/ProtocolLogger.java

@@ -0,0 +1,63 @@
+/**
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2016 dmulloy2
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+package com.comphenix.protocol;
+
+import java.text.MessageFormat;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.plugin.Plugin;
+
+/**
+ * @author dmulloy2
+ */
+public class ProtocolLogger {
+	private static Logger logger;
+
+	protected static void init(Plugin plugin) {
+		ProtocolLogger.logger = plugin.getLogger();
+	}
+
+	/**
+	 * Logs a message to console with a given level.
+	 * @param level Logging level
+	 * @param message Message to log
+	 * @param args Arguments to format in
+	 */
+	public static void log(Level level, String message, Object... args) {
+		logger.log(level, MessageFormat.format(message, args));
+	}
+
+	/**
+	 * Logs a method to console with the INFO level.
+	 * @param message Message to log
+	 * @param args Arguments to format in
+	 */
+	public static void log(String message, Object... args) {
+		log(Level.INFO, message, args);
+	}
+
+	/**
+	 * Logs a message to console with a given level and exception.
+	 * @param level Logging level
+	 * @param message Message to log
+	 * @param ex Exception to log
+	 */
+	public static void log(Level level, String message, Throwable ex) {
+		logger.log(level, message, ex);
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/ProtocolManager.java

@@ -0,0 +1,285 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.async.AsyncMarker;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.ListeningWhitelist;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketListener;
+import com.comphenix.protocol.injector.PacketConstructor;
+import com.comphenix.protocol.reflect.FieldAccessException;
+import com.comphenix.protocol.utility.MinecraftVersion;
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Represents an API for accessing the Minecraft protocol.
+ * @author Kristian
+ */
+public interface ProtocolManager extends PacketStream {
+	/**
+	 * Retrieve the protocol version of a given player.
+	 * <p>
+	 * This only really makes sense of a server that support clients of multiple Minecraft versions, such as Spigot #1628.
+	 * @param player - the player.
+	 * @return The associated protocol version, or {@link Integer#MIN_VALUE} if unknown.
+	 */
+	public int getProtocolVersion(Player player);
+	
+	/**
+	 * Send a packet to the given player.
+	 * <p>
+	 * Re-sending a previously cancelled packet is discouraged. Use {@link AsyncMarker#incrementProcessingDelay()}
+	 * to delay a packet until a certain condition has been met.
+	 * 
+	 * @param receiver - the receiver.
+	 * @param packet - packet to send.
+	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
+	 * @throws InvocationTargetException - if an error occurred when sending the packet.
+	 */
+	@Override
+	public void sendServerPacket(Player receiver, PacketContainer packet, boolean filters)
+			throws InvocationTargetException;
+	
+	/**
+	 * Simulate receiving a certain packet from a given player.
+	 * <p>
+	 * Receiving a previously cancelled packet is discouraged. Use {@link AsyncMarker#incrementProcessingDelay()}
+	 * to delay a packet until a certain condition has been met.
+	 * 
+	 * @param sender - the sender.
+	 * @param packet - the packet that was sent.
+	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
+	 * @throws InvocationTargetException If the reflection machinery failed.
+	 * @throws IllegalAccessException If the underlying method caused an error.
+	 */
+	@Override
+	public void recieveClientPacket(Player sender, PacketContainer packet, boolean filters)
+			throws IllegalAccessException, InvocationTargetException;
+	
+	/**
+	 * Broadcast a given packet to every connected player on the server.
+	 * @param packet - the packet to broadcast.
+	 * @throws FieldAccessException If we were unable to send the packet due to reflection problems.
+	 */
+	public void broadcastServerPacket(PacketContainer packet);
+	
+	/**
+	 * Broadcast a packet to every player that is receiving information about a given entity.
+	 * <p>
+	 * This is usually every player in the same world within an observable distance. If the entity is a
+	 * player, it will only be included if <i>includeTracker</i> is TRUE.
+	 * @param packet - the packet to broadcast.
+	 * @param entity - the entity whose trackers we will inform.
+	 * @param includeTracker - whether or not to also transmit the packet to the entity, if it is a tracker.
+	 * @throws FieldAccessException If we were unable to send the packet due to reflection problems.
+	 */
+	public void broadcastServerPacket(PacketContainer packet, Entity entity, boolean includeTracker);
+	
+	/**
+	 * Broadcast a packet to every player within the given maximum observer distance.
+	 * @param packet - the packet to broadcast.
+	 * @param origin - the origin to consider when calculating the distance to each observer.
+	 * @param maxObserverDistance - the maximum distance to the origin.
+	 */
+	public void broadcastServerPacket(PacketContainer packet, Location origin, int maxObserverDistance);
+	
+	/**
+	 * Retrieves a list of every registered packet listener.
+	 * @return Every registered packet listener.
+	 */
+	public ImmutableSet<PacketListener> getPacketListeners();
+
+	/**
+	 * Adds a packet listener.
+	 * <p>
+	 * Adding an already registered listener has no effect. If you need to change the packets
+	 * the current listener is observing, you must first remove the packet listener before you
+	 * can register it again.
+	 * @param listener - new packet listener.
+	 */
+	public void addPacketListener(PacketListener listener);
+
+	/**
+	 * Removes a given packet listener.
+	 * <p>
+	 * Attempting to remove a listener that doesn't exist has no effect.
+	 * @param listener - the packet listener to remove.
+	 */
+	public void removePacketListener(PacketListener listener);
+
+	/**
+	 * Removes every listener associated with the given plugin.
+	 * @param plugin - the plugin to unload.
+	 */
+	public void removePacketListeners(Plugin plugin);
+
+	/**
+	 * Constructs a new encapsulated Minecraft packet with the given ID.
+	 * <p>
+	 * Deprecated: Use {@link #createPacket(PacketType)} instead.
+	 * @param id - packet ID.
+	 * @return New encapsulated Minecraft packet.
+	 */
+	@Deprecated
+	public PacketContainer createPacket(int id);
+	
+	/**
+	 * Constructs a new encapsulated Minecraft packet with the given ID.
+	 * @param  type - packet  type.
+	 * @return New encapsulated Minecraft packet.
+	 */
+	public PacketContainer createPacket(PacketType type);
+	
+	/**
+	 * Constructs a new encapsulated Minecraft packet with the given ID.
+	 * <p>
+	 * If set to true, the <i>forceDefaults</i> option will force the system to automatically
+	 * give non-primitive fields in the packet sensible default values. For instance, certain
+	 * packets - like Packet60Explosion - require a List or Set to be non-null. If the
+	 * forceDefaults option is true, the List or Set will be automatically created.
+	 * <p>
+	 * Deprecated: Use {@link #createPacket(PacketType, boolean)} instead.
+	 * 
+	 * @param id - packet ID.
+	 * @param forceDefaults - TRUE to use sensible defaults in most fields, FALSE otherwise.
+	 * @return New encapsulated Minecraft packet.
+	 */
+	@Deprecated
+	public PacketContainer createPacket(int id, boolean forceDefaults);
+	
+	/**
+	 * Constructs a new encapsulated Minecraft packet with the given ID.
+	 * <p>
+	 * If set to true, the <i>forceDefaults</i> option will force the system to automatically
+	 * give non-primitive fields in the packet sensible default values. For instance, certain
+	 * packets - like Packet60Explosion - require a List or Set to be non-null. If the
+	 * forceDefaults option is true, the List or Set will be automatically created.
+	 * 
+	 * @param type - packet type.
+	 * @param forceDefaults - TRUE to use sensible defaults in most fields, FALSE otherwise.
+	 * @return New encapsulated Minecraft packet.
+	 */
+	public PacketContainer createPacket(PacketType type, boolean forceDefaults);
+
+	/**
+	 * Construct a packet using the special builtin Minecraft constructors.
+	 * <p>
+	 * Deprecated: Use {@link #createPacketConstructor(PacketType, Object...)} instead.
+	 * @param id - the packet ID.
+	 * @param arguments - arguments that will be passed to the constructor.
+	 * @return The packet constructor.
+	 */
+	@Deprecated
+	public PacketConstructor createPacketConstructor(int id, Object... arguments);
+	
+	/**
+	 * Construct a packet using the special builtin Minecraft constructors.
+	 * @param type - the packet type.
+	 * @param arguments - arguments that will be passed to the constructor.
+	 * @return The packet constructor.
+	 */
+	public PacketConstructor createPacketConstructor(PacketType type, Object... arguments);
+	
+	/**
+	 * Completely resend an entity to a list of clients.
+	 * <p>
+	 * Note that this method is NOT thread safe. If you call this method from anything
+	 * but the main thread, it will throw an exception.
+	 * @param entity - entity to refresh.
+	 * @param observers - the clients to update.
+	 */
+	public void updateEntity(Entity entity, List<Player> observers) throws FieldAccessException;
+	
+	/**
+	 * Retrieve the associated entity.
+	 * @param container - the world the entity belongs to.
+	 * @param id - the unique ID of the entity.
+	 * @return The associated entity.
+	 * @throws FieldAccessException Reflection failed.
+	 */
+	public Entity getEntityFromID(World container, int id) throws FieldAccessException;
+	
+	/**
+	 * Retrieve every client that is receiving information about a given entity.
+	 * @param entity - the entity that is being tracked.
+	 * @return Every client/player that is tracking the given entity.
+	 * @throws FieldAccessException If reflection failed.
+	 */
+	public List<Player> getEntityTrackers(Entity entity) throws FieldAccessException;
+	
+	/**
+	 * Retrieves a immutable set containing the ID of the sent server packets that will be observed by listeners.
+	 * <p>
+	 * Deprecated: Use {@link #getSendingFilterTypes()} instead.
+	 * @return Every filtered server packet.
+	 */
+	@Deprecated
+	public Set<Integer> getSendingFilters();
+	
+	/**
+	 * Retrieves a immutable set containing the type of the sent server packets that will be observed by listeners.
+	 * @return Every filtered server packet.
+	 */
+	public Set<PacketType> getSendingFilterTypes();
+	
+	/**
+	 * Retrieves a immutable set containing the ID of the received client packets that will be observed by listeners.
+	 * <p>
+	 * Deprecated: Use {@link #getReceivingFilterTypes()} instead.
+	 * @return Every filtered client packet.
+	 */
+	@Deprecated
+	public Set<Integer> getReceivingFilters();
+	
+	/**
+	 * Retrieves a immutable set containing the type of the received client packets that will be observed by listeners.
+	 * @return Every filtered client packet.
+	 */
+	public Set<PacketType> getReceivingFilterTypes();
+	
+	/**
+	 * Retrieve the current Minecraft version.
+	 * @return The current version.
+	 */
+	public MinecraftVersion getMinecraftVersion();
+	
+	/**
+	 * Determines whether or not this protocol manager has been disabled.
+	 * @return TRUE if it has, FALSE otherwise.
+	 */
+	public boolean isClosed();
+
+	/**
+	 * Retrieve the current asynchronous packet manager.
+	 * @return Asynchronous packet manager.
+	 */
+	public AsynchronousManager getAsynchronousManager();
+
+	public void verifyWhitelist(PacketListener listener, ListeningWhitelist whitelist);
+}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncFilterManager.java

@@ -0,0 +1,493 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitScheduler;
+
+import com.comphenix.protocol.AsynchronousManager;
+import com.comphenix.protocol.PacketStream;
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolManager;
+import com.comphenix.protocol.error.ErrorReporter;
+import com.comphenix.protocol.events.ListeningWhitelist;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.events.PacketListener;
+import com.comphenix.protocol.injector.PrioritizedListener;
+import com.comphenix.protocol.injector.SortedPacketListenerList;
+import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+
+/**
+ * Represents a filter manager for asynchronous packets.
+ * <p>
+ * By using {@link AsyncMarker#incrementProcessingDelay()}, a packet can be delayed without having to block the
+ * processing thread.
+ * @author Kristian
+ */
+public class AsyncFilterManager implements AsynchronousManager {
+
+	private SortedPacketListenerList serverTimeoutListeners;
+	private SortedPacketListenerList clientTimeoutListeners;
+	private Set<PacketListener> timeoutListeners;
+	
+	private PacketProcessingQueue serverProcessingQueue;
+	private PacketProcessingQueue clientProcessingQueue;
+
+	// Sending queues
+	private final PlayerSendingHandler playerSendingHandler;
+	
+	// Report exceptions
+	private final ErrorReporter reporter;
+	
+	// The likely main thread
+	private final Thread mainThread;
+	
+	// Default scheduler
+	private final BukkitScheduler scheduler;
+	
+	// Current packet index
+	private final AtomicInteger currentSendingIndex = new AtomicInteger();
+	
+	// Our protocol manager
+	private ProtocolManager manager;
+	
+	/**
+	 * Initialize a asynchronous filter manager.
+	 * <p>
+	 * <b>Internal method</b>. Retrieve the global asynchronous manager from the protocol manager instead.
+	 * @param reporter - desired error reporter.
+	 * @param scheduler - task scheduler.
+	 */
+	public AsyncFilterManager(ErrorReporter reporter, BukkitScheduler scheduler) {
+		// Initialize timeout listeners
+		this.serverTimeoutListeners = new SortedPacketListenerList();
+		this.clientTimeoutListeners = new SortedPacketListenerList();
+		this.timeoutListeners = Sets.newSetFromMap(new ConcurrentHashMap<PacketListener, Boolean>());
+
+		this.playerSendingHandler = new PlayerSendingHandler(reporter, serverTimeoutListeners, clientTimeoutListeners);
+		this.serverProcessingQueue = new PacketProcessingQueue(playerSendingHandler);
+		this.clientProcessingQueue = new PacketProcessingQueue(playerSendingHandler);
+		this.playerSendingHandler.initializeScheduler();
+		
+		this.scheduler = scheduler;
+		this.reporter = reporter;
+		this.mainThread = Thread.currentThread();
+	}
+	
+	/**
+	 * Retrieve the protocol manager.
+	 * @return The protocol manager.
+	 */
+	public ProtocolManager getManager() {
+		return manager;
+	}
+	
+	/**
+	 * Set the associated protocol manager.
+	 * @param manager - the new manager.
+	 */
+	public void setManager(ProtocolManager manager) {
+		this.manager = manager;
+	}
+	
+	@Override
+	public AsyncListenerHandler registerAsyncHandler(PacketListener listener) {
+		return registerAsyncHandler(listener, true);
+	}
+	
+	@Override
+	public void registerTimeoutHandler(PacketListener listener) {
+		if (listener == null)
+			throw new IllegalArgumentException("listener cannot be NULL.");
+		if (!timeoutListeners.add(listener))
+			return;
+		
+		ListeningWhitelist sending = listener.getSendingWhitelist();
+		ListeningWhitelist receiving = listener.getReceivingWhitelist();
+		
+		if (!ListeningWhitelist.isEmpty(sending))
+			serverTimeoutListeners.addListener(listener, sending);
+		if (!ListeningWhitelist.isEmpty(receiving))
+			serverTimeoutListeners.addListener(listener, receiving);
+	}
+
+	@Override
+	public Set<PacketListener> getTimeoutHandlers() {
+		return ImmutableSet.copyOf(timeoutListeners);
+	}
+	
+	@Override
+	public Set<PacketListener> getAsyncHandlers() {
+		ImmutableSet.Builder<PacketListener> builder = ImmutableSet.builder();
+		
+		// Add every asynchronous packet listener
+		for (PrioritizedListener<AsyncListenerHandler> handler :
+				Iterables.concat(serverProcessingQueue.values(), clientProcessingQueue.values())) {
+			builder.add(handler.getListener().getAsyncListener());
+		}
+		return builder.build();
+	}
+	
+	/**
+	 * Registers an asynchronous packet handler.
+	 * <p>
+	 * Use {@link AsyncMarker#incrementProcessingDelay()} to delay a packet until its ready to be transmitted.
+	 * <p>
+	 * To start listening asynchronously, pass the getListenerLoop() runnable to a different thread.
+	 * <p>
+	 * Asynchronous events will only be executed if a synchronous listener with the same packets is registered.
+	 * If you already have a synchronous event, call this method with autoInject set to FALSE.
+	 * 
+	 * @param listener - the packet listener that will receive these asynchronous events.
+	 * @param autoInject - whether or not to automatically create the corresponding synchronous listener,
+	 * @return An asynchronous handler.
+	 */
+	public AsyncListenerHandler registerAsyncHandler(PacketListener listener, boolean autoInject) {
+		AsyncListenerHandler handler = new AsyncListenerHandler(mainThread, this, listener);
+		
+		ListeningWhitelist sendingWhitelist = listener.getSendingWhitelist();
+		ListeningWhitelist receivingWhitelist = listener.getReceivingWhitelist();
+		
+		if (!hasValidWhitelist(sendingWhitelist) && !hasValidWhitelist(receivingWhitelist)) {
+			throw new IllegalArgumentException("Listener has an empty sending and receiving whitelist.");
+		}
+		
+		// Add listener to either or both processing queue
+		if (hasValidWhitelist(sendingWhitelist)) {
+			manager.verifyWhitelist(listener, sendingWhitelist);
+			serverProcessingQueue.addListener(handler, sendingWhitelist);
+		}
+		if (hasValidWhitelist(receivingWhitelist)) {
+			manager.verifyWhitelist(listener, receivingWhitelist);
+			clientProcessingQueue.addListener(handler, receivingWhitelist);
+		}
+		
+		// We need a synchronized listener to get the ball rolling
+		if (autoInject) {
+			handler.setNullPacketListener(new NullPacketListener(listener));
+			manager.addPacketListener(handler.getNullPacketListener());
+		}
+		return handler;
+	}
+	
+	private boolean hasValidWhitelist(ListeningWhitelist whitelist) {
+		return whitelist != null && whitelist.getTypes().size() > 0;
+	}
+	
+	@Override
+	public void unregisterTimeoutHandler(PacketListener listener) {
+		if (listener == null)
+			throw new IllegalArgumentException("listener cannot be NULL.");
+		
+		ListeningWhitelist sending = listener.getSendingWhitelist();
+		ListeningWhitelist receiving = listener.getReceivingWhitelist();
+		
+		// Do it in the opposite order
+		if (serverTimeoutListeners.removeListener(listener, sending).size() > 0 ||
+			clientTimeoutListeners.removeListener(listener, receiving).size() > 0) {
+			timeoutListeners.remove(listener);
+		}
+	}
+	
+	@Override
+	public void unregisterAsyncHandler(PacketListener listener) {
+		if (listener == null)
+			throw new IllegalArgumentException("listener cannot be NULL.");
+		
+		AsyncListenerHandler handler =
+					  findHandler(serverProcessingQueue, listener.getSendingWhitelist(), listener);
+		
+		if (handler == null) {
+			handler = findHandler(clientProcessingQueue, listener.getReceivingWhitelist(), listener);
+		}
+		unregisterAsyncHandler(handler);
+	}
+	
+	// Search for the first correct handler
+	private AsyncListenerHandler findHandler(PacketProcessingQueue queue, ListeningWhitelist search, PacketListener target) {
+		if (ListeningWhitelist.isEmpty(search))
+			return null;
+		
+		for (PacketType type : search.getTypes()) {
+			for (PrioritizedListener<AsyncListenerHandler> element : queue.getListener(type)) {
+				if (element.getListener().getAsyncListener() == target) {
+					return element.getListener();
+				}
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public void unregisterAsyncHandler(AsyncListenerHandler handler) {
+		if (handler == null)
+			throw new IllegalArgumentException("listenerToken cannot be NULL");
+		
+		handler.cancel();
+	}
+	
+	// Called by AsyncListenerHandler
+	void unregisterAsyncHandlerInternal(AsyncListenerHandler handler) {
+		
+		PacketListener listener = handler.getAsyncListener();
+		boolean synchronusOK = onMainThread();
+		
+		// Unregister null packet listeners
+		if (handler.getNullPacketListener() != null) {
+			manager.removePacketListener(handler.getNullPacketListener());
+		}
+		
+		// Just remove it from the queue(s)
+		if (hasValidWhitelist(listener.getSendingWhitelist())) {
+			List<PacketType> removed = serverProcessingQueue.removeListener(handler, listener.getSendingWhitelist());
+			
+			// We're already taking care of this, so don't do anything
+			playerSendingHandler.sendServerPackets(removed, synchronusOK);
+		}
+		
+		if (hasValidWhitelist(listener.getReceivingWhitelist())) {
+			List<PacketType> removed = clientProcessingQueue.removeListener(handler, listener.getReceivingWhitelist());
+			playerSendingHandler.sendClientPackets(removed, synchronusOK);
+		}
+	}
+	
+	/**
+	 * Determine if we're running on the main thread.
+	 * @return TRUE if we are, FALSE otherwise.
+	 */
+	private boolean onMainThread() {
+		return Thread.currentThread().getId() == mainThread.getId();
+	}
+	
+	@Override
+	public void unregisterAsyncHandlers(Plugin plugin) {
+		unregisterAsyncHandlers(serverProcessingQueue, plugin);
+		unregisterAsyncHandlers(clientProcessingQueue, plugin);
+	}
+	
+	private void unregisterAsyncHandlers(PacketProcessingQueue processingQueue, Plugin plugin) {
+		
+		// Iterate through every packet listener
+		for (PrioritizedListener<AsyncListenerHandler> listener : processingQueue.values()) {
+			// Remove the listener
+			if (Objects.equal(listener.getListener().getPlugin(), plugin)) {
+				unregisterAsyncHandler(listener.getListener());
+			}
+		}
+	}
+	
+	/**
+	 * Enqueue a packet for asynchronous processing.
+	 * 
+	 * @param syncPacket - synchronous packet event.
+	 * @param asyncMarker - the asynchronous marker to use.
+	 */
+	public synchronized void enqueueSyncPacket(PacketEvent syncPacket, AsyncMarker asyncMarker) {
+		PacketEvent newEvent = PacketEvent.fromSynchronous(syncPacket, asyncMarker);
+
+		if (asyncMarker.isQueued() || asyncMarker.isTransmitted())
+			throw new IllegalArgumentException("Cannot queue a packet that has already been queued.");
+
+		asyncMarker.setQueuedSendingIndex(asyncMarker.getNewSendingIndex());
+
+		// The player is only be null when they're logged out,
+		// so this should be a pretty safe check
+		Player player = newEvent.getPlayer();
+		if (player != null) {
+			// Start the process
+			getSendingQueue(syncPacket).enqueue(newEvent);
+
+			// We know this is occuring on the main thread, so pass TRUE
+			getProcessingQueue(syncPacket).enqueue(newEvent, true);
+		}
+	}
+	
+	@Override
+	public Set<Integer> getSendingFilters() {
+		return PacketRegistry.toLegacy(serverProcessingQueue.keySet());
+	}
+	
+	@Override
+	public Set<PacketType> getReceivingTypes() {
+		return serverProcessingQueue.keySet();
+	}
+	
+	@Override
+	public Set<Integer> getReceivingFilters() {
+		return PacketRegistry.toLegacy(clientProcessingQueue.keySet());
+	}
+	
+	@Override
+	public Set<PacketType> getSendingTypes() {
+		return clientProcessingQueue.keySet();
+	}
+	
+	/**
+	 * Retrieve the current task scheduler.
+	 * @return Current task scheduler.
+	 */
+	public BukkitScheduler getScheduler() {
+		return scheduler;
+	}
+	
+	@Override
+	public boolean hasAsynchronousListeners(PacketEvent packet) {
+		 Collection<?> list = getProcessingQueue(packet).getListener(packet.getPacketType());
+		 return list != null && list.size() > 0;
+	}
+	
+	/**
+	 * Construct a asynchronous marker with all the default values.
+	 * @return Asynchronous marker.
+	 */
+	public AsyncMarker createAsyncMarker() {
+		return createAsyncMarker(AsyncMarker.DEFAULT_TIMEOUT_DELTA);
+	}
+	
+	/**
+	 * Construct an async marker with the given sending priority delta and timeout delta.
+	 * @param timeoutDelta - how long (in ms) until the packet expire.
+	 * @return An async marker.
+	 */
+	public AsyncMarker createAsyncMarker(long timeoutDelta) {
+		return createAsyncMarker(timeoutDelta, currentSendingIndex.incrementAndGet());
+	}
+	
+	// Helper method
+	private AsyncMarker createAsyncMarker(long timeoutDelta, long sendingIndex) {
+		return new AsyncMarker(manager, sendingIndex, System.currentTimeMillis(), timeoutDelta);
+	}
+	
+	@Override
+	public PacketStream getPacketStream() {
+		return manager;
+	}
+
+	@Override
+	public ErrorReporter getErrorReporter() {
+		return reporter;
+	}
+	
+	@Override
+	public void cleanupAll() {
+		serverProcessingQueue.cleanupAll();
+		playerSendingHandler.cleanupAll();
+		timeoutListeners.clear();
+		
+		serverTimeoutListeners = null;
+		clientTimeoutListeners = null;
+	}
+	
+	@Override
+	public void signalPacketTransmission(PacketEvent packet) {
+		signalPacketTransmission(packet, onMainThread());
+	}
+
+	/**
+	 * Signal that a packet is ready to be transmitted.
+	 * @param packet - packet to signal.
+	 * @param onMainThread - whether or not this method was run by the main thread.
+	 */
+	private void signalPacketTransmission(PacketEvent packet, boolean onMainThread) {
+		AsyncMarker marker = packet.getAsyncMarker();
+		if (marker == null)
+			throw new IllegalArgumentException(
+					"A sync packet cannot be transmitted by the asynchronous manager.");
+		if (!marker.isQueued())
+			throw new IllegalArgumentException(
+					"A packet must have been queued before it can be transmitted.");
+		
+		// Only send if the packet is ready
+		if (marker.decrementProcessingDelay() == 0) {
+			PacketSendingQueue queue = getSendingQueue(packet, false);
+			
+			// No need to create a new queue if the player has logged out
+			if (queue != null)
+				queue.signalPacketUpdate(packet, onMainThread);
+		}
+	}
+	
+	/**
+	 * Retrieve the sending queue this packet belongs to.
+	 * @param packet - the packet.
+	 * @return The server or client sending queue the packet belongs to.
+	 */
+	public PacketSendingQueue getSendingQueue(PacketEvent packet) {
+		return playerSendingHandler.getSendingQueue(packet);
+	}
+	
+	/**
+	 * Retrieve the sending queue this packet belongs to.
+	 * @param packet - the packet.
+	 * @param createNew - if TRUE, create a new queue if it hasn't already been created.
+	 * @return The server or client sending queue the packet belongs to.
+	 */
+	public PacketSendingQueue getSendingQueue(PacketEvent packet, boolean createNew) {
+		return playerSendingHandler.getSendingQueue(packet, createNew);
+	}
+	
+	/**
+	 * Retrieve the processing queue this packet belongs to.
+	 * @param packet - the packet.
+	 * @return The server or client sending processing the packet belongs to.
+	 */
+	public PacketProcessingQueue getProcessingQueue(PacketEvent packet) {
+		return packet.isServerPacket() ? serverProcessingQueue : clientProcessingQueue;
+	}
+	
+	/**
+	 * Signal that a packet has finished processing.
+	 * @param packet - packet to signal.
+	 */
+	public void signalFreeProcessingSlot(PacketEvent packet) {
+		getProcessingQueue(packet).signalProcessingDone();
+	}
+	
+	/**
+	 * Send any due packets, or clean up packets that have expired.
+	 * @param tickCounter Tick counter
+	 * @param onMainThread Whether or not to execute on the main thread
+	 */
+	public void sendProcessedPackets(int tickCounter, boolean onMainThread) {
+		// The server queue is unlikely to need checking that often
+		if (tickCounter % 10 == 0) {
+			playerSendingHandler.trySendServerPackets(onMainThread);
+		}
+		
+		playerSendingHandler.trySendClientPackets(onMainThread);
+	}
+
+	/**
+	 * Clean up after a given player has logged out.
+	 * @param player - the player that has just logged out.
+	 */
+	public void removePlayer(Player player) {
+		playerSendingHandler.removePlayer(player);
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncListenerHandler.java

@@ -0,0 +1,706 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.error.Report;
+import com.comphenix.protocol.error.ReportType;
+import com.comphenix.protocol.events.ListeningWhitelist;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.events.PacketListener;
+import com.comphenix.protocol.timing.TimedListenerManager;
+import com.comphenix.protocol.timing.TimedListenerManager.ListenerType;
+import com.comphenix.protocol.timing.TimedTracker;
+import com.comphenix.protocol.utility.WrappedScheduler;
+import com.google.common.base.Function;
+import com.google.common.base.Joiner;
+
+/**
+ * Represents a handler for an asynchronous event.
+ * <p>
+ * Use {@link AsyncMarker#incrementProcessingDelay()} to delay a packet until a certain condition has been met.
+ * @author Kristian
+ */
+public class AsyncListenerHandler {
+	public static final ReportType REPORT_HANDLER_NOT_STARTED = new ReportType(
+		"Plugin %s did not start the asynchronous handler %s by calling start() or syncStart().");
+
+	/**
+	 * Signal an end to packet processing.
+	 */
+	private static final PacketEvent INTERUPT_PACKET = new PacketEvent(new Object());
+	
+	/**
+	 * Called when the threads have to wake up for something important.
+	 */
+	private static final PacketEvent WAKEUP_PACKET = new PacketEvent(new Object());
+	
+	/**
+	 * The expected number of ticks per second.
+	 */
+	private static final int TICKS_PER_SECOND = 20;
+	
+	// Unique worker ID
+	private static final AtomicInteger nextID = new AtomicInteger();
+	
+	// Default queue capacity
+	private static final int DEFAULT_CAPACITY = 1024;
+	
+	// Cancel the async handler
+	private volatile boolean cancelled;
+	
+	// Number of worker threads
+	private final AtomicInteger started = new AtomicInteger();
+	
+	// The packet listener
+	private PacketListener listener;
+
+	// The filter manager
+	private AsyncFilterManager filterManager;
+	private NullPacketListener nullPacketListener;
+	
+	// List of queued packets
+	private ArrayBlockingQueue<PacketEvent> queuedPackets = new ArrayBlockingQueue<PacketEvent>(DEFAULT_CAPACITY);
+	
+	// List of cancelled tasks
+	private final Set<Integer> stoppedTasks = new HashSet<Integer>();
+	private final Object stopLock = new Object();
+	
+	// Processing task on the main thread
+	private int syncTask = -1;
+	
+	// Minecraft main thread
+	private Thread mainThread;
+	
+	// Warn plugins that the async listener handler must be started
+	private int warningTask;
+	
+	// Timing manager
+	private TimedListenerManager timedManager = TimedListenerManager.getInstance();
+	
+	/**
+	 * Construct a manager for an asynchronous packet handler.
+	 * @param mainThread - the main game thread.
+	 * @param filterManager - the parent filter manager.
+	 * @param listener - the current packet listener.
+	 */
+	AsyncListenerHandler(Thread mainThread, AsyncFilterManager filterManager, PacketListener listener) {
+		if (filterManager == null)
+			throw new IllegalArgumentException("filterManager cannot be NULL");
+		if (listener == null)
+			throw new IllegalArgumentException("listener cannot be NULL");
+
+		this.mainThread = mainThread;
+		this.filterManager = filterManager;
+		this.listener = listener;
+		startWarningTask();
+	}
+	
+	private void startWarningTask() {
+		warningTask = filterManager.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable() {
+			@Override
+			public void run() {
+				ProtocolLibrary.getErrorReporter().reportWarning(AsyncListenerHandler.this, Report.
+						newBuilder(REPORT_HANDLER_NOT_STARTED).
+						messageParam(listener.getPlugin(), AsyncListenerHandler.this).
+						build()
+				);
+			}
+		}, 2 * TICKS_PER_SECOND);
+	}
+	
+	private void stopWarningTask() {
+		int taskId = warningTask;
+		
+		// Ensure we have a task to cancel
+		if (warningTask >= 0) {
+			filterManager.getScheduler().cancelTask(taskId);
+			warningTask = -1;
+		}
+	}
+	
+	/**
+	 * Determine whether or not this asynchronous handler has been cancelled.
+	 * @return TRUE if it has been cancelled/stopped, FALSE otherwise.
+	 */
+	public boolean isCancelled() {
+		return cancelled;
+	}
+
+	/**
+	 * Retrieve the current asynchronous packet listener.
+	 * @return Current packet listener.
+	 */
+	public PacketListener getAsyncListener() {
+		return listener;
+	}
+
+	/**
+	 * Set the synchronized listener that has been automatically created.
+	 * @param nullPacketListener - automatically created listener.
+	 */
+	void setNullPacketListener(NullPacketListener nullPacketListener) {
+		this.nullPacketListener = nullPacketListener;
+	}
+
+	/**
+	 * Retrieve the synchronized listener that was automatically created.
+	 * @return Automatically created listener.
+	 */
+	PacketListener getNullPacketListener() {
+		return nullPacketListener;
+	}
+
+	/**
+	 * Retrieve the plugin associated with this async listener.
+	 * @return The plugin.
+	 */
+	public Plugin getPlugin() {
+		return listener != null ? listener.getPlugin() : null;
+	}
+	
+	/**
+	 * Cancel the handler.
+	 */
+	public void cancel() {
+		// Remove the listener as quickly as possible
+		close();
+	}
+
+	/**
+	 * Queue a packet for processing.
+	 * @param packet - a packet for processing.
+	 * @throws IllegalStateException If the underlying packet queue is full.
+	 */
+	public void enqueuePacket(PacketEvent packet) {
+		if (packet == null)
+			throw new IllegalArgumentException("packet is NULL");
+		
+		queuedPackets.add(packet);
+	}
+	
+	/**
+	 * Create a worker that will initiate the listener loop. Note that using stop() to
+	 * close a specific worker is less efficient than stopping an arbitrary worker.
+	 * <p>
+	 * <b>Warning</b>: Never call the run() method in the main thread.
+	 * @return The listener loop
+	 */
+	public AsyncRunnable getListenerLoop() {
+		return new AsyncRunnable() {
+
+			private final AtomicBoolean firstRun = new AtomicBoolean();
+			private final AtomicBoolean finished = new AtomicBoolean();
+			private final int id = nextID.incrementAndGet();
+			
+			@Override
+			public int getID() {
+				return id;
+			}
+			
+			@Override
+			public void run() {
+				// Careful now
+				if (firstRun.compareAndSet(false, true)) {
+					listenerLoop(id);
+					
+					synchronized (stopLock) {
+						stoppedTasks.remove(id);
+						stopLock.notifyAll();
+						finished.set(true);
+					}
+					
+				} else {
+					if (finished.get())
+						throw new IllegalStateException(
+							"This listener has already been run. Create a new instead.");
+					else
+						throw new IllegalStateException(
+							"This listener loop has already been started. Create a new instead.");
+				}
+			}
+			
+			@Override
+			public boolean stop() throws InterruptedException {
+				synchronized (stopLock) {
+					if (!isRunning())
+						return false;
+
+					stoppedTasks.add(id);
+			
+					// Wake up threads - we have a listener to stop
+					for (int i = 0; i < getWorkers(); i++) {
+						queuedPackets.offer(WAKEUP_PACKET);
+					}
+					
+					finished.set(true);
+					waitForStops();
+					return true;
+				}
+			}
+
+			@Override
+			public boolean isRunning() {
+				return firstRun.get() && !finished.get();
+			}
+			
+			@Override
+			public boolean isFinished() {
+				return finished.get();
+			}
+		};
+	}
+	
+	/**
+	 * Start a singler worker thread handling the asynchronous listener.
+	 */
+	public synchronized void start() {
+		if (listener.getPlugin() == null)
+			throw new IllegalArgumentException("Cannot start task without a valid plugin.");
+		if (cancelled)
+			throw new IllegalStateException("Cannot start a worker when the listener is closing.");
+		
+		final AsyncRunnable listenerLoop = getListenerLoop();
+		
+		stopWarningTask();
+		scheduleAsync(new Runnable() {
+			@Override
+			public void run() {
+				Thread thread = Thread.currentThread();
+				
+				String previousName = thread.getName();
+				String workerName = getFriendlyWorkerName(listenerLoop.getID());
+
+				// Add the friendly worker name
+				thread.setName(workerName);
+				listenerLoop.run();
+				thread.setName(previousName);
+			}
+		});
+	}
+	
+	/**
+	 * Start a singler worker thread handling the asynchronous listener.
+	 * <p>
+	 * This method is intended to allow callers to customize the thread priority
+	 * before the worker loop is actually called. This is simpler than to
+	 * schedule the worker threads manually.
+	 * <pre><code>
+	 * listenerHandler.start(new Function&lt;AsyncRunnable, Void&gt;() {
+	 *     &#64;Override
+	 *     public Void apply(&#64;Nullable AsyncRunnable workerLoop) {
+	 *         Thread thread = Thread.currentThread();
+	 *         int prevPriority = thread.getPriority();
+	 *	
+	 *         thread.setPriority(Thread.MIN_PRIORITY);
+	 *         workerLoop.run();
+	 *         thread.setPriority(prevPriority);
+	 *         return null;
+	 *     }
+	 *   });
+	 * }
+	 * </code></pre>
+	 * @param executor - a method that will execute the given listener loop.
+	 */
+	public synchronized void start(Function<AsyncRunnable, Void> executor) {
+		if (listener.getPlugin() == null)
+			throw new IllegalArgumentException("Cannot start task without a valid plugin.");
+		if (cancelled)
+			throw new IllegalStateException("Cannot start a worker when the listener is closing.");
+		
+		final AsyncRunnable listenerLoop = getListenerLoop();
+		final Function<AsyncRunnable, Void> delegateCopy = executor;
+		
+		scheduleAsync(new Runnable() {
+			@Override
+			public void run() {
+				delegateCopy.apply(listenerLoop);
+			}
+		});
+	}
+	
+	private void scheduleAsync(Runnable runnable) {
+		// Handle deprecation
+		WrappedScheduler.runAsynchronouslyRepeat(listener.getPlugin(), filterManager.getScheduler(), runnable, 0L, -1L);
+	}
+	
+	/**
+	 * Create a friendly thread name using the following convention:
+	 * <p><code>
+	 * &nbsp;&nbsp;&nbsp;&nbsp;Protocol Worker {id} - {plugin} - [recv: {packets}, send: {packets}]
+	 * </code></p>
+	 * @param id - the worker ID.
+	 * @return A friendly thread name.
+	 */
+	public String getFriendlyWorkerName(int id) {
+		return String.format("Protocol Worker #%s - %s - [recv: %s, send: %s]",
+				id,
+				PacketAdapter.getPluginName(listener),
+				fromWhitelist(listener.getReceivingWhitelist()),
+				fromWhitelist(listener.getSendingWhitelist())
+		);
+	}
+	
+	/**
+	 * Convert the given whitelist to a comma-separated list of packet IDs.
+	 * @param whitelist - the whitelist.
+	 * @return A comma separated list of packet IDs in the whitelist, or the emtpy string.
+	 */
+	private String fromWhitelist(ListeningWhitelist whitelist) {
+		if (whitelist == null)
+			return "";
+		else
+			return Joiner.on(", ").join(whitelist.getTypes());
+	}
+	
+	/**
+	 * Start processing packets on the main thread.
+	 * <p>
+	 * This is useful if you need to synchronize with the main thread in your packet listener, but
+	 * you're not performing any expensive processing.
+	 * <p>
+	 * <b>Note</b>: Use a asynchronous worker if the packet listener may use more than 0.5 ms
+	 * of processing time on a single packet. Do as much as possible on the worker thread, and schedule synchronous tasks
+	 * to use the Bukkit API instead.
+	 * @return TRUE if the synchronized processing was successfully started, FALSE if it's already running.
+	 * @throws IllegalStateException If we couldn't start the underlying task.
+	 */
+	public synchronized boolean syncStart() {
+		return syncStart(500, TimeUnit.MICROSECONDS);
+	}
+	
+	/**
+	 * Start processing packets on the main thread.
+	 * <p>
+	 * This is useful if you need to synchronize with the main thread in your packet listener, but
+	 * you're not performing any expensive processing.
+	 * <p>
+	 * The processing time parameter gives the upper bound for the amount of time spent processing pending packets.
+	 * It should be set to a fairly low number, such as 0.5 ms or 1% of a game tick - to reduce the impact
+	 * on the main thread. Never go beyond 50 milliseconds.
+	 * <p>
+	 * <b>Note</b>: Use a asynchronous worker if the packet listener may exceed the ideal processing time
+	 * on a single packet. Do as much as possible on the worker thread, and schedule synchronous tasks
+	 * to use the Bukkit API instead.
+	 * 
+	 * @param time - the amount of processing time alloted per game tick (20 ticks per second).
+	 * @param unit - the unit of the processingTime argument.
+	 * @return TRUE if the synchronized processing was successfully started, FALSE if it's already running.
+	 * @throws IllegalStateException If we couldn't start the underlying task.
+	 */
+	public synchronized boolean syncStart(final long time, final TimeUnit unit) {
+		if (time <= 0)
+			throw new IllegalArgumentException("Time must be greater than zero.");
+		if (unit == null)
+			throw new IllegalArgumentException("TimeUnit cannot be NULL.");
+	
+		final long tickDelay = 1;
+		final int workerID = nextID.incrementAndGet();
+		
+		if (syncTask < 0) {
+			stopWarningTask();
+			
+			syncTask = filterManager.getScheduler().scheduleSyncRepeatingTask(getPlugin(), new Runnable() {
+				@Override
+				public void run() {
+					long stopTime = System.nanoTime() + unit.convert(time, TimeUnit.NANOSECONDS);
+					
+					while (!cancelled) {
+						PacketEvent packet = queuedPackets.poll();
+						
+						if (packet == INTERUPT_PACKET || packet == WAKEUP_PACKET) {
+							// Sorry, asynchronous threads!
+							queuedPackets.add(packet);
+							
+							// Try again next tick
+							break;
+						} else if (packet != null && packet.getAsyncMarker() != null) {
+							processPacket(workerID, packet, "onSyncPacket()");
+						} else {
+							// No more packets left - wait a tick
+							break;
+						}
+						
+						// Check time here, ensuring that we at least process one packet
+						if (System.nanoTime() < stopTime)
+							break;
+					}
+				}
+			}, tickDelay, tickDelay);
+			
+			// This is very bad - force the caller to handle it
+			if (syncTask < 0)
+				throw new IllegalStateException("Cannot start synchronous task.");
+			else
+				return true;
+		} else {
+			return false;
+		}
+	}
+	
+	/**
+	 * Stop processing packets on the main thread.
+	 * @return TRUE if we stopped any processing tasks, FALSE if it has already been stopped.
+	 */
+	public synchronized boolean syncStop() {
+		if (syncTask > 0) {
+			filterManager.getScheduler().cancelTask(syncTask);
+			
+			syncTask = -1;
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+	/**
+	 * Start multiple worker threads for this listener.
+	 * @param count - number of worker threads to start.
+	 */
+	public synchronized void start(int count) {
+		for (int i = 0; i < count; i++)
+			start();
+	}
+	
+	/**
+	 * Stop a worker thread.
+	 */
+	public synchronized void stop() {
+		queuedPackets.add(INTERUPT_PACKET);
+	}
+	
+	/**
+	 * Stop the given amount of worker threads.
+	 * @param count - number of threads to stop.
+	 */
+	public synchronized void stop(int count) {
+		for (int i = 0; i < count; i++)
+			stop();
+	}
+	
+	/**
+	 * Set the current number of workers.
+	 * <p>
+	 * This method can only be called with a count of zero when the listener is closing.
+	 * @param count - new number of workers.
+	 */
+	public synchronized void setWorkers(int count) {
+		if (count < 0)
+			throw new IllegalArgumentException("Number of workers cannot be less than zero.");
+		if (count > DEFAULT_CAPACITY)
+			throw new IllegalArgumentException("Cannot initiate more than " + DEFAULT_CAPACITY + " workers");
+		if (cancelled && count > 0)
+			throw new IllegalArgumentException("Cannot add workers when the listener is closing.");
+		
+		long time = System.currentTimeMillis();
+		
+		// Try to get to the correct count
+		while (started.get() != count) {
+			if (started.get() < count)
+				start();
+			else
+				stop();
+			
+			// May happen if another thread is doing something similar to "setWorkers"
+			if ((System.currentTimeMillis() - time) > 50)
+				throw new RuntimeException("Failed to set worker count.");
+		}
+	}
+	
+	/**
+	 * Retrieve the current number of registered workers.
+	 * <p>
+	 * Note that the returned value may be out of data.
+	 * @return Number of registered workers.
+	 */
+	public synchronized int getWorkers() {
+		return started.get();
+	}
+	
+	/**
+	 * Wait until every tasks scheduled to stop has actually stopped.
+	 * @return TRUE if the current listener should stop, FALSE otherwise.
+	 * @throws InterruptedException - If the current thread was interrupted.
+	 */
+	private boolean waitForStops() throws InterruptedException {
+		synchronized (stopLock) {
+			while (stoppedTasks.size() > 0 && !cancelled) {
+				stopLock.wait();
+			}
+			return cancelled;
+		}
+	}
+	
+	/**
+	 * The main processing loop of asynchronous threads.
+	 * <p>
+	 * Note: DO NOT call this method from the main thread
+	 * @param workerID - the current worker ID.
+	 */
+	private void listenerLoop(int workerID) {
+		// Danger, danger!
+		if (Thread.currentThread().getId() == mainThread.getId())
+			throw new IllegalStateException("Do not call this method from the main thread.");
+		if (cancelled)
+			throw new IllegalStateException("Listener has been cancelled. Create a new listener instead.");
+
+		try {
+			// Wait if certain threads are stopping
+			if (waitForStops())
+				return;
+			
+			// Proceed
+			started.incrementAndGet();
+			
+			while (!cancelled) {
+				PacketEvent packet = queuedPackets.take();
+				
+				// Handle cancel requests
+				if (packet == WAKEUP_PACKET) {
+					// This is a bit slow, but it should be safe
+					synchronized (stopLock) {
+						// Are we the one who is supposed to stop?
+						if (stoppedTasks.contains(workerID))
+							return;
+						if (waitForStops())
+							return;
+					}
+				} else if (packet == INTERUPT_PACKET) {
+					return;
+				}
+				
+				if (packet != null && packet.getAsyncMarker() != null) {
+					processPacket(workerID, packet, "onAsyncPacket()");
+				}
+			}
+			
+		} catch (InterruptedException e) {
+			// We're done
+		} finally {
+			// Clean up
+			started.decrementAndGet();
+		}
+	}
+	
+	/**
+	 * Called when a packet is scheduled for processing.
+	 * @param workerID - the current worker ID.
+	 * @param packet - the current packet.
+	 * @param methodName - name of the method.
+	 */
+	private void processPacket(int workerID, PacketEvent packet, String methodName) {
+		AsyncMarker marker = packet.getAsyncMarker();
+		
+		// Here's the core of the asynchronous processing
+		try {
+			synchronized (marker.getProcessingLock()) {
+				marker.setListenerHandler(this);
+				marker.setWorkerID(workerID);
+				
+				// We're not THAT worried about performance here
+				if (timedManager.isTiming()) {
+					// Retrieve the tracker to use
+					TimedTracker tracker = timedManager.getTracker(listener,
+						packet.isServerPacket() ? ListenerType.ASYNC_SERVER_SIDE : ListenerType.ASYNC_CLIENT_SIDE);
+					long token = tracker.beginTracking();
+					
+					if (packet.isServerPacket())
+						listener.onPacketSending(packet);
+					else
+						listener.onPacketReceiving(packet);
+					
+					// And we're done
+					tracker.endTracking(token, packet.getPacketType());
+					
+				} else {
+					if (packet.isServerPacket())
+						listener.onPacketSending(packet);
+					else
+						listener.onPacketReceiving(packet);
+				}
+			}
+			
+		} catch (OutOfMemoryError e) {
+			throw e;
+		} catch (ThreadDeath e) {
+			throw e;
+		} catch (Throwable e) {
+			// Minecraft doesn't want your Exception.
+			filterManager.getErrorReporter().reportMinimal(listener.getPlugin(), methodName, e);
+		}
+		
+		// Now, get the next non-cancelled listener
+		if (!marker.hasExpired()) {
+			for (; marker.getListenerTraversal().hasNext(); ) {
+				AsyncListenerHandler handler = marker.getListenerTraversal().next().getListener();
+				
+				if (!handler.isCancelled()) {
+					handler.enqueuePacket(packet);
+					return;
+				}
+			}
+		}
+		
+		// There are no more listeners - queue the packet for transmission
+		filterManager.signalFreeProcessingSlot(packet);
+		
+		// Note that listeners can opt to delay the packet transmission
+		filterManager.signalPacketTransmission(packet);
+	}
+	
+	/**
+	 * Close all worker threads and the handler itself.
+	 */
+	private synchronized void close() {
+		// Remove the listener itself
+		if (!cancelled) {
+			filterManager.unregisterAsyncHandlerInternal(this);
+			cancelled = true;
+			
+			// Close processing tasks
+			syncStop();
+			
+			// Tell every uncancelled thread to end
+			stopThreads();
+		}
+	}
+	
+	/**
+	 * Use the poision pill method to stop every worker thread.
+	 */
+	private void stopThreads() {
+		// Poison Pill Shutdown
+		queuedPackets.clear();
+		stop(started.get());
+		
+		// Individual shut down is irrelevant now
+		synchronized (stopLock) {
+			stopLock.notifyAll();
+		}
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncMarker.java

@@ -1,345 +1,487 @@
-package com.comphenix.protocol.async;
-
-import java.io.IOException;
-import java.io.Serializable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-
-import net.minecraft.server.Packet;
-
-import com.comphenix.protocol.PacketStream;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.google.common.primitives.Longs;
-
-/**
- * Contains information about the packet that is being processed by asynchronous listeners.
- * <p>
- * Asynchronous listeners can use this to set packet timeout or transmission order.
- * 
- * @author Kristian
- */
-public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
-		
-	/**
-	 * Generated by Eclipse.
-	 */
-	private static final long serialVersionUID = -2621498096616187384L;
-
-	/**
-	 * Default number of milliseconds until a packet will rejected.
-	 */
-	public static final int DEFAULT_TIMEOUT_DELTA = 60000;
-	
-	/**
-	 * Default number of packets to skip.
-	 */
-	public static final int DEFAULT_SENDING_DELTA = 0;
-	
-	/**
-	 * The packet stream responsible for transmitting the packet when it's done processing.
-	 */
-	private transient PacketStream packetStream;
-	
-	/**
-	 * Current list of async packet listeners.
-	 */
-	private transient Iterator<PrioritizedListener<AsyncListenerHandler>> listenerTraversal;
-	
-	// Timeout handling
-	private long initialTime;
-	private long timeout;
-	
-	// Packet order
-	private long originalSendingIndex;
-	private long newSendingIndex;
-	
-	// Whether or not the packet has been processed by the listeners
-	private volatile boolean processed;
-	
-	// Whether or not the packet has been sent
-	private volatile boolean transmitted;
-	
-	// Whether or not the asynchronous processing itself should be cancelled
-	private volatile boolean asyncCancelled;
-	
-	// Used to identify the asynchronous worker
-	private AsyncListenerHandler listenerHandler;
-	private int workerID;
-	
-	// Determine if Minecraft processes this packet asynchronously
-	private static Method isMinecraftAsync;
-	private static boolean alwaysSync;
-
-	/**
-	 * Create a container for asyncronous packets.
-	 * @param initialTime - the current time in milliseconds since 01.01.1970 00:00.
-	 */
-	AsyncMarker(PacketStream packetStream, long sendingIndex, long sendingDelta, long initialTime, long timeoutDelta) {
-		if (packetStream == null)
-			throw new IllegalArgumentException("packetStream cannot be NULL");
-		
-		this.packetStream = packetStream;
-		
-		// Timeout
-		this.initialTime = initialTime;
-		this.timeout = initialTime + timeoutDelta;
-		
-		// Sending index
-		this.originalSendingIndex = sendingIndex;
-		this.newSendingIndex = sendingIndex;
-	}
-	
-	/**
-	 * Retrieve the time the packet was initially queued for asynchronous processing.
-	 * @return The initial time in number of milliseconds since 01.01.1970 00:00. 
-	 */
-	public long getInitialTime() {
-		return initialTime;
-	}	
-
-	/**
-	 * Retrieve the time the packet will be forcefully rejected.
-	 * @return The time to reject the packet, in milliseconds since 01.01.1970 00:00.
-	 */
-	public long getTimeout() {
-		return timeout;
-	}
-	
-	/**
-	 * Set the time the packet will be forcefully rejected.
-	 * @param timeout - time to reject the packet, in milliseconds since 01.01.1970 00:00.
-	 */
-	public void setTimeout(long timeout) {
-		this.timeout = timeout;
-	}
-
-	/**
-	 * Retrieve the order the packet was originally transmitted.
-	 * @return The original packet index.
-	 */
-	public long getOriginalSendingIndex() {
-		return originalSendingIndex;
-	}
-
-	/**
-	 * Retrieve the desired sending order after processing has completed.
-	 * <p>
-	 * Higher sending order means lower priority.
-	 * @return Desired sending order.
-	 */
-	public long getNewSendingIndex() {
-		return newSendingIndex;
-	}
-
-	/**
-	 * Sets the desired sending order after processing has completed.
-	 * <p>
-	 * Higher sending order means lower priority.
-	 * @param newSendingIndex - new packet send index.
-	 */
-	public void setNewSendingIndex(long newSendingIndex) {
-		this.newSendingIndex = newSendingIndex;
-	}
-
-	/**
-	 * Retrieve the packet stream responsible for transmitting this packet.
-	 * @return The packet stream.
-	 */
-	public PacketStream getPacketStream() {
-		return packetStream;
-	}
-
-	/**
-	 * Sets the output packet stream responsible for transmitting this packet.
-	 * @param packetStream - new output packet stream.
-	 */
-	public void setPacketStream(PacketStream packetStream) {
-		this.packetStream = packetStream;
-	}
-
-	/**
-	 * Retrieve whether or not this packet has been processed by the async listeners.
-	 * @return TRUE if it has been processed, FALSE otherwise.
-	 */
-	public boolean isProcessed() {
-		return processed;
-	}
-
-	/**
-	 * Sets whether or not this packet has been processed by the async listeners.
-	 * @param processed - TRUE if it has, FALSE otherwise.
-	 */
-	void setProcessed(boolean processed) {
-		this.processed = processed;
-	}
-
-	/**
-	 * Retrieve whether or not this packet has already been sent.
-	 * @return TRUE if it has been sent before, FALSE otherwise.
-	 */
-	public boolean isTransmitted() {
-		return transmitted;
-	}
-
-	/**
-	 * Determine if this packet has expired.
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean hasExpired() {
-		return hasExpired(System.currentTimeMillis());
-	}
-	
-	/**
-	 * Determine if this packet has expired given this time.
-	 * @param currentTime - the current time in milliseconds since 01.01.1970 00:00.
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean hasExpired(long currentTime) {
-		return timeout < currentTime;
-	}
-	
-	/**
-	 * Determine if the asynchronous handling should be cancelled.
-	 * @return TRUE if it should, FALSE otherwise.
-	 */
-	public boolean isAsyncCancelled() {
-		return asyncCancelled;
-	}
-
-	/**
-	 * Set whether or not the asynchronous handling should be cancelled.
-	 * @param asyncCancelled - TRUE to cancel it, FALSE otherwise.
-	 */
-	public void setAsyncCancelled(boolean asyncCancelled) {
-		this.asyncCancelled = asyncCancelled;
-	}
-
-	/**
-	 * Retrieve the current asynchronous listener handler.
-	 * @return Asychronous listener handler, or NULL if this packet is not asynchronous.
-	 */
-	public AsyncListenerHandler getListenerHandler() {
-		return listenerHandler;
-	}
-
-	/**
-	 * Set the current asynchronous listener handler. 
-	 * <p>
-	 * Used by the worker to update the value.
-	 * @param listenerHandler - new listener handler.
-	 */
-	void setListenerHandler(AsyncListenerHandler listenerHandler) {
-		this.listenerHandler = listenerHandler;
-	}
-
-	/**
-	 * Retrieve the current worker ID.
-	 * @return Current worker ID.
-	 */
-	public int getWorkerID() {
-		return workerID;
-	}
-
-	/**
-	 * Set the current worker ID.
-	 * <p>
-	 * Used by the worker.
-	 * @param workerID - new worker ID.
-	 */
-	void setWorkerID(int workerID) {
-		this.workerID = workerID;
-	}
-
-	/**
-	 * Retrieve iterator for the next listener in line.
-	 * @return Next async packet listener iterator.
-	 */
-	Iterator<PrioritizedListener<AsyncListenerHandler>> getListenerTraversal() {
-		return listenerTraversal;
-	}
-	
-	/**
-	 * Set the iterator for the next listener.
-	 * @param listenerTraversal - the new async packet listener iterator.
-	 */
-	void setListenerTraversal(Iterator<PrioritizedListener<AsyncListenerHandler>> listenerTraversal) {
-		this.listenerTraversal = listenerTraversal;
-	}
-	
-	/**
-	 * Transmit a given packet to the current packet stream.
-	 * @param event - the packet to send.
-	 * @throws IOException If the packet couldn't be sent.
-	 */
-	public void sendPacket(PacketEvent event) throws IOException {
-		try {
-			if (event.isServerPacket()) {
-				packetStream.sendServerPacket(event.getPlayer(), event.getPacket(), false);
-			} else {
-				packetStream.recieveClientPacket(event.getPlayer(), event.getPacket(), false);
-			}
-			transmitted = true;
-			
-		} catch (InvocationTargetException e) {
-			throw new IOException("Cannot send packet", e);
-		} catch (IllegalAccessException e) {
-			throw new IOException("Cannot send packet", e);
-		}
-	}
-	
-	/**
-	 * Determine if Minecraft allows asynchronous processing of this packet.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public boolean isMinecraftAsync(PacketEvent event) throws FieldAccessException {
-		
-		if (isMinecraftAsync == null && !alwaysSync) {
-			try {
-				isMinecraftAsync = FuzzyReflection.fromClass(Packet.class).getMethodByName("a_.*");
-			} catch (RuntimeException e) {
-				// This will occur in 1.2.5 (or possibly in later versions)
-				List<Method> methods = FuzzyReflection.fromClass(Packet.class).
-										getMethodListByParameters(boolean.class, new Class[] {});
-				
-				// Try to look for boolean methods
-				if (methods.size() == 2) {
-					isMinecraftAsync = methods.get(1);
-				} else if (methods.size() == 1) {
-					// We're in 1.2.5
-					alwaysSync = true;
-				} else {
-					System.err.println("Cannot determine asynchronous state of packets!");
-					alwaysSync = true;
-				}
-			}
-		}
-		
-		if (alwaysSync) {
-			return false;
-		} else {
-			try {
-				// Wrap exceptions 
-				return (Boolean) isMinecraftAsync.invoke(event.getPacket().getHandle());
-			} catch (IllegalArgumentException e) {
-				throw new FieldAccessException("Illegal argument", e);
-			} catch (IllegalAccessException e) {
-				throw new FieldAccessException("Unable to reflect method call 'a_', or: isAsyncPacket.", e);
-			} catch (InvocationTargetException e) {
-				throw new FieldAccessException("Minecraft error", e);
-			}
-		}
-	}
-	
-	@Override
-	public int compareTo(AsyncMarker o) {
-		if (o == null)
-			return 1;
-		else
-			return Longs.compare(getNewSendingIndex(), o.getNewSendingIndex());
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+
+import com.comphenix.protocol.PacketStream;
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLogger;
+import com.comphenix.protocol.events.NetworkMarker;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.injector.PrioritizedListener;
+import com.comphenix.protocol.reflect.FieldAccessException;
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.utility.MinecraftVersion;
+import com.google.common.primitives.Longs;
+
+/**
+ * Contains information about the packet that is being processed by asynchronous listeners.
+ * <p>
+ * Asynchronous listeners can use this to set packet timeout or transmission order.
+ * 
+ * @author Kristian
+ */
+public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
+		
+	/**
+	 * Generated by Eclipse.
+	 */
+	private static final long serialVersionUID = -2621498096616187384L;
+
+	/**
+	 * Default number of milliseconds until a packet will rejected.
+	 */
+	public static final int DEFAULT_TIMEOUT_DELTA = 1800 * 1000;
+	
+	/**
+	 * Default number of packets to skip.
+	 */
+	public static final int DEFAULT_SENDING_DELTA = 0;
+	
+	/**
+	 * The packet stream responsible for transmitting the packet when it's done processing.
+	 */
+	private transient PacketStream packetStream;
+	
+	/**
+	 * Current list of async packet listeners.
+	 */
+	private transient Iterator<PrioritizedListener<AsyncListenerHandler>> listenerTraversal;
+	
+	// Timeout handling
+	private long initialTime;
+	private long timeout;
+	
+	// Packet order
+	private long originalSendingIndex;
+	private long newSendingIndex;
+	
+	// Used to determine if a packet must be reordered in the sending queue
+	private Long queuedSendingIndex;
+	
+	// Whether or not the packet has been processed by the listeners
+	private volatile boolean processed;
+	
+	// Whether or not the packet has been sent
+	private volatile boolean transmitted;
+	
+	// Whether or not the asynchronous processing itself should be cancelled
+	private volatile boolean asyncCancelled;
+	
+		// Whether or not to delay processing
+	private AtomicInteger processingDelay = new AtomicInteger();
+	
+	// Used to synchronize processing on the shared PacketEvent
+	private Object processingLock = new Object();
+	
+	// Used to identify the asynchronous worker
+	private transient AsyncListenerHandler listenerHandler;
+	private transient int workerID;
+	
+	// Determine if Minecraft processes this packet asynchronously
+	private volatile static Method isMinecraftAsync;
+	private volatile static boolean alwaysSync;
+
+	/**
+	 * Create a container for asyncronous packets.
+	 * @param initialTime - the current time in milliseconds since 01.01.1970 00:00.
+	 */
+	AsyncMarker(PacketStream packetStream, long sendingIndex, long initialTime, long timeoutDelta) {
+		if (packetStream == null)
+			throw new IllegalArgumentException("packetStream cannot be NULL");
+		
+		this.packetStream = packetStream;
+		
+		// Timeout
+		this.initialTime = initialTime;
+		this.timeout = initialTime + timeoutDelta;
+		
+		// Sending index
+		this.originalSendingIndex = sendingIndex;
+		this.newSendingIndex = sendingIndex;
+	}
+	
+	/**
+	 * Retrieve the time the packet was initially queued for asynchronous processing.
+	 * @return The initial time in number of milliseconds since 01.01.1970 00:00.
+	 */
+	public long getInitialTime() {
+		return initialTime;
+	}
+
+	/**
+	 * Retrieve the time the packet will be forcefully rejected.
+	 * @return The time to reject the packet, in milliseconds since 01.01.1970 00:00.
+	 */
+	public long getTimeout() {
+		return timeout;
+	}
+	
+	/**
+	 * Set the time the packet will be forcefully rejected.
+	 * @param timeout - time to reject the packet, in milliseconds since 01.01.1970 00:00.
+	 */
+	public void setTimeout(long timeout) {
+		this.timeout = timeout;
+	}
+
+	/**
+	 * Retrieve the order the packet was originally transmitted.
+	 * @return The original packet index.
+	 */
+	public long getOriginalSendingIndex() {
+		return originalSendingIndex;
+	}
+
+	/**
+	 * Retrieve the desired sending order after processing has completed.
+	 * <p>
+	 * Higher sending order means lower priority.
+	 * @return Desired sending order.
+	 */
+	public long getNewSendingIndex() {
+		return newSendingIndex;
+	}
+
+	/**
+	 * Sets the desired sending order after processing has completed.
+	 * <p>
+	 * Higher sending order means lower priority.
+	 * @param newSendingIndex - new packet send index.
+	 */
+	public void setNewSendingIndex(long newSendingIndex) {
+		this.newSendingIndex = newSendingIndex;
+	}
+
+	/**
+	 * Retrieve the packet stream responsible for transmitting this packet.
+	 * @return The packet stream.
+	 */
+	public PacketStream getPacketStream() {
+		return packetStream;
+	}
+
+	/**
+	 * Sets the output packet stream responsible for transmitting this packet.
+	 * @param packetStream - new output packet stream.
+	 */
+	public void setPacketStream(PacketStream packetStream) {
+		this.packetStream = packetStream;
+	}
+
+	/**
+	 * Retrieve whether or not this packet has been processed by the async listeners.
+	 * @return TRUE if it has been processed, FALSE otherwise.
+	 */
+	public boolean isProcessed() {
+		return processed;
+	}
+
+	/**
+	 * Sets whether or not this packet has been processed by the async listeners.
+	 * @param processed - TRUE if it has, FALSE otherwise.
+	 */
+	void setProcessed(boolean processed) {
+		this.processed = processed;
+	}
+
+	/**
+	 * Increment the number of times the current packet must be signalled as done before its transmitted.
+	 * <p>
+	 * This is useful if an asynchronous listener is waiting for further information before the
+	 * packet can be sent to the user. A packet listener <b>MUST</b> eventually call
+	 * {@link AsyncFilterManager#signalPacketTransmission(PacketEvent)},
+	 * even if the packet is cancelled, after this method is called.
+	 * <p>
+	 * It is recommended that processing outside a packet listener is wrapped in a synchronized block
+	 * using the {@link #getProcessingLock()} method.
+	 * 
+	 * @return The new processing delay.
+	 */
+	public int incrementProcessingDelay() {
+		return processingDelay.incrementAndGet();
+	}
+	
+	/**
+	 * Decrement the number of times this packet must be signalled as done before it's transmitted.
+	 * @return The new processing delay. If zero, the packet should be sent.
+	 */
+	int decrementProcessingDelay() {
+		return processingDelay.decrementAndGet();
+	}
+	
+	/**
+	 * Retrieve the number of times a packet must be signalled to be done before it's sent.
+	 * @return Number of processing delays.
+	 */
+	public int getProcessingDelay() {
+		return processingDelay.get();
+	}
+	
+	/**
+	 * Whether or not this packet is or has been queued for processing.
+	 * @return TRUE if it has, FALSE otherwise.
+	 */
+	public boolean isQueued() {
+		return queuedSendingIndex != null;
+	}
+
+	/**
+	 * Retrieve the sending index when the packet was queued.
+	 * @return Queued sending index.
+	 */
+	public long getQueuedSendingIndex() {
+		return queuedSendingIndex != null ? queuedSendingIndex : 0;
+	}
+
+	/**
+	 * Set the sending index when the packet was queued.
+	 * @param queuedSendingIndex - sending index.
+	 */
+	void setQueuedSendingIndex(Long queuedSendingIndex) {
+		this.queuedSendingIndex = queuedSendingIndex;
+	}
+
+	/**
+	 * Processing lock used to synchronize access to the parent PacketEvent and PacketContainer.
+	 * <p>
+	 * This lock is automatically acquired for every asynchronous packet listener. It should only be
+	 * used to synchronize access to a PacketEvent if it's processing has been delayed.
+	 * @return A processing lock.
+	 */
+	public Object getProcessingLock() {
+		return processingLock;
+	}
+
+	public void setProcessingLock(Object processingLock) {
+		this.processingLock = processingLock;
+	}
+
+	/**
+	 * Retrieve whether or not this packet has already been sent.
+	 * @return TRUE if it has been sent before, FALSE otherwise.
+	 */
+	public boolean isTransmitted() {
+		return transmitted;
+	}
+
+	/**
+	 * Determine if this packet has expired.
+	 * @return TRUE if it has, FALSE otherwise.
+	 */
+	public boolean hasExpired() {
+		return hasExpired(System.currentTimeMillis());
+	}
+	
+	/**
+	 * Determine if this packet has expired given this time.
+	 * @param currentTime - the current time in milliseconds since 01.01.1970 00:00.
+	 * @return TRUE if it has, FALSE otherwise.
+	 */
+	public boolean hasExpired(long currentTime) {
+		return timeout < currentTime;
+	}
+	
+	/**
+	 * Determine if the asynchronous handling should be cancelled.
+	 * @return TRUE if it should, FALSE otherwise.
+	 */
+	public boolean isAsyncCancelled() {
+		return asyncCancelled;
+	}
+
+	/**
+	 * Set whether or not the asynchronous handling should be cancelled.
+	 * <p>
+	 * This is only relevant during the synchronous processing. Asynchronous
+	 * listeners should use the normal cancel-field to cancel a PacketEvent.
+	 * 
+	 * @param asyncCancelled - TRUE to cancel it, FALSE otherwise.
+	 */
+	public void setAsyncCancelled(boolean asyncCancelled) {
+		this.asyncCancelled = asyncCancelled;
+	}
+
+	/**
+	 * Retrieve the current asynchronous listener handler.
+	 * @return Asychronous listener handler, or NULL if this packet is not asynchronous.
+	 */
+	public AsyncListenerHandler getListenerHandler() {
+		return listenerHandler;
+	}
+
+	/**
+	 * Set the current asynchronous listener handler.
+	 * <p>
+	 * Used by the worker to update the value.
+	 * @param listenerHandler - new listener handler.
+	 */
+	void setListenerHandler(AsyncListenerHandler listenerHandler) {
+		this.listenerHandler = listenerHandler;
+	}
+
+	/**
+	 * Retrieve the current worker ID.
+	 * @return Current worker ID.
+	 */
+	public int getWorkerID() {
+		return workerID;
+	}
+
+	/**
+	 * Set the current worker ID.
+	 * <p>
+	 * Used by the worker.
+	 * @param workerID - new worker ID.
+	 */
+	void setWorkerID(int workerID) {
+		this.workerID = workerID;
+	}
+
+	/**
+	 * Retrieve iterator for the next listener in line.
+	 * @return Next async packet listener iterator.
+	 */
+	Iterator<PrioritizedListener<AsyncListenerHandler>> getListenerTraversal() {
+		return listenerTraversal;
+	}
+	
+	/**
+	 * Set the iterator for the next listener.
+	 * @param listenerTraversal - the new async packet listener iterator.
+	 */
+	void setListenerTraversal(Iterator<PrioritizedListener<AsyncListenerHandler>> listenerTraversal) {
+		this.listenerTraversal = listenerTraversal;
+	}
+	
+	/**
+	 * Transmit a given packet to the current packet stream.
+	 * @param event - the packet to send.
+	 * @throws IOException If the packet couldn't be sent.
+	 */
+	void sendPacket(PacketEvent event) throws IOException {
+		try {
+			if (event.isServerPacket()) {
+				packetStream.sendServerPacket(event.getPlayer(), event.getPacket(), NetworkMarker.getNetworkMarker(event), false);
+			} else {
+				packetStream.recieveClientPacket(event.getPlayer(), event.getPacket(), NetworkMarker.getNetworkMarker(event), false);
+			}
+			transmitted = true;
+			
+		} catch (InvocationTargetException e) {
+			throw new IOException("Cannot send packet", e);
+		} catch (IllegalAccessException e) {
+			throw new IOException("Cannot send packet", e);
+		}
+	}
+	
+	/**
+	 * Determine if Minecraft allows asynchronous processing of this packet.
+	 * @param event - packet event
+	 * @return TRUE if it does, FALSE otherwise.
+	 * @throws FieldAccessException If determining fails for some reasaon
+	 */
+	public boolean isMinecraftAsync(PacketEvent event) throws FieldAccessException {
+		if (isMinecraftAsync == null && !alwaysSync) {
+			try {
+				isMinecraftAsync = FuzzyReflection.fromClass(MinecraftReflection.getPacketClass()).getMethodByName("a_.*");
+			} catch (RuntimeException e) {
+				// This will occur in 1.2.5 (or possibly in later versions)
+				List<Method> methods = FuzzyReflection.fromClass(MinecraftReflection.getPacketClass()).
+										getMethodListByParameters(boolean.class, new Class[] {});
+				
+				// Try to look for boolean methods
+				if (methods.size() == 2) {
+					isMinecraftAsync = methods.get(1);
+				} else if (methods.size() == 1) {
+					// We're in 1.2.5
+					alwaysSync = true;
+				} else if (MinecraftVersion.getCurrentVersion().isAtLeast(MinecraftVersion.BOUNTIFUL_UPDATE)) {
+					// The centralized async marker was removed in 1.8
+					// Incoming chat packets can be async
+					if (event.getPacketType() == PacketType.Play.Client.CHAT) {
+						String content = event.getPacket().getStrings().readSafely(0);
+						if (content != null) {
+							// Incoming chat packets are async only if they aren't commands
+							return ! content.startsWith("/");
+						} else {
+							ProtocolLogger.log(Level.WARNING, "Failed to determine contents of incoming chat packet!");
+							alwaysSync = true;
+						}
+					} else if (event.getPacketType() == PacketType.Status.Server.SERVER_INFO) {
+						return true;
+					} else {
+						// TODO: Find more cases of async packets
+						return false;
+					}
+				} else {
+					ProtocolLogger.log(Level.INFO, "Could not determine asynchronous state of packets (this can probably be ignored)");
+					alwaysSync = true;
+				}
+			}
+		}
+
+		if (alwaysSync) {
+			return false;
+		} else {
+			try {
+				// Wrap exceptions
+				return (Boolean) isMinecraftAsync.invoke(event.getPacket().getHandle());
+			} catch (IllegalArgumentException e) {
+				throw new FieldAccessException("Illegal argument", e);
+			} catch (IllegalAccessException e) {
+				throw new FieldAccessException("Unable to reflect method call 'a_', or: isAsyncPacket.", e);
+			} catch (InvocationTargetException e) {
+				throw new FieldAccessException("Minecraft error", e);
+			}
+		}
+	}
+	
+	@Override
+	public int compareTo(AsyncMarker o) {
+		if (o == null)
+			return 1;
+		else
+			return Longs.compare(getNewSendingIndex(), o.getNewSendingIndex());
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		// Standard equals
+		if (other == this)
+			return true;
+		if (other instanceof AsyncMarker)
+			return getNewSendingIndex() == ((AsyncMarker) other).getNewSendingIndex();
+		else
+			return false;
+	}
+	
+	@Override
+	public int hashCode() {
+		return Longs.hashCode(getNewSendingIndex());
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncRunnable.java

@@ -0,0 +1,53 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+/**
+ * A runnable representing a asynchronous event listener.
+ * 
+ * @author Kristian
+ */
+public interface AsyncRunnable extends Runnable {
+	
+	/**
+	 * Retrieve a unique worker ID.
+	 * @return Unique worker ID.
+	 */
+	public int getID();
+	
+	/**
+	 * Stop the given runnable.
+	 * <p>
+	 * This may not occur right away.
+	 * @return TRUE if the thread was stopped, FALSE if it was already stopped.
+	 * @throws InterruptedException if it is interrupted
+	 */
+	public boolean stop() throws InterruptedException;
+	
+	/**
+	 * Determine if we're running or not.
+	 * @return TRUE if we're running, FALSE otherwise.
+	 */
+	public boolean isRunning();
+
+	/**
+	 * Determine if this runnable has already run its course.
+	 * @return TRUE if it has been stopped, FALSE otherwise.
+	 */
+	boolean isFinished();
+}

modules/API/src/main/java/com/comphenix/protocol/async/NullPacketListener.java

@@ -1,62 +1,81 @@
-package com.comphenix.protocol.async;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.events.ListenerPriority;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-
-/**
- * Represents a NO OPERATION listener.
- * 
- * @author Kristian
- */
-class NullPacketListener implements PacketListener {
-	
-	private ListeningWhitelist sendingWhitelist;
-	private ListeningWhitelist receivingWhitelist;
-	private Plugin plugin;
-
-	/**
-	 * Create a no-op listener with the same whitelist and plugin as the given listener.
-	 * @param original - the packet listener to copy.
-	 */
-	public NullPacketListener(PacketListener original) {
-		this.sendingWhitelist = cloneWhitelist(ListenerPriority.LOW, original.getSendingWhitelist());
-		this.receivingWhitelist = cloneWhitelist(ListenerPriority.LOW, original.getReceivingWhitelist());
-		this.plugin = original.getPlugin();
-	}
-
-	@Override
-	public void onPacketSending(PacketEvent event) {
-		// NULL
-	}
-
-	@Override
-	public void onPacketReceiving(PacketEvent event) {
-		// NULL
-	}
-
-	@Override
-	public ListeningWhitelist getSendingWhitelist() {
-		return sendingWhitelist;
-	}
-
-	@Override
-	public ListeningWhitelist getReceivingWhitelist() {
-		return receivingWhitelist;
-	}
-	
-	private ListeningWhitelist cloneWhitelist(ListenerPriority priority, ListeningWhitelist whitelist) {
-		if (whitelist != null) 
-			return new ListeningWhitelist(priority, whitelist.getWhitelist());
-		else 
-			return null;
-	}
-
-	@Override
-	public Plugin getPlugin() {
-		return plugin;
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.events.ListenerOptions;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.ListeningWhitelist;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.events.PacketListener;
+
+/**
+ * Represents a NO OPERATION listener.
+ * 
+ * @author Kristian
+ */
+class NullPacketListener implements PacketListener {
+	
+	private ListeningWhitelist sendingWhitelist;
+	private ListeningWhitelist receivingWhitelist;
+	private Plugin plugin;
+
+	/**
+	 * Create a no-op listener with the same whitelist and plugin as the given listener.
+	 * @param original - the packet listener to copy.
+	 */
+	public NullPacketListener(PacketListener original) {
+		this.sendingWhitelist = cloneWhitelist(ListenerPriority.LOW, original.getSendingWhitelist());
+		this.receivingWhitelist = cloneWhitelist(ListenerPriority.LOW, original.getReceivingWhitelist());
+		this.plugin = original.getPlugin();
+	}
+
+	@Override
+	public void onPacketSending(PacketEvent event) {
+		// NULL
+	}
+
+	@Override
+	public void onPacketReceiving(PacketEvent event) {
+		// NULL
+	}
+
+	@Override
+	public ListeningWhitelist getSendingWhitelist() {
+		return sendingWhitelist;
+	}
+
+	@Override
+	public ListeningWhitelist getReceivingWhitelist() {
+		return receivingWhitelist;
+	}
+	
+	private ListeningWhitelist cloneWhitelist(ListenerPriority priority, ListeningWhitelist whitelist) {
+		if (whitelist != null) 
+			// We don't use the Bukkit API, so don't engage the ProtocolLib synchronization code
+			return ListeningWhitelist.newBuilder(whitelist).priority(priority).mergeOptions(ListenerOptions.ASYNC).build();
+		else 
+			return null;
+	}
+
+	@Override
+	public Plugin getPlugin() {
+		return plugin;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/PacketEventHolder.java

@@ -0,0 +1,76 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import com.comphenix.protocol.events.PacketEvent;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ComparisonChain;
+import com.google.common.primitives.Longs;
+
+/**
+ * Provides a comparable to a packet event.
+ * 
+ * @author Kristian
+ */
+class PacketEventHolder implements Comparable<PacketEventHolder> {
+
+	private PacketEvent event;
+	private long sendingIndex = 0;
+	
+	/**
+	 * A wrapper that ensures the packet event is ordered by sending index.
+	 * @param event - packet event to wrap.
+	 */
+	public PacketEventHolder(PacketEvent event) {
+		this.event = Preconditions.checkNotNull(event, "Event must be non-null");
+		
+		if (event.getAsyncMarker() != null)
+			this.sendingIndex = event.getAsyncMarker().getNewSendingIndex();
+	}
+
+	/**
+	 * Retrieve the stored event.
+	 * @return The stored event.
+	 */
+	public PacketEvent getEvent() {
+		return event;
+	}
+	
+	@Override
+	public int compareTo(PacketEventHolder other) {
+		return ComparisonChain.start().
+			   compare(sendingIndex, other.sendingIndex).
+			   result();
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		// Standard equals
+		if (other == this)
+			return true;
+		if (other instanceof PacketEventHolder)
+			return sendingIndex == ((PacketEventHolder) other).sendingIndex;
+		else
+			return false;
+	}
+	
+	@Override
+	public int hashCode() {
+		return Longs.hashCode(sendingIndex);
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/PacketProcessingQueue.java

@@ -1,152 +1,196 @@
-package com.comphenix.protocol.async;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Queue;
-import java.util.concurrent.Semaphore;
-
-import com.comphenix.protocol.concurrency.AbstractConcurrentListenerMultimap;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.google.common.collect.MinMaxPriorityQueue;
-
-
-/**
- * Handles the processing of every packet type.
- * 
- * @author Kristian
- */
-class PacketProcessingQueue extends AbstractConcurrentListenerMultimap<AsyncListenerHandler> {
-
-	// Initial number of elements
-	public static final int INITIAL_CAPACITY = 64;
-	
-	/**
-	 * Default maximum number of packets to process concurrently.
-	 */
-	public static final int DEFAULT_MAXIMUM_CONCURRENCY = 32;
-	
-	/**
-	 * Default maximum number of packets to queue for processing.
-	 */
-	public static final int DEFAULT_QUEUE_LIMIT = 1024 * 60;
-	
-	/**
-	 * Number of packets we're processing concurrently.
-	 */
-	private final int maximumConcurrency;
-	private Semaphore concurrentProcessing;
-	
-	// Queued packets for being processed
-	private Queue<PacketEventHolder> processingQueue;
-	
-	// Packets for sending
-	private PacketSendingQueue sendingQueue;
-
-	public PacketProcessingQueue(PacketSendingQueue sendingQueue) {
-		this(sendingQueue, INITIAL_CAPACITY, DEFAULT_QUEUE_LIMIT, DEFAULT_MAXIMUM_CONCURRENCY);
-	}
-	
-	public PacketProcessingQueue(PacketSendingQueue sendingQueue, int initialSize, int maximumSize, int maximumConcurrency) {
-		super();
-
-		this.processingQueue = Synchronization.queue(MinMaxPriorityQueue.
-				expectedSize(initialSize).
-				maximumSize(maximumSize).
-				<PacketEventHolder>create(), null);
-				
-		this.maximumConcurrency = maximumConcurrency;
-		this.concurrentProcessing = new Semaphore(maximumConcurrency);
-		this.sendingQueue = sendingQueue;
-	}
-	
-	/**
-	 * Enqueue a packet for processing by the asynchronous listeners.
-	 * @param packet - packet to process.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 * @return TRUE if we sucessfully queued the packet, FALSE if the queue ran out if space.
-	 */
-	public boolean enqueue(PacketEvent packet, boolean onMainThread) {
-		try {
-			processingQueue.add(new PacketEventHolder(packet));
-
-			// Begin processing packets
-			signalBeginProcessing(onMainThread);
-			return true;
-		} catch (IllegalStateException e) {
-			return false;
-		}
-	}
-	
-	/**
-	 * Number of packet events in the queue.
-	 * @return The number of packet events in the queue.
-	 */
-	public int size() {
-		return processingQueue.size();
-	}
-	
-	/**
-	 * Called by the current method and each thread to signal that a packet might be ready for processing.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public void signalBeginProcessing(boolean onMainThread) {	
-		while (concurrentProcessing.tryAcquire()) {
-			PacketEventHolder holder = processingQueue.poll();
-			
-			// Any packet queued?
-			if (holder != null) {
-				PacketEvent packet = holder.getEvent();
-				AsyncMarker marker = packet.getAsyncMarker();
-				Collection<PrioritizedListener<AsyncListenerHandler>> list = getListener(packet.getPacketID());
-				
-				// Yes, removing the marker will cause the chain to stop
-				if (list != null) {
-					Iterator<PrioritizedListener<AsyncListenerHandler>> iterator = list.iterator();
-					
-					if (iterator.hasNext()) {
-						marker.setListenerTraversal(iterator);
-						iterator.next().getListener().enqueuePacket(packet);
-						continue;
-					}
-				}
-				
-				// The packet has no further listeners. Just send it.
-				sendingQueue.signalPacketUpdate(packet, onMainThread);
-				signalProcessingDone();
-				
-			} else {
-				// No more queued packets.
-				signalProcessingDone();
-				return;
-			}
- 		}
-	}
-	
-	/**
-	 * Called when a packet has been processed.
-	 */
-	public void signalProcessingDone() {
-		concurrentProcessing.release();
-	}
-
-	/**
-	 * Retrieve the maximum number of packets to process at any given time.
-	 * @return Number of simultaneous packet to process.
-	 */
-	public int getMaximumConcurrency() {
-		return maximumConcurrency;
-	}
-	
-	public void cleanupAll() {
-		// Cancel all the threads and every listener
-		for (PrioritizedListener<AsyncListenerHandler> handler : values()) {
-			if (handler != null) {
-				handler.getListener().cancel();
-			}
-		}
-		
-		// Remove the rest, just in case
-		clearListeners();
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.concurrent.Semaphore;
+
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.concurrency.AbstractConcurrentListenerMultimap;
+import com.comphenix.protocol.error.Report;
+import com.comphenix.protocol.error.ReportType;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.injector.PrioritizedListener;
+import com.google.common.collect.MinMaxPriorityQueue;
+
+
+/**
+ * Handles the processing of every packet type.
+ * 
+ * @author Kristian
+ */
+class PacketProcessingQueue extends AbstractConcurrentListenerMultimap<AsyncListenerHandler> {
+	public static final ReportType REPORT_GUAVA_CORRUPT_MISSING = 
+			new ReportType("Guava is either missing or corrupt. Reverting to PriorityQueue.");
+
+	// Initial number of elements
+	public static final int INITIAL_CAPACITY = 64;
+	
+	/**
+	 * Default maximum number of packets to process concurrently.
+	 */
+	public static final int DEFAULT_MAXIMUM_CONCURRENCY = 32;
+	
+	/**
+	 * Default maximum number of packets to queue for processing.
+	 */
+	public static final int DEFAULT_QUEUE_LIMIT = 1024 * 60;
+	
+	/**
+	 * Number of packets we're processing concurrently.
+	 */
+	private final int maximumConcurrency;
+	private Semaphore concurrentProcessing;
+	
+	// Queued packets for being processed
+	private Queue<PacketEventHolder> processingQueue;
+	
+	// Packets for sending
+	private PlayerSendingHandler sendingHandler;
+	
+	public PacketProcessingQueue(PlayerSendingHandler sendingHandler) {
+		this(sendingHandler, INITIAL_CAPACITY, DEFAULT_QUEUE_LIMIT, DEFAULT_MAXIMUM_CONCURRENCY);
+	}
+	
+	public PacketProcessingQueue(PlayerSendingHandler sendingHandler, int initialSize, int maximumSize, int maximumConcurrency) {
+		super();
+
+		try {
+			this.processingQueue = Synchronization.queue(MinMaxPriorityQueue.
+					expectedSize(initialSize).
+					maximumSize(maximumSize).
+					<PacketEventHolder>create(), null);
+		} catch (IncompatibleClassChangeError e) {
+			// Print in the console
+			ProtocolLibrary.getErrorReporter().reportWarning(
+				this, Report.newBuilder(REPORT_GUAVA_CORRUPT_MISSING).error(e));
+			
+			// It's a Beta class after all
+			this.processingQueue = Synchronization.queue(
+					new PriorityQueue<PacketEventHolder>(), null);
+		}
+				
+		this.maximumConcurrency = maximumConcurrency;
+		this.concurrentProcessing = new Semaphore(maximumConcurrency);
+		this.sendingHandler = sendingHandler;
+	}
+	
+	/**
+	 * Enqueue a packet for processing by the asynchronous listeners.
+	 * @param packet - packet to process.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 * @return TRUE if we sucessfully queued the packet, FALSE if the queue ran out if space.
+	 */
+	public boolean enqueue(PacketEvent packet, boolean onMainThread) {
+		try {
+			processingQueue.add(new PacketEventHolder(packet));
+
+			// Begin processing packets
+			signalBeginProcessing(onMainThread);
+			return true;
+		} catch (IllegalStateException e) {
+			return false;
+		}
+	}
+	
+	/**
+	 * Number of packet events in the queue.
+	 * @return The number of packet events in the queue.
+	 */
+	public int size() {
+		return processingQueue.size();
+	}
+	
+	/**
+	 * Called by the current method and each thread to signal that a packet might be ready for processing.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 */
+	public void signalBeginProcessing(boolean onMainThread) {	
+		while (concurrentProcessing.tryAcquire()) {
+			PacketEventHolder holder = processingQueue.poll();
+			
+			// Any packet queued?
+			if (holder != null) {
+				PacketEvent packet = holder.getEvent();
+				AsyncMarker marker = packet.getAsyncMarker();
+				Collection<PrioritizedListener<AsyncListenerHandler>> list = getListener(packet.getPacketType());
+				
+				marker.incrementProcessingDelay();
+				
+				// Yes, removing the marker will cause the chain to stop
+				if (list != null) {
+					Iterator<PrioritizedListener<AsyncListenerHandler>> iterator = list.iterator();
+					
+					if (iterator.hasNext()) {
+						marker.setListenerTraversal(iterator);
+						iterator.next().getListener().enqueuePacket(packet);
+						continue;
+					}
+				}
+				
+				// The packet has no further listeners. Just send it.
+				if (marker.decrementProcessingDelay() == 0) {
+					PacketSendingQueue sendingQueue = sendingHandler.getSendingQueue(packet, false);
+					
+					// In case the player has logged out
+					if (sendingQueue != null)
+						sendingQueue.signalPacketUpdate(packet, onMainThread);
+				}
+				signalProcessingDone();
+				
+			} else {
+				// No more queued packets.
+				signalProcessingDone();
+				return;
+			}
+ 		}
+	}
+	
+	/**
+	 * Called when a packet has been processed.
+	 */
+	public void signalProcessingDone() {
+		concurrentProcessing.release();
+	}
+
+	/**
+	 * Retrieve the maximum number of packets to process at any given time.
+	 * @return Number of simultaneous packet to process.
+	 */
+	public int getMaximumConcurrency() {
+		return maximumConcurrency;
+	}
+	
+	public void cleanupAll() {
+		// Cancel all the threads and every listener
+		for (PrioritizedListener<AsyncListenerHandler> handler : values()) {
+			if (handler != null) {
+				handler.getListener().cancel();
+			}
+		}
+		
+		// Remove the rest, just in case
+		clearListeners();
+		
+		// Remove every packet in the queue
+		processingQueue.clear();
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/PacketSendingQueue.java

@@ -0,0 +1,307 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.PriorityBlockingQueue;
+
+import org.bukkit.entity.Player;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.error.Report;
+import com.comphenix.protocol.error.ReportType;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.injector.PlayerLoggedOutException;
+import com.comphenix.protocol.reflect.FieldAccessException;
+
+/**
+ * Represents packets ready to be transmitted to a client.
+ * @author Kristian
+ */
+abstract class PacketSendingQueue {
+	public static final ReportType REPORT_DROPPED_PACKET = new ReportType("Warning: Dropped packet index %s of type %s.");
+	
+	public static final int INITIAL_CAPACITY = 10;
+	
+	private PriorityBlockingQueue<PacketEventHolder> sendingQueue;
+	
+	// Asynchronous packet sending
+	private Executor asynchronousSender;
+	// Whether or not packet transmission must occur on a specific thread
+	private final boolean notThreadSafe;
+	// Whether or not we've run the cleanup procedure
+	private boolean cleanedUp = false;
+	
+	/**
+	 * Create a packet sending queue.
+	 * @param notThreadSafe - whether or not to synchronize with the main thread or a background thread.
+	 */
+	public PacketSendingQueue(boolean notThreadSafe, Executor asynchronousSender) {
+		this.sendingQueue = new PriorityBlockingQueue<PacketEventHolder>(INITIAL_CAPACITY);
+		this.notThreadSafe = notThreadSafe;
+		this.asynchronousSender = asynchronousSender;
+	}
+	
+	/**
+	 * Number of packet events in the queue.
+	 * @return The number of packet events in the queue.
+	 */
+	public int size() {
+		return sendingQueue.size();
+	}
+	
+	/**
+	 * Enqueue a packet for sending. 
+	 * @param packet - packet to queue.
+	 */
+	public void enqueue(PacketEvent packet) {
+		sendingQueue.add(new PacketEventHolder(packet));
+	}
+	
+	/**
+	 * Invoked when one of the packets have finished processing.
+	 * @param packetUpdated - the packet that has now been updated.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 */
+	public synchronized void signalPacketUpdate(PacketEvent packetUpdated, boolean onMainThread) {
+		
+		AsyncMarker marker = packetUpdated.getAsyncMarker();
+		
+		// Should we reorder the event?
+		if (marker.getQueuedSendingIndex() != marker.getNewSendingIndex() && !marker.hasExpired()) {
+			PacketEvent copy = PacketEvent.fromSynchronous(packetUpdated, marker);
+			
+			// "Cancel" the original event
+			packetUpdated.setReadOnly(false);
+			packetUpdated.setCancelled(true);
+			
+			// Enqueue the copy with the new sending index
+			enqueue(copy);
+		}
+		
+		// Mark this packet as finished
+		marker.setProcessed(true);
+		trySendPackets(onMainThread);
+	}
+
+	/***
+	 * Invoked when a list of packet IDs are no longer associated with any listeners.
+	 * @param packetsRemoved - packets that no longer have any listeners.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 */
+	public synchronized void signalPacketUpdate(List<PacketType> packetsRemoved, boolean onMainThread) {
+		Set<PacketType> lookup = new HashSet<PacketType>(packetsRemoved);
+		
+		// Note that this is O(n), so it might be expensive
+		for (PacketEventHolder holder : sendingQueue) {
+			PacketEvent event = holder.getEvent();
+			
+			if (lookup.contains(event.getPacketType())) {
+				event.getAsyncMarker().setProcessed(true);
+			}
+		}
+		
+		// This is likely to have changed the situation a bit
+		trySendPackets(onMainThread);
+	}
+	
+	/**
+	 * Attempt to send any remaining packets.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 */
+	public void trySendPackets(boolean onMainThread) {
+		// Whether or not to continue sending packets
+		boolean sending = true;
+		
+		// Transmit as many packets as we can
+		while (sending) {
+			PacketEventHolder holder = sendingQueue.poll();
+			
+			if (holder != null) {
+				sending = processPacketHolder(onMainThread, holder);
+					
+				if (!sending) {
+					// Add it back again
+					sendingQueue.add(holder);
+				}
+				
+			} else {
+				// No more packets to send
+				sending = false;
+			}
+		}
+	}
+	
+	/**
+	 * Invoked when a packet might be ready for transmission.
+	 * @param onMainThread - TRUE if we're on the main thread, FALSE otherwise.
+	 * @param holder - packet container.
+	 * @return TRUE to continue sending packets, FALSE otherwise.
+	 */
+	private boolean processPacketHolder(boolean onMainThread, final PacketEventHolder holder) {
+		PacketEvent current = holder.getEvent();
+		AsyncMarker marker = current.getAsyncMarker();
+		boolean hasExpired = marker.hasExpired();
+		
+		// Guard in cause the queue is closed
+		if (cleanedUp) {
+			return true;
+		}
+				
+		// End condition?
+		if (marker.isProcessed() || hasExpired) {
+			if (hasExpired) {
+				// Notify timeout listeners
+				onPacketTimeout(current);
+				
+				// Recompute
+				marker = current.getAsyncMarker();
+				hasExpired = marker.hasExpired();
+				
+				// Could happen due to the timeout listeners
+				if (!marker.isProcessed() && !hasExpired) {
+					return false;
+				}
+			}
+			
+			// Is it okay to send the packet?
+			if (!current.isCancelled() && !hasExpired) {
+				// Make sure we're on the main thread
+				if (notThreadSafe) {
+					try {
+						boolean wantAsync = marker.isMinecraftAsync(current);
+						boolean wantSync = !wantAsync;
+						
+						// Wait for the next main thread heartbeat if we haven't fulfilled our promise
+						if (!onMainThread && wantSync) {
+							return false;
+						}
+						
+						// Let's give it what it wants
+						if (onMainThread && wantAsync) {
+							asynchronousSender.execute(new Runnable() {
+								@Override
+								public void run() {
+									// We know this isn't on the main thread
+									processPacketHolder(false, holder);
+								}
+							});
+							
+							// Scheduler will do the rest
+							return true;
+						}
+						
+					} catch (FieldAccessException e) {
+						e.printStackTrace();
+						
+						// Just drop the packet
+						return true;
+					}
+				} 
+				
+				// Silently skip players that have logged out
+				if (isOnline(current.getPlayer())) {
+					sendPacket(current);
+				}
+			} 
+			
+			// Drop the packet
+			return true;
+		}
+		
+		// Add it back and stop sending
+		return false;
+	}
+	
+	/**
+	 * Invoked when a packet has timed out.
+	 * @param event - the timed out packet.
+	 */
+	protected abstract void onPacketTimeout(PacketEvent event);
+	
+	private boolean isOnline(Player player) {
+		return player != null && player.isOnline();
+	}
+	
+	/**
+	 * Send every packet, regardless of the processing state.
+	 */
+	private void forceSend() {
+		while (true) {
+			PacketEventHolder holder = sendingQueue.poll();
+			
+			if (holder != null) {
+				sendPacket(holder.getEvent());
+			} else {
+				break;
+			}
+		}
+	}
+	
+	/**
+	 * Whether or not the packet transmission must synchronize with the main thread.
+	 * @return TRUE if it must, FALSE otherwise.
+	 */
+	public boolean isSynchronizeMain() {
+		return notThreadSafe;
+	}
+
+	/**
+	 * Transmit a packet, if it hasn't already.
+	 * @param event - the packet to transmit.
+	 */
+	private void sendPacket(PacketEvent event) {
+		
+		AsyncMarker marker = event.getAsyncMarker();
+		
+		try {
+			// Don't send a packet twice
+			if (marker != null && !marker.isTransmitted()) {
+				marker.sendPacket(event);
+			}
+		
+		} catch (PlayerLoggedOutException e) {
+			ProtocolLibrary.getErrorReporter().reportDebug(this, Report.newBuilder(REPORT_DROPPED_PACKET).
+				messageParam(marker.getOriginalSendingIndex(), event.getPacketType()).
+				callerParam(event)
+			);
+			
+		} catch (IOException e) {
+			// Just print the error
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Automatically transmits every delayed packet.
+	 */
+	public void cleanupAll() {
+		if (!cleanedUp) {
+			// Note that the cleanup itself will always occur on the main thread
+			forceSend();
+			
+			// And we're done
+			cleanedUp = true;
+		}
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/PlayerSendingHandler.java

@@ -0,0 +1,264 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+import org.bukkit.entity.Player;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.concurrency.ConcurrentPlayerMap;
+import com.comphenix.protocol.error.ErrorReporter;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.injector.SortedPacketListenerList;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+
+/**
+ * Contains every sending queue for every player.
+ * 
+ * @author Kristian
+ */
+class PlayerSendingHandler {
+	private ErrorReporter reporter;
+	private ConcurrentMap<Player, QueueContainer> playerSendingQueues;
+	
+	// Timeout listeners
+	private SortedPacketListenerList serverTimeoutListeners;
+	private SortedPacketListenerList clientTimeoutListeners;
+	
+	// Asynchronous packet sending
+	private Executor asynchronousSender;
+	
+	// Whether or not we're currently cleaning up
+	private volatile boolean cleaningUp;
+	
+	/**
+	 * Sending queues for a given player.
+	 * 
+	 * @author Kristian
+	 */
+	private class QueueContainer {
+		private PacketSendingQueue serverQueue;
+		private PacketSendingQueue clientQueue;
+		
+		public QueueContainer() {
+			// Server packets can be sent concurrently
+			serverQueue = new PacketSendingQueue(false, asynchronousSender) {
+				@Override
+				protected void onPacketTimeout(PacketEvent event) {
+					if (!cleaningUp) {
+						serverTimeoutListeners.invokePacketSending(reporter, event);
+					}
+				}
+			};
+			
+			// Client packets must be synchronized
+			clientQueue = new PacketSendingQueue(true, asynchronousSender) {
+				@Override
+				protected void onPacketTimeout(PacketEvent event) {
+					if (!cleaningUp) {
+						clientTimeoutListeners.invokePacketSending(reporter, event);
+					}
+				}
+			};
+		}
+
+		public PacketSendingQueue getServerQueue() {
+			return serverQueue;
+		}
+
+		public PacketSendingQueue getClientQueue() {
+			return clientQueue;
+		}
+	}
+	
+	/**
+	 * Initialize a packet sending handler.
+	 * @param reporter - error reporter.
+	 * @param serverTimeoutListeners - set of server timeout listeners.
+	 * @param clientTimeoutListeners - set of client timeout listeners.
+	 */
+	public PlayerSendingHandler(ErrorReporter reporter, 
+			SortedPacketListenerList serverTimeoutListeners, SortedPacketListenerList clientTimeoutListeners) {
+		
+		this.reporter = reporter;
+		this.serverTimeoutListeners = serverTimeoutListeners;
+		this.clientTimeoutListeners = clientTimeoutListeners;
+		
+		// Initialize storage of queues
+		this.playerSendingQueues = ConcurrentPlayerMap.usingAddress();
+	}
+	
+	/**
+	 * Start the asynchronous packet sender.
+	 */
+	public synchronized void initializeScheduler() {
+		if (asynchronousSender == null) {
+			ThreadFactory factory = new ThreadFactoryBuilder().
+				setDaemon(true).
+				setNameFormat("ProtocolLib-AsyncSender %s").
+				build();
+			asynchronousSender = Executors.newSingleThreadExecutor(factory);
+		}
+	}
+
+	/**
+	 * Retrieve the sending queue this packet belongs to.
+	 * @param packet - the packet.
+	 * @return The server or client sending queue the packet belongs to.
+	 */
+	public PacketSendingQueue getSendingQueue(PacketEvent packet) {
+		return getSendingQueue(packet, true);
+	}
+	
+	/**
+	 * Retrieve the sending queue this packet belongs to.
+	 * @param packet - the packet.
+	 * @param createNew - if TRUE, create a new queue if it hasn't already been created.
+	 * @return The server or client sending queue the packet belongs to.
+	 */
+	public PacketSendingQueue getSendingQueue(PacketEvent packet, boolean createNew) {
+		QueueContainer queues = playerSendingQueues.get(packet.getPlayer());
+		
+		// Safe concurrent initialization
+		if (queues == null && createNew) {
+			final QueueContainer newContainer = new QueueContainer();
+
+			// Attempt to map the queue
+			queues = playerSendingQueues.putIfAbsent(packet.getPlayer(), newContainer);
+			
+			if (queues == null) {
+				queues = newContainer;
+			}
+		}
+		
+		// Check for NULL again
+		if (queues != null)
+			return packet.isServerPacket() ? queues.getServerQueue() : queues.getClientQueue();
+		else
+			return null;
+	}
+
+	/**
+	 * Send all pending packets.
+	 */
+	public void sendAllPackets() {
+		if (!cleaningUp) {
+			for (QueueContainer queues : playerSendingQueues.values()) {
+				queues.getClientQueue().cleanupAll();
+				queues.getServerQueue().cleanupAll();
+			}
+		}
+	}
+	
+	/**
+	 * Immediately send every server packet with the given list of IDs.
+	 * @param types - types of every packet to send immediately.
+	 * @param synchronusOK - whether or not we're running on the main thread. 
+	 */
+	public void sendServerPackets(List<PacketType> types, boolean synchronusOK) {
+		if (!cleaningUp) {
+			for (QueueContainer queue : playerSendingQueues.values()) {
+				queue.getServerQueue().signalPacketUpdate(types, synchronusOK);
+			}
+		}
+	}
+	
+	/**
+	 * Immediately send every client packet with the given list of IDs.
+	 * @param ids - ID of every packet to send immediately.
+	 * @param synchronusOK - whether or not we're running on the main thread. 
+	 */
+	public void sendClientPackets(List<PacketType> types, boolean synchronusOK) {
+		if (!cleaningUp) {
+			for (QueueContainer queue : playerSendingQueues.values()) {
+				queue.getClientQueue().signalPacketUpdate(types, synchronusOK);
+			}
+		}
+	}
+	
+	/**
+	 * Send any outstanding server packets.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 */
+	public void trySendServerPackets(boolean onMainThread) {
+		for (QueueContainer queue : playerSendingQueues.values()) {
+			queue.getServerQueue().trySendPackets(onMainThread);
+		}
+	}
+	
+	/**
+	 * Send any outstanding server packets.
+	 * @param onMainThread - whether or not this is occuring on the main thread.
+	 */
+	public void trySendClientPackets(boolean onMainThread) {
+		for (QueueContainer queue : playerSendingQueues.values()) {
+			queue.getClientQueue().trySendPackets(onMainThread);
+		}
+	}
+	
+	/**
+	 * Retrieve every server packet queue for every player.
+	 * @return Every sever packet queue.
+	 */
+	public List<PacketSendingQueue> getServerQueues() {
+		List<PacketSendingQueue> result = new ArrayList<PacketSendingQueue>();
+		
+		for (QueueContainer queue : playerSendingQueues.values())
+			result.add(queue.getServerQueue());
+		return result;
+	}
+	
+	/**
+	 * Retrieve every client packet queue for every player.
+	 * @return Every client packet queue.
+	 */
+	public List<PacketSendingQueue> getClientQueues() {
+		List<PacketSendingQueue> result = new ArrayList<PacketSendingQueue>();
+		
+		for (QueueContainer queue : playerSendingQueues.values())
+			result.add(queue.getClientQueue());
+		return result;
+	}
+	
+	/**
+	 * Send all pending packets and clean up queues.
+	 */
+	public void cleanupAll() {
+		if (!cleaningUp) {
+			cleaningUp = true;
+			
+			sendAllPackets();
+			playerSendingQueues.clear();
+		}
+	}
+
+	/**
+	 * Invoked when a player has just logged out.
+	 * @param player - the player that just logged out.
+	 */
+	public void removePlayer(Player player) {
+		// Every packet will be dropped - there's nothing we can do
+		playerSendingQueues.remove(player);
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/async/Synchronization.java

@@ -1,211 +1,228 @@
-package com.comphenix.protocol.async;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Queue;
-
-import javax.annotation.Nullable;
-
-import com.google.common.base.Preconditions;
-
-/**
- * Synchronization views copied from Google Guava.
- * 
- * @author Kristian
- */
-class Synchronization {
-
-	/**
-	 * Create a synchronized wrapper for the given queue.
-	 * <p>
-	 * This wrapper cannot synchronize the iterator(). Callers are expected 
-	 * to synchronize iterators manually.
-	 * @param queue - the queue to synchronize.
-	 * @param mutex - synchronization mutex, or NULL to use the queue.
-	 * @return A synchronization wrapper.
-	 */
-	public static <E> Queue<E> queue(Queue<E> queue, @Nullable Object mutex) {
-		return (queue instanceof SynchronizedQueue) ? 
-				queue : 
-					new SynchronizedQueue<E>(queue, mutex);
-	}
-	
-	private static class SynchronizedObject implements Serializable {
-		private static final long serialVersionUID = -4408866092364554628L;
-
-		final Object delegate;
-		final Object mutex;
-
-		SynchronizedObject(Object delegate, @Nullable Object mutex) {
-			this.delegate = Preconditions.checkNotNull(delegate);
-			this.mutex = (mutex == null) ? this : mutex;
-		}
-
-		Object delegate() {
-			return delegate;
-		}
-
-		// No equals and hashCode; see ForwardingObject for details.
-
-		@Override
-		public String toString() {
-			synchronized (mutex) {
-				return delegate.toString();
-			}
-		}
-	}
-
-	private static class SynchronizedCollection<E> extends SynchronizedObject implements Collection<E> {
-		private static final long serialVersionUID = 5440572373531285692L;
-
-		private SynchronizedCollection(Collection<E> delegate,
-				@Nullable Object mutex) {
-			super(delegate, mutex);
-		}
-
-		@SuppressWarnings("unchecked")
-		@Override
-		Collection<E> delegate() {
-			return (Collection<E>) super.delegate();
-		}
-
-		@Override
-		public boolean add(E e) {
-			synchronized (mutex) {
-				return delegate().add(e);
-			}
-		}
-
-		@Override
-		public boolean addAll(Collection<? extends E> c) {
-			synchronized (mutex) {
-				return delegate().addAll(c);
-			}
-		}
-
-		@Override
-		public void clear() {
-			synchronized (mutex) {
-				delegate().clear();
-			}
-		}
-
-		@Override
-		public boolean contains(Object o) {
-			synchronized (mutex) {
-				return delegate().contains(o);
-			}
-		}
-
-		@Override
-		public boolean containsAll(Collection<?> c) {
-			synchronized (mutex) {
-				return delegate().containsAll(c);
-			}
-		}
-
-		@Override
-		public boolean isEmpty() {
-			synchronized (mutex) {
-				return delegate().isEmpty();
-			}
-		}
-
-		@Override
-		public Iterator<E> iterator() {
-			return delegate().iterator(); // manually synchronized
-		}
-
-		@Override
-		public boolean remove(Object o) {
-			synchronized (mutex) {
-				return delegate().remove(o);
-			}
-		}
-
-		@Override
-		public boolean removeAll(Collection<?> c) {
-			synchronized (mutex) {
-				return delegate().removeAll(c);
-			}
-		}
-
-		@Override
-		public boolean retainAll(Collection<?> c) {
-			synchronized (mutex) {
-				return delegate().retainAll(c);
-			}
-		}
-
-		@Override
-		public int size() {
-			synchronized (mutex) {
-				return delegate().size();
-			}
-		}
-
-		@Override
-		public Object[] toArray() {
-			synchronized (mutex) {
-				return delegate().toArray();
-			}
-		}
-
-		@Override
-		public <T> T[] toArray(T[] a) {
-			synchronized (mutex) {
-				return delegate().toArray(a);
-			}
-		}
-
-	}
-
-	private static class SynchronizedQueue<E> extends SynchronizedCollection<E> implements Queue<E> {
-		private static final long serialVersionUID = 1961791630386791902L;
-
-		SynchronizedQueue(Queue<E> delegate, @Nullable Object mutex) {
-			super(delegate, mutex);
-		}
-
-		@Override
-		Queue<E> delegate() {
-			return (Queue<E>) super.delegate();
-		}
-
-		@Override
-		public E element() {
-			synchronized (mutex) {
-				return delegate().element();
-			}
-		}
-
-		@Override
-		public boolean offer(E e) {
-			synchronized (mutex) {
-				return delegate().offer(e);
-			}
-		}
-
-		@Override
-		public E peek() {
-			synchronized (mutex) {
-				return delegate().peek();
-			}
-		}
-
-		@Override
-		public E poll() {
-			synchronized (mutex) {
-				return delegate().poll();
-			}
-		}
-
-		@Override
-		public E remove() {
-			synchronized (mutex) {
-				return delegate().remove();
-			}
-		}
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.async;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Queue;
+
+import javax.annotation.Nullable;
+
+import com.google.common.base.Preconditions;
+
+/**
+ * Synchronization views copied from Google Guava.
+ * 
+ * @author Kristian
+ */
+class Synchronization {
+
+	/**
+	 * Create a synchronized wrapper for the given queue.
+	 * <p>
+	 * This wrapper cannot synchronize the iterator(). Callers are expected 
+	 * to synchronize iterators manually.
+	 * @param queue - the queue to synchronize.
+	 * @param mutex - synchronization mutex, or NULL to use the queue.
+	 * @return A synchronization wrapper.
+	 */
+	public static <E> Queue<E> queue(Queue<E> queue, @Nullable Object mutex) {
+		return (queue instanceof SynchronizedQueue) ? 
+				queue : 
+					new SynchronizedQueue<E>(queue, mutex);
+	}
+	
+	private static class SynchronizedObject implements Serializable {
+		private static final long serialVersionUID = -4408866092364554628L;
+
+		final Object delegate;
+		final Object mutex;
+
+		SynchronizedObject(Object delegate, @Nullable Object mutex) {
+			this.delegate = Preconditions.checkNotNull(delegate);
+			this.mutex = (mutex == null) ? this : mutex;
+		}
+
+		Object delegate() {
+			return delegate;
+		}
+
+		// No equals and hashCode; see ForwardingObject for details.
+
+		@Override
+		public String toString() {
+			synchronized (mutex) {
+				return delegate.toString();
+			}
+		}
+	}
+
+	private static class SynchronizedCollection<E> extends SynchronizedObject implements Collection<E> {
+		private static final long serialVersionUID = 5440572373531285692L;
+
+		private SynchronizedCollection(Collection<E> delegate,
+				@Nullable Object mutex) {
+			super(delegate, mutex);
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		Collection<E> delegate() {
+			return (Collection<E>) super.delegate();
+		}
+
+		@Override
+		public boolean add(E e) {
+			synchronized (mutex) {
+				return delegate().add(e);
+			}
+		}
+
+		@Override
+		public boolean addAll(Collection<? extends E> c) {
+			synchronized (mutex) {
+				return delegate().addAll(c);
+			}
+		}
+
+		@Override
+		public void clear() {
+			synchronized (mutex) {
+				delegate().clear();
+			}
+		}
+
+		@Override
+		public boolean contains(Object o) {
+			synchronized (mutex) {
+				return delegate().contains(o);
+			}
+		}
+
+		@Override
+		public boolean containsAll(Collection<?> c) {
+			synchronized (mutex) {
+				return delegate().containsAll(c);
+			}
+		}
+
+		@Override
+		public boolean isEmpty() {
+			synchronized (mutex) {
+				return delegate().isEmpty();
+			}
+		}
+
+		@Override
+		public Iterator<E> iterator() {
+			return delegate().iterator(); // manually synchronized
+		}
+
+		@Override
+		public boolean remove(Object o) {
+			synchronized (mutex) {
+				return delegate().remove(o);
+			}
+		}
+
+		@Override
+		public boolean removeAll(Collection<?> c) {
+			synchronized (mutex) {
+				return delegate().removeAll(c);
+			}
+		}
+
+		@Override
+		public boolean retainAll(Collection<?> c) {
+			synchronized (mutex) {
+				return delegate().retainAll(c);
+			}
+		}
+
+		@Override
+		public int size() {
+			synchronized (mutex) {
+				return delegate().size();
+			}
+		}
+
+		@Override
+		public Object[] toArray() {
+			synchronized (mutex) {
+				return delegate().toArray();
+			}
+		}
+
+		@Override
+		public <T> T[] toArray(T[] a) {
+			synchronized (mutex) {
+				return delegate().toArray(a);
+			}
+		}
+
+	}
+
+	private static class SynchronizedQueue<E> extends SynchronizedCollection<E> implements Queue<E> {
+		private static final long serialVersionUID = 1961791630386791902L;
+
+		SynchronizedQueue(Queue<E> delegate, @Nullable Object mutex) {
+			super(delegate, mutex);
+		}
+
+		@Override
+		Queue<E> delegate() {
+			return (Queue<E>) super.delegate();
+		}
+
+		@Override
+		public E element() {
+			synchronized (mutex) {
+				return delegate().element();
+			}
+		}
+
+		@Override
+		public boolean offer(E e) {
+			synchronized (mutex) {
+				return delegate().offer(e);
+			}
+		}
+
+		@Override
+		public E peek() {
+			synchronized (mutex) {
+				return delegate().peek();
+			}
+		}
+
+		@Override
+		public E poll() {
+			synchronized (mutex) {
+				return delegate().poll();
+			}
+		}
+
+		@Override
+		public E remove() {
+			synchronized (mutex) {
+				return delegate().remove();
+			}
+		}
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/collections/ExpireHashMap.java

@@ -0,0 +1,246 @@
+package com.comphenix.protocol.collections;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.PriorityQueue;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import com.google.common.base.Function;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Ticker;
+import com.google.common.collect.Maps;
+import com.google.common.primitives.Longs;
+
+/**
+ * Represents a hash map where each association may expire after a given time has elapsed.
+ * <p>
+ * Note that replaced key-value associations are only collected once the original expiration time has elapsed. 
+ * 
+ * @author Kristian Stangeland
+ *
+ * @param <K> - type of the keys.
+ * @param <V> - type of the values.
+ */
+public class ExpireHashMap<K, V> {
+	private class ExpireEntry implements Comparable<ExpireEntry> {
+		public final long expireTime;
+		public final K expireKey;
+		public final V expireValue;
+		
+		public ExpireEntry(long expireTime, K expireKey, V expireValue) {
+			this.expireTime = expireTime;
+			this.expireKey = expireKey;
+			this.expireValue = expireValue;
+		}
+
+		@Override
+		public int compareTo(ExpireEntry o) {
+			return Longs.compare(expireTime, o.expireTime);
+		}
+
+		@Override
+		public String toString() {
+			return "ExpireEntry [expireTime=" + expireTime + ", expireKey=" + expireKey
+					+ ", expireValue=" + expireValue + "]";
+		}
+	}
+	
+	private Map<K, ExpireEntry> keyLookup = new HashMap<K, ExpireEntry>();
+	private PriorityQueue<ExpireEntry> expireQueue =  new PriorityQueue<ExpireEntry>();
+	
+	// View of keyLookup with direct values
+	private Map<K, V> valueView = Maps.transformValues(keyLookup, new Function<ExpireEntry, V>() {
+		@Override
+		public V apply(ExpireEntry entry) {
+			return entry.expireValue;
+		}
+	});
+	
+	// Supplied by the constructor
+	private Ticker ticker;
+	
+	/**
+	 * Construct a new hash map where each entry may expire at a given time.
+	 */
+	public ExpireHashMap() {
+		this(Ticker.systemTicker());
+	}
+	
+	/**
+	 * Construct a new hash map where each entry may expire at a given time.
+	 * @param ticker - supplier of the current time.
+	 */
+	public ExpireHashMap(Ticker ticker) {
+		this.ticker = ticker;
+	}
+	
+	/**
+	 * Retrieve the value associated with the given key, if it has not expired.
+	 * @param key - the key.
+	 * @return The value, or NULL if not found or it has expired.
+	 */
+	public V get(K key) {
+		evictExpired();
+		
+		ExpireEntry entry = keyLookup.get(key);
+		return entry != null ? entry.expireValue : null;
+	}
+	
+	/**
+	 * Associate the given key with the given value, until the expire delay have elapsed.
+	 * @param key - the key.
+	 * @param value - the value.
+	 * @param expireDelay - the amount of time until this association expires. Must be greater than zero.
+	 * @param expireUnit - the unit of the expiration.
+	 * @return Any previously unexpired association with this key, or NULL.
+	 */
+	public V put(K key, V value, long expireDelay, TimeUnit expireUnit) {
+		Preconditions.checkNotNull(expireUnit, "expireUnit cannot be NULL");
+		Preconditions.checkState(expireDelay > 0, "expireDelay cannot be equal or less than zero.");
+		evictExpired();
+		
+		ExpireEntry entry = new ExpireEntry(
+			ticker.read() + TimeUnit.NANOSECONDS.convert(expireDelay, expireUnit), 
+			key, value
+		); 
+		ExpireEntry previous = keyLookup.put(key, entry);
+		
+		// We enqueue its removal
+		expireQueue.add(entry);
+		return previous != null ? previous.expireValue : null;
+	}
+	
+	/**
+	 * Determine if the given key is referring to an unexpired association in the map.
+ 	 * @param key - the key.
+	 * @return TRUE if it is, FALSE otherwise.
+	 */
+	public boolean containsKey(K key) {
+		evictExpired();
+		return keyLookup.containsKey(key);
+	}
+	
+	/**
+	 * Determine if the given value is referring to an unexpired association in the map.
+ 	 * @param value - the value.
+	 * @return TRUE if it is, FALSE otherwise.
+	 */
+	public boolean containsValue(V value) {
+		evictExpired();
+		
+		// Linear scan is the best we've got
+		for (ExpireEntry entry : keyLookup.values()) {
+			if (Objects.equal(value, entry.expireValue)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Remove a key and its associated value from the map.
+	 * @param key - the key to remove.
+	 * @return Value of the removed association, NULL otherwise.
+	 */
+	public V removeKey(K key) {
+		evictExpired();
+		
+		ExpireEntry entry = keyLookup.remove(key);
+		return entry != null ? entry.expireValue : null;
+	}
+	
+	/**
+	 * Retrieve the number of entries in the map.
+	 * @return The number of entries.
+	 */
+	public int size() {
+		evictExpired();
+		return keyLookup.size();
+	}
+	
+	/**
+	 * Retrieve a view of the keys in the current map.
+	 * @return View of the keys.
+	 */
+	public Set<K> keySet() {
+		evictExpired();
+		return keyLookup.keySet();
+	}
+	
+	/**
+	 * Retrieve a view of all the values in the current map.
+	 * @return All the values.
+	 */
+	public Collection<V> values() {
+		evictExpired();
+		return valueView.values();
+	}
+	
+	/**
+	 * Retrieve a view of all the entries in the set.
+	 * @return All the entries.
+	 */
+	public Set<Entry<K, V>> entrySet() {
+		evictExpired();
+		return valueView.entrySet();
+	}
+	
+	/**
+	 * Retrieve a view of this expire map as an ordinary map that does not support insertion.
+	 * @return The map.
+	 */
+	public Map<K, V> asMap() {
+		evictExpired();
+		return valueView;
+	}
+	
+	/**
+	 * Clear all references to key-value pairs that have been removed or replaced before they were naturally evicted.
+	 * <p>
+	 * This operation requires a linear scan of the current entries in the map.
+	 */
+	public void collect() {
+		// First evict what we can
+		evictExpired();
+		
+		// Recreate the eviction queue - this is faster than removing entries in the old queue
+		expireQueue.clear();
+		expireQueue.addAll(keyLookup.values());
+	}
+	
+	/**
+	 * Clear all the entries in the current map.
+	 */
+	public void clear() {
+		keyLookup.clear();
+		expireQueue.clear();
+	}
+	
+	/**
+	 * Evict any expired entries in the map.
+	 * <p>
+	 * This is called automatically by any of the read or write operations.
+	 */
+	protected void evictExpired() {
+		long currentTime = ticker.read();
+		
+		// Remove expired entries
+		while (expireQueue.size() > 0 && expireQueue.peek().expireTime <= currentTime) {
+			ExpireEntry entry = expireQueue.poll();
+
+			if (entry == keyLookup.get(entry.expireKey)) {
+				keyLookup.remove(entry.expireKey);
+			}
+		}
+	}
+	
+	@Override
+	public String toString() {
+		return valueView.toString();
+	}
+}
+ 

modules/API/src/main/java/com/comphenix/protocol/collections/IntegerMap.java

@@ -0,0 +1,140 @@
+package com.comphenix.protocol.collections;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+
+/**
+ * Represents a very quick integer-based lookup map, with a fixed key space size.
+ * <p>
+ * Integers must be non-negative.
+ * @author Kristian
+ */
+public class IntegerMap<T> {
+	private T[] array;
+	private int size;
+	
+	/**
+	 * Construct a new integer map.
+	 * @param <T> Parameter type
+	 * @return A new integer map.
+	 */
+	public static <T> IntegerMap<T> newMap() {
+		return new IntegerMap<T>();
+	}
+	
+	/**
+	 * Construct a new integer map with a default capacity.
+	 */
+	public IntegerMap() {
+		this(8);
+	}
+	
+	/**
+	 * Construct a new integer map with a given capacity.
+	 * @param initialCapacity - the capacity.
+	 */
+	public IntegerMap(int initialCapacity) {
+		@SuppressWarnings("unchecked")
+		T[] backingArray = (T[]) new Object[initialCapacity];
+		this.array = backingArray;
+		this.size = 0;
+	}
+
+	/**
+	 * Associate an integer key with the given value.
+	 * @param key - the integer key. Cannot be negative.
+	 * @param value - the value. Cannot be NULL.
+	 * @return The previous association, or NULL if not found.
+	 */
+	public T put(int key, T value) {
+		ensureCapacity(key);
+		
+		T old = array[key];
+		array[key] = Preconditions.checkNotNull(value, "value cannot be NULL");
+		
+		if (old == null)
+			size++;
+		return old;
+	}
+	
+	/**
+	 * Remove an association from the map.
+	 * @param key - the key of the association to remove.
+	 * @return The old associated value, or NULL.
+	 */
+	public T remove(int key) {
+		T old = array[key];
+		array[key] = null;
+		
+		if (old != null)
+			size--;
+		return old;
+	}
+	
+	/**
+	 * Resize the backing array to fit the given key.
+	 * @param key - the key.
+	 */
+	protected void ensureCapacity(int key) {
+		int newLength = array.length;
+
+		// Don't resize if the key fits
+		if (key < 0)
+			throw new IllegalArgumentException("Negative key values are not permitted.");
+		if (key < newLength)
+			return;
+		
+		while (newLength <= key) {
+			int next = newLength * 2;
+			// Handle overflow
+			newLength = next > newLength ? next : Integer.MAX_VALUE;
+		}
+		this.array = Arrays.copyOf(array, newLength);
+	}
+	
+	/**
+	 * Retrieve the number of mappings in this map.
+	 * @return The number of mapping.
+	 */
+	public int size() {
+		return size;
+	}
+
+	/**
+	 * Retrieve the value associated with a given key.
+	 * @param key - the key.
+	 * @return The value, or NULL if not found.
+	 */
+	public T get(int key) {
+		if (key >= 0 && key < array.length)
+			return array[key];
+		return null;
+	}
+	
+	/**
+	 * Determine if the given key exists in the map.
+	 * @param key - the key to check.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	public boolean containsKey(int key) {
+		return get(key) != null;
+	}
+	
+	/**
+	 * Convert the current map to an Integer map.
+	 * @return The Integer map.
+	 */
+	public Map<Integer, Object> toMap() {
+		Map<Integer, Object> map = Maps.newHashMap();
+		
+		for (int i = 0; i < array.length; i++) {
+			if (array[i] != null) {
+				map.put(i, array[i]);
+			}
+		}
+		return map;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/AbstractConcurrentListenerMultimap.java

@@ -1,131 +1,144 @@
-package com.comphenix.protocol.concurrency;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.google.common.collect.Iterables;
-
-/**
- * A thread-safe implementation of a listener multimap.
- * 
- * @author Kristian
- */
-public abstract class AbstractConcurrentListenerMultimap<TListener> {
-
-	// The core of our map
-	private ConcurrentMap<Integer, SortedCopyOnWriteArray<PrioritizedListener<TListener>>> listeners = 
-		new ConcurrentHashMap<Integer, SortedCopyOnWriteArray<PrioritizedListener<TListener>>>();
-	
-	/**
-	 * Adds a listener to its requested list of packet recievers.
-	 * @param listener - listener with a list of packets to recieve notifcations for.
-	 * @param whitelist - the packet whitelist to use.
-	 */
-	public void addListener(TListener listener, ListeningWhitelist whitelist) {
-		
-		PrioritizedListener<TListener> prioritized = new PrioritizedListener<TListener>(listener, whitelist.getPriority());
-		
-		for (Integer packetID : whitelist.getWhitelist()) {
-			addListener(packetID, prioritized);
-		}
-	}
-	
-	// Add the listener to a specific packet notifcation list
-	private void addListener(Integer packetID, PrioritizedListener<TListener> listener) {
-		
-		SortedCopyOnWriteArray<PrioritizedListener<TListener>> list = listeners.get(packetID);
-		
-		// We don't want to create this for every lookup
-		if (list == null) {
-			// It would be nice if we could use a PriorityBlockingQueue, but it doesn't preseve iterator order,
-			// which is a essential feature for our purposes.
-			final SortedCopyOnWriteArray<PrioritizedListener<TListener>> value = new SortedCopyOnWriteArray<PrioritizedListener<TListener>>();
-			
-			list = listeners.putIfAbsent(packetID, value);
-			
-			// We may end up creating multiple multisets, but we'll agree 
-			// on the one to use.
-			if (list == null) {
-				list = value;
-			}
-		}
-		
-		// Thread safe
-		list.add(listener);
-	}
-	
-	/**
-	 * Removes the given listener from the packet event list.
-	 * @param listener - listener to remove.
-	 * @param whitelist - the packet whitelist that was used.
-	 * @return Every packet ID that was removed due to no listeners.
-	 */
-	public List<Integer> removeListener(TListener listener, ListeningWhitelist whitelist) {
-	
-		List<Integer> removedPackets = new ArrayList<Integer>();
-		
-		// Again, not terribly efficient. But adding or removing listeners should be a rare event.
-		for (Integer packetID : whitelist.getWhitelist()) {
-			
-			SortedCopyOnWriteArray<PrioritizedListener<TListener>> list = listeners.get(packetID);
-			
-			// Remove any listeners
-			if (list != null) {
-				// Don't remove from newly created lists
-				if (list.size() > 0) {
-					// Remove this listener. Note that priority is generally ignored.
-					list.remove(new PrioritizedListener<TListener>(listener, whitelist.getPriority()));
-					
-					if (list.size() == 0) {
-						listeners.remove(packetID);
-						removedPackets.add(packetID);
-					}
-				}
-			}
-			
-			// Move on to the next
-		}
-		
-		return removedPackets;
-	}
-	
-	/**
-	 * Retrieve the registered listeners, in order from the lowest to the highest priority.
-	 * <p>
-	 * The returned list is thread-safe and doesn't require synchronization.
-	 * @param packetID - packet ID.
-	 * @return Registered listeners.
-	 */
-	public Collection<PrioritizedListener<TListener>> getListener(int packetID) {
-		return listeners.get(packetID);
-	}
-	
-	/**
-	 * Retrieve every listener.
-	 * @return Every listener.
-	 */
-	public Iterable<PrioritizedListener<TListener>> values() {
-		return Iterables.concat(listeners.values());
-	}
-	
-	/**
-	 * Retrieve every registered packet ID:
-	 * @return Registered packet ID.
-	 */
-	public Set<Integer> keySet() {
-		return listeners.keySet();
-	}
-	
-	/**
-	 * Remove all packet listeners.
-	 */
-	protected void clearListeners() {
-		listeners.clear();
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.concurrency;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.ListeningWhitelist;
+import com.comphenix.protocol.injector.PrioritizedListener;
+import com.google.common.collect.Iterables;
+
+/**
+ * A thread-safe implementation of a listener multimap.
+ * 
+ * @author Kristian
+ */
+public abstract class AbstractConcurrentListenerMultimap<TListener> {
+	// The core of our map
+	private ConcurrentMap<PacketType, SortedCopyOnWriteArray<PrioritizedListener<TListener>>> mapListeners;
+	
+	public AbstractConcurrentListenerMultimap() {
+		mapListeners =   new ConcurrentHashMap<PacketType, SortedCopyOnWriteArray<PrioritizedListener<TListener>>>();
+	}
+	
+	/**
+	 * Adds a listener to its requested list of packet receivers.
+	 * @param listener - listener with a list of packets to receive notifications for.
+	 * @param whitelist - the packet whitelist to use.
+	 */
+	public void addListener(TListener listener, ListeningWhitelist whitelist) {
+		PrioritizedListener<TListener> prioritized = new PrioritizedListener<TListener>(listener, whitelist.getPriority());
+		
+		for (PacketType type : whitelist.getTypes()) {
+			addListener(type, prioritized);
+		}
+	}
+	
+	// Add the listener to a specific packet notifcation list
+	private void addListener(PacketType type, PrioritizedListener<TListener> listener) {
+		SortedCopyOnWriteArray<PrioritizedListener<TListener>> list = mapListeners.get(type);
+		
+		// We don't want to create this for every lookup
+		if (list == null) {
+			// It would be nice if we could use a PriorityBlockingQueue, but it doesn't preseve iterator order,
+			// which is a essential feature for our purposes.
+			final SortedCopyOnWriteArray<PrioritizedListener<TListener>> value = new SortedCopyOnWriteArray<PrioritizedListener<TListener>>();
+
+			// We may end up creating multiple multisets, but we'll agree on which to use
+			list = mapListeners.putIfAbsent(type, value);
+		
+			if (list == null) {
+				list = value;
+			}
+		}
+		
+		// Thread safe
+		list.add(listener);
+	}
+	
+	/**
+	 * Removes the given listener from the packet event list.
+	 * @param listener - listener to remove.
+	 * @param whitelist - the packet whitelist that was used.
+	 * @return Every packet ID that was removed due to no listeners.
+	 */
+	public List<PacketType> removeListener(TListener listener, ListeningWhitelist whitelist) {
+		List<PacketType> removedPackets = new ArrayList<PacketType>();
+		
+		// Again, not terribly efficient. But adding or removing listeners should be a rare event.
+		for (PacketType type : whitelist.getTypes()) {
+			SortedCopyOnWriteArray<PrioritizedListener<TListener>> list = mapListeners.get(type);
+			
+			// Remove any listeners
+			if (list != null) {
+				// Don't remove from newly created lists
+				if (list.size() > 0) {
+					// Remove this listener. Note that priority is generally ignored.
+					list.remove(new PrioritizedListener<TListener>(listener, whitelist.getPriority()));
+					
+					if (list.size() == 0) {
+						mapListeners.remove(type);
+						removedPackets.add(type);
+					}
+				}
+			}
+			// Move on to the next
+		}
+		return removedPackets;
+	}
+	
+	/**
+	 * Retrieve the registered listeners, in order from the lowest to the highest priority.
+	 * <p>
+	 * The returned list is thread-safe and doesn't require synchronization.
+	 * @param type - packet type.
+	 * @return Registered listeners.
+	 */
+	public Collection<PrioritizedListener<TListener>> getListener(PacketType type) {
+		return mapListeners.get(type);
+	}
+	
+	/**
+	 * Retrieve every listener.
+	 * @return Every listener.
+	 */
+	public Iterable<PrioritizedListener<TListener>> values() {
+		return Iterables.concat(mapListeners.values());
+	}
+	
+	/**
+	 * Retrieve every registered packet type:
+	 * @return Registered packet type.
+	 */
+	public Set<PacketType> keySet() {
+		return mapListeners.keySet();
+	}
+	
+	/**
+	 * Remove all packet listeners.
+	 */
+	protected void clearListeners() {
+		mapListeners.clear();
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/AbstractIntervalTree.java

@@ -0,0 +1,494 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.concurrency;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.Set;
+import java.util.TreeMap;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Range;
+
+/**
+ * Represents a generic store of intervals and associated values. No two intervals
+ * can overlap in this representation.
+ * <p>
+ * Note that this implementation is not thread safe.
+ * 
+ * @author Kristian
+ *
+ * @param <TKey> - type of the key. Must implement Comparable.
+ * @param <TValue> - type of the value to associate.
+ */
+public abstract class AbstractIntervalTree<TKey extends Comparable<TKey>, TValue> {
+	
+	protected enum State {
+		OPEN,
+		CLOSE,
+		BOTH
+	}
+	
+	/**
+	 * Represents a range and a value in this interval tree.
+	 */
+	public class Entry implements Map.Entry<Range<TKey>, TValue> {
+		private EndPoint left;
+		private EndPoint right;
+
+		Entry(EndPoint left, EndPoint right) {
+			if (left == null)
+				throw new IllegalAccessError("left cannot be NUll");
+			if (right == null)
+				throw new IllegalAccessError("right cannot be NUll");
+			if (left.key.compareTo(right.key) > 0)
+				throw new IllegalArgumentException(
+						"Left key (" + left.key + ") cannot be greater than the right key (" + right.key + ")");
+			
+			this.left = left;
+			this.right = right;
+		}
+
+		@Override
+		public Range<TKey> getKey() {
+			return Range.closed(left.key, right.key);
+		}
+
+		@Override
+		public TValue getValue() {
+			return left.value;
+		}
+
+		@Override
+		public TValue setValue(TValue value) {
+			TValue old = left.value;
+			
+			// Set both end points
+			left.value = value;
+			right.value = value;
+			return old;
+		}
+		
+		@SuppressWarnings("rawtypes")
+		@Override
+		public boolean equals(Object obj) {
+			// Quick equality check
+			if (obj == this) {
+				return true;
+			} else if (obj instanceof AbstractIntervalTree.Entry) {
+				return Objects.equal(left.key, ((AbstractIntervalTree.Entry) obj).left.key) &&
+					   Objects.equal(right.key, ((AbstractIntervalTree.Entry) obj).right.key) &&
+					   Objects.equal(left.value, ((AbstractIntervalTree.Entry) obj).left.value);
+			} else {
+				return false;
+			}
+		}
+		
+		@Override
+		public int hashCode() {
+			return Objects.hashCode(left.key, right.key, left.value);
+		}
+		
+		@Override
+		public String toString() {
+			return String.format("Value %s at [%s, %s]", left.value, left.key, right.key);
+		}
+	}
+	
+	/**
+	 * Represents a single end point (open, close or both) of a range.
+	 */
+	protected class EndPoint {
+		
+		// Whether or not the end-point is opening a range, closing a range or both.
+		public State state;
+		
+		// The value this range contains
+		public TValue value;
+		
+		// The key of this end point
+		public TKey key;
+
+		public EndPoint(State state, TKey key, TValue value) {
+			this.state = state;
+			this.key = key;
+			this.value = value;
+		}
+	}
+	
+	// To quickly look up ranges we'll index them by endpoints
+	protected NavigableMap<TKey, EndPoint> bounds = new TreeMap<TKey, EndPoint>();
+	
+	/**
+	 * Removes every interval that intersects with the given range.
+	 * @param lowerBound - lowest value to remove.
+	 * @param upperBound - highest value to remove.
+	 * @return Intervals that were removed
+	 */
+	public Set<Entry> remove(TKey lowerBound, TKey upperBound) {
+		return remove(lowerBound, upperBound, false);
+	}
+	
+	/**
+	 * Removes every interval that intersects with the given range.
+	 * @param lowerBound - lowest value to remove.
+	 * @param upperBound - highest value to remove.
+	 * @param preserveDifference - whether or not to preserve the intervals that are partially outside.
+	 * @return Intervals that were removed
+	 */
+	public Set<Entry> remove(TKey lowerBound, TKey upperBound, boolean preserveDifference) {
+		checkBounds(lowerBound, upperBound);
+		NavigableMap<TKey, EndPoint> range = bounds.subMap(lowerBound, true, upperBound, true);
+		
+		EndPoint first = getNextEndPoint(lowerBound, true);
+		EndPoint last = getPreviousEndPoint(upperBound, true);
+		
+		// Used while resizing intervals
+		EndPoint previous = null;
+		EndPoint next = null;
+		
+		Set<Entry> resized = new HashSet<Entry>();
+		Set<Entry> removed = new HashSet<Entry>();
+		
+		// Remove the previous element too. A close end-point must be preceded by an OPEN end-point.
+		if (first != null && first.state == State.CLOSE) {
+			previous = getPreviousEndPoint(first.key, false);
+			
+			// Add the interval back
+			if (previous != null) {
+				removed.add(getEntry(previous, first));
+			}
+		}
+		
+		// Get the closing element too.
+		if (last != null && last.state == State.OPEN) {
+			next = getNextEndPoint(last.key, false);
+		
+			if (next != null) {
+				removed.add(getEntry(last, next));
+			}
+		}
+		
+		// Now remove both ranges
+		removeEntrySafely(previous, first);
+		removeEntrySafely(last, next);
+		
+		// Add new resized intervals
+		if (preserveDifference) {
+			if (previous != null) {
+				resized.add(putUnsafe(previous.key, decrementKey(lowerBound), previous.value));
+			}
+			if (next != null) {
+				resized.add(putUnsafe(incrementKey(upperBound), next.key, next.value));
+			}
+		}
+		
+		// Get the removed entries too
+		getEntries(removed, range);
+		invokeEntryRemoved(removed);
+		
+		if (preserveDifference) {
+			invokeEntryAdded(resized);
+		}
+		
+		// Remove the range as well
+		range.clear();
+		return removed;
+	}
+	
+	/**
+	 * Retrieve the entry from a given set of end points.
+	 * @param left - leftmost end point.
+	 * @param right - rightmost end point.
+	 * @return The associated entry.
+	 */
+	protected Entry getEntry(EndPoint left, EndPoint right) {
+		if (left == null)
+			throw new IllegalArgumentException("left endpoint cannot be NULL.");
+		if (right == null)
+			throw new IllegalArgumentException("right endpoint cannot be NULL.");
+		
+		// Make sure the order is correct
+		if (right.key.compareTo(left.key) < 0) {
+			return getEntry(right, left);
+		} else {
+			return new Entry(left, right);
+		}
+	}
+	
+	private void removeEntrySafely(EndPoint left, EndPoint right) {
+		if (left != null && right != null) {
+			bounds.remove(left.key);
+			bounds.remove(right.key);
+		}
+	}
+	
+	// Adds a given end point
+	protected EndPoint addEndPoint(TKey key, TValue value, State state) {
+		EndPoint endPoint = bounds.get(key);
+		
+		if (endPoint != null) {
+			endPoint.state = State.BOTH;
+		} else {
+			endPoint = new EndPoint(state, key, value);
+			bounds.put(key, endPoint);
+		}
+		return endPoint;
+	}
+	
+	/**
+	 * Associates a given interval of keys with a certain value. Any previous
+	 * association will be overwritten in the given interval.
+	 * <p>
+	 * Overlapping intervals are not permitted. A key can only be associated with a single value.
+	 * 
+	 * @param lowerBound - the minimum key (inclusive).
+	 * @param upperBound - the maximum key (inclusive).
+	 * @param value - the value, or NULL to reset this range.
+	 */
+	public void put(TKey lowerBound, TKey upperBound, TValue value) {
+		// While we don't permit overlapping intervals, we'll still allow overwriting existing intervals.
+		remove(lowerBound, upperBound, true);
+		invokeEntryAdded(putUnsafe(lowerBound, upperBound, value));
+	}
+	
+	/**
+	 * Associates a given interval without performing any interval checks.
+	 * @param lowerBound - the minimum key (inclusive).
+	 * @param upperBound - the maximum key (inclusive).
+	 * @param value - the value, or NULL to reset the range.
+	 */
+	private Entry putUnsafe(TKey lowerBound, TKey upperBound, TValue value) {
+		// OK. Add the end points now
+		if (value != null) {
+			EndPoint left = addEndPoint(lowerBound, value, State.OPEN);
+			EndPoint right = addEndPoint(upperBound, value, State.CLOSE);
+
+			return new Entry(left, right);
+		} else {
+			return null;
+		}
+	}
+	
+	/**
+	 * Used to verify the validity of the given interval.
+	 * @param lowerBound - lower bound (inclusive).
+	 * @param upperBound - upper bound (inclusive).
+	 */
+	private void checkBounds(TKey lowerBound, TKey upperBound) {
+		if (lowerBound == null)
+			throw new IllegalAccessError("lowerbound cannot be NULL.");
+		if (upperBound == null)
+			throw new IllegalAccessError("upperBound cannot be NULL.");
+		if (upperBound.compareTo(lowerBound) < 0)
+			throw new IllegalArgumentException("upperBound cannot be less than lowerBound.");
+	}
+	
+	/**
+	 * Determines if the given key is within an interval.
+	 * @param key - key to check.
+	 * @return TRUE if the given key is within an interval in this tree, FALSE otherwise.
+	 */
+	public boolean containsKey(TKey key) {
+		return getEndPoint(key) != null;
+	}
+	
+	/**
+	 * Enumerates over every range in this interval tree.
+	 * @return Number of ranges.
+	 */
+	public Set<Entry> entrySet() {
+		// Don't mind the Java noise
+		Set<Entry> result = new HashSet<Entry>();
+		getEntries(result, bounds);
+		return result;
+	}
+	
+	/**
+	 * Remove every interval.
+	 */
+	public void clear() {
+		if (!bounds.isEmpty()) {
+			remove(bounds.firstKey(), bounds.lastKey());
+		}
+	}
+	
+	/**
+	 * Converts a map of end points into a set of entries.
+	 * @param destination - set of entries.
+	 * @param map - a map of end points.
+	 */
+	private void getEntries(Set<Entry> destination, NavigableMap<TKey, EndPoint> map) {
+		Map.Entry<TKey, EndPoint> last = null;
+		
+		for (Map.Entry<TKey, EndPoint> entry : map.entrySet()) {
+			switch (entry.getValue().state) {
+			case BOTH:
+				EndPoint point = entry.getValue();
+				destination.add(new Entry(point, point));
+				break;
+			case CLOSE:
+				if (last != null) {
+					destination.add(new Entry(last.getValue(), entry.getValue()));
+				}
+				break;
+			case OPEN:
+				// We don't know the full range yet
+				last = entry;
+				break;
+			default:
+				throw new IllegalStateException("Illegal open/close state detected.");
+			}
+		}
+	}
+	
+	/**
+	 * Inserts every range from the given tree into the current tree.
+	 * @param other - the other tree to read from.
+	 */
+	public void putAll(AbstractIntervalTree<TKey, TValue> other) {
+		// Naively copy every range.
+		for (Entry entry : other.entrySet()) {
+			put(entry.left.key, entry.right.key, entry.getValue());
+		}
+	}
+	
+	/**
+	 * Retrieves the value of the range that matches the given key, or NULL if nothing was found.
+	 * @param key - the level to read for.
+	 * @return The correct amount of experience, or NULL if nothing was recorded.
+	 */
+	public TValue get(TKey key) {
+		EndPoint point = getEndPoint(key);
+
+		if (point != null)
+			return point.value;
+		else
+			return null;
+	}
+	
+	/**
+	 * Get the left-most end-point associated with this key.
+	 * @param key - key to search for.
+	 * @return The end point found, or NULL.
+	 */
+	protected EndPoint getEndPoint(TKey key) {
+		EndPoint ends = bounds.get(key);
+		
+		if (ends != null) {
+			// Always return the end point to the left
+			if (ends.state == State.CLOSE) {
+				Map.Entry<TKey, EndPoint> left = bounds.floorEntry(decrementKey(key));
+				return left != null ? left.getValue() : null;
+				
+			} else {
+				return ends;
+			}
+			
+		} else {
+			// We need to determine if the point intersects with a range
+			Map.Entry<TKey, EndPoint> left = bounds.floorEntry(key);
+			
+			// We only need to check to the left
+			if (left != null && left.getValue().state == State.OPEN) {
+				return left.getValue();
+			} else {
+				return null;
+			}
+		}
+	}
+	
+	/**
+	 * Get the previous end point of a given key.
+	 * @param point - the point to search with.
+	 * @param inclusive - whether or not to include the current point in the search.
+	 * @return The previous end point of a given given key, or NULL if not found.
+	 */
+	protected EndPoint getPreviousEndPoint(TKey point, boolean inclusive) {
+		if (point != null) {
+			Map.Entry<TKey, EndPoint> previous = bounds.floorEntry(inclusive ? point : decrementKey(point));
+		
+			if (previous != null)
+				return previous.getValue();
+		}
+		return null;
+	}
+	
+	/**
+	 * Get the next end point of a given key.
+	 * @param point - the point to search with.
+	 * @param inclusive - whether or not to include the current point in the search.
+	 * @return The next end point of a given given key, or NULL if not found.
+	 */
+	protected EndPoint getNextEndPoint(TKey point, boolean inclusive) {
+		if (point != null) {
+			Map.Entry<TKey, EndPoint> next = bounds.ceilingEntry(inclusive ? point : incrementKey(point));
+		
+			if (next != null)
+				return next.getValue();
+		}
+		return null;
+	}
+
+	private void invokeEntryAdded(Entry added) {
+		if (added != null) {
+			onEntryAdded(added);
+		}
+	}
+	
+	private void invokeEntryAdded(Set<Entry> added) {
+		for (Entry entry : added) {
+			onEntryAdded(entry);
+		}
+	}
+
+	private void invokeEntryRemoved(Set<Entry> removed) {
+		for (Entry entry : removed) {
+			onEntryRemoved(entry);
+		}
+	}
+	
+	// Listeners for added or removed entries
+	/**
+	 * Invoked when an entry is added.
+	 * @param added - the entry that was added.
+	 */
+	protected void onEntryAdded(Entry added) { }
+	
+	/**
+	 * Invoked when an entry is removed.
+	 * @param removed - the removed entry.
+	 */
+	protected void onEntryRemoved(Entry removed) { }
+	
+	// Helpers for decrementing or incrementing key values
+	/**
+	 * Decrement the given key by one unit.
+	 * @param key - the key that should be decremented.
+	 * @return The new decremented key.
+	 */
+	protected abstract TKey decrementKey(TKey key);
+	
+	/**
+	 * Increment the given key by one unit.
+	 * @param key - the key that should be incremented.
+	 * @return The new incremented key.
+	 */
+	protected abstract TKey incrementKey(TKey key);
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/BlockingHashMap.java

@@ -0,0 +1,266 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.concurrency;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+
+import com.comphenix.protocol.utility.SafeCacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.RemovalCause;
+import com.google.common.cache.RemovalListener;
+import com.google.common.cache.RemovalNotification;
+
+/**
+ * A map that supports blocking on read operations. Null keys are not supported.
+ * <p>
+ * Values are stored as weak references, and will be automatically removed once they've all been dereferenced.
+ * <p>
+ * @author Kristian
+ *
+ * @param <TKey> - type of the key.
+ * @param <TValue> - type of the value.
+ */
+public class BlockingHashMap<TKey, TValue> {
+	// Map of values
+	private final ConcurrentMap<TKey, TValue> backingMap;
+	
+	// Map of locked objects
+	private final ConcurrentMap<TKey, Object> locks;
+	
+	/**
+	 * Retrieve a cache loader that will always throw an exception.
+	 * @param <TKey> Type of the key
+	 * @param <TValue> Type of the value
+	 * @return An invalid cache loader.
+	 */
+	public static <TKey, TValue> CacheLoader<TKey, TValue> newInvalidCacheLoader() {
+		return new CacheLoader<TKey, TValue>() {
+			@Override
+			public TValue load(TKey key) throws Exception {
+				throw new IllegalStateException("Illegal use. Access the map directly instead.");
+			}
+		};
+	}
+	
+	/**
+	 * Initialize a new map.
+	 */
+	public BlockingHashMap() {
+		backingMap = SafeCacheBuilder.<TKey, TValue>newBuilder().
+			weakValues().
+			removalListener(
+				new RemovalListener<TKey, TValue>() {
+					@Override
+					public void onRemoval(RemovalNotification<TKey, TValue> entry) {
+						// Clean up locks too
+						if (entry.getCause() != RemovalCause.REPLACED) {
+							locks.remove(entry.getKey());
+						}
+					}
+				}).
+			build(BlockingHashMap.<TKey, TValue> newInvalidCacheLoader());
+		
+		// Normal concurrent hash map
+		locks = new ConcurrentHashMap<TKey, Object>();
+	}
+	
+	/**
+	 * Initialize a new map.
+	 * @param <TKey> Type of the key
+	 * @param <TValue> Type of the value
+	 * @return The created map.
+	 */
+	public static <TKey, TValue> BlockingHashMap<TKey, TValue> create() {
+		return new BlockingHashMap<TKey, TValue>();
+	}
+	
+	/**
+	 * Waits until a value has been associated with the given key, and then retrieves that value.
+	 * @param key - the key whose associated value is to be returned
+	 * @return The value to which the specified key is mapped.
+	 * @throws InterruptedException If the current thread got interrupted while waiting.
+	 */
+	public TValue get(TKey key) throws InterruptedException {
+		if (key == null)
+			throw new IllegalArgumentException("key cannot be NULL.");
+		
+		TValue value = backingMap.get(key);
+		
+		// Only lock if no value is available
+		if (value == null) {
+			final Object lock = getLock(key);
+			
+			synchronized (lock) {
+				while (value == null) {
+					lock.wait();
+					value = backingMap.get(key);
+				}
+			}
+		}
+		
+		return value;
+	}
+	
+	/**
+	 * Waits until a value has been associated with the given key, and then retrieves that value.
+	 * @param key - the key whose associated value is to be returned
+	 * @param timeout - the amount of time to wait until an association has been made.
+	 * @param unit - unit of timeout.
+	 * @return The value to which the specified key is mapped, or NULL if the timeout elapsed.
+	 * @throws InterruptedException If the current thread got interrupted while waiting.
+	 */
+	public TValue get(TKey key, long timeout, TimeUnit unit) throws InterruptedException {
+		return get(key, timeout, unit, false);
+	}
+	
+	/**
+	 * Waits until a value has been associated with the given key, and then retrieves that value.
+	 * <p>
+	 * If timeout is zero, this method will return immediately if it can't find an socket injector.
+	 * 
+	 * @param key - the key whose associated value is to be returned
+	 * @param timeout - the amount of time to wait until an association has been made.
+	 * @param unit - unit of timeout.
+	 * @param ignoreInterrupted - TRUE if we should ignore the thread being interrupted, FALSE otherwise.
+	 * @return The value to which the specified key is mapped, or NULL if the timeout elapsed.
+	 * @throws InterruptedException If the current thread got interrupted while waiting.
+	 */
+	public TValue get(TKey key, long timeout, TimeUnit unit, boolean ignoreInterrupted) throws InterruptedException {
+		if (key == null)
+			throw new IllegalArgumentException("key cannot be NULL.");
+		if (unit == null)
+			throw new IllegalArgumentException("Unit cannot be NULL.");
+		if (timeout < 0)
+			throw new IllegalArgumentException("Timeout cannot be less than zero.");
+		
+		TValue value = backingMap.get(key);
+		
+		// Only lock if no value is available
+		if (value == null && timeout > 0) {
+			final Object lock = getLock(key);
+			final long stopTimeNS = System.nanoTime() + unit.toNanos(timeout);
+			
+			// Don't exceed the timeout
+			synchronized (lock) {
+				while (value == null) {
+					try {
+						long remainingTime = stopTimeNS - System.nanoTime();
+						
+						if (remainingTime > 0) {
+							TimeUnit.NANOSECONDS.timedWait(lock, remainingTime);
+							value = backingMap.get(key);
+						} else {
+							// Timeout elapsed
+							break;
+						}
+					} catch (InterruptedException e) {
+						// This is fairly dangerous - but we might HAVE to block the thread
+						if (!ignoreInterrupted)
+							throw e;
+					}
+				}
+			}
+		}
+		return value;
+	}
+	
+	/**
+	 * Associate a given key with the given value.
+	 * <p>
+	 * Wakes up any blocking getters on this specific key.
+	 * 
+	 * @param key - the key to associate.
+	 * @param value - the value.
+	 * @return The previously associated value.
+	 */
+	public TValue put(TKey key, TValue value) {
+		if (value == null)
+			throw new IllegalArgumentException("This map doesn't support NULL values.");
+		
+		final TValue previous = backingMap.put(key, value);
+		final Object lock = getLock(key);
+		
+		// Inform our readers about this change
+		synchronized (lock) {
+			lock.notifyAll();
+			return previous;
+		}
+	}
+	
+	/**
+	 * If and only if a key is not present in the map will it be associated with the given value.
+	 * @param key - the key to associate.
+	 * @param value - the value to associate.
+	 * @return The previous value this key has been associated with.
+	 */
+	public TValue putIfAbsent(TKey key, TValue value) {
+		if (value == null)
+			throw new IllegalArgumentException("This map doesn't support NULL values.");
+		
+		final TValue previous = backingMap.putIfAbsent(key, value);
+		
+		// No need to unlock readers if we haven't changed anything
+		if (previous == null) {
+			final Object lock = getLock(key);
+			
+			synchronized (lock) {
+				lock.notifyAll();
+			}
+		}
+		return previous;
+	}
+	
+	public int size() {
+		return backingMap.size();
+	}
+	
+	public Collection<TValue> values() {
+		return backingMap.values();
+	}
+	
+	public Set<TKey> keys() {
+		return backingMap.keySet();
+	}
+	
+	/**
+	 * Atomically retrieve the lock associated with a given key.
+	 * @param key - the current key.
+	 * @return An asssociated lock.
+	 */
+	private Object getLock(TKey key) {
+		Object lock = locks.get(key);
+		
+		if (lock == null) {
+			Object created = new Object();
+			
+			// Do this atomically
+			lock = locks.putIfAbsent(key, created);
+			
+			// If we succeeded, use the latch we created - otherwise, use the already inserted latch
+			if (lock == null) {
+				lock = created;
+			}
+		}
+		
+		return lock;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/ConcurrentPlayerMap.java

@@ -0,0 +1,332 @@
+package com.comphenix.protocol.concurrency;
+
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.bukkit.entity.Player;
+
+import com.comphenix.protocol.utility.SafeCacheBuilder;
+import com.comphenix.protocol.utility.Util;
+import com.google.common.base.Function;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.RemovalListener;
+import com.google.common.cache.RemovalNotification;
+import com.google.common.collect.AbstractIterator;
+import com.google.common.collect.Maps;
+import com.google.common.util.concurrent.UncheckedExecutionException;
+
+/**
+ * Represents a concurrent player map.
+ * <p>
+ * This map may use player addresses as keys.
+ * @author Kristian
+ */
+public class ConcurrentPlayerMap<TValue> extends AbstractMap<Player, TValue> implements ConcurrentMap<Player, TValue> {
+	/**
+	 * Represents the different standard player keys,
+	 * @author Kristian
+	 */
+	public enum PlayerKey implements Function<Player, Object> {
+		/**
+		 * Use a player's {@link Player#getAddress()} as key in the map.
+		 */
+		ADDRESS {
+			@Override
+			public Object apply(Player player) {
+				return player.getAddress();
+			}
+		},
+		
+		/**
+		 * Use a player's {@link Player#getName()} as key in the map.
+		 */
+		NAME {
+			@Override
+			public Object apply(Player player) {
+				return player.getName();
+			}
+		},
+	}
+	
+	/**
+	 * An internal map of player keys to values.
+	 */
+	protected ConcurrentMap<Object, TValue> valueLookup = createValueMap();
+	
+	/**
+	 * A cache of the associated keys for each player.
+	 */
+	
+	protected ConcurrentMap<Object, Player> keyLookup = createKeyCache();
+	/**
+	 * The method used to retrieve a unique key for a player.
+	 */
+	protected final Function<Player, Object> keyMethod;
+	
+	/**
+	 * Construct a new concurrent player map that uses each player's address as key.
+	 * @param <T> Parameter type
+	 * @return Concurrent player map.
+	 */
+	public static <T> ConcurrentPlayerMap<T> usingAddress() {
+		return new ConcurrentPlayerMap<T>(PlayerKey.ADDRESS);
+	}
+	
+	/**
+	 * Construct a new concurrent player map that uses each player's name as key.
+	 * @param <T> Parameter type
+	 * @return Concurrent player map.
+	 */
+	public static <T> ConcurrentPlayerMap<T> usingName() {
+		return new ConcurrentPlayerMap<T>(PlayerKey.NAME);
+	}
+	
+	/**
+	 * Construct a new concurrent player map using the given standard key method.
+	 * @param standardMethod - the standard key method.
+	 */
+	public ConcurrentPlayerMap(PlayerKey standardMethod) {
+		this.keyMethod = standardMethod;
+	}
+	
+	/**
+	 * Construct a new concurrent player map using the given custom key method.
+	 * @param method - custom key method.
+	 */
+	public ConcurrentPlayerMap(Function<Player, Object> method) {
+		this.keyMethod = method;
+	}
+	
+	/**
+	 * Construct the map that will store the associated values.
+	 * <p>
+	 * The default implementation uses a {@link ConcurrentHashMap}.
+	 * @return The value map.
+	 */
+	protected ConcurrentMap<Object, TValue> createValueMap() {
+		return Maps.newConcurrentMap();
+	}
+	
+	/**
+	 * Construct a cache of keys and the associated player.
+	 * @return The key map.
+	 */
+	protected ConcurrentMap<Object, Player> createKeyCache() {
+		return SafeCacheBuilder.newBuilder().
+			weakValues().
+			removalListener(
+			  new RemovalListener<Object, Player>() {
+				@Override
+				public void onRemoval(RemovalNotification<Object, Player> removed) {
+					// We ignore explicit removal
+					if (removed.wasEvicted()) {
+						onCacheEvicted(removed.getKey());
+					}
+				}
+			}).
+			build(
+			  new CacheLoader<Object, Player>() {
+				@Override
+				public Player load(Object key) throws Exception {
+					Player player = findOnlinePlayer(key);
+					
+					if (player != null)
+						return player;
+					
+					// Per the contract, this method should not return NULL
+					throw new IllegalArgumentException(
+							"Unable to find a player associated with: " + key);
+				}
+			});
+	}
+	
+	/**
+	 * Invoked when an entry in the cache has been evicted, typically by the garbage collector.
+	 * @param key - the key.
+	 * @param player - the value that was evicted or collected.
+	 */
+	private void onCacheEvicted(Object key) {
+		Player newPlayer = findOnlinePlayer(key);
+		
+		if (newPlayer != null) {
+			// Update the reference
+			keyLookup.put(key, newPlayer);
+		} else {
+			valueLookup.remove(key);
+		}
+	}
+	
+	/**
+	 * Find an online player from the given key.
+	 * @param key - a non-null key.
+	 * @return The player with the given key, or NULL if not found.
+	 */
+	protected Player findOnlinePlayer(Object key) {
+		for (Player player : Util.getOnlinePlayers()) {
+			if (key.equals(keyMethod.apply(player))) {
+				return player;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Lookup a player by key in the cache, optionally searching every online player.
+	 * @param key - the key of the player we are locating.
+	 * @return The player, or NULL if not found.
+	 */
+	protected Player lookupPlayer(Object key) {
+		try {
+			return keyLookup.get(key);
+		} catch (UncheckedExecutionException e) {
+			return null;
+		}
+	}
+	
+	/**
+	 * Retrieve the key of a particular player, ensuring it is cached.
+	 * @param player - the player whose key we want to retrieve.
+	 * @return The key.
+	 */
+	protected Object cachePlayerKey(Player player) {
+		Object key = keyMethod.apply(player);
+		
+		keyLookup.put(key, player);
+		return key;
+	}
+	
+	@Override
+	public TValue put(Player key, TValue value) {
+		return valueLookup.put(cachePlayerKey(key), value);
+	}
+	
+	@Override
+	public TValue putIfAbsent(Player key, TValue value) {
+		return valueLookup.putIfAbsent(cachePlayerKey(key), value);
+	}
+	
+	@Override
+	public TValue replace(Player key, TValue value) {
+		return valueLookup.replace(cachePlayerKey(key), value);
+	}
+	
+	@Override
+	public boolean replace(Player key, TValue oldValue, TValue newValue) {
+		return valueLookup.replace(cachePlayerKey(key), oldValue, newValue);
+	}
+
+	@Override
+	public TValue remove(Object key) {
+		if (key instanceof Player) {
+			Object playerKey = keyMethod.apply((Player) key);
+			
+			if (playerKey != null) {
+				TValue value = valueLookup.remove(playerKey);
+			
+				keyLookup.remove(playerKey);
+				return value;
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public boolean remove(Object key, Object value) {
+		if (key instanceof Player) {
+			Object playerKey = keyMethod.apply((Player) key);
+			
+			if (playerKey != null && valueLookup.remove(playerKey, value)) {
+				keyLookup.remove(playerKey);
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	@Override
+	public TValue get(Object key) {
+		if (key instanceof Player) {
+			Object playerKey = keyMethod.apply((Player) key);
+			return playerKey != null ? valueLookup.get(playerKey) : null;
+		}
+		return null;
+	}
+	
+	@Override
+	public boolean containsKey(Object key) {
+		if (key instanceof Player) {
+			Object playerKey = keyMethod.apply((Player) key);
+			return playerKey != null && valueLookup.containsKey(playerKey);
+		}
+		return false;
+	}
+		
+	@Override
+	public Set<Entry<Player, TValue>> entrySet() {
+		return new AbstractSet<Entry<Player,TValue>>() {
+			@Override
+			public Iterator<Entry<Player, TValue>> iterator() {
+				return entryIterator();
+			}
+		
+			@Override
+			public int size() {
+				return valueLookup.size();
+			}
+			
+			@Override
+			public void clear() {
+				valueLookup.clear();
+				keyLookup.clear();
+			}
+		};
+	}
+
+	/**
+	 * Retrieve an iterator of entries that supports removal of elements.
+	 * @return Entry iterator.
+	 */
+	private Iterator<Entry<Player, TValue>> entryIterator() {
+		// Skip entries with stale data
+		final Iterator<Entry<Object, TValue>> source = valueLookup.entrySet().iterator();
+		final AbstractIterator<Entry<Player,TValue>> filtered =
+		  new AbstractIterator<Entry<Player,TValue>>() {
+			@Override
+			protected Entry<Player, TValue> computeNext() {
+				while (source.hasNext()) {
+					Entry<Object, TValue> entry = source.next();
+					Player player = lookupPlayer(entry.getKey());
+					
+					if (player == null) {
+						// Remove entries that cannot be found
+						source.remove();
+						keyLookup.remove(entry.getKey());
+					} else {
+						return new SimpleEntry<Player, TValue>(player, entry.getValue());
+					}
+				}
+				return endOfData();
+			}
+		};
+		
+		// We can't return AbstractIterator directly, as it doesn't permitt the remove() method
+		return new Iterator<Entry<Player, TValue>>() {
+			@Override
+			public boolean hasNext() {
+				return filtered.hasNext();
+			}
+			@Override
+			public Entry<Player, TValue> next() {
+				return filtered.next();
+			}
+			@Override
+			public void remove() {
+				source.remove();
+			}
+		};
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/IntegerSet.java

@@ -0,0 +1,116 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.concurrency;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Represents a very quick integer set that uses a lookup table to store membership.
+ * <p>
+ * This class is intentionally missing a size method.
+ * @author Kristian
+ */
+public class IntegerSet {
+	private final boolean[] array;
+
+	/**
+	 * Initialize a lookup table with the given maximum number of elements.
+	 * <p>
+	 * This creates a set for elements in the range [0, count).
+	 * <p>
+	 * Formally, the current set must be a subset of [0, 1, 2, ..., count - 1].
+	 * @param maximumCount - maximum element value and count.
+	 */
+	public IntegerSet(int maximumCount) {
+		this.array = new boolean[maximumCount];
+	}
+	
+	/**
+	 * Initialize a lookup table with a given maximum and value list.
+	 * <p>
+	 * The provided elements must be in the range [0, count).
+	 * @param maximumCount - the maximum element value and count.
+	 * @param values - the elements to add to the set.
+	 */
+	public IntegerSet(int maximumCount, Collection<Integer> values) {
+		this.array = new boolean[maximumCount];
+		addAll(values);
+	}
+	
+	/**
+	 * Determine whether or not the given element exists in the set.
+	 * @param element - the element to check. Must be in the range [0, count).
+	 * @return TRUE if the given element exists, FALSE otherwise.
+	 */
+	public boolean contains(int element) {
+		return array[element];
+	}
+	
+	/**
+	 * Add the given element to the set, or do nothing if it already exists.
+	 * @param element - element to add.
+	 * @throws ArrayIndexOutOfBoundsException If the given element is not in the range [0, count).
+	 */
+	public void add(int element) {
+		array[element] = true;
+	}
+	
+	/**
+	 * Add the given collection of elements to the set.
+	 * @param packets - elements to add.
+	 */
+	public void addAll(Collection<Integer> packets) {
+		for (Integer id : packets) {
+			add(id);
+		}
+	}
+	
+	/**
+	 * Remove the given element from the set, or do nothing if it's already removed.
+	 * @param element - element to remove.
+	 */
+	public void remove(int element) {
+		// We don't actually care if the caller tries to remove an element outside the valid set
+		if (element >= 0 && element < array.length)
+			array[element] = false;
+	}
+	
+	/**
+	 * Remove every element from the set.
+	 */
+	public void clear() {
+		Arrays.fill(array, false);
+	}
+	
+	/**
+	 * Convert the current IntegerSet to an equivalent HashSet.
+	 * @return The resulting HashSet.
+	 */
+	public Set<Integer> toSet() {
+		Set<Integer> elements = new HashSet<Integer>();
+		
+		for (int i = 0; i < array.length; i++) {
+			if (array[i])
+				elements.add(i);
+		}
+		return elements;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/PacketTypeSet.java

@@ -0,0 +1,134 @@
+package com.comphenix.protocol.concurrency;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+
+/**
+ * Represents a concurrent set of packet types.
+ * @author Kristian
+ */
+public class PacketTypeSet {
+	private Set<PacketType> types = Collections.newSetFromMap(Maps.<PacketType, Boolean>newConcurrentMap());
+	private Set<Class<?>> classes = Collections.newSetFromMap(Maps.<Class<?>, Boolean>newConcurrentMap());
+	
+	public PacketTypeSet() {
+		// Do nothing
+	}
+	
+	public PacketTypeSet(Collection<? extends PacketType> values) {
+		for (PacketType type : values) {
+			addType(type);
+		}
+	}
+	
+	/**
+	 * Add a particular type to the set.
+	 * @param type - the type to add.
+	 */
+	public synchronized void addType(PacketType type) {
+		Class<?> packetClass = getPacketClass(type);
+		types.add(Preconditions.checkNotNull(type, "type cannot be NULL."));
+		
+		if (packetClass != null) {
+			classes.add(getPacketClass(type));
+		}
+	}
+	
+	/**
+	 * Add the given types to the set of packet types.
+	 * @param types - the types to add.
+	 */
+	public synchronized void addAll(Iterable<? extends PacketType> types) {
+		for (PacketType type : types) {
+			addType(type);
+		}
+	}
+	
+	/**
+	 * Remove a particular type to the set.
+	 * @param type - the type to remove.
+	 */
+	public synchronized void removeType(PacketType type) {
+		Class<?> packetClass = getPacketClass(type);
+		types.remove(Preconditions.checkNotNull(type, "type cannot be NULL."));
+		
+		if (packetClass != null) {
+			classes.remove(getPacketClass(type));
+		}
+	}
+	
+	/**
+	 * Remove the given types from the set.
+	 * @param types Types to remove
+	 */
+	public synchronized void removeAll(Iterable<? extends PacketType> types) {
+		for (PacketType type : types) {
+			removeType(type);
+		}
+	}
+	
+	/**
+	 * Retrieve the packet class associated with a particular type.
+	 * @param type - the packet type.
+	 * @return The associated packet type.
+	 */
+	protected Class<?> getPacketClass(PacketType type) {
+		return PacketRegistry.getPacketClassFromType(type);
+	}
+	
+	/**
+	 * Determine if the given packet type exists in the set.
+	 * @param type - the type to find.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	public boolean contains(PacketType type) {
+		return types.contains(type);
+	}
+	
+	/**
+	 * Determine if a packet type with the given packet class exists in the set.
+	 * @param packetClass - the class to find.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	public boolean contains(Class<?> packetClass) {
+		return classes.contains(packetClass);
+	}
+	
+	/**
+	 * Determine if the type of a packet is in the current set.
+	 * @param packet - the packet.
+	 * @return TRUE if it is, FALSE otherwise.
+	 */
+	public boolean containsPacket(Object packet) {
+		if (packet == null)
+			return false;
+		return classes.contains(packet.getClass());
+	}
+	
+	/**
+	 * Retrieve a view of this packet type set.
+	 * @return The packet type values.
+	 */
+	public Set<PacketType> values() {
+		return types;
+	}
+	
+	/**
+	 * Retrieve the number of entries in the set.
+	 * @return The number of entries.
+	 */
+	public int size() {
+		return types.size();
+	}
+	
+	public synchronized void clear() {
+		types.clear();
+		classes.clear();
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/concurrency/SortedCopyOnWriteArray.java

@@ -1,223 +1,244 @@
-package com.comphenix.protocol.concurrency;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-import com.google.common.base.Objects;
-import com.google.common.collect.Iterables;
-
-/**
- * An implicitly sorted array list that preserves insertion order and maintains duplicates.
- * @param <T> - type of the elements in the list.
- */
-public class SortedCopyOnWriteArray<T extends Comparable<T>> implements Iterable<T>, Collection<T> {
-	// Prevent reordering
-	private volatile List<T> list;
-	
-	/**
-	 * Construct an empty sorted array.
-	 */
-	public SortedCopyOnWriteArray() {
-		list = new ArrayList<T>();
-	}
-	
-	/**
-	 * Create a sorted array from the given list. The elements will be automatically sorted.
-	 * @param wrapped - the collection whose elements are to be placed into the list.
-	 */
-	public SortedCopyOnWriteArray(Collection<T> wrapped) {
-		this.list = new ArrayList<T>(wrapped);
-	}
-	
-	/**
-	 * Create a sorted array from the given list. 
-	 * @param wrapped - the collection whose elements are to be placed into the list.
-	 * @param sort - TRUE to automatically sort the collection, FALSE if it is already sorted. 
-	 */
-	public SortedCopyOnWriteArray(Collection<T> wrapped, boolean sort) {
-		this.list = new ArrayList<T>(wrapped);
-		
-		if (sort) {
-			Collections.sort(list);
-		}
-	}
-	
-	/**
-	 * Inserts the given element in the proper location.
-	 * @param value - element to insert.
-	 */
-	@Override
-	public synchronized boolean add(T value) {
-    	
-    	// We use NULL as a special marker, so we don't allow it
-    	if (value == null)
-    		throw new IllegalArgumentException("value cannot be NULL");
-    	
-    	List<T> copy = new ArrayList<T>();
-
-        for (T element : list) {
-        	// If the value is now greater than the current element, it should be placed right before it
-        	if (value != null && value.compareTo(element) < 0) {
-        		copy.add(value);
-        		value = null;
-        	}
-        	copy.add(element);
-        }
-        
-        // Don't forget to add it
-        if (value != null)
-        	copy.add(value);
-        
-        list = copy;
-        return true;
-    }
-    
-	@Override
-    public synchronized boolean addAll(Collection<? extends T> values) {
-		
-		if (values == null)
-			throw new IllegalArgumentException("values cannot be NULL");
-		if (values.size() == 0)
-			return false;
-		
-    	List<T> copy = new ArrayList<T>();
-    	
-    	// Insert the new content and sort it
-    	copy.addAll(list);
-    	copy.addAll(values);
-    	Collections.sort(copy);
-    	
-    	list = copy;
-    	return true;
-    }
-    
-    /**
-     * Removes from the list by making a new list with every element except the one given.
-     * <p>
-     * Objects will be compared using the given objects equals() method.
-     * @param value - value to remove.
-     */
-	@Override
-    public synchronized boolean remove(Object value) {
-    	List<T> copy = new ArrayList<T>();
-    	
-    	// Note that there's not much to be gained from using BinarySearch, as we
-    	// have to copy (and thus read) the entire list regardless.
-    	
-    	// Copy every element except the one given to us. 
-    	for (T element : list) {
-    		if (value != null && !Objects.equal(value, element)) {
-    			copy.add(element);
-    			value = null;
-    		}
-    	}
-
-    	list = copy;
-    	return value == null;
-    }
-    
-	@Override
-	public boolean removeAll(Collection<?> values) {
-		// Special cases
-		if (values == null)
-			throw new IllegalArgumentException("values cannot be NULL");
-		if (values.size() == 0)
-			return false;
-		
-		List<T> copy = new ArrayList<T>();
-		
-		copy.addAll(list);
-		copy.removeAll(values);
-		
-		list = copy;
-		return true;
-	}
-
-	@Override
-	public boolean retainAll(Collection<?> values) {
-		// Special cases
-		if (values == null)
-			throw new IllegalArgumentException("values cannot be NULL");
-		if (values.size() == 0)
-			return false;
-		
-		List<T> copy = new ArrayList<T>();
-		
-		copy.addAll(list);
-		copy.removeAll(values);
-		
-		list = copy;
-		return true;
-	}
-	
-    /**
-     * Removes from the list by making a copy of every element except the one with the given index.
-     * @param index - index of the element to remove.
-     */
-    public synchronized void remove(int index) {
-    	
-    	List<T> copy = new ArrayList<T>(list);
-    	
-    	copy.remove(index);
-    	list = copy;
-    }
-    
-    /**
-     * Retrieves an element by index. 
-     * @param index - index of element to retrieve.
-     * @return The element at the given location.
-     */
-    public T get(int index) {
-    	return list.get(index);
-    }
-    
-    /**
-     * Retrieve the size of the list.
-     * @return Size of the list.
-     */
-    public int size() {
-    	return list.size();
-    }
-
-    /**
-     * Retrieves an iterator over the elements in the given list. 
-     * Warning: No not attempt to remove elements using the iterator.
-     */
-	public Iterator<T> iterator() {
-		return Iterables.unmodifiableIterable(list).iterator();
-	}
-	
-	@Override
-	public void clear() {
-		list = new ArrayList<T>();
-	}
-
-	@Override
-	public boolean contains(Object value) {
-		return list.contains(value);
-	}
-
-	@Override
-	public boolean containsAll(Collection<?> values) {
-		return list.containsAll(values);
-	}
-
-	@Override
-	public boolean isEmpty() {
-		return list.isEmpty();
-	}
-
-	@Override
-	public Object[] toArray() {
-		return list.toArray();
-	}
-
-	@SuppressWarnings("hiding")
-	@Override
-	public <T> T[] toArray(T[] a) {
-		return list.toArray(a);
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.concurrency;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+
+/**
+ * An implicitly sorted array list that preserves insertion order and maintains duplicates.
+ * @param <T> - type of the elements in the list.
+ */
+public class SortedCopyOnWriteArray<T extends Comparable<T>> implements Collection<T> {
+	// Prevent reordering
+	private volatile List<T> list;
+	
+	/**
+	 * Construct an empty sorted array.
+	 */
+	public SortedCopyOnWriteArray() {
+		list = new ArrayList<T>();
+	}
+	
+	/**
+	 * Create a sorted array from the given list. The elements will be automatically sorted.
+	 * @param wrapped - the collection whose elements are to be placed into the list.
+	 */
+	public SortedCopyOnWriteArray(Collection<T> wrapped) {
+		this.list = new ArrayList<T>(wrapped);
+	}
+	
+	/**
+	 * Create a sorted array from the given list. 
+	 * @param wrapped - the collection whose elements are to be placed into the list.
+	 * @param sort - TRUE to automatically sort the collection, FALSE if it is already sorted. 
+	 */
+	public SortedCopyOnWriteArray(Collection<T> wrapped, boolean sort) {
+		this.list = new ArrayList<T>(wrapped);
+		
+		if (sort) {
+			Collections.sort(list);
+		}
+	}
+	
+	/**
+	 * Inserts the given element in the proper location.
+	 * @param value - element to insert.
+	 */
+	@Override
+	public synchronized boolean add(T value) {
+    	// We use NULL as a special marker, so we don't allow it
+    	if (value == null)
+    		throw new IllegalArgumentException("value cannot be NULL");
+    	
+    	List<T> copy = new ArrayList<T>();
+
+        for (T element : list) {
+        	// If the value is now greater than the current element, it should be placed right before it
+        	if (value != null && value.compareTo(element) < 0) {
+        		copy.add(value);
+        		value = null;
+        	}
+        	copy.add(element);
+        }
+        
+        // Don't forget to add it
+        if (value != null)
+        	copy.add(value);
+        
+        list = copy;
+        return true;
+    }
+    
+	@Override
+    public synchronized boolean addAll(Collection<? extends T> values) {
+		if (values == null)
+			throw new IllegalArgumentException("values cannot be NULL");
+		if (values.size() == 0)
+			return false;
+		
+    	List<T> copy = new ArrayList<T>();
+    	
+    	// Insert the new content and sort it
+    	copy.addAll(list);
+    	copy.addAll(values);
+    	Collections.sort(copy);
+    	
+    	list = copy;
+    	return true;
+    }
+    
+    /**
+     * Removes from the list by making a new list with every element except the one given.
+     * <p>
+     * Objects will be compared using the given objects equals() method.
+     * @param value - value to remove.
+     */
+	@Override
+    public synchronized boolean remove(Object value) {
+    	List<T> copy = new ArrayList<T>();
+    	boolean result = false;
+    	
+    	// Note that there's not much to be gained from using BinarySearch, as we
+    	// have to copy (and thus read) the entire list regardless.
+    	
+    	// Copy every element except the one given to us. 
+    	for (T element : list) {
+    		if (!Objects.equal(value, element)) {
+    			copy.add(element);    			
+    		} else {
+    			result = true;
+    		}
+    	}
+
+    	list = copy;
+    	return result;
+    }
+    
+	@Override
+	public boolean removeAll(Collection<?> values) {
+		// Special cases
+		if (values == null)
+			throw new IllegalArgumentException("values cannot be NULL");
+		if (values.size() == 0)
+			return false;
+		
+		List<T> copy = new ArrayList<T>();
+		
+		copy.addAll(list);
+		copy.removeAll(values);
+		
+		list = copy;
+		return true;
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> values) {
+		// Special cases
+		if (values == null)
+			throw new IllegalArgumentException("values cannot be NULL");
+		if (values.size() == 0)
+			return false;
+		
+		List<T> copy = new ArrayList<T>();
+		
+		copy.addAll(list);
+		copy.removeAll(values);
+		
+		list = copy;
+		return true;
+	}
+	
+    /**
+     * Removes from the list by making a copy of every element except the one with the given index.
+     * @param index - index of the element to remove.
+     */
+    public synchronized void remove(int index) {
+    	List<T> copy = new ArrayList<T>(list);
+    	
+    	copy.remove(index);
+    	list = copy;
+    }
+    
+    /**
+     * Retrieves an element by index. 
+     * @param index - index of element to retrieve.
+     * @return The element at the given location.
+     */
+    public T get(int index) {
+    	return list.get(index);
+    }
+    
+    /**
+     * Retrieve the size of the list.
+     * @return Size of the list.
+     */
+    public int size() {
+    	return list.size();
+    }
+
+    /**
+     * Retrieves an iterator over the elements in the given list. 
+     * Warning: No not attempt to remove elements using the iterator.
+     */
+	public Iterator<T> iterator() {
+		return Iterables.unmodifiableIterable(list).iterator();
+	}
+	
+	@Override
+	public void clear() {
+		list = new ArrayList<T>();
+	}
+
+	@Override
+	public boolean contains(Object value) {
+		return list.contains(value);
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> values) {
+		return list.containsAll(values);
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return list.isEmpty();
+	}
+
+	@Override
+	public Object[] toArray() {
+		return list.toArray();
+	}
+
+	@SuppressWarnings("hiding")
+	@Override
+	public <T> T[] toArray(T[] a) {
+		return list.toArray(a);
+	}
+	
+	@Override
+	public String toString() {
+		return list.toString();
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/BasicErrorReporter.java

@@ -0,0 +1,107 @@
+package com.comphenix.protocol.error;
+
+import java.io.PrintStream;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.error.Report.ReportBuilder;
+import com.comphenix.protocol.reflect.PrettyPrinter;
+
+/**
+ * Represents a basic error reporter that prints error reports to the standard error stream.
+ * <p>
+ * Note that this implementation doesn't distinguish between {@link #reportWarning(Object, Report)} 
+ * and {@link #reportDetailed(Object, Report)} - they both have the exact same behavior.
+ * @author Kristian
+ */
+public class BasicErrorReporter implements ErrorReporter {
+	private final PrintStream output;
+	
+	/**
+	 * Construct a new basic error reporter that prints directly the standard error stream.
+	 */
+	public BasicErrorReporter() {
+		 this(System.err);
+	}
+	
+	/**
+	 * Construct a error reporter that prints to the given output stream.
+	 * @param output - the output stream.
+	 */
+	public BasicErrorReporter(PrintStream output) {
+		this.output = output;
+	}
+
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
+		output.println("Unhandled exception occured in " +  methodName + " for " + sender.getName());
+		error.printStackTrace(output);
+	}
+
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
+		reportMinimal(sender, methodName, error);
+		
+		// Also print parameters
+		printParameters(parameters);
+	}
+
+	@Override
+	public void reportDebug(Object sender, Report report) {
+		// We just have to swallow it
+	}
+
+	@Override
+	public void reportDebug(Object sender, ReportBuilder builder) {
+		// As above
+	}
+	
+	@Override
+	public void reportWarning(Object sender, Report report) {
+		// Basic warning
+		output.println("[" + sender.getClass().getSimpleName() + "] " + report.getReportMessage());
+		
+		if (report.getException() != null) {
+			report.getException().printStackTrace(output);
+		}
+		printParameters(report.getCallerParameters());
+	}
+
+	@Override
+	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
+		reportWarning(sender, reportBuilder.build());
+	}
+
+	@Override
+	public void reportDetailed(Object sender, Report report) {
+		// No difference from warning
+		reportWarning(sender, report);
+	}
+
+	@Override
+	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
+		reportWarning(sender, reportBuilder);
+	}
+	
+	/**
+	 * Print the given parameters to the standard error stream.
+	 * @param parameters - the output parameters.
+	 */
+	private void printParameters(Object[] parameters) {
+		if (parameters != null && parameters.length > 0) {
+			output.println("Parameters: ");
+			
+			try {
+				for (Object parameter : parameters) {
+					if (parameter == null)
+						output.println("[NULL]");
+					else
+						output.println(PrettyPrinter.printObject(parameter));
+				}
+			} catch (IllegalAccessException e) {
+				// Damn it
+				e.printStackTrace();
+			}
+		}
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/DelegatedErrorReporter.java

@@ -0,0 +1,94 @@
+package com.comphenix.protocol.error;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.error.Report.ReportBuilder;
+
+/**
+ * Construct an error reporter that delegates to another error reporter.
+ * @author Kristian
+ */
+public class DelegatedErrorReporter implements ErrorReporter {
+	private final ErrorReporter delegated;
+
+	/**
+	 * Construct a new error reporter that forwards all reports to a given reporter.
+	 * @param delegated - the delegated reporter.
+	 */
+	public DelegatedErrorReporter(ErrorReporter delegated) {
+		this.delegated = delegated;
+	}
+	
+	/**
+	 * Retrieve the underlying error reporter.
+	 * @return Underlying error reporter.
+	 */
+	public ErrorReporter getDelegated() {
+		return delegated;
+	}
+
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
+		delegated.reportMinimal(sender, methodName, error);
+	}
+
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
+		delegated.reportMinimal(sender, methodName, error, parameters);
+	}
+
+	@Override
+	public void reportDebug(Object sender, Report report) {
+		Report transformed = filterReport(sender, report, false);
+		
+		if (transformed != null) {
+			delegated.reportDebug(sender, transformed);
+		}
+	}
+	
+	@Override
+	public void reportWarning(Object sender, Report report) {
+		Report transformed = filterReport(sender, report, false);
+		
+		if (transformed != null) {
+			delegated.reportWarning(sender, transformed);
+		}
+	}
+
+	@Override
+	public void reportDetailed(Object sender, Report report) {
+		Report transformed = filterReport(sender, report, true);
+		
+		if (transformed != null) {
+			delegated.reportDetailed(sender, transformed);
+		}
+	}
+
+	/**
+	 * Invoked before an error report is passed on to the underlying error reporter.
+	 * <p>
+	 * To cancel a report, return NULL.
+	 * @param sender - the sender instance or class.
+	 * @param report - the error report.
+	 * @param detailed - whether or not the report will be displayed in detail.
+	 * @return The report to pass on, or NULL to cancel it.
+	 */
+	protected Report filterReport(Object sender, Report report, boolean detailed) {
+		return report;
+	}
+	
+	@Override
+	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
+		reportWarning(sender, reportBuilder.build());
+	}
+	
+	@Override
+	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
+		reportDetailed(sender, reportBuilder.build());
+	}
+	
+	@Override
+	public void reportDebug(Object sender, ReportBuilder builder) {
+		reportDebug(sender, builder.build());
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/DetailedErrorReporter.java

@@ -0,0 +1,618 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.error;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang.builder.ToStringBuilder;
+import org.apache.commons.lang.builder.ToStringStyle;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.ProtocolLogger;
+import com.comphenix.protocol.collections.ExpireHashMap;
+import com.comphenix.protocol.error.Report.ReportBuilder;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.reflect.PrettyPrinter;
+import com.google.common.base.Preconditions;
+import com.google.common.primitives.Primitives;
+
+/**
+ * Internal class used to handle exceptions.
+ * 
+ * @author Kristian
+ */
+public class DetailedErrorReporter implements ErrorReporter {
+	/**
+	 * Report format for printing the current exception count.
+	 */
+	public static final ReportType REPORT_EXCEPTION_COUNT = new ReportType("Internal exception count: %s!");
+	
+	public static final String SECOND_LEVEL_PREFIX = "  ";
+	public static final String DEFAULT_PREFIX = "  ";
+	public static final String DEFAULT_SUPPORT_URL = "https://github.com/dmulloy2/ProtocolLib/issues";
+
+	// Users that are informed about errors in the chat
+	public static final String ERROR_PERMISSION = "protocol.info";
+	
+	// We don't want to spam the server
+	public static final int DEFAULT_MAX_ERROR_COUNT = 20;
+	
+	// Prevent spam per plugin too
+	private ConcurrentMap<String, AtomicInteger> warningCount = new ConcurrentHashMap<String, AtomicInteger>();
+	
+	protected String prefix;
+	protected String supportURL;
+	
+	protected AtomicInteger internalErrorCount = new AtomicInteger();
+	
+	protected int maxErrorCount;
+	protected Logger logger;
+	
+	protected WeakReference<Plugin> pluginReference;
+	protected String pluginName;
+	
+	// Whether or not Apache Commons is not present
+	protected static boolean apacheCommonsMissing;
+	
+	// Whether or not detailed errror reporting is enabled
+	protected boolean detailedReporting;
+	
+	// Map of global objects
+	protected Map<String, Object> globalParameters = new HashMap<String, Object>();
+	
+	// Reports to ignore
+	private ExpireHashMap<Report, Boolean> rateLimited = new ExpireHashMap<Report, Boolean>();
+	private Object rateLock = new Object();
+	
+	/**
+	 * Create a default error reporting system.
+	 * @param plugin - the plugin owner.
+	 */
+	public DetailedErrorReporter(Plugin plugin) {
+		this(plugin, DEFAULT_PREFIX, DEFAULT_SUPPORT_URL);
+	}
+	
+	/**
+	 * Create a central error reporting system.
+	 * @param plugin - the plugin owner.
+	 * @param prefix - default line prefix.
+	 * @param supportURL - URL to report the error.
+	 */
+	public DetailedErrorReporter(Plugin plugin, String prefix, String supportURL) {
+		this(plugin, prefix, supportURL, DEFAULT_MAX_ERROR_COUNT, getBukkitLogger());
+	}
+
+	/**
+	 * Create a central error reporting system.
+	 * @param plugin - the plugin owner.
+	 * @param prefix - default line prefix.
+	 * @param supportURL - URL to report the error.
+	 * @param maxErrorCount - number of errors to print before giving up.
+	 * @param logger - current logger.
+	 */
+	public DetailedErrorReporter(Plugin plugin, String prefix, String supportURL, int maxErrorCount, Logger logger) {
+		if (plugin == null)
+			throw new IllegalArgumentException("Plugin cannot be NULL.");
+		
+		this.pluginReference = new WeakReference<Plugin>(plugin);
+		this.pluginName = getNameSafely(plugin);
+		this.prefix = prefix;
+		this.supportURL = supportURL;
+		this.maxErrorCount = maxErrorCount;
+		this.logger = logger;
+	}
+
+	private String getNameSafely(Plugin plugin) {
+		try {
+			return plugin.getName();
+		} catch (LinkageError e) {
+			return "ProtocolLib";
+		}
+	}
+
+	// Attempt to get the logger.
+	private static Logger getBukkitLogger() {
+		try {
+			return Bukkit.getLogger();
+		} catch (LinkageError e) {
+			return Logger.getLogger("Minecraft");
+		}
+	}
+	
+	/**
+	 * Determine if we're using detailed error reporting.
+	 * @return TRUE if we are, FALSE otherwise.
+	 */
+	public boolean isDetailedReporting() {
+		return detailedReporting;
+	}
+	
+	/**
+	 * Set whether or not to use detailed error reporting.
+	 * @param detailedReporting - TRUE to enable it, FALSE otherwise.
+	 */
+	public void setDetailedReporting(boolean detailedReporting) {
+		this.detailedReporting = detailedReporting;
+	}
+	
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
+		if (reportMinimalNoSpam(sender, methodName, error)) {
+			// Print parameters, if they are given
+			if (parameters != null && parameters.length > 0) {
+				logger.log(Level.SEVERE, printParameters(parameters));
+			}
+		}
+	}
+	
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
+		reportMinimalNoSpam(sender, methodName, error);
+	}
+	
+	/**
+	 * Report a problem with a given method and plugin, ensuring that we don't exceed the maximum number of error reports.
+	 * @param sender - the component that observed this exception.
+	 * @param methodName - the method name.
+	 * @param error - the error itself.
+	 * @return TRUE if the error was printed, FALSE if it was suppressed.
+	 */
+	public boolean reportMinimalNoSpam(Plugin sender, String methodName, Throwable error) {
+		String pluginName = PacketAdapter.getPluginName(sender);
+		AtomicInteger counter = warningCount.get(pluginName);
+		
+		// Thread safe pattern
+		if (counter == null) {
+			AtomicInteger created = new AtomicInteger();
+			counter = warningCount.putIfAbsent(pluginName, created);
+			
+			if (counter == null) {
+				counter = created;
+			}
+		}
+		
+		final int errorCount = counter.incrementAndGet();
+		
+		// See if we should print the full error
+		if (errorCount < getMaxErrorCount()) {
+			logger.log(Level.SEVERE, "[" + pluginName + "] Unhandled exception occured in " +
+					 methodName + " for " + pluginName, error);
+			return true;
+			
+		} else {
+			// Nope - only print the error count occationally
+			if (isPowerOfTwo(errorCount)) {
+				logger.log(Level.SEVERE, "[" + pluginName + "] Unhandled exception number " + errorCount + " occured in " +
+						 methodName + " for " + pluginName, error);
+			}
+			return false;
+		}
+	}
+	
+	/**
+	 * Determine if a given number is a power of two.
+	 * <p>
+	 * That is, if there exists an N such that 2^N = number.
+	 * @param number - the number to check.
+	 * @return TRUE if the given number is a power of two, FALSE otherwise.
+	 */
+	private boolean isPowerOfTwo(int number) {
+	    return (number & (number - 1)) == 0;
+	}
+	
+	@Override
+	public void reportDebug(Object sender, ReportBuilder builder) {
+		reportDebug(sender, Preconditions.checkNotNull(builder, "builder cannot be NULL").build());
+	}
+	
+	@Override
+	public void reportDebug(Object sender, Report report) {
+		if (logger.isLoggable(Level.FINE) && canReport(report)) {
+			reportLevel(Level.FINE, sender, report);
+		}
+	}
+	
+	@Override
+	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
+		if (reportBuilder == null)
+			throw new IllegalArgumentException("reportBuilder cannot be NULL.");
+		
+		reportWarning(sender, reportBuilder.build());
+	}
+	
+	@Override
+	public void reportWarning(Object sender, Report report) {
+		if (logger.isLoggable(Level.WARNING) && canReport(report)) {
+			reportLevel(Level.WARNING, sender, report);
+		}
+	}
+	
+	/**
+	 * Determine if we should print the given report.
+	 * <p>
+	 * The default implementation will check for rate limits.
+	 * @param report - the report to check.
+	 * @return TRUE if we should print it, FALSE otherwise.
+	 */
+	protected boolean canReport(Report report) {
+		long rateLimit = report.getRateLimit();
+		
+		// Check for rate limit
+		if (rateLimit > 0) {
+			synchronized (rateLock) {
+				if (rateLimited.containsKey(report)) {
+					return false;
+				}
+				rateLimited.put(report, true, rateLimit, TimeUnit.NANOSECONDS);
+			}
+		}
+		return true;
+	}
+	
+	private void reportLevel(Level level, Object sender, Report report) {
+		String message = "[" + pluginName + "] [" + getSenderName(sender) + "] " + report.getReportMessage();
+		
+		// Print the main warning
+		if (report.getException() != null) {
+			logger.log(level, message, report.getException());
+		} else {
+			logger.log(level, message);
+			
+			// Remember the call stack
+			if (detailedReporting) {
+				printCallStack(level, logger);
+			}
+		}
+		
+		// Parameters?
+		if (report.hasCallerParameters()) {
+			// Write it
+			logger.log(level, printParameters(report.getCallerParameters()));
+		}
+	}
+	
+	/**
+	 * Retrieve the name of a sender class.
+	 * @param sender - sender object.
+	 * @return The name of the sender's class.
+	 */
+	private String getSenderName(Object sender) {
+		if (sender != null)
+			return ReportType.getSenderClass(sender).getSimpleName();
+		else
+			return "NULL";
+	}
+	
+	@Override
+	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
+		reportDetailed(sender, reportBuilder.build());
+	}
+	
+	@Override
+	public void reportDetailed(Object sender, Report report) {
+		final Plugin plugin = pluginReference.get();
+		final int errorCount = internalErrorCount.incrementAndGet();
+		
+		// Do not overtly spam the server!
+		if (errorCount > getMaxErrorCount()) {
+			// Only allow the error count at rare occations
+			if (isPowerOfTwo(errorCount)) {
+				// Permit it - but print the number of exceptions first
+				reportWarning(this, Report.newBuilder(REPORT_EXCEPTION_COUNT).messageParam(errorCount).build());
+			} else {
+				// NEVER SPAM THE CONSOLE
+				return;
+			}
+		}
+		
+		// Secondary rate limit
+		if (!canReport(report)) {
+			return;
+		}
+		
+		StringWriter text = new StringWriter();
+		PrintWriter writer = new PrintWriter(text);
+
+		// Helpful message
+		writer.println("[" + pluginName + "] INTERNAL ERROR: " + report.getReportMessage());
+	    writer.println("If this problem hasn't already been reported, please open a ticket");
+	    writer.println("at " + supportURL + " with the following data:");
+	    
+	    // Now, let us print important exception information
+		writer.println("Stack Trace:");
+
+		if (report.getException() != null) {
+			report.getException().printStackTrace(writer);
+			
+		} else if (detailedReporting) {
+			printCallStack(writer);
+		}
+		
+		// Data dump!
+		writer.println("Dump:");
+		
+		// Relevant parameters
+		if (report.hasCallerParameters()) {
+			printParameters(writer, report.getCallerParameters());
+		}
+		
+		// Global parameters
+		for (String param : globalParameters()) {
+			writer.println(SECOND_LEVEL_PREFIX + param + ":");
+			writer.println(addPrefix(getStringDescription(getGlobalParameter(param)),
+					SECOND_LEVEL_PREFIX + SECOND_LEVEL_PREFIX));
+		}
+		
+		// Now, for the sender itself
+		writer.println("Sender:");
+		writer.println(addPrefix(getStringDescription(sender), SECOND_LEVEL_PREFIX));
+		
+		// And plugin
+		if (plugin != null) {
+			writer.println("Version:");
+			writer.println(addPrefix(plugin.toString(), SECOND_LEVEL_PREFIX));
+		}
+
+		// And java version
+		writer.println("Java Version:");
+		writer.println(addPrefix(System.getProperty("java.version"), SECOND_LEVEL_PREFIX));
+
+		// Add the server version too
+		if (Bukkit.getServer() != null) {
+			writer.println("Server:");
+			writer.println(addPrefix(Bukkit.getServer().getVersion(), SECOND_LEVEL_PREFIX));
+
+			// Inform of this occurrence
+			if (ERROR_PERMISSION != null) {
+				Bukkit.getServer().broadcast(
+						String.format("Error %s (%s) occured in %s.", report.getReportMessage(), report.getException(), sender),
+						ERROR_PERMISSION
+				);
+			}
+		}
+		
+		// Make sure it is reported
+		logger.severe(addPrefix(text.toString(), prefix));
+	}
+	
+	/**
+	 * Print the call stack to the given logger.
+	 * @param logger - the logger.
+	 */
+	private void printCallStack(Level level, Logger logger) {
+		StringWriter text = new StringWriter();
+		printCallStack(new PrintWriter(text));
+		
+		// Print the exception
+		logger.log(level, text.toString());
+	}
+	
+	/**
+	 * Print the current call stack.
+	 * @param writer - the writer.
+	 */
+	private void printCallStack(PrintWriter writer) {
+		Exception current = new Exception("Not an error! This is the call stack.");
+		current.printStackTrace(writer);
+	}
+	
+	private String printParameters(Object... parameters) {
+		StringWriter writer = new StringWriter();
+		
+		// Print and retrieve the string buffer
+		printParameters(new PrintWriter(writer), parameters);
+		return writer.toString();
+	}
+
+	private void printParameters(PrintWriter writer, Object[] parameters) {
+		writer.println("Parameters: ");
+		
+		// We *really* want to get as much information as possible
+		for (Object param : parameters) {
+			writer.println(addPrefix(getStringDescription(param), SECOND_LEVEL_PREFIX));
+		}
+	}
+	
+	/**
+	 * Adds the given prefix to every line in the text.
+	 * @param text - text to modify.
+	 * @param prefix - prefix added to every line in the text.
+	 * @return The modified text.
+	 */
+	protected String addPrefix(String text, String prefix) {
+		return text.replaceAll("(?m)^", prefix);
+	}
+	
+	/**
+	 * Retrieve a string representation of the given object.
+	 * @param value - object to convert.
+	 * @return String representation.
+	 */
+	public static String getStringDescription(Object value) {
+		// We can't only rely on toString.
+		if (value == null) {
+			return "[NULL]";
+		} if (isSimpleType(value) || value instanceof Class<?>) {
+			return value.toString();
+		} else {
+			try {
+				if (!apacheCommonsMissing)
+					return ToStringBuilder.reflectionToString(value, ToStringStyle.MULTI_LINE_STYLE, false, null);
+			} catch (LinkageError ex) {
+				// Apache is probably missing
+				apacheCommonsMissing = true;
+			} catch (ThreadDeath | OutOfMemoryError e) {
+				throw e;
+			} catch (Throwable ex) {
+				// Don't use the error logger to log errors in error logging (that could lead to infinite loops)
+				ProtocolLogger.log(Level.WARNING, "Cannot convert to a String with Apache: " + ex.getMessage());
+			}
+			
+			// Use our custom object printer instead
+			try {
+				return PrettyPrinter.printObject(value, value.getClass(), Object.class);
+			} catch (IllegalAccessException e) {
+				return "[Error: " + e.getMessage() + "]";
+			}
+		}
+	}
+	
+	/**
+	 * Determine if the given object is a wrapper for a primitive/simple type or not.
+	 * @param test - the object to test.
+	 * @return TRUE if this object is simple enough to simply be printed, FALSE othewise.
+	 */
+	protected static boolean isSimpleType(Object test) {
+		return test instanceof String || Primitives.isWrapperType(test.getClass());
+	}
+	
+	/**
+	 * Retrieve the current number of errors printed through {@link #reportDetailed(Object, Report)}.
+	 * @return Number of errors printed.
+	 */
+	public int getErrorCount() {
+		return internalErrorCount.get();
+	}
+
+	/**
+	 * Set the number of errors printed.
+	 * @param errorCount - new number of errors printed.
+	 */
+	public void setErrorCount(int errorCount) {
+		internalErrorCount.set(errorCount);
+	}
+
+	/**
+	 * Retrieve the maximum number of errors we can print before we begin suppressing errors.
+	 * @return Maximum number of errors.
+	 */
+	public int getMaxErrorCount() {
+		return maxErrorCount;
+	}
+
+	/**
+	 * Set the maximum number of errors we can print before we begin suppressing errors.
+	 * @param maxErrorCount - new max count.
+	 */
+	public void setMaxErrorCount(int maxErrorCount) {
+		this.maxErrorCount = maxErrorCount;
+	}
+	
+	/**
+	 * Adds the given global parameter. It will be included in every error report.
+	 * <p>
+	 * Both key and value must be non-null.
+	 * @param key - name of parameter.
+	 * @param value - the global parameter itself.
+	 */
+	public void addGlobalParameter(String key, Object value) {
+		if (key == null)
+			throw new IllegalArgumentException("key cannot be NULL.");
+		if (value == null)
+			throw new IllegalArgumentException("value cannot be NULL.");
+		
+		globalParameters.put(key, value);
+	}
+	
+	/**
+	 * Retrieve a global parameter by its key.
+	 * @param key - key of the parameter to retrieve.
+	 * @return The value of the global parameter, or NULL if not found.
+	 */
+	public Object getGlobalParameter(String key) {
+		if (key == null)
+			throw new IllegalArgumentException("key cannot be NULL.");
+		
+		return globalParameters.get(key);
+	}
+	
+	/**
+	 * Reset all global parameters.
+	 */
+	public void clearGlobalParameters() {
+		globalParameters.clear();
+	}
+	
+	/**
+	 * Retrieve a set of every registered global parameter.
+	 * @return Set of all registered global parameters.
+	 */
+	public Set<String> globalParameters() {
+		return globalParameters.keySet();
+	}
+	
+	/**
+	 * Retrieve the support URL that will be added to all detailed reports.
+	 * @return Support URL.
+	 */
+	public String getSupportURL() {
+		return supportURL;
+	}
+
+	/**
+	 * Set the support URL that will be added to all detailed reports.
+	 * @param supportURL - the new support URL.
+	 */
+	public void setSupportURL(String supportURL) {
+		this.supportURL = supportURL;
+	}
+	
+	/**
+	 * Retrieve the prefix to apply to every line in the error reports.
+	 * @return Error report prefix.
+	 */
+	public String getPrefix() {
+		return prefix;
+	}
+
+	/**
+	 * Set the prefix to apply to every line in the error reports.
+	 * @param prefix - new prefix.
+	 */
+	public void setPrefix(String prefix) {
+		this.prefix = prefix;
+	}
+	
+	/**
+	 * Retrieve the current logger that is used to print all reports.
+	 * @return The current logger.
+	 */
+	public Logger getLogger() {
+		return logger;
+	}
+
+	/**
+	 * Set the current logger that is used to print all reports.
+	 * @param logger - new logger.
+	 */
+	public void setLogger(Logger logger) {
+		this.logger = logger;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/ErrorReporter.java

@@ -0,0 +1,90 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.error;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.error.Report.ReportBuilder;
+
+/**
+ * Represents an object that can forward an error {@link Report} to the display and permanent storage.
+ * 
+ * @author Kristian
+ */
+public interface ErrorReporter {
+	/**
+	 * Prints a small minimal error report regarding an exception from another plugin.
+	 * @param sender - the other plugin.
+	 * @param methodName - name of the caller method.
+	 * @param error - the exception itself.
+	 */
+	public abstract void reportMinimal(Plugin sender, String methodName, Throwable error);
+
+	/**
+	 * Prints a small minimal error report regarding an exception from another plugin.
+	 * @param sender - the other plugin.
+	 * @param methodName - name of the caller method.
+	 * @param error - the exception itself.
+	 * @param parameters - any relevant parameters to print.
+	 */
+	public abstract void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters);
+	
+	/**
+	 * Prints a debug message from the current sender.
+	 * <p>
+	 * Most users will not see this message.
+	 * @param sender - the sender.
+	 * @param report - the report.
+	 */
+	public abstract void reportDebug(Object sender, Report report);
+	
+	/**
+	 * Prints a debug message from the current sender.
+	 * @param sender - the sender.
+	 * @param builder - the report builder.
+	 */
+	public abstract void reportDebug(Object sender, ReportBuilder builder);
+	
+	/**
+	 * Prints a warning message from the current plugin.
+	 * @param sender - the object containing the caller method.
+	 * @param report - an error report to include.
+	 */
+	public abstract void reportWarning(Object sender, Report report);
+	
+	/**
+	 * Prints a warning message from the current plugin.
+	 * @param sender - the object containing the caller method.
+	 * @param reportBuilder - an error report builder that will be used to get the report.
+	 */
+	public abstract void reportWarning(Object sender, ReportBuilder reportBuilder);
+
+	/**
+	 * Prints a detailed error report about an unhandled exception.
+	 * @param sender - the object containing the caller method.
+	 * @param report - an error report to include.
+	 */
+	public abstract void reportDetailed(Object sender, Report report);
+	
+	/**
+	 * Prints a detailed error report about an unhandled exception.
+	 * @param sender - the object containing the caller method.
+	 * @param reportBuilder - an error report builder that will be used to get the report.
+	 */
+	public abstract void reportDetailed(Object sender, ReportBuilder reportBuilder);
+}

modules/API/src/main/java/com/comphenix/protocol/error/PluginContext.java

@@ -0,0 +1,108 @@
+package com.comphenix.protocol.error;
+
+import java.io.File;
+import java.net.URLDecoder;
+import java.security.CodeSource;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+
+import com.google.common.base.Preconditions;
+
+public final class PluginContext {
+	// Determine plugin folder
+	private static File pluginFolder;
+	
+	private PluginContext() {
+		// Not constructable
+	}
+	
+	/**
+	 * Retrieve the name of the plugin that called the last method(s) in the exception.
+	 * @param ex - the exception.
+	 * @return The name of the plugin, or NULL.
+	 */
+	public static String getPluginCaller(Exception ex) {
+		StackTraceElement[] elements = ex.getStackTrace();
+		String current = getPluginName(elements[0]);
+		
+		for (int i = 1; i < elements.length; i++) {
+			String caller = getPluginName(elements[i]);
+			if (caller != null && !caller.equals(current)) {
+				return caller;
+			}
+		}
+
+		return null;
+	}
+	
+	/**
+	 * Lookup the plugin that this method invocation belongs to, and return its file name.
+	 * @param element - the method invocation.
+	 * @return Plugin name, or NULL if not found.
+	 */
+	public static String getPluginName(StackTraceElement element) {
+		try {
+			if (Bukkit.getServer() == null) {
+				return null;
+			}
+	
+			CodeSource codeSource = Class.forName(element.getClassName()).getProtectionDomain().getCodeSource();
+			if (codeSource != null) {
+				String encoding = codeSource.getLocation().getPath();
+				File path = new File(URLDecoder.decode(encoding, "UTF-8"));
+				File plugins = getPluginFolder();
+				
+				if (plugins != null && folderContains(plugins, path)) {
+					return path.getName().replaceAll(".jar", "");
+				}
+			}
+		} catch (Throwable ex) {
+			// throw new RuntimeException("Cannot lookup plugin name.", ex);
+		}
+
+		return null; // Cannot find it
+	}
+	
+	/**
+	 * Determine if a folder contains the given file.
+	 * @param folder - the folder.
+	 * @param file - the file.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	private static boolean folderContains(File folder, File file) {
+		Preconditions.checkNotNull(folder, "folder cannot be NULL");
+		Preconditions.checkNotNull(file, "file cannot be NULL");
+		
+		// Get absolute versions
+		folder = folder.getAbsoluteFile();
+		file = file.getAbsoluteFile();
+
+		while (file != null) {
+		    if (folder.equals(file))
+		        return true;
+		    file = file.getParentFile();
+		}
+
+		return false;
+	}
+	
+	/**
+	 * Retrieve the folder that contains every plugin on the server.
+	 * @return Folder with every plugin, or NULL if Bukkit has not been initialized yet.
+	 */
+	private static File getPluginFolder() {
+		File folder = pluginFolder;
+		
+		if (folder == null && Bukkit.getServer() != null) {
+			Plugin[] plugins = Bukkit.getPluginManager().getPlugins();
+			
+			if (plugins.length > 0) {
+				folder = plugins[0].getDataFolder().getParentFile();
+				pluginFolder = folder;
+			}
+		}
+
+		return folder;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/Report.java

@@ -0,0 +1,240 @@
+package com.comphenix.protocol.error;
+
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.Nullable;
+
+/**
+ * Represents a error or warning report.
+ * 
+ * @author Kristian
+ */
+public class Report {
+	private final ReportType type;
+	private final Throwable exception;
+	private final Object[] messageParameters;
+	private final Object[] callerParameters;
+	
+	// Used to rate limit reports that are similar
+	private final long rateLimit;
+	
+	/**
+	 * Must be constructed through the factory method in Report.
+	 */
+	public static class ReportBuilder {
+		private ReportType type;
+		private Throwable exception;
+		private Object[] messageParameters;
+		private Object[] callerParameters;
+		private long rateLimit;
+	
+		private ReportBuilder() {
+			// Don't allow
+		}
+		
+		/**
+		 * Set the current report type. Cannot be NULL.
+		 * @param type - report type.
+		 * @return This builder, for chaining.
+		 */
+		public ReportBuilder type(ReportType type) {
+			if (type == null)
+				throw new IllegalArgumentException("Report type cannot be set to NULL.");
+			this.type = type;
+			return this;
+		}
+		
+		/**
+		 * Set the current exception that occurred.
+		 * @param exception - exception that occurred.
+		 * @return This builder, for chaining.
+		 */
+		public ReportBuilder error(@Nullable Throwable exception) {
+			this.exception = exception;
+			return this;
+		}
+		
+		/**
+		 * Set the message parameters that are used to construct a message text.
+		 * @param messageParameters - parameters for the report type.
+		 * @return This builder, for chaining.
+		 */
+		public ReportBuilder messageParam(@Nullable Object... messageParameters) {
+			this.messageParameters = messageParameters;
+			return this;
+		}
+		
+		/**
+		 * Set the parameters in the caller method. This is optional.
+		 * @param callerParameters - parameters of the caller method.
+		 * @return This builder, for chaining.
+		 */
+		public ReportBuilder callerParam(@Nullable Object... callerParameters) {
+			this.callerParameters = callerParameters;
+			return this;
+		}
+		
+		/**
+		 * Set the minimum number of nanoseconds to wait until a report of equal type and parameters
+		 * is allowed to be printed again.
+		 * @param rateLimit - number of nanoseconds, or 0 to disable. Cannot be negative.
+		 * @return This builder, for chaining.
+		 */
+		public ReportBuilder rateLimit(long rateLimit) {
+			if (rateLimit < 0)
+				throw new IllegalArgumentException("Rate limit cannot be less than zero.");
+			this.rateLimit = rateLimit;
+			return this;
+		}
+		
+		/**
+		 * Set the minimum time to wait until a report of equal type and parameters is allowed to be printed again.
+		 * @param rateLimit - the time, or 0 to disable. Cannot be negative.
+		 * @param rateUnit - the unit of the rate limit.
+		 * @return This builder, for chaining.
+		 */
+		public ReportBuilder rateLimit(long rateLimit, TimeUnit rateUnit) {
+			return rateLimit(TimeUnit.NANOSECONDS.convert(rateLimit, rateUnit));
+		}
+		
+		/**
+		 * Construct a new report with the provided input.
+		 * @return A new report.
+		 */
+		public Report build() {
+			return new Report(type, exception, messageParameters, callerParameters, rateLimit);
+		}
+	}
+	
+	/**
+	 * Construct a new report builder.
+	 * @param type - the initial report type.
+	 * @return Report builder.
+	 */
+	public static ReportBuilder newBuilder(ReportType type) {
+		return new ReportBuilder().type(type);
+	}
+	
+	/**
+	 * Construct a new report with the given type and parameters.
+	 * @param exception - exception that occured in the caller method.
+	 * @param type - the report type that will be used to construct the message.
+	 * @param messageParameters - parameters used to construct the report message.
+	 * @param callerParameters - parameters from the caller method.
+	 */
+	protected Report(ReportType type, @Nullable Throwable exception,
+			@Nullable Object[] messageParameters, @Nullable Object[] callerParameters) {
+		this(type, exception, messageParameters, callerParameters, 0);
+	}
+
+	/**
+	 * Construct a new report with the given type and parameters.
+	 * @param exception - exception that occurred in the caller method.
+	 * @param type - the report type that will be used to construct the message.
+	 * @param messageParameters - parameters used to construct the report message.
+	 * @param callerParameters - parameters from the caller method.
+	 * @param rateLimit - minimum number of nanoseconds to wait until a report of equal type and parameters is allowed to be printed again.
+	 */
+	protected Report(ReportType type, @Nullable Throwable exception,
+			@Nullable Object[] messageParameters, @Nullable Object[] callerParameters, long rateLimit) {
+		if (type == null)
+			throw new IllegalArgumentException("type cannot be NULL.");
+		this.type = type;
+		this.exception = exception;
+		this.messageParameters = messageParameters;
+		this.callerParameters = callerParameters;
+		this.rateLimit = rateLimit;
+	}
+	
+	/**
+	 * Format the current report type with the provided message parameters.
+	 * @return The formated report message.
+	 */
+	public String getReportMessage() {
+		return type.getMessage(messageParameters);
+	}
+	
+	/**
+	 * Retrieve the message parameters that will be used to construc the report message.
+	 * <p>
+	 * This should not be confused with the method parameters of the caller method.
+	 * @return Message parameters.
+	 */
+	public Object[] getMessageParameters() {
+		return messageParameters;
+	}
+	
+	/**
+	 * Retrieve the parameters of the caller method. Optional - may be NULL.
+	 * @return Parameters or the caller method.
+	 */
+	public Object[] getCallerParameters() {
+		return callerParameters;
+	}
+	
+	/**
+	 * Retrieve the report type.
+	 * @return Report type.
+	 */
+	public ReportType getType() {
+		return type;
+	}
+	
+	/**
+	 * Retrieve the associated exception, or NULL if not found.
+	 * @return Associated exception, or NULL.
+	 */
+	public Throwable getException() {
+		return exception;
+	}
+	
+	/**
+	 * Determine if we have any message parameters.
+	 * @return TRUE if there are any message parameters, FALSE otherwise.
+	 */
+	public boolean hasMessageParameters() {
+		return messageParameters != null && messageParameters.length > 0;
+	}
+	
+	/**
+	 * Determine if we have any caller parameters.
+	 * @return TRUE if there are any caller parameters, FALSE otherwise.
+	 */
+	public boolean hasCallerParameters() {
+		return callerParameters != null && callerParameters.length > 0;
+	}
+
+	/**
+	 * Retrieve desired  minimum number of nanoseconds until a report of the same type and parameters should be reprinted.
+	 * <p>
+	 * Note that this may be ignored or modified by the error reporter. Zero indicates no rate limit.
+	 * @return The number of nanoseconds. Never negative.
+	 */
+	public long getRateLimit() {
+		return rateLimit;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + Arrays.hashCode(callerParameters);
+		result = prime * result + Arrays.hashCode(messageParameters);
+		result = prime * result + ((type == null) ? 0 : type.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj instanceof Report) {
+			Report other = (Report) obj;
+			return type == other.type &&
+				   Arrays.equals(callerParameters, other.callerParameters) &&
+				   Arrays.equals(messageParameters, other.messageParameters);
+		}
+		return false;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/ReportType.java

@@ -0,0 +1,148 @@
+package com.comphenix.protocol.error;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.comphenix.protocol.reflect.FieldAccessException;
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
+
+/**
+ * Represents a strongly-typed report. Subclasses should be immutable.
+ * <p>
+ * By convention, a report must be declared as a static field publicly accessible from the sender class.
+ * @author Kristian
+ */
+public class ReportType {
+	private final String errorFormat;
+	
+	// Used to store the report name
+	protected String reportName;
+	
+	/**
+	 * Construct a new report type.
+	 * @param errorFormat - string used to format the underlying report.
+	 */
+	public ReportType(String errorFormat) {
+		this.errorFormat = errorFormat;
+	}
+	
+	/**
+	 * Convert the given report to a string, using the provided parameters.
+	 * @param parameters - parameters to insert, or NULL to insert nothing.
+	 * @return The full report in string format.
+	 */
+	public String getMessage(Object[] parameters) {
+		if (parameters == null || parameters.length == 0)
+			return toString();
+		else
+			return String.format(errorFormat, parameters);
+	}
+	
+	@Override
+	public String toString() {
+		return errorFormat;
+	}
+	
+	/**
+	 * Retrieve the class of the given sender.
+	 * <p>
+	 * If the sender is already a Class, we return it.
+	 * @param sender - the sender to look up.
+	 * @return The class of the sender.
+	 */
+	public static Class<?> getSenderClass(Object sender) {
+		if (sender == null)
+			throw new IllegalArgumentException("sender cannot be NUll.");
+		else if (sender instanceof Class<?>)
+			return (Class<?>) sender;
+		else
+			return sender.getClass();
+	}
+	
+	/**
+	 * Retrieve the full canonical name of a given report type.
+	 * <p>
+	 * Note that the sender may be a class (for static callers), in which 
+	 * case it will be used directly instead of its getClass() method.
+	 * <p>
+	 * It is thus not advisable for class classes to report reports.
+	 * @param sender - the sender, or its class.
+	 * @param type - the report type.
+	 * @return The full canonical name.
+	 */
+	public static String getReportName(Object sender, ReportType type) {
+		if (sender == null)
+			throw new IllegalArgumentException("sender cannot be NUll.");
+		return getReportName(getSenderClass(sender), type);
+	}
+	
+	/**
+	 * Retrieve the full canonical name of a given report type.
+	 * <p>
+	 * This is in the format <i>canonical_name_of_class#report_type</i>
+	 * @param clazz - the sender class.
+	 * @param type - the report instance.
+	 * @return The full canonical name.
+	 */
+	private static String getReportName(Class<?> sender, ReportType type) {
+		if (sender == null)
+			throw new IllegalArgumentException("sender cannot be NUll.");
+		
+		// Whether or not we need to retrieve the report name again
+		if (type.reportName == null) {
+			for (Field field : getReportFields(sender)) {
+				try {
+					field.setAccessible(true);
+					
+					if (field.get(null) == type) {
+						// We got the right field!
+						return type.reportName = field.getDeclaringClass().getCanonicalName() + "#" + field.getName();
+					}
+				} catch (IllegalAccessException e) {
+					throw new FieldAccessException("Unable to read field " + field, e);
+				}
+			}
+			throw new IllegalArgumentException("Cannot find report name for " + type);
+		}
+		return type.reportName;
+	}
+	
+	/**
+	 * Retrieve all publicly associated reports.
+	 * @param sender - sender class.
+	 * @return All associated reports.
+	 */
+	public static ReportType[] getReports(Class<?> sender) {
+		if (sender == null)
+			throw new IllegalArgumentException("sender cannot be NULL.");
+		List<ReportType> result = new ArrayList<ReportType>();
+		
+		// Go through all the fields
+		for (Field field : getReportFields(sender)) {
+			try {
+				field.setAccessible(true);
+				result.add((ReportType) field.get(null));
+			} catch (IllegalAccessException e) {
+				throw new FieldAccessException("Unable to read field " + field, e);
+			}
+		}
+		return result.toArray(new ReportType[0]);
+	}
+	
+	/**
+	 * Retrieve all publicly associated report fields.
+	 * @param clazz - sender class.
+	 * @return All associated report fields.
+	 */
+	private static List<Field> getReportFields(Class<?> clazz) {
+		return FuzzyReflection.fromClass(clazz).getFieldList(
+				FuzzyFieldContract.newBuilder().
+					requireModifier(Modifier.STATIC).
+					typeDerivedOf(ReportType.class).
+					build()
+		);
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/error/RethrowErrorReporter.java

@@ -0,0 +1,53 @@
+package com.comphenix.protocol.error;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.error.Report.ReportBuilder;
+import com.google.common.base.Joiner;
+
+/**
+ * Represents an error reporter that rethrows every exception instead.
+ * @author Kristian
+ */
+public class RethrowErrorReporter implements ErrorReporter {
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
+		throw new RuntimeException("Minimal error by " + sender + " in " + methodName, error);
+	}
+
+	@Override
+	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
+		throw new RuntimeException(
+				"Minimal error by " + sender + " in " + methodName + " with " + Joiner.on(",").join(parameters), error);
+	}
+
+	@Override
+	public void reportDebug(Object sender, Report report) {
+		// Do nothing - this is just a debug
+	}
+
+	@Override
+	public void reportDebug(Object sender, ReportBuilder builder) {
+		// As above
+	}
+	
+	@Override
+	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
+		reportWarning(sender, reportBuilder.build());
+	}
+	
+	@Override
+	public void reportWarning(Object sender, Report report) {
+		throw new RuntimeException("Warning by " + sender + ": " + report);
+	}
+
+	@Override
+	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
+		reportDetailed(sender, reportBuilder.build());
+	}
+	
+	@Override
+	public void reportDetailed(Object sender, Report report) {
+		throw new RuntimeException("Detailed error " + sender + ": " + report, report.getException());
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/events/ConnectionSide.java

@@ -0,0 +1,90 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.events;
+
+import com.comphenix.protocol.PacketType.Sender;
+
+/**
+ * Used to set a packet filter.
+ * 
+ * @author Kristian
+ */
+public enum ConnectionSide {
+	/**
+	 * Listen for server side packets that will invoke onPacketSending().
+	 */
+	SERVER_SIDE,
+	
+	/**
+	 * Listen for client side packets that will invoke onPacketReceiving().
+	 */
+	CLIENT_SIDE,
+	
+	/**
+	 * Listen for both client and server side packets.
+	 */
+	BOTH;
+	
+	public boolean isForClient() {
+		return this == CLIENT_SIDE || this == BOTH;
+	}
+	
+	public boolean isForServer() {
+		return this == SERVER_SIDE || this == BOTH;
+	}
+	
+	/**
+	 * Retrieve the sender of this connection side.
+	 * <p>
+	 * This is NULL for {@link #BOTH}.
+	 * @return The sender.
+	 */
+	public Sender getSender() {
+		if (this == SERVER_SIDE)
+			return Sender.SERVER;
+		else if (this == CLIENT_SIDE)
+			return Sender.CLIENT;
+		return null;
+	}
+	
+	/**
+	 * If both connection sides are present, return {@link #BOTH} - otherwise, return the one valud connection side.
+	 * <p>
+	 * NULL is not a valid connection side.
+	 * @param a - the first connection side.
+	 * @param b - the second connection side.
+	 * @return BOTH or the one valid side, or NULL.
+	 */
+	public static ConnectionSide add(ConnectionSide a, ConnectionSide b) {
+		if (a == null)
+			return b;
+		if (b == null)
+			return a;
+		
+		// Now merge them together
+		boolean client = a.isForClient() || b.isForClient();
+		boolean server = a.isForServer() || b.isForServer();
+		
+		if (client && server)
+			return BOTH;
+		else if (client)
+			return CLIENT_SIDE;
+		else
+			return SERVER_SIDE;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/events/ListenerOptions.java

@@ -0,0 +1,32 @@
+package com.comphenix.protocol.events;
+
+import com.comphenix.protocol.injector.GamePhase;
+
+
+/**
+ * Represents additional options a listener may require.
+ * 
+ * @author Kristian
+ */
+public enum ListenerOptions {
+	/**
+	 * Retrieve the serialized client packet as it appears on the network stream.
+	 */
+	INTERCEPT_INPUT_BUFFER,
+	
+	/**
+	 * Disable the automatic game phase detection that will normally force {@link GamePhase#LOGIN} when
+	 * a packet ID is known to be transmitted during login.
+	 */
+	DISABLE_GAMEPHASE_DETECTION,
+	
+	/**
+	 * Do not verify that the owning plugin has a vaid plugin.yml.
+	 */
+	SKIP_PLUGIN_VERIFIER,
+	
+	/**
+	 * Notify ProtocolLib that {@link PacketListener#onPacketSending(PacketEvent)} is thread safe.
+	 */
+	ASYNC;
+}

modules/API/src/main/java/com/comphenix/protocol/events/ListenerPriority.java

@@ -1,68 +1,68 @@
-/*
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2012 Kristian S. Stangeland
- *
- *  This program is free software; you can redistribute it and/or modify it under the terms of the 
- *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
- *  the License, or (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
- *  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with this program; 
- *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
- *  02111-1307 USA
- */
-
-package com.comphenix.protocol.events;
-
-/**
- * Represents a packet event priority, similar to the Bukkit EventPriority.
- * 
- * @author Kristian
- */
-public enum ListenerPriority {
-	/**
-	 * Event call is of very low importance and should be ran first, to allow
-	 * other plugins to further customise the outcome.
-	 */
-	LOWEST(0),
-	/**
-	 * Event call is of low importance.
-	 */
-	LOW(1),
-	/**
-	 * Event call is neither important or unimportant, and may be ran normally.
-	 */
-	NORMAL(2),
-	/**
-	 * Event call is of high importance.
-	 */
-	HIGH(3),
-	/**
-	 * Event call is critical and must have the final say in what happens to the
-	 * event.
-	 */
-	HIGHEST(4),
-	/**
-	 * Event is listened to purely for monitoring the outcome of an event.
-	 * <p/>
-	 * No modifications to the event should be made under this priority.
-	 */
-	MONITOR(5);
-
-	private final int slot;
-
-	private ListenerPriority(int slot) {
-		this.slot = slot;
-	}
-
-	/**
-	 * A low slot represents a low priority.
-	 * @return Integer representation of this priorty.
-	 */
-	public int getSlot() {
-		return slot;
-	}
-}
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.events;
+
+/**
+ * Represents a packet event priority, similar to the Bukkit EventPriority.
+ * 
+ * @author Kristian
+ */
+public enum ListenerPriority {
+	/**
+	 * Event call is of very low importance and should be ran first, to allow
+	 * other plugins to further customise the outcome.
+	 */
+	LOWEST(0),
+	/**
+	 * Event call is of low importance.
+	 */
+	LOW(1),
+	/**
+	 * Event call is neither important or unimportant, and may be ran normally.
+	 */
+	NORMAL(2),
+	/**
+	 * Event call is of high importance.
+	 */
+	HIGH(3),
+	/**
+	 * Event call is critical and must have the final say in what happens to the
+	 * event.
+	 */
+	HIGHEST(4),
+	/**
+	 * Event is listened to purely for monitoring the outcome of an event.
+	 * <p>
+	 * No modifications to the event should be made under this priority.
+	 */
+	MONITOR(5);
+
+	private final int slot;
+
+	private ListenerPriority(int slot) {
+		this.slot = slot;
+	}
+
+	/**
+	 * A low slot represents a low priority.
+	 * @return Integer representation of this priorty.
+	 */
+	public int getSlot() {
+		return slot;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/events/ListeningWhitelist.java

@@ -0,0 +1,484 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.events;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.injector.GamePhase;
+import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.google.common.base.Objects;
+import com.google.common.collect.Sets;
+
+/**
+ * Determines which packets will be observed by a listener, and with what priority.
+
+ * @author Kristian
+ */
+public class ListeningWhitelist {
+	/**
+	 * A whitelist with no packets - indicates that the listener shouldn't observe any packets.
+	 */
+	public static final ListeningWhitelist EMPTY_WHITELIST = new ListeningWhitelist(ListenerPriority.LOW);
+
+	private final ListenerPriority priority;
+	private final GamePhase gamePhase;
+	private final Set<ListenerOptions> options;
+	private final Set<PacketType> types;
+	
+	// Cache whitelist
+	private transient Set<Integer> intWhitelist;
+	
+	private ListeningWhitelist(Builder builder) {
+		this.priority = builder.priority;
+		this.types = builder.types;
+		this.gamePhase = builder.gamePhase;
+		this.options = builder.options;
+	}
+	
+	/**
+	 * Creates a packet whitelist for a given priority with a set of packet IDs.
+	 * <p>
+	 * Deprecated: Use {@link #newBuilder()} instead.
+	 * @param priority - the listener priority.
+	 * @param whitelist - set of IDs to observe/enable.
+	 */
+	@Deprecated
+	public ListeningWhitelist(ListenerPriority priority, Set<Integer> whitelist) {
+		this(priority, whitelist, GamePhase.PLAYING);
+	}
+
+	/**
+	 * Creates a packet whitelist for a given priority with a set of packet IDs.
+	 * <p>
+	 * Deprecated: Use {@link #newBuilder()} instead.
+	 * @param priority - the listener priority.
+	 * @param whitelist - set of IDs to observe/enable.
+	 * @param gamePhase - which game phase to receieve notifications on.
+	 */
+	@Deprecated
+	public ListeningWhitelist(ListenerPriority priority, Set<Integer> whitelist, GamePhase gamePhase) {
+		this.priority = priority;
+		this.types = PacketRegistry.toPacketTypes(safeSet(whitelist));
+		this.gamePhase = gamePhase;
+		this.options = EnumSet.noneOf(ListenerOptions.class);
+	}
+
+	/**
+	 * Creates a packet whitelist of a given priority for a list of packets.
+	 * <p>
+	 * Deprecated: Use {@link #newBuilder()} instead.
+	 * @param priority - the listener priority.
+	 * @param whitelist - list of packet IDs to observe/enable.
+	 */
+	@Deprecated
+	public ListeningWhitelist(ListenerPriority priority, Integer... whitelist) {
+		this.priority = priority;
+		this.types = PacketRegistry.toPacketTypes(Sets.newHashSet(whitelist));
+		this.gamePhase = GamePhase.PLAYING;
+		this.options = EnumSet.noneOf(ListenerOptions.class);
+	}
+
+	/**
+	 * Creates a packet whitelist for a given priority with a set of packet IDs.
+	 * <p>
+	 * Deprecated: Use {@link #newBuilder()} instead.
+	 * @param priority - the listener priority.
+	 * @param whitelist - list of packet IDs to observe/enable.
+	 * @param gamePhase - which game phase to receieve notifications on.
+	 */
+	@Deprecated
+	public ListeningWhitelist(ListenerPriority priority, Integer[] whitelist, GamePhase gamePhase) {
+		this.priority = priority;
+		this.types = PacketRegistry.toPacketTypes(Sets.newHashSet(whitelist));
+		this.gamePhase = gamePhase;
+		this.options = EnumSet.noneOf(ListenerOptions.class);
+	}
+
+	/**
+	 * Creates a packet whitelist for a given priority with a set of packet IDs and options.
+	 * <p>
+	 * Deprecated: Use {@link #newBuilder()} instead.
+	 * @param priority - the listener priority.
+	 * @param whitelist - list of packet IDs to observe/enable.
+	 * @param gamePhase - which game phase to receieve notifications on.
+	 * @param options - every special option associated with this whitelist.
+	 */
+	@Deprecated
+	public ListeningWhitelist(ListenerPriority priority, Integer[] whitelist, GamePhase gamePhase, ListenerOptions... options) {
+		this.priority = priority;
+		this.types = PacketRegistry.toPacketTypes(Sets.newHashSet(whitelist));
+		this.gamePhase = gamePhase;
+		this.options = safeEnumSet(Arrays.asList(options), ListenerOptions.class);
+	}
+
+	/**
+	 * Whether or not this whitelist has any enabled packets.
+	 * @return TRUE if there are any packets, FALSE otherwise.
+	 */
+	public boolean isEnabled() {
+		return types != null && types.size() > 0;
+	}
+
+	/**
+	 * Retrieve the priority in the execution order of the packet listener. Highest priority will be executed last.
+	 * @return Execution order in terms of priority.
+	 */
+	public ListenerPriority getPriority() {
+		return priority;
+	}
+
+	/**
+	 * Retrieves the list of packets that will be observed by the listeners.
+	 * <p>
+	 * Deprecated: Use {@link #getTypes()} instead.
+	 * @return Packet whitelist.
+	 */
+	@Deprecated
+	public Set<Integer> getWhitelist() {
+		if (intWhitelist == null)
+			intWhitelist = PacketRegistry.toLegacy(types);
+		return intWhitelist;
+	}
+
+	/**
+	 * Retrieves a set of the packets that will be observed by the listeners.
+	 * @return Packet whitelist.
+	 */
+	public Set<PacketType> getTypes() {
+		return types;
+	}
+	
+	/**
+	 * Retrieve which game phase this listener is active under.
+	 * @return The active game phase.
+	 */
+	public GamePhase getGamePhase() {
+		return gamePhase;
+	}
+	
+	/**
+	 * Retrieve every special option associated with this whitelist.
+	 * @return Every special option.
+	 */
+	public Set<ListenerOptions> getOptions() {
+		return Collections.unmodifiableSet(options);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hashCode(priority, types, gamePhase, options);
+	}
+
+	/**
+	 * Determine if any of the given IDs can be found in the whitelist.
+	 * @param whitelist - whitelist to test.
+	 * @param idList - list of packet IDs to find.
+	 * @return TRUE if any of the packets in the list can be found in the whitelist, FALSE otherwise.
+	 */
+	public static boolean containsAny(ListeningWhitelist whitelist, int... idList) {
+		if (whitelist != null) {
+			for (int i = 0; i < idList.length; i++) {
+				if (whitelist.getWhitelist().contains(idList[i]))
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Determine if the given whitelist is empty or not.
+	 * @param whitelist - the whitelist to test.
+	 * @return TRUE if the whitelist is empty, FALSE otherwise.
+	 */
+	public static boolean isEmpty(ListeningWhitelist whitelist) {
+		if (whitelist == EMPTY_WHITELIST)
+			return true;
+		else if (whitelist == null)
+			return true;
+		else
+			return whitelist.getTypes().isEmpty();
+	}
+
+	@Override
+	public boolean equals(final Object obj) {
+		if (obj instanceof ListeningWhitelist) {
+			final ListeningWhitelist other = (ListeningWhitelist) obj;
+			return Objects.equal(priority, other.priority)
+					&& Objects.equal(types, other.types)
+					&& Objects.equal(gamePhase, other.gamePhase)
+					&& Objects.equal(options, other.options);
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public String toString() {
+		if (this == EMPTY_WHITELIST)
+			return "EMPTY_WHITELIST";
+		else
+			return Objects.toStringHelper(this).
+				add("priority", priority).
+				add("packets", types).
+				add("gamephase", gamePhase).
+				add("options", options).
+				toString();
+	}
+	
+	/**
+	 * Construct a new builder of whitelists.
+	 * @return New whitelist builder.
+	 */
+	public static Builder newBuilder() {
+		return new Builder(null);
+	}
+	
+	/**
+	 * Construct a new builder of whitelists initialized to the same values as the template.
+	 * @param template - the template object.
+	 * @return New whitelist builder.
+	 */
+	public static Builder newBuilder(ListeningWhitelist template) {
+		return new Builder(template);
+	}
+	
+	/**
+	 * Construct a copy of a given enum.
+	 * @param options - the options to copy, or NULL to indicate the empty set.
+	 * @return A copy of the enum set.
+	 */
+	private static <T extends Enum<T>> EnumSet<T> safeEnumSet(Collection<T> options, Class<T> enumClass) {
+		if (options != null && !options.isEmpty()) {
+			return EnumSet.copyOf(options);
+		} else {
+			return EnumSet.noneOf(enumClass);
+		}
+	}
+	
+	/**
+	 * Construct a copy of a given set.
+	 * @param list - the set to copy.
+	 * @return The copied set.
+	 */
+	private static <T> Set<T> safeSet(Collection<T> set) {
+		if (set != null)
+			return Sets.newHashSet(set);
+		else
+			return Collections.emptySet();
+	}
+
+	/**
+	 * Represents a builder of whitelists.
+	 * @author Kristian
+	 */
+	public static class Builder {
+		// Default values
+		private ListenerPriority priority = ListenerPriority.NORMAL;
+		private Set<PacketType> types = Sets.newHashSet();
+		private GamePhase gamePhase = GamePhase.PLAYING;
+		private Set<ListenerOptions> options = Sets.newHashSet();
+		
+		/**
+		 * Construct a new listening whitelist template.
+		 * @param template - the template.
+		 */
+		private Builder(ListeningWhitelist template) {
+			if (template != null) {
+				priority(template.getPriority());
+				gamePhase(template.getGamePhase());
+				types(template.getTypes());
+				options(template.getOptions());
+			}
+		}
+		
+		/**
+		 * Set the priority to use when constructing new whitelists.
+		 * @param priority - the priority.
+		 * @return This builder, for chaining.
+		 */
+		public Builder priority(ListenerPriority priority) {
+			this.priority = priority;
+			return this;
+		}
+		
+		/**
+		 * Set the priority of the whitelist to monitor.
+		 * @return This builder, for chaining.
+		 */
+		public Builder monitor() {
+			return priority(ListenerPriority.MONITOR);
+		}
+		
+		/**
+		 * Set the priority of the whitelist to normal.
+		 * @return This builder, for chaining.
+		 */
+		public Builder normal() {
+			return priority(ListenerPriority.NORMAL);
+		}
+		
+		/**
+		 * Set the priority of the whitelist to lowest.
+		 * @return This builder, for chaining.
+		 */
+		public Builder lowest() {
+			return priority(ListenerPriority.LOWEST);
+		}
+		
+		/**
+		 * Set the priority of the whitelist to low.
+		 * @return This builder, for chaining.
+		 */
+		public Builder low() {
+			return priority(ListenerPriority.LOW);
+		}
+		
+		/**
+		 * Set the priority of the whitelist to highest.
+		 * @return This builder, for chaining.
+		 */
+		public Builder highest() {
+			return priority(ListenerPriority.HIGHEST);
+		}
+		
+		/**
+		 * Set the priority of the whitelist to high.
+		 * @return This builder, for chaining.
+		 */
+		public Builder high() {
+			return priority(ListenerPriority.HIGH);
+		}
+		
+		/**
+		 * Set the whitelist of packet IDs to copy when constructing new whitelists.
+		 * <p>
+		 * Deprecated: Use {@link #types(Collection)} instead.
+		 * @param whitelist - the whitelist of packets.
+		 * @return This builder, for chaining.
+		 */
+		@Deprecated
+		public Builder whitelist(Collection<Integer> whitelist) {
+			this.types = PacketRegistry.toPacketTypes(safeSet(whitelist));
+			return this;
+		}
+		
+		/**
+		 * Set the whitelist of packet types to copy when constructing new whitelists.
+		 * @param types - the whitelist of packets.
+		 * @return This builder, for chaining.
+		 */
+		public Builder types(PacketType... types) {
+			this.types = safeSet(Sets.newHashSet(types));
+			return this;
+		}
+		
+		/**
+		 * Set the whitelist of packet types to copy when constructing new whitelists.
+		 * @param types - the whitelist of packets.
+		 * @return This builder, for chaining.
+		 */
+		public Builder types(Collection<PacketType> types) {
+			this.types = safeSet(types);
+			return this;
+		}
+		
+		/**
+		 * Set the gamephase to use when constructing new whitelists.
+		 * @param gamePhase - the gamephase.
+		 * @return This builder, for chaining.
+		 */
+		public Builder gamePhase(GamePhase gamePhase) {
+			this.gamePhase = gamePhase;
+			return this;
+		}
+		
+		/**
+		 * Set the gamephase to {@link GamePhase#BOTH}.
+		 * @return This builder, for chaining.
+		 */
+		public Builder gamePhaseBoth() {
+			return gamePhase(GamePhase.BOTH);
+		}
+		/**
+		 * Set the options to copy when constructing new whitelists.
+		 * @param options - the options.
+		 * @return This builder, for chaining.
+		 */
+		public Builder options(Set<ListenerOptions> options) {
+			this.options = safeSet(options);
+			return this;
+		}
+		
+		/**
+		 * Set the options to copy when constructing new whitelists.
+		 * @param options - the options.
+		 * @return This builder, for chaining.
+		 */
+		public Builder options(Collection<ListenerOptions> options) {
+			this.options = safeSet(options);
+			return this;
+		}
+		
+		/**
+		 * Set the options to copy when constructing new whitelists.
+		 * @param serverOptions - the options array.
+		 * @return This builder, for chaining.
+		 */
+		public Builder options(ListenerOptions[] serverOptions) {
+			this.options = safeSet(Sets.newHashSet(serverOptions));
+			return this;
+		}
+		
+		/**
+		 * Options to merge into the current set of options.
+		 * @param serverOptions - the options array.
+		 * @return This builder, for chaining.
+		 */
+		public Builder mergeOptions(ListenerOptions... serverOptions) {
+			return mergeOptions(Arrays.asList(serverOptions));
+		}
+		
+		/**
+		 * Options to merge into the current set of options.
+		 * @param serverOptions - the options array.
+		 * @return This builder, for chaining.
+		 */
+		public Builder mergeOptions(Collection<ListenerOptions> serverOptions) {
+			if (options == null)
+				return options(serverOptions);
+			
+			// Merge the options
+			this.options.addAll(serverOptions);
+			return this;
+		}
+		
+		/**
+		 * Construct a new whitelist from the values in this builder.
+		 * @return The new whitelist.
+		 */
+		public ListeningWhitelist build() {
+			return new ListeningWhitelist(this);
+		}
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/events/MonitorAdapter.java

@@ -0,0 +1,96 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the 
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of 
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program; 
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.events;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.Packets;
+import com.comphenix.protocol.injector.GamePhase;
+import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.comphenix.protocol.reflect.FieldAccessException;
+
+/**
+ * Represents a listener that is notified of every sent and received packet.
+ * 
+ * @author Kristian
+ */
+public abstract class MonitorAdapter implements PacketListener {
+
+	private Plugin plugin;
+	private ListeningWhitelist sending = ListeningWhitelist.EMPTY_WHITELIST;
+	private ListeningWhitelist receiving = ListeningWhitelist.EMPTY_WHITELIST;
+
+	public MonitorAdapter(Plugin plugin, ConnectionSide side) {
+		initialize(plugin, side, getLogger(plugin));
+	}
+	
+	public MonitorAdapter(Plugin plugin, ConnectionSide side, Logger logger) {
+		initialize(plugin, side, logger);
+	}
+	
+	@SuppressWarnings("deprecation")
+	private void initialize(Plugin plugin, ConnectionSide side, Logger logger) {
+		this.plugin = plugin;
+
+		// Recover in case something goes wrong
+		try {
+			if (side.isForServer())
+				this.sending = ListeningWhitelist.newBuilder().monitor().types(PacketRegistry.getServerPacketTypes()).gamePhaseBoth().build();
+			if (side.isForClient())
+				this.receiving = ListeningWhitelist.newBuilder().monitor().types(PacketRegistry.getClientPacketTypes()).gamePhaseBoth().build();
+		} catch (FieldAccessException e) {
+			if (side.isForServer())
+				this.sending = new ListeningWhitelist(ListenerPriority.MONITOR, Packets.Server.getRegistry().values(), GamePhase.BOTH);
+			if (side.isForClient())
+				this.receiving = new ListeningWhitelist(ListenerPriority.MONITOR, Packets.Client.getRegistry().values(), GamePhase.BOTH);
+			logger.log(Level.WARNING, "Defaulting to 1.3 packets.", e);
+		}
+	}
+	
+	/**
+	 * Retrieve a logger, even if we're running in a CraftBukkit version that doesn't support it.
+	 * @param plugin - the plugin to retrieve.
+	 * @return The logger.
+	 */
+	private Logger getLogger(Plugin plugin) {
+		try {
+			return plugin.getLogger();
+		} catch (NoSuchMethodError e) {
+			return Logger.getLogger("Minecraft");
+		}
+	}
+	
+	@Override
+	public ListeningWhitelist getSendingWhitelist() {
+		return sending;
+	}
+	
+	@Override
+	public ListeningWhitelist getReceivingWhitelist() {
+		return receiving;
+	}
+	
+	@Override
+	public Plugin getPlugin() {
+		return plugin;
+	}
+}
+

modules/API/src/main/java/com/comphenix/protocol/events/NetworkMarker.java

@@ -0,0 +1,421 @@
+package com.comphenix.protocol.events;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.PriorityQueue;
+
+import javax.annotation.Nonnull;
+
+import org.bukkit.entity.Player;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolManager;
+import com.comphenix.protocol.utility.ByteBufferInputStream;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.utility.StreamSerializer;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+
+/**
+ * Marker containing the serialized packet data seen from the network,
+ * or output handlers that will serialize the current packet.
+ * 
+ * @author Kristian
+ */
+public abstract class NetworkMarker {
+	public static class EmptyBufferMarker extends NetworkMarker {
+		public EmptyBufferMarker(@Nonnull ConnectionSide side) {
+			super(side, (byte[]) null, null);
+		}
+
+		@Override
+		protected DataInputStream skipHeader(DataInputStream input) throws IOException {
+			throw new IllegalStateException("Buffer is empty.");
+		}
+
+		@Override
+		protected ByteBuffer addHeader(ByteBuffer buffer, PacketType type) {
+			throw new IllegalStateException("Buffer is empty.");
+		}
+
+		@Override
+		protected DataInputStream addHeader(DataInputStream input, PacketType type) {
+			throw new IllegalStateException("Buffer is empty.");
+		}
+	}
+	
+	// Custom network handler
+	private PriorityQueue<PacketOutputHandler> outputHandlers;
+	// Post listeners
+	private List<PacketPostListener> postListeners;
+	// Post packets
+	private List<ScheduledPacket> scheduledPackets;
+	
+	// The input buffer
+	private ByteBuffer inputBuffer;
+	private final ConnectionSide side;
+	private final PacketType type;
+	
+	// Cache serializer too
+	private StreamSerializer serializer;
+	
+	/**
+	 * Construct a new network marker.
+	 * @param side - which side this marker belongs to.
+	 * @param inputBuffer - the read serialized packet data.
+	 * @param type - packet type
+	 */
+	public NetworkMarker(@Nonnull ConnectionSide side, ByteBuffer inputBuffer, PacketType type) {
+		this.side = Preconditions.checkNotNull(side, "side cannot be NULL.");
+		this.inputBuffer = inputBuffer;
+		this.type = type;
+	}
+	
+	/**
+	 * Construct a new network marker.
+	 * <p>
+	 * The input buffer is only non-null for client-side packets.
+	 * @param side - which side this marker belongs to.
+	 * @param inputBuffer - the read serialized packet data.
+	 * @param type - packet type
+	 */
+	public NetworkMarker(@Nonnull ConnectionSide side, byte[] inputBuffer, PacketType type) {
+		this.side = Preconditions.checkNotNull(side, "side cannot be NULL.");
+		this.type = type;
+			
+		if (inputBuffer != null) {
+			this.inputBuffer = ByteBuffer.wrap(inputBuffer);
+		}
+	}
+	
+	/**
+	 * Retrieve whether or not this marker belongs to a client or a server side packet.
+	 * @return The side the parent packet belongs to.
+	 */
+	public ConnectionSide getSide() {
+		return side;
+	}
+
+	/**
+	 * Retrieve a utility class for serializing and deserializing Minecraft objects.
+	 * @return Serialization utility class.
+	 */
+	public StreamSerializer getSerializer() {
+		if (serializer == null)
+			serializer = new StreamSerializer();
+		return serializer;
+	}
+	
+	/**
+	 * Retrieve the serialized packet data (excluding the header by default) from the network input stream.
+	 * <p>
+	 * The returned buffer is read-only. If the parent event is a server side packet this
+	 * method throws {@link IllegalStateException}.
+	 * <p>
+	 * It returns NULL if the packet was transmitted by a plugin locally.
+	 * @return A byte buffer containing the raw packet data read from the network.
+	 */
+	public ByteBuffer getInputBuffer() {
+		return getInputBuffer(true);
+	}
+		
+	/**
+	 * Retrieve the serialized packet data from the network input stream.
+	 * <p>
+	 * The returned buffer is read-only. If the parent event is a server side packet this
+	 * method throws {@link IllegalStateException}.
+	 * <p>
+	 * It returns NULL if the packet was transmitted by a plugin locally.
+	 * @param excludeHeader - whether or not to exclude the packet ID header.
+	 * @return A byte buffer containing the raw packet data read from the network.
+	 */
+	public ByteBuffer getInputBuffer(boolean excludeHeader) {
+		if (side.isForServer())
+			throw new IllegalStateException("Server-side packets have no input buffer.");
+		
+		if (inputBuffer != null) {
+			ByteBuffer result = inputBuffer.asReadOnlyBuffer();
+			
+			try {
+				if (excludeHeader)
+					result = skipHeader(result);
+				else
+					result = addHeader(result, type);
+			} catch (IOException e) {
+				throw new RuntimeException("Cannot skip packet header.", e);
+			}
+			return result;
+		}
+		return null;
+	}
+	
+	/**
+	 * Retrieve the serialized packet data (excluding the header by default) as an input stream.
+	 * <p>
+	 * The data is exactly the same as in {@link #getInputBuffer()}.
+	 * @see #getInputBuffer()
+	 * @return The incoming serialized packet data as a stream, or NULL if the packet was transmitted locally.
+	 */
+	public DataInputStream getInputStream() {
+		return getInputStream(true);
+	}
+	
+	/**
+	 * Retrieve the serialized packet data as an input stream.
+	 * <p>
+	 * The data is exactly the same as in {@link #getInputBuffer()}.
+	 * @see #getInputBuffer()
+	 * @param excludeHeader - whether or not to exclude the packet ID header.
+	 * @return The incoming serialized packet data as a stream, or NULL if the packet was transmitted locally.
+	 */
+	@SuppressWarnings("resource")
+	public DataInputStream getInputStream(boolean excludeHeader) {
+		if (side.isForServer())
+			throw new IllegalStateException("Server-side packets have no input buffer.");
+		if (inputBuffer == null)
+			return null;
+		
+		DataInputStream input = new DataInputStream(
+				new ByteArrayInputStream(inputBuffer.array())
+		);
+		
+		try {
+			if (excludeHeader)
+				input = skipHeader(input);
+			else
+				input = addHeader(input, type);
+		} catch (IOException e) {
+			throw new RuntimeException("Cannot skip packet header.", e);
+		}
+		return input;
+	}
+	
+	/**
+	 * Whether or not the output handlers have to write a packet header.
+	 * @return TRUE if they do, FALSE otherwise.
+	 */
+	public boolean requireOutputHeader() {
+		return MinecraftReflection.isUsingNetty();
+	}
+	
+	/**
+	 * Enqueue the given output handler for managing how the current packet will be written to the network stream.
+	 * <p>
+	 * Note that output handlers are not serialized, as most consumers will probably implement them using anonymous classes.
+	 * It is not safe to serialize anonymous classes, as their name depend on the order in which they are declared in the parent class.
+	 * <p>
+	 * This can only be invoked on server side packet events.
+	 * @param handler - the handler that will take part in serializing the packet.
+	 * @return TRUE if it was added, FALSE if it has already been added.
+	 */
+	public boolean addOutputHandler(@Nonnull PacketOutputHandler handler) {
+		checkServerSide();
+		Preconditions.checkNotNull(handler, "handler cannot be NULL.");
+		
+		// Lazy initialization - it's imperative that we save space and time here
+		if (outputHandlers == null) {
+			outputHandlers = new PriorityQueue<PacketOutputHandler>(10, new Comparator<PacketOutputHandler>() {
+				@Override
+				public int compare(PacketOutputHandler o1, PacketOutputHandler o2) {
+					return Ints.compare(o1.getPriority().getSlot(), o2.getPriority().getSlot());
+				}
+			});
+		}
+		return outputHandlers.add(handler);
+	}
+	
+	/**
+	 * Remove a given output handler from the serialization queue.
+	 * <p>
+	 * This can only be invoked on server side packet events.
+	 * @param handler - the handler to remove.
+	 * @return TRUE if the handler was removed, FALSE otherwise.
+	 */
+	public boolean removeOutputHandler(@Nonnull PacketOutputHandler handler) {
+		checkServerSide();
+		Preconditions.checkNotNull(handler, "handler cannot be NULL.");
+		
+		if (outputHandlers != null) {
+			return outputHandlers.remove(handler);
+		}
+		return false;
+	}
+	
+	/**
+	 * Retrieve every registered output handler in no particular order.
+	 * @return Every registered output handler.
+	 */
+	@Nonnull
+	public Collection<PacketOutputHandler> getOutputHandlers() {
+		if (outputHandlers != null) {
+			return outputHandlers;
+		} else {
+			return Collections.emptyList();
+		}
+	}
+	
+	/**
+	 * Add a listener that is invoked after a packet has been successfully sent to the client, or received
+	 * by the server.
+	 * <p>
+	 * Received packets are not guarenteed to have been fully processed, but packets passed
+	 * to {@link ProtocolManager#recieveClientPacket(Player, PacketContainer)} will be processed after the
+	 * current packet event.
+	 * <p>
+	 * Note that post listeners will be executed asynchronously off the main thread. They are not executed
+	 * in any defined order.
+	 * @param listener - the listener that will be invoked.
+	 * @return TRUE if it was added.
+	 */
+	public boolean addPostListener(PacketPostListener listener) {
+		if (postListeners == null)
+			postListeners = Lists.newArrayList();
+		return postListeners.add(listener);
+	}
+	
+	/**
+	 * Remove the first instance of the given listener.
+	 * @param listener - listener to remove.
+	 * @return TRUE if it was removed, FALSE otherwise.
+	 */
+	public boolean removePostListener(PacketPostListener listener) {
+		if (postListeners != null) {
+			return postListeners.remove(listener);
+		}
+		return false;
+	}
+	
+	/**
+	 * Retrieve an immutable view of all the listeners that will be invoked once the packet has been sent or received.
+	 * @return Every post packet listener. Never NULL.
+	 */
+	public List<PacketPostListener> getPostListeners() {
+		return postListeners != null ? Collections.unmodifiableList(postListeners) : Collections.<PacketPostListener>emptyList();
+	}
+	
+	/**
+	 * Retrieve a list of packets that will be schedule (in-order) when the current packet has been successfully transmitted.
+	 * <p>
+	 * This list is modifiable.
+	 * @return List of packets that will be scheduled.
+	 */
+	public List<ScheduledPacket> getScheduledPackets() {
+		if (scheduledPackets == null)
+			scheduledPackets = Lists.newArrayList();
+		return scheduledPackets;
+	}
+	
+	/**
+	 * Ensure that the packet event is server side.
+	 */
+	private void checkServerSide() {
+		if (side.isForClient()) {
+			throw new IllegalStateException("Must be a server side packet.");
+		}
+	}
+	
+	/**
+	 * Return a byte buffer without the header in the current packet.
+	 * <p>
+	 * It's safe to modify the position of the buffer.
+	 * @param buffer - a read-only byte source.
+	 * @return A byte buffer without the header in the current packet.
+	 * @throws IOException If integer reading fails
+	 */
+	protected ByteBuffer skipHeader(ByteBuffer buffer) throws IOException {
+		skipHeader(new DataInputStream(new ByteBufferInputStream(buffer)));
+		return buffer;
+	}
+	
+	/**
+	 * Return an input stream without the header in the current packet.
+	 * <p>
+	 * It's safe to modify the input stream.
+	 * @param input - input stream
+	 * @return An input stream without the header
+	 * @throws IOException If integer reading fails
+	 */
+	protected abstract DataInputStream skipHeader(DataInputStream input) throws IOException;
+	
+	/**
+	 * Return the byte buffer prepended with the packet header.
+	 * @param buffer - the read-only byte buffer.
+	 * @param type - the current packet.
+	 * @return The byte buffer.
+	 */
+	protected abstract ByteBuffer addHeader(ByteBuffer buffer, PacketType type);
+	
+	/**
+	 * Return the input stream prepended with the packet header.
+	 * @param input - the input stream.
+	 * @param type - the current packet.
+	 * @return The byte buffer.
+	 */
+	protected abstract DataInputStream addHeader(DataInputStream input, PacketType type);
+	
+	/**
+	 * Determine if the given marker has any output handlers.
+	 * @param marker - the marker to check.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	public static boolean hasOutputHandlers(NetworkMarker marker) {
+		return marker != null && !marker.getOutputHandlers().isEmpty();
+	}
+	
+	/**
+	 * Determine if the given marker has any post listeners.
+	 * @param marker - the marker to check.
+	 * @return TRUE if it does, FALSE otherwise.
+	 */
+	public static boolean hasPostListeners(NetworkMarker marker) {
+		return marker != null && !marker.getPostListeners().isEmpty();
+	}
+	
+	/**
+	 * Retrieve the byte buffer stored in the given marker.
+	 * @param marker - the marker.
+	 * @return The byte buffer, or NULL if not found.
+	 */
+	public static byte[] getByteBuffer(NetworkMarker marker) {
+		if (marker != null) {
+			ByteBuffer buffer = marker.getInputBuffer();
+			
+			if (buffer != null) {
+				byte[] data = new byte[buffer.remaining()];
+				
+				buffer.get(data, 0, data.length);
+				return data;
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Retrieve the network marker of a particular event without creating it.
+	 * <p>
+	 * This is an internal method that should not be used by API users.
+	 * @param event - the event.
+	 * @return The network marker.
+	 */
+	public static NetworkMarker getNetworkMarker(PacketEvent event) {
+		return event.networkMarker;
+	}
+	
+	/**
+	 * Retrieve the scheduled packets of a particular network marker without constructing the list.
+	 * <p>
+	 * This is an internal method that should not be used by API users.
+	 * @param marker - the marker.
+	 * @return The list, or NULL if not found or initialized.
+	 */
+	public static List<ScheduledPacket> readScheduledPackets(NetworkMarker marker) {
+		return marker.scheduledPackets;
+	}
+}

modules/API/src/main/java/com/comphenix/protocol/events/PacketAdapter.java

@@ -0,0 +1,636 @@
+/*
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2012 Kristian S. Stangeland
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+
+package com.comphenix.protocol.events;
+
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.injector.GamePhase;
+import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+/**
+ * Represents a packet listener with useful constructors.
+ * <p>
+ * Remember to override onPacketReceiving() and onPacketSending(), depending on the ConnectionSide.
+ * @author Kristian
+ */
+public abstract class PacketAdapter implements PacketListener {
+	protected Plugin plugin;
+	protected ConnectionSide connectionSide;
+	protected ListeningWhitelist receivingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
+	protected ListeningWhitelist sendingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
+
+	/**
+	 * Initialize a packet adapter using a collection of parameters. Use {@link #params()} to get an instance to this builder.
+	 * @param params - the parameters.
+	 */
+	public PacketAdapter(@Nonnull AdapterParameteters params) {
+		this(
+			checkValidity(params).plugin, params.connectionSide, params.listenerPriority,
+			params.gamePhase, params.options, params.packets
+		);
+	}
+	
+	/**
+	 * Initialize a packet listener with the given parameters.
+	 * @param plugin - the plugin.
+	 * @param types - the packet types.
+	 */
+	public PacketAdapter(Plugin plugin, PacketType... types) {
+		this(plugin, ListenerPriority.NORMAL, types);
+	}
+	
+	/**
+	 * Initialize a packet listener with the given parameters.
+	 * @param plugin - the plugin.
+	 * @param types - the packet types.
+	 */
+	public PacketAdapter(Plugin plugin, Iterable<? extends PacketType> types) {
+		this(params(plugin, Iterables.toArray(types, PacketType.class)));
+	}
+	
+	/**
+	 * Initialize a packet listener with the given parameters.
+	 * @param plugin - the plugin.
+	 * @param listenerPriority - the priority.
+	 * @param types - the packet types.
+	 */
+	public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, Iterable<? extends PacketType> types) {
+		this(params(plugin, Iterables.toArray(types, PacketType.class)).listenerPriority(listenerPriority));
+	}
+	
+	/**
+	 * Initialize a packet listener with the given parameters.
+	 * @param plugin - the plugin.
+	 * @param listenerPriority - the priority.
+	 * @param types - the packet types.
+	 * @param options - the options.
+	 */
+	public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, Iterable<? extends PacketType> types, ListenerOptions... options) {
+		this(params(plugin, Iterables.toArray(types, PacketType.class)).listenerPriority(listenerPriority).options(options));
+	}
+	
+	/**
+	 * Initialize a packet listener with the given parameters.
+	 * @param plugin - the plugin.
+	 * @param listenerPriority - the priority.
+	 * @param types - the packet types.
+	 */
+	public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, PacketType... types) {
+		this(params(plugin, types).listenerPriority(listenerPriority));
+	}
+	
+	/**
+	 * Initialize a packet listener with default priority.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, Integer... packets) {
+		this(plugin, connectionSide, ListenerPriority.NORMAL, packets);
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param listenerPriority - the event priority.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Set<Integer> packets) {
+		this(plugin, connectionSide, listenerPriority, GamePhase.PLAYING, packets.toArray(new Integer[0]));
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param gamePhase - which game phase this listener is active under.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, GamePhase gamePhase, Set<Integer> packets) {
+		this(plugin, connectionSide, ListenerPriority.NORMAL, gamePhase, packets.toArray(new Integer[0]));
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param listenerPriority - the event priority.
+	 * @param gamePhase - which game phase this listener is active under.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, GamePhase gamePhase, Set<Integer> packets) {
+		this(plugin, connectionSide, listenerPriority, gamePhase, packets.toArray(new Integer[0]));
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param listenerPriority - the event priority.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Integer... packets) {
+		this(plugin, connectionSide, listenerPriority, GamePhase.PLAYING, packets);
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param options - which listener options to use.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerOptions[] options, Integer... packets) {
+		this(plugin, connectionSide, ListenerPriority.NORMAL, GamePhase.PLAYING, options, packets);
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param gamePhase - which game phase this listener is active under.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, GamePhase gamePhase, Integer... packets) {
+		this(plugin, connectionSide, ListenerPriority.NORMAL, gamePhase, packets);
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param listenerPriority - the event priority.
+	 * @param gamePhase - which game phase this listener is active under.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, GamePhase gamePhase, Integer... packets) {
+		this(plugin, connectionSide, listenerPriority, gamePhase, new ListenerOptions[0], packets);
+	}
+	
+	/**
+	 * Initialize a packet listener for a single connection side.
+	 * <p>
+	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
+	 * <p>
+	 * Listener options must be specified in order for {@link NetworkMarker#getInputBuffer()} to function correctly.
+	 * <p>
+	 * Deprecated: Use {@link #params()} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param connectionSide - the packet type the listener is looking for.
+	 * @param listenerPriority - the event priority.
+	 * @param gamePhase - which game phase this listener is active under.
+	 * @param options - which listener options to use.
+	 * @param packets - the packet IDs the listener is looking for.
+	 */
+	@Deprecated
+	public PacketAdapter(
+			Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority,
+			GamePhase gamePhase, ListenerOptions[] options, Integer... packets) {
+		
+		this(plugin, connectionSide, listenerPriority, gamePhase, options,
+			PacketRegistry.toPacketTypes(Sets.newHashSet(packets), connectionSide.getSender()).toArray(new PacketType[0])
+		);
+	}
+	
+	// For internal use only
+	private PacketAdapter(
+			Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority,
+			GamePhase gamePhase, ListenerOptions[] options, PacketType... packets) {
+		
+		if (plugin == null)
+			throw new IllegalArgumentException("plugin cannot be null");
+		if (connectionSide == null)
+			throw new IllegalArgumentException("connectionSide cannot be null");
+		if (listenerPriority == null)
+			throw new IllegalArgumentException("listenerPriority cannot be null");
+		if (gamePhase == null)
+			throw new IllegalArgumentException("gamePhase cannot be NULL");
+		if (packets == null)
+			throw new IllegalArgumentException("packets cannot be null");
+		if (options == null)
+			throw new IllegalArgumentException("options cannot be null");
+		
+		ListenerOptions[] serverOptions = options;
+		ListenerOptions[] clientOptions = options;
+		
+		// Special case that allows us to specify optionIntercept().
+		if (connectionSide == ConnectionSide.BOTH) {
+			serverOptions = except(serverOptions, new ListenerOptions[0],
+					ListenerOptions.INTERCEPT_INPUT_BUFFER);
+		}
+		
+		// Add whitelists
+		if (connectionSide.isForServer())
+			sendingWhitelist = ListeningWhitelist.newBuilder().
+				priority(listenerPriority).
+				types(packets).
+				gamePhase(gamePhase).
+				options(serverOptions).
+				build();
+		
+		if (connectionSide.isForClient())
+			receivingWhitelist = ListeningWhitelist.newBuilder().
+				priority(listenerPriority).
+				types(packets).
+				gamePhase(gamePhase).
+				options(clientOptions).
+				build();
+		
+		this.plugin = plugin;
+		this.connectionSide = connectionSide;
+	}
+	
+	// Remove a given element from an array
+	private static <T> T[] except(T[] values, T[] buffer, T except) {
+		List<T> result = Lists.newArrayList(values);
+		
+		result.remove(except);
+		return result.toArray(buffer);
+	}
+	
+	@Override
+	public void onPacketReceiving(PacketEvent event) {
+		// Lets prevent some bugs
+		throw new IllegalStateException("Override onPacketReceiving to get notifcations of received packets!");
+	}
+	
+	@Override
+	public void onPacketSending(PacketEvent event) {
+		// Lets prevent some bugs
+		throw new IllegalStateException("Override onPacketSending to get notifcations of sent packets!");
+	}
+	
+	@Override
+	public ListeningWhitelist getReceivingWhitelist() {
+		return receivingWhitelist;
+	}
+	
+	@Override
+	public ListeningWhitelist getSendingWhitelist() {
+		return sendingWhitelist;
+	}
+	
+	@Override
+	public Plugin getPlugin() {
+		return plugin;
+	}
+	
+	/**
+	 * Retrieves the name of the plugin that has been associated with the listener.
+	 * @param listener - the listener.
+	 * @return Name of the associated plugin.
+	 */
+	public static String getPluginName(PacketListener listener) {
+		return getPluginName(listener.getPlugin());
+	}
+	
+	/**
+	 * Retrieves the name of the given plugin.
+	 * @param plugin - the plugin.
+	 * @return Name of the given plugin.
+	 */
+	public static String getPluginName(Plugin plugin) {
+		if (plugin == null)
+			return "UNKNOWN";
+
+		try {
+			return plugin.getName();
+		} catch (NoSuchMethodError e) {
+			return plugin.toString();
+		}
+	}
+	
+	@Override
+	public String toString() {
+		// This is used by the error reporter
+		return String.format("PacketAdapter[plugin=%s, sending=%s, receiving=%s]",
+				getPluginName(this),
+				sendingWhitelist,
+				receivingWhitelist);
+	}
+	
+	/**
+	 * Construct a helper object for passing parameters to the packet adapter.
+	 * <p>
+	 * This is often simpler and better than passing them directly to each constructor.
+	 * @return Helper object.
+	 */
+	public static AdapterParameteters params() {
+		return new AdapterParameteters();
+	}
+	
+	/**
+	 * Construct a helper object for passing parameters to the packet adapter.
+	 * <p>
+	 * This is often simpler and better than passing them directly to each constructor.
+	 * Deprecated: Use {@link #params(Plugin, PacketType...)} instead.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param packets - the packet IDs the listener is looking for.
+	 * @return Helper object.
+	 */
+	@Deprecated
+	public static AdapterParameteters params(Plugin plugin, Integer... packets) {
+		return new AdapterParameteters().plugin(plugin).packets(packets);
+	}
+
+	/**
+	 * Construct a helper object for passing parameters to the packet adapter.
+	 * <p>
+	 * This is often simpler and better than passing them directly to each constructor.
+	 * @param plugin - the plugin that spawned this listener.
+	 * @param packets - the packet types the listener is looking for.
+	 * @return Helper object.
+	 */
+	public static AdapterParameteters params(Plugin plugin, PacketType... packets) {
+		return new AdapterParameteters().plugin(plugin).types(packets);
+	}
+	
+	/**
+	 * Represents a builder for passing parameters to the packet adapter constructor.
+	 * <p>
+	 * Note: Never make spelling mistakes in a public API!
+	 * @author Kristian
+	 */
+	public static class AdapterParameteters {
+		private Plugin plugin;
+		private ConnectionSide connectionSide;
+		private PacketType[] packets;
+	
+		// Parameters with default values
+		private GamePhase gamePhase = GamePhase.PLAYING;
+		private ListenerOptions[] options = new ListenerOptions[0];
+		private ListenerPriority listenerPriority = ListenerPriority.NORMAL;
+		
+		/**
+		 * Set the plugin that spawned this listener. This parameter is required.
+		 * @param plugin - the plugin.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters plugin(@Nonnull Plugin plugin) {
+			this.plugin = Preconditions.checkNotNull(plugin, "plugin cannot be NULL.");
+			return this;
+		}
+		
+		/**
+		 * Set the packet types this listener is looking for. This parameter is required.
+		 * @param connectionSide - the new packet type.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters connectionSide(@Nonnull ConnectionSide connectionSide) {
+			this.connectionSide = Preconditions.checkNotNull(connectionSide, "connectionside cannot be NULL.");
+			return this;
+		}
+		
+		/**
+		 * Set this adapter to also look for client-side packets.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters clientSide() {
+			return connectionSide(ConnectionSide.add(connectionSide, ConnectionSide.CLIENT_SIDE));
+		}
+		
+		/**
+		 * Set this adapter to also look for server-side packets.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters serverSide() {
+			return connectionSide(ConnectionSide.add(connectionSide, ConnectionSide.SERVER_SIDE));
+		}
+		
+		/**
+		 * Set the the event priority, where the execution is in ascending order from lowest to highest.
+		 * <p>
+		 * Default is {@link ListenerPriority#NORMAL}.
+		 * @param listenerPriority - the new event priority.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters listenerPriority(@Nonnull ListenerPriority listenerPriority) {
+			this.listenerPriority = Preconditions.checkNotNull(listenerPriority, "listener priority cannot be NULL.");
+			return this;
+		}
+		
+		/**
+		 * Set which game phase this listener is active under. This is a hint for ProtocolLib to start intercepting login packets.
+		 * <p>
+		 * Default is {@link GamePhase#PLAYING}, which will not intercept login packets.
+		 * @param gamePhase - the new game phase.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters gamePhase(@Nonnull GamePhase gamePhase) {
+			this.gamePhase = Preconditions.checkNotNull(gamePhase, "gamePhase cannot be NULL.");
+			return this;
+		}
+		
+		/**
+		 * Set the game phase to {@link GamePhase#LOGIN}, allowing ProtocolLib to intercept login packets.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters loginPhase() {
+			return gamePhase(GamePhase.LOGIN);
+		}
+		
+		/**
+		 * Set listener options that decide whether or not to intercept the raw packet data as read from the network stream.
+		 * <p>
+		 * The default is to disable this raw packet interception.
+		 * @param options - every option to use.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters options(@Nonnull ListenerOptions... options) {
+			this.options = Preconditions.checkNotNull(options, "options cannot be NULL.");
+			return this;
+		}
+
+		/**
+		 * Set listener options that decide whether or not to intercept the raw packet data as read from the network stream.
+		 * <p>
+		 * The default is to disable this raw packet interception.
+		 * @param options - every option to use.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters options(@Nonnull Set<? extends ListenerOptions> options) {
+			Preconditions.checkNotNull(options, "options cannot be NULL.");
+			this.options = options.toArray(new ListenerOptions[0]);
+			return this;
+		}
+		
+		/**
+		 * Add a given option to the current builder.
+		 * @param option - the option to add.
+		 * @return This builder, for chaining.
+		 */
+		private AdapterParameteters addOption(ListenerOptions option) {
+			if (options == null) {
+				return options(option);
+			} else {
+				Set<ListenerOptions> current = Sets.newHashSet(options);
+				current.add(option);
+				return options(current);
+			}
+		}
+		
+		/**
+		 * Set the listener option to {@link ListenerOptions#INTERCEPT_INPUT_BUFFER}, causing ProtocolLib to read the raw packet data from the network stream.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters optionIntercept() {
+			return addOption(ListenerOptions.INTERCEPT_INPUT_BUFFER);
+		}
+		
+		/**
+		 * Set the listener option to {@link ListenerOptions#DISABLE_GAMEPHASE_DETECTION}, causing ProtocolLib to ignore automatic game phase detection.
+		 * <p>
+		 * This is no longer relevant in 1.7.2.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters optionManualGamePhase() {
+			return addOption(ListenerOptions.DISABLE_GAMEPHASE_DETECTION);
+		}
+		
+		/**
+		 * Set the listener option to {@link ListenerOptions#ASYNC}, indicating that our listener is thread safe.
+		 * <p>
+		 * This allows ProtocolLib to perform certain optimizations.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters optionAsync() {
+			return addOption(ListenerOptions.ASYNC);
+		}
+		
+		/**
+		 * Set the packet IDs of the packets the listener is looking for.
+		 * <p>
+		 * This parameter is required.
+		 * <p>
+		 * Deprecated: Use {@link #types(PacketType...)} instead.
+		 * @param packets - the packet IDs to look for.
+		 * @return This builder, for chaining.
+		 */
+		@Deprecated
+		public AdapterParameteters packets(@Nonnull Integer... packets) {
+			Preconditions.checkNotNull(packets, "packets cannot be NULL");
+			PacketType[] types = new PacketType[packets.length];
+			
+			for (int i = 0; i < types.length; i++) {
+				types[i] = PacketType.findLegacy(packets[i]);
+			}
+			this.packets = types;
+			return this;
+		}
+		
+		/**
+		 * Set the packet IDs of the packets the listener is looking for.
+		 * <p>
+		 * This parameter is required.
+		 * @param packets - a set of the packet IDs to look for.
+		 * @return This builder, for chaining.
+		 */
+		@Deprecated
+		public AdapterParameteters packets(@Nonnull Set<Integer> packets) {
+			return packets(packets.toArray(new Integer[0]));
+		}
+		
+		/**
+		 * Set the packet types the listener is looking for.
+		 * <p>
+		 * This parameter is required.
+		 * @param packets - the packet types to look for.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters types(@Nonnull PacketType... packets) {
+			// Set the connection side as well
+			if (connectionSide == null) {
+				for (PacketType type : packets) {
+					this.connectionSide = ConnectionSide.add(this.connectionSide, type.getSender().toSide());
+				}
+			}
+			this.packets = Preconditions.checkNotNull(packets, "packets cannot be NULL");
+			
+			if (packets.length == 0)
+				throw new IllegalArgumentException("Passed an empty packet type array.");
+			return this;
+		}
+		
+		/**
+		 * Set the packet types the listener is looking for.
+		 * <p>
+		 * This parameter is required.
+		 * @param packets - a set of packet types to look for.
+		 * @return This builder, for chaining.
+		 */
+		public AdapterParameteters types(@Nonnull Set<PacketType> packets) {
+			return types(packets.toArray(new PacketType[0]));
+		}
+	}
+	
+	/**
+	 * Determine if the required parameters are set.
+	 */
+	private static AdapterParameteters checkValidity(AdapterParameteters params) {
+		if (params == null)
+			throw new IllegalArgumentException("params cannot be NULL.");
+		if (params.plugin == null)
+			throw new IllegalStateException("Plugin was never set in the parameters.");
+		if (params.connectionSide == null)
+			throw new IllegalStateException("Connection side was never set in the parameters.");
+		if (params.packets == null)
+			throw new IllegalStateException("Packet IDs was never set in the parameters.");
+		return params;
+	}
+}