Ereignisse

HyperPerms feuert Ereignisse ab, wenn Berechtigungen geprüft oder geändert werden. Hören Sie auf diese Ereignisse, um sie in andere Plugins zu integrieren oder benutzerdefiniertes Verhalten zu implementieren.

Verfügbare Ereignisse

PermissionCheckEvent

Wird jedes Mal ausgelöst, wenn eine Berechtigung für einen Spieler geprüft wird. Verwenden Sie dies, um die Berechtigungsergebnisse zu ändern oder den Zugriff zu protokollieren.

import dev.hyperperms.api.event.PermissionCheckEvent;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;

public class PermissionListener implements Listener {

    @EventHandler
    public void onPermissionCheck(PermissionCheckEvent event) {
        UUID player = event.getUser().getUuid();
        String permission = event.getPermission();
        boolean result = event.getResult();

        // Log the check
        System.out.println(player + " checked " + permission + " = " + result);

        // Modify the result (use carefully!)
        if (permission.equals("special.override")) {
            event.setResult(true);
        }
    }
}

Ereigniseigenschaften

• getUser() - Der zu prüfende Benutzer
• getPermission() - Der zu überprüfende Berechtigungsknoten
• getContexts() - Die Kontexte für diese Prüfung
• getResult() - Das berechnete Ergebnis
• setResult(boolean) - Überschreiben des Ergebnisses

Warnung: PermissionCheckEvent feuert sehr häufig. Halten Sie Ihren Handler schnell, um Leistungsprobleme zu vermeiden. Vermeiden Sie schwere Operationen in diesem Ereignis.

GroupCreateEvent

Wird ausgelöst, wenn eine neue Gruppe erstellt wird.

import dev.hyperperms.api.event.GroupCreateEvent;

@EventHandler
public void onGroupCreate(GroupCreateEvent event) {
    String groupName = event.getGroupName();

    // Prevent creation of certain groups
    if (groupName.startsWith("reserved_")) {
        event.setCancelled(true);
        event.setCancelReason("Cannot create groups with 'reserved_' prefix");
        return;
    }

    getLogger().info("Group created: " + groupName);
}

GroupDeleteEvent

Wird ausgelöst, wenn eine Gruppe gelöscht wird.

import dev.hyperperms.api.event.GroupDeleteEvent;

@EventHandler
public void onGroupDelete(GroupDeleteEvent event) {
    Group group = event.getGroup();

    // Prevent deletion of protected groups
    if (group.getName().equals("default")) {
        event.setCancelled(true);
        event.setCancelReason("Cannot delete the default group");
        return;
    }

    // Log the deletion
    getLogger().info("Group deleted: " + group.getName());
}

GroupModifyEvent

Wird ausgelöst, wenn die Eigenschaften oder Berechtigungen einer Gruppe geändert werden.

import dev.hyperperms.api.event.GroupModifyEvent;
import dev.hyperperms.api.event.GroupModifyEvent.ModificationType;

@EventHandler
public void onGroupModify(GroupModifyEvent event) {
    Group group = event.getGroup();
    ModificationType type = event.getModificationType();

    switch (type) {
        case PERMISSION_ADD:
            getLogger().info("Permission added to " + group.getName());
            break;
        case PERMISSION_REMOVE:
            getLogger().info("Permission removed from " + group.getName());
            break;
        case PARENT_ADD:
            getLogger().info("Parent added to " + group.getName());
            break;
        case PARENT_REMOVE:
            getLogger().info("Parent removed from " + group.getName());
            break;
        case WEIGHT_CHANGE:
            getLogger().info("Weight changed for " + group.getName());
            break;
        case PREFIX_CHANGE:
            getLogger().info("Prefix changed for " + group.getName());
            break;
        case SUFFIX_CHANGE:
            getLogger().info("Suffix changed for " + group.getName());
            break;
    }
}

UserModifyEvent

Wird ausgelöst, wenn die Berechtigungen, Gruppen oder Eigenschaften eines Benutzers geändert werden.

import dev.hyperperms.api.event.UserModifyEvent;
import dev.hyperperms.api.event.UserModifyEvent.ModificationType;

