Table of content

DiceParser: Wat is het?

DiceParser is een softwarecomponent waarmee u dobbelstenen kunt gooien met behulp van eenvoudige commando's. Deze softwarecomponent is beschikbaar op verschillende platforms, zoals: Discord-bot, onderdeel van Rolisteam, Twitter, enz.

Over de voorbeelden in deze documentatie

Voor de duidelijkheid: alle voorbeelden in deze documentatie tonen niet het opstartvoorvoegsel. Vergeet niet het juiste voorvoegsel toe te voegen, afhankelijk van waar u het dice-commando uitvoert: Rolisteam, Discord, IRC, enz. Als u het niet weet, probeer dan !. Het voorvoegsel zorgt ervoor dat het systeem uw commando kan herkennen.

Hoe een dobbelsteen te gooien

Het is heel eenvoudig. U hoeft alleen maar op te roepen:

!1d6

Het eerste getal is het aantal dobbelstenen dat u wilt gooien. Het tweede getal moet het aantal zijden zijn.

Voorbeelden

!1d6

Gooi een dobbelsteen met zes zijden.

!1d10

Gooi een dobbelsteen met tien zijden.

!5d10

Gooi vijf dobbelstenen met tien zijden.

!777d6

Gooi 777 dobbelstenen met zes zijden.

Dankzij diverse bewerkingen en opties kunt u uw gooi-commando enigszins aanpassen: zie Lijst van operators.

Dobbelsteen werpen in een reeks

!4d[-1..1]

Het gooien van 4 dobbelstenen met een waarde tussen -1 en 1. (Fudge/Fate-systeem)

!3d[0..9]

Gooi 3 dobbelstenen met 10 zijden, beginnend bij 0.

!3d[-20..-9]

Gooi 3 dobbelstenen met de waarden die liggen tussen -20 en -9.

Instructies

Het optellen (of andere rekenkundige bewerkingen) van de resultaten van twee (of meer) soorten dobbelstenen is eenvoudig:

!1d10+1d8

Om alle resultaten weer te geven zonder er bewerkingen mee uit te voeren, gebruikt u ; om meerdere instructies te markeren.

!1d10;1d6 # 2 instructions

of

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

Op deze manier kunt u berekeningen uitvoeren als het resultaat van de eerste instructie aan een bepaalde voorwaarde voldoet, enzovoort. Als u bijvoorbeeld een aanval wilt uitvoeren, berekent de tweede instructie de schade. In de derde instructie kunt u het resultaat van de aanval vergelijken en, als de aanval geldig is, het volgende weergeven:

zie meer

Samenvoegen

Het is mogelijk om alle instructies in één grote instructie samen te voegen. De operator samenvoegen is daarvoor bedoeld. Het is handig wanneer u alle dobbelsteenresultaten als hetzelfde resultaat wilt behandelen.

Stel bijvoorbeeld dat u de hogere dobbelstenen tussen een d6 en een d8 moet houden.

!d6;d8mk1

Meer details over de k-operator vindt u in Lijst van operators.

Berekening tussen instructies

Dankzij het variabelensysteem is het mogelijk om naar het resultaat van een specifieke instructie te verwijzen.

  • Om naar de eerste instructie te verwijzen: $1
  • Om naar de tweede instructie te verwijzen: $2
  • Om naar de derde instructie te verwijzen: $3 etc… het aantal instructies is niet beperkt.
!8d10;$1c[>6];$1c1;$2-$3
  • De eerste instructie is het gooien van 8 (tienzijdige) dobbelstenen
  • De tweede instructie telt hoeveel dobbelstenen een waarde hoger dan 6 hebben.
  • De derde instructie telt hoeveel dobbelstenen gelijk zijn aan 1.
  • De vierde instructie trekt het resultaat van de derde instructie af van het resultaat van de tweede instructie.

Lijst met operators

  • k: bewaren
  • K: explodeer en bewaar
  • kl: lager behouden
  • s: sorteer
  • c: telling
  • r: opnieuw gooien
  • r: opnieuw gooien tot
  • e: explodeer
  • a: opnieuw gooien en optellen
  • @: spring terug
  • p: schilder dobbelsteen
  • m: samenvoegen
  • i: indien
  • ;: volgende instructie
  • g: groepeer
  • b: verbind
  • #: Toelichting

Behouden

!kX

