Table of content

DiceParser: che cos'è?

DiceParser è un componente software dedicato al lancio dei dadi tramite semplici comandi. È disponibile per diverse piattaforme, come:
come bot discord, è incluso in Rolisteam, su X, ecc.

Informazioni sugli esempi in questa documentazione

Per chiarezza, tutti gli esempi in questa documentazione non mostrano il prefisso di avvio. Quando avvii il comando dei dadi, ricorda di aggiungere sempre il prefisso adatto: Rolisteam, discord, IRC… Se non lo sai, prova !. Il prefisso consente al sistema di identificare il tuo comando.

Come lanciare un dado

È davvero semplice. You have to call:

!1d6

Il primo numero è il conteggio dei dadi da lanciare. Il secondo numero è il conteggio delle facce.

Esempi

!1d6

Lancio di un dado con sei facce.

!1d10

Lancio di un dado con dieci facce.

!5d10

Lancio di cinque dadi con dieci facce.

!777d6

Lancio di 777 dadi con sei facce.

Grazie a varie operazioni e opzioni, puoi regolare il comando di lancio: vedi l'elenco degli operatori.

Lancio di dadi con intervallo

!4d[-1..1]

Lancio di quattro dadi con valore tra -1 e 1 (sistema Fudge/Fate).

!3d[0..9]

Lancio di tre dadi con dieci facce con partenza da 0.

!3d[-20..-9]

Lancio di tre dadi, con valori tra -20 e -9.

Istruzioni

L'aggiunta (o qualsiasi altra operazione aritmetica) di risultati da due o più tipi di dado è semplice:

!1d10+1d8

Per visualizzare tutti i risultati senza eseguire operazioni su quei risultati. Usa ; per contrassegnare le varie istruzioni.

!1d10;1d6 # 2 instructions

oppure

!5d6;1d10;4d100;3d20  # 4 instructions

Come in questo caso, potrai eseguire dei calcoli se il risultato della prima istruzione rispetta una condizione, e così via. Per esempio, se vuoi lanciare per attaccare, poi la seconda istruzione saranno i danni. Nella terza istruzione puoi confrontare il risultato dell'attacco, e se l'attacco è valido. Puoi visualizzare:

vedi altro

Unire

È possibile unire ciascuna istruzione in una più grande. L'operatore merge è dedicato a questo. Utile quando hai necessità di gestire tutti i risultati dei dadi come un unico risultato.

Per esempio, se devi mantenere i dadi più alti tra d6 e d8.

!d6;d8mk1

Ulteriori dettagli sull'operatore k nell'elenco degli operatori.

Calcolo tra istruzioni

Grazie al sistema di variabili, è possibile fare riferimento al risultato di un'istruzione specifica.

  • Per fare riferimento alla prima istruzione: $1
  • Per fare riferimento alla seconda istruzione: $2
  • Per fare riferimento alla terza istruzione: $3 e via discorrendo… il numero delle istruzioni è illimitato.
!8d10;$1c[>6];$1c1;$2-$3
  • La prima istruzione lancia otto dadi (da dieci facce)
  • La seconda istruzione conta quanti dadi sono più alti di 6.
  • La terza istruzione conta quanti dadi sono uguali a 1.
  • La quarta istruzione sottrae il risultato della terza istruzione dal risultato delle seconda.

Elenco degli operatori

  • k: Keep (tieni)
  • K: Explode and keep (esplodi e tieni)
  • kl: Keep lower (tieni i più bassi)
  • s: Sort (ordina)
  • c: Count (conta)
  • r: Reroll (rilancia)
  • R: Reroll until (rilancia fino a)
  • e: Explode (esplodi)
  • a: Reroll and add (rilancio e aggiungi)
  • @: Backward Jump (salto indietro)
  • p: Paint dice (disegna dadi)
  • m: Merge (unisci)
  • i: if (se)
  • ;: Next instruction (istruzione successiva)
  • g: Group (gruppo)
  • b: bind (lega)
  • #: Commento

