Savage Worlds compatible expression

[saif-ellafi]

Hello!

We were looking into a single expression that could tackle the Savage Worlds dice roll in one shot.

Characters roll their Stat dice (i.e. 1d8), and on top, a 1d6 roll. Both can explode. However, before exploding, we have to choose the highest of those two individual rolls, and explode that one (if highest).

I would have hoped this expression worked, but it does not:

((1d6+1d8)-L)!

Could this be supported?

Thanks in advance!

[stevesea]

I think there could be issues with losing some information in the intermediate operations

❯ dart run example/main.dart -r 1234 '((1d6+1d8)-L)!' -o pretty
((((1d6) + (1d8)) -l ) ! ) ===> RollSummary(total: 6, results: [6], metadata: {rolled: [6, 4], discarded: [4]})
  ((((1d6) + (1d8)) -l ) ! ) =explode=> RollResult(total: 6, results: [6])
      (((1d6) + (1d8)) -l ) =drop=> RollResult(total: 6, results: [6], metadata: {discarded: [4]})
          ((1d6) + (1d8)) =add=> RollResult(total: 10, results: [4, 6])
              (1d6) =rollDice=> RollResult(total: 6, results: [6], metadata: {rolled: [6]})
              (1d8) =rollDice=> RollResult(total: 4, results: [4], metadata: {rolled: [4]})

The d8 rolled a 4, the d6 rolled a 6.
When they're added that becomes a roll result [4,6]. But, the result loses some context from those individual results.

The RollResult operator + combines the two results into a new RollResult whose nsides is max(left.nsides, right.nsides) -- so the results [4,6] from the rolls above thinks nsides==8.

If I change the explode to explode any result 6 or greater, it explodes the 6 result from 1d6, but is incorrect:

❯ dart run example/main.dart -r 1234 '((1d6+1d8)-L)!>=6' -o pretty
((((1d6) + (1d8)) -l ) !>= 6) ===> RollSummary(total: 11, results: [6, 5], metadata: {rolled: [6, 4, 5], discarded: [4]})
  ((((1d6) + (1d8)) -l ) !>= 6) =explode=> RollResult(total: 11, results: [6, 5], metadata: {rolled: [5]})
      (((1d6) + (1d8)) -l ) =drop=> RollResult(total: 6, results: [6], metadata: {discarded: [4]})
          ((1d6) + (1d8)) =add=> RollResult(total: 10, results: [4, 6])
              (1d6) =rollDice=> RollResult(total: 6, results: [6], metadata: {rolled: [6]})
              (1d8) =rollDice=> RollResult(total: 4, results: [4], metadata: {rolled: [4]})

(if the 1d8 had rolled a 7 or 6, then this dice expression would explode on the d8 result).

[stevesea]

a couple things that make this tricky to implement relates to how the results are processed by traversing the graph :

1. after an operation, the result is immutable.
2. as the results are propagated up the operation graph, some context is lost. The 'results' is just a list of ints, and each int lacks any reference to the operation that created it.
3. an operation asks its immediate left hand side & right hand side for their results, but doesn't traverse the result graphs

it feels like the right way to do things might be for an individual result to be more than a simple integer.
(and not do something more convoluted where the explode operation has to traverse the graph of results to figure out which results are eligible for explosion).

[stevesea]

slept on it, and I think I'll pursue that approach -- making the roll results an richer object than an integer.

It's a big refactor, but it feels like a good change to support this use case and others. I think it'd also help implement richer applications -- similar to your recent suggestion regarding adding more metadata in the dice roll results.

It will probably make sense to move some of the current result metadata into that new object. 🤔
nsides feels like it's redundant, and might belong only on the new object.
discarded might be a flag on the new object.

from the example above, rolling ((1d6 + 1d8)-L)!