Deze optie sorteert de resulterende lijst met dobbelstenen en selecteert de X dobbelstenen met de hoogste waarde.

Explodeer en bewaar

!KX

Dobbelstenen exploderen als hun waarde de maximale waarde van de dobbelsteen bereikt. De optie sorteert de resulterende lijst met dobbelstenen en selecteert vervolgens de X dobbelstenen met de hoogste waarde.

Voorbeelden

!6d10K4

Gooi 6 dobbelstenen met 10 zijden, elke 10 explodeert. De waarde van de geëxplodeerde dobbelstenen is dus groter dan 10. Resultaat: 40 details: 23 [10,10,3],9,5,3,1,1

Een andere manier om dit commando te schrijven is:

!6d10e10k4

Op deze manier kunt u de explosiedrempel wijzigen.

Om het getal te berekenen dat u wilt behouden, beheert de operator k de variabele. U kunt de berekening niet direct achter de k plaatsen, maar u kunt wel verwijzen naar een eerdere berekening.

# Good
!5-3;10d10k$1 

# BAD
!10d10k5-3

# BAD
!10d10k(5-3)

Lagere dobbelsteen behouden

klX

Deze optie sorteert de resulterende lijst, en selecteert daarna de X dobbelstenen met de laagste waarde.

Sorteren

!3D10s

De lijst met dobbelstenen is gesorteerd in aflopende volgorde.

!10d6sl

Er worden 6 dobbelstenen met 6 zijden gegooid, waarna ze in oplopende volgorde worden gesorteerd

Aantal

!3D10c[Validator]

Tel hoeveel dobbelstenen aan de voorwaarde voldoen en toon het aantal (zie Validator voor meer informatie over de syntax)

Opnieuw gooien

!3D10r[Validator]

Gooi de dobbelsteen opnieuw als de vorige waarde overeenkomt met de validator (zie Validator voor meer informatie over de syntaxis).

Opnieuw gooien tot

!3D10R[Validator]

Werkt net als "Opnieuw gooien", maar blijf de dobbelstenen gooien totdat de voorwaarde niet meer waar is.

Explodeer

!3D10e[Validator]

Explodeer de waarde zolang deze voldoet aan de Validator (zie Validator voor meer informatie over de syntaxis).

!3D10e(3)[Validator]

Een explode-node kan een limiet hebben op het aantal keren dat de dobbelsteen explodeert.

!3D10e(1d10)[Validator]

De limiet is een expressie.

Voorbeelden

!3D10e10

Als de dobbelsteenwaarde gelijk is aan 10, wordt de dobbelsteen opnieuw gegooid en het resultaat wordt opgeteld bij de vorige dobbelsteenwaarde.

Resultaat: 49 details: 8, 12 [10,2], 29 [10,10,9]

!3D10e[>8]

Als de dobbelsteenwaarde groter is dan 8, wordt de dobbelsteen opnieuw gegooid en wordt het resultaat bij de vorige dobbelsteenwaarde opgeteld.

Resultaat: 35 details: 3, 27 [9,10,8], 5

Toevoegen

!3D10a[Validator]

Gooi de dobbelsteen opnieuw als de waarde overeenkomt met de Validator en tel de nieuwe waarde op bij de vorige. Dit gebeurt slechts één keer.

Voorval

!10d10o

Tel en sorteer het aantal voorkomende waarden. Resultaat: 3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]

!10d10o2,7

Tel en sorteer de voorkomende waarden wanneer ze minstens 2 keer voorkomen en de waarde 7 of hoger is. Resultaat: 2x8 - [1,2,3,5,6,7,8,8,9,10]

!10d10o2[<6]

Tel en sorteer de voorkomende waarden. Wanneer ze minstens twee keer voorkomen, moet de waarde voldoen aan de validatiecriteria (hier minder dan 6). Resultaat: 2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]

Fouten

!10d10o[<6]

Deze opdracht geeft een waarschuwing. De operator voor het detecteren van gebeurtenissen kan namelijk 0 of 2 parameters hebben. Maar slechts één validator wordt nog niet ondersteund.

Spring terug

Deze operator is bedoeld om de volgende operator toe te passen op het voorlaatste resultaat. Bijvoorbeeld:

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

c[=10] in dit commando telt het aantal tienen in de uitkomst van 8D10. Als u de @ verwijdert, probeert het het aantal tienen te tellen in de uitkomst van c[>=7]. De uitkomst van c[>=7] is een scalair getal (1 of 2 ... (maximale waarde 8)); het is geen dobbelsteenlijst.

Verf

!8D10p[1:blue]

Verf de eerste dobbelsteen in de lijst blauw

!8d10p[2:blue]

Verf de eerste twee dobbelstenen in de lijst blauw.

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

De hoeveelheid kleur is afhankelijk van de clienttoepassing van DiceParser.

  • Met Rolisteam kunt u de naam van elke Qt-kleur instellen of de hexadecimale code van uw kleur instellen: #ff28AC.
  • De CLI-applicatie ondersteunt een beperkt aantal kleuren: zwart, wit, blauw, rood, zwart, groen, geel.

Filter

Met de filteroperator kunt u bepaalde dobbelsteenresultaten negeren op basis van een validator.

!4d6f[!=6]

Resultaat:

totaal: 11 - details[5 2 6 4]

de 6 wordt genegeerd.

Samenvoegen

De samenvoegingsoperator wordt gebruikt om meerdere worpen van verschillende dobbelsteentypen samen te voegen tot één dobbelsteenresultaat, waarna u elke gewenste operator kunt toepassen.

!1d6;1d8mk1

Deze opdracht voegt het resultaat van d6 en d8 samen. Vervolgens wordt de operator k op beide resultaten toegepast om het beste resultaat te behouden. Let op: deze operator voegt de instructielijst samen. Instructiereferenties (zoals $1, enz.) werken niet meer na de samenvoegingsoperator.

Spreiding

Het maakt van geëxplodeerde dobbelstenen nieuwe dobbelstenen. De operator wordt geactiveerd door y.

!4d6e6y6k3

Eerste resultaat: 10 [6, 4], 3, 3, 2
Resultaat na spreiding: 6, 4, 3, 2
Eindresultaat: 6+4+3 = 13

Helemaal hetzelfde

Deze operator is tijdelijk. Hij is bedoeld om problemen met het Tunnels- en Trolls-systeem op te lossen. Daarom is de markeroperator t. Dobbelstenen exploderen wanneer alle dobbelstenen dezelfde waarde hebben.

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

Uniek

Het maakt van geëxplodeerde dobbelstenen nieuwe dobbelstenen.

!4d6e6u

Resultaat: 6 4 3 3 2 Eindresultaat: 6+4+3 = 13

Lijst met waarden

Stel uw eigen waardelijst samen en pas een willekeurige dobbelsteenoperator toe.

![10,25,43,8]k1

Behaal een hogere score met behulp van meerdere instructies:

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

Elke waarde wordt omgezet in een dobbelsteen.

Verbind

Verbind werkt precies hetzelfde als samenvoegen, maar de instructie-array blijft ongewijzigd.

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

Gooi twee 8-zijdige dobbelstenen en twee 12-zijdige dobbelstenen en combineer de resultaten. Gebruik dit eindresultaat om de twee hoogste worpen te behouden en isoleer vervolgens de laagste van de twee hoogste. Aan het einde tonen we het resultaat in een zin.

If

If-operator betekent u toestaan iets te doen als een voorwaarde waar is. De if-operator heeft twee verplichte parameters:

  • De voorwaarde (zie validator)
  • de instructie om te handelen wanneer deze waar is.

Er zijn ook 2 optionele parameters.

  • de vergelijkingsmethode
  • de instructie om te handelen wanneer deze niet-waar is.

i*[]{}{}

  • *: de vergelijkingsmethode
  • []: de validator

Vergelijkingsmethode

Er zijn vier verschillende methoden.

  • Bij elke: de voorwaarde wordt getest op elke dobbelsteen uit het vorige deel van de opdracht. [Standaardmethode]
  • Bij elke waarde ?: de voorwaarde wordt getest op elke eindwaarde van dobbelsteen uit het vorige deel van de opdracht.
  • Allemaal *: Alle dobbelstenen moeten aan de voorwaarde voldoen om de instructie voor waar te activeren. Als geen van de dobbelstenen aan de voorwaarde voldoet, wordt de instructie voor niet-waar uitgevoerd.
  • Eén ervan .: minstens één dobbelsteen moet aan de voorwaarde voldoen om de instructie voor waar te activeren. Als geen enkele dobbelsteen aan de voorwaarde voldoet, wordt de instructie voor niet-waar uitgevoerd.
  • Op scalaire waarde :: de voorwaarde wordt geëvalueerd op het scalaire resultaat van de dobbelsteenworp.

Voorbeelden:

!1d6i[<4]{3}

Als de waarde van de dobbelsteen kleiner is dan 4, is de waarde van de dobbelsteen 3. (Dus 1, 2, 3 worden 3).

!4d6e6i[=4]{-4}

Als de dobbelsteen de waarde 4 heeft, wordt deze verwijderd. [Kuro System]

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

Als minstens één dobbelsteen een 6 aangeeft, gooi dan nog een d6 en tel het resultaat bij de dobbelsteen op.

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

Als alle dobbelstenen een 6 opleveren, gooi dan nog een d6 en tel het resultaat bij de uitkomst op.

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

Als de som van twee dobbelstenen groter is dan 15, wordt "Succes" weergegeven. Anders wordt "Mislukt" weergegeven.

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

Hetzelfde als hierboven, maar het eindresultaat wordt naast Succes of Mislukt weergegeven.

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

Hetzelfde als hierboven, maar het resultaat van elke dobbelsteen wordt tussen vierkante haken weergegeven.

Groep

Groepeer de dobbelstenen en tel vervolgens het aantal groepen (7e zeesysteem).

Complexe uitvoer

De groepsoperator kan een parameter accepteren om de complexe uitvoer te activeren. Deze uitvoer toont elke groep en eventuele overgebleven waarden. Om deze uitvoer te activeren, moet er een s direct na de g worden toegevoegd. Zie het onderstaande voorbeeld:

Voorbeeld

!3d20g10

Dit spel gooit 3 dobbelstenen en probeert ze vervolgens te groeperen in groepen van 10. Als u 9 9 2 krijgt, kunt u slechts één groep maken waarvan de waarde groter of gelijk is aan tien ({9,2}, waarbij de tweede 9 "verspild" is).

Met de g-operator mag u dobbelstenen herschikken om groepen te creëren. Als u bijvoorbeeld 4d20g10 gooit en u krijgt 7 4 3 6, dan is het resultaat 2 ({7,3} en {6,4}).

!5d10gs10

Het eindresultaat zal dan zijn:

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

{7,3} en {6,4} zijn groeperingen, en [2] wordt buiten beschouwing gelaten.

Hoofd-/kleine letter omwisselen (S)

Met de operator hoofd-/kleine letter omwisselen kunt u een numerieke waarde omzetten in tekst. Het doel hiervan is om dit eenvoudiger te maken dan met meerdere if-statements. Zoals u wellicht verwacht, is de syntaxis vergelijkbaar met die van if.

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

U kunt ook een standaardoptie toevoegen.

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

Exclusieve modus: deze modus is ingeschakeld wanneer een ^ na de S staat.

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

Toelichting

!2D6 # Sword attack

Toon "Zwaard aanval" en het resultaat van de twee dobbelstenen. DiceParser negeert alles na de #. Het hele gedeelte wordt als één commentaar behandeld. Dus DiceParser kan de vraag beantwoorden:

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

Ben ik slecht ? Ja

Transformeren

Transformeer dobbelstenen op basis van een voorwaarde naar een andere waarde.

!5d10T[>5]{15}

Gooi 5 dobbelstenen met 10 zijden en vervang vervolgens alle waarden groter dan 5 door 15 ende overige door 0.

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

Deze operator accepteert meerdere voorwaarden: T[=5]{15}[=6]{16}

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

U kunt ook een laatste expressie toevoegen om de waarde van alle dobbelstenen te wijzigen die niet aan een voorwaarde voldoen: T[>5]{15}{0}

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

Functies

DiceParser biedt functies voor het verwerken van instructies. Sommige functies zullen binnenkort beschikbaar komen (bijv. max, min). Hiermee kunnen meerdere opdrachten tegelijk worden verwerkt.

Herhalen

!repeat(1d10,5)

Uitvoer:

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

Let op! Wees voorzichtig, repeat werkt slecht met meerdere instructiecommando's

Floor

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

Het commando:

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

Ceil

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

Het commando:

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

Round

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

Het commando:

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

De uitvoer

DiceParser biedt functies waarmee u de uitvoer van de opdracht kunt beheren. De laatste instructie moet een tekenreeksinstructie zijn. Tekenreeksinstructies beginnen met " en eindigen met ".

