Table of content

DiceParser : Qu'est-ce que c'est ?

DiceParser est un composant logiciel dédié au lancer de dés via des commandes simples. Ce composant logiciel est disponible sur différentes plateformes.
Telles que : bot Discord, intégré à Rolisteam, sur Twitter, etc.

À propos des exemples dans cette documentation

Pour être clair, tous les exemples dans cette documentation ne montrent pas le préfixe de démarrage. Veuillez vous rappeler d’ajouter le préfixe approprié selon l’endroit où vous exécutez la commande : Rolisteam, Discord, IRC… Si vous ne le savez pas, essayez !. Le préfixe permet au système d’identifier votre commande.

Comment lancer un dé

C'est vraiment simple. Vous devez appeler :

!1d6

Le premier nombre est le nombre de dés que vous voulez lancer. Le deuxième nombre doit être le nombre de faces du dé.

Exemples

!1d6

Lancez un dé à six faces.

!1d10

Lance un dé à dix faces.

!5d10

Lancez cinq dés à dix faces.

!777d6

Lance un dé à six faces 777.

Grâce à plusieurs opérations et options, vous pouvez ajuster un peu votre commande de roulage : voir Liste des opérateurs.

Lancer les dés dans la plage

!4d[-1..1]

Lancer 4 dés avec des valeurs comprises entre -1 et 1. (système Fudge/Fate)

!3d[0..9]

Lancer 3 dés à 10 faces commençant à 0.

!3d[-20..-9]

En lançant 3 dés, les valeurs sont comprises entre -20 et -9.

Instructions

Ajouter (ou effectuer toute opération arithmétique) les résultats de deux (ou plusieurs) types de dés est facile :

!1d10+1d8

Pour afficher tous les résultats sans effectuer aucune opération avec ces résultats. Utilisez ; pour marquer plusieurs instructions.

!1d10;1d6 # 2 instructions

ou

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

Ainsi, vous pourrez effectuer un calcul si le résultat de la première instruction respecte une condition, et ainsi de suite. Par exemple, si vous voulez lancer une attaque, alors la deuxième instruction sera les dommages. Dans la troisième instruction, vous pouvez comparer le résultat de l’attaque, et si l’attaque est valide. Vous pouvez afficher :

voir plus

Aller

Il est possible de fusionner toutes les instructions en une seule grande. L'opérateur merge est dédié à cela. Il est utile lorsque vous devez gérer tous les résultats de dés comme le même résultat.

Par exemple, si vous devez conserver le dé le plus élevé entre un d6 et un d8.

!d6;d8mk1

Plus de détails sur l'opérateur k dans Liste des opérateurs.

Calcul entre instructions

Grâce au système de variables, il est possible de référencer le résultat d'une instruction spécifique.

  • Pour faire référence à la première instruction : $1
  • Pour faire référence à la deuxième instruction : $2
  • Pour faire référence à la troisième instruction : $3, etc. … le nombre d'instructions n'est pas limité.
!8d10;$1c[>6];$1c1;$2-$3
  • La première instruction fait lancer 8 dés à 10 faces
  • La deuxième instruction compte combien de dés sont supérieurs à 6.
  • La troisième instruction compte combien de dés sont égaux à 1.
  • La quatrième instruction soustrait le résultat de la troisième instruction de celui de la deuxième.

Liste des opérateurs

  • k : garder
  • K : Exploser et garder
  • kl : Garde plus petit
  • s : trie
  • c : Compte
  • r : Relance
  • R : Relance jusqu'à
  • e : Explose
  • a : Relance et ajoute
  • @ : Saut en arrière
  • p : Peint des dés
  • m : Fusionner
  • i : si
  • ; : Instruction suivante
  • g : Groupe
  • b: lie
  • # : Commentaire

Garde

!kX

L'option trie la liste de dés obtenue et sélectionne les X dés les plus élevés.

Explose et garde

!KX

Les dés explosent si leur valeur est au maximum du dé, l'option trie ensuite la liste des dés obtenus, puis sélectionne les X dés les plus élevés.