roll 1d6 ==> [{6 (nsides:6)}] # rolled 6, results object includes nsides:6 and other metadata about the dice that were rolled
roll 1d8 ==> [{4 (nsides:8)}] # rolled 8
op + ==> [{6 (nsides:6)}, {4 (nsides:8)}] # append one set of results with the other
op -L ==>  [{6 (nsides:6)}, {4 (nsides:8, discarded:true)}] # drop lowest, setting discarded:true on the 4
op ! ==> [{6 (nsides:6)}, {1 (nsides:6)}, {4 (nsides:8, discarded:true)}] # explode the 6 since it rolled the highest possible number on that dice

an application getting that result [{6 (nsides:6)}, {1 (nsides:6)}, {4 (nsides:8, discarded:true)}] could iterate over the list to animate those dice.

also, using an object would let me record a UID with each result, and more metadata linking dice results together. For example, having a dice roll that happened due to an exploding/compounding dice, the app might want to animate the explosion in some fun way. elaborating the example above, you might get a roll summary like:
[{6 (nsides:6, uid:1234)}, {1 (nsides:6, uid: 3456, explodedFrom:1234)}, {4 (nsides:8, uid:2345, discarded:true)}]

how does that sound?

[saif-ellafi]

Hello @stevesea - thanks so much for following this, couldn't answer as you seemed to be processing this in a direction deeper than I can understand :)

The collection of metadata is indeed useful, for me in particular, some users want to hide the metadata while others do more complex things and want to know what occurred. Additionally, keeping track of how many dice were rolled in total (and which) could allow certain APIs to interact with the parser and do other things like visual effects and so on.

As of the formula in particular, I can't justify whether the refactor is helpful or not for beyond integers, in this case as you indicated the formula was reading the wrong maximum and incorrectly forcing the user to present the expression as sum.

Perhaps the most natural alternative would be to do something like supporting arrays, for example ((1d6, 1d8)-L)! could enable you to parse the expression without having to refactor the object class, and instead supporting this new operation (which will requiere a keep lowest/highest next to it), then the explode dice would only see what was kept and nothing more.

Not much of help but I hope at least some fruit for thought! In the end what we players will seek is "the" formula that works for each system that we can copy paste and share ^^ perhaps we can build a compendium of expressions per system (most popular systems out there) and that would be s fantastic way to spot what is missing.

Best regards

[stevesea]

I think I've made progress on this. Created a new PR for what'll become a 8.0.0 release.

in the PR, the RollResult's results field changes from List<int> to List<RolledDie>. RolledDie represents not just the outcome of the roll, but also includes metadata about the type of die, nsides of the die (if polyhedral die), and metadata about the dice expression's modification of the rolls.

for example, in this output we can see the 6 exploded, adding a 1. the 4 rolled was discarded:

❯ dart run example/main.dart -r 1234 '((1d6 + 1d8)-L)!' -o pretty
((((1d6) + (1d8)) -l ) ! ) ===> RollSummary(total: 7, results: [6(d6💣), 1(d6🔥)], discarded: [4(d8⛔︎)])
  ((((1d6) + (1d8)) -l ) ! ) =explode=> RollResult(total: 7, results: [6(d6💣), 1(d6🔥), 4(d8⛔︎)])
      (((1d6) + (1d8)) -l ) =drop=> RollResult(total: 6, results: [6(d6), 4(d8⛔︎)])
          ((1d6) + (1d8)) =add=> RollResult(total: 10, results: [6(d6), 4(d8)])
              (1d6) =rollDice=> RollResult(total: 6, results: [6(d6)])
              (1d8) =rollDice=> RollResult(total: 4, results: [4(d8)])

[stevesea]

with regard to your other recommendation -- adding some place for a compendium of examples for each system.
were you thinking a markdown doc or wiki of this repo? Or something else?

[stevesea]

Although... maybe that dice expression is not quite right for Savage Worlds

The example from this page: https://wiki.roll20.net/Savage_Worlds#Wild_Card_Die_Rolls
they're doing a [[ {1d8!, 1d6!}kh1 ]] -- so exploding 1d8 and 1d6 separately, then picking the higher result. That'd give you a different result than ((1d6 + 1d8)-L)!.

But, reviewing the expression again... we have a d6 and d8. Both may explode, so the subexpression has a nondeterminate number of results which makes keeping or dropping tricky. Either 1d6! or 1d8! could each roll 2 or more die, but we only want to keep one of the sets of die.

