Can I get some help on calculating damage per round in my homebrew, that mixes d20s and d6s?

Question

I am tweaking my homebrew RPG and trying to determine various Damage Per Round through an Excel spreadsheet. Here are the details:

• A single players always roll d20 system where 20 is a auto hit and 1 is auto miss.
• There is no additional roll to damage. Weapons have static Damage and Rate of Fire. The way RoF works is for every point To-Hit (TH) that exceeds the defense value (DC) an additional hit is made up to the max RoF. For example, a PC rolls (+mods) a TH15 with a repeating crossbow that fires 3 bolts (RoF3). Comparing it to an NPCs static (no roll) DC14, the PC hits the them twice, once for meeting DC14, and once for exceeding it by 1 point. Had it been TH14 there would be just 1 hit, and TH18 would have yielded 3 hits because the number of bolts is capped at 3 (RoF3).
• While a natural 20 always hits, the TH:DC ratio for RoF remains, e.g. a TH22 accompanied by a Nat20 vs a DC22 or higher would still yield a single hit regardless of RoF. I have a bonus system planned that doesn't need to be taken into account.
• Attackers and Defenders have static positive modifiers like Accuracy (ACR) and Agility (AGL) that are added to TH and DC respectively.
• Attackers and Defenders can further modify their TH and DC with a limited pool of d6s; higher character level increases the size of the pool and how many d6s they may add from it to modify their TH or DC. I believe this is is simply the average 3.5 of a d6 multiplied by #d6s, though that may not be right.
• Defender Armor reduces each hit (e.g. 2 hits at 2 DMG each vs Armor 1 would do 1 DMG each for a total of 2 DMG). Armor may reduce DMG to zero, but never into the negative.

Below is my formula thus far, which gets me to the success rate of an RoF1. I am not showing any static modifications (AGL, ACR, etc) as they can get lumped into the TH and DC, while I am showing the d6 modifier from the characters' pool because of the random nature of bonus d6s:

