bukkit
Evenementafhandeling

Invoering

Syntaxis

• Bukkit.getPluginManager (). RegisterEvents (Listener l, Plugin p);

Opmerkingen

Registreer evenementen binnen de klasse Listener

import org.bukkit.event.Listener;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerQuitEvent;

public class MyEventListener implements Listener {

    /**
     * Constructor
     */
    public MyEventListener(Main plugin){
        //register Events of this class
        //with methode: registerEvents(Listener, Plugin);
        plugin.getServer().getPluginManager().registerEvents(this, plugin);
    }      

    /**
     * A Event with HIGH priority
     */
    @EventHandler(priority = EventPriority.HIGH) //An EventHandler annotation
    public void onPlayerLogin(PlayerLoginEvent event){  //A bukkit event
        event.getPlayer().sendMessage("Welcome.");
    }
    /**
     * A Event with NORMAL (default) priority
     */
    @EventHandler    
    public void onPlayerQuit(PlayerQuitEvent event){ 
        Bukkit.broadcastMessage(event.getPlayer().getName() + " left the Server.");
    }
        

}

/**
 * Main class
 */
public class Main extends JavaPlugin {
    public void onEnable(){
        //Register Events
        new MyEventListener(this);
    }
}

Gebeurtenissen registreren in uw hoofdklasse

public class Main extends JavaPlugin {

    @Override
    public void onEnable() {
        Bukkit.getPluginManager().registerEvents(this, this);   
    }
  
    @EventHandler
    public void yourEvent(Event e) {
    //...
    }
}

Luisteren naar evenementen

Bukkit maakt gebruik van een op gebeurtenissen gebaseerd systeem waarmee ontwikkelaars van plug-ins kunnen communiceren met en wijzigingen kunnen aanbrengen in de server en specifieke acties die in de wereld plaatsvinden.

Een gebeurtenishandler maken

Gebeurtenishandlers zijn methoden die worden aangeroepen wanneer hun gebeurtenis plaatsvindt. Ze zijn over het algemeen openbaar en ongeldig en worden volgens on{EventNameStem} . Alle handlers moeten echter de annotatie @EventHandler hebben en de gebeurtenis als ALLEEN parameter bevatten. Hier is een voorbeeld van een gebeurtenishandler voor PlayerJoinEvent

@EventHandler
public void onPlayerJoin(PlayerJoinEvent event){
    //Run when a player joins
}

Opmerking: de naamindeling voor Bukkit-evenementen is {Source}{Action}({Target})Event . Enkele voorbeelden van deze gebeurtenisnamen zijn: PlayerInteractEvent of BlockBreakEvent of PlayerJoinEvent . Een lijst met alle evenementen is te vinden op de Spigot Javadocs

Gebeurtenissen registreren

Alleen het aanmaken van een event-handler is niet voldoende om Bukkit in staat te stellen event-oproepen naar uw methode te verzenden. U moet het ook registreren via de PluginManager-interface.

De meest gebruikelijke manier om evenementen te registreren is om een klasse te maken die de luisteraar-interface implementeert en deze gebruikt om uw event-handlers in te pakken.

public class EventListener implements Listener { //Implements the Listener interface

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event){
        //Run when a player joins
    }

}

Deze luisteraarklasse en al zijn evenementen kunnen vervolgens als volgt in uw hoofdinvoegtoepassingsklasse worden geregistreerd:

@Override
public void onEnable(){
    Bukkit.getPluginManager().registerEvents(new EventListener(), this); //Register your listener and its event handlers
}

Aangepaste gebeurtenissen maken

Soms moet je je eigen evenement maken, een evenement waar andere plug-ins naar kunnen luisteren (Vault, onder andere plug-ins, doet dit) en zelfs annuleren. Bukkit's Event API maakt dit mogelijk. Het enige wat u hoeft te doen is een nieuwe klasse maken, het Event uitbreiden, de handlers en de attributen toevoegen die uw evenement nodig heeft (zoals speler of bericht).

import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

public final class CustomEvent extends Event {
    private static final HandlerList handlers = new HandlerList();
    private String message;

    public CustomEvent(String example) {
        message = example;
    }

    public String getMessage() {
        return message;
    }

    public HandlerList getHandlers() {
        return handlers;
    }

    public static HandlerList getHandlerList() {
        return handlers;
    }
}

Uw aangepaste gebeurtenis bellen

Je hebt de controle over het maken en bellen van je evenementen, waar je het zelf bepaalt. Hier is een voorbeeld

// Create the event here
CustomEvent event = new CustomEvent("Sample Message");
// Call the event
Bukkit.getServer().getPluginManager().callEvent(event);
Bukkit.getServer().broadcastMessage(event.getMessage());

