Table of content

DiceParser: Què és?

El DiceParser és un component de programari dedicat a tirar daus a través d'ordres simples. Aquest component de programari està disponible en diferents plataformes.
Com ara: bot de Discord, inclòs en el Rolisteam, a Twitter, etc.

Sobre els exemples d'aquesta documentació

Per a deixar-ho clar, tots els exemples d'aquesta documentació no mostren el prefix d'inici. Recordeu afegir el prefix adequat donat on executeu l'ordre de daus: Rolisteam, discord, IRC… Si no ho sabeu, proveu !. El prefix permet al sistema identificar la vostra ordre.

Com tirar un dau

És molt senzill. Cal fer:

!1d6

El primer nombre és el número de daus que voleu tirar. El segon nombre hauria de ser el número de cares.

Exemples

!1d6

Tira un dau de sis cares.

!1d10

Tira un dau de deu cares.

!5d10

Tira cinc daus de deu cares.

!777d6

Tira 777 daus de sis cares.

Gràcies a diverses operacions i opcions, podeu ajustar una mica l'ordre de tirada: vegeu la llista d'operadors.

Tirada de daus en un interval

!4d[-1..1]

Tira 4 daus amb un valor entre -1 a 1. (Sistema Fudge/Fate)

!3d[0..9]

Tira 3 daus amb 10 cares començant a 0.

!3d[-20..-9]

Tira 3 daus, els valors estan entre -20 i -9.

Instruccions

Afegir (o qualsevol operació aritmètica) resultats de dos (o més) classes de daus és fàcil:

!1d10+1d8

Per a mostrar tots els resultats sense realitzar cap operació amb aquests resultats. Utilitzeu ; per a marcar diverses instruccions.

!1d10;1d6 # 2 instructions

o

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

D'aquesta manera, podreu fer algun càlcul si el resultat de la primera instrucció respecta una condició, etc. Per exemple, si voleu llançar un atac, llavors la segona instrucció serà els danys, en la tercera instrucció, podeu comparar el resultat de l'atac, i si l'atac és vàlid. Podeu mostrar:

vegeu més

Fusió

És possible fusionar totes les instruccions dins d'una més gran. La fusió d'operadors està dedicada a això. És útil quan cal gestionar tots els resultats de daus com el mateix resultat.

Per exemple, si necessiteu mantenir els daus més alts entre d6 i d8.

!d6;d8mk1

Més detalls sobre l'operador k a la Llista d'operadors.

Càlculs entre instruccions

Gràcies al sistema variable, és possible fer referència al resultat d'una instrucció específica.

  • Per a fer referència a la primera instrucció: $1
  • Per a fer referència a la segona instrucció: $2
  • Per a fer referència a la tercera instrucció: $3 … no es limita el nombre d'instruccions.
!8d10;$1c[>6];$1c1;$2-$3
  • La primera instrucció tira 8 daus (10 cares)
  • La segona instrucció compta quants daus són superiors a 6.
  • La tercera instrucció compta quants daus són iguals a 1.
  • La quarta instrucció resta el resultat de la tercera instrucció del resultat de la segona.

Llista d'operadors

  • k: Keep (Mantenir)
  • K: Explode and keep (Explotar i mantenir)
  • kl: Keep lower (Mantenir baix)
  • s: Sort (Ordenar)
  • c: Count (Comptar)
  • r: Reroll (Tornar a tirar)
  • R: Reroll until (Tornar a tirar fins)
  • e: Explode (Explotar)
  • a: Reroll and add (Tornar a tirar i afegir)
  • @: Backward Jump (Salt enrere)
  • p: Paint dice (Pinta el dau)
  • m: Merge (Fusió)
  • i: if (si)
  • ;: Instrucció següent
  • g: Grup
  • b: bind (enllaça)
  • #: Comentari

Keep

!kX

L'opció ordena la llista resultant de daus i selecciona els X daus més alts.

Explota i manté

!KX

Els daus exploten si el seu valor és al dau màxim, l'opció ordena la llista de daus resultants, llavors selecciona els X daus més alts.

Exemples

!6d10K4

Tira 6 daus de 10 cares, cada 10 explota. Per tant, el valor dels daus explotats és superior a 10. Resultat: 40 detalls: 23 [10,10,3],9,5,3,1,1

Una altra manera d'escriure aquesta ordre és:

!6d10e10k4

Aquesta manera us permet canviar el llindar d'explosió.

