Skill Challenge success calculator

[ravenight]

:blink blink: So for easy challenges, the higher the complexity the easier chance of success... That can't be right, I'm guessing the math is off somewhere.

Yeah, many people, Stalker0 primarily, have pointed out that this is the case. It is the one flaw in the system that I think they have to errata, because it is the only that makes absolutely no sense. Everything else can be fixed with careful challenge design or slightly adjusted DCs for a party with no highly skilled players, or just on-the-fly reactions, but this basic flaw in the math is just silly and can be chalked up only to error.

 

[Stalker0]

Yeah, many people, Stalker0 primarily, have pointed out that this is the case. It is the one flaw in the system that I think they have to errata, because it is the only that makes absolutely no sense. Everything else can be fixed with careful challenge design or slightly adjusted DCs for a party with no highly skilled players, or just on-the-fly reactions, but this basic flaw in the math is just silly and can be chalked up only to error.

You can't just fix this without completely changing the system, especially the complexities, and then retoll everything based on that.

 

[mach1.9pants]

I have been trying to keep up witht he math but my math is now so poor at deeper levels (attrophied since college) that I have gven up.

Soooo can a math genius or genii give me an easy 'do this an it is good enough' type fix. Like set all DCs 3 lower than recommended by DMG or whatever.

Or is that not just going to happen?\
Cheers

 

[Saeviomagy]

I have a java-based skill challenge simulator. And by simulator I mean brute-force, evaluate all possible outcomes and give the cumulative probabilities. It's even possible to program in AI for the players (like: if the guy after me has a skill 2 points higher than me, do a +/-2 skill check instead, or always assist unless I have the group's highest skill).

Do enough people know how to use java that something like this would be useful?

Would people be ok downloading and executing source?

Would I be fine publishing such source here?

 

[baudot]

You can't just fix this without completely changing the system, especially the complexities, and then retoll everything based on that.

I save to disbelieve!

But seriously:
Look at what happens to the math when you let the party undo (Complexity+1) failures and assume +9+levelMod as the standard skill level. You get a 50/50 success failure split. Plenty of room from there to juggle challenge design in how you give them them those failure undos, and where you let them pick up bonuses to tip them over 50% odds.

For me, the big breakthrough was realizing that the permutation distribution for the possible rolls fell on Pascal's Triangle.
(See: http://en.wikipedia.org/wiki/Pascal's_triangle )
Once you spot this, you see that you can get your players back to even odds (if their individual skill checks are even odds) by giving them the remaining half of the triangle, rather than just a 3rd off to one wing.

Indulge me. Pull up the wikipedia link above. Scroll down until you get to the 16 row triangle.

Now look at row 5 (row 6, if you count the 0 at the top), the one that goes:
1 5 10 10 5 1
This is our row that represents a complexity 1 challenge.
That is:
There's at most 5 rolls of the dice.
1 possible version is all successes.
5 possible versions are all but one success.
10 possible versions are all but two successes.
10 possible versions are all but two failures.
5 possible versions are all but one failure.
1 possible version is all failures.

Right now, only the first two possibilities are considered to pass the check. If we can push the third in, we can get back to balance. - 16 out of 32 ways to succeed, 16 out of 32 ways to fail. If we fail as often as we succeed on the individual die rolls, badda bing, badda boom. 50% chance.

And this is where the idea of designing failure forgiveness into challenges comes in. Make sense?

 

[baudot]

The math behind complexity+1:
This is the same as the number of failures that causes the challenge to end in failure as a whole. This is just a sneaky way of saying that the new challenge chart is


Level Win Lose
1 4 4
2 6 6
3 8 8
4 10 10
5 12 12


Now instead of looking at row 5 of pascal's triangle for a complexity 1 challenge, you're looking at row 7, with 4 of the chances to either side. The side checks to earn the failures forgiven gives the DM a lot of room for interesting story work. So for each complexity level, you're looking at a third more checks maximum, plus the checks needed to earn those checks. And fixed!

 

[baudot]

To make forgiveness checks properly dramatic, their should be some kind of pressure on them. This can't be "if you fail the check it adds one to your failures" since that would make them a wash (at skill 9) and undo the whole point.

Healing surges, where appropriate, remain good. If the party isn't under pressure for their surges, (i.e. they'll have some other damaging encounter before or after the skill challenge) then it's pretty meaningless.