Maybe compounding is better than exploding in this case? For example:

• (1d6! + 1d8!)kh
  • rolls 6(d6) and 5(d8)
  • the d6 explodes and rolls a 2(d6), which is accumulated into the results
  • so the left-hand-side of 'keep high' is [6(d6), 2(d6), 5(d8)], which returns: 6(d6)
• instead, with the expression (1d6!! + 1d8!!)kh
  • rolls 6(d6) and 5(d8)
  • the d6 compounds and rolls a 2(d6), which is added to the 6
  • the left-hand-side of 'keep high' is [8(d6), 5(d8)], which returns 8(d6).

---

It feels like I could do support something similar to roll20's docs. Update the parser to allow , to separate distinct sub-expressions.

I still like the changes I'm making in the above PR -- it made me a clean up a few other rough edges, and it does feel like it will enable apps to fun rendering of the results

[saif-ellafi]

Thanks for the incredible follow up, I am not an expert of Savage Worlds but I had initially thought first you compare the dice rolls and then you explode the highest :P but I think you're right, you do both rolls, explode them both if necessary, pick up the highest result overall.

Sorry for the confusion!

Do both scenarios work now? Did the PR still benefit the Compounding case or did we just support an extra strange scenario?

[stevesea]

The current latest release would work as-is for the compounding case.

❯ dart run example/main.dart -r1234 '(1d6! + 1d8!)kh' -o pretty
((((1d6) ! ) + ((1d8) ! )) kh ) ===> RollSummary(total: 6, results: [6], metadata: {rolled: [6, 2, 5], discarded: [5, 2]})
  ((((1d6) ! ) + ((1d8) ! )) kh ) =drop=> RollResult(total: 6, results: [6], metadata: {discarded: [5, 2]})
      (((1d6) ! ) + ((1d8) ! )) =add=> RollResult(total: 13, results: [2, 5, 6])
          ((1d6) ! ) =explode=> RollResult(total: 8, results: [6, 2], metadata: {rolled: [2]})
              (1d6) =rollDice=> RollResult(total: 6, results: [6], metadata: {rolled: [6]})
          ((1d8) ! ) =explode=> RollResult(total: 5, results: [5])
              (1d8) =rollDice=> RollResult(total: 5, results: [5], metadata: {rolled: [5]})
❯ dart run example/main.dart -r1234 '(1d6!! + 1d8!!)kh' -o pretty
((((1d6) !! ) + ((1d8) !! )) kh ) ===> RollSummary(total: 8, results: [8], metadata: {rolled: [6, 8, 5], discarded: [6, 5]})
  ((((1d6) !! ) + ((1d8) !! )) kh ) =drop=> RollResult(total: 8, results: [8], metadata: {discarded: [5]})
      (((1d6) !! ) + ((1d8) !! )) =add=> RollResult(total: 13, results: [5, 8])
          ((1d6) !! ) =compound=> RollResult(total: 8, results: [8], metadata: {rolled: [8], discarded: [6]})
              (1d6) =rollDice=> RollResult(total: 6, results: [6], metadata: {rolled: [6]})
          ((1d8) !! ) =compound=> RollResult(total: 5, results: [5])
              (1d8) =rollDice=> RollResult(total: 5, results: [5], metadata: {rolled: [5]})

But, I'm going to keep working on the PR. I think how I'd implemented things previously is the strange scenario (allowing addition of results of '1d6 + 1d8', and then with the results setting nsides=max(6,8) ).

[stevesea]

With the work I've continued doing on the PR, I think you'll have a couple different ways to roll for Savage Worlds.

sum of compounding die, keeping highest

