Help deciding on notation for two similar modifier changes

[GreenImp]

I need some feedback on some notation suggestions, for two similar bits of functionality:

Max re-rolls

#207 has introduced the ability to specify the maximum number of times that an exploding or re-roll modifier should explode / re-roll, even if the compare point is matched.

e.g.
Default behaviour:

// explode on a roll of 10, and keep exploding until a 10 isn't rolled
1d10!: [10!, 10!, 10!, 10!, 10!, 4] = 54

New behaviour:

// explode on a roll of 10, but only explode a maximum of `n` times (In this case, 2), even if it would usually explode
1d10!: [10!, 10!, 10] = 30

My thought for this notation was simply adding a number at the end (Before any compare point):

// `!2` means "explode, but no more than two times"
1d10!2: [10!, 10!, 10] = 30

Change number of dice re-rolled

By default, the exploding and re-roll modifiers roll a single die for each one that explodes / re-rolls.

// the 8 exploded and rolled one more die
1d8!: [8!, 3] = 11

#205 looks at the possibility to set a different amount of dice to roll, for each exploding / re-rolling die. The exact example is:

roll 1d8, if 8, then roll 2d8 and keep each result. Thus: roll:1d8, [8], automatically reroll:2d8: [6] and [5]

So, something like:

// the 8 exploded and rolled 2 more dice
1d8!: [8!, 3, 6] = 17

My thoughts of the notation for this are also:

// `!2` means "explode, and roll two die instead of 1"
1d8!2: [8!, 3, 6] = 17

The problem

The issue is that my thoughts on the notation for both of these things are the same. I can't think of a good notation to use for either, that doesn't conflict with the other.

Maybe one of them, or both, need to prefix the number, so it's explicit about what it is?

I'm honestly open to any suggestions.

[stevelle]

Starting from the needs of #205

s{group roll syntax}{cp}; substitute the indicated group roll for each roll matching the comparison point, if provided (default to matching max value, like ! does) to cover the explosion case (e.g. 1d8s{2d8} provides [6], [5]: 11)
&{op}{c}; to apply the calculation to each die (e.g. roll:4d4&+1 provides [4+1], [2+1], [4+1], [1+1]: 5, 3, 5, 2)

• op == mathematical operator
• c == constant numeric literal

This provides very rich mechanics for how to perform an exploding re-roll, and should do so with strong code and syntax reuse, by utilizing the existing group roll mechanic. My only question is how the latter syntax might play badly with the Maths functions.

I like the choice of s because a substitution is happening on a given (or default) comparison point -- the original rolled value is replaced by the group roll. I like the choice of & because it reads well: such as "4 times d4 and 1" in the provided example. Both of these are introducing new keywords (s and &) so the syntax should be unambiguous and flexible.

Moving to the needs of #207

! / !{cp} / !{n} / !{n}{cp}; explode n number of times to satisfy one condition of #207 with n = undefined puts no bound on explosion, optionally considering the provided comparison point
i / i{cp} / i{n} / i{n}{cp}; implode n number of times to satisfy one condition of #207 with n = undefined puts no bound on implosion, optionally considering the provided comparison point

This allows independent control of explosion and implosion e.g. 4d6!i+2 to indicate both unbounded explode and implode behaviors apply on a 6 or 1 respectively. We must specify n to limit explosion/implosion counts before the comparison point to disambiguate the syntax, when a limit is desired. This is consistent with

I like the symmetry on vertical axis of the ! vs i so this suggestion is keeping that from the #207 discussion.

Alternative:
For #207 we only need support for n = 1, so consider syntax like:
! / !{cp} / !o / 1o{cp} and i / i{cp} / io / io{cp} similar to that used today for Re-roll.

[GreenImp]

Thanks for your feedback here, it's really good! Seriously appreciated.

Needs of #205

s modifier

I like the idea of the "substitute" modifier, but I was really hoping to get it working with compounding and penetrating dice as well, just like the explode modifier does.
I suppose, a substitute modifier could also have a compound and penetrate options on it. However, it's then a lot of duplication of functionality.
I'd also like to be able to have the same functionality working on the re-roll modifier, where the original value is also dropped.

I'm also a bit wary of allowing the whole Group Rolls syntax in there, as I think that creates some technical difficulties. However, using the same curly braces, to surround the die notation could work.

I'm more than happy to discuss this, but I'm currently leaning more towards having it as an additional option on both the explode and re-roll modifiers (The JS classes can extend the same class or something similar).

Maybe even using your suggested notation:

!{cp}s{group roll syntax}
// or
!s{group roll syntax}{cp}

So you'd have things like:

4d6!s{2d8}>4
2d10!ps{3d2)
6d4!!s{2d6}=2

Although, I can possibly see cases where you might want to explode on one value, but only "substitute" with mutilple rolls on another value.
For example, you may want to explode on anything greater that or equal to 4, but only roll 2 extra dice on a roll of 6.

So maybe a notation like:

s{{d}{cp}}

Where {d} is the die syntax, and {cp} is the optional compare point:

s{2d8>4}

For example:

4d6!s{2d8=6}>=4
// or mayeb keep the substitute compare point outside of the curly braces and force the explode CP to be first
4d6!>=4s{2d8}=6

What are your thoughts?

& modifier

I didn't like the & modifier at first, but thinking about it, it's actually pretty good. It makes it more flexible that having separate mul, add, etc. modifiers. I think that's definitely a better notation than what I've done here #198 (comment)
It's also important that it still allows a compare point as well, so it would be something like:

&{op}{c}{cp}

Like so:

// add 2 to each roll
4d6&+2

// add 2 to each roll that is greater than 3
4d6&+2>3

What do you see as potential issue with the math functions?

Needs of #207

It's important for me, that both the explode/re-roll cap and the imploding functionality work with both the exploding, and re-roll modifiers. So they can either replace the previous roll, or append to them.

roll cap

I think this is good, and is what I've implemented on the branch where I was working on this (See the iterationLimit):
https://github.com/GreenImp/rpg-dice-roller/blob/d638c43f29e673341804e7b5524f4c954d4f0613/src/parser/grammars/grammar.pegjs#L64-L67

https://github.com/GreenImp/rpg-dice-roller/blob/d638c43f29e673341804e7b5524f4c954d4f0613/src/parser/grammars/grammar.pegjs#L100-L103

It works with both exploding, and re-rolls:

// explode a maximum of 2 times per die
4d6!2

// re-roll a maximum of 2 times per die
4d6r2

Like with re-rolling, you can also specifying "o", for "once", instead of the umber 1:

// explode a maximum of 1 time per die
4d6!1
4d6!o

// re-roll a maximum of 1 time per die
4d6r1
4d6ro

imploding

I like this. I think your suggestion is spot on. A separate "implode" modifier should do the trick.