Money costs fit some scenes. Since it represents open bribery in a social challenge, I'd make the costs go up as the party had more failures to erase. They're obviously desperate. Then again, bribing in advance can show you as an easy mark, so that might not be the best either. Room to give the NPC being bribed some personality here. In a crafting challenge, it might represent throwing out less-than-perfect materials partway through the process, and starting over fresh.

In a long, spread out challenge, earning a forgiveness could be a mini-scene. As an example, imagine the party needs to win over and rally a town of suspicious villagers before an enemy army arrives. Each success on the challenge represents a villager speaking up for them at the town council meeting, and each failure is a villager that goes out of his way to smear their name. If they pass the challenge they've managed to reverse the suspicions of the villagers to trust. Say this is a major plot point and I want my party to be able to win the village over almost assuredly, but make this brute force way of winning the village costly. I call it a complexity 3 challenge. Each day they can roll one social skill to win over (or anger) a villager, without doing any quests. That gives them 8 days to win or lose the challenge. Because I want them to be able to force a win, I devise 6 individual scenes, each of which can automatically win over a villager, or earn forgiveness from one who the party had previously angered.

Typical scenes might be climbing down a dangerous cliff to rescue a lost goat, or volunteering to repair the town's walls for an afternoon. There are unrelated scenes the party could be using their time to perform that are more profitable, like reforging their armor, or researching magical ruins near the village. These do nothing to earn the respect of the villagers, but they have a typical scene treasure reward where the scenes that win the villagers over don't. This is essentially a way of hiding a gold cost in a non-bribery social interaction.

In all these cases, not earning forgiveness doesn't count as another failure, but getting the forgiveness does imply a cost. A party that's exceptionally skilled can breeze through without ever paying it, and a more modestly skilled party only starts paying after they've used up their "free" failures.

 

[baudot]

Clearly I need to sleep more and think about skill challenges less. I just restated ideas from the DMG as if they were original. To be clear, the only original thing in that last post was the notion that if you can pay some in-game resource for forgiveness, it nicely meters the cost, since a skillful party gets away without paying and a less skilled party can still succeed at some cost. If the PCs can't shirk rolling, this nicely captures the pressure they should feel in a skill challenge, but may be more forgiving than the version of this they hint at in the DMG.

 

[ravenight]

I do like the idea of failure forgiveness, but I think the complexity+1 metric still has the problem of not actually increasing the difficulty based on complexity (the difficulty stays flat assuming there is no player skill to the challenge that would improve with a longer challenge).

Below is a perl script I wrote to simulate skill challenges. The easiest things to tweak are at the parameters at the top and the function calls at the bottom (the variables are number of trials, successes for victory, failures for loss). Hopefully the comments make it clear what each things does: the basic idea is that some number of checks are primary and some number are secondary - primary checks give official successes and failures, secondary ones give a stacking +2 to the next primary. Which checks are secondary or primary is determined at random.

You can control the DCs by changing the values pushed into the check_DC_distribution array (you can push as many as you want). So if you want the DCs that are possible to be 15, 17, 23 and 24, you just push each of those onto the array and it chooses one at random. I think this simulator may slightly underestimate the PCs chances of success, because it doesn't allow them to tend towards repeating easy checks and avoiding harder ones, nor does it account for the fact that if I've got +11 in stealth and there's a DC 13 stealth check, then it will always come up as my +11 vs. the DC 13 (it instead randomly shuffles skill values and check DCs based on the distributions). It also allows the same skill to make both secondary and primary checks. I don't think these assumptions are actually that bad but they assume a bit of malleability of challenges that may not always be the case.

