Success chances for Skill Challenges

[AbdulAlhazred]

At the risk of sounding like a broken record, I would like to reiterate that I think the "three failures" model and the "failed skill check results in a failure" condition is a very poor setup for skill challenges in general.

Well, I ran a number of SCs using Obsidian SC system and what I've found is between it and the updated 4e system there are SOME differences, but not as much as you might think. Obsidian eschews failures, but in essence they still exist in that anything that isn't a success is a failure. In fact it deters people from using secondary skills in that they either have to also contribute to the success count or else they are effectively failures. It does pretty much mandate that everyone participate (I guess you could sit on your hands, but it would just hurt the party). So it has a couple of strengths, but equally the more structured round based mechanics can be too constraining at times.

In any case, if someone has come up with some other set of mechanics that doesn't involve counting up how many times you made your DCs I for one want to hear about it. I can easily structure a ADVENTURE that way, but any kind of activity can be broken down to SCs. If it involves a branching plot line then it should be multiple SCs and that's about the only other way I can think of to structure that kind of activity is as some sort of "flow chart". It would simply be a slightly different way of deciding what die roll counts for what in the end.

 

[msherman]

In my next game, I'm running a mystery type plot. Lots of roleplaying to investigate the source of the mystery, with an ambush in the middle and a boss fight at the end. The RP will be a skill challenge, with the results of the challenge determining how prepared they are for the boss fight: full success will have them surprise the boss and rescue his captives, partial success will have the boss ready for him, and he'll execute the prisoners when the party attacks, and a failure will have the party not even find the bosses lair, so he'll attack them elsewhere, and as a result, they won't get his treasure.

We've been using Obsidian, but the one thing I don't like about it is the strict 3 round structure -- it can get in the way of an RP scene, especially a long open-ended one like I plan for this scenario. So I'm going to try something new for this adventure: I'm giving each player 3 tokens, representing their three tries in the skill challenge. I'll call for skill checks left and right during the RP as they investigate the mystery, but it's up to the players to decide when to use a token -- the actions they use tokens on will have more significant results, pass or fail. For example, a player might decide to use one of his tokens on a Streetwise check while trolling for info at a bar. A success without the token might only get him one item from my list of secrets, while with the token he'll get three. A failed check without a token might not get any ill effect, but with the token, a failure might attract the bad guys attention and provoke the planned ambush attack. PCs won't be allowed to use a token for a skill they've already succeeded with in the SC, but of course they can still make the check without a token.

So the players will still be making 3 checks each in the skill challenge, but they won't be forced to act in turn, or forced to stop acting just because they've already done something this round, even if there's something to do that their PC is best suited for (like, say, the Bard not being able to sweet-talk someone because he's already acted).

 

[sfedi]

The errata changes the complexities. That will totally change your results.

You're right, I'm going to edit the first page and make it clear how many successes and failures I've calculated those results with.

It's 2 + 2*C, not 3*C successes needed. But the errata is what made it 3 failures max, so you at least had that already.

Ok, so the results above should still apply for Complexity 2 Skill Challenges.
They need 6 successes before 3 failures in both systems.

In any case, if someone has come up with some other set of mechanics that doesn't involve counting up how many times you made your DCs I for one want to hear about it.

Slightly off-topic, but I recommend you this articles:

At WillSeries: How to Make a Skill Challenge Fun «

At WillSeries: How to Design a Skill Challenge «

And check out his examples:

At WillSeries: Skill Challenges «

The main idea, which I think is key, is to introduce some type of resource to a skill challenge.

 

[sfedi]

A sophisticated programmer could probably find a good way to "brute force" these calculations; simply running 100,000 simulations for each set of values is also a valid approach.

The above calculations are exact.

The calculus is somewhat complex, because it first makes a tree of all the possible paths of rolls:

Example for Complexity: 3 successes, 3 failures
Path 1: 3 successes
Path 2: 2 successes, 1 failure, 1 success
Path 3: 1 success, 2 failures, 1 success
...
Path n-1: 2 failures, 1 success, 1 failure
Path n: 3 failures

For each path it determines if it is a success or a failure (just by looking at the last roll), it calculates it probability and finally it adds all probabilities for successes, and for failures.

You can even tell the algorithm to run the calculus with different chances for each roll.

 

[sfedi]

Sorry for the multiple post, I think it makes clearer the different results and answers.

This are the results of the errata applied:


Success chance for Skill Challenges complexity 1 (Need 4 successes before 3 failures)

