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

U kunt een tekenreeksinstructie binnen de if-operator plaatsen:

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

Uitvoer: Success of Fail

Het geeft een snel antwoord, maar soms wilt u de gegooide waarden zien. DiceParser kan bepaalde speciale tags vervangen om waarden, berekeningsresultaten en meer om te bekijken.

Sneltoetsen

Er zijn 3 snelkoppelingstags.

  • %1: laatste scalaire resultaat van elke instructie.
  • %2: alle dobbelsteenresultaten.
  • %3: laatste scalaire resultaat van de laatste instructie.

De standaarduitvoer is %1 details[%2]. Het toont dus het laatste scalaire resultaat van elke instructie en het dobbelsteenresultaat.

%1 en %3 zijn equivalent wanneer er slechts één instructie is (geen ;).

Ze zijn erg handig, maar als u veel instructies hebt, kan het een beetje rommelig worden.

Eindresultaat

Het is ook mogelijk om een ​​verwijzing in te stellen naar de uiteindelijke waarde van een specifieke instructie (het resultaat moet een getal of een tekenreeks zijn).

  • Om naar de eerste instructie te verwijzen: $1
  • Om naar de tweede instructie te verwijzen: $2
  • Om naar de derde instructie te verwijzen: $3

Er is geen limiet aan het instructienummer.

Tekenreeks als eindresultaat

U kunt naar het subresultaat van een tekenreeks verwijzen door [x] toe te voegen na de instructie. Laten we een voorbeeld bekijken, dan is het makkelijker te begrijpen.

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

Het standaardresultaat ziet er als volgt uit:

cats,bats

Nu willen we een zin maken met deze tekst:

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

Omdat $1 verwijst naar "katten, vleermuizen", zal het het volgende tonen:

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

Het is dus niet echt nuttig. Om het wat te verbeteren, moeten we enkele subindexen toevoegen.

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

Dan hebben we een correcte uitvoer.

U houdt van katten en u bent bang voor vleermuizen

Laten we eens naar een paar voorbeelden kijken:

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

De standaarduitvoer toont: 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]"}}

Hier volgt een voorbeeld van de uitvoer:

  • 4 Success[4,3,10,7,2,2,7,10]
  • Mislukt 0 [10,3,1,1,2,2,7,5] (2 successen - 2 mislukkingen = 0)
  • Kritieke mislukking -2 [1,3,1,1,2,2,7,5] (1 succes - 3 mislukkingen = -2)

In dit voorbeeld treedt de kritieke fout op wanneer er meer fouten dan successen zijn. In het volgende voorbeeld treedt de kritieke fout op wanneer er geen successen zijn en minstens één fout.

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

Nog een voorbeeld, om te laten zien hoe u een tekenreeks en een dobbelsteenresultaat kunt combineren.

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

U hebt 5 gouden munten gevonden

Resultaat van dobbelsteen

DiceParser biedt tags om het dobbelresultaat weer te geven (en elke gegooide waarde van een specifieke instructie).

Om de dobbelsteenwaarden van een specifieke instructie weer te geven, voegt u gewoon @ toe, gevolgd door het instructienummer (bijv.: @1).

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

De uitvoer:

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

Nieuwe regel

Mogelijk moet u uw resultaat over meerdere regels weergeven. Dat is heel eenvoudig:

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

Deze opdracht zal het volgende weergeven:

Attack: 31

Schade: 7

Rekenen

Rolisteam Dice Parser kan primaire rekenkundige bewerkingen uitvoeren zoals: +, -, /, * en beheert ook de prioriteit van deze bewerkingen. Daarnaast kan het ook haakjes verwerken.

!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

Gooi 2 dobbelstenen en tel 3 op bij de som van de resultaten. Het resultaat wordt vervolgens gebruikt om dobbelstenen te gooien: !(3+2D6)D10

Rekenen en dobbelstenen