$$ \left(21-\frac{(DC+3.5\#d6)-(TH+3.5\#d6)}{20}\right)\times100 $$

What I can't figure out from here is how to include atuo-hit on 20 and auto-miss on 1 (the above equation can yield 100% chance, which shouldn't happen), DMG, RoF, and Armor.

Answer 1

I think you're on the right track. If you're doing this in a spreadsheet, MIN, MAX, and probably IF are going to be your friends for enforcing cutoffs and boundaries (like non-negative damage, auto hits/misses, etc.).

I'm guessing what you're trying to get a feel for is not (just) the average expected damage per round, but the distribution. That might be more challenging to do in a spreadsheet (although totally possible). My Spreadsheet Fu is lacking, so others will likely be able to provide more guidance as to specific strategies.

That being said, I put together an interactive widget using Jupyter with dyce¹ that might help. Assuming I understand your mechanic (and got my math and my widgets wired up right), the amount of damage a PC can expect to land on a single round with a TH mod of -2, a DC target of 11, 2d6 on attack, 1d6 on defense, a DMG of 3, Armor of 1, and an RoF of 6 is:

It is capable of modeling three scenarios: a PC attacking (supporting crit hits on 20/misses on 1 against the NPC); a PC defending (supporting crit misses on 20/hits on 1 against the PC); and PC v. PC (supporting symmetrically-negating crit hits/misses). The code is a little unwieldy, but the critical functions are expected_dmg_frm_rnd_pc_attacks, expected_dmg_frm_rnd_pc_defends, and expected_dmg_frm_rnd_pc_v_pc.

One limitation about this implementation is that it does not show hits separately from DMG. That might be important if, for example, contacting an opponent was situationally advantageous, even if it didn't result in harm. (For example, one particularly sharp-eyed PC spots a desired target in a crowd that the rest of the party can't easily see and lobs a couple vials of talc or pies or whatever to "paint" or "mark" it.) That's easy to work in here by creating an artificial spread between DMG and Armor so you can see the number of hits while ignoring any damage. As a side note, you could compute max(0, dmg - armor) outside of the model and just have one control for that, if you wanted.

This model also assumes that Armor is not depleted by hits or DMG (as does your mechanic, I believe). Modeling such a thing would be possible, but more complicated, and may not be worth the extra accounting at the table, especially if it negatively impacts the pace of the game.

anydyce² is used to to generate "burst" graphs. You can play around with it in your browser: [source]³

I'm hoping that even if you don't speak Python, the above is accessible enough to either get you where you want to go calc-wise, or give you enough inspiration to modify your spreadsheet to get it to do what you want. Like I said, I think you're close.

---

¹ dyce is my Python dice probability library.

² anydyce is my visualization layer for dyce meant as a rough stand-in for AnyDice.

³ While GitHub and JupyterLab/JupyterLite seem like pretty durable projects, who knows if or when any will disappear or change? You can download a zip file of the repository and use it locally. To do that, you'll need a working installation of Jupyter Lab (or at least Jupyter).

The "easiest" way that I've found is via SageMath. SageMath a fairly powerful platform roughly analogous to Mathematica. It is a massive collection of various open source science and math packages that are beyond overkill for this notebook. However, convenient installers exist for MacOS and Windows. Note that SageMath does not yet default to Jupyter Lab (only Jupyter), so the interface is slightly different.

There are other ways, but each is fairly technical. For example, I am able to run the notebook via Docker by downloading and unzipping the aforementioned Gist zip into /tmp/dpr and then running docker run --rm --publish 8888:8888 --volume '/tmp/dpr:/home/jovyan/work' jupyter/scipy-notebook.

Binder automates installing dependencies. I added a cell to the notebook to handle that in other environments.

At the risk of finger wagging, I offer a word of caution: It's probably a good idea to avoid running downloaded scripts without inspecting and understanding them. In this case, I would examine the contents of the zip file to make sure they reflect your intention. It's also worth understanding that Jupyter is a complete Python environment that works by spooling up a local web server and offering users access to that environment. As such, it has its own security limitations. This is especially relevant if you're running it on a host connected to the internet.

Make your own decisions, of course, but sometimes reminders of risks are useful.

Answer 2

Let \$N\$ be a random variable representing the number of hits and \$d\$ be the damage each hit does.¹ It follows that the damage per round \$D=N\times d\$.

Now \$N\$ depends on 2 other random variables:

• the hit roll \$H\$ which is simply a discrete uniform distribution generated by rolling a d20, and
• the target number \$T\$.

So:

$$D=d\times\begin{cases} 0, & \text{if }H=1 \\ \max \left(0, \max \left(\begin{cases}1, &\text{if }H=20 \\ 0,&\text{otherwise }\end{cases},\min \left(rof, H-T\right)\right)-arm\right), & \text{otherwise}\\ \end{cases}$$

where \$rof\$ is the RoF and \$arm\$ is the armour.

Now:

$$T=dc+agl-acc+N$$

where \$dc\$ is the defence value, \$agl\$ is the agility bonus, \$acc\$ is the accuracy bonus and \$N\$ is the result of the d6's. Specifically:

$$N=(def-att)\text{d}6$$

Where \$def\$ is the number of d6 the defender rolls and \$att\$ is the number rolled by the attacker.

Putting all this together gives:

$$D=d\times\begin{cases} 0, & \text{if }H=1 \\ \max \left(0, \max \left(\begin{cases}1, &\text{if }H=20 \\ 0,&\text{otherwise }\end{cases},\min \left(rof, H-\left(dc+agl-acc+(def-att)\text{d}6\right)\right)\right)-arm\right), & \text{otherwise}\\ \end{cases}$$

Here is an anydice implementation.

¹We'll use the convention that capital letters represent random variables and lower case represent constants - albeit constants that we might not know.