Joined
Last Online
Recent Posts
posted in Super Secret RPG read more

I don’t think we need to throw away everything, but we do need to re-think some things.

If we use a white-wolf style die pool, where any die is above a certain number is a success, we have a system where there’s a clear increase of player capability since each added die increases the number successes on average. If the success threshold on the die is low enough, like 5, it means untrained players have a chance.

Add in the concept that an encounter (combat or not) is over once a certain number of successes are achieved, or some other less desirable result occurs (too much time passes , or the players are KO’ed). We add in that some things are resistant, and negate successes when ‘attacked’ (for lack of a better term). A locked door with a hard lock might negate 2 lock-picking successes, but if it’s made of rotting wood, negate 0 ‘attack’ successes. An ancient dragon negates more successes than a cabled minion of the same level.

I’m not a fan of needing to specify how many successes each item should take, but if the system is regular enough, then we should be able to have a table similar to what is in the DnD GM screen: At level L, hard task absorbs N, a standard N - M, and an easy absorbs N - M - O. With a shallow enough pool of stat increases, we may not even need a particularly long table.

The DOI has a 1/5 chance of making a result more interesting, so having a clear ‘degree of failure’ beyond that is adding complexity to a ‘not fun’ mechanic (as Travis pointed out), but helps turn it to a fun one. It’s also easier to explain than the wild die and exploding die of d6 and white-wolf.

If that’s the system, d6’s might be nice as they are more common, and would be immediately discernible from a d10. I think I might be getting ahead of myself here.

posted in Super Secret RPG read more

I think there is something wrong with the code you are using to generate the results. I wrote a script to do the same, and got something very different, and one that jives with intuition: the more dice you roll, the more likely you are to get above the target number, making the target numbers worthless after a very small poolsize. Note that the 100.0% are not because it always succeeded, but because I’m rounding to 1 significant digit.

Target Pool 4 Pool 7 Pool 10
1 100.0% 100.0% 100.0%
2 99.9% 100.0% 100.0%
3 99.3% 99.9% 100.0%
4 97.5% 99.6% 100.0%
5 93.1% 99.1% 100.0%
6 85.9% 97.6% 99.3%
7 75.3% 92.0% 96.6%
8 57.4% 80.1% 89.3%
9 34.9% 52.9% 65.2%
10 0.0% 0.0% 0.0%

The only target numbers worth anything are 7, 8, and 9, and even 7 and 8 lose their worth by level 12.

Code used to generate results:

#! /usr/bin/env escript

main([ThreshStr, PoolSizeStr, ItorsStr]) ->
	main([ThreshStr, PoolSizeStr, ItorsStr, ""]);

main([ThreshStr, PoolSizeStr, ItorsStr, Debug]) ->
	random:seed(os:timestamp()),
	Thresh = list_to_integer(ThreshStr),
	PoolSize = list_to_integer(PoolSizeStr),
	Itors = list_to_integer(ItorsStr),
	ResSetCounts = lists:map(fun(_) ->
		ResList = roll_dice(PoolSize),
		case Debug of
			"true" ->
				io:format("~p~n", [ResList]);
			_ ->
				ok
		end,
		count_successes(Thresh, ResList)
	end, lists:seq(1, Itors)),
	RollsSuccess = lists:foldl(fun(N, Acc) ->
		if N > 0 -> Acc + 1; true -> Acc end
	end, 0, ResSetCounts),
	RawRatio = RollsSuccess / Itors,
	NicePercent = nice_percent(RawRatio, 2),
	io:format("~p%~n", [NicePercent]).

nice_percent(Ratio, SignificantDigits) ->
	Smaller = math:pow(10, SignificantDigits),
	Bigger = 100 * Smaller,
	round(Ratio * Bigger) / Smaller.

count_successes(Thresh, ResList) ->
	Filtered = lists:filter(fun(N) -> N > Thresh end, ResList),
	length(Filtered).

roll_die() ->
	random:uniform(10).

roll_dice(N) ->
	roll_dice(N, []).

roll_dice(0, Acc) ->
	Acc;

roll_dice(N, Acc) ->
	roll_dice(N - 1, [roll_die() | Acc]).

Invoked in a loop:

for tn in `seq 1 10`; do echo "th: $tn"; for ps in 4 7 10; do echo "ps: $ps"; ./r.escript $tn $ps 1000; done; done


Looks like your connection to Lord Null was lost, please wait while we try to reconnect.