Table of content

DiceParser: O que é isso?

O DiceParser é um componente de software dedicado a rolar dados através de comandos simples. Este componente está disponível em diferentes plataformas, como bot do Discord, integrado ao Rolisteam, no Twitter, etc.

Sobre os exemplos nesta documentação

Para que fique claro, todos os exemplos nesta documentação não mostram o prefixo de inicialização. Lembre-se de adicionar o prefixo correto, dependendo de onde você executa o comando dice: Rolisteam, Discord, IRC… Se não souber, tente !. O prefixo permite que o sistema identifique seu comando.

Como rolar um dado

É muito simples. Você precisa usar:

!1d6

O primeiro número indica a quantidade de dados que você deseja rolar. O segundo número deve indicar a quantidade de faces.

Exemplos

!1d6

Rolar um dado de seis lados.

!1d10

Rolar um dados de dez lados.

!5d10

Rolar cinco dados de dez lados.

!777d6

Rolar 777 dados de seis lados.

Graças a diversas operações e opções, você pode ajustar um pouco seu comando de rolagem: veja a Lista de operadores.

Rolar dado na distância

!4d[-1..1]

Rolar 4 dados com valores entre -1 e 1. (Sistema Fudge/Fate)

!3d[0..9]

Rolar 3 dados com 10 lados, começando em 0.

!3d[-20..-9]

Rolar 3 dados, os valores ficam entre -20 e -9.

Instruções

Somar (ou realizar qualquer operação aritmética) os resultados de dois (ou mais) tipos de dados é fácil:

!1d10+1d8

Para exibir todos os resultados sem realizar nenhuma operação com eles, use ; para marcar várias instruções.

!1d10;1d6 # 2 instructions

ou

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

Dessa forma, você poderá realizar alguns cálculos se o resultado da primeira instrução respeitar uma condição e assim por diante. Por exemplo, se você quiser rolar um ataque, a segunda instrução calculará o dano. Na terceira instrução, você pode comparar o resultado do ataque e verificar se o ataque é válido. Você pode exibir:

veja mais

Mesclar

É possível mesclar todas as instruções dentro de uma instrução maior. O operador merge é dedicado a isso. Ele é útil quando você precisa gerenciar todos os resultados de dados como se fossem o mesmo resultado.

Por exemplo, se você precisar manter o dado maior entre um d6 e um d8.

!d6;d8mk1

Mais detalhes sobre o operador k na Lista de operadores.

Cálculo entre instruções

Graças ao sistema de variáveis, é possível referenciar o resultado de uma instrução específica.

  • Para fazer referência à primeira instrução: $1
  • Para fazer referência à segunda instrução: $2
  • Para fazer referência à terceira instrução: $3 etc… o número de instruções não é limitado.
!8d10;$1c[>6];$1c1;$2-$3
  • A primeira instrução consiste em rolar 8 dados (de 10 lados)
  • A segunda instrução conta quantos dados têm valor superior a 6.
  • A terceira instrução conta quantos dados são iguais a 1.
  • A quarta instrução subtrai o resultado da terceira instrução do resultado da segunda.

Lista de operadores

  • k: Manter
  • K: Explodir e manter
  • kl: Manter baixo
  • s: Ordenar
  • c: Contar
  • r: Rolar novamente
  • R: Rolar novamente até
  • e: Explodir
  • a: Rolar novamente e adicionar
  • @: Salto para trás
  • p: Pintar dado
  • m: Mesclar
  • i: Se
  • ;: Próxima instrução
  • g: Agrupar
  • b: Ligar
  • #: Comentário

Manter

!kX

Essa opção ordena a lista de dados resultante e seleciona os X dados de maior valor.

Explodir e manter

!KX

Os dados explodem se o seu valor for igual ao máximo do dado; a opção ordena a lista de dados resultante e, em seguida, seleciona os X dados com o valor mais alto.

Exemplos

!6d10K4

Role 6 dados de 10 lados, cada 10 explode. Portanto, o valor dos dados explodidos é maior que 10. Resultado: 40 detalhes: 23 [10,10,3],9,5,3,1,1

Outra forma de escrever este comando é:

!6d10e10k4

Dessa forma, você pode alterar o limite de explosão.

Para calcular o número que você deseja manter, o operador k gerencia variáveis. Você não pode colocar o cálculo diretamente após o k, mas pode se referir a um cálculo anterior.