Exemples

!6d10K4

Lancez 6 dés à 10 faces, chaque 10 explose. Ainsi, la valeur des dés explosés est supérieure à 10. Résultat : 40 détails : 23 [10,10,3], 9, 5, 3, 1, 1

Une autre façon d'écrire cette commande est :

!6d10e10k4

Cette méthode vous permet de modifier le seuil d'explosion.

Pour calculer le nombre que vous souhaitez conserver, l'opérateur k gère la variable. Vous ne pouvez pas mettre directement le calcul derrière le k, mais vous pouvez vous référer à un calcul précédent.

# Good
!5-3;10d10k$1 

# BAD
!10d10k5-3

# BAD
!10d10k(5-3)

Garder les dés les plus bas

klX

L'option trie la liste de dés obtenue, puis elle sélectionne les X dés les plus bas.

Trie

!3D10s

La liste des dés est triée par ordre décroissant.

!10d6sl

On lance 6 dés à 6 faces, puis ils sont triés par ordre croissant.

Compte

!3D10c[Validator]

Comptez combien de dés respectent la condition et affichez le nombre (Voir le validateur pour plus de détails sur la syntaxe)

Relance

!3D10r[Validator]

Relancez le dé si la valeur précédente correspond au validateur (voir le validateur pour plus de détails sur la syntaxe).

Relance jusqu'à

!3D10R[Validator]

Fonctionne comme « Reroll », mais continue de lancer les dés jusqu'à ce que la condition soit fausse.

Explose

!3D10e[Validator]

Explosez tant que la valeur correspond au validateur (voir validateur pour plus de détails sur la syntaxe).

!3D10e(3)[Validator]

Le nœud d'explosion peut avoir une limite sur le nombre de fois que le dé peut exploser.

!3D10e(1d10)[Validator]

La limite est une expression.

Exemples

!3D10e10

Lorsque la valeur du dé est égale à 10, le dé est relancé et son résultat est ajouté à la valeur précédente du dé.

Résultat : 49 détails : 8, 12 [10,2], 29 [10,10,9]

!3D10e[>8]

Tant que la valeur du dé est supérieure à 8, le dé est relancé et son résultat est ajouté à la valeur précédente du dé.

Résultat : 35 détails : 3, 27 [9,10,8], 5

ajoute

!3D10a[Validator]

Relance le dé si sa valeur correspond au validateur et ajoute la nouvelle valeur à la précédente. Cela ne se fait qu'une seule fois.

Occurrence

!10d10o

Comptez et triez les occurrences de chaque valeur. Résultat : 3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]

!10d10o2,7

Compte et trie les occurrences lorsqu'elles se produisent au moins 2 fois, la valeur est de 7 ou plus. Résultat : 2x8 - [1,2,3,5,6,7,8,8,9,10]

!10d10o2[<6]

Compte et trie les occurrences lorsqu'elles apparaissent au moins 2 fois, la valeur doit respecter le validateur (ici inférieure à 6). Résultat : 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Erreurs

!10d10o[<6]

Cette commande déclenche un avertissement. L'opérateur d'occurrence peut avoir 0 ou 2 paramètres. Mais un seul validateur n'est pas encore pris en charge.

Saut en arrière

Cet opérateur est dédié à appliquer son opérateur suivant à l’avant-dernier résultat . Par exemple :

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

c[=10] dans cette commande compte le nombre de 10 dans le résultat de 8D10, si vous retirez le @, il essaiera de compter le nombre de 10 dans le résultat de c[>=7]. Le résultat de c[>=7] est un nombre scalaire (1 ou 2 ... (valeur maximale 8)) ; ce n'est pas une liste de dés.

Peindre

!8D10p[1:blue]

Peins le premier dé de la liste en bleu

!8d10p[2:blue]

Peins les deux premiers dés de la liste en bleu.

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

