Reply to thread

Message

<blockquote data-quote="DClown" data-source="post: 4312890" data-attributes="member: 70244">The previous code snippet appears to be a dart thrower algorithm from a cursory glance.&nbsp; To be honest a dart thrower was the first thing I coded just to get a general idea, so I'm not saying anything derogatory besides the fact that its inaccurate and has a more complex implementation then the recursive solution.&nbsp; The original poster got around a recursive solution by forcing all of the skill values to be the same.&nbsp; This makes the processing time dependant on a few factoral calculations for the corresponing number of combinations.&nbsp; The recursive solution allows entry of varying DCs, varying skill combinations, and varying number of successes with varying number of allowed failures.I had two assumptions about skill challenges since i've only sat down with the PHB and havent cracked the DMG yet.Do 1's and 20's still count as auto fail/success on skill challenge checks?Are the skill challenge roll pattern primary/secondary/primary/tertiary repeat?If so here is the complete algorithm.&nbsp; Its c++ but its easy to port since it really only has a single line of code that isn't setup, i/o, or proceedural.&nbsp; ( double probFail = (DC - skills[skillIndex%4]-1) * .05; )With a little bit of work you can use this algorithm to vary the parameters so that you can enter a target success rate and spit out a reasonable number of success to fail ratios for a given DC.[code]#include &lt;iostream&gt;// globals for use with the recursive functiondouble successRate = 0;int numToSucceed;int numToFail;int skills[3] = {0,0,0};// function declarationsdouble calcSuccessRate(int successes, int failures, int DC, int skill1, int skill2, int skill3);void recurseProbability(int successes, int failures, int DC, int skillIndex, double cummulativeProb);// mainint main(int argc, char** argv){&nbsp; &nbsp; int reqSuccesses = atoi(argv[1]);&nbsp; &nbsp; int allowedFailures&nbsp; = atoi(argv[2]);&nbsp; &nbsp; int DC = atoi(argv[3]);&nbsp; &nbsp; int skill1 = atoi(argv[4]);&nbsp; &nbsp; int skill2 = atoi(argv[5]);&nbsp; &nbsp; int skill3 = atoi(argv[6]);&nbsp; &nbsp; calcSuccessRate(reqSuccesses, allowedFailures, DC, skill1,skill2,skill3);}// wrapper for the recursive function, sets up globalsdouble calcSuccessRate(int successes, int failures, int DC, int skill1, int skill2, int skill3){&nbsp; &nbsp; numToSucceed = successes;&nbsp; &nbsp; numToFail = failures;&nbsp; &nbsp; successRate = 0;&nbsp; &nbsp; // do skill checks alternate primary / secondary/ primary / tertiary repeat?&nbsp; &nbsp; // if not adjust the skill matrix accordingly&nbsp; &nbsp; skills[0] = skill1;&nbsp; &nbsp; skills[1] = skill2;&nbsp; &nbsp; skills[2] = skill1;&nbsp; &nbsp; skills[3] = skill3;&nbsp; &nbsp; recurseProbability(0,0,DC,0,1.0);&nbsp; &nbsp; std::cout &lt;&lt; &quot; successRate = &quot; &lt;&lt; successRate &lt;&lt; std::endl;}// calculates the chance of successvoid recurseProbability(int successes, int failures, int DC, int skillIndex, double cummulativeProb){&nbsp; &nbsp; if ((successes+failures) &gt;= numToSucceed+numToFail)&nbsp; &nbsp; {&nbsp; &nbsp; &nbsp; &nbsp; if (successes &gt;= numToSucceed) successRate += cummulativeProb;&nbsp; &nbsp; &nbsp; &nbsp; return;&nbsp; &nbsp; }&nbsp; &nbsp; // determine chance to fail&nbsp; &nbsp; double probFail = (DC - skills[skillIndex%4]-1) * .05;&nbsp; &nbsp; // are 20 auto success and 1 auto fail?&nbsp; &nbsp; // if so then keep this, otherwise change .95 to 1, and .05 to 0&nbsp; &nbsp; if (probFail &gt;= 1) probFail = .95;&nbsp; &nbsp; if (probFail &lt;= 0) probFail = .05;&nbsp; &nbsp; // this roll is a success&nbsp; &nbsp; recurseProbability(successes+1, failures, DC, skillIndex+1, cummulativeProb*(1-probFail));&nbsp; &nbsp; // this roll is a failure&nbsp; &nbsp; recurseProbability(successes, failures+1, DC, skillIndex+1, cummulativeProb*probFail);}[/code]</blockquote>