Het is mogelijk om rekenkundige bewerkingen uit te voeren op dobbelstenen. Let op: de standaardbewerking om een ​​dobbelsteenlijst naar een scalaire waarde om te zetten, is de som. Dus als u met 3d6 gooit, krijgt u een lijst met 3 waarden: {2, 5, 1}. Nu passen we de opdracht 3d6+4 een beetje aan: deze wordt als volgt opgelost: {2, 5, 1} = 8; 8+4 = 12. Het eindresultaat is 12.

  • !3d6+4 ⇾ gooi 3 dobbelstenen; tel de resultaten op; en tel er 4 bij op:
  • !10D10-2 ⇾ gooi 10 dobbelstenen; tel de resultaten op; en trek daarna 2 af
  • !87-1D20 ⇾ Trek het resultaat van 1 dobbelsteen van 87 af
  • !(6-4)D10 ⇾ Trek 4 af van 6 en gooi vervolgens twee dobbelstenen.
  • !1D10/2 ⇾ deel door 2 het resultaat van 1 dobbelsteen.
  • !(2+2)**2 ⇾ Resultaat: 16
  • !1d10**2 ⇾ gooi 1d10 en vermenigvuldig het resultaat met zichzelf.
  • !15|2 ⇾ Geheel getal deling van 15 door 2. Resultaat: 7
  • !15/2 ⇾ delen van 15 door 2. Resultaat: 7.5

Validator

Er zijn vijf soorten validators:

  • Scalair
  • Bereik
  • Booleanse uitdrukking
  • Voorwaardelijke-operator
  • Composiet

Elke operator die een validator vereist (zoals a,r,e,c) kan deze drie soorten gebruiken.

Scalair

De scalaire waarde stelt de validator in op gelijkheid tussen de dobbelsteenwaarde en de validator.

!4d10e10

Dit commando betekent: gooi 4 dobbelstenen, en ze exploderen bij een 10.

Bereik

Het bereik wordt gedefinieerd door twee grenzen. U moet vierkante haken gebruiken en de twee grenzen worden gescheiden door ...

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

Booleaanse voorwaarde

Het commando telt hoeveel dobbelstenen een waarde hebben tussen >=8 en <=10.

!4d10c[>7]

Het commando telt hoeveel dobbelstenen een waarde hoger dan 7 hebben.

Vergelijk operator

Met de Rolisteam Dice Parser kunt u verschillende logische operatoren gebruiken:

  • Gelijk aan: =
  • Groter of gelijk aan: >=
  • Kleiner of gelijk aan: <=
  • Kleiner: <
  • Groter dan: >
  • Verschillend: !=

Vergelijk methoden

Als if-operator kunt u de vergelijkingsmethode specificeren.

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

Deze opdracht geeft 0 terug, omdat er geen dobbelsteen is gegooid, dus het resultaat van 1L[7,8,9] is een eindwaarde.

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

Uitvoer: 1

!5d6e6sc[>=8]

Uitvoer:

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

!5d6e6f[?>=16]

Uitvoer: Omdat de eindsom gelijk is aan 11. Dat is minder dan 16, dus het filter filtert alles.

0 details: [2 4 1 3 1]

De eindsom is hoger dan 16, dus het hele resultaat wordt geaccepteerd door de filteroperator.

23 details: [3 6 3 5 6]

!5d6e6sc[:>=8]

Uitvoer:

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

Voorwaardelijke-operator

Deze validator biedt de modulo-operator als bewerking en een Booleaanse voorwaarde om de waarde te valideren:

!4d10c[%2=0]

Tel hoeveel even getallen er zijn gegooid.

!4d10c[%2=1]

Tel hoeveel oneven getallen er zijn gegooid.

modulo

Samengestelde validator

Een validator kan het resultaat zijn van meerdere validators.

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

Tel alle dobbelstenen groter dan 4 en even [6, 8, 10].

Samengestelde validator ondersteunt 3 logische bewerkingen:

  • AND : &
  • OR : |
  • Exclusieve OF : ^

Samengestelde validator accepteert evenveel validators als u nodig hebt:

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

Lijstoperator

Tekstwaarden

De operator L (of l) (wat staat voor lijst) biedt een manier om een ​​waarde uit een lijst te halen.

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

Met commentaar

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

Ben ik slecht ? Ja

Unieke waarden verkrijgen

De parameter u vereist unieke waarden.

!2Lu[yes,no]

Deze opdracht kan yes,no of no,yes retourneren. De 'u' maakt het onmogelijk om yes,yes of no,no te retourneren.

Verwijder de komma tussen de waarden

Standaard worden de resultaten weergegeven met een komma tussen elke waarde. U kunt de komma verwijderen met de parameter n.

!2Ln[to,kyo]

Deze opdracht kan toto, kyokyo, tokyo, kyoto retourneren.

Uniek zonder komma

!2Lun[to,kyo]