La quantité de couleur dépend de l'application cliente de DiceParser.

  • Avec Rolisteam, vous pouvez définir le nom de n'importe quelle couleur Qt ou définir le code hexadécimal de votre couleur : #ff28AC.
  • L'application CLI prend en charge quelques couleurs : noir, blanc, bleu, rouge, noir, vert, jaune.

Filtre

L'opérateur de filtre vous permet d'ignorer certains résultats de dés selon un validateur.

!4d6f[!=6]

Résultat :

total : 11 - détails[5 2 6 4]

le 6 est ignoré.

Aller

L'opérateur de fusion est utilisé pour rassembler plusieurs lancers de dés de différents types de dés en un seul résultat de dés, puis vous pouvez appliquer n'importe quel type d'opérateur.

!1d6;1d8mk1

Cette commande fusionne les résultats du d6 et du d8. Ensuite, elle applique l'opérateur k sur les deux résultats pour ne garder que le meilleur. Attention, cet opérateur fusionne les listes d'instructions. Les références d'instructions (comme $1, etc.) ne fonctionneront plus après l'opérateur de fusion.

Aplati

Il transforme les dés explosés en nouveaux dés. L'opérateur est déclenché par y.

!4d6e6y6k3

Premier résultat : 10 [6, 4], 3, 3, 2
Résultat après répartition : 6, 4, 3, 2
Résultat final : 6+4+3 = 13

Tous les mêmes

Cet opérateur est temporaire. Il est dédié à répondre aux questions concernant le système Tunnels et Trolls. C'est pourquoi l'opérateur marqueur est « t ». Les dés explosent lorsque tous les dés ont la même valeur.

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

Unique

Cela transforme les dés explosés en nouveaux dés.

!4d6e6u

Résultat : 6 4 3 3 2 Résultat final : 6+4+3 = 13

Liste de valeurs

Créez votre propre liste de valeurs et appliquez n'importe quel opérateur de dés.

![10,25,43,8]k1

Obtenez un meilleur score grâce à plusieurs instructions :

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

Chaque valeur est transformée en dé.

Lier

Lier fonctionne exactement comme merge mais il laisse le tableau d'instructions intact.

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

Lancez deux dés à 8 faces et deux dés à 12 faces, puis combinez leurs résultats. Avec ce résultat final, nous gardons les deux dés les plus élevés puis nous isolons le plus bas des deux plus élevés. À la fin, nous affichons le résultat dans une phrase.

Si

L'opérateur SI signifie vous permettre de faire une chose si certaines conditions sont vraies. L'opérateur SI a 2 paramètres obligatoires :

  • La condition (voir le validateur)
  • l'instruction à exécuter lorsqu'elle est vraie.

Il y a aussi 2 paramètres optionnels

  • la méthode compare
  • l'instruction à exécuter lorsqu'elle est fausse.

i*[]{}{}

  • * : la méthode compare
  • [] : le validateur

Méthode compare

Il y a 4 méthodes différentes.

  • Sur chacun : la condition est testée sur chaque dé de la partie précédente de la commande. [Méthode par défaut]
  • Sur chaque valeur ? : la condition est testée sur chaque valeur finale du dé provenant de la partie précédente de la commande.
  • Tous * : Tous les dés doivent satisfaire la condition pour retourner vrai. Si tous les dés ne remplissent pas la condition, faux est retourné.
  • L'un d'eux . : au moins un dé doit remplir la condition pour retourner vrai. Si aucun dé ne remplit la condition, alors faux est retourné.
  • Sur scalaire : : la condition est évaluée sur le résultat scalaire du lancer de dés.

Exemples :

!1d6i[<4]{3}

Si la valeur du dé est inférieure à 4, la valeur du dé est 3. (Ainsi 1, 2 et 3 deviennent 3).

!4d6e6i[=4]{-4}

Si le dé a 4 comme valeur, il la retire. [Système Kuro]

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

si au moins un dé est égal à 6, alors lancez un autre d6 et ajoutez-le au résultat.

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

si tous les dés sont égaux à 6, lancez alors un autre d6 et ajoutez-le au résultat.

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

