roll a d6

Lancez A D6

Quoi/pourquoi ?

roll-a-d6 est une bibliothèque de moteurs de lancer de dés qui prend en charge des macros et des formules sophistiquées qu'aucun autre rouleau de dés ne prend en charge.

À la base, nous avons le lancer de dés : rollFormula(formula, macrosObject)

Exemple:

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

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

Les composants du lanceur de dés comprennent le validateur, le tokenizer, l'analyseur, le convertisseur RPN et l'évaluateur. Pour plus d'informations, consultez la documentation de l'API ici.

Un exemple de lancer de dés plus sophistiqué pris en charge par ce package :

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

Syntaxe du rouleau

Constantes

Rouleaux

Les lancers doivent être au format x d y , par exemple « 1d20 » ou

Opérateurs

Les opérateurs doivent être utilisés en infixe, par exemple 5+7, bien qu'ils soient évalués en suffixe.

Arithmétique

+, -, *, /

Comparaisons

Supérieur à ( > ), Inférieur à ( < ) et autres opérateurs similaires ( <= , >= , == et <> (différent)) renvoient vrai ou faux.

Greater of ( >> ) et Lesser of ( << ) renvoient la valeur appropriée, par exemple, 5<<7 renvoie 5 .

Logique

|| et && effectue les opérations équivalentes.

Conditions

-> et ; sont les équivalents de then et else. Par exemple : 1d20>10->1d6;0 lancera d’abord 1d20, puis comparera cette valeur à 10. Si la valeur est supérieure à 10, il lancera 1d6 et renverra le résultat de ce lancer. Si la valeur est inférieure ou égale à 10, elle renverra 0.

Opérateurs d'expansion

Ces opérateurs vous permettent de rouler facilement la même chose plusieurs fois. Par exemple, 4#+1d6 est l’équivalent de 1d6+1d6+1d6+1d6 . Ceci est distinct de 4*1d6 car le premier ne relancera pas ces dés ; ce dernier le fera.

Les opérateurs suivants sont pris en charge :

• #+ - Additionnez les résultats ensemble
• #* - Multipliez les résultats ensemble
• #& - AND ( && ) les résultats ensemble, renvoyant la dernière valeur si tous sont véridiques, ou la première valeur fausse.
• #| - OU ( || ) les résultats ensemble, renvoyant la dernière valeur si tous sont faux, ou la première valeur véridique.

Valeurs par défaut

Préfixer une référence de variable avec ^ la fera être traitée comme 0 si elle n'a pas été transmise.

Évaluation macro

En utilisant le nom d'une macro, vous pouvez évaluer cette macro dans votre formule. Les macros peuvent également faire référence à d'autres macros.

Voici un exemple simple :

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

Évaluation des macro-instances mondiales et locales

Vous souhaiterez peut-être vérifier le résultat d’une macro, puis l’utiliser. Il existe plusieurs façons de procéder.

Une façon consiste à utiliser les opérateurs >> et << . Par exemple, pour choisir la valeur la plus élevée entre macro1 et macro2 , vous écrivez macro1>>macro2 .

La méthode la plus avancée implique des instances de macro globales et locales.

[] est utilisé pour les instances de macro locales. {} est utilisé pour les instances de macro globales.

Les évaluations d'instances de macro locales sont utilisées uniquement pour la macro/formule actuellement évaluée. Par exemple, vous voudrez peut-être savoir si le résultat de 1d20 était 20, 1 ou s'il était supérieur à une certaine valeur. Vous pouvez procéder ainsi : r=1d20,r[0]==20->crit;(r[0]==0->miss;r[0]>=minimum->hit)

Les évaluations d'instances de macro globales sont utilisées pour chaque macro qui les référence. Ils sont plus utiles dans des applications très ciblées que dans des rouleaux réutilisables plus généraux.

Effets secondaires

À la suite d'un jet, vous souhaiterez peut-être modifier certaines valeurs, comme diminuer l'utilisation d'une capacité. Alternativement, vous souhaiterez peut-être suivre une valeur pendant un lancer et l'utiliser pour déterminer la marche à suivre ensuite. Vous pouvez le faire avec des effets secondaires !

Actuellement, seuls trois effets secondaires sont pris en charge :

• := (affectation)
• += (incrément)
• -= (décrémenter)

Si vous souhaitez appliquer un effet secondaire, vous devez préfixer le nom de la variable avec $ .

Vous pouvez utiliser le pseudo-opérateur ... entre un effet secondaire et le résultat que vous souhaitez renvoyer.

Un exemple d'effet secondaire, en utilisant les macros ci-dessus :

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