Table of content

DiceParser: Què és?

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

Sobre els exemples d'esta documentació

Per a deixar-ho clar, tots els exemples d'esta 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 estos resultats. Utilitzeu ; per a marcar diverses instruccions.

!1d10;1d6 # 2 instructions

o

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

D'esta manera, podreu fer algun càlcul si el resultat de la primera instrucció respecta una condició, etc. Per exemple, si voleu iniciar 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 açò. És útil quan cal gestionar tots els resultats de daus com el mateix resultat.

Per exemple, si necessiteu mantindre 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 (Mantindre)
  • K: Explode and keep (Explotar i mantindre)
  • kl: Keep lower (Mantindre 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 arrere)
  • 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 tria 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 esta ordre és:

!6d10e10k4

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

Per a calcular el número que voleu mantindre, 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ó siga 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 tindre 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 siga 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 siga 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

Afig

!3D10a[Validator]

Torna a tirar el dau si el seu valor s'ajusta al validador i afig el valor nou a l'anterior. Açò 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 produïxen 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 produïxen almenys 2 vegades, el valor ha de respectar el validador (ací menys de 6). Resultat: 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Errors

!10d10o[<6]

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

Salt arrere

Este 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 esta 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 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, roig, 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

Esta ordre fusiona el resultat de d6 i d8. Després, aplica l'operador k en tots dos resultats per a mantindre el millor. Aneu amb compte, este 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 siguen 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

Este operador és temporal. Està dedicat a respondre problemes sobre el sistema «Tunnels and Trolls». És per açò 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 siguen 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

Obtindre 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 este 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 siga certa.

També hi ha 2 paràmetres opcionals

  • el mètode de comparació
  • la instrucció a fer quan siga 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 complixen 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 complisquen 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'afig al resultat.

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

Si tots els daus són iguals a 6, llavors tira un altre d6 i l'afig 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).

Eixida complexa

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

Exemple

!3d20g10

Açò 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 siga 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ó, l'eixida 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 seua 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: este mode està habilitat quan un ^ seguix 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 roín? 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)

Este 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 complixen 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 prompte (p. ex.: max, min). Permetrà gestionar diverses ordres alhora.

Repetició

!repeat(1d10,5)

Eixida:

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**

L'eixida

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

Tirada:

"result"

Eixida: result

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

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

Eixida: Correcte or Error

Oferix 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 siga.

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ó.

L'eixida 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 açò 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 este text:

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

Com que $1 es referix 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 eixida adequada.

You love cats and you are afraid of bats

Vegem alguns exemples:

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

L'eixida 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]"}}

Ací, algun exemple d'eixida:

  • 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 este exemple, el fracàs crítica succeïx quan hi ha més fracassos que l'èxit. En el següent exemple, el fracàs crítica succeïx 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 a 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]"

L'eixida:

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

Línia nova

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

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

Es mostrarà esta ordre:

Attack: 31

Danys: 7

Aritmètica

El Dice Parser de 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 afig 3 a la suma d'estos daus. Llavors el resultat s'utilitza per a tirar daus: !(3+2D6)D10

Aritmètica i daus

És possible utilitzar operacions aritmètiques en daus. Cal tindre 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 afig 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 ⇾ Sostrau de 4 a 6 i després tira dos daus.
  • !1D10/2 ⇾ Dividix 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 requerisca un validador (com a,r,e,c) pot utilitzar estes tres classes.

Escalar

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

!4d10e10

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

Interval

L'interval es definix 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 damunt de 7.

Operador de comparació

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

  • Igual: =
  • Més gran o igual: >=
  • Més xicotet o igual: <=
  • Més xicotet: <
  • 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 complixen 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 complisquen 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]

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

Eixida: 1

!5d6e6sc[>=8]

Eixida:

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

!5d6e6f[?>=16]

Eixida: 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]

Eixida:

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

Operació de condició

Este validador oferix «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 d'arreplegar el valor de la llista.

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

Amb comentari

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

Soc roín? sí

Obtindre valors únics

El paràmetre u demana valors únics.

!2Lu[yes,no]

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

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

Únic sense coma

!2Lun[to,kyo]

o

!2Lnu[to,kyo]

Estes 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 damunt de 7

!1D8+2D6+7

Tira 1 dau amb 8 cares i afig el resultat a 2 daus amb 6 cares i afig 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'estes paraules.

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

Tira 8 daus amb 10 cares, després compta quants daus respecten la condició Validator1 i sostrau 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 coincidisca. Primera avaluació, aa => 1d10a Segona avaluació, 1d10a => 1d101d10 Ordre final a executar: 1d101d10

Bé

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

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

Algunes regles

  1. Utilitzeu una expressió regular per a afegir restriccions sobre la substitució de text
  2. Utilitzeu un nom completament diferent
  3. Eviteu patrons de macro que s'incloguen 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 ací la diferència entre estos 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 mantindre 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 característiques 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