Dice pools? Dice pools.

Here's a thought(?)/question (?) on dice rules;
Dice pool rule
-Define dice
-add dice to the roll pool somehow before rolling
-GM posting a roll for players to click and add to their post.

Is any of this somehow achievable already?
How hard would it be to implement?

Asking for a friend.

'Dice pools' are not a really well-defined term. They all revolve around a set of rules for interpreting the result. Would the roller not need to understand what to do with the dice once they are rolled?

For now we can collect the needed dice by discussion and then roll the number needed, and the humans can interpret what they mean.

Being able to keep just the highest or lowest helps with many dice pool rulesets.

Do we yet have the ability to not add up the dice? That would be useful for dice pools where the total does not matter.

I'll try to outline the case a bit better.

A character has traits and items.
Each trait and item adds dice to your rolling pool.

Ok,ok. How about a variable (checkbox?) that when it's true, it adds a d(something) and the end roll is calculated by variable total?

Rules can define the details, e.g. highlighting successes etc, like TftL rules.

Yah, I'm still confused on how this would work too. Can you provide an example? It would be hard to code something like that.

Basically, instead of adding a new roll when clicking on a rolls field, it would just add those dice to an existing roll.

At least that's what I think Antiproduct wants and what I have been thinking about for a while now as well

Basically, if you select

Trait A | 2D6

and

Trait B | 1D8

on your sheet, the current system would turn that into two rolls:
Trait A | 2D6
Trait B | 1D8

But a dice pool system would turn that into one roll:

Trait A, Trait B | 2D6, 1D8

Basically, I'm starting every post with basically

Why's this better?

Because it takes up less space and looks better. And because then I would actually use it for games like Cortex if it worked like that, while right now, I still do that manually

This mechanism would also apply to Genisys (or however they spells it) and the FFG Star Wars games.

If you're not mixing dice types, something like this might work for what you are describing?

[abilities="Character Sheet"]
Base Proficiency: [_base=1]
Ability: [_abl=3] | Active ? [_ablBool=1/1]
Equipment: [_equip=2] | Active ? [_equipBool=1/1]
Other bonuses: [_bonus=1/5]

[table="rolls"]
Action | Roll
Do Action (with Abl/Equip/Bonus?) | [_$=base+abl*ablBool+equip*equipBool+bonus]d20
[/table]
[/abilities]

You can adjusted the boxes that currently apply to the action and then click roll.

---

If you need mixed dice, then we might need a new BBCode tag, maybe something like:

[dicepool]
[_$=base]d20 + [_$=abl*ablBool]d8 + [_$=equip*equipBool]d6 + [_$=bonus]d4
[/dicepool]

Which would render to a clickable button: 1d20 + 3d8 + 2d6 +1d4
When clicked the whole expression is added to a single Roll field.

Dice rules could then interpret the results.

