# Applicazione della moderazione personalizzata Verité normalmente applica mute, slowmode e freeze della chat automaticamente. Tuttavia, alcuni plugin di chat intercettano il normale evento di chat di Minecraft e gestiscono autonomamente l'invio dei messaggi. Se il tuo plugin funziona in questo modo, Verité potrebbe non vedere mai il messaggio, quindi i suoi controlli di mute e slowmode non vengono mai eseguiti. In tal caso, dovresti interrogare Verité sul mittente prima che il tuo plugin invii il messaggio, e fermare tu stesso il messaggio quando Verité lo indica. > **Questa guida è necessaria solo se il tuo plugin gestisce o sostituisce la normale chat di Minecraft.** I server che utilizzano la chat standard non richiedono alcuna configurazione aggiuntiva. Questa è la controparte di moderazione della guida [Integrazione della chat personalizzata](page:developers/wiring). La guida sul filtro controlla il contenuto dei messaggi; questa guida applica mute, slowmode e freeze della chat. ## Integrazione Java La superficie di moderazione risiede in `teacommontea.api.VeriteModeration`. Ogni metodo restituisce un valore sicuro quando il modulo di moderazione è disabilitato, così un chiamante non deve mai gestirlo come caso speciale. ### 1. Aggiungi Verité come dipendenza opzionale Aggiungi Verité al tuo `plugin.yml`: ```yaml softdepend: - Verite ``` L'utilizzo di una dipendenza opzionale garantisce che Verité venga caricato prima della tua integrazione quando è installato, senza renderlo obbligatorio per l'avvio del tuo plugin. ### 2. Verifica se l'API è disponibile Se Verité è opzionale, verifica la disponibilità dell'API prima di utilizzarla: ```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; } ``` In questo modo, la tua integrazione può semplicemente non fare nulla quando Verité non è installato. ### 3. Applica i mute Prima che il tuo sistema di chat personalizzato invii un messaggio, chiedi a Verité se il mittente è mutato: ```java if (VERITE_AVAILABLE) { if (VeriteModeration.muteGate(player)) { return; } } ``` `muteGate` restituisce `true` quando il giocatore è mutato, e mentre lo fa gli invia l'avviso di mute per te. Quando restituisce `true`, ferma il messaggio. Se preferisci costruire tu stesso l'avviso, leggi invece il mute attivo: ```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` è un controllo puro e non invia nulla. `activeMute` restituisce il mute come `Punishment`, da cui puoi leggere `reason()`, `permanent()` e `remaining(now)`. ### 4. Applica slowmode e freeze della chat Verité ha due freni della chat a livello di server: un freeze globale della chat impostato dallo staff e uno slowmode per giocatore. Applica entrambi allo stesso modo in cui applichi i mute: ```java if (VeriteModeration.chatMuteGate(player)) { return; } if (VeriteModeration.slowmodeGate(player)) { return; } ``` Ciascuno restituisce `true` quando il giocatore deve essere fermato, e gli invia il motivo (l'avviso di chat bloccata o l'attesa rimanente dello slowmode) mentre lo fa. Controlla entrambi prima di inviare. ### Mettere tutto insieme Un gestore di chat completo che riproduce l'applicazione di Verité si presenta così: ```java if (VERITE_AVAILABLE) { if (VeriteModeration.muteGate(player)) { return; } if (VeriteModeration.chatMuteGate(player)) { return; } if (VeriteModeration.slowmodeGate(player)) { return; } } sendMessage(player, message); ``` ## Reagire alle punizioni Se il tuo plugin ha bisogno di sapere quando una punizione viene emessa o revocata (per il logging, le notifiche o la sincronizzazione di un altro sistema), registra un listener: ```java VeriteModeration.registerListener(new ModerationListener() { @Override public void entryAdded(Punishment punishment) { } @Override public void entryRemoved(Punishment punishment) { } }); ``` `entryAdded` si attiva quando una punizione viene emessa, `entryRemoved` quando una viene revocata. Ogni `Punishment` porta con sé il bersaglio, il tipo, il motivo, la durata, l'esecutore e se era silenziosa. Chiama `unregisterListener` con lo stesso listener per smettere di ricevere eventi. ## Blocco del server Verité può sigillare il server dietro un blocco. Il tuo plugin può leggere lo stato del blocco o guidarlo tramite `teacommontea.api.VeriteLockdown`: ```java if (VeriteLockdown.active()) { String reason = VeriteLockdown.reason(); } VeriteLockdown.begin("Maintenance"); VeriteLockdown.end(); ``` `active()` riporta se un blocco è in vigore, `reason()` restituisce il motivo attuale, `begin(reason)` ne avvia uno ed `end()` lo rimuove. Usa `active()` per condizionare il tuo comportamento durante un blocco, oppure `begin` ed `end` per guidare il blocco dai tuoi comandi. --- # Utilizzare Verité con Skript Se il tuo sistema di chat personalizzato è scritto in Skript, non è necessario interagire con l'API Java. Con **Verité e Skript installati**, la sintassi di moderazione di Verité è disponibile automaticamente. ## Applicare mute, slowmode e freeze Se il tuo script gestisce già autonomamente l'invio dei messaggi di chat, controlla il mittente prima di inviare. Usa questi all'interno del tuo evento di chat: ```vb if chat is frozen for player: stop if player is on slowmode: stop ``` `chat is frozen` riporta il freeze globale della chat, e `player is on slowmode` riporta il cooldown dello slowmode per giocatore. Entrambi inviano al giocatore il motivo come effetto collaterale, quindi usali dove intendi applicare la regola, non solo per leggere lo stato. Per controllare il mute personale di un giocatore: ```vb if player is muted: stop ``` `player is muted` legge lo stato del mute attivo senza inviare nulla, quindi abbinalo al tuo avviso. ## Controllare il blocco Puoi avviare o revocare un blocco del server da uno script: ```vb begin message lockdown with reason "Maintenance" end message lockdown ``` Il motivo è opzionale; ometterlo utilizza un'etichetta generica. ## Riferimento della sintassi 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` e `is on slowmode` inviano al giocatore un avviso quando corrispondono, quindi usali in un gestore di chat dove intendi fermare il messaggio. --- ## Riferimento API L'API pubblica si trova nel package: ```text teacommontea.api ``` Le classi principali per l'applicazione della moderazione sono: ```java VeriteModeration VeriteLockdown ``` I metodi utili includono: ```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() ``` I metodi gate (`muteGate`, `chatMuteGate`, `slowmodeGate`) decidono sia se fermare il giocatore sia gli inviano il motivo. I metodi di interrogazione (`isMuted`, `activeMute`) leggono solo lo stato e non inviano nulla. Per la maggior parte delle integrazioni di chat personalizzate, applicare i tre gate in ordine è tutto ciò che serve: ```java if (VeriteModeration.muteGate(player) || VeriteModeration.chatMuteGate(player) || VeriteModeration.slowmodeGate(player)) { return; } ``` Verité si occupa del resto.