si la somme de deux dés est supérieure à 15, cela affiche "Success" (Succès), sinon cela affiche "Fail" (Échec).

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

Comme ci-dessus, mais le résultat final est affiché à côté de Succès ou Échec.

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

Comme ci-dessus, mais le résultat de chaque dé est affiché entre crochets.

Groupe

Le groupe lance les dés, puis compte le nombre de groupes (système de la 7e mer).

Sortie complexe

L'opérateur de groupe peut prendre un paramètre pour activer la sortie complexe. Cette sortie affichera chaque groupe ainsi que les valeurs restantes, le cas échéant. Pour activer cette sortie, il est nécessaire d'ajouter un s juste après le g. Voir l'exemple ci-dessous :

Exemple

!3d20g10

Cela lancera 3 dés puis tentera de les regrouper pour former des groupes de 10. Si vous obtenez 9 9 2, vous ne pouvez créer qu'un seul groupe dont la valeur est égale ou supérieure à dix ({9,2}, le deuxième 9 étant « gaspillé »).

L'opérateur g permet de réorganiser les dés pour créer des groupes. Lors d'un lancer de 4d20g10, si vous obtenez 7 4 3 6, le résultat sera 2 ({7,3} et {6,4}).

!5d10gs10

Ensuite, le résultat final sera :

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

{7,3} et {6,4} forment un groupe, et [2] est mis de côté.

Instruction switch (S)

L'opérateur switch permet de transformer une valeur numérique en texte. Son objectif est de rendre cela plus facile que d'utiliser plusieurs SI. Comme vous pouvez vous en douter, sa syntaxe est proche de celle du SI.

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

Vous pouvez également ajouter une option par défaut

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

Mode exclusif : ce mode est activé lorsqu'un ^ suit le S.

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

Comment

!2D6 # Sword attack

Affichez « Attaque d’épée » et le résultat des deux dés. DiceParser ignore tout ce qui suit le #. Toute la partie est traitée comme un seul commentaire. Donc DiceParser peut répondre à la question :

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

Suis-je mauvais ? Oui

Transforme

Transforme les dés en une autre valeur selon une condition.

!5d10T[>5]{15}

Lance 5 dés à 10 faces, puis remplace toutes les valeurs supérieures à 5 par 15 et les autres par 0.

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

Cet opérateur accepte plusieurs conditions : T[=5]{15}[=6]{16}

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

Vous pouvez également ajouter une expression finale pour changer la valeur de tous les dés qui ne correspondent pas à une condition : T[>5]{15}{0}

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

Fonctions

DiceParser offre des fonctions pour gérer les instructions. Certaines fonctions arriveront bientôt (par exemple : max, min). Cela permettra de gérer plusieurs commandes à la fois.

Répéter

!repeat(1d10,5)

Sortie :

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

Attention ! Faites attention, repeat fonctionne mal avec plusieurs commandes d'instruction

Sol

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

La commande :

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

Ceil

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

La commande :

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

Arrondi

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

La commande :

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

La sortie

DiceParser offre des fonctionnalités vous permettant de contrôler la sortie des commandes. L'instruction finale doit être une instruction sous forme de chaîne. Une instruction sous forme de chaîne commence par " et se termine par ".

En cours :

résultat

Sortie : résultat

Vous pouvez définir une instruction de chaîne à l'intérieur de l'opérateur if :

1d6i:[>3]{"Succès"}{"Échec"}

Sortie : Succès ou Échec

Il offre une réponse rapide, mais parfois vous avez besoin de voir les valeurs obtenues. DiceParser peut remplacer certains tags spéciaux afin de voir les valeurs, le résultat du calcul et tout le reste.

Raccourcis

Il y a 3 balises de raccourci.

  • %1 : dernier résultat scalaire de chaque instruction.
  • %2 : tous les résultats des dés.
  • %3 : dernier résultat scalaire de la dernière instruction.

La sortie par défaut est %1 details[%2]. Ainsi, elle affiche le dernier résultat scalaire de chaque instruction et le résultat des dés.