❯ dart run example/main.dart  -o pretty '(1d8!!+1d6!!)kh'
((((1d8) !! ) + ((1d6) !! )) kh ) ===> RollSummary(total: 15, results: [15(d8∑)], discarded: [14(d6⛔︎∑), 8(d8⛔︎⥅), 7(d8⛔︎⥅), 6(d6⛔︎⥅), 6(d6⛔︎⥅), 2(d6⛔︎⥅)])
  ((((1d8) !! ) + ((1d6) !! )) kh ) =drop=> RollResult(total: 15, results: [15(d8∑)], discarded: [14(d6⛔︎∑), 8(d8⛔︎⥅), 7(d8⛔︎⥅), 6(d6⛔︎⥅), 6(d6⛔︎⥅), 2(d6⛔︎⥅)])
      (((1d8) !! ) + ((1d6) !! )) =add=> RollResult(total: 29, results: [15(d8∑), 14(d6∑)], discarded: [8(d8⛔︎⥅), 7(d8⛔︎⥅), 6(d6⛔︎⥅), 6(d6⛔︎⥅), 2(d6⛔︎⥅)])
          ((1d8) !! ) =compound=> RollResult(total: 15, results: [15(d8∑)], discarded: [8(d8⛔︎⥅), 7(d8⛔︎⥅)])
              (1d8) =rollDice=> RollResult(total: 8, results: [8(d8)])
          ((1d6) !! ) =compound=> RollResult(total: 14, results: [14(d6∑)], discarded: [6(d6⛔︎⥅), 6(d6⛔︎⥅), 2(d6⛔︎⥅)])
              (1d6) =rollDice=> RollResult(total: 6, results: [6(d6)])

or, with the comma-separators, there's a couple ways to do it:

as above, with compounding:

❯ dart run example/main.dart -o pretty '(1d8!!,1d6!!) kh'
((((1d8) !! ) , ((1d6) !! )) kh ) ===> RollSummary(total: 9, results: [9(val)], discarded: [2(val⛔︎), 8(d8⛔︎⥅), 1(d8⛔︎⥅), 9(d8⛔︎∑), 2(d6⛔︎)])
  ((((1d8) !! ) , ((1d6) !! )) kh ) =drop=> RollResult(total: 9, results: [9(val)], discarded: [2(val⛔︎), 8(d8⛔︎⥅), 1(d8⛔︎⥅), 9(d8⛔︎∑), 2(d6⛔︎)])
      (((1d8) !! ) , ((1d6) !! )) =comma=> RollResult(total: 11, results: [9(val), 2(val)], discarded: [8(d8⛔︎⥅), 1(d8⛔︎⥅), 9(d8⛔︎∑), 2(d6⛔︎)])
          ((1d8) !! ) =compound=> RollResult(total: 9, results: [9(d8∑)], discarded: [8(d8⛔︎⥅), 1(d8⛔︎⥅)])
              (1d8) =rollDice=> RollResult(total: 8, results: [8(d8)])
          ((1d6) !! ) =compound=> RollResult(total: 2, results: [2(d6)])
              (1d6) =rollDice=> RollResult(total: 2, results: [2(d6)])

or, now exploding should work (since the comma is accumulating each sub-expression's total):

❯ dart run example/main.dart -o pretty '(1d8!,1d6!) kh'
((((1d8) ! ) , ((1d6) ! )) kh ) ===> RollSummary(total: 11, results: [11(val)], discarded: [2(val⛔︎), 2(d8⛔︎), 6(d6⛔︎💣), 5(d6⛔︎🔥)])
  ((((1d8) ! ) , ((1d6) ! )) kh ) =drop=> RollResult(total: 11, results: [11(val)], discarded: [2(val⛔︎), 2(d8⛔︎), 6(d6⛔︎💣), 5(d6⛔︎🔥)])
      (((1d8) ! ) , ((1d6) ! )) =comma=> RollResult(total: 13, results: [2(val), 11(val)], discarded: [2(d8⛔︎), 6(d6⛔︎💣), 5(d6⛔︎🔥)])
          ((1d8) ! ) =explode=> RollResult(total: 2, results: [2(d8)])
              (1d8) =rollDice=> RollResult(total: 2, results: [2(d8)])
          ((1d6) ! ) =explode=> RollResult(total: 11, results: [6(d6💣), 5(d6🔥)])
              (1d6) =rollDice=> RollResult(total: 6, results: [6(d6)])