Per a calcular el número que voleu mantenir, l'operador k gestiona la variable. No podeu posar directament el càlcul darrere de la k, però podeu referir-vos a un càlcul anterior.

# Good
!5-3;10d10k$1 

# BAD
!10d10k5-3

# BAD
!10d10k(5-3)

Mantén els daus més baixos

klX

L'opció ordena la llista de daus resultants, després selecciona els X daus més baixos.

Ordenació

!3D10s

La llista de daus s'ordena en ordre descendent.

!10d6sl

Tira 6 daus de 6 cares i després s'ordenen en ordre ascendent

Comptador

!3D10c[Validator]

Compta quants daus respecten la condició i mostra el número (vegeu el validador per a més detalls sobre la sintaxi)

Tornar a tirar

!3D10r[Validator]

Torna a tirar el dau si el valor anterior s'ajusta al validador (vegeu el validador per a més detalls sobre la sintaxi).

Tornar a tirar fins

!3D10R[Validator]

Funciona com «Torna a tirar», però continua tirant els daus fins que la condició sigui falsa.

Explota

!3D10e[Validator]

Explota mentre el valor s'ajusta al validador (vegeu el validador per a més detalls sobre la sintaxi).

!3D10e(3)[Validator]

El node d'explosió pot tenir un límit de quantes vegades explotarà el dau.

!3D10e(1d10)[Validator]

El límit és una expressió.

Exemples

!3D10e10

Mentre que el valor dels daus sigui igual que 10, el dau es tira de nou i el seu resultat s'afegirà al valor dels daus anteriors.

Resultat: 49 detalls: 8, 12 [10,2], 29 [10,10,9]

!3D10e[>8]

Mentre que el valor dels daus sigui més gran que 8, els daus es tiren de nou i el seu resultat s'afegirà al valor dels daus anteriors.

Resultat: 35 detalls: 3, 27 [9,10,8], 5

Afegeix

!3D10a[Validator]

Torna a tirar el dau si el seu valor s'ajusta al validador i afegeix el valor nou a l'anterior. Això només ho fa una vegada.

Ocurrència

!10d10o

Compta i ordena les ocurrències de cada valor. Resultat: 3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]

!10d10o2,7

Compta i ordena les ocurrències quan es produeixen almenys 2 vegades, el valor és 7 o més. Resultat: 2x8 - [1,2,3,5,6,7,8,8,9,10]

!10d10o2[<6]

Compta i ordena les ocurrències quan es produeixen almenys 2 vegades, el valor ha de respectar el validador (aquí menys de 6). Resultat: 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Errors

!10d10o[<6]

Aquesta ordre activarà un avís. Com a operador d'ocurrència pot tenir 0 o 2 paràmetres. Però encara no s'admet només un validador.

Salt enrere

Aquest operador està dedicat a aplicar el seu operador següent al segon a l'últim resultat. Per exemple:

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

c[=10] en aquesta ordre està comptant el nombre de 10 en el resultat de 8D10, si elimineu la @, intentarà comptar el nombre de 10 en el resultat de c[>=7]. El resultat de c[>=7] és un nombre escalar (1 o 2 … (valor màxim 8)); no és una llista de daus.

Pintura

!8D10p[1:blue]

Pinta de blau el primer dau de la llista

!8d10p[2:blue]

Pinta de blau els dos primers daus de la llista.

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

La quantitat de color depèn de l'aplicació client del DiceParser.

  • Amb el Rolisteam, podeu establir el nom de qualsevol color de les Qt o establir el codi hexadecimal del color: #ff28AC.
  • L'aplicació client permet pocs colors: negre, blanc, blau, vermell, negre, verd, groc.

Filtre

L'operador de filtratge permet ignorar alguns resultats de daus donat un validador.

!4d6f[!=6]

Resultat:

total: 11 - details[5 2 6 4]

el 6 s'ignora.

Fusió

L'operador de fusió s'utilitza per a reunir diverses tirades de daus de tipus de dau diferents en un resultat de daus i llavors es pot aplicar qualsevol classe d'operador.

!1d6;1d8mk1

Aquesta ordre fusiona el resultat de d6 i d8. Després, aplica l'operador k en tots dos resultats per a mantenir el millor. Aneu amb compte, aquest operador fusiona la llista d'instruccions. La referència d'instruccions (com ara $1, etc.) no funcionarà després de l'operador de fusió.

Extensió

Fa que els daus explotats siguin daus nous. L'operador s'activa amb y.

