# Benutzerdefinierte Moderationsdurchsetzung

Verité setzt Stummschaltungen, Slowmode und Chat-Freezes normalerweise automatisch durch. Einige Chat-Plugins fangen jedoch das normale Chat-Ereignis von Minecraft ab und übernehmen die Nachrichtenzustellung selbst.

Wenn dein Plugin dies tut, sieht Verité die Nachricht möglicherweise nie, sodass seine eigenen Stummschaltungs- und Slowmode-Prüfungen nie ausgeführt werden. In diesem Fall solltest du Verité vor dem Senden der Nachricht nach dem Absender fragen und die Nachricht selbst stoppen, wenn Verité es anweist.

> **Du benötigst diese Anleitung nur, wenn dein Plugin den normalen Minecraft-Chat verarbeitet oder ersetzt.** Server, die den Standard-Chat verwenden, benötigen keine zusätzliche Einrichtung.

Dies ist das Moderationsgegenstück zur Anleitung [Integration benutzerdefinierter Chat-Systeme](page:developers/wiring). Die Filteranleitung prüft den Nachrichteninhalt; diese Anleitung setzt Stummschaltungen, Slowmode und Chat-Freezes durch.

## Java-Integration

Die Moderationsoberfläche befindet sich in `teacommontea.api.VeriteModeration`. Jede Methode gibt einen sicheren Wert zurück, wenn das Moderationsmodul deaktiviert ist, sodass ein Aufrufer diesen Fall nie gesondert behandeln muss.

### 1. Verité als optionale Abhängigkeit hinzufügen

Füge Verité zu deiner `plugin.yml` hinzu:

```yaml
softdepend:
  - Verite
```

Eine optionale Abhängigkeit stellt sicher, dass Verité vor deiner Integration geladen wird, sofern es installiert ist, ohne Verité zu einer zwingenden Voraussetzung für den Start deines Plugins zu machen.

### 2. Prüfen, ob die API verfügbar ist

Wenn Verité optional ist, prüfe vor der Verwendung, ob die API verfügbar ist:

```java
private static final boolean VERITE_AVAILABLE;

static {
    boolean available;

    try {
        Class.forName("teacommontea.api.VeriteModeration");
        available = true;
    } catch (ClassNotFoundException ignored) {
        available = false;
    }

    VERITE_AVAILABLE = available;
}
```

Deine Integration kann dann einfach nichts tun, wenn Verité nicht installiert ist.

### 3. Stummschaltungen durchsetzen

Bevor dein benutzerdefiniertes Chat-System eine Nachricht sendet, frage Verité, ob der Absender stummgeschaltet ist:

```java
if (VERITE_AVAILABLE) {
    if (VeriteModeration.muteGate(player)) {
        return;
    }
}
```

`muteGate` gibt `true` zurück, wenn der Spieler stummgeschaltet ist, und sendet ihm dabei den Stummschaltungshinweis für dich. Wenn es `true` zurückgibt, stoppe die Nachricht.

Wenn du den Hinweis lieber selbst erstellst, lies stattdessen die aktive Stummschaltung:

```java
if (VeriteModeration.isMuted(player.getUniqueId())) {
    Punishment mute = VeriteModeration.activeMute(player.getUniqueId());

    String line = mute.permanent()
        ? "You are muted."
        : "You are muted for " + mute.remaining(System.currentTimeMillis()) + " more milliseconds.";

    player.sendMessage(line);
    return;
}
```

`isMuted` ist eine reine Prüfung und sendet nichts. `activeMute` gibt die Stummschaltung als `Punishment` zurück, aus der du `reason()`, `permanent()` und `remaining(now)` lesen kannst.

### 4. Slowmode und Chat-Freeze durchsetzen

Verité hat zwei serverweite Chat-Bremsen: einen globalen Chat-Freeze, der von Mitarbeitern gesetzt wird, und einen spielerbezogenen Slowmode. Gate beide auf dieselbe Weise wie Stummschaltungen:

```java
if (VeriteModeration.chatMuteGate(player)) {
    return;
}

if (VeriteModeration.slowmodeGate(player)) {
    return;
}
```

Jedes gibt `true` zurück, wenn der Spieler gestoppt werden sollte, und sendet ihm dabei den Grund (den Chat-Freeze-Hinweis oder die verbleibende Slowmode-Wartezeit). Prüfe beide vor dem Senden.

### Alles zusammensetzen

Ein vollständiger Chat-Handler, der Verités Durchsetzung nachbildet, sieht so aus:

```java
if (VERITE_AVAILABLE) {
    if (VeriteModeration.muteGate(player)) {
        return;
    }

    if (VeriteModeration.chatMuteGate(player)) {
        return;
    }

    if (VeriteModeration.slowmodeGate(player)) {
        return;
    }
}

sendMessage(player, message);
```

## Auf Strafen reagieren