Keep

!kX

L'opzione ordina l'elenco dei dadi risultante e seleziona i dadi X più alti.

Explode e Keep

!KX

I dadi esplodono se il loro valore è il massimo del dado, l'opzione ordina l'elenco dei dadi risultante, quindi seleziona i dadi X più alti.

Esempi

!6d10K4

Lancio di sei dadi da 10 facce, ogni 10 esplode. Dunque il valore dei dadi esplosi è maggiore di 10. Risultato: 40 dettagli: 23 [10,10,3],9,5,3,1,1

Un altro modo di scrivere il comando è:

!6d10e10k4

Questo modo di permette di cambiare la soglia di esplosione.

Per calcolare il numero che vuoi mantenere, l'operatore k gestisce la variabile. Non puoi inserire direttamente il calcolo dietro k ma puoi fare riferimento a un calcolo precedente.

# Good
!5-3;10d10k$1 

# BAD
!10d10k5-3

# BAD
!10d10k(5-3)

Keep Lower (tieni i dadi più bassi)

klX

L'opzione ordina l'elenco dei dadi risultante, quindi seleziona i dadi X più bassi.

Sort (ordina)

!3D10s

L'elenco dei dadi è ordinato in modo decrescente.

!10d6sl

Lancia sei dadi a 6 facce, quindi i dadi sono ordinati in modo crescente.

Count (conta)

!3D10c[Validator]

Conta quanti dadi rispettano la condizione e ne visualizza il numero (per maggiori dettagli sulla sintassi, vedi il Validatore).

Reroll (rilancia)

!3D10r[Validator]

Rilancia il dado se il valore precedente corrisponde al validatore (per maggiori dettagli sulla sintassi, vedi il Validatore).

Reroll until (rilancia fino a)

!3D10R[Validator]

Come "Reroll", ma continua a lanciare i dadi fino a che la condizione è «false».

Explode (esplodi)

!3D10e[Validator]

Esplode se il valore corrisponde al validatore (per maggiori dettagli sulla sintassi, vedi il Validatore).

!3D10e(3)[Validator]

Il nodo Explode potrà avere un limite di quante volte il dado esploderà.

!3D10e(1d10)[Validator]

Il limite è un'espressione.

Esempi

!3D10e10

Finché il valore del dado è uguale a 10, il dado viene rilanciato e il risultato aggiunto al valore precedente.

Risultato: 49 dettagli: 8, 12 [10,2], 29 [10,10,9]

!3D10e[>8]

Finché il valore del dado è maggiore di 8, il dado viene rilanciato e il risultato aggiunto al valore precedente.

Risultato: 35 dettagli: 3, 27 [9,10,8], 5

Add (aggiungi)

!3D10a[Validator]

Ritira il dado se il suo valore soddisfa il validatore e aggiunge il nuovo valore al precedente. Questa operazione viene eseguita una sola volta.

Occurrence (occorrenza)

!10d10o

Conta e ordina le occorrenze di ogni valore. Risultato: 3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]

!10d10o2,7

Conta e ordina le occorrenze quando compaiono almeno due volte e il valore è 7 o superiore. Risultato: 2x8 - [1,2,3,5,6,7,8,8,9,10]

!10d10o2[<6]

Conta e ordina le occorrenze quando compaiono almeno due volte e il valore deve soddisfare il validatore (qui minore di 6). Risultato: 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Errori

!10d10o[<6]

Questo comando genera un avviso. L'operatore occurrence può avere 0 o 2 parametri. Un solo validatore non è ancora supportato.

