# Application de la modération personnalisée

Verité applique normalement les sourdines, le mode lent et les gels de chat automatiquement. Cependant, certains plugins de chat interceptent l’événement de chat standard de Minecraft et gèrent eux-mêmes la transmission des messages.

Si votre plugin fonctionne ainsi, Verité peut ne jamais voir le message, de sorte que ses propres vérifications de sourdine et de mode lent ne s’exécutent jamais. Dans ce cas, vous devez interroger Verité au sujet de l’expéditeur avant que votre plugin n’envoie le message, et arrêter le message vous-même lorsque Verité l’indique.

> **Vous n’avez besoin de ce guide que si votre plugin gère ou remplace le chat standard de Minecraft.** Les serveurs utilisant le chat standard ne nécessitent aucune configuration supplémentaire.

Ceci est le pendant modération du guide [Intégration d’un chat personnalisé](page:developers/wiring). Le guide du filtre analyse le contenu des messages ; ce guide applique les sourdines, le mode lent et les gels de chat.

## Intégration Java

La surface de modération se trouve dans `teacommontea.api.VeriteModeration`. Chaque méthode renvoie une valeur sûre lorsque le module de modération est désactivé, de sorte qu’un appelant n’a jamais à en faire un cas particulier.

### 1. Ajouter Verité en tant que dépendance facultative

Ajoutez Verité à votre `plugin.yml` :

```yaml
softdepend:
  - Verite
```

L’utilisation d’une dépendance facultative garantit que Verité est chargé avant votre intégration lorsqu’il est installé, sans pour autant le rendre obligatoire pour le démarrage de votre plugin.

### 2. Vérifier si l’API est disponible

Si Verité est facultatif, vérifiez la disponibilité de l’API avant de l’utiliser :

```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;
}
```

Votre intégration peut alors simplement ne rien faire lorsque Verité n’est pas installé.

### 3. Appliquer les sourdines

Avant que votre système de chat personnalisé n’envoie un message, demandez à Verité si l’expéditeur est réduit au silence :

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

`muteGate` renvoie `true` lorsque le joueur est réduit au silence, et ce faisant lui envoie l’avis de sourdine pour vous. Lorsqu’il renvoie `true`, arrêtez le message.

Si vous préférez construire l’avis vous-même, lisez plutôt la sourdine active :

```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` est une vérification pure et n’envoie rien. `activeMute` renvoie la sourdine sous forme de `Punishment`, à partir de laquelle vous pouvez lire `reason()`, `permanent()` et `remaining(now)`.

### 4. Appliquer le mode lent et le gel du chat

Verité dispose de deux freins de chat à l’échelle du serveur : un gel global du chat défini par le personnel, et un mode lent par joueur. Barrez les deux de la même manière que vous barrez les sourdines :

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

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

Chacun renvoie `true` lorsque le joueur devrait être arrêté, et lui envoie la raison (l’avis de gel du chat ou l’attente restante du mode lent) ce faisant. Vérifiez les deux avant l’envoi.

### En les assemblant

Un gestionnaire de chat complet qui reproduit l’application de Verité ressemble à ceci :

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

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

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

sendMessage(player, message);
```

## Réagir aux sanctions

Si votre plugin a besoin de savoir quand une sanction est émise ou levée (pour la journalisation, les notifications ou la synchronisation d’un autre système), enregistrez un écouteur :

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

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

`entryAdded` se déclenche lorsqu’une sanction est émise, `entryRemoved` lorsqu’une est levée. Chaque `Punishment` porte la cible, le type, la raison, la durée, l’exécuteur et le caractère silencieux. Appelez `unregisterListener` avec le même écouteur pour cesser de recevoir les événements.

## Verrouillage du serveur

Verité peut sceller le serveur derrière un verrouillage. Votre plugin peut lire l’état de verrouillage ou le piloter via `teacommontea.api.VeriteLockdown` :

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

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

`active()` indique si un verrouillage est en vigueur, `reason()` renvoie la raison actuelle, `begin(reason)` en démarre un, et `end()` le lève. Utilisez `active()` pour barrer votre propre comportement pendant un verrouillage, ou `begin` et `end` pour piloter le verrouillage depuis vos propres commandes.

---

# Utiliser Verité avec Skript

Si votre système de chat personnalisé est écrit en Skript, vous n’avez pas besoin d’interagir avec l’API Java.

Avec **Verité et Skript installés**, la syntaxe de modération de Verité est automatiquement disponible.

## Appliquer les sourdines, le mode lent et le gel

Si votre script gère déjà lui-même l’envoi des messages de chat, vérifiez l’expéditeur avant l’envoi. Utilisez ceci à l’intérieur de votre événement de chat :

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

if player is on slowmode:
    stop
```

`chat is frozen` indique le gel global du chat, et `player is on slowmode` indique le délai de mode lent par joueur. Les deux envoient la raison au joueur en effet de bord, alors utilisez-les là où vous comptez appliquer, et non simplement pour lire l’état.

Pour vérifier la sourdine personnelle d’un joueur :

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

`player is muted` lit l’état de sourdine active sans rien envoyer, alors associez-le à votre propre avis.

## Contrôler le verrouillage

Vous pouvez démarrer ou lever un verrouillage du serveur depuis un script :

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

end message lockdown
```

La raison est facultative ; l’omettre utilise une étiquette générique.

## Référence de la syntaxe Skript

```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` et `is on slowmode` envoient un avis au joueur lorsqu’ils correspondent, alors utilisez-les dans un gestionnaire de chat où vous comptez arrêter le message.

---

## Référence de l’API

L’API publique se trouve sous :

```text
teacommontea.api
```

Les classes principales pour l’application de la modération sont :

```java
VeriteModeration
VeriteLockdown
```

Les méthodes utiles comprennent :

```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()
```

Les méthodes de barrière (`muteGate`, `chatMuteGate`, `slowmodeGate`) décident à la fois d’arrêter le joueur et lui envoient la raison. Les méthodes de requête (`isMuted`, `activeMute`) ne font que lire l’état et n’envoient rien.

Pour la plupart des intégrations de chat personnalisé, appliquer les trois barrières dans l’ordre est tout ce dont vous avez besoin :

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

Verité s’occupe du reste.