# Good
!5-3;10d10k$1 

# BAD
!10d10k5-3

# BAD
!10d10k(5-3)

Manter dado mais baixo

klX

Essa opção ordena a lista de dados resultante e, em seguida, seleciona os X dados de menor valor.

Ordenar

!3D10s

A lista de dados está ordenada em ordem decrescente.

!10d6sl

O jogo lança 6 dados com 6 faces cada, e então os dados são ordenados em ordem crescente.

Contar

!3D10c[Validator]

Conta quantos dados atendem à condição e exibe o número (consulte o Validador para obter mais detalhes sobre a sintaxe).

Rolar novamente

!3D10r[Validator]

Rola o dado novamente se o valor anterior corresponder ao validador (consulte Validador para obter mais detalhes sobre a sintaxe).

Rolar novamente até

!3D10R[Validator]

Funciona como "Rolar novamente", mas continua rolando os dados até que a condição seja falsa.

Explodir

!3D10e[Validator]

Explode enquanto o valor se adequar ao Validador (consulte Validador para obter mais detalhes sobre a sintaxe).

!3D10e(3)[Validator]

O nó de explosão pode ter um limite de quantas vezes o dado irá explodir.

!3D10e(1d10)[Validator]

O limite é uma expressão.

Exemplos

!3D10e10

Enquanto o valor do dado for igual a 10, o dado é lançado novamente e o resultado é adicionado ao valor anterior.

Resultado: 49 detalhes: 8, 12 [10,2], 29 [10,10,9]

!3D10e[>8]

Enquanto o valor do dado for maior que 8, o dado é lançado novamente e o resultado é adicionado ao valor anterior.

Resultado: 35 detalhes: 3, 27 [9,10,8], 5

Adicionar

!3D10a[Validator]

Se o valor do dado corresponder ao Validador, role-o novamente e adicione o novo valor ao anterior. Isso só acontece uma vez.

Ocorrência

!10d10o

Contar e ordenar as ocorrências de cada valor. Resultado: 3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]

!10d10o2,7

Contar e ordenar ocorrências quando elas ocorrerem pelo menos 2 vezes, com valor igual ou superior a 7. Resultado: 2x8 - [1,2,3,5,6,7,8,8,9,10]

!10d10o2[<6]

Contar e ordenar ocorrências quando elas ocorrerem pelo menos 2 vezes; o valor deve respeitar o validador (aqui, menos de 6). Resultado: 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Erros

!10d10o[<6]

Este comando está gerando um aviso. O operador de ocorrência pode ter 0 ou 2 parâmetros, mas apenas um validador ainda não é suportado.

Salto para trás

Este operador se dedica a aplicar seu próximo operador ao penúltimo resultado. Por exemplo:

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

Neste comando, c[=10] conta o número de vezes que o valor 10 aparece no resultado de 8D10. Se você remover o @, ele tentará contar o número de vezes que o valor 10 aparece no resultado de c[>=7]. O resultado de c[>=7] é um número escalar (1 ou 2 ... (valor máximo 8)); não é uma lista de dados.

Pintar

!8D10p[1:blue]

Pinte o primeiro dado da lista de azul.

!8d10p[2:blue]

Pinte os dois primeiros dados da lista de azul.

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

A quantidade de cor depende da aplicação cliente do DiceParser.

  • Com o Rolisteam, você pode definir o nome de qualquer cor Qt ou definir o código hexadecimal da sua cor: #ff28AC.
  • O aplicativo de linha de comando suporta algumas cores: preto, branco, azul, vermelho, verde e amarelo.

Filtro

O operador de filtro permite ignorar alguns resultados de dados, dado um validador.

!4d6f[!=6]

Resultado:

total: 11 - detalhes[5 2 6 4]

o 6 é ignorado.

Mesclar

O operador de mesclagem é usado para reunir vários lançamentos de dados de diferentes tipos em um único resultado, e então você pode aplicar qualquer tipo de operador.

!1d6;1d8mk1

Este comando combina os resultados de d6 e d8. Em seguida, aplica o operador k em ambos os resultados para manter o melhor. Atenção: este operador combina a lista de instruções. Referências de instruções (como $1 etc.) não funcionarão após a operação de mesclagem.

Espalhar

Ele transforma dados explodidos em novos dados. O operador é acionado por y.

