bukkit
Evenementafhandeling
Zoeken…
Invoering
Wanneer er iets gebeurt in Bukkit, wordt een evenement genoemd, zodat elke plug-in kan beslissen wat te doen wanneer er iets gebeurt.
Een gebeurtenis wordt genoemd wanneer een speler een blok probeert te spelen, wanneer een entiteit wordt weergegeven, wanneer iemand zich aanmeldt ... Plug-ins kunnen naar specifieke gebeurtenissen luisteren en er op veel verschillende manieren mee omgaan, bijvoorbeeld door een bericht naar een beheerder te sturen wanneer een speler logt in via PlayerLoginEvent.
Syntaxis
- Bukkit.getPluginManager (). RegisterEvents (Listener l, Plugin p);
Opmerkingen
Kijk bij het registreren van een evenement of je het niet twee keer registreert! Of uw plug-in werkt twee keer voor het geregistreerde evenement.
Neem een extra kijkje voor het omgaan met specifieke evenementen:
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: