Nth Die of 5D20 Plus Bump & Meta Die mechanic help #12
-
|
Hey posita, thanks for your help with my D20 dicepool plus roll points mechanic. I am not totally satisfied with that mechanic So I am evaluating another one, this one is fairly novel, So I am running into problems on the scripting. The Mechanic Your dice are split between Standard dice, and bump dice. Specify which is which. Your dicepool is made up of 1 to 5 standard dice and 0 to 4 bump dice, in a combination of 5. The number your roll is determined from your stat, and follows a die code progression. The dice code is shown as xD+yB#N Where xD is the number of standard dice, yB is the number of bump dice, and #n Is your 'Set Die' Which die of the 5 you read to determine your result. A stat of 0 corresponds to 5D+0B#1 So now that we got our dice we roll them we then sort the 5 dice lowest to highest, left to right, with each 'die slot' corresponding to #n number at the end of the die code. Easy enough, then we have the bump dice rule. If your set die is a bump die, you bump 1 slot to the right, the next higher die to determine your result. YOu only ever bump once, and to the right, ever. No chaining bumps, no matter how many bump dice are in your pool. THis gives us more granularity, but also makes the odds hard to calculate. Also, when sorting the dice, bump dice take the rightmost slots if you have equal numbers. A quick example. My stat is 13, so I have a dicepool of 2D+3B#3. Which means I roll 2 standard dice, 3 Bump dice (all twenty sided btw.) and take the die in the 3rd die slot as my result die. If I rolled a 1 5, 7, 10, 13 I would take the die in the 3rd slot, the 7 and use it as my result. However, in this case it is a bump die, thus I bump 1 slot to the right and use the 10 result in the 4th die slot. Even though it is a bump die, I don't get to bump again, only one bump, ever. YOu also roll a sixth die, The meta die, if the meta die matches your (bumped) set die, your set die explodes, reroll and add the result to your running die total. If it matches the meta die again, you roll and add again, and so on. The meta die also generates side results Boons and Banes, on a 1 and 20, independent of success on the check. if the Meta Die comes up a 1, the action generated a bane, a negative circumstance. If it came up a 20, it generated a Boon, an positive circumstance, kind of like Genesys' system. ONly the match die and explosion is particularly important for our needs. So if my meta die came up a 10 on the previous roll, a 1 5, 7, 10, 13 I would reroll the 10 bumped set die, and add the result to a running die total. If it came up 10 again, it would match the meta die (which is never rerolled) and I would reroll and add again. If it came up a 20, I'd be done rolling since it doesn't match the meta die, but my die total would be a whopping 40. (10+10+20=40) OK so that complicates things. I don't have enough python chops to properly handle the Match die explosions and the semi-indepdeent nature of the Bump die. THis was very easy to handle in Troll I used an indepedent D5 to determine if your die was a bump die. I.e with 1D+4B#3, you have an 80% chance of it being a bump die and bumping to the die result in the 4th slot. so I was checking 4 or less on D5 then take die result at 4th slot, otherwise 3rd slot. Pretty easy logic. Finally, to represent Higher Scale/Superhuman abilities, you add up to 5 boost dice or spoiler dice, Boost dice are extra bump dice, of which after you roll, you take the 5 dice with the highest results rolled as you dicepool, setting aside the others. While spoiler dice are extra standard dice you add to your dicepool. up to 5 extra, and take the 5 lowest to figure your results as normal. So A LOT of complication and chrome on the basic idea. Which, once you pick the concept is pretty fast and relatively low math, just sort, read and go. So if you could help me figure up the odds with some nice visualizations I;d appreciate it Incidentally, I swiped the basic mechanic concept from a very old RPG.net design forum post. Which I can't find right now, though my implementation is different. thank you for any help. |
Beta Was this translation helpful? Give feedback.
Replies: 5 comments 24 replies
-
|
@wmrobmuadib, apologies for being unresponsive. (Busy summer.) I think I understand (at least some of) the mechanic. I can work on a representation, but I wanted to check to see if this was still relevant to you, or if you had moved onto something else? This is going to be a bit tricky, since you're keeping track of a numeric result as well as the presence of a boon/bane. There are technical solutions to this, but very few are likely to be satisfying visually. I have some ideas, but time will tell if they pan out.... |
Beta Was this translation helpful? Give feedback.
-
|
@posita Thanks for getting back to me. I am still using the mechanic. I have cobbled together a monte carlo sim version that does a pretty good job of figuring the probabilities. So don't absolutely need it, though having enumerated probabilities would be nice. The boon bane is static 5% roughly as the meta die isn't rerolled. Just the matching Check/set die. So no need to track that particularly. |
Beta Was this translation helpful? Give feedback.
-
|
Questions:
|
Beta Was this translation helpful? Give feedback.
-
|
@posita thanks for getting back to me. OH yeah, I left out the class advantage/disadvantage mechanic. Basically stats in addition to having value, have a class rank. Like Normal is +0 Extranormal +1 Parahuman +2 SUperhuman, +3 Metahuman +4 Alien +5 Monstrous +6, etc. WHen there is a class difference you compare class of acting ability with the opposition. If the acting class rank is greater than opposing class rank, YOu have class advantage equal to the difference. If the Acting class rank is less than the opposing class rank, you have class disadvantge, equal to the absolute value of the difference. If you have class advantage, you add extra bump dice to your dice pool, up to 5 extra, for a dicepool of your base dicepool dice based on your stat, plus up to 5 extra Bump dice. You then take the highest 5 dice in the dicepool to figure your results as normal. Placing BUmp dice in the rightmost slots where they are equal to standard dice. If you would have more than 5 dice to add, you add +2 to your check result per extra die past 5 bump dice. . IF you have class disadvantage you add extra standard dice to your dicepool. Up to to 5 extra standard dice for a dicepool of up to 5 extra standard dice and your base dicepool of five dice based on on your stat. YOu then take the 5 dice with the lowest results to figure your dice result as normal. Shifting results to the low end. If you have more than 5 class disadvantage dice to add, you subtract 2 from your check result per extra die past 5 standard dice. And yeah that is correct on 50, you add the 5th die twice, basically you wrap around twice, and then use the 1st die slot as a secondary auxilary die. |
Beta Was this translation helpful? Give feedback.
-
|
😳 Just when I thought it was safe to go back FWIW, your advantage/disadvantage mechanics run the risk of degrading the computational performance pretty quickly, such that I don't think you'll have an option but to fudge the results (as described in this comment). (At least I haven't yet come up with anything better.) My fudged Am I still correct in my understanding that the output of these rolls is a single number (plus an occasional boon or bane)? What are players rolling against? Is there a target number? Are these opposing rolls? Either? Both? I'm just curious, but have you play-tested this mechanic at the table with others? |
Beta Was this translation helpful? Give feedback.
-
|
The result of the set/check die is a single check total which is compared against an opposing value. Which is sometimes the result of an opposing roll. It is a high granularity multiple input mechanic with a lot of front loaded concepts. So it is not the fastest or easiest, and I am guess I am ok with that. Haven't done extensive testing with other tables, but have gotten feedback on it. Once you grok it it is pretty easy in practice. Just a matter of people liking it or not liking it. In my experience. |
Beta Was this translation helpful? Give feedback.
-
|
I found a bug in my disadvantage calculations, but that led to a question about the disadvantage mechanic. Let's say I have
After "losing" the top die, do I end up with:
In other words, do I lose the bump die in the final position before resolving the check die? I pushed a fix assuming the answer is "yes" (and the result before resolving the check die is |
Beta Was this translation helpful? Give feedback.
-
|
Hmm, yeah, that would give the greatest disadvantage to remove bump dice first when removing dice with equal result. And keeping bump dice when removing low dice with the same numbers. that is the most symmetric way to handle it. |
Beta Was this translation helpful? Give feedback.
-
|
Another stupid question without the benefit of additional context: Why is five a good pool size? Why not three? |
Beta Was this translation helpful? Give feedback.
-
|
In short, granularity. The check die on 5s gives a nice range from 1-20. a goal of the system. It does make things less convenient however. |
Beta Was this translation helpful? Give feedback.
-
|
The good news is that I have several working implementations (one using just from dyce import H
from dyce.evaluation import explode
from fractions import Fraction
d20 = H(20)
limit = Fraction(1, 10_000)
# See <https://posita.github.io/dyce/0.6/dyce.evaluation/#dyce.evaluation.explode> for a
# more thorough explanation, but basically, this will tell explode to continue branching
# until the overall likelihood of any branch of outcomes is less than or equal to 1 in
# 10,000
print(explode(d20, predicate=lambda result: result.outcome == 3, limit=limit))
print(explode(d20, predicate=lambda result: result.outcome == 14, limit=limit))Running the above will yield: Visually:
Here's what I get with my work-in-progress implementations for your first five stats without explosions: Visually:
When calculating results with even just a single explosion, my Visually:
So not a huge difference, but noticeable. These were all generated locally using Python running directly on my (reasonably modern) laptop. Unfortunately, this means that trying to produce these in-browser (e.g., via Pyodide/Jupyter Lite) will likely take roughly five times as long, which would likely render useless any attempt at an interactive UI that could compare multiple stats. I'm happy to try to throw something together though, if you think it would be useful? Either way, I'll post my implementations as soon as I have an opportunity to clean them up a bit. |
Beta Was this translation helpful? Give feedback.
-
|
@posita Thanks for your efforts here, It looks like my monte carlo stats are reasonably close. THough I didn't notice that the past 25 results ere incorrect. The simple quality testing I did had what looked like correct results for 21-24 and 25+. But I didn't test everything so could be luck that looked right. As for putting up a web version. that is ok to skip it, as I can just run it locally in a jupyter notebook. , if you could Please put together a script I can copy and past, I can run it locally on my jupyter notebook install. , my system is pretty fast. I appreciate your effort and I am sorry for explaining it so poorly in my attempt. Thank you. |
Beta Was this translation helpful? Give feedback.
-
|
It's totally cool. This is fun! I'm sorry for all the back-and-forth, but I think I'm finally getting the hang of this mechanic. I have stumbled across two approximations for explosions that make the computation time semi-reasonable. The first is, if you limit the number of explosions to one, you can compute the fast, explosion-less outcomes, then "add" the histogram There's a second, hand-wavy, slightly inaccurate approach which is provably wrong from a probability perspective, but more accurate than the single explosion method and may be close enough for your purposes. Specifically, that is to calculate the aggregate of all possible explosions with a much higher limit (e.g., five), then "add" the expected differences. Loosely speaking, for each possible outcome on a d20, assume a 1-in-20 chance it explodes, then, if it does, recurse up to five times. The expected differences between the first rolled outcome and the final (exploded) outcome would be something like It's not correct because it includes exploded totals for all outcomes. For example, consider exploding a 13 up to five times. There's no way to roll a 26, 39, 52, etc., or anything higher than 85. If we just take our aggregated difference histogram and add it to 13, we're going to get non-zero likelihoods for totals that violate those constraints. But the results above 20 will be reasonably close. Here's what this kind of fudging looks like in practice, when compared to the real deal:
You can't see from those visualizations, but the fudged versions remain pretty close to the real ones, even for the higher values (i.e., the unreadable small slivers in the burst graphs), at least certainly closer than merely exploding once. I'll try to work in this technique as an option as I clean things up. |
Beta Was this translation helpful? Give feedback.
-
|
Okay, I think I have something reasonably close, but it will very likely not perform adequately with (dis)advantages of three or more. (As of this writing, advantage calculations take substantially longer than disadvantage calculations with both implementations, but I haven't dug in to figure out the source of the disparity.) There's a I will say, it is one of the more complicated implementations for a single dice mechanic I've seen, which likely makes performance optimizations difficult without something bespoke to this mechanic. That said the I also provided a crude, regex-based notation parser for a format that loosely resembles what I proposed in #12 (reply in thread). I haven't tested it, but you could probably adapt it to one resembling your own with something like: NOTATION_RE: ClassVar = re.compile(
r"""
^
(?:\[(?P<override>[^]]+)\])?\s*
(?P<std>[1-9]\d*)\s*D\s*
\+
(?P<bump>(?:[1-9]\d*)?\d)\s*B\s*
\#\s*
(?P<bonuses>(?:[1-9]\d*\s*/\s*)*) # one-indexed (not zero-) for readability
(?P<set>[1-9]\d*)\s* # one-indexed (not zero-) for readability
(?:<\s*(?P<ex_std>[1-9]\d*)|>\s*(?P<ex_bump>[1-9]\d*)\s*)?
(?:\#\s*(?P<comment>.*))?
$
""",
re.IGNORECASE | re.VERBOSE,
)
BONUS_RE: ClassVar = re.compile(
r"(?P<bonus>[1-9]\d*)\s*/\s*", re.IGNORECASE | re.VERBOSE
)That should support notations like: There's a browser version docker pull jupyter/scipy-notebook:latest
git clone https://github.com/posita/dyce-notebooks.git dyce-nb
docker run --name jupyterlab-dyce --publish 8888:8888 --interactive --tty --mount "type=bind,src=${PWD}/dyce-nb,target=/home/jovyan/work/dyce-nb"After opening the link provided printed on startup, you should be able to navigate to |
Beta Was this translation helpful? Give feedback.
-
|
Glad to hear this was somewhat useful to you! 😊 If you prefer your own notation, I can help adjust the regex to use that instead. Thanks for the reference! I'm going to have to spend some time with it. Although, this immediately jumped out at me:
Wow. 😳 I always wondered who the intended customer was for something like Chessex's Bag of 50™ Assorted Loose Translucent Polyhedral d20 Dice. Now I know! Of course, I would encourage all GMs with d20-intensive mechanics to require their players to exclusively use these: |
Beta Was this translation helpful? Give feedback.
-
|
hah, I thought my 35mm metal d20 was big. As for bulk dice packs, amazon has a 100 assorted d20 pack for $25 these days. Though those translucent 20s are sweet. I adjusted my notation to xS&yB@n+#z so accepted your suggestion for rearranging how check die and 'riders' are indicated. Looks pretty good. If esoteric looking to people who are unfamiliar with it. Good thing my intended audience doesn't mind crunch! Oh a little bug I noticed, for some reason it is not parsing 5s0b@3<N correctly. It will do 1s4b@3<2 fine, but when I do something like.. notations = r""" """ thanks |
Beta Was this translation helpful? Give feedback.
-
|
Ah! Brilliant! (I'm a dummy who didn't test properly.) This should be fixed with posita/dyce-notebooks@9a97750. If you're running Jupyter Lite in your browser, you may have to clear your cookies/storage (but save any desired changes locally first). If you're running this locally (e.g., as described in #12 (comment)), you should be able to update your local copy of the repo (cloned into |
Beta Was this translation helpful? Give feedback.
-
|
There's a potential optimization that might be worth exploring. If we could encode whether an outcome was the result of a standard die or a bump die, we could take advantage of an optimization However, this technique can be exploited further under certain circumstances. For example, if you had If I find some time, I'll try to see if I can work this into the implementation. |
Beta Was this translation helpful? Give feedback.
-
|
I managed to make some improvements in posita/dyce-notebooks@51a2be5 . I should have spotted this, but it turns out my idea about narrowly limiting based on selection won't work with heterogeneous pools. That being said, one can limit sub pools to the target pool size for advantage/disadvantage, which helps out, sometimes substantially. I also should have spotted this before. Also, I used a bit-wise trick to encode whether an outcome is from a standard die or a bump die (interpretation here, decoding here, here, and here), which results in small, but measurable improvement over the prior approach of die outcomes being |
Beta Was this translation helpful? Give feedback.
Okay, I think I have something reasonably close, but it will very likely not perform adequately with (dis)advantages of three or more. (As of this writing, advantage calculations take substantially longer than disadvantage calculations with both implementations, but I haven't dug in to figure out the source of the disparity.)
There's a
dyce-based implementation and an attempt at anicepool-based implementation. As of this writing theicepoolimplementation is not very efficient, though. I'm wondering if I'm using the library effectively, or if it's an artifact of dealing with multiple pools and not having a short circuit mechanism (see HighDiceRoller/icepool#81), or ... ? Also included is…