People familiar with OpenRPG are familiar with the wide array of die functions it has
And probably others I'm forgetting and too lazy to look up the code of. Everything OpenRPG's roller does is included in the list below.
I made an argument in custom die thread for changing the way the dieroller works to something where people can set a campaign's default dieroller to be something specific to their system, without having to deal with the clutter of entering in some complicated symbol sequence every freaking time. In addition, they could create aliases for future roller use.
So say, an Exalted game could have two aliases setup, the default /roll xd being mapped to /generic xd10.tn(7).tn(10), while the /damage alias would skip the double-counting on the last .tn(10) there.
Despite the appearance, implementing this as pure method chaining, with set values being passed forward from function to function, leads to bad gotchas - some functions will need to be aware of each others existence inside of a chain, for example in e.g. L5R 3e and other systems involving limited numbers of rerolls combined with unlimited. In my roller it works in phases.
So, here's a list of transforms I have so far:
Affects the number of dice returned:
kx is an alias for .keep(x) - keep the highest x dice
lx is an alias for .lowest(x) - keep the lowest x dice
.prune(x) - prunes the highest and lowest x dice, each.
.extra(x) - an extra die is rolled for results of x or higher if x is positive, or -x or lower if x is negative. Treated as a new, unique die.
Affects the value of individual dice
.floor(x) - any die result under x is set to x.
.ceiling(x) - any die result over x is set to x.
.minroll(x) - sets the minimum possible roll to x, before the random number is generated, so there is still an even spread over the die's possible values.
.maxroll(x) - as above, but for the maximum value.
.addAll(x) - adds x to each die.
.explode(x) - The result of the reroll is added to the individual die, rather than treated as a new die as with extra().
.overRoll(x) - Like explode, but only works once.
.sortHighest() - Sorts die results from highest to lowest
.sortLowest() - lowest to highest
.sets() - Picks out set results, so you roll e.g. 10d10 and get 9,1,4,6,9,4,3,4,1,4, you get 4x4, 2x9, 2x1, 1x6, 1x3. One Roll Engine
The following change the way the total is calculated.
.tn(x) - If x is positive, successes are counted for x and over. if x is negative, for -x and under.
.tnCancel(x) - Cancel successes.
.successAdd(x) - adds an additional success on a result of exactly x
.successSubtract(x) - removes a success ""
The following work on the final total
.dc(x) - Difficulty. Raw result desired for success
.dcThreshold(x) - For systems with in-built threshold successes, e.g. 7th Sea, you'd set this to 5
Again, most players won't end up seeing most of this, in an ideal situation, because rather than require them to type all of this over and over, they instead use pre-built aliases that apply as many of the above functions as possible.
A number of these could take a second parameter or otherwise have some function modifying them. Before I went too far down that road I thought up something a lot more flexible than the above, allowing for dice to 'interact with each other', but I'm still trying to wrap my head around it.
Anyway, anyone have any other transforms they do to their dice?