!4d6e6y6k3

Primeiro resultado: 10 [6, 4], 3, 3, 2
Resultado após espalhar: 6, 4, 3, 2
Resultado final: 6+4+3 = 13

A mesma coisa

Este operador é temporário. Ele se dedica a resolver problemas relacionados ao sistema de Túneis e Trolls. É por isso que o operador marcador é t. Os dados explodem quando todos os dados têm o mesmo 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)]

Único

Isso transforma dados explodidos em dados novos.

!4d6e6u

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

Lista de valores

Crie sua própria lista de valores e aplique qualquer operador de dados.

![10,25,43,8]k1

Obtenha uma pontuação mais alta seguindo várias instruções:

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

Cada valor é transformado em um dado.

Ligar

O comando para ligar funciona exatamente como a mesclagem, mas mantém o array de instruções intacto.

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

Role dois dados de 8 lados e dois dados de 12 lados e combine os resultados. Usando esse resultado final, mantenha os dois dados com os valores mais altos e, em seguida, isole o menor dos dois dados com os valores mais altos. No final, apresente o resultado dentro de uma frase.

Se

O operador "Se" permite que você execute uma ação se determinadas condições forem verdadeiras. O operador "Se" possui dois parâmetros obrigatórios:

  • A condição (veja o validador)
  • a instrução quando ela for verdadeira.

Existem também 2 parâmetros opcionais

  • o método de comparação
  • a instrução a executar quando for falso.

i*[]{}{}

  • *: o método de comparação
  • []: o validador

Método de comparação

Existem quatro tipos de métodos diferentes.

  • Em cada: a condição é testada em cada dado da parte anterior do comando. [Método padrão]
  • Em cada valor ?: a condição é testada em cada valor final do dado da parte anterior do comando.
  • Todos eles *: Todos os dados devem atender à condição para acionar a instrução verdadeira. Se todos os dados não atenderem à condição, a instrução falsa será executada.
  • Um deles .: Pelo menos um dado deve atender à condição para acionar a instrução verdadeira. Se nenhum dado atender à condição, a instrução falsa será executada.
  • Sobre o escalar :: A condição é avaliada no resultado escalar do lançamento do dado.

Exemplos:

!1d6i[<4]{3}

Se o valor do dado for menor que 4, o valor do dado é 3. (Portanto, 1, 2, 3 tornam-se 3).

!4d6e6i[=4]{-4}

Se o dado tiver o valor 4, ele será removido. [Sistema Kuro]

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

Se pelo menos um dado for igual a 6, role outro d6 e adicione-o ao resultado.

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

Se todos os dados forem iguais a 6, role outro d6 e adicione o resultado.

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

Se a soma de dois dados for maior que 15, exibe "Sucesso", caso contrário, exibe "Falha".

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

Semelhante ao anterior, mas o resultado final é exibido ao lado de Sucesso ou Falha.

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

Igual ao anterior, mas o resultado de cada dado é exibido entre colchetes.

Agrupar

Agrupa os dados e depois conta o número de grupos (7º sistema marítimo).

Saída complexa

O operador de agrupar pode receber um parâmetro para ativar a saída complexa. Essa saída mostrará cada grupo e quaisquer valores restantes, se houver. Para ativar essa saída, é necessário adicionar um s logo após o g. Veja o exemplo abaixo:

Exemplo

!3d20g10

Isso rolará 3 dados e tentará agrupá-los para formar grupos de 10. Se você obtiver 9 9 2, você só poderá criar um grupo cujo valor seja maior ou igual a dez ({9,2}, sendo o segundo 9 "desperdiçado").

O operador g permite reordenar os dados para criar grupos. Ao rolar 4d20g10, se você obtiver 7 4 3 6, o resultado será 2 ({7,3} e {6,4}).

!5d10gs10

Então, o resultado final será:

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

{7,3} e {6,4} são grupos, e [2] é deixado de lado.

Alternar caso (S)

O operador de alternar caso permite transformar um valor numérico em texto. Seu objetivo é simplificar essa transformação em comparação com o uso de várias estruturas condicionais com "Se". Como você pode imaginar, sua sintaxe é semelhante à do "Se".

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

Você também pode adicionar uma opção padrão

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

Modo exclusivo: Este modo é ativado quando um ^ segue o S.

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

Comentário

!2D6 # Sword attack

