Dice Progression

Hello, I have a game where there are 256 levels for each skill, ability and knowledge. I'm trying to find a dice progression. I can only find them that stop at 16d6. I need something that is just straight dice progression from level 1 - 256, surpassing 16d6. I can't seem to find anything anywhere :( Any thoughts?

Hi Michael, Not sure I follow...  Do you need to use multiple dice? 1d256 would give you 1-256.

And there is no reason you couldn't roll 256d6, though it would be best to run without 3d dice well before that point.  I think the vtt caps the visible dice at 20 or so.

Sorry, I just meant a grid of dice as it grows. What the PROPER progression would be after 16d6. For example, I have this, but it only goes up to level 43... there are a total of 256 levels.

I have 256 levels. And so I'm going to need a section in the worker/sheet that has a list of dice combos per level.

Are you using an existing system with its own progression? Or are you inventing your own progression? If the latter you'll need to describe how much difference eacg level should make. The jump from 43 to 44 on that list is colossal and doesn't match any previous levels. It looks like it;s supposed to be a maximum level. But there's other weirdness - like the 34 average is less than the 33 average. But in general, the way the table jumps between die types and averages between levels means there's likely no way to systematise the progression. To be able to that, you need an identifiable pattern to the progression, and it doesnt look like there is one.

GiGs said: Are you using an existing system with its own progression? Or are you inventing your own progression? If the latter you'll need to describe how much difference eacg level should make. The jump from 43 to 44 on that list is colossal and doesn't match any previous levels. It looks like it;s supposed to be a maximum level. But there's other weirdness - like the 34 average is less than the 33 average. But in general, the way the table jumps between die types and averages between levels means there's likely no way to systematise the progression. To be able to that, you need an identifiable pattern to the progression, and it doesnt look like there is one. GiGs, that's why I'm looking for a pattern of progression that goes from 1 - 256. If there isn't one someone is already aware of, then a new one will have to be created.  Which is fine. Excel for the win. I was just hoping someone had an algorithm or example.

That's an extreme power creep, which is probably why you can't find an existing system. The GM is going to need to look up the roll distribution for every skill check, for every player's skill level, in order to be able to set a sensible target for a roll. Someone who doesn't invest very heavily in a skill essentially has zero chance of ever passing a roll, unless the target is utterly trivial and impossible to fail for someone with slightly more investment. This lumps a huge amount of math on the GM without really serving much of a purpose - I mean, a locked door at the start of the game might need a 5 to break it down due to the players' low skill levels. The same door encountered later in a game will need the difficulty artificially increaased to the hundreds for there to even be a point in rolling any dice. Why would the same door suddenly be 100 times harder to break down? Using your table as a very rough guide, a 256/256 skill roll is going to average somewhere between 700 and 1000, while a 1/256 is 1.5. That seems a staggering difference for the GM to take into account - are you sure that's what you want your system to do? Also worth considering, as you add more and more dice, the deviation from the average roll drops off rapidly. For example, if your progression makes it up to 60d20, 90% of rolls will land between 560 ad 700.  A player would have to roll thousands of times to stand much chance of seeing a roll below 500 or above 770, making the majority of the potential roll range redundant. Is this the goal of the system?

Michael D. said: GiGs said: Are you using an existing system with its own progression? Or are you inventing your own progression? If the latter you'll need to describe how much difference eacg level should make. The jump from 43 to 44 on that list is colossal and doesn't match any previous levels. It looks like it;s supposed to be a maximum level. But there's other weirdness - like the 34 average is less than the 33 average. But in general, the way the table jumps between die types and averages between levels means there's likely no way to systematise the progression. To be able to that, you need an identifiable pattern to the progression, and it doesnt look like there is one. GiGs, that's why I'm looking for a pattern of progression that goes from 1 - 256. If there isn't one someone is already aware of, then a new one will have to be created.  Which is fine. Excel for the win. I was just hoping someone had an algorithm or example. The are many different progressions possible that go from 1 to 256 (an infinite number, really). You'll have to state exactly what you want from the progression. PS: also everything that oosh said. Why do you need 256 steps? Thats a serious not a rehetoical question.

You may want to take a look at (the code from) the charactersheet for "Earthdawn". This system also uses a rather unique progression of an increasing number of dice (as a summary of different dice types => e.g. 2d20 + 1d12 + 1d8 + 2d6) with increasing levels of skills etc. 

To answer all y'alls questions, the reason for the dice progression is because it is used for damage, mostly. The levels are used as Dice Checks, and the levels alone use the level number, not the dice. This is mostly related to damage, and hitpoints. As an example, at level 1 you may have 15hp. At level 256 you may have 1,000,000,000hp.... maybe more. The game is not meant to be balanced. It's not like 5e with classes and people are all balanced out by the game manufacturer. The universe is huge and it embraces that things are not "balanced". Technology varies wildly. As a DR, you'd say "Oh, it's tech level 30" which means they'd have to roll a 30 or better on a skill to do something with it, unlocking a door, etc. But if it's a tech level 30 gun, then it may have a whole arrays of properties. The rules state that you grab the damage dice based on it's level, or a fraction of a level (1/2 level, etc.). But the damage dice also have multipliers, penetration values, etc. Which are purchased with Tech Levels. Anyway, I just needed a dice progression that is linear, that would simply just keep going 256 times.

Thorsten S. said: You may want to take a look at (the code from) the charactersheet for "Earthdawn". This system also uses a rather unique progression of an increasing number of dice (as a summary of different dice types => e.g. 2d20 + 1d12 + 1d8 + 2d6) with increasing levels of skills etc.  Very interesting, I'll have to check it out!

GiGs said: Michael D. said: GiGs said: Are you using an existing system with its own progression? Or are you inventing your own progression? If the latter you'll need to describe how much difference eacg level should make. The jump from 43 to 44 on that list is colossal and doesn't match any previous levels. It looks like it;s supposed to be a maximum level. But there's other weirdness - like the 34 average is less than the 33 average. But in general, the way the table jumps between die types and averages between levels means there's likely no way to systematise the progression. To be able to that, you need an identifiable pattern to the progression, and it doesnt look like there is one. GiGs, that's why I'm looking for a pattern of progression that goes from 1 - 256. If there isn't one someone is already aware of, then a new one will have to be created.  Which is fine. Excel for the win. I was just hoping someone had an algorithm or example. The are many different progressions possible that go from 1 to 256 (an infinite number, really). You'll have to state exactly what you want from the progression. PS: also everything that oosh said. Why do you need 256 steps? Thats a serious not a rehetoical question. There are 256 Tech Levels and 256 Skill levels.  There are no classes, everything is skill point based. Each Hero is 100% unique and customizable as they gain points. And balance between Hero's is not the purpose. The story is. But there are key points that need to be used as a reference, so the levels, correlating dice, etc.

Ah ok, that makes a bit more sense. If it's covering everything from - I attack the mecha with a teaspoon to - I fire the orbital particle beam weapon at the spider in my bedroom That would definitely account for the enormous difference in outcomes :) Vaguely reminds me of Palladium and their SDC/MDC system. An SDC object, like a human, being hit with an MDC weapon = reroll character. There aren't even pieces of you left to mourn. I haven't run this past anydice, but something simple like this might work? Intuitively, we're always adding a die or changing a die to one with a higher average, so there shouldn't be any funky probabilities going on.... but I could be wrong. 1. 1d4 2. 1d6 3. 1d8 4. 1d12 5. 1d20 6. 1d20 + 1d4 7. 1d20 + 1d6 8. 1d20 + 1d8 9. 1d20 + 1d12 10. 2d20 11. 2d20 + 1d4 .... ad infinitum You can speed up the progression by e.g. removing 1d6, or slow it down by adding in a 1d16 or 1d2 or whatever. Here's some example code that ends at 64d20: (() => { const dieSizes = [4, 8, 12, 20], dieSizeMaxIndex = dieSizes.length - 1, maxLevel = 256; let baseDice = 0, currentLevel = 1; for (let i=0; i<maxLevel; i++) { const currentDieSizeIndex = (currentLevel-1) % dieSizes.length; if (currentDieSizeIndex === dieSizeMaxIndex && currentLevel > 1) baseDice ++; const baseRoll = baseDice ? currentDieSizeIndex === dieSizeMaxIndex ? `${baseDice}d${dieSizes[dieSizes.length-1]}` : `${baseDice}d${dieSizes[dieSizes.length-1]} + ` : '', extraRoll = currentDieSizeIndex === dieSizeMaxIndex ? `` : `1d${dieSizes[currentDieSizeIndex]}`; console.log(`Level ${currentLevel}: ${baseRoll}${extraRoll}`); currentLevel++; } })(); edit - made the code a bit more browser-friendly. You should be able to run that repeatedly in the browser console by pasting the whole lot in there, since I'm not sure if you're set up for coding or not. You can change the array at the top to change the die size progression.

is that character sheetworker injectable?????????

Kind of - it just outputs to console at the moment, but it's easy to turn it into a function that outputs the progression. Exactly what kind of output do you need? Just an array like this? const output = ['1d4', '1d8', '1d12', '1d20', '2d20', '2d20 + 1d4' ... ] You'd then access each level with a ( level -1 ) index. So output[0] would give you skill level 1. Those are all strings too, ready to put into a roll expression. So putting `[[ ${output[0]} ]]` as the value of a roll button would roll 1d4. Is the roll expression string (based on current skill level) all you'll be needing to retrieve?

One question to bear in mind: what percentage of the target's hit points should an attack remove at each level. You said hit points go from aroun 15 up to a billion, and for that I think you might need an exponential pregression in the dice system (which would get tedious without using big multipliers) For example, lets say your attack does 128d20. That sounds like a lot - it would turn that 15 hit point character to paste. But it would still take about a million hits (that's not an exaggeration) to take out the billion hit point character. You don't want the damage for the highest possible damage in the game to be that 'little'. So for a viable progression, you'd need to figure out what percentage the damage increases with each level, and then fit a randomiser (dice roll) to that system.

