owlbear

Owlbear
=======

Parses and composes dice notation, with support for exploding dice, rerolls, discarding lowest rolls, moving along a dice chain and simple arithmetic. Doesn't actually roll anything.

Example
=======

``
var Owlbear = require('owlbear');

myOwlbear = new Owlbear();

myOwlbear.parse('4d6k3'); // k: keep n of x in xdykn
/*
returns:
[
{
count: 4,
chain: 0,
keep: 3,
die: {
sides: 6,
reroll: [],
explode: []
}
}
]
*/

myOwlbear.parse('1d4R! + 5'); // R: reroll lowest (1), !: explode highest (4)
/*
returns:
[
{
count: 1,
chain: 0,
keep: 1,
die: {
sides: 4,
reroll: [1],
explode: [4]
}
},
{
operator: '+'
},
{
constant: 5
}
]
*/

// or just get super goofy.
// >: shift up dice chain, <: shift down.
// r: reroll listed, x: explode listed.
myOwlbear.parse(Math.PI + 'd10.5r6.2,6.3x10!>>>><');
/*
returns:
[
{
count: Math.PI,
chain: 3,
keep: Math.PI,
die: {
sides: 10.5,
reroll: [6.2, 6.3],
explode: [10.5, 10]
}
}
]
*/

// we can go backwards as well.
myOwlbear.compose([
{
constant: 10
},
{
operator: '*'
},
{
count: 1,
chain: -1,
keep: 1,
die: {
sides: 4,
reroll: [1],
explode: []
}
}
]) == '10*1d4R<';
`

Owlbear objects
===============

`
new Owlbear(options);
`

Creates a new owlbear.

Supported options:

- `operators` - Supported operators. Defaults to [ '*', '/', '+', '-' ].

parse() method
==============

`
owlbear.parse(notation);
`

Dice notation may include any of the supported operators (as above) between die specifications. Each specification may be either a numeric constant or a die. Dice are in the format:

(number of dice)d(sides on a die)R!r(comma-separated numbers)x(comma-separated numbers)k(number of dice to keep)><

- (number of dice) defaults to 1 if not present. May be floating point, must be non-negative.
- (sides on a die) May be floating point, must be non-negative.
- R indicates the lowest possible roll should be rerolled on this die.
- ! indicates the highest possible roll should 'explode' -- be rerolled and added in.
- r indicates the numbers afterward should be rerolled.
- x indicates the numbers afterward should 'explode'.
- k(number of dice to keep) indicates that only the highest n dice count.
- < and > indicate shifts along a dice chain.

parse() returns an array of objects as shown in the above examples.

compose() method
================

`
owlbear.compose(Object[])
``

Returns a string of dice notation that will parse as the object provided.