Exibe "Ataque de espada" e o resultado dos dois dados. O DiceParser ignora tudo após o #. Toda a parte é tratada como um único comentário. Portanto, o DiceParser pode responder à pergunta:

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

Eu sou mal ? sim

Transformar

Transforma os dados em outro valor de acordo com uma condição.

!5d10T[>5]{15}

Role 5 dados de 10 faces e, em seguida, substitua todos os valores maiores que 5 por 15 e os demais por 0.

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

Este operador aceita várias condições: T[=5]{15}[=6]{16}

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

Você também pode adicionar uma expressão final para alterar o valor de todos os dados que não se encaixam em uma condição: T[>5]{15}{0}

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

Funções

O DiceParser fornece funções para lidar com instruções. Algumas funções serão adicionadas em breve (por exemplo: max, min). Isso permitirá gerenciar vários comandos simultaneamente.

Repetir

!repeat(1d10,5)

Saída:

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

Atenção! Tenha cuidado, o comando repeat não funciona bem com comandos de múltiplas instruções

Floor

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

O comando:

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

Ceil

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

O comando:

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

Round

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

O comando:

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

A saída

O DiceParser oferece recursos que permitem controlar a saída do comando. A instrução final deve ser uma instrução de string. A instrução de string começa com " e termina com ".

Rolagem:

"resultado"

Saída: resultado

Você pode definir instruções de string dentro do operador "Se":

1d6i:[>3]{"Sucesso"}{"Falha"}

Saída: Sucesso ou Falha

Oferece uma resposta rápida, mas às vezes você precisa ver os valores rolados. O DiceParser pode substituir algumas etiquetas especiais para visualizar valores, resultados de cálculos e outras informações.

Atalhos

Existem 3 etiquetas de atalho.

  • %1: último resultado escalar de cada instrução.
  • %2: todos os resultados dos dados.
  • %3: último resultado escalar da última instrução.

A saída padrão é %1 detalhes[%2]. Portanto, mostra o último resultado escalar de cada instrução e o resultado do dado.

%1 e %3 são equivalentes quando há apenas uma instrução (sem ;).

São realmente úteis, mas se houver muitas instruções, podem ficar um pouco confusas.

Resultado final

Também é possível definir uma referência ao valor final de uma instrução específica (o resultado deve ser um número ou uma string).

  • Para fazer referência à primeira instrução: $1
  • Para fazer referência à segunda instrução: $2
  • Para fazer referência à terceira instrução: $3

Não há limite para o número de instruções.

String como resultado final

Você pode referenciar o resultado da sub-rotina de um resultado de string adicionando [x] após a referência da instrução. Vejamos um exemplo, será mais fácil de entender.

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

O resultado padrão é semelhante a este:

cats,bats

Agora queremos construir uma frase com este texto:

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

Como $1 se refere a "gatos, morcegos", será exibido:

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

Portanto, não é realmente útil. Para melhorar um pouco, precisamos adicionar alguns sub-índices.

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

Então teremos um resultado adequado.

Você adora gatos e tem medo de morcegos

Vejamos alguns exemplos:

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

A saída padrão exibe: 45,4,0,4 detalhes[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]"}}

Aqui está um exemplo de saída:

  • 4 Sucesso[4,3,10,7,2,2,7,10]
  • Falha 0 [10,3,1,1,2,2,7,5] (2 sucessos - 2 falhas = 0)
  • Falha crítica -2 [1,3,1,1,2,2,7,5] (1 sucesso - 3 falhas = -2)

Neste exemplo, a falha crítica ocorre quando há mais falhas do que sucessos. No próximo exemplo, a falha crítica ocorre quando não houve sucesso e houve pelo menos uma falha.

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

Outro exemplo, para mostrar como combinar uma string com o resultado de um dado.

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

Você encontrou 5 moedas de ouro

Resultado do dado

O DiceParser fornece etiquetas para exibir o resultado dos dados (e cada valor rolado a partir de uma instrução específica).

Para exibir os valores dos dados de uma instrução específica, basta adicionar @ seguido pelo número da instrução (ex: @1).

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

A saída:

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

Nova linha

Você pode precisar exibir seu resultado em várias linhas. É muito fácil:

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

Este comando exibirá:

Attack: 31

Dano: 7

Aritmética

