public void BurningHands()
{
// Let's create a smart sorcerer first:
var sorcerer = new Character {
Int = 16, BurningHandsSpellLevel = 1
};
// Then let's create a provider for a modifier derived from the sorcerer's Intelligence:
var intMod = new IntModProvider {
Character = sorcerer
};
// Create a provider for a spell damage dice count, which depends on the sorcerer's current spell level.
var spellDiceCount = new BurningHandsDiceCountProvider {
Character = sorcerer
};
// Merge these into a chain:
DiceChain damageDice = Dice.Take(spellDiceCount).D(8).EachPlus(intMod);
// Let's burn some poor fella:
double damage = damageDice.Roll();
// Let's say we want to display the spell damage, so check the dice chain stats:
Trace.WriteLine("Damage: " + damageDice.Minimum + " to " + damageDice.Maximum);
// Outputs 'Damage: 4 to 11', which is equal to '1d8+3', looks good.
// What if sorcerer gains two levels of proficiency in the spell?
sorcerer.BurningHandsSpellLevel += 2;
Console.WriteLine("Damage: " + damageDice.Minimum + " to " + damageDice.Maximum);
// Outputs 'Damage: 8 to 22', which is equal to '2d8(+3)', once again looks good.
// Parens mean that 3 is apllied to each die separately instead of affecting dice sum.
// Now let's say when you miss an enemy with burning hands, you still can deal some damage.
// In this case damage dealt to the target equals to sum of each damage die that rolled its maximum result.
// Normally you don't want to deal with individual roll values when using dice chain,
// but there is a method just in case:
List <DiceChainRollStep> rollParts;
// Normal hit damage is returned by dice chain as usual:
damage = damageDice.RollStepByStep(out rollParts);
// Damage on a miss is calculated as a sum of each damage die that rolled its maximum result.
// Looking at dice chain 'Xd8+Y' we can see that damage dice are rolled in the first (leftmost) step.
double missedDamage = rollParts[0].Rolls.Where(roll => roll == Dice.D8.Maximum).Sum();
// For the sake of completeness, there is a way of achieving the same thing without a dice chain.
// That way we have to do all calculations manually.
// Let's bundle D8 with spell damage dice count:
var rawSpellDamage = new SeveralDice(Dice.D8, spellDiceCount);
// Make a damage roll, rolling each die separately:
var rawRolls = rawSpellDamage.RollSeparately().ToArray();
// .ToArray() is important here. Otherwise different roll values would be generated on each enumeration.
// Damage on a miss:
missedDamage = rawRolls.Where(roll => roll == Dice.D8.Maximum).Sum();
// Damage on a hit:
damage = rawRolls.Select(roll => roll + intMod.Roll()).Sum();
}