Azimkin/Bukkit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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)
This commit is contained in:
Erik Broes 2011-03-26 22:21:20 +01:00
parent 3be580aa61
commit 94894216e8
60 changed files with 312 additions and 376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/org/bukkit/event/block/BlockBreakEvent.java
View File

@ -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;
}

4
src/main/java/org/bukkit/event/block/BlockCanBuildEvent.java
View File

@ -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) {
super(type, block);
public BlockCanBuildEvent(Block block, int id, boolean canBuild) {
super(Type.BLOCK_CANBUILD, block);
buildable = canBuild;
material = id;
}

2
src/main/java/org/bukkit/event/block/BlockDamageEvent.java
View File

@ -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;
}

5
src/main/java/org/bukkit/event/block/BlockFromToEvent.java
View File

@ -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) {
super(type, block);
public BlockFromToEvent(final Block block, final BlockFace face) {
super(Type.BLOCK_FROMTO, block);
this.face = face;
this.cancel = false;
}

1
src/main/java/org/bukkit/event/block/BlockIgniteEvent.java
View File

@ -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;

70
src/main/java/org/bukkit/event/block/BlockInteractEvent.java
View File

@ -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;
}
}

5
src/main/java/org/bukkit/event/block/BlockPhysicsEvent.java
View File

@ -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) {
super(type, block);
public BlockPhysicsEvent(final Block block, final int changed) {
super(Type.BLOCK_PHYSICS, block);
this.changed = changed;
}

4
src/main/java/org/bukkit/event/block/BlockPlaceEvent.java
View File

@ -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) {
super(type, placedBlock);
public BlockPlaceEvent(Block placedBlock, BlockState replacedBlockState, Block placedAgainst, ItemStack itemInHand, Player thePlayer, boolean canBuild) {
super(Type.BLOCK_PLACE, placedBlock);
this.placedAgainst = placedAgainst;
this.itemInHand = itemInHand;
this.player = thePlayer;

49
src/main/java/org/bukkit/event/block/BlockRightClickEvent.java
View File

@ -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;
}
}

4
src/main/java/org/bukkit/event/block/LeavesDecayEvent.java
View File

