# Riferimento dell'integrazione Skript

Con Verité e Skript entrambi installati, Verité registra automaticamente un addon Skript e la sua sintassi diventa disponibile senza alcuna configurazione. Ogni elemento delega alla stessa superficie pubblica `teacommontea.api` documentata nel [Riferimento dell'API per sviluppatori](page:developers/api), così uno script vede esattamente ciò che il plugin applica.

Questa pagina elenca ogni condizione, effetto, espressione, evento e valore di evento registrato, raggruppati per tipo, con il pattern effettivamente registrato per ciascuno. Le parti opzionali appaiono in `[parentesi quadre]` e le scelte in `(a|b)`, seguendo la grammatica dei pattern di Skript. Un `-` iniziale su un tipo (per esempio `%-player%`) segna quell'argomento come opzionale.

Due argomenti hanno guide dedicate che mostrano questi elementi in un gestore di chat funzionante:

- Filtrare il contenuto della chat: [Integrazione della chat personalizzata](page:developers/wiring).
- Applicare mute, slowmode e freeze: [Applicazione della moderazione personalizzata](page:developers/moderation-enforcement).

## Condizioni

### Mutato, bannato, invisibile, in captcha

Queste sono condizioni di proprietà del giocatore, quindi supportano la grammatica standard `is` / `is not` di Skript e i bersagli plurali.

```vb
%players% (is|are) muted
%players% (is|are) banned by verite
%players% (is|are) vanished in verite
%players% (is|are) in a captcha
```

| Radice del pattern | Significato | Supportato da |
| --- | --- | --- |
| `muted` | Il giocatore ha un mute Verité attivo. Lettura pura, non invia nulla. | `VeriteModeration.isMuted` |
| `banned by verite` | Il giocatore ha un ban Verité attivo. | `VeriteModeration.isBanned` |
| `vanished in verite` | Il giocatore è invisibile tramite il vanish dello staff. | `VeriteVanish.isVanished` |
| `in a captcha` | Il giocatore sta attualmente risolvendo una sfida captcha. | `VeriteCaptcha.isActive` |

```vb
on chat:
    if player is in a captcha:
        cancel event
```

### Freeze della chat e slowmode

```vb
chat is frozen [for %-player%]
%player% is rate limited
%player% is on slowmode
```

`is rate limited` e `is on slowmode` sono due formulazioni dello stesso controllo dello slowmode. Tutte e tre si mappano ai gate di moderazione e inviano al giocatore un avviso come effetto collaterale, quindi usale in un gestore di chat dove intendi fermare il messaggio, non solo per leggere lo stato. `chat is frozen` si mappa a `VeriteModeration.chatMuteGate`; le formulazioni dello slowmode si mappano a `VeriteModeration.slowmodeGate`.

```vb
on chat:
    if chat is frozen for player:
        cancel event
    else if player is on slowmode:
        cancel event
```

### Testo bloccato dal filtro

```vb
%string% (was|is|are) blocked [for %-player%]
%string% (wasn't|was not|isn't|is not|aren't|are not) blocked [for %-player%]
```

Senza un giocatore è una classificazione pura che non registra nulla, sicura per scansionare cartelli, titoli di libri o rinomine all'incudine. Con `for %player%` registra anche la corrispondenza a carico di quel giocatore, corrispondendo al filtraggio della chat in tempo reale. Questo riporta solo se il testo è bloccato; usa l'espressione del risultato del filtro sottostante per distinguere le parolacce dall'autolesionismo o dall'abuso. Supportato da `VeriteFilter`. Vedi [Integrazione della chat personalizzata](page:developers/wiring).

### Punizione emessa o rimossa

Utilizzabile all'interno dell'evento `verite punishment` per distinguere un'emissione da una rimozione.

```vb
[the] verite punishment was removed
[the] verite punishment was (not removed|issued)
```

Legge il flag di rimozione dall'evento corrente. Al di fuori dell'evento è sempre false.

## Effetti

### Emettere una punizione

```vb
verite ban %player% [for %-timespan%] [(with reason|for) %-string%] [by %-player%] [silent:silently]
verite mute %player% [for %-timespan%] [(with reason|for) %-string%] [by %-player%] [silent:silently]
verite kick %player% [(with reason|for) %-string%] [by %-player%] [silent:silently]
verite warn %player% [(with reason|for) %-string%] [by %-player%] [silent:silently]
```

Un timespan rende un ban o un mute temporaneo; ometterlo lo rende permanente. Kick e warn non accettano un timespan. `by %player%` imposta l'esecutore; se omesso, la punizione viene emessa come console. Il `silently` finale imposta il flag silenzioso così che la punizione non venga trasmessa. Il bersaglio deve essere un giocatore online, poiché l'effetto ne risolve l'uuid e il nome. Supportato da `VeriteModeration.ban` / `mute` / `kick` / `warn`.

```vb
verite ban player for 7 days with reason "spam" by {_staff} silently
verite warn player for "first offence"
```

### Revocare una punizione

```vb
verite unban %player% [(with reason|for) %-string%] [by %-player%]
verite unmute %player% [(with reason|for) %-string%] [by %-player%]
verite unwarn %player% [(with reason|for) %-string%] [by %-player%]
```

`by %player%` registra chi l'ha revocata; se omesso, viene registrata come console. Il bersaglio deve essere online. Supportato da `VeriteModeration.unban` / `unmute` / `unwarn`.

### Scansionare il testo e registrare la corrispondenza

```vb
check %string% for %player%
```

Fa passare un messaggio attraverso il filtro e registra qualsiasi corrispondenza a carico del giocatore, esattamente come fa il filtraggio della chat in tempo reale, senza restituire il verdetto. Questa è la controparte fire-and-forget della condizione blocked e dell'espressione del risultato del filtro. Supportato da `VeriteFilter.check`.

### Emettere una sfida captcha

```vb
challenge %player% with [a] captcha [(with reason|for|from) %-string%]
challenge %player% with [a] detailed captcha [(with reason|for|from) %-string%]
```

Avvia immediatamente una sfida standard o dettagliata, contrassegnata con un'etichetta di origine opzionale che registra perché è stata aperta. L'etichetta è predefinita su un valore generico se omessa. Supportato da `VeriteCaptcha.challengeStandard` / `challengeDetailed`.

### Blocco del server

```vb
begin message lockdown [(with reason|for) %-string%]
end message lockdown
```

Sigilla il server dietro un blocco con un motivo opzionale, oppure lo revoca. Il motivo è predefinito su un'etichetta generica. Supportato da `VeriteLockdown.begin` / `end`. Vedi [Applicazione della moderazione personalizzata](page:developers/moderation-enforcement).

## Espressioni

### Risultato del filtro di un messaggio

```vb
filter [the] result of %string% [for %-player%]
```

Restituisce la classificazione del filtro come stringa in minuscolo: `clean`, `block`, `profanity`, `self_harm` o `abuse`. Questa è l'unica sintassi del filtro che preserva la distinzione tra normale contenuto bloccato e un interlocutore che potrebbe essere in crisi o essere danneggiato, quindi indirizza `self_harm` e `abuse` verso una risposta di supporto anziché una punizione. Senza un giocatore non registra nulla; con `for %player%` registra anche la corrispondenza. Supportato da `VeriteFilter.check` e `FilterResult`.

```vb
set {_result} to filter the result of {_msg} for player
if {_result} is "self_harm" or {_result} is "abuse":
    # handle with care, do not punish
    stop
if {_result} is not "clean":
    send block message to player
    stop
```

### Messaggio di blocco del filtro

```vb
block message
```

Restituisce il messaggio configurato mostrato quando un messaggio di chat viene bloccato. Supportato da `VeriteFilter.blockMessage`.

### Conteggio delle segnalazioni del filtro

```vb
[get] message flags (for|of) %player%
```

Restituisce quante volte il filtro ha segnalato un giocatore. Restituisce 0 per un giocatore senza record. Supportato da `VeriteFilter.count`.

### Dettagli del ban o del mute attivo

```vb
[get] [verite] ban status of %player% [reason:with reason]
[get] [verite] mute status of %player% [reason:with reason]
```

Senza `with reason` l'espressione restituisce il tempo rimanente in millisecondi, oppure `-1` per una punizione permanente. Con `with reason` restituisce il testo del motivo della punizione. Non restituisce nulla quando non c'è una punizione attiva di quel tipo. Supportato da `VeriteModeration.activeBan` / `activeMute`.

```vb
set {_left} to verite ban status of player
set {_why} to verite ban status of player with reason
```

### Campi di un valore di punizione

```vb
[get] punishment type of %veritepunishment%
[get] punishment reason of %veritepunishment%
[get] punishment target uuid of %veritepunishment%
[get] punishment target ip of %veritepunishment%
[get] punishment executor name of %veritepunishment%
[get] punishment removed by name of %veritepunishment%
[get] punishment removal reason of %veritepunishment%
[get] punishment length of %veritepunishment%
```

Legge un campo da un valore di punizione Verité, particolarmente utile all'interno dell'evento `verite punishment`. `type` è il tipo di punizione in minuscolo (`ban`, `mute`, `warning`, `kick`). `target uuid` è l'uuid del giocatore interessato come stringa, oppure nulla per una punizione con scope ip. `length` è la durata totale in millisecondi, oppure `-1` per una punizione permanente. Supportato dagli accessori pubblici di `Punishment`.

### Stato di vanish

Una proprietà booleana impostabile.

```vb
[the] vanish state of %players%
%players%'s vanish state
```

La lettura restituisce se il giocatore è invisibile. Impostare a `true` lo rende invisibile, `false` lo rende visibile. È supportata solo la modalità di modifica set. Supportato da `VeriteVanish.isVanished` / `vanish` / `unvanish`.

```vb
set vanish state of player to true
```

### Ricerche di nomi e uuid noti

```vb
[get] [verite] name of %player%
[get] [verite] uuid of %string%
```

`name of` restituisce l'ultimo nome utente noto che Verité ha registrato per un giocatore. `uuid of` risolve un nome utente nell'uuid che Verité ha registrato per ultimo per esso (come stringa), il che funziona per nomi offline o mai stati online nella directory di Verité. Entrambi non restituiscono nulla quando sconosciuti. Supportato da `VeritePlayerData.nameOf` / `uuidByName`.

### Paese GeoIP

```vb
[get] country of %string%
```

Restituisce il nome del paese che Verité risolve per una stringa ip, oppure nulla quando l'ip non può essere risolto, il database non è disponibile o l'indirizzo è privato. Supportato da `VeriteGeoIp.country`.

### Fancy time

```vb
[get] fancy time of %number%
```

Formatta un conteggio in millisecondi come durata leggibile dall'uomo nello stile di Verité, corrispondente al modo in cui il plugin descrive le durate delle punizioni e i tempi rimanenti. Supportato da `VeriteFormat.fancyTime`.

## Evento

Verité registra un evento Bukkit così che gli script possano reagire alle punizioni.

```vb
on verite punishment:
```

L'evento si attiva quando una punizione viene emessa e quando una viene revocata, perdonata o scaduta. Usa la condizione `verite punishment was removed` / `was issued` per distinguere le due, e le espressioni dei campi della punizione per leggere il record.

```vb
on verite punishment:
    if the verite punishment was issued:
        broadcast "%punishment executor name of event-punishment% punished someone"
```

### Valori di evento

All'interno dell'evento `verite punishment`, la punizione è esposta come valore di evento.

| Valore di evento | Tipo | Significato |
| --- | --- | --- |
| `event-punishment` | Verite Punishment | La punizione che è stata emessa o revocata. |

Il tipo `Verite Punishment` è registrato sotto il pattern `(verite ?)?punishments?`, quindi sia `punishment` sia `verite punishment` lo nominano. Leggi i suoi campi con le espressioni dei campi della punizione sopra.