!4d6e6y6k3

Primer resultat: 10 [6, 4], 3, 3, 2
Resultat després de l'extensió: 6, 4, 3, 2
Resultat final: 6+4+3 = 13

Tots el mateix

Aquest operador és temporal. Està dedicat a respondre problemes sobre el sistema «Tunnels and Trolls». És per això que l'operador del marcador és t. Els daus exploten quan tots els daus tenen el mateix valor.

!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)]

Únic

Fa que els daus explotats siguin daus nous.

!4d6e6u

Resultat: 6 4 3 3 2 Resultat final: 6+4+3 = 13

Llista de valors

Construïu la vostra pròpia llista de valors i apliqueu qualsevol operador de daus.

![10,25,43,8]k1

Obtenir una puntuació més alta d'entre diverses instruccions:

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

Cada valor es transforma en un dau.

Enllaç

Enllaç funciona exactament com una fusió, però manté la matriu d'instruccions intacta.

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

Tira dos daus de 8 cares i dos de 12 cares, després s'enllacen els seus resultats. Amb aquest resultat final, es mantenen els 2 daus més alts i després aïllem el més baix dels dos més alts. Al final, mostrem el resultat dins d'una frase.

Si (if)

L'operador «si» vol dir permetre-vos fer una cosa si algunes condicions són certes. L'operador «si» té 2 paràmetres obligatoris:

  • La condició (veure el validador)
  • la instrucció a fer quan sigui certa.

També hi ha 2 paràmetres opcionals

  • el mètode de comparació
  • la instrucció a fer quan sigui falsa.

i*[]{}{}

  • *: el mètode de comparació
  • []: el validador

Mètode de comparació

Hi ha 4 mètodes diferents.

  • A cada: la condició es prova en cada dau de la part prèvia de l'ordre. [Mètode predeterminat]
  • A cada valor ?: la condició es prova en cada valor final de dau de la part prèvia de l'ordre.
  • Tots ells *: Tots els daus han de complir la condició per a activar la instrucció certa. Si tots els daus no compleixen la condició s'executa la instrucció falsa.
  • Un d'ells .: almenys un dau ha de complir la condició per a activar la instrucció certa. Si no hi ha daus que compleixin la condició s'executa la instrucció falsa.
  • A l'escalar :: la condició s'avalua en el resultat de l'escalar de la tirada dels daus.

Exemples:

!1d6i[<4]{3}

Si el valor del dau és inferior a 4, el valor de dau és 3. (Així 1, 2 , 3 esdevé 3).

!4d6e6i[=4]{-4}

Si el dau té 4 com a valor, l'elimina. [Sistema Kuro]

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

Si almenys un dau és igual que 6, llavors tira un altre d6 i l'afegeix al resultat.

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

Si tots els daus són iguals a 6, llavors tira un altre d6 i l'afegeix al resultat.

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

Si la suma de dos daus és superior a 15, es mostra «Success», en cas contrari es mostra «Fail».

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

Igual que abans, però el resultat final es mostra a banda de «Success» o «Fail».

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

Igual que a dalt, però el resultat de cada dau es mostra entre claudàtors.

Agrupa

Agrupa els daus, i després compta el nombre del grup (sistema 7è Mar).

Sortida complexa

L'operador d'agrupar pot prendre un paràmetre per activar la sortida complexa. Aquesta sortida mostrarà cada grup i qualsevol valor que es deixi de banda si n'hi ha. Per a activar aquesta sortida, es requereix afegir una s just després de la g. Vegeu l'exemple següent:

Exemple

!3d20g10

Això tirarà 3 daus i després tractarà d'agrupar-los per a fer grups de 10. Si obteniu 9 9 2, només podeu crear un grup el valor del qual sigui més o igual que deu ({9,2}, el segon 9 és «desaprofitarà»).

L'operador g pot reordenar daus per a crear grups. En tirar 4d20g10, si obteniu 7 4 3 6, el resultat serà 2 ({7,3} i {6,4}).

!5d10gs10

A continuació, la sortida final serà:

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

{7,3} i {6,4} són un grup, i [2] es deixa de banda.

Canvia la caixa (S)

L'operador canvia de caixa permet transformar el valor numèric en text. El seu objectiu és fer-ho més fàcil que utilitzar diversos «si». Com és d'esperar, la seva sintaxi és propera a «si».

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

També podeu afegir una opció predeterminada

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

Mode exclusiu: aquest mode està habilitat quan un ^ segueix la S.

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