Individual chance 30%: 7%
Individual chance 35%: 12%
Individual chance 40%: 18%
Individual chance 45%: 26%
Individual chance 50%: 34%
Individual chance 55%: 44%
Individual chance 60%: 54%
Individual chance 65%: 65%
Individual chance 70%: 74%
Individual chance 75%: 83%
Individual chance 80%: 90%
Individual chance 85%: 95%
Individual chance 90%: 98%


Success chance for Skill Challenges complexity 2 (Need 6 successes before 3 failures)

Individual chance 30%: 1%
Individual chance 35%: 3%
Individual chance 40%: 5%
Individual chance 45%: 9%
Individual chance 50%: 14%
Individual chance 55%: 22%
Individual chance 60%: 32%
Individual chance 65%: 43%
Individual chance 70%: 55%
Individual chance 75%: 68%
Individual chance 80%: 80%
Individual chance 85%: 89%
Individual chance 90%: 96%


Success chance for Skill Challenges complexity 3 (Need 8 successes before 3 failures)

Individual chance 30%: 0%
Individual chance 35%: 0%
Individual chance 40%: 1%
Individual chance 45%: 3%
Individual chance 50%: 5%
Individual chance 55%: 10%
Individual chance 60%: 17%
Individual chance 65%: 26%
Individual chance 70%: 38%
Individual chance 75%: 53%
Individual chance 80%: 68%
Individual chance 85%: 82%
Individual chance 90%: 93%


Success chance for Skill Challenges complexity 4 (Need 10 successes before 3 failures)

Individual chance 30%: 0%
Individual chance 35%: 0%
Individual chance 40%: 0%
Individual chance 45%: 1%
Individual chance 50%: 2%
Individual chance 55%: 4%
Individual chance 60%: 8%
Individual chance 65%: 15%
Individual chance 70%: 25%
Individual chance 75%: 39%
Individual chance 80%: 56%
Individual chance 85%: 74%
Individual chance 90%: 89%


Success chance for Skill Challenges complexity 5 (Need 12 successes before 3 failures)

Individual chance 30%: 0%
Individual chance 35%: 0%
Individual chance 40%: 0%
Individual chance 45%: 0%
Individual chance 50%: 1%
Individual chance 55%: 2%
Individual chance 60%: 4%
Individual chance 65%: 8%
Individual chance 70%: 16%
Individual chance 75%: 28%
Individual chance 80%: 45%
Individual chance 85%: 65%
Individual chance 90%: 84%

 

[sfedi]

The code

For those who asked, here's the code:

The evaluation code, which generates the text I posted:

[sblock]

| calculator result desc |
desc := WriteStream on: String new.
1 to: 5 do: [ :complexity | | successes failures maxNumberOfRolls |
 successes := 2 + (2 * complexity).
 failures := 3.
 maxNumberOfRolls := successes + failures.
 desc cr; cr.
 desc nextPutAll: 
  'Success chance for Skill Challenges complexity ', 
  complexity printString, ' (Need ', successes printString, ' successes before ',
  failures printString, ' failures)'.
 desc cr; cr.
 0.3 to: 0.95 by: 0.05 do: [ :successRate |
  desc nextPutAll: 'Individual chance '.
  (successRate * 100) asInteger printOn: desc.
  desc nextPutAll: '%: '.
  calculator := SCCalculator 
    failures: failures
    successes: successes
    chances: (Array new: maxNumberOfRolls withAll: successRate).
  result := calculator execute.
  (result successChance * 100) asInteger printOn: desc.
  desc nextPutAll: '%'.
  desc cr.
 ].
].
desc contents.

[/sblock]

Note that it is almost all text formating. The proper calculation is done here:

Higher level algorithm methods:

[sblock]

SCCalculator>>execute
	"Return result of the calculation"

	| unsolvedPaths solvedPaths |
	unsolvedPaths := OrderedCollection new.
	solvedPaths := OrderedCollection new.
	unsolvedPaths add: SolutionPath new.
	[unsolvedPaths notEmpty] whileTrue: 
			[| toSolvePaths |
			toSolvePaths := OrderedCollection new.
			unsolvedPaths do: 
					[:solutionPath | 
					(self isSolved: solutionPath) 
						ifTrue: [solvedPaths add: solutionPath]
						ifFalse: [toSolvePaths addAll: (solutionPath nextPathsWithChances: self chances)]].
			unsolvedPaths := toSolvePaths].
	^SCSolutionPaths solutionPaths: solvedPaths

SCCalculator>>isSolved: aSolutionPath 
	^(aSolutionPath successes = self successesNeeded) 
	or: [aSolutionPath failures = self maxFailures].

