Nasłuchiwacze wydarzeń

In order to listen for an event, an event listener must be registered. This is done by making a method with any name, defining the first parameter to be the desired event type, and then affixing the Listener annotation to the method, as illustrated below.

import org.spongepowered.api.event.Listener;

@Listener
public void onSomeEvent(SomeEvent event) {
    // Do something with the event
}

In addition, the class containing these methods must be registered with the event manager:

Wskazówka

For event listeners on your main plugin class (annotated by Plugin), you do not need to register the object for events as Sponge will do it automatically.

Informacja

The event bus supports supertypes. For example, ChangeBlockEvent.Break extends ChangeBlockEvent. Therefore, a plugin could listen to ChangeBlockEvent and still receive ChangeBlockEvent.Breaks. However, a plugin listening to just ChangeBlockEvent.Break would not be notified of other types of ChangeBlockEvent.

Rejestrowanie i wyrejestrowywanie detektorów zdarzeń

To register event listeners annotated by @Listener that are not in the main plugin class, you can use EventManager#registerListeners(Object, Object), which accepts a reference to the plugin and an instance of the class containing the event listeners.

Example: Registering Event Listeners in Other Classes

import org.spongepowered.api.Sponge;

public class ExampleListener {

    @Listener
    public void onSomeEvent(SomeEvent event) {
        // Do something with the event
    }
}

Sponge.getEventManager().registerListeners(this, new ExampleListener());

Dynamiczne rejestrowanie detektorów zdarzeń

Some plugins (such as scripting plugins) may wish to dynamically register an event listener. In that case the event listener is not a method annotated with @Listener, but rather a class implementing the EventListener interface. This event listener can then be registered by calling EventManager#registerListener, which accepts a reference to the plugin as the first argument, the Class of events handled as the second argument, and the listener itself as the final argument. Optionally, you can specify an Order to run the event listener in as the third argument or a boolean value as the fourth argument (before the instance of the listener) which determines whether to call the listener before other server modifications.

Przykład: Implementowanie EventListener

import org.spongepowered.api.event.EventListener;
import org.spongepowered.api.event.block.ChangeBlockEvent;

public class ExampleListener implements EventListener<ChangeBlockEvent.Break> {

    @Override
    public void handle(ChangeBlockEvent.Break event) throws Exception {
        [...]
    }
}

Example: Dynamically Registering the Event Listener

EventListener<ChangeBlockEvent.Break> listener = new ExampleListener();
Sponge.getEventManager().registerListener(this, ChangeBlockEvent.Break.class, listener);

Wskazówka

For event listeners created with the @Listener annotation, the order of the execution can be configured (see also About @Listener). For dynamically registered listeners this is possible by passing an Order to the third argument the EventManager#registerListener method.

Unregistering Event Listeners

Aby wyrejestrować pojedynczy event listener, możesz użyć metody EventManager#unregisterListeners(Object), która przyjmuje instancję klasy zawierającą event listenery.

EventListener listener = ...;
Sponge.getEventManager().unregisterListeners(listener);

Alternatywnie, możesz użyć EventManager#unregisterPluginListeners(Object), przesyłając referencje do pluginu, aby wyrejestrować wszystkie event listenery dla tego pluginu. Zauważ, że usunie to wszystkie event listenery pluginu, w tym te, zarejestrowane adnotacją @Listener.

PluginContainer plugin = ...;
Sponge.getEventManager().unregisterPluginListeners(plugin);

O @Listener

The @Listener annotation has a few configurable fields:

order is the priority in which the event listener is to be run. See the Order enum in SpongeAPI to see the available options.
beforeModifications określa czy event listener powinien zostać wywołany przed innymi modyfikacjami serwerowymi takimi jak mody Forge. Domyślnie ustawione jest to na false.

Domyślnie, @Listener jest skonfigurowany tak, że Twój event listener nie zostanie wywoływany, jeśli dany event można anulować i został anulowany (np. przez inny plugin).

GameReloadEvent

To prevent all plugins providing their own reload commands, Sponge provides a built-in callback for plugins to listen to, and when executed, perform any reloading actions. What constitutes as a «reloading action» is purely up to the plugin to decide. The GameReloadEvent will fire when a player executes the /sponge plugins reload command. The event is not necessarily limited to reloading configuration.

import org.spongepowered.api.event.game.GameReloadEvent;

@Listener
public void reload(GameReloadEvent event) {
    // Do reload stuff
}

Note that this is different for what generally is considered a «reload», as the event is purely all callback for plugins and does not do any reloading on its own.

Wywoływanie zdarzeń

To dispatch an event, you need an object that implements the Event interface.

You can fire events using the event bus (EventManager):

boolean cancelled = Sponge.getEventManager().post(theEventObject);

Metoda zwraca true, jeśli zdarzenie zostało anulowane, false, jeśli nie.

Wywoływanie zdarzeń Sponge

It is possible to generate instances of built-in events with the static SpongeEventFactory. This class is automatically generated so there are no Javadocs. Use your IDE’s autocompletion to list the existing methods. The events created by the SpongeEventFactory are then passed to EventManager#post(Event).

Przykład: Odpalanie LightningEvent

import org.spongepowered.api.event.action.LightningEvent;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.cause.EventContext;
import org.spongepowered.api.event.cause.EventContextKeys;
import org.spongepowered.api.event.SpongeEventFactory;

PluginContainer plugin = ...;
EventContext eventContext = EventContext.builder().add(EventContextKeys.PLUGIN, plugin).build();

LightningEvent lightningEvent = SpongeEventFactory.createLightningEventPre(Cause.of(eventContext, plugin));
Sponge.getEventManager().post(lightningEvent);

Ostrzeżenie

A Cause can never be empty. At the very least it should contain your plugin container.