Comentari

!2D6 # Sword attack

Mostra «Sword attack» i el resultat dels dos daus. El DiceParser ho ignora tot després de la #. Tota la part es tracta com un comentari. Per tant, el DiceParser pot respondre a la pregunta:

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

Soc dolent? sí

Transformació

Transforma els daus a conseqüència d'una condició en un altre valor.

!5d10T[>5]{15}

Tira 5 daus de 10 cares, després reemplaça tots els valors superiors a 5 per 15 i els altres amb 0.

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

Aquest operador accepta diverses condicions: T[=5]{15}[=6]{16}

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

També podeu afegir una expressió final per a canviar el valor de tots els daus que no compleixen a una condició: T[>5]{15}{0}

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

Funcions

El DiceParser proporciona una funció per a gestionar les instruccions. Algunes funcions arribaran aviat (p. ex.: max, min). Permetrà gestionar diverses ordres alhora.

Repetició

!repeat(1d10,5)

Sortida:

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

Atenció! Aneu amb compte, repeat funciona malament amb diverses ordres d'instrucció

Floor

  • 15/7 = 2.14286
  • Floor(15/7) = 2

L'ordre:

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

Ceil

  • 15/7 = 2.14286
  • Ceil(15/7) = 3

L'ordre:

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

Round

  • 15/7 = 2.14286
  • Round(15/7) = 2

L'ordre:

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

La sortida

El DiceParser proporciona funcions per a permetre controlar la sortida de l'ordre. La instrucció final cal que sigui una instrucció de cadena. La instrucció de cadena comença per " i acaba per ".

Tirada:

"result"

Sortida: result

Podeu establir la instrucció de cadena dins de l'operador «if»:

1d6i:[>3]{"Correcte"}{"Error"}

Sortida: Correcte or Error

Ofereix una resposta ràpida, però de vegades cal veure els valors tirats. El DiceParser pot reemplaçar algunes etiquetes especials per tal de veure els valors, el resultat del càlcul i el que sigui.

Dreceres

Hi ha 3 etiquetes de drecera.

  • %1: últim resultat escalar de cada instrucció.
  • %2: tots els resultats dels daus.
  • %3: últim resultat escalar de l'última instrucció.

La sortida predeterminada és %1 details[%2]. Per tant, mostra l'últim resultat escalar de cada instrucció i el resultat dels daus.

%1 i %3 són equivalents quan només hi ha una instrucció (no ;).

Són molt útils però si teniu moltes instruccions això pot arribar a ser una mica confús.

Resultat final

També és possible establir una referència al valor final d'una instrucció específica (el resultat ha de ser un nombre o una cadena)

  • Per a fer referència a la primera instrucció: $1
  • Per a fer referència a la segona instrucció: $2
  • Per a fer referència a la tercera instrucció: $3

No hi ha límit en el nombre d'instruccions.

Cadena com a resultat final

Podeu fer referència al subresultat d'un resultat d'una cadena afegint [x] després de la referència d'instrucció. Vegem un exemple, serà més fàcil d'entendre.

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

El resultat predeterminat es veu així:

cats,bats

Ara volem fer una frase amb aquest text:

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

Com que $1 es refereix a "cats,bats", es mostrarà:

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

Per tant, no és realment útil. Per tal de fer-ho una mica millor, cal afegir alguns subíndexs.

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

Després tenim una sortida adequada.

You love cats and you are afraid of bats

Vegem alguns exemples:

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

La sortida predeterminada 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]"}}

Aquí, algun exemple de sortida:

  • 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)

En aquest exemple, el fracàs crític succeeix quan hi ha més fracassos que l'èxit. En el següent exemple, el fracàs crític succeeix quan no hi ha hagut cap èxit i almenys un fracàs.

!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 altre exemple, per a mostrar com combinar la cadena i el resultat dels daus.

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

Heu trobat 5 monedes d'or

Resultat dels daus