« %1 » et « %3 » sont équivalents lorsqu’il n’y a qu’une seule instruction (non ;).

Ils sont vraiment utiles, mais si vous avez beaucoup d'instructions, cela peut devenir un peu désordonné.

Résultat final

Il est également possible de définir une référence à la valeur finale d'une instruction spécifique (le résultat doit être un nombre ou une chaîne).

  • Pour faire référence à la première instruction : $1
  • Pour faire référence à la deuxième instruction : $2
  • Pour faire référence à la troisième instruction : $3

Il n'y a pas de limite au nombre d'instructions.

Chaîne comme résultat final

Vous pouvez faire référence au sous-résultat d'un résultat de chaîne en ajoutant [x] après la référence de l'instruction. Voyons un exemple, ce sera plus facile à comprendre.

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

Le résultat par défaut ressemble à ceci :

cats,bats

Maintenant, nous voulons faire une phrase avec ce texte :

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

Comme $1 fait référence à « chats,chauves-souris », il affichera :

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

Donc, ce n'est pas vraiment utile. Pour l'améliorer un peu, nous devons ajouter quelques sous-index.

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

alors nous avons une sortie correcte.

Tu aimes les chats et tu as peur des chauves-souris

Voyons quelques exemples :

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

La sortie par défaut affiche : 45,4,0,4 détails[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]"}}

Voici un exemple de sortie :

  • 4 Succès[4,3,10,7,2,2,7,10]
  • Échec 0 [10,3,1,1,2,2,7,5] (2 réussites - 2 échecs = 0)
  • Échec critique -2 [1,3,1,1,2,2,7,5] (1 réussite - 3 échecs = -2)

Dans cet exemple, l'échec critique se produit lorsqu'il y a plus d'échecs que de réussites. Dans l'exemple suivant, l'échec critique se produit lorsqu'il n'y a eu aucun succès et au moins un échec.

!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 autre exemple, pour montrer comment combiner une chaîne et le résultat d'un dé.

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

Vous avez trouvé 5 pièces d'or

Résultat du dé