Onthoud: je hebt de controle over je evenementen. Als je het niet noemt en er naar handelt, gebeurt het niet!

Luisteren naar een aangepaste gebeurtenis

Luisteren naar een aangepaste gebeurtenis is hetzelfde als luisteren naar een normale gebeurtenis.

import org.bukkit.event.Listener;
import org.bukkit.event.EventHandler;

public final class CustomListener implements Listener {
    
    @EventHandler
    public void onCustomEvent(CustomEvent event) {
    // Some code here
    }
}

Uw CustomEvent opzegbaar maken

Als je je evenement ooit annuleerbaar wilt maken, voeg je gewoon implements Cancellable , boolean cancelled en een getter en setter toe:

import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Cancellable;

public final class CustomEvent extends Event implements Cancellable {
    private static final HandlerList handlers = new HandlerList();
    private String message;
    private boolean cancelled;

    public CustomEvent(String example) {
        message = example;
    }

    public String getMessage() {
        return message;
    }

    public boolean isCancelled() {
        return cancelled;
    }

    public void setCancelled(boolean cancel) {
        cancelled = cancel;
    }

    public HandlerList getHandlers() {
        return handlers;
    }

    public static HandlerList getHandlerList() {
        return handlers;
    }
}

Daarna zou u controleren of een plug-in de aangepaste gebeurtenis had geannuleerd.

// Create the event here
CustomEvent event = new CustomEvent("Sample Message");
// Call the event
Bukkit.getServer().getPluginManager().callEvent(event);
// Check if the event is not cancelled
if (!event.isCancelled()) {
    Bukkit.getServer().broadcastMessage(event.getMessage());
}

Basisgebeurtenisafhandeling

Bukkit maakt gebruik van een op gebeurtenissen gebaseerd systeem waarmee ontwikkelaars van plug-ins kunnen communiceren met en wijzigingen kunnen aanbrengen in de server en specifieke acties die in de wereld plaatsvinden.

Een gebeurtenishandler maken

Gebeurtenishandlers zijn methoden die worden aangeroepen wanneer hun gebeurtenis plaatsvindt. Ze zijn over het algemeen openbaar en ongeldig en worden volgens on{EventNameStem} . Alle handlers moeten echter de annotatie @EventHandler hebben en de gebeurtenis als ALLEEN parameter bevatten. Hier is een voorbeeld van een gebeurtenishandler voor PlayerJoinEvent

@EventHandler
public void onPlayerJoin(PlayerJoinEvent event){
    //Run when a player joins
}

Opmerking: de naamindeling voor Bukkit-evenementen is {Source}{Action}({Target})Event . Enkele voorbeelden van deze gebeurtenisnamen zijn: PlayerInteractEvent of BlockBreakEvent of PlayerJoinEvent . Een lijst met alle evenementen is te vinden op de Spigot Javadocs

Gebeurtenissen registreren

Alleen het aanmaken van een event-handler is niet voldoende om Bukkit in staat te stellen event-oproepen naar uw methode te verzenden. U moet het ook registreren via de PluginManager-interface.

De meest gebruikelijke manier om evenementen te registreren is om een klasse te maken die de luisteraar-interface implementeert en deze gebruikt om uw event-handlers in te pakken.

public class EventListener implements Listener { //Implements the Listener interface

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event){
        //Run when a player joins
    }

}

Deze luisteraarklasse en al zijn evenementen kunnen vervolgens als volgt in uw hoofdinvoegtoepassingsklasse worden geregistreerd:

@Override
public void onEnable(){
    Bukkit.getPluginManager().registerEvents(new EventListener(), this); //Register your listener and its event handlers
}

Evenementprioriteiten

Bukkit heeft een systeem genaamd Event Priorities om plug-ins te helpen gebeurtenissen op de juiste manier af te handelen. De zeven prioriteiten zijn (in ouder van eerste uitgevoerd tot laatste):

• laagste
• Laag
• Normaal (standaard)
• hoog
• hoogst
• Toezicht houden op

Als u van plan bent veel evenementen te annuleren (bijvoorbeeld een beveiligingsplug-in), is het een goed idee om een lagere prioriteit (of laagste) te gebruiken om problemen te voorkomen.

Wijzig nooit de uitkomst van een evenement bij MONITOR.

@EventHandler //same as @EventHandler(priority = EventPriority.NORMAL)
public void onLogin(PlayerLoginEvent event) {
    // normal login
}

@EventHandler(priority = EventPriority.HIGH)
public void onLogin(PlayerLoginEvent event) {
    // high login
}

Meer informatie:

• EventPriority bij spigot javadocs
• Evenementprioriteiten op BukkitWiki