Gooien:

"resultaat"

Uitvoer: resultaat

You can set string instruction inside if operator:

1d6i:[>3]{"Success"}{"Fail"}

Output: Success or Fail

It offers a quick answer ,but sometimes you need to see the rolled values. DiceParser can replace some special tags in order to see values, computation result and whatever.

Sneltoetsen

There are 3 shortcut tags.

  • %1: last scalar result from each instruction.
  • %2: all dice results.
  • %3: last scalar result from the last instruction.

The default output is %1 details[%2]. So, it shows the last scalar result of each instruction and dice result.

%1 and %3 are equivalent when there is only one instruction (no ;).

They are really useful but if you have many instructions that can become a bit messy.

Eindresultaat

It is also possible to set reference to the final value of specific instruction (the result should be a number or a string)

  • Om naar de eerste instructie te verwijzen: $1
  • Om naar de tweede instructie te verwijzen: $2
  • To reference the third instruction: $3

There is no limit on instruction number.

String as final result

You can reference the sub result of a string result by adding [x] after the instruction reference. Let see an example, it will be easier to understand.

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

The default result looks like this:

cats,bats

Now we want to make a sentence with this text:

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

As $1 refers to "cats,bats", it will show:

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

So, it is not really useful. In order to make it a bit better, we must add some sub-indexes.

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

Then we have a proper output.

You love cats and you are afraid of bats

Let see some examples:

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

The default output displays: 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]"}}

Here, some output example:

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

In this example, the critical fail happens when there are more fails than success. In the next example, the critical fail happens when there was no success and a least one fail.

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

Another example, to show how to combine string and dice result.

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

You found 5 gold coins

Dice Result

DiceParser provides tags to display dice result (and each rolled values from a specific instruction).

To show dice values from a specific instruction, just add @ followed by the instruction's number (e.g: @1)

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

De uitvoer:

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

Nieuwe regel

You may need to display your result on several lines. It is really easy:

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

This command will display:

Attack: 31

Schade: 7

Rekenen

Rolisteam Dice Parser is able to compute primary arithmetic operation such as: +, -, /, * and it also manages those operator priority and it can also manage parenthesis.

!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

Arithmetic and Dice

It is possible to use arithmetic operation on dice. Please pay attention that the default operation to translate a dice list to scalar is the sum. So if you roll 3d6, the result will be a list with 3 values {2, 5 ,1}. Now, we change a bit the command 3d6+4: It is resolved like this: {2, 5 ,1} = 8; 8+4 = 12. The final result is 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 ⇾ Resultaat: 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

Validator

There are five kinds of Validator:

  • Scalair
  • Bereik
  • Boolean expression
  • Condition Operation
  • Composiet

Any operator which requires validator (such as a,r,e,c) can use those three kinds.

Scalair

The scalar value sets the validator on equality between the dice value and the validator

!4d10e10

This command means: roll 4 dice, and they explode on 10.

Bereik

The range is defined as two bounds. You have to use square brackets and the two bounds are separated by ...

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

Boolean Condition

The command counts how many dice have values between >=8 and <=10.

!4d10c[>7]

The command counts how many dice are above 7.

Compare Operator

The Rolisteam Dice Parser allows you to use several logic operators:

  • Gelijk aan: =
  • Groter of gelijk aan: >=
  • Lesser or equal: <=
  • Lesser: <
  • Groter dan: >
  • Different: !=

Compare methods

As the if operator, you can specify the compare method.

  • Bij elke: de voorwaarde wordt getest op elke dobbelsteen uit het vorige deel van de opdracht. [Standaardmethode]
  • Bij elke waarde ?: de voorwaarde wordt getest op elke eindwaarde van dobbelsteen uit het vorige deel van de opdracht.
  • Allemaal *: Alle dobbelstenen moeten aan de voorwaarde voldoen om de instructie voor waar te activeren. Als geen van de dobbelstenen aan de voorwaarde voldoet, wordt de instructie voor niet-waar uitgevoerd.
  • Eén ervan .: minstens één dobbelsteen moet aan de voorwaarde voldoen om de instructie voor waar te activeren. Als geen enkele dobbelsteen aan de voorwaarde voldoet, wordt de instructie voor niet-waar uitgevoerd.
  • Op scalaire waarde :: de voorwaarde wordt geëvalueerd op het scalaire resultaat van de dobbelsteenworp.