Backward Jump (salto all'indietro)

Questo operatore serve ad applicare l'operatore successivo al penultimo risultato. Ad esempio:

!8D10c[>=7]+@c[=10]

c[=10] in questo comando conta il numero di 10 nel risultato di 8D10; se rimuovi @, proverà a contare il numero di 10 nel risultato di c[>=7]. Il risultato di c[>=7] è un numero scalare (1 o 2 ... massimo 8); non è una lista di dadi.

Paint (colora)

!8D10p[1:blue]

Colora di blu il primo dado dell'elenco.

!8d10p[2:blue]

Colora di blu i primi due dadi dell'elenco.

https://gist.github.com/obiwankennedy/62101383d411e55d205e44df78aa5299

La quantità di colori dipende dall'applicazione client di DiceParser.

  • Con Rolisteam puoi configurare qualsiasi nome colore di Qt oppure specificare il codice esadecimale del colore: #ff28AC.
  • L'applicazione CLI supporta pochi colori: black, white, blue, red, black, green, yellow.

Filter (filtro)

L'operatore filter permette di ignorare alcuni risultati dei dadi in base a un validatore.

!4d6f[!=6]

Risultato:

totale: 11 - dettagli[5 2 6 4]

il 6 viene ignorato.

Unire

L'operatore merge viene utilizzato per raggruppare diversi lanci di dadi di tipi differenti in un unico risultato, sul quale puoi poi applicare qualsiasi operatore.

!1d6;1d8mk1

Questo comando unisce i risultati del d6 e del d8. Successivamente applica a entrambi l'operatore k per mantenere il risultato migliore. Attenzione: questo operatore unisce l'elenco delle istruzioni. I riferimenti alle istruzioni (come $1, ecc.) non funzioneranno più dopo l'operatore merge.

Spread (diffondi)

Trasforma i dadi esplosi in nuovi dadi. L'operatore viene attivato con y.

!4d6e6y6k3

Primo risultato: 10 [6, 4], 3, 3, 2
Risultato dopo la diffusione: 6, 4, 3, 2
Risultato finale: 6+4+3 = 13

All the same (tutti uguali)

Questo operatore è temporaneo. È stato creato per rispondere a problemi del sistema Tunnels and Trolls. Per questo motivo il simbolo dell'operatore è t. I dadi esplodono quando tutti hanno lo stesso valore.

!2d6t

> # Explode twice because 2,1
Result: 12 - details:[2d6t (5 [2,1,2] 7 [2,1,4])]

> # Nothing happened
Result: 10 - details:[2d6t (4 6)]

Unique (unico)

Trasforma i dadi esplosi in nuovi dadi.

!4d6e6u

Risultato: 6 4 3 3 2 Risultato finale: 6+4+3 = 13

Value list (elenco valori)

Crea un elenco personalizzato di valori e applica qualsiasi operatore sui dadi.

![10,25,43,8]k1

Ottieni il punteggio più alto da diverse istruzioni:

!1d10;2d6+9;1d20;[$1,$2,$3,$4]k1

Ogni valore viene trasformato in un dado.

Bind (associa)

Bind funziona esattamente come merge, ma mantiene intatta la matrice delle delle istruzioni.

!2d8;2d12b;$2k2;$2k2kl1;"your total is $3 with lowest: $4"

Lancia due dadi a 8 facce e due dadi a 12 facce, quindi collega i risultati. Usando il risultato finale, manteniamo i due dadi più alti e poi isoliamo il più basso tra questi due. Alla fine visualizziamo il risultato all'interno di una frase.

If (se)

L'operatore if permette di eseguire qualcosa se determinate condizioni sono vere (true). L'operatore if ha due parametri obbligatori:

  • La condizione (vedi il validatore)
  • l'istruzione da eseguire quando è vera.

Ci sono anche due parametri opzionali

  • il metodo di confronto
  • l'istruzione da eseguire quando è falsa (false).

i*[]{}{}

  • *: il metodo di confronto
  • []: il validatore

Metodo di confronto

Ci sono quattro metodi diversi.

  • Su ogni elemento: la condizione viene testata su ogni dado della parte precedente del comando. [Metodo predefinito]
  • Su ogni valore ?: la condizione viene testata su ogni valore finale del dado della parte precedente del comando.
  • Su tutti *: tutti i dadi devono soddisfare la condizione per attivare l'istruzione true. Se non tutti la soddisfano, viene eseguita l'istruzione false.
  • Su uno qualsiasi .: almeno un dado deve soddisfare la condizione per attivare l'istruzione true. Se nessuno la soddisfa, viene eseguita l'istruzione false.
  • Su scalare :: la condizione viene valutata sul risultato scalare del tiro di dadi.

Esempi:

!1d6i[<4]{3}

Se il valore del dado è minore di 4, il valore diventa 3 (quindi 1, 2, 3 diventano 3).

!4d6e6i[=4]{-4}

Se il dado ha valore 4, viene rimosso. [Sistema Kuro]

!4d6i.[=6]{+1d6}

Se almeno un dado è uguale a 6, allora tira un altro d6 e aggiungilo al risultato.

!4d6i*[=6]{+1d6}

Se tutti i dadi sono uguali a 6, allora tira un altro d6 e aggiungilo al risultato.

!2d10i:[>15]{"Success"}{"Fail"}

Se la somma di due dadi è maggiore di 15, mostra "Success", altrimenti mostra "Fail".

!2d10i:[>15]{"Success %1 "}{"Fail %1"}

Come sopra, ma il risultato finale viene mostrato accanto a Success o Fail.

!2d10i:[>15]{"Success %1 [%2]"}{"Fail %1 [%2]"}

Come sopra, ma il risultato di ogni dado viene mostrato tra parentesi quadre.

Group (raggruppa)

Raggruppa i dadi, poi conta il numero di gruppi (sistema 7th Sea).

Risultato complesso

L'operatore group può prendere un parametro per attivare il risultato complesso. Questo risultato mostrerà ogni gruppo e gli eventuali valori rimasti. Per attivarlo è necessario aggiungere una s subito dopo la g. Vedi esempio sotto:

Esempio

!3d20g10

Questo tirerà tre dadi e proverà a raggrupparli in gruppi di dieci. Se ottieni 9 9 2, puoi creare solo un gruppo con valore maggiore o uguale a 10 ({9,2}, il secondo 9 viene "sprecato").

L'operatore g può riordinare i dadi per creare gruppi. Tirando 4d20g10, se ottieni 7 4 3 6, il risultato sarà 2 ({7,3} e {6,4}).

!5d10gs10

Il risultato finale sarà:

2 ({7,3}, {6,4} - [2])

{7,3} e {6,4} sono gruppi, e [2] è rimasto fuori.

Switch case (S)

L'operatore switch case permette di trasformare un valore numerico in testo. L'obiettivo è semplificare rispetto a più if. Come puoi immaginare, la sintassi è simile a if.

!1d100S[<50]{"Low"}[>=50]{"Low"}

Puoi anche aggiungere un'opzione predefinita.

!1d4S[=1]{"Low"}[=2]{"small"}[=3]{"medium"}{"big"}

Modalità esclusiva: questa modalità si attiva quando un ^ segue la S.

!1d100S^[<25]{"Low"}[<50]{"small"}[<75]{"medium"}[>=75]{"big"}

Comment (commento)

!2D6 # Sword attack

Mostra "Sword attack" (Attacco con spada) e il risultato dei due dadi. DiceParser ignora tutto dopo il #. L'intera parte è trattata come commento. Dunque DiceParser può rispondere alla domanda:

!1L[yes,no] # Am I evil ?

Am I evil? yes (Sono malvagio? Sì)

Transform (trasforma)

Trasforma i dadi secondo una condizione in un altro valore.

!5d10T[>5]{15}

Tira cinque dadi a 10 facce, poi sostituisci tutti i valori maggiori di 5 con 15 e gli altri con 0.

(6,9,7,5,2) => (15,15,15,5,2)

Questo operatore accetta più condizioni: T[=5]{15}[=6]{16}

(6,9,7,5,2) => (16,9,7,15,2)

Puoi anche aggiungere un'espressione finale per modificare i valori che non soddisfano una condizione: T[>5]{15}{0}

(6,9,7,5,2) => (15,15,15,0,0)

Funzioni

DiceParser fornisce funzioni per gestire le istruzioni. Alcune funzioni arriveranno presto (es: max, min). Permette di gestire più comandi assieme.

Repeat (ripeti)

!repeat(1d10,5)

Risultato:

2 - Details [2]
8 - Details [8]
3 - Details [3]
1 - Details [1]
10 - Details [10]

Fai attenzione, repeat funziona male con comandi a istruzioni multiple.

Floor (arrotonda per difetto)

  • 15/7 = 2,14286
  • Floor(15/7) = 2

Il comando:

15/7;**floor($1)**;ceil($1);round($1)  
result: 2.14286,**2**,3,2

Ceil (arrotonda per eccesso)

  • 15/7 = 2,14286
  • Ceil(15/7) = 3

Il comando:

15/7;floor($1);**ceil($1)**;round($1)  
result: 2.14286,2, **3** ,2

Round (arrotonda)

  • 15/7 = 2,14286
  • Round(15/7) = 2

Il comando:

15/7;floor($1);ceil($1);**round($1)**  
result: 2.14286,2,3, **2**

Il risultato

DiceParser offre funzioni per controllare il risultato dei comandi. L'istruzione finale deve essere un'istruzione di stringa. L'istruzione di stringa inizia con " e termina con with ".

Tiro:

"result"

Risultato: result

Puoi usare istruzioni stringa dentro l'operatore if:

1d6i:[>3]{"Success"}{"Fail"}

Risultato: Success o Fail

Permette una risposta rapida, ma a volte hai necessità di osservare i valori tirati. DiceParser può sostituire alcuni tag speciali per osservare i valori, il risultato del calcolo e qualsiasi altra cosa.

Scorciatoie

Esistono tre 3 tag di scorciatoia:

  • %1: ultimo risultato scalare di ogni istruzione.
  • %2: tutti i risultati dei dadi.
  • %3: ultimo risultato scalare dell'ultima istruzione.

Il risultato predefinito è %1 details[%2]. Mostra dunque l'ultimo risultato scalare di ciascuna istruzione e il risultato dei dadi.

%1 e %3 sono equivalenti quando è presente soltanto un'istruzione (no ;).

Sono davvero utili ma con molte istruzioni possono diventare complessi.

Risultato finale

È anche possibile riferirsi al valore finale di una specifica istruzione (il risultato deve essere un numero o una stringa):

  • Per fare riferimento alla prima istruzione: $1
  • Per fare riferimento alla seconda istruzione: $2
  • Per fare riferimento alla terza istruzione: $3

Non c'è limite al numero di istruzioni.

Stringa come risultato finale

Puoi riferirti a una parte del risultato stringa aggiungendo [x] dopo il riferimento. Vediamo un esempio per chiarire.

!2Lu[cats,dogs,rats,rabbits,bats,squirrels]

Il risultato predefinito appare così:

cats,bats

Ora vogliamo creare una frase con questo testo:

!2Lu[cats,dogs,rats,rabbits,bats,squirrels];"You love $1 and you are afraid of $1"

Poiché $1 si riferisce a "cats,bats", verrà mostrato:

You love cats,bats and you are afraid of cats,bats

Quindi non è molto utile. Per migliorarlo dobbiamo usare indici secondari.

!2Lu[cats,dogs,rats,rabbits,bats,squirrels];"You love $1[0] and you are afraid of $1[1]"

Ora abbiamo un risultato corretto.

You love cats and you are afraid of bats (Ti piacciono i gatti e hai paura dei pipistrelli)

Vediamo alcuni esempi:

!8d10;$1c[>6];$1c1;$2-$3

Il risultato predefinito mostra: 45,4,0,4 details[4,3,10,7,2,2,7,10]

!8d10;$1c[>6];$1c1;$2-$3i:[>0]{"%3 Success[%2]"}{i:[<0]{"Critical fail %3 [%2]"}{"Fail %3 [%2]"}}

Esempi di risultati:

  • 4 Success[4,3,10,7,2,2,7,10]
  • Fail 0 [10,3,1,1,2,2,7,5] (2 success - 2 fails = 0)
  • Critical fail -2 [1,3,1,1,2,2,7,5] (1 success - 3 fails = -2)

In questo esempio il fallimento critico (critical fail) si verifica quando ci sono più fallimenti che successi. Nell'esempio successivo, il fallimento critico si verifica quando non ci sono successi e c'è almeno un fallimento.

!8d10;$1c[>6];$1c1;$2-$3;$4i:[=0]{"Fail $4 [%2]"}{$4i:[>0]{"$2 Success[%2]"}{$2i:[=0]{"Critical Fail $4 [%2]"}{"Fail $4 [%2]"}}}

Un altro esempio per combinare stringa e risultato dadi.

!1d6+1;1L[gold coins,spell scrolls,weapons];"You found $1 $2"

You found 5 gold coins (Hai trovato cinque monete d'oro)

Risultato dei dadi

DiceParser fornisce tag per visualizzare il risultato del lancio dei dadi (e i singoli valori ottenuti da una specifica istruzione).

Per mostrare i valori di una istruzione, usa @ seguito dal numero dell'istruzione (es: @1)

!2d6;3d8;"Result $2 - d8:[@2] - d6:[@1]"

Il risultato:

Result 15 - d8:[7,4,4] - d6:[3,6]`

Nuova riga

Puoi mostrare il risultato su più righe. È davvero semplice:

!1d100;1d10;"Attack: $1\nDamage: $2"

Questo comando mostrerà:

Attack: 31

Damage (danno): 7

Aritmetica

DiceParser può calcolare operazioni aritmetiche di base come +, -, /, * e rispettare le priorità tra gli operatori e gestire le parentesi.

!8+8+8
Result: 24

!24-4
Result: 20

!(3+4)*2
Result: 14

!7/2
Result: 3.5

!15|6
Result: 2

!15/6
Result: 2.5

Tira due dadi e aggiungi 3 alla somma. Poi usa il risultato per tirare altri dadi: !(3+2D6)D10

Aritmetica e dadi

È possibile usare operazioni aritmetiche sui dadi. Fai attenzione che l'operazione predefinita per tradurre un elenco di dadi in scalare è la somma. Pertanto se tiri 3d6, il risultato sarà un elenco con tre valori {2, 5 ,1}. Cambiamo un po' il comando 3d6+4, viene risolto come questo: {2, 5 ,1} = 8; 8+4 = 12. Il risultato finale è 12.

  • !3d6+4 ⇾ tira tre dadi, somma e aggiunge 4:
  • !10D10-2 ⇾ tira dieci dadi, somma e sottrae 2
  • !87-1D20 ⇾ sottrae il risultato di un dado da 87
  • !(6-4)D10 ⇾ sottrae 4 da 6 e poi tira due dadi.
  • !1D10/2 ⇾ Divide per 2 il risultato di un dado.
  • !(2+2)**2 ⇾ Risultato: 16
  • !1d10**2 ⇾ Tira 1d10 e poi moltiplica il risultato per sé stesso.
  • !15|2 ⇾ Divisione intera di 15 per 2. Risultato: 7
  • !15/2 ⇾ Divisione di 15 per 2. Risultato: 7.5

Validatore

Esistono cinque tipi di validatore:

  • Scalare
  • Intervallo
  • Espressione logica (booleana)
  • Operazione di condizione
  • Composito

Qualsiasi operatore che richiede un validatore (come a,r,e,c) può usare quei tre tipi.

Scalare

Il valore scalare imposta il validatore sull'uguaglianza tra il valore del dado e il validatore.

!4d10e10

Questo comando significa: tira quattro dadi, ed essi esplodono su 10.

Intervallo

L'intervallo è definito da due limiti. Devi usare parentesi quadre e i due limiti sono separati da ...

!4d10c[8..10]
!1d[-1..8]

Condizione logica

Il comando conta quanti dadi hanno valori compresi tra >=8 e <=10.

!4d10c[>7]

Il comando conta quanti dadi sono sopra 7.

Operatore di confronto

DiceParser di Rolisteam ti permette di usare diversi operatori logici:

  • Uguale: =
  • Maggiore o uguale di: >=
  • Minore o uguale di: <=
  • Minore di: <
  • Maggiore di: >
  • Diverso: !=

Metodi di confronto

Come per l'operatore if, puoi specificare il metodo di confronto.

  • Su ogni elemento: la condizione viene testata su ogni dado della parte precedente del comando. [Metodo predefinito]
  • Su ogni valore ?: la condizione viene testata su ogni valore finale del dado della parte precedente del comando.
  • Su tutti *: tutti i dadi devono soddisfare la condizione per attivare l'istruzione true. Se non tutti la soddisfano, viene eseguita l'istruzione false.
  • Su uno qualsiasi .: almeno un dado deve soddisfare la condizione per attivare l'istruzione true. Se nessuno la soddisfa, viene eseguita l'istruzione false.
  • Su scalare :: la condizione viene valutata sul risultato scalare del tiro di dadi.
Esempi:
!1L[7,8,9]c[>6]

Questo comando restituisce 0 perché non è stato lanciato alcun dado, quindi il risultato di 1L[7,8,9] è un valore finale.

!1L[7,8,9]c[?>6]

Risultato: 1

!5d6e6sc[>=8]

Risultato:

0 dettagli: [8 [6,2] 2 1 1 1]

!5d6e6f[?>=16]

Risultato: poiché la somma finale è uguale a 11. È inferiore a 16, quindi il filtro elimina tutto.

0 dettagli: [2 4 1 3 1]

La somma finale è maggiore di 16, quindi l'intero risultato è accettato dall'operatore filter.

23 dettagli: [3 6 3 5 6]

!5d6e6sc[:>=8]

Risultato:

1 dettagli: [8 [6,2] 2 1 1 1]

Operazione di condizione

Questo validatore offre il modulo come operazione e una condizione booleana per convalidare il valore:

!4d10c[%2=0]

Conta quanti numeri pari sono stati tirati.

!4d10c[%2=1]

Conta quanti numeri dispari sono stati tirati.

modulo

Validatore composito

Il validatore può essere il risultato di più validatori.

!4d10c[>4&%2=0]

Conta tutti i dadi maggiori di 4 e pari [6,8,10].

Il validatore composito supporta tre operazioni logiche:

  • AND: &
  • OR: |
  • OR esclusivo: ^

Il validatore composito accetta tanti validatori quanti ne hai bisogno:

!9d100c[=1|=3|=5|=7|=11|=13|=17|=19|=23|=29|=31|=37|=41|=43|=47|=53|=59|=61|=67|=71|=73|=79|=83|=89|=97]

Operatore elenco

Valori testuali

L'operatore L (o l) (nel senso di lista o elenco) permette di scegliere un valore da un elenco.

!1L[sword,bow,knife,gun,shotgun]

Con commento

!1L[yes,no] # Am I evil ?

Am I evil? yes (Sono malvagio? Sì)

Ottenere valori univoci

Il parametro u richiede valori univoci.

!2Lu[yes,no]

Questo comando può restituire yes,no oppure no,yes. Il parametro u rendeimpossibile ottenere yes,yes o no,no.

Rimuovere la virgola tra i valori

Per impostazione predefinita, i risultati sono separati da una virgola. Puoi rimuoverla con il parametro n.

!2Ln[to,kyo]

Questo comando può restituire toto, kyokyo, tokyo, kyoto.

Univoci senza virgola

!2Lun[to,kyo]

oppure

!2Lnu[to,kyo]

Questi comandi possono restituire tokyo oppure kyoto.

Valori numerici

Se il valore è un numero, viene trattato come tale e puoi eseguire calcoli o usare qualsiasi operatore.

!1L[-1,0,1,2,3,4]+7

Testo e numeri insieme

Non è consigliato usare testo e numeri nello stesso operatore elenco.Attualmente il comportamento cambia in base al risultato. Se il valore scelto è un numero puoi fare altri calcoli, altrimenti il risultato viene mostrato direttamente senza controllo.

Il comportamento cambierà in una futura versione per basarsi sul set di dati.Se il set di dati contiene solo numeri, allora è possibile eseguire calcoli. In caso contrario sarà trattato come stringa.

Cambiare la probabilità

Esistono due modi principali per controllare la probabilità di scelta nell'elenco.

Metodo ant

!1L[2,2,3,3,3,3,4,4,4,5]

oppure

!1L[arm,arm,leg,leg,chest,chest,chest,head]

Metodo lazy

Per intervallo:

!1L[1,2,3,4,5,6[6..10]]

Per peso:

!1L[1[2],2[2],3[4]]

Risultati multipli:

1
3
1
2
2
1
2
3
1
2
3
2
2
3

Esempi vari

!3D100

Tira tre dadi con 100 facce.

!10D10e[=10]s

Tira dieci dadi con 10 facce, il 10i esplode e ordina il risultato.

!100291D66666666s

Tira 100291 dadi con 66666666666 facce e ordina il risultato.

!15D10c[>7]

Tira 15 dadi con 10 facce e conta quanti dadi sono sopra 7.

!1D8+2D6+7

Tira un dado con 8 facce e aggiungi il risultato a due dadi con 6 facce e aggiungi 7.

!D25

Tira un dado con 25 facce.

!88-1D20

88 meno il valore di un dado a 20 facce.

!8+8+8

Calcola: 24

!1L[sword,bow,knife,gun,shotgun]

Verrà scelta una di queste parole.

!8D10c[Validator1]-@c[validator2]

Tira otto dadi con 10 facce poi conta quanti dadi rispettano la condizione Validator1 e sottrai il numero di dadi che rispettano il validator2 e mostra il numero (vedi Validatore per maggiori dettagli sulla sintassi).

!8D10c[>=6]-@c[=1]

Sistema Old World of darkness.

!8D10c[>=7]+@c[=10]

Sistema Exalted seconda edizione.

Aggiungere macro e ordine

Supponiamo di voler definire due macro: a e aa.

Devo aggiungerle dal nome più complesso al più semplice.

Sbagliato

  1. a => 1d10
  2. aa => 2d10

Esecuzione di aa: il sistema macro confronterà aa con la prima macro a e quella corrispondenza. Prima valutazione: aa => 1d10a; seconda valutazione: 1d10a => 1d101d10; comando finale da eseguire: 1d101d10.

Corretto

  1. aa => 2d10
  2. a => 1d10

Quando eseguo il comando aa, il sistema macro confronta aa con aa: la prima valutazione: aa => 2d10 concorda; comando finale da eseguire: 2d10.

Alcune regole

  1. Usa le espressioni regolari per aggiungere vincoli sulla sostituzione testuale
  2. Usa nomi completamente diversi
  3. Evita modelli di macro inclusi in altri modelli di macro

Dovrebbe essere a posto.

Migliori pratiche

Poiché DiceParser offre sempre più funzionalità, potresti trovare diversi modi per fare la stessa cosa. Qui spieghiamo la differenza tra questi vari approcci. In questo modo potrai utilizzare quello corretto.

Lanciare diversi tipi di dadi e sommarli

Sbagliato

!2d8;2d10m

Corretto

!2d8+2d10

L'operatore merge è utile quando vuoi usare gli operatori dei dadi su tutti i dadi tirati.

Sbagliato

!1d20K1+1d10K1

Corretto

!1d20+1d10

L'operatore k per mantenere tanti dadi quanti ne lanci è piuttosto inutile perché è il comportamento predefinito.

Documentazione delle macro

Esempi e ulteriori informazioni

Segnalazione di errori e nuove funzionalità

Apri un ticket nel nostro sistema di tracciamento degli errori. Oppure contattaci su discord o tramite gli altri metodi