roll a d6

Role A D6

O quê/por quê?

roll-a-d6 é uma biblioteca de mecanismo de lançamento de dados que suporta macros e fórmulas sofisticadas que nenhum outro rolo de dados suporta.

Em sua essência, temos o rolo de dados: rollFormula(formula, macrosObject)

Exemplo:

 import * as d6 from 'roll-a-d6' ;

const roll = d6 . rollFormula ( '1d20+Strength,1d8+Strength' , { Strength : '5' } ) ;
console . log ( roll . result . join ( ', ' ) ) ;

Os componentes do rolo de dados incluem validador, tokenizador, analisador, conversor RPN e avaliador. Para obter mais informações, verifique a documentação da API aqui.

Um exemplo de lançamento de dados mais sofisticado que este pacote suporta:

 import * as d6 from 'roll-a-d6' ;

const macros = {
  roll : 'r=1d20,(^adv&&^disadv)||(adv==0&&disadv==0)->r[0];(adv->r[0]>>r[1];r[0]<<r[1])' ,
  atk : 'roll[0]==20->dmgDice[0]+dmgDice[1]+dmgMod;(roll[0]==1->0;roll[0]+bonus>ac@Defender->dmgDice[0]+dmgMod;0)' ,
  bonus : 'prof+dmgMod' ,
  shortSword : '1d6,dmgMod=Dex>>Str' ,
  sneakAttack : '3d6' ,
  sneakAttackIfPossible : 'canYouSneakAttack->sneakAttack;0' ,
  Str : '10' ,
  Dex : '18' ,
  prof : '3' ,
} ;
const roll = d6 . rollFormula ( 'ac@Defender=?,canYouSneakAttack=1,dmgDice=shortSword,(atk[0]+atk[1])>0->(atk[0]+atk[1]+sneakAttackIfPossible);0' , macros ) ;
//  now I know the attacker's AC is 15
const foundResult = roll . result . find ( ( { minValue , maxValue } ) => minValue <= 15 && ! ( maxValue < 15 ) ) ;
console . log ( foundResult [ 0 ] ) ; 

Sintaxe do rolo

Constantes

Rolinhos

Os rolos devem estar no formato x d y , por exemplo, '1d20' ou

Operadores

Os operadores devem ser usados ​​infixos, por exemplo, 5+7, embora sejam avaliados como pós-fixados.

Aritmética

+, -, *, /

Comparações

Maior que ( > ), Menor que ( < ) e outros operadores semelhantes ( <= , >= , == e <> (diferente de)) retornam verdadeiro ou falso.

Maior entre ( >> ) e Menor entre ( << ) retorna o valor apropriado, por exemplo, 5<<7 retorna 5 .

Lógica

|| e && executam as operações equivalentes.

Condicionais

-> e ; são os equivalentes de then e else. Por exemplo: 1d20>10->1d6;0 primeiro rolará 1d20 e depois comparará esse valor com 10. Se o valor for maior que 10, rolará 1d6 e retornará o resultado dessa jogada. Se o valor for menor ou igual a 10, retornará 0.

Operadores de expansão

Esses operadores permitem rolar a mesma coisa muitas vezes com facilidade. Por exemplo, 4#+1d6 é equivalente a 1d6+1d6+1d6+1d6 . Isto é diferente de 4*1d6 porque o primeiro não irá relançar esses dados; o último irá.

Os seguintes operadores são suportados:

• #+ - Some os resultados
• #* - Multiplique os resultados
• #& - AND ( && ) os resultados juntos, retornando o último valor se todos forem verdadeiros ou o primeiro valor falso.
• #| - OR ( || ) os resultados juntos, retornando o último valor se todos forem falsos, ou o primeiro valor verdadeiro.

Valores padrão

Prefixar uma referência de variável com ^ fará com que ela seja tratada como 0 se não tiver sido transmitida.

Avaliação macro

Ao usar o nome de uma macro, você pode avaliar essa macro em sua fórmula. As macros também podem fazer referência a outras macros.

Aqui está um exemplo simples:

 import * as d6 from 'roll-a-d6' ;

const macros = {
  macro : '1d20>10->helperMacro;0' ,
  helperMacro : '1d10+5' ,
} ;
const formula = 'macro+macro' ;
const roll = d6 . rollFormula ( formula , macros ) ; 

Avaliação de macroinstâncias globais e locais

Você pode verificar o resultado de uma macro e usá-la. Existem algumas maneiras de fazer isso.

Uma maneira envolve usar os operadores >> e << . Por exemplo, para escolher o valor mais alto entre macro1 e macro2 , você escreveria macro1>>macro2 .

A forma mais avançada envolve instâncias macro globais e locais.

[] é usado para instâncias de macro locais. {} é usado para instâncias de macro globais.

As avaliações de instâncias de macro locais são usadas apenas para a macro/fórmula atualmente avaliada. Por exemplo, você pode querer saber se o resultado de 1d20 foi 20, 1 ou se estava acima de um determinado valor. Você pode fazer isso assim: r=1d20,r[0]==20->crit;(r[0]==0->miss;r[0]>=minimum->hit)

Avaliações globais de instâncias de macro são usadas para cada macro que as referencia. Eles são mais úteis em aplicações muito específicas do que em rolos reutilizáveis ​​mais gerais.

Efeitos colaterais

Como resultado de um teste, você pode querer alterar algum valor, como diminuir o uso de uma habilidade. Alternativamente, você pode querer rastrear um valor durante uma rolagem e usá-lo para determinar o que fazer a seguir. Você pode fazer isso com efeitos colaterais!

Atualmente, apenas três efeitos colaterais são suportados:

• := (tarefa)
• += (incremento)
• -= (diminuir)

Se desejar aplicar um efeito colateral, você deve prefixar o nome da variável com $ .

Você pode usar o pseudo-operador ... entre um efeito colateral e o resultado que deseja retornar.

Um exemplo de efeito colateral, usando as macros acima:

  const myMacros = {
    ... macros ,
    sneakAttack : '3d6' ,
    sneakAttackIfPossible : 'canSneakAttack>0->$canSneakAttack:=0...sneakAttack;0' ,
    attackWithSneakAttack : 'atk[0]>0->atk[0]+sneakAttackIfPossible;0' ,
  } ;
  const formula = 'canSneakAttack=1,2#+attackWithSneakAttack' ;
  d6 . rollFormula ( formula , myMacros ) ;