of

!2Lnu[to,kyo]

Die commando's kunnen tokyo of kyoto retourneren.

Getalwaarden

Als de waarde een getal is, wordt deze ook als zodanig behandeld en kunt u er berekeningen mee uitvoeren of elke operator gebruiken.

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

Tekst en getal tegelijk

Het is niet aan te raden om tekst en getallen in dezelfde lijstoperator te gebruiken. Momenteel verandert het gedrag afhankelijk van het resultaat. Als de gekozen waarde een getal is, kunt u andere berekeningen uitvoeren, maar anders wordt het resultaat direct weergegeven zonder verdere controle.

Het gedrag zal in een toekomstige uitgave veranderen, waarbij de beslissing gebaseerd zal zijn op de gegevensset. Als de gegevensset alleen getallen bevat, is berekening mogelijk. Anders wordt het resultaat als een tekenreeks behandeld.

Verander het vreemde

Er zijn twee belangrijke manieren om de kans op een vreemde keuze in de lijst te beheersen.

De mierenmethode

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

of

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

De luie methode

Op reeks:

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

Op gewicht:

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

Verschillende resultaten:

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

Diverse voorbeelden

!3D100

Gooi 3 dobbelstenen met 100 zijden

!10D10e[=10]s

Gooi 10 dobbelstenen met 10 zijden, 10 explosies en sorteer het resultaat.

!100291D66666666s

Gooi 100291 dobbelstenen met 66666666666291 zijden en sorteer het resultaat

!15D10c[>7]

gooi 15 dobbelstenen met 10 zijden en tel het aantal dobbelstenen die boven 7 zijn

!1D8+2D6+7

Gooi 1 dobbelsteen met 8 zijden en tel het resultaat op bij 2 dobbelstenen met 6 zijden en tel daar 7 bij op.

!D25

Gooi 1 dobbelsteen met 25 zijden

!88-1D20

88 min de waarde of 1 dobbelsteen met 20 zijden

!8+8+8

berekenen: 24

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

Een van deze woorden zal worden gekozen.

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

Gooi 8 dobbelstenen met 10 zijden, tel vervolgens hoeveel dobbelstenen voldoen aan de voorwaarde Validator1, trek het aantal dobbelstenen dat voldoet aan validator2 af en toon het resultaat (zie Validator voor meer informatie over de syntaxis).

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

Oude wereld in een systeem van duisternis.

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

Exalted 2e editie systeem.

Macro toevoegen en bestellen

Stel dat we twee macro's willen definiëren: a en aa.

Ik moet ze op volgorde van de meest complexe naam naar de eenvoudigste zetten.

Fout

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

Het uitvoeren van aa: het macrosysteem vergelijkt aa met de eerste macro a en die overeenkomst. Eerste evaluatie, aa => 1d10a Tweede evaluatie, 1d10a => 1d101d10 Eindopdracht die moet worden uitgevoerd: 1d101d10

Goed

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

Wanneer ik het commando aa uitvoer, vergelijkt het macrosysteem aa met 2d10: eerste evaluatie: aa => 2d10 Het uiteindelijke commando dat moet worden uitgevoerd: 2d10

Enige regels

  1. Gebruik reguliere expressies om beperkingen op te leggen aan tekstvervanging
  2. Gebruik een compleet andere naam
  3. Vermijd macropatronen die onderdeel uitmaken van een ander macropatroon

Het komt vast goed.

Beste praktijk

Naarmate DiceParser meer en meer functies biedt, zult u wellicht verschillende manieren vinden om hetzelfde te doen. We willen hier het verschil tussen deze verschillende benaderingen uitleggen. Zo kunt u de juiste methode kiezen.

Gooi met verschillende soorten dobbelstenen en tel de resultaten bij elkaar op

Fout

!2d8;2d10m

Goed

!2d8+2d10

De samenvoegingsoperator is handig wanneer u de dobbelsteenoperator op alle gegooide dobbelstenen wilt toepassen.

Fout

!1d20K1+1d10K1

Goed

!1d20+1d10

De k-operator om evenveel dobbelstenen te behouden als u gooit, is vrij nutteloos omdat dit het standaardgedrag is.

Macro-documentatie

Voorbeelden en meer informatie

Bugrapporten en nieuwe functies

Dien een ticket in via ons bugvolgsysteem. Of neem contact met ons op via Discord of via een van de andere manieren.