Okay, to build on my last post, lets build a progression. lets say you have a starting character, that takes 15 damage, and a top level character that takes about a billion hits. Thats roughly 100,000,000 times as many hit points. So how do we determine a 128 scale progression to go from 1x at the lowest level to 100 million times at the top level. It turns out that isn't very hard for computers. First step is identifying that 100,000,000 is eight steps of 10x. So if we divide that 128 by 8 we get 16 steps. That means every 16 steps has to multiple by 10. Then 8 steps of those 16 steps will give use 100,000,000. So we now need to figure out how to get 10x from 1x in 16 steps. That's easy enough with a computer, and it turns out the answer is (very roughly), 1.17 (one and a sixth). So if your scale increases by roughly 1/6th every step, you end up with the same proportionate damage at step 128 vs 1 billion hits as you do at level 1 with 10 hit points. Small error: at level 128 you'll only have increased 127 steps, not 128, but it's okay for the higher level character to have gained a little damage capcity! Now the problem: if level 1 is 1d6, level 128 is about 100 million d6. If you build the scale properly, you'll get that number, but rolling the dice will be difficult. You can easily change some of the assumptions. You might say that it takes 10 average hits at level 1 to take out a level 1 characer, and a 100 or 1000 average hits at level 128 to take out that billion hits character, and restructure the progression appropriately. This is where deciding the constraints of the progression system is important. But whatever you do, you'll hit this problem: Ridiculously large numbers are easy for computers to handle (which is why computer games use them), but they aren't feasible for players to use them. That's why tabletop rpgs don't use them. It would be better to convert the system into a linear one. If you know that a 128 level attack is going to 128x the damage of a level 1 attack, upi can simply multiply the low level hit points by 128, getting around 2,000. And you'll be able to build a system that copes with that, and still feels like the numbers are massive, without using video game numbers. So in summary: my recommendation is to swap the idea of an exponential scale (going from 15 to a billion hits) to a linear one (going from 15 hits to 1-2,000). Everything will be easier - and not just easier, but actually feasible to use at a tabletop.