So every time you click a dice roll, it munges the reason and roll onto the last one of the same type (provided there's room)?

I just looked at it with some player data from one of my games.



vs




I'm not sure it looks better. It looks like a bloody mess to me.

Because you're using it for what it wouldn't be made for. The intention isn't to mash a couple of unrelated rolls together (though you could use it for attack roll and damage) but to make one roll look like one roll



vs



And the thing is, this is one roll/action.
You need to take all these results as one roll. It makes much more sense to have them all right with each other rather than spread out like this.

I have to take your word that your first example is clearer.

But how's the computer supposed to know which rolls are related?

I think my [dicepool] tag idea (above) would accomplish that

That already works without a dicepool tag (if I understand the requirement).

In bowl's case, it might be something like this:

[abilities="Character Sheet"]
Teams: [_t=8] [_tBool=1/1]
Uncompromising: [_u=8] [_uBool=1/1]
Superhuman Punch: [_sp=10] [_spBool=1/1]
Enhanced Speed: [_es=8] [_esBool=1/1]
Combat: [_c=10] [_cBool=1/1]

[table="rolls"]
Action | Roll
Do Action | [dicepool][_$=tBool]d[_$=t] + [_$=uBool]d[_$=u] + [_$=spBool]d[_$=sp] + [_$=esBool]d[_$=es] + [_$=cBool]d[_$=c][/dicepool]
[/table]
[/abilities]

Note: I just typed out the results of the [dicepool] tag in the charsheet as an example

---

Edit:
Testing without [dicepool] tag as Adam suggests ...

Oh, that's great! In that case, ignore my last post XD

Too late. I've added your example to this game.

Okay. So the problem (if this is a solution) is that the page doesn't recalculate the roll based on clicking things.

Testing

Also, it seems that 0d8 is calculated as 1d8?

test

Even if typed into the Roll field manually, so it's not the char sheet integration that's causing that problem

I'll need to test out Chal's code thing. If that works for this, that would be great.

Otherwise
Maybe a new roll table tag. Something like [table="rollspool"]. And if you click things inside that table, they get pooled rather than posted separately ?‍♀️

Gives Chalry all the cookies.

That's what I had in mind. Thanks a bunch.
Now, what were you debating about?

Okay, so with some tweaks on my machine (without using dicepool)

Chal's logic renders this (which updates as you select checkboxes)



And rolls this (stripping 0d's)

Although I'm not dismissing the rollspool idea (I think it sounds interesting - esp. for star wars where they need to add purple(?) dice).

Is this rolls pool something that people want?

I'm still trying to wrap my head around Chal's thing but that might take care of the problem. Rollspool might be easier, though (On the user side, not the adam side)

Can't really say before I spent a bit more time trying to work out the workaround

That looks good and I think it would be useful to have.

I think the rollpool, where you click multiple, would also be useful and might be clearer and less coding on the user end. The current way doesn't tell the other players which abilities you're using, the rollpool multi-click way would presumably add the label of each click to the Reason field, which might make it easier to follow.

Right, that's an issue I didn't notice right away. That makes the feature less useful as you'd still have to type out what you're using... Though maybe you could use variables to also have the thing automatically add descriptions? I'm still struggling with this code but it doesn't seem impossible

If you add this under the abilities:

#Selected Abilities
Teams: [_$=tBool]
Uncompromising: [_$=uBool]
Superhuman Punch: [_$=spBool]
Enhanced Speed: [_$=esBool]
Combat: [_$=cBool]

Then you get a drop down menu that will add a spoiler showing which abilities were selected.
(I updated Chal's Example sheet, so people can test it out)


But this feels like a hack, so I think the rollpool idea would be cleaner and more user friendly.

---

This is a little more pretty than 1's and 0's.

Wait. Are these pools supposed to add them? I thought BoS wanted them comma separated.

I just did addition as my example. I think it would depend on the game. Some games want added total, some might want number of 1's, etc.

We might want to find a lowest common denominator for dice pools, since there is no such thing as 'a dice pool game', they all have different rules with regards to what is done with the dice after they are collected and rolled.

Some might want them totalled up, some might want them separate. There are games where some cancel each other out, and other intricate rules, but those (as with FFG Star Wars) would probably need their own underlying code and could not easily or safely be expressed by the general dice roller.

There are even games where we might roll a variety of dice 2d6+2d8+1d10+5d5 and keep the highest. Currently I don't see any way to have the dice roller syntax keep the highest from that (though it can keep the highest from each type, which I have needed before).

Just a way to collect them may be all we can offer, then the players would need to interpret what they mean.

Yes, I was assuming this was just to make the rolling easier. The custom dice rules would be required to interpret results or if they aren't enough then we'd still need to do the interpretation manually for complicated rules for now.

---

I added the comma separated option in "Chal's Example" sheet. Seems to work as well. So even if it's too complicated to implement the clickable [rollpool] option, I think this approach will work for some dice pool games (with the slight adjustments that Adam suggested to fix the 0d, in-place-update, etc.)

Okay, so I tried to convert my sheet that I would primarily use this for into Chal's styling and it did not work. I don't quite understand the reasons for what went wrong, but first of all, it doesn't look pretty with so many empty dice in the pool and it seems to have cut off the end because it exceeded the length of the text box. It also didn't actually roll the dice it was supposed to roll, even though it correctly displays them as 1dX



I didn't add the spoiler thingy because with it showing everything, whether you rolled it or not, it also will not be super nice to look at...

So while this is a crazy awesome hack, I don't think it really solves the issue unfortunately :/

---

On a positive note: The Edit/Preview toggle was super helpful in troubleshooting my sheet for the many errors I made while trying to get this to work

I too admire the hack, but I'll knock something up for staging tomorrow based on a table attribute. If I understand the requirement then it's just a few lines of javascript.

@bowlofspinach, Hmm ... yeah that doesn't look good. Sounds like Adam thinks the [rollpool] table idea is a possibility, so hopefully that is a better solution.

---

@Adam, I think we should still do the update that strips 0d's. It might be better to do that at the level of the sheet instead of at the dice roller, so if there are tons of 0d's in the roll calculation on a sheet, they don't make a mess on the sheet. It would also stop really long lists of no dice being input in the the dice roller, which seems to have a limited length based on bowl's test.

@bowlofspinach Is this what you meant?

You can add pool or pooladd attributes on rolls tables.
With those attribs, it'll add the last clicked dice to the last open roll (creating a new one if it needs to). pooladd uses addition instead of comma-separated.

Yes, that looks awesome!

The feature won't come with the dramatic music though. Soz.

Oh, in that case I'm not interested ???

Is there a sample sheet we can use to start testing with?

Sure. Create this and add it to your game.
https://mapdm.com/forums/thread/24251/

Nice functionality.

Not sure about the syntax, but it is not terrible. Maybe `pooladd` should be `pool add` which would allow for extensions like `pool minus` as if that could ever be a thing? `pool` could be shorthand for `pool comma`, or be set by an earlier tag?

Needing a separate (and possibly duplicated) table to be able to + vs , the dice into the pool could be messy. I can't see a simple way to handle that without introducing buttons or toggles. Hopefully most games will mostly use one or the other.

"Pool minus" is an interesting thought, as in removing dice again from the pool...
Not super pressing but it would be helpful in some circumstances.

What would also be cool but probably pretty complicated is if you could for example press two different 1D6 tags and combine them into 2D6.

But those are all little things that would be neat but aren't super important.

How about kebab case? pool-add? Else add looks like an attribute on its own.

2d6 is mechanically identical to 1d6+1d6, is it not?

Would games actually benefit enough from combing them into 2d6 notation to make it worth it? If it will make it easier to look at the dice after the roll and understand then it is always worth considering.

This does seem like FFG Star Wars assumes that combine, but just adding those with +s could remove the need to decide between the 2p3b and pbbpb notations since it will end up as p+b+b+p+b --which actually looks fine to me, but could get very long. :)

I was thinking they should be their own attribute. It is a 'pool' table (though not a pool table) and it has the 'add' or 'comma' (or 'minus') attribute dictating how it works?

It is. It would be a purely aesthetic thing, which is why I listed it as "would be neat to have but is absolutely not necessary"

Turns out `1d6+1d6` is not the same as `2d6`.

`2d6` displays '(1,2) = 3' while `1d6+1d6` displays '(1)+(2) = 3'. `2d6+d6` displays '(1,2)+(3) = 6'.

I don't think we can apply the all dice highlighting to plussed dice since they are not considered as the same thing. We can not sort them, and matches don't show as matches.

We also can not use drop/keep codes with them since that will only apply to the single clause as deliminated by the + signs. This might be beyond an easy fix as the + syntax might be complicated.

If we could have the option to turn multiple clicks into a `1d6` becomes `2d6` becomes `3d6` code that would solve a few of these. Maybe something like: `[ table="rolls pool-combine"]`?

This might also allow us so add a h1 or l1 entry to the table that can be clicked to tack that text onto the end of the dicecode. But people may forget to click that in the end, and having it as something that can be defined in the table definition could make it automatic for games that need that.

This code also display funny: `0d6+2d6+1d6+2d6`. It add arrows to the result.

It seems to be related to the 0d6 in the first position. Having it elsewhere (`1d6+0d6+2d6`) seems to not mention the 0d and displays properly.

Are you using the dice pool functionality @vagueGM (or anyone else for that matter)?

Huh. That's weird. It's rendered them like exploding dice. I need to look at that.

I am wanting to test it in my upcoming CBR+PNK game, it would be useful... if it worked.