SCSolutionPaths>>successChance
	^(self solutionPaths select: [:each | each isResult: #success]) 
		inject: 0 
		into: [ :total :successPath | total + successPath probability]

[/sblock]

What this does is to generate "solution paths", that is, a series of successful rolls or failed rolls in several combinations.
(a path is solved if it has enough successful rolls or enough failed rolls)
It collects all solution paths.
It will then ask it's "successChance" and it will sweep all successfull outcomes and sum up their individual probabilities.

How an incomplete solution path, gives it's next two solution paths, and some other helper methods:

[sblock]

SolutionPath>>nextPathsWithChances: chances 
	| newPaths successPath failurePath |
	newPaths := OrderedCollection new.
	successPath := SolutionPath new.
	successPath nodes: self nodes copy.
	successPath nodes add: (SCSolutionNode result: #success probability: (chances at: self nodes size + 1)).
	newPaths add: successPath.
	failurePath := SolutionPath new.
	failurePath nodes: self nodes copy.
	failurePath nodes add: (SCSolutionNode result: #failure probability: 1 - (chances at: self nodes size + 1)).
	newPaths add: failurePath.
	^newPaths

SolutionPath>>failures
	^(self nodes select: [:each | each result = #failure]) size

SolutionPath>>successes
	^(self nodes select: [:each | each result = #success]) size

SolutionPath>>probability
	^self nodes inject: 1 into: [ :total :node |
		total * node probability ]

[/sblock]

The rest of the code is really trivial: accessors most of them.

 

[Stalker0]

A good solid summary.

One thing it doesn't take into account though is that rarely party members are using skills with exactly the same bonus.

For example, Fighters tend to have weaker skills in general. There best skills (like athletics or endurance) are often hindered by ACP, which lowers the max value.

Also in my experience certain skills are more coveted and certain classes more willing to take magic items and feats to bump skills.

A rarely see a player take skill focus streetwise, but skill focus perception...sure.


Now you can average the party's bonus and run the numbers that way but its not completely accurate (an average value provides higher success rates in general then looking at extreme values).

 

[AbdulAlhazred]

I think you can do the calculations more easily by simply summing the probabilities of failures. It actually doesn't matter what the sequence of rolls is. So for complexity 1 its 7 rolls with less than 3 failures. So all you need to know is the chance in 7 rolls of 3 dice coming up below N. That number is 7/(21-N)*.05 + 6/(21-N)*.05 + 5/(21-N)*.05 is it not?

 

[sfedi]

One thing it doesn't take into account though is that rarely party members are using skills with exactly the same bonus.

Mmm, I don't know what you mean here.

This calculation takes into account the success chance of a roll.
It doesn't account for skill bonuses or DCs.

You mean that it is rare that a party has always the same chance for each roll accross a SC?

Now you can average the party's bonus and run the numbers that way but its not completely accurate (an average value provides higher success rates in general then looking at extreme values).

I ran some cases, which I don't consider conclusive in any way.

Here are the results:

Success chance for Skill Challenges complexity 2 (Need 6 successes before 3 failures)

chances := #(0.65 0.65 0.65 0.65 0.65 0.65 0.65 0.65 0.65 0.65 ).
SC success chance: 43%

chances := #(0.5 0.8 0.5 0.8 0.5 0.8 0.5 0.8 0.5 0.8 ).
SC success chance: 42%

chances := #(0.8 0.5 0.8 0.5 0.8 0.5 0.8 0.5 0.8 0.5 ).
SC success chance: 42%

chances := #(0.6 0.7 0.6 0.7 0.6 0.7 0.6 0.7 0.6 0.7 ).
SC success chance: 43%

Note that all cases have a 65% average chance.

The first is always the same chance for each roll.

The second is 50% for the first, then 80% for the second and so on.

The third case is 80% for the first, then 50% for the second and so on.

And the last is analog to the second case, but with a lesser variance.

 

[sfedi]

I think you can do the calculations more easily by simply summing the probabilities of failures. It actually doesn't matter what the sequence of rolls is. So for complexity 1 its 7 rolls with less than 3 failures. So all you need to know is the chance in 7 rolls of 3 dice coming up below N. That number is 7/(21-N)*.05 + 6/(21-N)*.05 + 5/(21-N)*.05 is it not?

Mmm, I'm not sure about that.

In any case, I chose not to go that way because I wanted to analyze the case where you had different chances for each roll of the SC.
And you can't do that with a formula (at least not in this case).

That's why I needed a program like the one I did, so you can feed it an arbitrary sequence of chances and calculate the chance of succeeding in the skill challenge.