Hopefully this is useful to some people with perl interpreters (you can get one free from activestate, though I wouldn't recommend running any code you find on some forum post unless you understand what it does).

#****Defined Parameters****
#**Skill bonuses for trained skills
$lowskill_bonus = 8;
$highskill_bonus = 11;

#**Percentage of trained skills that use $lowskill_bonus
$lowskill_percent = (2/3);

#**Ratio of primary skill checks vs. secondary skill checks
$primary_ratio = (1/2);

#**Parameters for secondary skill checks
$secondary_bonus = 2;
$secondary_DC_increase = 0;

#**Parameters for DM granting a "best friend" bonus
$DMsBestFriend_chance = 0.25;
$DMsBestFriend_bonus = 2;

#**Distribution of DCs for all skill checks
push(@check_DC_distribution, 15);
push(@check_DC_distribution, 15);
push(@check_DC_distribution, 15);

#****Main Loop****
sub simSkillChallenge {

	my ($num_iterations, $max_successes, $max_failures) = @_;
	my $failed = 0;
	
	my $check_DC_sum = 0;
	my $check_DC_iters = 0;

	for($i = 0; $i < $num_iterations; $i++) {
		my $successes = 0;
		my $failures = 0;
		my $previous_bonus = 0;
	
		while($successes < $max_successes) {
			#determine player's base bonus
			my $player_bonus = 0;
			my $skill = rand();
			if($skill < $lowskill_percent) {
				$player_bonus = $lowskill_bonus;
			} else {
				$player_bonus = $highskill_bonus;
			}
			
			#DMs best friend modifier
			my $DMroll = rand();
			if($DMroll < $DMsBestFriend_chance) {
				$player_bonus += $DMsBestFriend_bonus;
				#print "Got a DMs Best Friend! (now at \+$player_bonus)\n";
			}
			
			#Determine primary or secondary check
			my $isprimary = 0;
			my $primary_roll = rand();
			if($primary_roll < $primary_ratio) {$isprimary = 1;}
			
			#select check's DC
			my $check_index = int(rand(@check_DC_distribution));
			#print "Check index: $check_index\t@check_DC_distribution\n";
			my $check_DC = $check_DC_distribution[$check_index];
			
			#calculations to verify check DCs
			$check_DC_sum += $check_DC;
			$check_DC_iters++;
			
			#apply adjustment for secondary checks
			if($isprimary) {
				#Apply bonus from previous secondary checks
				$player_bonus += $previous_bonus;
				$previous_bonus = 0;
			} else {
				$check_DC += $secondary_DC_increase;
			}
			
			#make the roll and adjudicate results
			my $player_roll = int(rand(20));
			$player_roll += $player_bonus;
			#print "Roll: $player_roll, isprimary: $isprimary\n";
			if($player_roll >= $check_DC) {
				if($isprimary == 1) {
					$successes++;
					#print "Success!\n";
				} else {
					$previous_bonus += $secondary_bonus;
					#print "Got a secondary bonus!\n";
				}
			} else {
				if($isprimary == 1) {
					$failures++;
					#print "Failure!\n";
				}
			}
			
			if($failures >= $max_failures) {
				$failed++;
				$successes = $max_successes;
				#print "Lost the Challenge!\n";
			}
		}
		if($failures < $max_failures) {
			#print "Won the Challenge!\n";
		}
	}
	
	my $failed_percent = 100 * $failed / $num_iterations;
	my $check_DC_average = $check_DC_sum / $check_DC_iters;
	
	print "\nOf $num_iterations tries, $failed were failures ($failed_percent %)\nAverage DC: $check_DC_average\n";
}

print "Complexity 2:\t";
simSkillChallenge(10000, 6, 4);

print "Complexity 5:\t";
simSkillChallenge(10000, 12, 4)

 

[baudot]

I do like the idea of failure forgiveness, but I think the complexity+1 metric still has the problem of not actually increasing the difficulty based on complexity (the difficulty stays flat assuming there is no player skill to the challenge that would improve with a longer challenge).

That's deliberate.

The notion I was aiming for was that more complex is not the same as more risky. Rather, more complex is a longer, more involved task, and if it has a cost, that cost will be higher. That is, if every fourth check forces you to pay to erase a failure, each complexity level on average results in that cost happening once. For an example, if there's a challenge where you can buy off a failure at the cost of a healing surge (a forced march over dangerous terrain on the way to a battle, perhaps) then the difference between a complexity 1 challenge and a complexity five challenge is not the chance of success or failue, but whether one party member ends up paying that cost only, or if each party member loses a surge on average.