O analisador de dados do Rolisteam é capaz de calcular operações aritméticas primárias como: +, -, /, * e também gerencia a prioridade desses operadores, além de lidar com parênteses.

!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

Role 2 dados e adicione 3 à soma dos resultados. Em seguida, use o resultado para rolar os dados: !(3+2D6)D10

Aritmética e Dados

É possível usar operações aritméticas com dados. Observe que a operação padrão para converter uma lista de dados em um escalar é a soma. Portanto, se você rolar 3d6, o resultado será uma lista com 3 valores {2, 5, 1}. Agora, vamos alterar um pouco o comando 3d6+4: Ele é resolvido assim: {2, 5, 1} = 8; 8+4 = 12. O resultado final é 12.

  • !3d6+4 ⇾ Role 3 dados; some os resultados; e adicione 4:
  • !10D10-2 ⇾ Role 10 dados; some os resultados; e então subtraia 2.
  • !87-1D20 ⇾ Subtrai o resultado de 1 dado de 87
  • !(6-4)D10 ⇾ Subtraia 4 de 6 e depois role dois dados.
  • !1D10/2 ⇾Divida por 2 o resultado de 1 dado.
  • !(2+2)**2 ⇾ Resultado: 16
  • !1d10**2 ⇾ Role 1d10 e multiplique o resultado por si mesmo.
  • !15|2 ⇾ Divisão inteira de 15 por 2. Resultado: 7
  • !15/2 ⇾ Divisão de 15 por 2. Resultado: 7,5

Validador

Existem cinco tipos de validadores:

  • Escalar
  • Intervalo
  • Expressão booleana
  • Operação de condição
  • Composto

Qualquer operador que exija um validador (como a,r,e,c) pode usar esses três tipos.

Escalar

O valor escalar define o validador com base na igualdade entre o valor do dado e o validador

!4d10e10

Este comando significa: role 4 dados, e eles explodem no 10.

Intervalo

O intervalo é definido como dois limites. Você deve usar colchetes e os dois limites são separados por ...

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

Condição booleana

O comando conta quantos dados têm valores entre >=8 e <=10.

!4d10c[>7]

O comando conta quantos dados têm valor superior a 7.

Operador de comparação

O analisador de dados do Rolisteam permite que você use diversos operadores lógicos:

  • Igual: =
  • Maior ou igual: >=
  • Menor ou igual: <=
  • Menor: <
  • Maior: >
  • Diferente: !=

Métodos de comparação

Como operador Se, você pode especificar o método de comparação.

  • Em cada: a condição é testada em cada dado da parte anterior do comando. [Método padrão]
  • Em cada valor ?: a condição é testada em cada valor final do dado da parte anterior do comando.
  • Todos eles *: Todos os dados devem atender à condição para acionar a instrução verdadeira. Se todos os dados não atenderem à condição, a instrução falsa será executada.
  • Um deles .: Pelo menos um dado deve atender à condição para acionar a instrução verdadeira. Se nenhum dado atender à condição, a instrução falsa será executada.
  • Sobre o escalar :: A condição é avaliada no resultado escalar do lançamento do dado.
Exemplos:
!1L[7,8,9]c[>6]

Este comando retornará 0 porque nenhum dado foi lançado, então o resultado de 1L[7,8,9] é um valor final.

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

Saída: 1

!5d6e6sc[>=8]

Saída:

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

!5d6e6f[?>=16]

Saída: Como a soma final é igual a 11, e é menor que 16, o filtro está filtrando tudo.

0 detalhes: [2 4 1 3 1]

A soma final é maior que 16, portanto o resultado completo é aceito pelo operador de filtro.

23 detalhes: [3 6 3 5 6]

!5d6e6sc[:>=8]

Saída:

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

Operação de condição

Este validador oferece o operador módulo e uma condição booleana para validar o valor:

!4d10c[%2=0]

Conta quantos números pares foram obtidos nos dados.

!4d10c[%2=1]

Conta quantos números ímpares foram obtidos nos dados.

módulo

Validador composto

O validador pode ser o resultado de vários validadores.

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

Conta todos os dados maiores que 4 e pares [6,8,10].

O validador composto suporta 3 operações lógicas:

  • E : &
  • OU : |
  • OU Exclusivo : ^

O validador composto aceita quantos validadores você precisar:

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

Valores de texto

O operador L (ou l) (que significa lista) fornece uma maneira de selecionar um valor de uma lista.

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