[QUOTE="DClown, post: 4312890, member: 70244"] The previous code snippet appears to be a dart thrower algorithm from a cursory glance. To be honest a dart thrower was the first thing I coded just to get a general idea, so I'm not saying anything derogatory besides the fact that its inaccurate and has a more complex implementation then the recursive solution. The original poster got around a recursive solution by forcing all of the skill values to be the same. This makes the processing time dependant on a few factoral calculations for the corresponing number of combinations. The recursive solution allows entry of varying DCs, varying skill combinations, and varying number of successes with varying number of allowed failures. I had two assumptions about skill challenges since i've only sat down with the PHB and havent cracked the DMG yet. Do 1's and 20's still count as auto fail/success on skill challenge checks? Are the skill challenge roll pattern primary/secondary/primary/tertiary repeat? If so here is the complete algorithm. Its c++ but its easy to port since it really only has a single line of code that isn't setup, i/o, or proceedural. ( double probFail = (DC - skills[skillIndex%4]-1) * .05; ) With a little bit of work you can use this algorithm to vary the parameters so that you can enter a target success rate and spit out a reasonable number of success to fail ratios for a given DC. [code] #include <iostream> // globals for use with the recursive function double successRate = 0; int numToSucceed; int numToFail; int skills[3] = {0,0,0}; // function declarations double calcSuccessRate(int successes, int failures, int DC, int skill1, int skill2, int skill3); void recurseProbability(int successes, int failures, int DC, int skillIndex, double cummulativeProb); // main int main(int argc, char** argv) { int reqSuccesses = atoi(argv[1]); int allowedFailures = atoi(argv[2]); int DC = atoi(argv[3]); int skill1 = atoi(argv[4]); int skill2 = atoi(argv[5]); int skill3 = atoi(argv[6]); calcSuccessRate(reqSuccesses, allowedFailures, DC, skill1,skill2,skill3); } // wrapper for the recursive function, sets up globals double calcSuccessRate(int successes, int failures, int DC, int skill1, int skill2, int skill3) { numToSucceed = successes; numToFail = failures; successRate = 0; // do skill checks alternate primary / secondary/ primary / tertiary repeat? // if not adjust the skill matrix accordingly skills[0] = skill1; skills[1] = skill2; skills[2] = skill1; skills[3] = skill3; recurseProbability(0,0,DC,0,1.0); std::cout << " successRate = " << successRate << std::endl; } // calculates the chance of success void recurseProbability(int successes, int failures, int DC, int skillIndex, double cummulativeProb) { if ((successes+failures) >= numToSucceed+numToFail) { if (successes >= numToSucceed) successRate += cummulativeProb; return; } // determine chance to fail double probFail = (DC - skills[skillIndex%4]-1) * .05; // are 20 auto success and 1 auto fail? // if so then keep this, otherwise change .95 to 1, and .05 to 0 if (probFail >= 1) probFail = .95; if (probFail <= 0) probFail = .05; // this roll is a success recurseProbability(successes+1, failures, DC, skillIndex+1, cummulativeProb*(1-probFail)); // this roll is a failure recurseProbability(successes, failures+1, DC, skillIndex+1, cummulativeProb*probFail); } [/code] [/QUOTE]

Verification