Voorbeelden:
!1L[7,8,9]c[>6]

This command will return 0 because, no die has been rolled, so the result of 1L[7,8,9] is a final value.

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

Uitvoer: 1

!5d6e6sc[>=8]

Uitvoer:

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

!5d6e6f[?>=16]

Output: As the final sum is equal to 11. It's less than 16, so the filter is filtering everything.

0 details: [2 4 1 3 1]

The final sum is higher than 16, so the whole result is accepted by the filter operator.

23 details: [3 6 3 5 6]

!5d6e6sc[:>=8]

Uitvoer:

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

Condition Operation

This validator offers modulo as operation and a Boolean Condition to validate the value:

!4d10c[%2=0]

Count how many even numbers have been rolled.

!4d10c[%2=1]

Count how many odd numbers have been rolled.

modulo

Composite Validator

Validator can be the result of several validators.

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

Count all dice greater than 4 and even [6,8,10].

Composite Validator supports 3 logical operations:

  • AND : &
  • OR : |
  • Exclusive OR : ^

Composite Validator accepts as many validators as you need:

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

List operator

Tekstwaarden

The L (or l) operator (meaning list) provides a way to pick up value from list.

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

With comment

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

Ben ik slecht ? Ja

Getting unique values

The u parameter asks for unique values.

!2Lu[yes,no]

This command can return yes,no or no,yes. The u make it impossible to return yes,yes or no,no

Remove comma between values

By default, results are displayed with a comma between each value. You can remove the comma with the parameter n

!2Ln[to,kyo]

This command can return toto, kyokyo, tokyo, kyoto.

Unique with no comma

!2Lun[to,kyo]

of

!2Lnu[to,kyo]

Those commands can return tokyo or kyoto.

Number values

If the value is a number, it is treated as well, and you can do computation on it or use any operator.

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

Text and Number at the same time

It is not recommended to use text and number in the same list operator. Currently, the behavior changes given the result. If the chosen value is a number, you can do other computation, but otherwise, the result is displayed directly without any control on it.

The behavior will change in future release to base the decision on the data set. If the data set only contains numbers, then computation is possible. Otherwise, it will be treated as string result.

Change the odd

There are 2 main ways to control the odd on the pickup in the list.

The ant method

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

of

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

The lazy method

By range:

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

By weight:

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

Several results:

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

Miscellaneous Examples

!3D100

Roll 3 dice with 100 faces

!10D10e[=10]s

Roll 10 dice with 10 faces, 10 explodes, and sort the result.

!100291D66666666s

Roll 100291 dice with 66666666666 faces and sort result

!15D10c[>7]

roll 15 dice with 10 faces, and it counts number of dice which are above 7

!1D8+2D6+7

Roll 1 die with 8 faces and add the result to 2 dice with 6 faces and add 7.

!D25

roll 1 die with 25 faces

!88-1D20

88 minus the value of 1 die of 20 faces

!8+8+8

berekenen: 24

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

One of this word will be picked.

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

Roll 8 dice with 10 faces then it counts how many dice respect the condition Validator1 and substract the number of dice which respect the validator2 and display the number (See Validator for more details about syntax)

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

Old World in darkness system.

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

Exalted 2nd edition system.

Adding Macro and order

Let's say we want to define 2 macros: a and aa.

I must add them from the more complex name to the simplest.

Fout

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

Running aa: The macro system will compare aa with the first macro a and that match. First evaluation, aa => 1d10a Second evaluation, 1d10a => 1d101d10 Final command to be executed: 1d101d10

Goed

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

When I run the command: aa. The macro system will compare aa with aa: match First evaluation: aa => 2d10 Final command to be executed: 2d10

Some rules

  1. Use regular expression to add constrains about text substitution
  2. Use completely different name
  3. Avoid macro pattern that are included into another macro pattern

You should be fine.

Beste praktijk

As DiceParser provides more and more features, you may find several ways to do the same thing. We want here to explain the difference between those several approaches. Then you will be able to use the right one.

Roll several kind of dice and sum them

Fout

!2d8;2d10m

Goed

!2d8+2d10

The merge operator is useful when you want to use dice operator on all rolled dice.

Fout

!1d20K1+1d10K1

Goed

!1d20+1d10

The k operator to keep as many dice as you roll is pretty useless because it is the default behavior.

Macro documentation

Examples and More information

Bug report and new features

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