Wenn dein Plugin wissen muss, wann eine Strafe verhängt oder aufgehoben wird (zum Loggen, für Benachrichtigungen oder zum Synchronisieren eines anderen Systems), registriere einen Listener:

```java
VeriteModeration.registerListener(new ModerationListener() {
    @Override
    public void entryAdded(Punishment punishment) {
    }

    @Override
    public void entryRemoved(Punishment punishment) {
    }
});
```

`entryAdded` wird ausgelöst, wenn eine Strafe verhängt wird, `entryRemoved`, wenn eine aufgehoben wird. Jede `Punishment` trägt das Ziel, den Typ, den Grund, die Dauer, den Ausführenden und ob sie still war. Rufe `unregisterListener` mit demselben Listener auf, um den Empfang von Ereignissen zu beenden.

## Server-Lockdown

Verité kann den Server hinter einem Lockdown abriegeln. Dein Plugin kann den Lockdown-Zustand lesen oder ihn über `teacommontea.api.VeriteLockdown` steuern:

```java
if (VeriteLockdown.active()) {
    String reason = VeriteLockdown.reason();
}

VeriteLockdown.begin("Maintenance");
VeriteLockdown.end();
```

`active()` meldet, ob ein Lockdown in Kraft ist, `reason()` gibt den aktuellen Grund zurück, `begin(reason)` startet einen und `end()` hebt ihn auf. Verwende `active()`, um dein eigenes Verhalten während eines Lockdowns zu gaten, oder `begin` und `end`, um den Lockdown über deine eigenen Befehle zu steuern.

---

# Verité mit Skript verwenden

Wenn dein benutzerdefiniertes Chat-System in Skript geschrieben ist, musst du nicht mit der Java-API interagieren.

Wenn **Verité und Skript installiert** sind, steht die Moderationssyntax von Verité automatisch zur Verfügung.

## Stummschaltungen, Slowmode und Freeze durchsetzen

Wenn dein Skript das Senden von Chatnachrichten bereits selbst übernimmt, prüfe den Absender vor dem Senden. Verwende diese innerhalb deines Chat-Ereignisses:

```vb
if chat is frozen for player:
    stop

if player is on slowmode:
    stop
```

`chat is frozen` meldet den globalen Chat-Freeze, und `player is on slowmode` meldet die spielerbezogene Slowmode-Abklingzeit. Beide senden dem Spieler den Grund als Nebeneffekt, verwende sie also dort, wo du durchsetzen willst, nicht nur, um den Zustand zu lesen.

Um die persönliche Stummschaltung eines Spielers zu prüfen:

```vb
if player is muted:
    stop
```

`player is muted` liest den Zustand der aktiven Stummschaltung, ohne etwas zu senden, kombiniere es also mit deinem eigenen Hinweis.

## Lockdown steuern

Du kannst einen Server-Lockdown aus einem Skript starten oder aufheben:

```vb
begin message lockdown with reason "Maintenance"

end message lockdown
```

Der Grund ist optional; wenn er weggelassen wird, wird ein generisches Label verwendet.

## Skript-Syntaxreferenz

```vb
player is muted
player is not muted

chat is frozen [for %-player%]
player is rate limited
player is on slowmode

begin message lockdown [(with reason|for) %-string%]
end message lockdown
```

`chat is frozen`, `is rate limited` und `is on slowmode` senden dem Spieler bei einem Treffer einen Hinweis, verwende sie also in einem Chat-Handler, in dem du die Nachricht stoppen willst.

---

## API-Referenz

Die öffentliche API befindet sich unter:

```text
teacommontea.api
```

Die primären Klassen für die Moderationsdurchsetzung sind:

```java
VeriteModeration
VeriteLockdown
```

Zu den nützlichen Methoden gehören:

```java
VeriteModeration.muteGate(Player player)
VeriteModeration.chatMuteGate(Player player)
VeriteModeration.slowmodeGate(Player player)

VeriteModeration.isMuted(UUID player)
VeriteModeration.activeMute(UUID player)

VeriteModeration.registerListener(ModerationListener listener)
VeriteModeration.unregisterListener(ModerationListener listener)

VeriteLockdown.active()
VeriteLockdown.reason()
VeriteLockdown.begin(String reason)
VeriteLockdown.end()
```

Die Gate-Methoden (`muteGate`, `chatMuteGate`, `slowmodeGate`) entscheiden sowohl, ob der Spieler gestoppt werden soll, als auch senden ihm den Grund. Die Abfragemethoden (`isMuted`, `activeMute`) lesen nur den Zustand und senden nichts.

Für die meisten benutzerdefinierten Chat-Integrationen ist das Durchsetzen der drei Gates der Reihe nach alles, was du brauchst:

```java
if (VeriteModeration.muteGate(player)
        || VeriteModeration.chatMuteGate(player)
        || VeriteModeration.slowmodeGate(player)) {
    return;
}
```

Verité übernimmt den Rest.