Com comentário

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

Eu sou mal ? sim

Obtenção de valores únicos

O parâmetro u solicita valores únicos.

!2Lu[yes,no]

Este comando pode retornar sim,não ou não,sim. O u impede que retorne sim,sim ou não,não.

Remover a vírgula entre os valores

Por padrão, os resultados são exibidos com uma vírgula entre cada valor. Você pode remover a vírgula com o parâmetro n.

!2Ln[to,kyo]

Este comando pode retornar toto, kyokyo, tokyo, kyoto.

Único, sem vírgula

!2Lun[to,kyo]

ou

!2Lnu[to,kyo]

Esses comandos podem retornar tokyo ou kyoto.

Valores numéricos

Se o valor for um número, ele também será tratado como tal, e você poderá realizar cálculos com ele ou usar qualquer operador.

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

Texto e número ao mesmo tempo

Não é recomendável usar texto e número no mesmo operador de lista. Atualmente, o comportamento muda de acordo com o resultado. Se o valor escolhido for um número, você pode realizar outros cálculos, mas, caso contrário, o resultado é exibido diretamente, sem qualquer controle sobre ele.

O comportamento será alterado em versões futuras para basear a decisão no conjunto de dados. Se o conjunto de dados contiver apenas números, o cálculo será possível. Caso contrário, será tratado como um resultado de texto.

Alterar o ímpar

Existem duas maneiras principais de controlar a probabilidade de um item ser selecionado na lista.

O método das formigas

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

ou

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

O método preguiçoso

Por intervalo:

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

Por peso:

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

Vários resultados:

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

Exemplos diversos

!3D100

Rolar 3 dados com 100 faces

!10D10e[=10]s

Rolar 10 dados com 10 faces, 10 explodem, e classificar o resultado.

!100291D66666666s

Rolar 100291 dados com 66666666666 faces e ordenar o resultado.

!15D10c[>7]

Rolar 15 dados com 10 faces e contar o número de dados que resultarem em um número maior que 7.

!1D8+2D6+7

Rolar um dado com 8 faces e somar o resultado a dois dados com 6 faces, somando o total de 7.

!D25

Rolar um dado com 25 faces.

!88-1D20

88 menos o valor de um dado de 20 faces.

!8+8+8

Calcular: 24

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

Uma dessas palavras será escolhida.

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

Rolar 8 dados com 10 faces, contar quantos dados atendem à condição Validator1 e subtraia o número de dados que atendem à condição Validator2, exibindo o resultado (consulte Validador para obter mais detalhes sobre a sintaxe).

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

Velho Mundo no sistema de escuridão.

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

Sistema Exaltado 2ª edição.

Adicionando Macro e pedido

Digamos que queremos definir 2 macros: a e aa.

Devo adicioná-los do nome mais complexo para o mais simples.

Ruim

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

Executando aa: O sistema de macros comparará aa com a primeira macro a e encontrará uma correspondência. Primeira avaliação: aa => 1d10a. Segunda avaliação: 1d10a => 1d101d10. Comando final a ser executado: 1d101d10.

Bom

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

Quando eu executar o comando: aa. O sistema de macros comparará aa com aa: correspondência Primeira avaliação: aa => 2d10 Comando final a ser executado: 2d10

Algumas regras

  1. Use expressões regulares para adicionar restrições à substituição de texto
  2. Use um nome complexamente diferente
  3. Evite padrões macro que estejam incluídos em outro padrão macro

Você ficará bem.

Melhores práticas

À medida que o DiceParser oferece cada vez mais recursos, você pode encontrar diversas maneiras de realizar a mesma tarefa. Nosso objetivo aqui é explicar a diferença entre essas abordagens, para que você possa escolher a mais adequada.

Role vários tipos de dados e some-os

Ruim

!2d8;2d10m

Bom

!2d8+2d10

O operador de mesclagem é útil quando você deseja usar o operador de dados em todos os dados rolados.

Ruim

!1d20K1+1d10K1

Bom

!1d20+1d10

O operador k para manter tantos dados quantos você rolar é praticamente inútil, pois esse é o comportamento padrão.

Documentação de Macro

Exemplos e mais informações

Relatório de bugs e novas funcionalidades

Por favor, abra um chamado em nosso sistema de rastreamento de bugs. Ou entre em contato conosco no discord ou por qualquer outro meio