> ## Documentation Index
> Fetch the complete documentation index at: https://simplecloud.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Events in Echtzeit behandeln

> Auf Server-, Gruppen- und Persistent-Server-Änderungen mit der Events API reagieren

Diese Anleitung zeigt Muster für die Echtzeit-Event-Behandlung in deinen Plugins.

## Einfache Event-Behandlung

### Events abonnieren

```java theme={null}
Subscription sub = api.event().server().onStarted(event -> {
    System.out.println("Server gestartet: " + event.getServerId());
});

// Schließen wenn fertig
sub.close();
```

### Plugin-Lebenszyklus-Verwaltung

```java theme={null}
public class MeinPlugin extends JavaPlugin {
    private CloudApi api;
    private final List<Subscription> subscriptions = new ArrayList<>();

    @Override
    public void onEnable() {
        api = CloudApi.create();
        registerEvents();
    }

    @Override
    public void onDisable() {
        subscriptions.forEach(Subscription::close);
        subscriptions.clear();
    }

    private void registerEvents() {
        subscriptions.add(api.event().server().onStarted(this::onServerStarted));
        subscriptions.add(api.event().server().onStopped(this::onServerStopped));
        subscriptions.add(api.event().group().onUpdated(this::onGroupUpdated));
    }

    private void onServerStarted(ServerStartedEvent event) {
        getLogger().info("Server gestartet: " + event.getServerId());
    }

    private void onServerStopped(ServerStoppedEvent event) {
        getLogger().info("Server gestoppt: " + event.getServerId());
    }

    private void onGroupUpdated(GroupUpdatedEvent event) {
        getLogger().info("Gruppe aktualisiert: " + event.getServerGroupId());
    }
}
```

## Gängige Event-Muster

### Server anfordern, wenn eine Gruppe leer wird

```java theme={null}
public void setupAutoStart(String groupName, int minimum) {
    api.event().server().onStopped(event -> {
        Server stopped = event.getServer();
        if (!stopped.isFromGroup() || !groupName.equals(stopped.getGroup().getName())) {
            return;
        }

        api.server().getServersByGroup(groupName).thenAccept(servers -> {
            long running = servers.stream()
                .filter(server -> server.getState() != ServerState.STOPPING)
                .filter(server -> server.getState() != ServerState.CLEANUP)
                .count();

            if (running < minimum) {
                api.group().getGroupByName(groupName).thenCompose(group -> {
                    if (group == null) {
                        return CompletableFuture.failedFuture(
                            new IllegalArgumentException("Gruppe nicht gefunden: " + groupName));
                    }
                    return api.group().requestServerStart(group);
                });
            }
        });
    });
}
```

### Alle Status-Änderungen loggen

```java theme={null}
public void setupStateLogging() {
    api.event().server().onStateChanged(event -> {
        String message = String.format("[%s] %s -> %s",
            event.getServerId(),
            event.getOldState(),
            event.getNewState());

        logger.info(message);
    });
}
```

### Staff bei Server-Crash benachrichtigen

```java theme={null}
public void setupCrashNotifications() {
    api.event().server().onStopped(event -> {
        if (!event.getCrashed()) return;

        notifyStaff(Component.text("[Alert] Server abgestürzt: " + event.getServerId())
            .color(NamedTextColor.RED));
    });
}
```

## Events filtern

### Nach Gruppe filtern

Server Events werden sowohl für Gruppen-Server als auch für persistente Server ausgelöst. Nutze das enthaltene `Server`-Model, um persistente Server-Instanzen zu überspringen.

```java theme={null}
public void watchGroup(String groupName) {
    api.event().server().onStarted(event -> {
        Server server = event.getServer();
        if (server.isFromGroup() && groupName.equals(server.getGroup().getName())) {
            handleGroupServerStart(event);
        }
    });
}
```

## Einmalige Events

### Auf bestimmten Server warten

```java theme={null}
public CompletableFuture<Void> waitForServer(String serverId) {
    CompletableFuture<Void> future = new CompletableFuture<>();

    Subscription sub = api.event().server().onStateChanged(event -> {
        if (event.getServerId().equals(serverId) &&
            event.getNewState() == ServerState.AVAILABLE) {
            future.complete(null);
        }
    });

    future.whenComplete((result, error) -> sub.close());

    return future;
}
```