DiceParser fournit des balises pour afficher le résultat des dés (et chaque valeur obtenue à partir d'une instruction spécifique).

Pour afficher les valeurs des dés d'une instruction spécifique, il suffit d'ajouter @ suivi du numéro de l'instruction (ex : @1)

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

Le résultat :

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

Nouvelle ligne

Vous pourriez avoir besoin d'afficher votre résultat sur plusieurs lignes. C'est vraiment facile :

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

Cette commande affichera :

Attack: 31

Attaque : 31 Dégâts : 7

Arithmétique

Rolisteam Dice Parser est capable d'effectuer des opérations arithmétiques de base telles que : +, -, /, * et il gère également la priorité de ces opérateurs ainsi que les parenthèses.

!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

Roll 2 dice and add 3 to the sum of those dice. Then the result is used for rolling dice: !(3+2D6)D10

Arithmétique et dés

Il est possible d'utiliser des opérations arithmétiques sur les dés. Veuillez noter que l'opération par défaut pour convertir une liste de dés en scalaire est la somme. Ainsi, si vous lancez 3d6, le résultat sera une liste avec 3 valeurs {2, 5, 1}. Maintenant, nous modifions un peu la commande 3d6+4 : elle se résout comme suit : {2, 5, 1} = 8 ; 8+4 = 12. Le résultat final est 12.

  • !3d6+4 ⇾ Roll 3 dice; sum the result; and add 4:
  • !10D10-2 ⇾ Roll 10 dice; sum the result; and then subtract 2
  • !87-1D20 ⇾ Subtract the result of 1 die to 87
  • !(6-4)D10 ⇾ Subtract 4 to 6 and then roll two dice.
  • !1D10/2 ⇾Divide by 2 the result of 1 die.
  • !(2+2)**2 ⇾ Result: 16
  • !1d10**2 ⇾ Roll 1d10 then multiply the result by itself.
  • !15|2 ⇾ Integer division of 15 by 2. Result: 7
  • !15/2 ⇾ Division of 15 by 2. Result: 7.5

Validateur

Il existe cinq types de validateurs :

  • Scalaire
  • Intervalle
  • Expression booléenne
  • Opérations possibles
  • Composite

Tout opérateur nécessitant un validateur (tel que a,r,e,c) peut utiliser ces trois types.

Scalaire

La valeur scalaire définit le validateur sur l'égalité entre la valeur du dé et le validateur

!4d10e10

Cette commande signifie : lance 4 dés et ils explosent sur 10.

Intervalle

L’intervalle est défini par deux limites. Vous devez utiliser des crochets et les deux limites sont séparées par ...

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

Condition booléenne

La commande compte combien de dés ont des valeurs comprises entre 8 et 10.

!4d10c[>7]

La commande compte combien de dés sont supérieurs à 7.

Opérateur de comparaison

Le parseur de dés Rolisteam vous permet d'utiliser plusieurs opérateurs logiques :

  • Égal : =
  • Supérieur ou égal : >=
  • Inférieur ou égal : <=
  • Inférieur : <
  • Supérieur : >
  • Différent : !=

Comparer les méthodes

Comme pour l'opérateur SI, vous pouvez spécifier la méthode de comparaison.

  • Sur chacun : la condition est testée sur chaque dé de la partie précédente de la commande. [Méthode par défaut]
  • Sur chaque valeur ? : la condition est testée sur chaque valeur finale du dé provenant de la partie précédente de la commande.
  • Tous * : Tous les dés doivent satisfaire la condition pour retourner vrai. Si tous les dés ne remplissent pas la condition, faux est retourné.
  • L'un d'eux . : au moins un dé doit remplir la condition pour retourner vrai. Si aucun dé ne remplit la condition, alors faux est retourné.
  • Sur scalaire : : la condition est évaluée sur le résultat scalaire du lancer de dés.
Exemples :
!1L[7,8,9]c[>6]

Cette commande renverra 0 car aucun dé n'a été lancé, donc le résultat de 1L[7,8,9] est une valeur finale.

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

Sortie : 1

!5d6e6sc[>=8]

Sortie :

0 détails : [8 [6,2] 2 1 1 1]

!5d6e6f[?>=16]

Sortie : Comme la somme finale est égale à 11. C'est moins que 16, donc le filtre filtre tout.

0 détails : [2 4 1 3 1]

La somme finale est supérieure à 16, donc le résultat entier est accepté par l'opérateur de filtrage.

23 détails : [3 6 3 5 6]

!5d6e6sc[:>=8]

Sortie :

1 détails : [8 [6,2] 2 1 1 1]

Opérations possibles

Ce validateur propose le modulo comme opération et une condition booléenne pour valider la valeur :

!4d10c[%2=0]

Comptez combien de nombres pairs ont été lancés.

!4d10c[%2=1]

Comptez combien de nombres impairs ont été lancés.

modulo

Validateur composite

Le validateur peut être le résultat de plusieurs validateurs.

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

Comptez tous les dés supérieurs à 4 et pairs [6,8,10].

Le validateur composite prend en charge 3 opérations logiques :

  • ET : &
  • OU : |
  • OU exclusif : ^

Le validateur composite accepte autant de validateurs que vous en avez besoin :

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

Opérateur de liste

Valeurs textuelles

L'opérateur L (ou l) (signifiant liste) offre un moyen de récupérer une valeur à partir d'une liste.

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

Avec commentaire

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

Suis-je mauvais ? Oui

Obtenir des valeurs uniques

Le paramètre u demande des valeurs uniques.

!2Lu[yes,no]

Cette commande peut retourner yes,no ou no,yes. L'option u rend impossible le retour de yes,yes ou no,no

Supprimer la virgule entre les valeurs

Par défaut, les résultats sont affichés avec une virgule entre chaque valeur. Vous pouvez supprimer la virgule avec le paramètre n.

!2Ln[to,kyo]

Cette commande peut renvoyer toto, kyokyo, tokyo, kyoto.

Unique sans virgule

!2Lun[to,kyo]

ou

!2Lnu[to,kyo]

Ces commandes peuvent renvoyer tokyo ou kyoto.

Valeurs numériques

Si la valeur est un nombre, elle est également traitée comme telle et vous pouvez effectuer des calculs ou utiliser n'importe quel opérateur.

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

Texte et chiffre en même temps

Il n'est pas recommandé d'utiliser du texte et des nombres dans le même opérateur de liste. Actuellement, le comportement change en fonction du résultat. Si la valeur choisie est un nombre, vous pouvez effectuer d'autres calculs, mais sinon, le résultat est affiché directement sans aucun contrôle.

Le comportement changera dans une future version pour baser la décision sur l'ensemble de données. Si l'ensemble de données ne contient que des nombres, le calcul sera possible. Sinon, il sera traité comme un résultat de type chaîne de caractères.

Changer les probabilités

Il y a deux principales façons de contrôler le poids d’un élément dans la liste.

La méthode de la fourmi

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

ou

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

La méthode paresseuse

Par plage :

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

Par poids :

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

Plusieurs résultats :

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

Exemples divers

!3D100

Lancez 3 dés à 100 faces

!10D10e[=10]s

Lancez 10 dés à 10 faces, 10 explose, et triez le résultat.

!100291D66666666s

Lancez 100291 dés avec 66666666666 faces et triez le résultat

!15D10c[>7]

lancez 15 dés à 10 faces et comptez le nombre de dés supérieurs à 7

!1D8+2D6+7

lancez 1 dé à 8 faces et ajoutez le résultat à 2 dés à 6 faces, puis ajoutez 7.

!D25

lancer un dé à 25 faces

!88-1D20

88 moins la valeur d'un dé à 20 faces

!8+8+8

calculer : 24

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

L'un de ces mots sera choisi.

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

Lancez 8 dés à 10 faces, puis calculez combien de dés respectent la condition Validator1 et soustrayez le nombre de dés qui respectent Validator2, puis affichez le nombre (Voir Validator pour plus de détails sur la syntaxe)

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

Ancien Monde dans un système d'obscurité.

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

Système Exalted 2e édition.

Ajouter une macro et une commande

Disons que nous voulons définir 2 macros : a et aa.

Je dois les ajouter du nom le plus complexe au plus simple.

Mauvais

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

exécution de aa : Le système de macros va comparer aa avec la première macro a et cela correspond. Première évaluation, aa => 1d10a Deuxième évaluation, 1d10a => 1d101d10 Commande finale à exécuter : 1d101d10

Bien

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

Lorsque j'exécute la commande : aa. Le système de macros comparera aa avec aa : correspondance Première évaluation : aa => 2d10 Commande finale à exécuter : 2d10

Quelques règles

  1. Utilisez des expressions régulières pour ajouter des contraintes concernant la substitution de texte
  2. Utilise un nom complètement différent
  3. Évitez les motifs de macro qui sont inclus dans un autre motif de macro

Tu devrais aller bien.

Meilleures pratiques

À mesure que DiceParser propose de plus en plus de fonctionnalités, vous pourriez trouver plusieurs façons de faire la même chose. Nous voulons ici expliquer la différence entre ces différentes approches. Ainsi, vous pourrez utiliser celle qui convient le mieux.

Lance plusieurs types de dés et fais leur somme

Mauvais

!2d8;2d10m

Bon

!2d8+2d10

L'opérateur de fusion est utile lorsque vous voulez utiliser l'opérateur de dés sur tous les dés lancés.

Mauvais

!1d20K1+1d10K1

Bon

!1d20+1d10

L'opérateur k pour garder autant de dés que vous lancez est assez inutile car c'est le comportement par défaut.

Documentation des macros

Exemples et plus d'informations

Rapport de bogue et nouvelles fonctionnalités

Please fulfill a ticket in our Bug tracker system. Or contact us on discord or any other ways