@ -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) {
super(type, block);
public LeavesDecayEvent(final Block block) {
super(Type.LEAVES_DECAY, block);
}
/**

4
src/main/java/org/bukkit/event/block/SignChangeEvent.java
View File

@ -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) {
super(type, theBlock);
public SignChangeEvent(final Block theBlock, final Player thePlayer, String[] theLines) {
super(Type.SIGN_CHANGE, theBlock);
this.player = thePlayer;
this.lines = theLines;
}

9
src/main/java/org/bukkit/event/entity/CreatureSpawnEvent.java
View File

@ -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);
this.creatureType = mobtype;
this.location = loc;
}
protected CreatureSpawnEvent(Event.Type type, Entity spawnee, CreatureType mobtype, Location loc) {
super(type, spawnee);
super(Type.CREATURE_SPAWN, spawnee);
this.creatureType = mobtype;
this.location = loc;
}

4
src/main/java/org/bukkit/event/entity/EntityCombustEvent.java
View File

@ -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) {
super(type, what);
public EntityCombustEvent(Entity what) {
super(Type.ENTITY_COMBUST, what);
this.cancel = false;
}

6
src/main/java/org/bukkit/event/entity/EntityDamageByBlockEvent.java
View File

@ -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)
{
super(Event.Type.ENTITY_DAMAGE, damagee, cause, damage);
public EntityDamageByBlockEvent(Block damager, Entity damagee, DamageCause cause, int damage) {
super(Type.ENTITY_DAMAGE, damagee, cause, damage);
this.damager = damager;
}

12
src/main/java/org/bukkit/event/entity/EntityDamageByEntityEvent.java
View File

@ -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)
{
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);
public EntityDamageByEntityEvent(Entity damager, Entity damagee, DamageCause cause, int damage) {
super(Type.ENTITY_DAMAGE, damagee, cause, damage);
this.damager = damager;
}

3
src/main/java/org/bukkit/event/entity/EntityDamageByProjectileEvent.java
View File

@ -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();

4
src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
View File

@ -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) {
super(type, what);
public EntityDeathEvent(final Entity what, final List<ItemStack> drops) {
super(Type.ENTITY_DEATH, what);
this.drops = drops;
}

6
src/main/java/org/bukkit/event/entity/EntityExplodeEvent.java
View File

@ -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) {
super(type.ENTITY_EXPLODE, what);
public EntityExplodeEvent (Entity what, Location location, List<Block> blocks) {
super(Type.ENTITY_EXPLODE, what);
this.location = location;
this.cancel = false;
this.blocks = blocks;

4
src/main/java/org/bukkit/event/entity/ExplosionPrimeEvent.java
View File

@ -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) {
super(type.EXPLOSION_PRIME, what);
public ExplosionPrimeEvent(Entity what, float radius, boolean fire) {
super(Type.EXPLOSION_PRIME, what);
this.cancel = false;
this.radius = radius;
this.fire = fire;

9
src/main/java/org/bukkit/event/player/PlayerAnimationEvent.java
View File

@ -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) {
super(type, player);
public PlayerAnimationEvent(final Player player) {
super(Type.PLAYER_ANIMATION, player);
// Only supported animation type for now:
animationType = PlayerAnimationType.ARM_SWING;
@ -27,9 +27,8 @@ public class PlayerAnimationEvent extends PlayerEvent {
*
* @returns the animation type
*/
public PlayerAnimationType getAnimationType()
{
return animationType;
public PlayerAnimationType getAnimationType() {
return animationType;
}
}

1
src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
View File

@ -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 {

4
src/main/java/org/bukkit/event/player/PlayerChatEvent.java
View File

@ -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) {
super(type, player);
public PlayerChatEvent(final Player player, final String message) {
super(Type.PLAYER_CHAT, player);
this.message = message;
recipients = new HashSet<Player>(Arrays.asList(player.getServer().getOnlinePlayers()));

3
src/main/java/org/bukkit/event/player/PlayerDropItemEvent.java
View File

@ -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;
}

5
src/main/java/org/bukkit/event/player/PlayerEggThrowEvent.java
View File

@ -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) {
super(type, player);
public PlayerEggThrowEvent(Player player, Egg egg, boolean hatching, byte numHatches, CreatureType hatchType) {
super(Type.PLAYER_EGG_THROW, player);
this.egg = egg;
this.hatching = hatching;
this.numHatches = numHatches;

1
src/main/java/org/bukkit/event/player/PlayerInteractEvent.java
View File

@ -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;
/**

4
src/main/java/org/bukkit/event/player/PlayerInventoryEvent.java
View File

@ -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) {
super(type, player);
public PlayerInventoryEvent(final Player player, final Inventory inventory) {
super(Type.PLAYER_INTERACT, player);
this.inventory = inventory;
}

4
src/main/java/org/bukkit/event/player/PlayerItemHeldEvent.java
View File

@ -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) {
super(type, player);
public PlayerItemHeldEvent(final Player player, final int previous, final int current) {
super(Type.PLAYER_ITEM_HELD, player);
this.previous = previous;
this.current = current;
}

4
src/main/java/org/bukkit/event/player/PlayerJoinEvent.java
View File

@ -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) {
super(eventType, playerJoined);
public PlayerJoinEvent(Player playerJoined, String joinMessage) {
super(Type.PLAYER_JOIN, playerJoined);
this.joinMessage = joinMessage;
}

4
src/main/java/org/bukkit/event/player/PlayerKickEvent.java
View File

@ -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) {
super(eventType, playerKicked);
public PlayerKickEvent(Player playerKicked, String kickReason, String leaveMessage) {
super(Type.PLAYER_KICK, playerKicked);
this.kickReason = kickReason;
this.leaveMessage = leaveMessage;
this.cancel = false;

4
src/main/java/org/bukkit/event/player/PlayerLoginEvent.java
View File

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

5
src/main/java/org/bukkit/event/player/PlayerMoveEvent.java
View File

@ -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) {
super(type, player);
public PlayerMoveEvent(final Player player, final Location from, final Location to) {
super(Type.PLAYER_MOVE, player);
this.from = from;
this.to = to;
}

3
src/main/java/org/bukkit/event/player/PlayerPickupItemEvent.java
View File

@ -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;
}

4
src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java
View File

@ -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) {
super(type, respawnPlayer);
public PlayerRespawnEvent(Player respawnPlayer, Location respawnLocation) {
super(Type.PLAYER_RESPAWN, respawnPlayer);
this.respawnLocation = respawnLocation;
}

6
src/main/java/org/bukkit/event/player/PlayerToggleSneakEvent.java
View File

@ -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) {
super(type, player);
public PlayerToggleSneakEvent(final Player 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

9
src/main/java/org/bukkit/event/server/PluginDisableEvent.java Normal file
View File

@ -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);
}
}

9
src/main/java/org/bukkit/event/server/PluginEnableEvent.java Normal file
View File

@ -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);
}
}

4
src/main/java/org/bukkit/event/server/ServerCommandEvent.java
View File

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

4
src/main/java/org/bukkit/event/server/ServerListener.java
View File

@ -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) {
}
/**

4
src/main/java/org/bukkit/event/vehicle/VehicleBlockCollisionEvent.java
View File

@ -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) {
super(type, vehicle);
public VehicleBlockCollisionEvent(Vehicle vehicle, Block block) {
super(Type.VEHICLE_COLLISION_BLOCK, vehicle);
this.block = block;
}

5
src/main/java/org/bukkit/event/vehicle/VehicleCreateEvent.java
View File

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

4
src/main/java/org/bukkit/event/vehicle/VehicleDamageEvent.java
View File

@ -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) {
super(type, vehicle);
public VehicleDamageEvent(Vehicle vehicle, Entity attacker, int damage) {
super(Type.ENTITY_DAMAGE, vehicle);
this.attacker = attacker;
this.damage = damage;
}

5
src/main/java/org/bukkit/event/vehicle/VehicleEnterEvent.java
View File

@ -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) {
super(type, vehicle);
public VehicleEnterEvent(Vehicle vehicle, Entity entered) {
super(Type.VEHICLE_ENTER, vehicle);
this.entered = entered;
}

4
src/main/java/org/bukkit/event/vehicle/VehicleEntityCollisionEvent.java
View File

@ -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) {
super(type, vehicle);
public VehicleEntityCollisionEvent(Vehicle vehicle, Entity entity) {
super(Type.VEHICLE_COLLISION_ENTITY, vehicle);
this.entity = entity;
}

5
src/main/java/org/bukkit/event/vehicle/VehicleExitEvent.java
View File

@ -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) {
super(type, vehicle);
public VehicleExitEvent(Vehicle vehicle, LivingEntity exited) {
super(Type.VEHICLE_EXIT, vehicle);
this.exited = exited;
}

2
src/main/java/org/bukkit/event/vehicle/VehicleListener.java
View File

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

5
src/main/java/org/bukkit/event/vehicle/VehicleMoveEvent.java
View File

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

9
src/main/java/org/bukkit/event/vehicle/VehicleUpdateEvent.java Normal file
View File

@ -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);
}
}

21
src/main/java/org/bukkit/event/world/ChunkEvent.java Normal file
View File

@ -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;
}
}

19
src/main/java/org/bukkit/event/world/ChunkLoadEvent.java
View File

@ -6,21 +6,8 @@ import org.bukkit.Chunk;
/**
* Called when a chunk is loaded
*/
public class ChunkLoadEvent extends WorldEvent {
private final Chunk 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;
public class ChunkLoadEvent extends ChunkEvent {
public ChunkLoadEvent(final Chunk chunk) {
super(Type.CHUNK_LOAD, chunk);
}
}

6
src/main/java/org/bukkit/event/world/ChunkUnloadEvent.java
View File

@ -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) {
super(type, chunk);
public ChunkUnloadEvent(final Chunk chunk) {
super(Type.CHUNK_UNLOAD, chunk);
}
/**

6
src/main/java/org/bukkit/event/world/WorldListener.java
View File

@ -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) {
}
}

9
src/main/java/org/bukkit/event/world/WorldLoadEvent.java Normal file
View File

@ -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);
}
}

9
src/main/java/org/bukkit/event/world/WorldSaveEvent.java Normal file
View File

@ -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);
}
}

1
src/main/java/org/bukkit/fillr/Checker.java
View File

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

1
src/main/java/org/bukkit/fillr/Getter.java
View File

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

1
src/main/java/org/bukkit/fillr/Updater.java
View File

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

2
src/main/java/org/bukkit/plugin/PluginDescriptionFile.java
View File

@ -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;

1
src/main/java/org/bukkit/plugin/SimplePluginManager.java
View File

@ -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;

1
src/main/java/org/bukkit/plugin/java/JavaPlugin.java
View File

@ -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;

272
src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
View File

@ -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.ChunkUnloadEvent;
import org.bukkit.event.world.WorldEvent;
import org.bukkit.event.world.WorldListener;
import org.bukkit.event.world.*;
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 ) {
((PlayerListener)listener).onPlayerJoin( (PlayerJoinEvent)event );
public void execute(Listener listener, Event event) {
((PlayerListener) listener).onPlayerJoin((PlayerJoinEvent) event);
}
};
case PLAYER_QUIT:
return new EventExecutor() { public void execute( Listener listener, Event event ) {
((PlayerListener)listener).onPlayerQuit( (PlayerEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerRespawn( (PlayerRespawnEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerKick( (PlayerKickEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerCommandPreprocess( (PlayerChatEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerChat( (PlayerChatEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerMove( (PlayerMoveEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerTeleport( (PlayerMoveEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerInteract( (PlayerInteractEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerLogin( (PlayerLoginEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerEggThrow( (PlayerEggThrowEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerAnimation( (PlayerAnimationEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onInventoryOpen( (PlayerInventoryEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onItemHeldChange( (PlayerItemHeldEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerDropItem( (PlayerDropItemEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerPickupItem( (PlayerPickupItemEvent)event );
return new EventExecutor() {
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 ) {
((PlayerListener)listener).onPlayerToggleSneak( (PlayerToggleSneakEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockPhysics( (BlockPhysicsEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockCanBuild( (BlockCanBuildEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockPlace( (BlockPlaceEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockDamage( (BlockDamageEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockFlow( (BlockFromToEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onLeavesDecay( (LeavesDecayEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onSignChange( (SignChangeEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockIgnite( (BlockIgniteEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockRedstoneChange( (BlockRedstoneEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockBurn( (BlockBurnEvent)event );
return new EventExecutor() {
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 ) {
((BlockListener)listener).onBlockBreak( (BlockBreakEvent)event );
return new EventExecutor() {
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 ) {
((ServerListener)listener).onPluginEnable( (PluginEvent)event );
return new EventExecutor() {
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 ) {
((ServerListener)listener).onPluginDisable( (PluginEvent)event );
return new EventExecutor() {
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 ) {
((ServerListener)listener).onServerCommand( (ServerCommandEvent)event );
return new EventExecutor() {
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 ) {
((WorldListener)listener).onChunkLoad( (ChunkLoadEvent)event );
return new EventExecutor() {
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 ) {
((WorldListener)listener).onChunkUnload( (ChunkUnloadEvent)event );
return new EventExecutor() {
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 ) {
((WorldListener)listener).onWorldSave( (WorldEvent)event );
return new EventExecutor() {
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 ) {
((WorldListener)listener).onWorldLoad( (WorldEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onEntityDamage( (EntityDamageEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onEntityDeath( (EntityDeathEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onEntityCombust( (EntityCombustEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onEntityExplode( (EntityExplodeEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onExplosionPrime( (ExplosionPrimeEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onEntityTarget( (EntityTargetEvent)event );
return new EventExecutor() {
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 ) {
((EntityListener)listener).onCreatureSpawn( (CreatureSpawnEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleCreate( (VehicleCreateEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleDamage( (VehicleDamageEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleBlockCollision( (VehicleBlockCollisionEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleEntityCollision( (VehicleEntityCollisionEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleEnter( (VehicleEnterEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleExit( (VehicleExitEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleMove( (VehicleMoveEvent)event );
return new EventExecutor() {
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 ) {
((VehicleListener)listener).onVehicleUpdate((VehicleEvent)event);
return new EventExecutor() {
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 ) {
((CustomEventListener)listener).onCustomEvent( event );
return new EventExecutor() {
public void execute(Listener listener, Event event) {
((CustomEventListener) listener).onCustomEvent(event);
}
};
}