El DiceParser proporciona etiquetes per mostrar el resultat dels daus (i cada valor tirat a partir d'una instrucció específica).

Per a mostrar els valors dels daus a partir d'una instrucció específica, només cal afegir @ seguit del número d'instrucció (p. ex: @1)

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

La sortida:

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

Línia nova

És possible que hàgiu de mostrar el vostre resultat en diverses línies. És molt fàcil:

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

Es mostrarà aquesta ordre:

Attack: 31

Danys: 7

Aritmètica

El Dice Parser del Rolisteam és capaç de calcular operacions aritmètiques primàries com: +, -, /, * i també gestiona la prioritat de l'operador i també pot gestionar parèntesis.

!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 2 daus i afegeix 3 a la suma d'aquests daus. Llavors el resultat s'utilitza per a tirar daus: !(3+2D6)D10

Aritmètica i daus

És possible fer servir operacions aritmètiques en daus. Tingueu en compte que l'operació predeterminada per a traduir una llista de daus a escalar és la suma. Així que si tireu 3d6, el resultat serà una llista amb 3 valors {2, 5 ,1}. Ara, canviem una mica l'ordre 3d6+4: es resol així: {2, 5 ,1} = 8; 8+4 = 12. El resultat final és 12.

  • !3d6+4 ⇾ Tira 3 daus; suma el resultat; i afegeix 4:
  • !10D10-2 ⇾ Tira 10 daus; suma el resultat; i després resta 2
  • !87-1D20 ⇾ Resta el resultat d'1 dau a 87
  • !(6-4)D10 ⇾ Sostreu de 4 a 6 i després tira dos daus.
  • !1D10/2 ⇾ Divideix entre 2 el resultat d'1 dau.
  • !(2+2)**2 ⇾ Resultat: 16
  • !1d10**2 ⇾ Tira 1d10 llavors multiplicar el resultat per si mateix.
  • !15|2 ⇾ Divisió entera de 15 entre 2. Resultat: 7
  • !15/2 ⇾ Divisió de 15 entre 2. Resultat: 7,5

Validador

Hi ha cinc classes de validadors:

  • Escalar
  • Interval
  • Expressió booleana
  • Operació de condició
  • Composició

Qualsevol operador que requereixi un validador (com a,r,e,c) pot utilitzar aquestes tres classes.

Escalar

El valor escalar estableix el validador en igualtat entre el valor dels daus i el validador

!4d10e10

Aquesta ordre significa: tireu 4 daus i exploten al 10.

Interval

L'interval es defineix com dos límits. Heu d'utilitzar claudàtors i els dos límits estan separats per ...

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

Condició booleana

L'ordre compta quants daus tenen valors entre >=8 i <=10.

!4d10c[>7]

L'ordre compta quants daus estan per sobre de 7.

Operador de comparació

El Dice Parser del Rolisteam permet utilitzar diversos operadors lògics:

  • Igual: =
  • Més gran o igual: >=
  • Més petit o igual: <=
  • Més petit: <
  • Més gran: >
  • Diferent: !=

Mètodes de comparació

Com a l'operador if, podeu especificar el mètode de comparació.

  • A cada: la condició es prova en cada dau de la part prèvia de l'ordre. [Mètode predeterminat]
  • A cada valor ?: la condició es prova en cada valor final de dau de la part prèvia de l'ordre.
  • Tots ells *: Tots els daus han de complir la condició per a activar la instrucció certa. Si tots els daus no compleixen la condició s'executa la instrucció falsa.
  • Un d'ells .: almenys un dau ha de complir la condició per a activar la instrucció certa. Si no hi ha daus que compleixin la condició s'executa la instrucció falsa.
  • A l'escalar :: la condició s'avalua en el resultat de l'escalar de la tirada dels daus.
Exemples:
!1L[7,8,9]c[>6]

Aquesta ordre retornarà 0 perquè no s'ha tirat cap dau, de manera que el resultat de 1L[7,8,9] és un valor final.

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

Sortida: 1

!5d6e6sc[>=8]

Sortida:

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

!5d6e6f[?>=16]

Sortida: com que la suma final és 11. És menys de 16, així que el filtre ho filtra tot.

0 detalls: [2 4 1 3 1]

La suma final és superior a 16, de manera que el resultat sencer és acceptat per l'operador filtre.

23 detalls: [3 6 3 5 6]

!5d6e6sc[:>=8]

Sortida:

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

Operació de condició

Aquest validador ofereix «modulo» com a operació i una condició booleana per a validar el valor:

!4d10c[%2=0]

Compta quants nombres parells s'han tirat.

!4d10c[%2=1]

Compta quants nombres senars s'han tirat.

modulo

Validador compost

El validador pot ser el resultat de diversos validadors.

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

Compta tots els daus més grans que 4 i senars [6,8,10].

El validador compost admet 3 operacions lògiques:

  • I: &
  • O: |
  • O exclusiu: ^

El validador compost accepta tants validadors com necessiteu:

!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]

