refactor ast into multiple files. cleanup rerolls. allow explode of dF, d66

Author: stevesea

CHANGELOG.md

@@ -2,16 +2,23 @@
 
 ## ⚠️⚠️ Breaking changes ⚠️⚠️
 
-Roll results have changed significantly (again). It's amazing what having users will do to a package!
+Roll results have changed significantly. Now, the individual die results are modeled 
+as a RolledDie object, rather than an integer. The RolledDie object incorporates 
+a lot of the metadata/scoring in pre-8.0.0 results. 
+
+Having a more elaborate result will make it easier for client applications
+to render the outcome of a roll. Each RolledDie knows its result, the # of sides on the die,
+whether it was counted as a success/failure, and 
 
 ## 📈 Enhancements
 
 - upgrade to dart 3.8.0
 - upgrade to petitparser 7.0.0
+- added dependency on fast_immutable_collections
 - remove metadata & score from RollResult
 - rather than simple list of Integers representing the output of a roll or operation, now each
   die rolled is a 'RolledDie' object which has the metadata/score.
-    - the RollResult's results field changes from List<int> to List<RolledDie>. RolledDie represents not just the
+    - the RollResult's results field changes from List<int> to IList<RolledDie>. RolledDie represents not just the
       outcome of the roll, but also includes metadata about the type of die, nsides of the die (if polyhedral die),
       and metadata about the dice expression's modification of the rolls.
 - RollResult.results will include both discarded an not-discarded RolledDie.

README.md