@EventHandler
public void onUserModify(UserModifyEvent event) {
    User user = event.getUser();
    ModificationType type = event.getModificationType();

    switch (type) {
        case GROUP_ADD:
            Group addedGroup = (Group) event.getData();
            getLogger().info(user.getUsername() + " added to " + addedGroup.getName());
            break;
        case GROUP_REMOVE:
            Group removedGroup = (Group) event.getData();
            getLogger().info(user.getUsername() + " removed from " + removedGroup.getName());
            break;
        case PRIMARY_GROUP_CHANGE:
            Group newPrimary = (Group) event.getData();
            getLogger().info(user.getUsername() + " primary group set to " + newPrimary.getName());
            break;
        case PERMISSION_ADD:
        case PERMISSION_REMOVE:
            getLogger().info(user.getUsername() + " permissions modified");
            break;
    }
}

UserPromoteEvent

Wird ausgelöst, wenn ein Benutzer auf einer Strecke befördert wird.

import dev.hyperperms.api.event.UserPromoteEvent;

@EventHandler
public void onUserPromote(UserPromoteEvent event) {
    User user = event.getUser();
    Track track = event.getTrack();
    Group fromGroup = event.getFromGroup();
    Group toGroup = event.getToGroup();

    getLogger().info(String.format(
        "%s promoted from %s to %s on track %s",
        user.getUsername(),
        fromGroup.getName(),
        toGroup.getName(),
        track.getName()
    ));

    // Example: Send a message to the player
    Player player = Bukkit.getPlayer(user.getUuid());
    if (player != null) {
        player.sendMessage("Congratulations! You've been promoted to " + toGroup.getDisplayName());
    }
}

UserDemoteEvent

Wird ausgelöst, wenn ein Benutzer auf einer Strecke degradiert wird.

import dev.hyperperms.api.event.UserDemoteEvent;

@EventHandler
public void onUserDemote(UserDemoteEvent event) {
    User user = event.getUser();
    Track track = event.getTrack();
    Group fromGroup = event.getFromGroup();
    Group toGroup = event.getToGroup();

    getLogger().info(String.format(
        "%s demoted from %s to %s on track %s",
        user.getUsername(),
        fromGroup.getName(),
        toGroup.getName(),
        track.getName()
    ));
}

Ereignispriorität

Verwenden Sie Ereignisprioritäten, um die Reihenfolge zu steuern, in der Listener aufgerufen werden:

import org.bukkit.event.EventPriority;

// Called early - good for logging
@EventHandler(priority = EventPriority.LOWEST)
public void onPermissionCheckLog(PermissionCheckEvent event) {
    // Log the original result
}

// Called late - good for overriding
@EventHandler(priority = EventPriority.HIGHEST)
public void onPermissionCheckOverride(PermissionCheckEvent event) {
    // Override the result if needed
}

Abbruch von Ereignissen

Abbrechbare Ereignisse können abgebrochen werden, um die Aktion zu verhindern:

@EventHandler
public void onGroupDelete(GroupDeleteEvent event) {
    // Prevent deletion
    event.setCancelled(true);

    // Optionally provide a reason (shown to command executor)
    event.setCancelReason("Group deletion is disabled");
}

Tipp: Wenn ein Ereignis abgebrochen wird, wird die Aktion verhindert, aber die Quelle (Befehl oder API-Aufruf) erhält eine Benachrichtigung, dass es abgebrochen wurde.

Registrierung von Listenern

public class MyPlugin extends JavaPlugin {

    @Override
    public void onEnable() {
        // Register your event listeners
        getServer().getPluginManager().registerEvents(
            new PermissionListener(),
            this
        );
    }
}

Bewährte Praktiken

• Handler schnell halten - Besonders für PermissionCheckEvent
• Angemessene Priorität verwenden - Früh protokollieren, spät ändern
• Nicht blockieren - Vermeiden Sie I/O or network calls in handlers
• Handle Exceptions - Lass Fehler sich nicht ausbreiten
• Vorsichtiges Abbrechen - Berücksichtigen Sie die Benutzererfahrung

Siehe auch

• API Reference
• Placeholders