GiGs, to answer your first question about dmg to HP to reduce ho, the average hits for an encounter, 1 on 1, should be 4 ish. Where npc does on 4. A player usually is going to be better off and more powerful. Hard encounters would be maybe 6 or 8. OR still 4, but the NPCs damage would be equal to the players, or more. That is a GM determination. Again, this isn't something I want fully standardized. It's more story/theater of the mind. A d not meant to be so rules oriented. This puts more weight on the GM.  So I wanted some clear cut guidelines the GM can use, more as a reference than a hard rule.

I really like your solution. I played 20 years with the huge numbers one. Billion HP, etc.  In fact we had 3 different scales of armor.  HP, armor points and hulk points.  Each 100x the previous scale. That said, the GM was a certifiable genius and handled most of the data crunching with some amazing intuition. He's not relevant anymore and so when I decided to codefy I began to struggle. The phb is written, but a lot of the numbers get wonky quickly (I'm play testing now.) But the plot line and story, and all the facets of the game we developed was as epic as star wars and as intricate as game of thrones.

Michael D. said: That said, the GM was a certifiable genius and handled most of the data crunching with some amazing intuition. I would not be surprised if that GM made up a lot of stuff and fudge the numbers, so it seemed like things were flowing smoothly, and he was evading the system to make it work. (I have been that kind of GM.)

GiGs said: Michael D. said: That said, the GM was a certifiable genius and handled most of the data crunching with some amazing intuition. I would not be surprised if that GM made up a lot of stuff and fudge the numbers, so it seemed like things were flowing smoothly, and he was evading the system to make it work. (I have been that kind of GM.) In the beginning there was a lot of fudging. But as the system developed it became easy to play without him having to do a lot of mental math all the time.  We knew what the levels meant, magic power, Tech Levels, etc. It got to a point where he could focus on the story and be able to create foes very easily based on our current power levels. Weapons, Armor and gear were more about money than anything else. We usually didn't play engineers. (When I played solo with him I did do some engineer stuff). He was a fantastic story teller.

Oosh said: Kind of - it just outputs to console at the moment, but it's easy to turn it into a function that outputs the progression. Exactly what kind of output do you need? Just an array like this? const output = ['1d4', '1d8', '1d12', '1d20', '2d20', '2d20 + 1d4' ... ] You'd then access each level with a ( level -1 ) index. So output[0] would give you skill level 1. Those are all strings too, ready to put into a roll expression. So putting `[[ ${output[0]} ]]` as the value of a roll button would roll 1d4. Is the roll expression string (based on current skill level) all you'll be needing to retrieve? Oosh! Sorry, I missed the question at the bottom! Dice progression gets reference in several different areas. When rolling for HP of the armor or dmg for the weapon (HP is 4x that of weapon, so the weapon progresses slower). Some combat skills have it. I would just need to be able to refer to it before the dice table is read, meaning I would need to be able to to say "Skill Level / # = level of dice count progression" Does that make sense?