All Known Subinterfaces:: CancellableEvent

All Known Implementing Classes:: CommandEvent, CommandPostProcessEvent, CommandPostRegistrationEvent, CommandPreProcessEvent, CommandPreRegistrationEvent

public interface Event

Base marker interface for all events that can be handled by the EventBus.

Only events implementing this interface are eligible for registration and processing through the event bus system. This design ensures type safety and prevents arbitrary objects from being posted as events.

This is a marker interface with no methods, serving purely as a contract that identifies classes as events within the framework's event system.

Creating Custom Events

To create a custom event, simply implement this interface and add any relevant data fields and accessor methods:


 public class PlayerJoinEvent implements Event {
     private final Player player;
     private final String joinMessage;

     public PlayerJoinEvent(Player player, String joinMessage) {
         this.player = player;
         this.joinMessage = joinMessage;
     }

     public Player getPlayer() {
         return player;
     }

     public String getJoinMessage() {
         return joinMessage;
     }
 }

Cancellable Events

For events that support cancellation, implement CancellableEvent instead:


 public class PlayerChatEvent implements CancellableEvent {
     private final Player player;
     private String message;
     private boolean cancelled;

     public PlayerChatEvent(Player player, String message) {
         this.player = player;
         this.message = message;
     }

     public Player getPlayer() {
         return player;
     }

     public String getMessage() {
         return message;
     }

     public void setMessage(String message) {
         this.message = message;
     }

     @Override
     public boolean isCancelled() {
         return cancelled;
     }

     @Override
     public void setCancelled(boolean cancelled) {
         this.cancelled = cancelled;
     }
 }

RootCommand-Related Events

For events related to command operations, extend CommandEvent:


 public class CommandExecutionEvent<S extends CommandSource> extends CommandEvent<S> {
     private final ExecutionContext<S> context;
     private final long executionTime;

     public CommandExecutionEvent(RootCommand<S> command,
                                  ExecutionContext<S> context,
                                  long executionTime) {
         super(command);
         this.context = context;
         this.executionTime = executionTime;
     }

     public ExecutionContext<S> getContext() {
         return context;
     }

     public long getExecutionTime() {
         return executionTime;
     }
 }

Usage Example


 // Register a handler for your custom event
 eventBus.register(PlayerJoinEvent.class, event -> {
     Player player = event.getPlayer();
     logger.info("Player joined: " + player.getName());
     broadcastMessage(event.getJoinMessage());
 });

 // Post the event
 eventBus.post(new PlayerJoinEvent(player, "Welcome!"));

Since:

1.0

See Also:

Interface Event

Creating Custom Events

Cancellable Events

RootCommand-Related Events

Usage Example