Some more backwards incompatible changes (minor though), also a ton of small cleanup.

onPluginEnable(PluginEvent event)   -> onPluginEnable(PluginEnableEvent event)
onPluginDisable(PluginEvent event)  -> onPluginDisable(PluginDisableEvent event)
onVehicleUpdate(VehicleEvent event) -> onVehicleUpdate(VehicleUpdateEvent event)
onWorldSave(WorldEvent event)       -> onWorldSave(WorldSaveEvent event)
onWorldLoad(WorldEvent event)       -> onWorldLoad(WorldLoadEvent event)

src/main/java/org/bukkit/event/block/BlockBreakEvent.java

@@ -3,7 +3,6 @@ package org.bukkit.event.block;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  *
@@ -15,7 +14,7 @@ public class BlockBreakEvent extends BlockEvent implements Cancellable {
     private boolean cancel;
 
     public BlockBreakEvent(final Block theBlock, Player player) {
-        super(Event.Type.BLOCK_BREAK, theBlock);
+        super(Type.BLOCK_BREAK, theBlock);
         this.player = player;
         this.cancel = false;
     }

src/main/java/org/bukkit/event/block/BlockCanBuildEvent.java

@@ -13,8 +13,8 @@ public class BlockCanBuildEvent extends BlockEvent {
     protected boolean buildable;
     protected int material;
 
-    public BlockCanBuildEvent(Type type, Block block, int id, boolean canBuild) {
+    public BlockCanBuildEvent(Block block, int id, boolean canBuild) {
-        super(type, block);
+        super(Type.BLOCK_CANBUILD, block);
         buildable = canBuild;
         material = id;
     }

src/main/java/org/bukkit/event/block/BlockDamageEvent.java

@@ -18,7 +18,7 @@ public class BlockDamageEvent extends BlockEvent implements Cancellable {
         super(Type.BLOCK_DAMAGE, block);
         this.instaBreak = instaBreak;
         this.player = player;
-        this.itemstack = itemstack;
+        this.itemstack = itemInHand;
         this.cancel = false;
     }
 

src/main/java/org/bukkit/event/block/BlockFromToEvent.java

@@ -3,7 +3,6 @@ package org.bukkit.event.block;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Holds information for events with a source block and a destination block
@@ -13,8 +12,8 @@ public class BlockFromToEvent extends BlockEvent implements Cancellable {
     protected BlockFace face;
     protected boolean cancel;
 
-    public BlockFromToEvent(final Event.Type type, final Block block, final BlockFace face) {
+    public BlockFromToEvent(final Block block, final BlockFace face) {
-        super(type, block);
+        super(Type.BLOCK_FROMTO, block);
         this.face = face;
         this.cancel = false;
     }

src/main/java/org/bukkit/event/block/BlockIgniteEvent.java

@@ -11,7 +11,6 @@ import org.bukkit.event.Event;
  * Represents a block ignite event.
  */
 public class BlockIgniteEvent extends BlockEvent implements Cancellable {
-
     private IgniteCause cause;
     private boolean cancel;
     private Player thePlayer;

src/main/java/org/bukkit/event/block/BlockInteractEvent.java

@@ -1,70 +0,0 @@
-package org.bukkit.event.block;
-
-import org.bukkit.block.Block;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-/**
- * This event is triggered whenever an entity interacts with the universe
- * it's always called, on a left click or a right click, or walking on
- * (as in the case of pressure plates). Use cancellable to prevent things
- * from happening (doors opening, buttons, pressure plates being walked
- * on, etc). Note: even though pressure plates work totally differently
- * than the other interact events, it's still thrown in with this event. 
- * 
- * @author durron597
- */
-public class BlockInteractEvent extends BlockEvent implements Cancellable {
-    protected boolean cancel;
-    protected LivingEntity theEntity;
-    
-    /**
-     * @param type The type of this event
-     * @param interactedBlock the block that was interacted with
-     * @param who The entity that interacted with 
-     */
-    public BlockInteractEvent(Type type, Block interactedBlock, LivingEntity who) {
-        super(type, interactedBlock);
-        theEntity = who;
-        cancel = false;
-    }
-
-    /**
-     * Gets the cancellation state of this event. A cancelled event will not
-     * be executed in the server, but will still pass to other plugins
-     *
-     * @return true if this event is cancelled
-     */
-    public boolean isCancelled() {
-        return cancel;
-    }
-
-    /**
-     * Sets the cancellation state of this event. A cancelled event will not
-     * be executed in the server, but will still pass to other plugins
-     *
-     * @param cancel true if you wish to cancel this event
-     */
-    public void setCancelled(boolean cancel) {
-        this.cancel = cancel;
-    }
-    
-    /**
-     * Returns the entity that triggered this event
-     * 
-     * @return Entity the entity that triggered this event
-     */
-    public LivingEntity getEntity() {
-        return theEntity;
-    }
-    
-    /**
-     * Convenience method for seeing if this event was triggered by a player
-     * 
-     * @return boolean whether this event was triggered by a player
-     */
-    public boolean isPlayer() {
-       return theEntity instanceof Player; 
-    }
-}

src/main/java/org/bukkit/event/block/BlockPhysicsEvent.java

@@ -2,7 +2,6 @@ package org.bukkit.event.block;
 
 import org.bukkit.block.Block;
 import org.bukkit.Material;
-import org.bukkit.event.Event;
 
 /**
  * Thrown when a block physics check is called
@@ -13,8 +12,8 @@ public class BlockPhysicsEvent extends BlockEvent {
     private final int changed;
     private boolean cancel = false;
 
-    public BlockPhysicsEvent(final Event.Type type, final Block block, final int changed) {
+    public BlockPhysicsEvent(final Block block, final int changed) {
-        super(type, block);
+        super(Type.BLOCK_PHYSICS, block);
         this.changed = changed;
     }
 

src/main/java/org/bukkit/event/block/BlockPlaceEvent.java

@@ -17,8 +17,8 @@ public class BlockPlaceEvent extends BlockEvent implements Cancellable {
     protected ItemStack itemInHand;
     protected Player player;
 
-    public BlockPlaceEvent(Type type, Block placedBlock, BlockState replacedBlockState, Block placedAgainst, ItemStack itemInHand, Player thePlayer, boolean canBuild) {
+    public BlockPlaceEvent(Block placedBlock, BlockState replacedBlockState, Block placedAgainst, ItemStack itemInHand, Player thePlayer, boolean canBuild) {
-        super(type, placedBlock);
+        super(Type.BLOCK_PLACE, placedBlock);
         this.placedAgainst = placedAgainst;
         this.itemInHand = itemInHand;
         this.player = thePlayer;

src/main/java/org/bukkit/event/block/BlockRightClickEvent.java

@@ -1,49 +0,0 @@
-package org.bukkit.event.block;
-
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.entity.Player;
-
-/**
- * Not implemented yet
- */
-public class BlockRightClickEvent extends BlockEvent  {
-    protected Block clickedBlock;
-    protected BlockFace direction;
-    protected ItemStack itemInHand;
-    protected Player player;
-
-    public BlockRightClickEvent(Type type, Block placedAgainst, BlockFace direction, ItemStack itemInHand, Player thePlayer) {
-        super(type, placedAgainst);
-        this.clickedBlock = placedAgainst;
-        this.direction = direction;
-        this.itemInHand = itemInHand;
-        this.player = thePlayer;
-    }
-
-    /**
-     * Gets the player who placed this block
-     *
-     * @return Player who placed the block
-     */
-    public Player getPlayer() {
-        return player;
-    }
-
-    /**
-     * @return BlockFace the direction this block was clicked
-     */
-    public BlockFace getDirection() {
-        return direction;
-    }
-
-    /**
-     * Returns the item in your hand when you placed the block
-     *
-     * @return ItemStack the item in your hand when placing the block
-     */
-    public ItemStack getItemInHand() {
-        return itemInHand;
-    }
-}

src/main/java/org/bukkit/event/block/LeavesDecayEvent.java

@@ -10,8 +10,8 @@ import org.bukkit.event.Cancellable;
 public class LeavesDecayEvent extends BlockEvent implements Cancellable {
     private boolean cancel = false;
 
-    public LeavesDecayEvent(final Type type, final Block block) {
+    public LeavesDecayEvent(final Block block) {
-        super(type, block);
+        super(Type.LEAVES_DECAY, block);
     }
 
     /**

src/main/java/org/bukkit/event/block/SignChangeEvent.java

@@ -12,8 +12,8 @@ public class SignChangeEvent extends BlockEvent implements Cancellable {
     private Player player;
     private String[] lines;
 
-    public SignChangeEvent(final Type type, final Block theBlock, final Player thePlayer, String[] theLines) {
+    public SignChangeEvent(final Block theBlock, final Player thePlayer, String[] theLines) {
-        super(type, theBlock);
+        super(Type.SIGN_CHANGE, theBlock);
         this.player = thePlayer;
         this.lines = theLines;
     }

src/main/java/org/bukkit/event/entity/CreatureSpawnEvent.java

@@ -4,7 +4,6 @@ import org.bukkit.entity.CreatureType;
 import org.bukkit.entity.Entity;
 import org.bukkit.Location;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Stores data for damage events
@@ -16,13 +15,7 @@ public class CreatureSpawnEvent extends EntityEvent implements Cancellable {
     private CreatureType creatureType;
 
     public CreatureSpawnEvent(Entity spawnee, CreatureType mobtype, Location loc) {
-        super(Event.Type.CREATURE_SPAWN, spawnee);
+        super(Type.CREATURE_SPAWN, spawnee);
-        this.creatureType = mobtype;
-        this.location = loc;
-    }
-
-    protected CreatureSpawnEvent(Event.Type type, Entity spawnee, CreatureType mobtype, Location loc) {
-        super(type, spawnee);
         this.creatureType = mobtype;
         this.location = loc;
     }

src/main/java/org/bukkit/event/entity/EntityCombustEvent.java

@@ -10,8 +10,8 @@ import org.bukkit.event.Cancellable;
 public class EntityCombustEvent extends EntityEvent implements Cancellable {
     private boolean cancel;
 
-    public EntityCombustEvent(Type type, Entity what) {
+    public EntityCombustEvent(Entity what) {
-        super(type, what);
+        super(Type.ENTITY_COMBUST, what);
         this.cancel = false;
     }
 

src/main/java/org/bukkit/event/entity/EntityDamageByBlockEvent.java

@@ -3,7 +3,6 @@ package org.bukkit.event.entity;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Entity;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Stores details for damage events where the damager is a block
@@ -12,9 +11,8 @@ public class EntityDamageByBlockEvent extends EntityDamageEvent implements Cance
 
     private Block damager;
 
-    public EntityDamageByBlockEvent(Block damager, Entity damagee, DamageCause cause, int damage)
+    public EntityDamageByBlockEvent(Block damager, Entity damagee, DamageCause cause, int damage) {
-    {
+        super(Type.ENTITY_DAMAGE, damagee, cause, damage);
-        super(Event.Type.ENTITY_DAMAGE, damagee, cause, damage);
         this.damager = damager;
     }
 

src/main/java/org/bukkit/event/entity/EntityDamageByEntityEvent.java

@@ -2,7 +2,6 @@ package org.bukkit.event.entity;
 
 import org.bukkit.entity.Entity;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Stores details for damage events where the damager is a block
@@ -11,15 +10,8 @@ public class EntityDamageByEntityEvent extends EntityDamageEvent implements Canc
 
     private Entity damager;
 
-    public EntityDamageByEntityEvent(Entity damager, Entity damagee, DamageCause cause, int damage)
+    public EntityDamageByEntityEvent(Entity damager, Entity damagee, DamageCause cause, int damage) {
-    {
+        super(Type.ENTITY_DAMAGE, damagee, cause, damage);
-        super(Event.Type.ENTITY_DAMAGE, damagee, cause, damage);
-        this.damager = damager;
-    }
-
-    protected EntityDamageByEntityEvent(Type damageType, Entity damager, Entity damagee, DamageCause cause, int damage)
-    {
-        super(damageType, damagee, cause, damage);
         this.damager = damager;
     }
 

src/main/java/org/bukkit/event/entity/EntityDamageByProjectileEvent.java

@@ -3,7 +3,6 @@ package org.bukkit.event.entity;
 import java.util.Random;
 
 import org.bukkit.entity.Entity;
-import org.bukkit.event.Event;
 
 public class EntityDamageByProjectileEvent extends EntityDamageByEntityEvent {
 
@@ -11,7 +10,7 @@ public class EntityDamageByProjectileEvent extends EntityDamageByEntityEvent {
     private boolean bounce;
 
     public EntityDamageByProjectileEvent(Entity damager, Entity damagee, Entity projectile, DamageCause cause, int damage) {
-        super(Event.Type.ENTITY_DAMAGE, damager, damagee, cause, damage);
+        super(damager, damagee, cause, damage);
         this.projectile = projectile;
         Random random = new Random();
         this.bounce = random.nextBoolean();

src/main/java/org/bukkit/event/entity/EntityDeathEvent.java

@@ -11,8 +11,8 @@ import org.bukkit.inventory.ItemStack;
 public class EntityDeathEvent extends EntityEvent {
     private List<ItemStack> drops;
 
-    public EntityDeathEvent(final Type type, final Entity what, final List<ItemStack> drops) {
+    public EntityDeathEvent(final Entity what, final List<ItemStack> drops) {
-        super(type, what);
+        super(Type.ENTITY_DEATH, what);
         this.drops = drops;
     }
 

src/main/java/org/bukkit/event/entity/EntityExplodeEvent.java

@@ -14,11 +14,11 @@ import org.bukkit.event.Cancellable;
 public class EntityExplodeEvent extends EntityEvent implements Cancellable {
     private boolean cancel;
     private Location location;
-    private List blocks;
+    private List<Block> blocks;
     private float yield = 0.3F;
 
-    public EntityExplodeEvent (Type type, Entity what, Location location, List<Block> blocks) {
+    public EntityExplodeEvent (Entity what, Location location, List<Block> blocks) {
-        super(type.ENTITY_EXPLODE, what);
+        super(Type.ENTITY_EXPLODE, what);
         this.location = location;
         this.cancel = false;
         this.blocks = blocks;

src/main/java/org/bukkit/event/entity/ExplosionPrimeEvent.java

@@ -8,8 +8,8 @@ public class ExplosionPrimeEvent extends EntityEvent implements Cancellable {
     private float radius;
     private boolean fire;
 
-    public ExplosionPrimeEvent(Type type, Entity what, float radius, boolean fire) {
+    public ExplosionPrimeEvent(Entity what, float radius, boolean fire) {
-        super(type.EXPLOSION_PRIME, what);
+        super(Type.EXPLOSION_PRIME, what);
         this.cancel = false;
         this.radius = radius;
         this.fire = fire;

src/main/java/org/bukkit/event/player/PlayerAnimationEvent.java

@@ -15,8 +15,8 @@ public class PlayerAnimationEvent extends PlayerEvent {
 	 * @param type The event type
 	 * @param player The player instance
 	 */
-	public PlayerAnimationEvent(final Type type, final Player player) {
+	public PlayerAnimationEvent(final Player player) {
-        super(type, player);
+        super(Type.PLAYER_ANIMATION, player);
 
         // Only supported animation type for now:
         animationType = PlayerAnimationType.ARM_SWING;
@@ -27,8 +27,7 @@ public class PlayerAnimationEvent extends PlayerEvent {
      *
      * @returns the animation type
      */
-    public PlayerAnimationType getAnimationType()
+    public PlayerAnimationType getAnimationType() {
-    {
         return animationType;
     }
 

src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java

@@ -5,7 +5,6 @@ import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event.Type;
 import org.bukkit.inventory.ItemStack;
 
 public class PlayerBucketEmptyEvent extends PlayerEvent implements Cancellable {

src/main/java/org/bukkit/event/player/PlayerChatEvent.java

@@ -16,8 +16,8 @@ public class PlayerChatEvent extends PlayerEvent implements Cancellable {
     private String format = "<%1$s> %2$s";
     private final Set<Player> recipients;
 
-    public PlayerChatEvent(final Type type, final Player player, final String message) {
+    public PlayerChatEvent(final Player player, final String message) {
-        super(type, player);
+        super(Type.PLAYER_CHAT, player);
         this.message = message;
 
         recipients = new HashSet<Player>(Arrays.asList(player.getServer().getOnlinePlayers()));

src/main/java/org/bukkit/event/player/PlayerDropItemEvent.java

@@ -3,7 +3,6 @@ package org.bukkit.event.player;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Thrown when a player drops an item from their inventory
@@ -13,7 +12,7 @@ public class PlayerDropItemEvent extends PlayerEvent implements Cancellable {
     private boolean cancel = false;
 
     public PlayerDropItemEvent(final Player player, final Item drop) {
-        super(Event.Type.PLAYER_DROP_ITEM, player);
+        super(Type.PLAYER_DROP_ITEM, player);
         this.drop = drop;
     }
 

src/main/java/org/bukkit/event/player/PlayerEggThrowEvent.java

@@ -4,7 +4,6 @@ import org.bukkit.entity.CreatureType;
 import org.bukkit.entity.Egg;
 import org.bukkit.entity.Player;
 
-
 /**
  *
  * @author tkelly
@@ -16,8 +15,8 @@ public class PlayerEggThrowEvent extends PlayerEvent {
     private CreatureType hatchType;
     private byte numHatches;
 
-    public PlayerEggThrowEvent(Type type, Player player, Egg egg, boolean hatching, byte numHatches, CreatureType hatchType) {
+    public PlayerEggThrowEvent(Player player, Egg egg, boolean hatching, byte numHatches, CreatureType hatchType) {
-        super(type, player);
+        super(Type.PLAYER_EGG_THROW, player);
         this.egg = egg;
         this.hatching = hatching;
         this.numHatches = numHatches;

src/main/java/org/bukkit/event/player/PlayerInteractEvent.java

@@ -6,7 +6,6 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event.Result;
 import org.bukkit.event.block.Action;
 
 /**

src/main/java/org/bukkit/event/player/PlayerInventoryEvent.java

@@ -10,8 +10,8 @@ import org.bukkit.inventory.Inventory;
 public class PlayerInventoryEvent extends PlayerEvent {
     protected Inventory inventory;
 
-    public PlayerInventoryEvent(final Type type, final Player player, final Inventory inventory) {
+    public PlayerInventoryEvent(final Player player, final Inventory inventory) {
-        super(type, player);
+        super(Type.PLAYER_INTERACT, player);
         this.inventory = inventory;
     }
 

src/main/java/org/bukkit/event/player/PlayerItemHeldEvent.java

@@ -10,8 +10,8 @@ public class PlayerItemHeldEvent extends PlayerEvent {
     private int previous;
     private int current;
 
-    public PlayerItemHeldEvent(final Type type, final Player player, final int previous, final int current) {
+    public PlayerItemHeldEvent(final Player player, final int previous, final int current) {
-        super(type, player);
+        super(Type.PLAYER_ITEM_HELD, player);
         this.previous = previous;
         this.current = current;
     }

src/main/java/org/bukkit/event/player/PlayerJoinEvent.java

@@ -5,8 +5,8 @@ import org.bukkit.entity.Player;
 public class PlayerJoinEvent extends PlayerEvent {
     private String joinMessage;
 
-    public PlayerJoinEvent(Type eventType, Player playerJoined, String joinMessage) {
+    public PlayerJoinEvent(Player playerJoined, String joinMessage) {
-        super(eventType, playerJoined);
+        super(Type.PLAYER_JOIN, playerJoined);
         this.joinMessage = joinMessage;
     }
 

src/main/java/org/bukkit/event/player/PlayerKickEvent.java

@@ -8,8 +8,8 @@ public class PlayerKickEvent extends PlayerEvent implements Cancellable {
     private String kickReason;
     private Boolean cancel;
 
-    public PlayerKickEvent(Type eventType, Player playerKicked, String kickReason, String leaveMessage) {
+    public PlayerKickEvent(Player playerKicked, String kickReason, String leaveMessage) {
-        super(eventType, playerKicked);
+        super(Type.PLAYER_KICK, playerKicked);
         this.kickReason = kickReason;
         this.leaveMessage = leaveMessage;
         this.cancel = false;

src/main/java/org/bukkit/event/player/PlayerLoginEvent.java

@@ -10,8 +10,8 @@ public class PlayerLoginEvent extends PlayerEvent {
     private Result result;
     private String message;
 
-    public PlayerLoginEvent(final Type type, final Player player) {
+    public PlayerLoginEvent(final Player player) {
-        super(type, player);
+        super(Type.PLAYER_LOGIN, player);
         this.result = Result.ALLOWED;
         this.message = "";
     }

src/main/java/org/bukkit/event/player/PlayerMoveEvent.java

@@ -4,7 +4,6 @@ package org.bukkit.event.player;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Holds information for player movement and teleportation events
@@ -14,8 +13,8 @@ public class PlayerMoveEvent extends PlayerEvent implements Cancellable {
     private Location from;
     private Location to;
 
-    public PlayerMoveEvent(final Event.Type type, final Player player, final Location from, final Location to) {
+    public PlayerMoveEvent(final Player player, final Location from, final Location to) {
-        super(type, player);
+        super(Type.PLAYER_MOVE, player);
         this.from = from;
         this.to = to;
     }

src/main/java/org/bukkit/event/player/PlayerPickupItemEvent.java

@@ -4,7 +4,6 @@ package org.bukkit.event.player;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
 
 /**
  * Thrown when a player picks an item up from the ground
@@ -14,7 +13,7 @@ public class PlayerPickupItemEvent extends PlayerEvent implements Cancellable {
     private boolean cancel = false;
 
     public PlayerPickupItemEvent(final Player player, final Item item) {
-        super(Event.Type.PLAYER_PICKUP_ITEM, player);
+        super(Type.PLAYER_PICKUP_ITEM, player);
         this.item = item;
     }
 

src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java

@@ -6,8 +6,8 @@ import org.bukkit.entity.Player;
 public class PlayerRespawnEvent extends PlayerEvent {
     private Location respawnLocation;
 
-    public PlayerRespawnEvent(Type type, Player respawnPlayer, Location respawnLocation) {
+    public PlayerRespawnEvent(Player respawnPlayer, Location respawnLocation) {
-        super(type, respawnPlayer);
+        super(Type.PLAYER_RESPAWN, respawnPlayer);
         this.respawnLocation = respawnLocation;
     }
 

src/main/java/org/bukkit/event/player/PlayerToggleSneakEvent.java

@@ -1,6 +1,5 @@
 package org.bukkit.event.player;
 
-
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
 
@@ -11,11 +10,10 @@ import org.bukkit.event.Cancellable;
 public class PlayerToggleSneakEvent extends PlayerEvent implements Cancellable{
     private boolean cancel = false;
 
-    public PlayerToggleSneakEvent(final Type type, final Player player) {
+    public PlayerToggleSneakEvent(final Player player) {
-        super(type, player);
+        super(Type.PLAYER_TOGGLE_SNEAK, player);
     }
 
-
     /**
      * Gets the cancellation state of this event. A cancelled event will not
      * be executed in the server, but will still pass to other plugins

src/main/java/org/bukkit/event/server/PluginDisableEvent.java

@@ -0,0 +1,9 @@
+package org.bukkit.event.server;
+
+import org.bukkit.plugin.Plugin;
+
+public class PluginDisableEvent extends PluginEvent {
+    public PluginDisableEvent(Plugin plugin) {
+        super(Type.PLUGIN_DISABLE, plugin);
+    }
+}

src/main/java/org/bukkit/event/server/PluginEnableEvent.java

@@ -0,0 +1,9 @@
+package org.bukkit.event.server;
+
+import org.bukkit.plugin.Plugin;
+
+public class PluginEnableEvent extends PluginEvent {
+    public PluginEnableEvent(Plugin plugin) {
+        super(Type.PLUGIN_ENABLE, plugin);
+    }
+}

src/main/java/org/bukkit/event/server/ServerCommandEvent.java

@@ -7,7 +7,7 @@ import org.bukkit.event.Event;
  * Server Command events
  */
 public class ServerCommandEvent extends Event {
-    public ServerCommandEvent(final Type type) {
+    public ServerCommandEvent() {
-        super(type);
+        super(Type.SERVER_COMMAND);
     }
 }

src/main/java/org/bukkit/event/server/ServerListener.java

@@ -12,7 +12,7 @@ public class ServerListener implements Listener {
      *
      * @param event Relevant event details
      */
-    public void onPluginEnable(PluginEvent event) {
+    public void onPluginEnable(PluginEnableEvent event) {
     }
 
     /**
@@ -20,7 +20,7 @@ public class ServerListener implements Listener {
      *
      * @param event Relevant event details
      */
-    public void onPluginDisable(PluginEvent event) {
+    public void onPluginDisable(PluginDisableEvent event) {
     }
 
     /**

src/main/java/org/bukkit/event/vehicle/VehicleBlockCollisionEvent.java

@@ -11,8 +11,8 @@ import org.bukkit.entity.Vehicle;
 public class VehicleBlockCollisionEvent extends VehicleCollisionEvent {
     private Block block;
     
-    public VehicleBlockCollisionEvent(Type type, Vehicle vehicle, Block block) {
+    public VehicleBlockCollisionEvent(Vehicle vehicle, Block block) {
-        super(type, vehicle);
+        super(Type.VEHICLE_COLLISION_BLOCK, vehicle);
         this.block = block;
     }
     

src/main/java/org/bukkit/event/vehicle/VehicleCreateEvent.java

@@ -8,8 +8,7 @@ import org.bukkit.entity.Vehicle;
  * @author sk89q
  */
 public class VehicleCreateEvent extends VehicleEvent {
-    public VehicleCreateEvent(Type type, Vehicle vehicle) {
+    public VehicleCreateEvent(Vehicle vehicle) {
-        
+        super(Type.VEHICLE_CREATE, vehicle);
-        super(type, vehicle);
     }
 }

src/main/java/org/bukkit/event/vehicle/VehicleDamageEvent.java

@@ -14,8 +14,8 @@ public class VehicleDamageEvent extends VehicleEvent implements Cancellable {
     private int damage;
     private boolean cancelled;
     
-    public VehicleDamageEvent(Type type, Vehicle vehicle, Entity attacker, int damage) {
+    public VehicleDamageEvent(Vehicle vehicle, Entity attacker, int damage) {
-        super(type, vehicle);
+        super(Type.ENTITY_DAMAGE, vehicle);
         this.attacker = attacker;
         this.damage = damage;
     }

src/main/java/org/bukkit/event/vehicle/VehicleEnterEvent.java

@@ -13,9 +13,8 @@ public class VehicleEnterEvent extends VehicleEvent implements Cancellable {
     private boolean cancelled;
     private Entity entered;
 
-    public VehicleEnterEvent(Type type, Vehicle vehicle, Entity entered) {
+    public VehicleEnterEvent(Vehicle vehicle, Entity entered) {
-        super(type, vehicle);
+        super(Type.VEHICLE_ENTER, vehicle);
-        
         this.entered = entered;
     }
 

src/main/java/org/bukkit/event/vehicle/VehicleEntityCollisionEvent.java

@@ -15,8 +15,8 @@ public class VehicleEntityCollisionEvent extends VehicleCollisionEvent implement
     private boolean cancelledPickup = false;
     private boolean cancelledCollision = false;
     
-    public VehicleEntityCollisionEvent(Type type, Vehicle vehicle, Entity entity) {
+    public VehicleEntityCollisionEvent(Vehicle vehicle, Entity entity) {
-        super(type, vehicle);
+        super(Type.VEHICLE_COLLISION_ENTITY, vehicle);
         this.entity = entity;
     }
     

src/main/java/org/bukkit/event/vehicle/VehicleExitEvent.java

@@ -13,9 +13,8 @@ public class VehicleExitEvent extends VehicleEvent implements Cancellable {
     private boolean cancelled;
     private LivingEntity exited;
 
-    public VehicleExitEvent(Type type, Vehicle vehicle, LivingEntity exited) {
+    public VehicleExitEvent(Vehicle vehicle, LivingEntity exited) {
-        super(type, vehicle);
+        super(Type.VEHICLE_EXIT, vehicle);
-        
         this.exited = exited;
     }
     

src/main/java/org/bukkit/event/vehicle/VehicleListener.java

@@ -73,6 +73,6 @@ public class VehicleListener implements Listener {
      *
      * @param event
      */
-    public void onVehicleUpdate(VehicleEvent event) {
+    public void onVehicleUpdate(VehicleUpdateEvent event) {
     }
 }

src/main/java/org/bukkit/event/vehicle/VehicleMoveEvent.java

@@ -12,9 +12,8 @@ public class VehicleMoveEvent extends VehicleEvent {
     private Location from;
     private Location to;
 
-    public VehicleMoveEvent(Type type, Vehicle vehicle,
+    public VehicleMoveEvent(Vehicle vehicle, Location from, Location to) {
-            Location from, Location to) {
+        super(Type.VEHICLE_MOVE, vehicle);
-        super(type, vehicle);
 
         this.from = from;
         this.to = to;

src/main/java/org/bukkit/event/vehicle/VehicleUpdateEvent.java

@@ -0,0 +1,9 @@
+package org.bukkit.event.vehicle;
+
+import org.bukkit.entity.Vehicle;
+
+public class VehicleUpdateEvent extends VehicleEvent {
+    public VehicleUpdateEvent(Vehicle vehicle) {
+        super(Type.VEHICLE_UPDATE, vehicle);
+    }
+}

src/main/java/org/bukkit/event/world/ChunkEvent.java

@@ -0,0 +1,21 @@
+package org.bukkit.event.world;
+
+import org.bukkit.Chunk;
+
+public class ChunkEvent extends WorldEvent {
+    protected Chunk chunk;
+
+    protected ChunkEvent(Type type, Chunk chunk) {
+        super(type, chunk.getWorld());
+        this.chunk = chunk;
+    }
+
+    /**
+     * Gets the chunk being loaded/unloaded
+     *
+     * @return Chunk that triggered this event
+     */
+    public Chunk getChunk() {
+        return chunk;
+    }
+}

src/main/java/org/bukkit/event/world/ChunkLoadEvent.java

@@ -6,21 +6,8 @@ import org.bukkit.Chunk;
 /**
  * Called when a chunk is loaded
  */
-public class ChunkLoadEvent extends WorldEvent {
+public class ChunkLoadEvent extends ChunkEvent {
-    private final Chunk chunk;
+    public ChunkLoadEvent(final Chunk chunk) {
-
+        super(Type.CHUNK_LOAD, chunk);
-    public ChunkLoadEvent(final Type type, final Chunk chunk) {
-        super(type, chunk.getWorld());
-
-        this.chunk = chunk;
-    }
-
-    /**
-     * Gets the chunk being loaded/unloaded
-     *
-     * @return Chunk that triggered this event
-     */
-    public Chunk getChunk() {
-        return chunk;
     }
 }

src/main/java/org/bukkit/event/world/ChunkUnloadEvent.java

@@ -7,11 +7,11 @@ import org.bukkit.event.Cancellable;
 /**
  * Called when a chunk is unloaded
  */
-public class ChunkUnloadEvent extends ChunkLoadEvent implements Cancellable {
+public class ChunkUnloadEvent extends ChunkEvent implements Cancellable {
     private boolean cancel = false;
 
-    public ChunkUnloadEvent(final Type type, final Chunk chunk) {
+    public ChunkUnloadEvent(final Chunk chunk) {
-        super(type, chunk);
+        super(Type.CHUNK_UNLOAD, chunk);
     }
 
     /**

src/main/java/org/bukkit/event/world/WorldListener.java

@@ -26,9 +26,9 @@ public class WorldListener implements Listener {
     /**
     * Called when a world is saved
     *
-    * param event Relevant event details
+    * @param event Relevant event details
     */
-    public void onWorldSave(WorldEvent event) {
+    public void onWorldSave(WorldSaveEvent event) {
     }
 
     /**
@@ -36,6 +36,6 @@ public class WorldListener implements Listener {
      *
      * @param event Relevant event details
      */
-    public void onWorldLoad(WorldEvent event) {
+    public void onWorldLoad(WorldLoadEvent event) {
     }
 }

src/main/java/org/bukkit/event/world/WorldLoadEvent.java

@@ -0,0 +1,9 @@
+package org.bukkit.event.world;
+
+import org.bukkit.World;
+
+public class WorldLoadEvent extends WorldEvent {
+    public WorldLoadEvent(World world) {
+        super(Type.WORLD_LOAD, world);
+    }
+}

src/main/java/org/bukkit/event/world/WorldSaveEvent.java

@@ -0,0 +1,9 @@
+package org.bukkit.event.world;
+
+import org.bukkit.World;
+
+public class WorldSaveEvent extends WorldEvent {
+    public WorldSaveEvent(World world) {
+        super(Type.WORLD_SAVE, world);
+    }
+}

src/main/java/org/bukkit/fillr/Checker.java

@@ -1,6 +1,5 @@
 package org.bukkit.fillr;
 
-import org.bukkit.entity.Player;
 import java.io.*;
 import java.util.jar.*;
 import org.bukkit.*;

src/main/java/org/bukkit/fillr/Getter.java

@@ -1,6 +1,5 @@
 package org.bukkit.fillr;
 
-import org.bukkit.entity.Player;
 import java.io.File;
 import java.util.logging.Level;
 

src/main/java/org/bukkit/fillr/Updater.java

@@ -1,6 +1,5 @@
 package org.bukkit.fillr;
 
-import org.bukkit.entity.Player;
 import org.bukkit.*;
 import org.bukkit.plugin.*;
 

src/main/java/org/bukkit/plugin/PluginDescriptionFile.java

@@ -5,9 +5,7 @@ import java.io.InputStream;
 import java.io.Reader;
 import java.io.Writer;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.constructor.SafeConstructor;

src/main/java/org/bukkit/plugin/SimplePluginManager.java

@@ -16,7 +16,6 @@ import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.Iterator;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import org.bukkit.Server;
 import java.util.regex.Pattern;

src/main/java/org/bukkit/plugin/java/JavaPlugin.java

@@ -4,7 +4,6 @@ package org.bukkit.plugin.java;
 import java.io.File;
 import org.bukkit.Server;
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.plugin.Plugin;

src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java

@@ -9,8 +9,6 @@ import java.net.URL;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
-import java.util.Arrays;
-import java.util.Map;
 import java.util.ArrayList;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
@@ -24,10 +22,7 @@ import org.bukkit.event.entity.*;
 import org.bukkit.event.player.*;
 import org.bukkit.event.server.*;
 import org.bukkit.event.vehicle.*;
-import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.event.world.*;
-import org.bukkit.event.world.ChunkUnloadEvent;
-import org.bukkit.event.world.WorldEvent;
-import org.bukkit.event.world.WorldListener;
 import org.bukkit.plugin.*;
 
 /**
@@ -161,289 +156,338 @@ public final class JavaPluginLoader implements PluginLoader {
         }
     }
 
-    public EventExecutor createExecutor( Event.Type type, Listener listener ) {
+    public EventExecutor createExecutor(Event.Type type, Listener listener ) {
         // TODO: remove multiple Listener type and hence casts
         switch (type) {
         // Player Events
         case PLAYER_JOIN:
             return new EventExecutor() {
-                public void execute( Listener listener, Event event ) {
+                public void execute(Listener listener, Event event) {
-                    ((PlayerListener)listener).onPlayerJoin( (PlayerJoinEvent)event );
+                    ((PlayerListener) listener).onPlayerJoin((PlayerJoinEvent) event);
                 }
             };
         case PLAYER_QUIT:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerQuit( (PlayerEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerQuit((PlayerEvent) event);
                 }
             };
         case PLAYER_RESPAWN:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerRespawn( (PlayerRespawnEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerRespawn((PlayerRespawnEvent) event);
                 }
             };
         case PLAYER_KICK:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerKick( (PlayerKickEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerKick((PlayerKickEvent) event);
                 }
             };
         case PLAYER_COMMAND_PREPROCESS:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerCommandPreprocess( (PlayerChatEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerCommandPreprocess((PlayerChatEvent) event);
                 }
             };
         case PLAYER_CHAT:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerChat( (PlayerChatEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerChat((PlayerChatEvent) event);
                 }
             };
         case PLAYER_MOVE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerMove( (PlayerMoveEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerMove((PlayerMoveEvent) event);
                 }
             };
         case PLAYER_TELEPORT:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerTeleport( (PlayerMoveEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerTeleport((PlayerMoveEvent) event);
                 }
             };
         case PLAYER_INTERACT:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerInteract( (PlayerInteractEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerInteract((PlayerInteractEvent) event);
                 }
             };
         case PLAYER_LOGIN:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerLogin( (PlayerLoginEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerLogin((PlayerLoginEvent) event);
                 }
             };
         case PLAYER_EGG_THROW:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerEggThrow( (PlayerEggThrowEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerEggThrow((PlayerEggThrowEvent) event);
                 }
             };
         case PLAYER_ANIMATION:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerAnimation( (PlayerAnimationEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerAnimation((PlayerAnimationEvent) event);
                 }
             };
         case INVENTORY_OPEN:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onInventoryOpen( (PlayerInventoryEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onInventoryOpen((PlayerInventoryEvent) event);
                 }
             };
         case PLAYER_ITEM_HELD:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onItemHeldChange( (PlayerItemHeldEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onItemHeldChange((PlayerItemHeldEvent) event);
                 }
             };
         case PLAYER_DROP_ITEM:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerDropItem( (PlayerDropItemEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerDropItem((PlayerDropItemEvent) event);
                 }
             };
         case PLAYER_PICKUP_ITEM:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerPickupItem( (PlayerPickupItemEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerPickupItem((PlayerPickupItemEvent) event);
                 }
             };
         case PLAYER_TOGGLE_SNEAK:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((PlayerListener)listener).onPlayerToggleSneak( (PlayerToggleSneakEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((PlayerListener) listener).onPlayerToggleSneak((PlayerToggleSneakEvent) event);
                 }
             };
-
         case PLAYER_BUCKET_EMPTY:
-            return new EventExecutor() { public void execute( Listener listener, Event event) {
+            return new EventExecutor() {
+                public void execute(Listener listener, Event event) {
                     ((PlayerListener) listener).onPlayerBucketEmpty((PlayerBucketEmptyEvent) event);
                 }
             };
-
         case PLAYER_BUCKET_FILL:
-            return new EventExecutor() { public void execute( Listener listener, Event event) {
+            return new EventExecutor() {
+                public void execute(Listener listener, Event event) {
                     ((PlayerListener) listener).onPlayerBucketFill((PlayerBucketFillEvent) event);
                 }
             };
 
         // Block Events
         case BLOCK_PHYSICS:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockPhysics( (BlockPhysicsEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockPhysics((BlockPhysicsEvent) event);
                 }
             };
         case BLOCK_CANBUILD:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockCanBuild( (BlockCanBuildEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockCanBuild((BlockCanBuildEvent) event);
                 }
             };
         case BLOCK_PLACE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockPlace( (BlockPlaceEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockPlace((BlockPlaceEvent) event);
                 }
             };
         case BLOCK_DAMAGE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockDamage( (BlockDamageEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockDamage((BlockDamageEvent) event);
                 }
             };
         case BLOCK_FROMTO:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockFlow( (BlockFromToEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockFlow((BlockFromToEvent) event);
                 }
             };
         case LEAVES_DECAY:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onLeavesDecay( (LeavesDecayEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onLeavesDecay((LeavesDecayEvent) event);
                 }
             };
         case SIGN_CHANGE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onSignChange( (SignChangeEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onSignChange((SignChangeEvent) event);
                 }
             };
         case BLOCK_IGNITE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockIgnite( (BlockIgniteEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockIgnite((BlockIgniteEvent) event);
                 }
             };
         case REDSTONE_CHANGE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockRedstoneChange( (BlockRedstoneEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockRedstoneChange((BlockRedstoneEvent) event);
                 }
             };
         case BLOCK_BURN:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockBurn( (BlockBurnEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockBurn((BlockBurnEvent) event);
                 }
             };
         case BLOCK_BREAK:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((BlockListener)listener).onBlockBreak( (BlockBreakEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((BlockListener) listener).onBlockBreak((BlockBreakEvent) event);
                 }
             };
 
         // Server Events
         case PLUGIN_ENABLE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((ServerListener)listener).onPluginEnable( (PluginEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((ServerListener) listener).onPluginEnable((PluginEnableEvent) event);
                 }
             };
         case PLUGIN_DISABLE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((ServerListener)listener).onPluginDisable( (PluginEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((ServerListener) listener).onPluginDisable((PluginDisableEvent) event);
                 }
             };
-
         case SERVER_COMMAND:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((ServerListener)listener).onServerCommand( (ServerCommandEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((ServerListener) listener).onServerCommand((ServerCommandEvent) event);
                 }
             };
 
         // World Events
         case CHUNK_LOAD:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((WorldListener)listener).onChunkLoad( (ChunkLoadEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((WorldListener) listener).onChunkLoad((ChunkLoadEvent) event);
                 }
             };
         case CHUNK_UNLOAD:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((WorldListener)listener).onChunkUnload( (ChunkUnloadEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((WorldListener) listener).onChunkUnload((ChunkUnloadEvent) event);
                 }
             };
         case WORLD_SAVE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((WorldListener)listener).onWorldSave( (WorldEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((WorldListener) listener).onWorldSave((WorldSaveEvent) event);
                 }
             };
         case WORLD_LOAD:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((WorldListener)listener).onWorldLoad( (WorldEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((WorldListener) listener).onWorldLoad((WorldLoadEvent) event);
                 }
             };
 
         // Entity Events
         case ENTITY_DAMAGE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onEntityDamage( (EntityDamageEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onEntityDamage((EntityDamageEvent) event);
                 }
             };
         case ENTITY_DEATH:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onEntityDeath( (EntityDeathEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onEntityDeath((EntityDeathEvent) event);
                 }
             };
         case ENTITY_COMBUST:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onEntityCombust( (EntityCombustEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onEntityCombust((EntityCombustEvent) event);
                 }
             };
         case ENTITY_EXPLODE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onEntityExplode( (EntityExplodeEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onEntityExplode((EntityExplodeEvent) event);
                 }
             };
         case EXPLOSION_PRIME:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onExplosionPrime( (ExplosionPrimeEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onExplosionPrime((ExplosionPrimeEvent) event);
                 }
             };
         case ENTITY_TARGET:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onEntityTarget( (EntityTargetEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onEntityTarget((EntityTargetEvent) event);
                 }
             };
         case CREATURE_SPAWN:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((EntityListener)listener).onCreatureSpawn( (CreatureSpawnEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((EntityListener) listener).onCreatureSpawn((CreatureSpawnEvent) event);
                 }
             };
 
         // Vehicle Events
         case VEHICLE_CREATE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleCreate( (VehicleCreateEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleCreate((VehicleCreateEvent) event);
                 }
             };
         case VEHICLE_DAMAGE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleDamage( (VehicleDamageEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleDamage((VehicleDamageEvent) event);
                 }
             };
         case VEHICLE_COLLISION_BLOCK:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleBlockCollision( (VehicleBlockCollisionEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleBlockCollision((VehicleBlockCollisionEvent) event);
                 }
             };
         case VEHICLE_COLLISION_ENTITY:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleEntityCollision( (VehicleEntityCollisionEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleEntityCollision((VehicleEntityCollisionEvent) event);
                 }
             };
         case VEHICLE_ENTER:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleEnter( (VehicleEnterEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleEnter((VehicleEnterEvent) event);
                 }
             };
         case VEHICLE_EXIT:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleExit( (VehicleExitEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleExit((VehicleExitEvent) event);
                 }
             };
         case VEHICLE_MOVE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleMove( (VehicleMoveEvent)event );
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleMove((VehicleMoveEvent) event);
                 }
             };
         case VEHICLE_UPDATE:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((VehicleListener)listener).onVehicleUpdate((VehicleEvent)event);
+                public void execute(Listener listener, Event event) {
+                    ((VehicleListener) listener).onVehicleUpdate((VehicleUpdateEvent) event);
                 }
             };
 
         // Custom Events
         case CUSTOM_EVENT:
-            return new EventExecutor() { public void execute( Listener listener, Event event ) {
+            return new EventExecutor() {
-                    ((CustomEventListener)listener).onCustomEvent( event );
+                public void execute(Listener listener, Event event) {
+                    ((CustomEventListener) listener).onCustomEvent(event);
                 }
             };
         }