@@ -117,10 +117,12 @@ void main() {
         * `4d6 #<=2` -- roll 4d6, count any <= 2
         * `4d6 #=5` -- roll 4d6, count any equal to 5
     * successes and failures
-        * A normal count operation `#` discards the rolled dice and changes the result to be the count
+        * A simple count operation `#` discards the rolled dice and changes the result to be the count of results matching the condition
             * For example, `2d6#<=3` rolls `[3,4]` then counts which results are `<=3` , returning `[1]`
         * But, sometimes you want to be able to count successes/failures without discarding the dice rolls.
           In this case, use modifiers `#s`, `#f`, `#cs`, `#cf` to add metadata to the results.
+            * without modifiers, `#s` or `#cs` will count the result as a success if it matches the maximum possible value for the die
+            * without modifiers, `#f` or `#cf` will count the result as a failure if it matches the minimum possible value for the die
             * `6d6 #f<=2 #s>=5 #cs6 #cf1` -- roll 6d6, count results <= 2 as failures, >= 5 as successes, =6 as critical
               successes, =1 as critical failures
                 * The above returns a result like:

lib/src/ast_core.dart

@@ -0,0 +1,108 @@
+import 'package:fast_immutable_collections/fast_immutable_collections.dart';
+
+import 'dice_expression.dart';
+import 'dice_roller.dart';
+import 'results.dart';
+import 'utils.dart';
+
+/// All our operations will inherit from this class.
+/// The `call()` method will be called by the parent node.
+/// The `eval()` method is called from the node
+abstract class DiceOp extends DiceExpression with LoggingMixin {
+  // each child class should override this to implement their operation
+  RollResult eval();
+
+  // all children can share this call operator -- and it'll let us be consistent w/ regard to logging
+  @override
+  RollResult call() {
+    final result = eval();
+    logger.finer(() => '$result');
+    return result;
+  }
+}
+
+/// base class for unary operations
+abstract class Unary extends DiceOp {
+  Unary(this.name, this.left);
+
+  final String name;
+  final DiceExpression left;
+
+  @override
+  String toString() => '($left)$name';
+}
+
+/// base class for binary operations
+abstract class Binary extends DiceOp {
+  Binary(this.name, this.left, this.right);
+
+  final String name;
+  final DiceExpression left;
+  final DiceExpression right;
+
+  @override
+  String toString() => '($left $name $right)';
+}
+
+/// multiply operation (flattens results)
+class MultiplyOp extends Binary {
+  MultiplyOp(super.name, super.left, super.right);
+
+  @override
+  RollResult eval() => left() * right();
+}
+
+/// add operation
+class AddOp extends Binary {
+  AddOp(super.name, super.left, super.right);
+
+  @override
+  RollResult eval() => left() + right();
+}
+
+/// subtraction operation
+class SubOp extends Binary {
+  SubOp(super.name, super.left, super.right);
+
+  @override
+  RollResult eval() => left() - right();
+}
+
+/// base class for unary dice operations
+abstract class UnaryDice extends Unary {
+  UnaryDice(super.name, super.left, this.roller);
+
+  final DiceRoller roller;
+
+  @override
+  String toString() => '($left$name)';
+}
+
+/// base class for binary dice expressions
+abstract class BinaryDice extends Binary {
+  BinaryDice(super.name, super.left, super.right, this.roller);
+
+  final DiceRoller roller;
+}
+
+/// A value expression. The token we read from input will be a String,
+/// it must parse as an int, and an empty string will return empty set.
+class SimpleValue extends DiceExpression {
+  SimpleValue(this.value)
+    : _results = RollResult(
+        expression: value,
+        opType: OpType.value,
+        results: value.isEmpty
+            ? []
+            : [RolledDie.singleVal(result: int.parse(value))],
+      );
+
+  final String value;
+  final RollResult _results;
+
+  @override
+  RollResult call() => _results;
+
+  @override
+  String toString() => value;
+}

lib/src/ast_dice.dart

@@ -0,0 +1,133 @@
+import 'package:fast_immutable_collections/fast_immutable_collections.dart';
+import 'package:petitparser/parser.dart';
+
+import 'ast_core.dart';
+import 'dice_roller.dart';
+import 'results.dart';
+
+/// roll fudge dice
+class FudgeDice extends UnaryDice {
+  FudgeDice(super.name, super.left, super.roller);
+
+  @override
+  RollResult eval() {
+    final lhs = left();
+    final ndice = lhs.totalOrDefault(() => 1);
+
+    // redundant w/ RangeError checks in the DiceRoller. But we can construct better error messages here.
+    if (ndice < DiceRoller.minDice || ndice > DiceRoller.maxDice) {
+      throw FormatException(
+        'Invalid number of dice ($ndice)',
+        toString(),
+        left.toString().length,
+      );
+    }
+    final roll = roller.rollFudge(ndice);
+    return RollResult.fromRollResult(
+      roll,
+      expression: toString(),
+      opType: roll.opType,
+      left: lhs,
+    );
+  }
+}
+
+class CSVDice extends UnaryDice {
+  CSVDice(super.op, super.left, super.roller, this.vals);
+
+  final SeparatedList<String, String> vals;
+
+  @override
+  String toString() => '(${left}d${vals.elements})';
+
+  @override
+  RollResult eval() {
+    final lhs = left();
+    final ndice = lhs.totalOrDefault(() => 1);
+
+    final roll = roller.rollVals(ndice, IList(vals.elements.map(int.parse)));
+
+    return RollResult.fromRollResult(
+      roll,
+      expression: toString(),
+      opType: OpType.rollVals,
+      left: lhs,
+    );
+  }
+}
+
+/// roll n % dice
+class PercentDice extends UnaryDice {
+  PercentDice(super.name, super.left, super.roller);
+
+  @override
+  RollResult eval() {
+    final lhs = left();
+    final ndice = lhs.totalOrDefault(() => 1);
+    final roll = roller.roll(ndice, 100);
+    return RollResult.fromRollResult(
+      roll,
+      expression: toString(),
+      opType: OpType.rollPercent,
+      left: lhs,
+    );
+  }
+}
+
+/// roll n D66
+class D66Dice extends UnaryDice {
+  D66Dice(super.name, super.left, super.roller);
+
+  @override
+  RollResult eval() {
+    final lhs = left();
+    final ndice = lhs.totalOrDefault(() => 1);
+    final roll = roller.rollD66(ndice);
+    return RollResult.fromRollResult(
+      roll,
+      expression: toString(),
+      opType: OpType.rollD66,
+      left: lhs,
+    );
+  }
+}
+
+/// roll N dice of Y sides.
+class StdDice extends BinaryDice {
+  StdDice(super.name, super.left, super.right, super.roller);
+
+  @override
+  String toString() => '($left$name$right)';
+
+  @override
+  RollResult eval() {
+    final lhs = left();
+    final rhs = right();
+    final ndice = lhs.totalOrDefault(() => 1);
+    final nsides = rhs.totalOrDefault(() => 1);
+
+    // redundant w/ RangeError checks in the DiceRoller. But we can construct better error messages here.
+    if (ndice < DiceRoller.minDice || ndice > DiceRoller.maxDice) {
+      throw FormatException(
+        'Invalid number of dice ($ndice)',
+        toString(),
+        left.toString().length,
+      );
+    }
+    if (nsides < DiceRoller.minSides || nsides > DiceRoller.maxSides) {
+      throw FormatException(
+        'Invalid number of sides ($nsides)',
+        toString(),
+        left.toString().length + name.length + 1,
+      );
+    }
+    final roll = roller.roll(ndice, nsides);
+    return RollResult.fromRollResult(
+      roll,
+      expression: toString(),
+      opType: roll.opType,
+      left: lhs,
+      right: rhs,
+    );
+  }
+}