Operador de llista

Valors de text

L'operador L (o l) (significa llista) proporciona una manera de recollir el valor de la llista.

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

Amb comentari

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

Soc dolent? sí

Obtenir valors únics

El paràmetre u demana valors únics.

!2Lu[yes,no]

Aquesta ordre pot retornar yes,no o no,yes. La u fa impossible tornar yes,yes o no,no

Elimina la coma entre valors

De manera predeterminada, els resultats es mostren amb una coma entre cada valor. Podeu eliminar la coma amb el paràmetre n

!2Ln[to,kyo]

Aquesta ordre pot retornar toto, kyokyo, tokyo, kyoto.

Únic sense coma

!2Lun[to,kyo]

o

!2Lnu[to,kyo]

Aquestes ordres poden retornar tokyo o kyoto.

Valors numèrics

Si el valor és un nombre, també es tracta i es pot fer càlcul amb ell o utilitzar qualsevol operador.

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

Text i número al mateix temps

No es recomana utilitzar text i número en el mateix operador de llista. Actualment, el comportament canvia donat el resultat. Si el valor escollit és un nombre, podeu fer un altre càlcul, però en cas contrari, el resultat es mostra directament sense cap control sobre seu.

El comportament canviarà en un llançament futur per basar la decisió en el conjunt de dades. Si el conjunt de dades només conté números, llavors el càlcul és possible. En cas contrari, es tractarà com a resultat de cadena.

Canvia el senar

Hi ha 2 maneres principals de controlar el senar a la tria de la llista.

El mètode de les formigues

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

o

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

El mètode relaxat

Per interval:

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

Per pes:

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

Diversos resultats:

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

Exemples diversos

!3D100

Tira 3 daus amb 100 cares

!10D10e[=10]s

Tira 10 daus amb 10 cares, exploten 10 i ordena el resultat.

!100291D66666666s

Tira 100291 daus amb 6666666666666 cares i ordena el resultat

!15D10c[>7]

Tira 15 daus amb 10 cares i compta el nombre de daus que estan per sobre de 7

!1D8+2D6+7

Tira 1 dau amb 8 cares i afegeix el resultat a 2 daus amb 6 cares i afegeix 7.

!D25

Tira 1 dau amb 25 cares

!88-1D20

88 menys el valor d'1 dau de 20 cares

!8+8+8

calcula: 24

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

Es triarà una d'aquestes paraules.

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

Tira 8 daus amb 10 cares, després compta quants daus respecten la condició Validator1 i sostreu el nombre de daus que respecten el validador2 i mostren el número (vegeu el validator per a més detalls sobre la sintaxi)

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

Sistema Old World in darkness.

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

Sistema Exalted 2a edició.

Afegir macros i ordre

Diguem que volem definir 2 macros: a i aa.

Cal d'afegir-los del nom més complex al més simple.

Malament

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

Execució aa: el sistema de macros compararà aa amb la primera macro a i que coincideixi. Primera avaluació, aa => 1d10a Segona avaluació, 1d10a => 1d101d10 Ordre final a executar: 1d101d10

Bé

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

Quan executi l'ordre: aa. El sistema de macros compararà aa amb a: coincideix amb la primera avaluació: aa => 2d10 Ordre final a executar: 2d10

Algunes regles

  1. Feu servir una expressió regular per a afegir restriccions sobre la substitució de text
  2. Feu servir un nom completament diferent
  3. Eviteu patrons de macro que s'incloguin en un altre patró de macro

Hauria d'estar bé.

Millors pràctiques

Com que el DiceParser proporciona cada vegada més característiques, és possible que trobeu diverses maneres de fer el mateix. Volem explicar aquí la diferència entre aquests enfocaments diversos. Llavors podreu utilitzar el correcte.

Tirar diversos tipus de daus i sumar-los

Malament

!2d8;2d10m

Bé

!2d8+2d10

L'operador de fusió és útil quan voleu utilitzar l'operador de daus en tots els daus tirats.

Malament

!1d20K1+1d10K1

Bé

!1d20+1d10

L'operador k per a mantenir tants daus com tireu és força inútil perquè és el comportament predeterminat.

Documentació de la macro

Exemples i més informació

Informe d'errors i funcionalitats noves

Ompliu un tiquet al sistema de [seguiment d'errors]((https://bugs.kde.org/enter_bug.cgi?product=Rolisteam). O contacteu amb nosaltres a discord o per qualsevol altre sistema