# Integração de chat personalizado Normalmente, o Verité filtra as mensagens automaticamente. No entanto, alguns plugins de chat intercetam o evento de chat normal do Minecraft e tratam do envio das mensagens por conta própria. Se o seu plugin fizer isso, o Verité poderá nunca receber a mensagem original para a filtrar. Nesse caso, deverá passar a mensagem pelo Verité antes de o seu plugin a enviar. > **Só precisa deste guia se o seu plugin tratar ou substituir o chat normal do Minecraft.** Os servidores que utilizam o chat padrão não precisam de qualquer configuração adicional. ## Integração com Java O Verité disponibiliza uma pequena API pública especificamente para integrações como sistemas de chat personalizados. ### 1. Adicione o Verité como dependência opcional Adicione o Verité ao seu `plugin.yml`: ```yaml softdepend: - Verite ``` A utilização de uma dependência opcional garante que o Verité é carregado antes da sua integração quando estiver instalado, sem o tornar obrigatório para que o seu plugin possa iniciar. ### 2. Verifique se a API está disponível Se o Verité for opcional, verifique se a API está disponível antes de a utilizar: ```java private static final boolean VERITE_AVAILABLE; static { boolean available; try { Class.forName("teacommontea.api.VeriteFilter"); available = true; } catch (ClassNotFoundException ignored) { available = false; } VERITE_AVAILABLE = available; } ``` Desta forma, a sua integração pode simplesmente não fazer nada quando o Verité não estiver instalado. ### 3. Filtre a mensagem Antes de o seu sistema de chat personalizado enviar uma mensagem, passe-a pelo `VeriteFilter`: ```java if (VERITE_AVAILABLE) { FilterResult result = VeriteFilter.check( player.getUniqueId(), message ); if (result.blocks()) { player.sendMessage(VeriteFilter.blockMessage()); return; } } ``` É tudo o que é necessário para uma integração básica. `check()` passa a mensagem pelo filtro do Verité e regista a sinalização associada ao jogador. Se `.blocks()` devolver `true`, o seu sistema de chat deverá impedir o envio da mensagem. ### Utilizar a categoria do filtro Por vezes, poderá querer saber **por que motivo** o Verité detetou uma mensagem: ```java FilterResult result = VeriteFilter.check( player.getUniqueId(), message ); switch (result) { case CLEAN -> { // Enviar normalmente } case SELF_HARM, ABUSE -> { // Tratar de forma adequada } default -> { // Conteúdo bloqueado comum } } ``` Os resultados possíveis são: * `CLEAN` * `BLOCK` * `PROFANITY` * `SELF_HARM` * `ABUSE` Qualquer resultado exceto `CLEAN` faz com que `.blocks()` devolva `true`. > **Importante:** `SELF_HARM` e `ABUSE` existem para permitir que estas mensagens sejam tratadas de forma diferente das violações comuns das regras. Recomendamos que não sejam automaticamente tratadas como infrações de chat passíveis de punição. ### Detetar mensagens repetidas Se o seu sistema de chat precisar de distinguir conteúdo filtrado da deteção de mensagens repetidas, utilize a sobrecarga com deteção de repetição: ```java FilterOutcome outcome = VeriteFilter.check( player.getUniqueId(), message, true ); if (outcome.blocks()) { if (outcome.repeat()) { player.sendMessage(VeriteFilter.repeatMessage()); } else { player.sendMessage(VeriteFilter.blockMessage()); } return; } ``` `outcome.category()` fornece a categoria normal do filtro, enquanto `outcome.repeat()` indica se a mensagem foi bloqueada por ser repetida. ## Filtrar outros conteúdos dos utilizadores A API não está limitada ao chat. Se o seu plugin aceitar conteúdo escrito pelos utilizadores, como alcunhas, prefixos, etiquetas de equipa ou campos semelhantes, pode passá-lo pelo mesmo filtro: ```java if (VeriteFilter.check(player.getUniqueId(), nickname).blocks()) { // Rejeitar a alcunha } ``` Para texto que não pertença a um jogador específico, utilize `VeriteFilter.ANONYMOUS`: ```java FilterResult result = VeriteFilter.check( VeriteFilter.ANONYMOUS, text ); ``` As verificações anónimas continuam a devolver a categoria de filtro adequada, mas não adicionam uma sinalização ao registo de nenhum jogador. --- # Utilizar o Verité com Skript Se o seu sistema de chat personalizado estiver escrito em Skript, não precisa de interagir com a API Java. Com **Verité e Skript instalados**, a sintaxe de filtragem do Verité fica automaticamente disponível. ## Filtrar chat personalizado Se o seu script já tratar do envio das mensagens de chat, verifique a mensagem antes de a enviar: ```vb if {_msg} is blocked for player: send block message to player stop ``` Incluir `for player` indica ao Verité quem enviou a mensagem e regista a sinalização associada a esse jogador. Sem um jogador: ```vb if {_text} is blocked: # Rejeitar o texto ``` O Verité efetua uma verificação pura do filtro sem registar uma sinalização. Isto é útil para elementos como nomes, etiquetas, placas ou outro texto que não deva contar contra um jogador específico. ## Verificar por que motivo uma mensagem foi bloqueada Para maior controlo, obtenha o resultado do filtro: ```vb set {_result} to filter result of {_msg} for player if {_result} is "self_harm": # Tratar separadamente stop if {_result} is "abuse": # Tratar separadamente stop if {_result} is not "clean": send block message to player stop ``` O resultado será um dos seguintes: `clean`, `block`, `profanity`, `self_harm` ou `abuse` > **Importante:** Considere tratar `self_harm` e `abuse` separadamente das violações comuns de moderação, em vez de punir automaticamente o jogador. ## Verificar o número de sinalizações de um jogador Também pode obter o número de mensagens que o Verité sinalizou para um jogador: ```vb set {_flags} to message flags of player ``` Isto pode ser utilizado pelo seu próprio sistema de moderação caso pretenda comportamentos diferentes para violações repetidas. ## Referência da sintaxe do Skript ```vb %string% is blocked [for %-player%] %string% is not blocked [for %-player%] filter result of %string% [for %-player%] block message message flags of %player% ``` O jogador opcional é importante: **Com um jogador:** o resultado do filtro é registado para esse jogador. **Sem um jogador:** o Verité apenas verifica o texto e não regista uma sinalização. --- ## Referência da API A API pública encontra-se em: ```text teacommontea.api ``` A classe principal para integrações de chat é: ```java VeriteFilter ``` Os métodos úteis incluem: ```java VeriteFilter.check(UUID player, String message) VeriteFilter.check(UUID player, String message, boolean repeatAware) VeriteFilter.count(UUID player) VeriteFilter.blockMessage() VeriteFilter.repeatMessage() VeriteFilter.selfHarmMessage() VeriteFilter.blockNotice(FilterResult result, String message) ``` `VeriteFilter.ANONYMOUS` pode ser utilizado ao filtrar texto que não esteja associado a um jogador. O Verité também disponibiliza os seus utilitários de normalização para integrações que deles necessitem, incluindo normalização de acentos, remoção de entidades, redução de caracteres repetidos, fingerprinting e remoção de caracteres nas extremidades. Estas funções são thread-safe e, de modo geral, **não precisam de ser chamadas manualmente** antes de utilizar `check()`. Para a maioria das integrações de chat personalizado, tudo o que precisa é: ```java if (VeriteFilter.check(player.getUniqueId(), message).blocks()) { // Não enviar a mensagem } ``` O Verité trata do resto.