split results into 'results' and 'discarded'

feels like these are distinct things, so they should be put into distinct bins.
it also felt awkward to always remember when performing operations on 'results' that some of those need to be skipped due to being discarded.

Author: stevesea

CHANGELOG.md

@@ -11,7 +11,12 @@ Roll results have changed significantly (again). It's amazing what having users
 - 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.
-- RollResult.results will include both discarded an not-discarded RolledDie. TODO: change?
+    - the RollResult's results field changes from List<int> to List<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.
+- RollSummary.results is just not-discarded die, there's a separate RollSummary.discarded. Alternatively, look at
+  RollSummary.detailedResults.results to see the whole set of die that accumulated while evaluating the expression.
 
 # 7.1.1
 

README.md

@@ -38,7 +38,7 @@ void main() {
 
 * advantage
     * `2d20-L` -- drop lowest
-    * `2d20k`, `2d20kh` -- keep highest
+    * `2d20k`, or `2d20kh` -- keep highest
 * disadvantage
     * `2d20-H` -- drop highest
     * `2d20-kl` -- keep lowest
@@ -141,6 +141,7 @@ void main() {
             * `(5d6+5d10)-L2` -- roll 5d6 and 5d10, and from aggregate results drop the lowest 2.
             * `5d6+5d10-L2` -- roll 5d6 and 5d10, and from only the 5d10 results drop the lowest 2. equivalent to
               `5d6+(5d10-L2)`
+            * `((1d6 + 1d8)-L)!` -- roll 1d6 and 1d8, drop the lowest result, and explode the remaining die
     * `*` for multiplication
     * `-` for subtraction
     * numbers must be integers
@@ -168,9 +169,7 @@ final roll = diceExpr_SecureRNG.roll();
 
 //....
 // when dice expr changes, update the stats graph. 
-final stats = await
-diceExpr_FastRNG.stats
-();
+final stats = await diceExpr_FastRNG.stats();
 // output of stats: {mean: 6.98, stddev: 2.41, min: 2, max: 12, count: 10000, histogram: {2: 310, 3: 557, 4: 787, 5: 1090, 6: 1450, 7: 1646, 8: 1395, 9: 1147, 10: 825, 11: 526, 12: 267}}
 
 ```

lib/src/ast.dart

@@ -181,26 +181,23 @@ class CountOp extends Binary {
       }
     }
 
-    final filteredResults = lhs.results.notDiscarded.where(test);
+    final filteredResults = lhs.results.where(test);
 
     if (countType == CountType.count) {
       // if counting, the count becomes the new result
 
       return RollResult(
         expression: toString(),
         opType: OpType.count,
-        results: [
-          RolledDie.singleVal(result: filteredResults.length),
-          ...lhs.results.notDiscarded.map(RolledDie.discard),
-          ...lhs.results.discarded,
-        ],
+        results: [RolledDie.singleVal(result: filteredResults.length)],
+        discarded: [...lhs.results.map(RolledDie.discard), ...lhs.discarded],
         left: lhs,
         right: rhs,
       );
     } else {
       // if counting success/failures, the results are updated w/ scoring
 
-      final otherResults = lhs.results.notDiscarded.whereNot(test);
+      final nonScoredResults = lhs.results.whereNot(test);
 
       return RollResult(
         expression: toString(),
@@ -209,9 +206,9 @@ class CountOp extends Binary {
           ...filteredResults.map(
             (v) => RolledDie.scoreForCountType(v, countType: countType),
           ),
-          ...otherResults,
-          ...lhs.results.discarded,
+          ...nonScoredResults,
         ],
+        discarded: lhs.discarded,
         left: lhs,
         right: rhs,
       );
@@ -238,23 +235,22 @@ class DropOp extends Binary {
 
     final Iterable<RolledDie> results;
     final Iterable<RolledDie> dropped;
-    final notDiscarded = lhs.results.notDiscarded;
     switch (name) {
       case '-<': // drop <
-        results = notDiscarded.where((v) => v.result >= target);
-        dropped = notDiscarded.where((v) => v.result < target);
+        results = lhs.results.where((v) => v.result >= target);
+        dropped = lhs.results.where((v) => v.result < target);
       case '-<=': // drop <=
-        results = notDiscarded.where((v) => v.result > target);
-        dropped = notDiscarded.where((v) => v.result <= target);
+        results = lhs.results.where((v) => v.result > target);
+        dropped = lhs.results.where((v) => v.result <= target);
       case '->': // drop >
-        results = notDiscarded.where((v) => v.result <= target);
-        dropped = notDiscarded.where((v) => v.result > target);
+        results = lhs.results.where((v) => v.result <= target);
+        dropped = lhs.results.where((v) => v.result > target);
       case '->=': // drop >=
-        results = notDiscarded.where((v) => v.result < target);
-        dropped = notDiscarded.where((v) => v.result >= target);
+        results = lhs.results.where((v) => v.result < target);
+        dropped = lhs.results.where((v) => v.result >= target);
       case '-=': // drop =
-        results = notDiscarded.where((v) => v.result != target);
-        dropped = notDiscarded.where((v) => v.result == target);
+        results = lhs.results.where((v) => v.result != target);
+        dropped = lhs.results.where((v) => v.result == target);
       default:
         throw FormatException(
           "unknown drop operation '$name'",
@@ -266,11 +262,8 @@ class DropOp extends Binary {
     return RollResult(
       expression: toString(),
       opType: OpType.drop,
-      results: [
-        ...results,
-        ...dropped.map(RolledDie.discard),
-        ...lhs.results.discarded,
-      ],
+      results: [...results],
+      discarded: [...dropped.map(RolledDie.discard), ...lhs.discarded],
       left: lhs,
       right: rhs,
     );
@@ -285,7 +278,7 @@ class DropHighLowOp extends Binary {
   RollResult eval() {
     final lhs = left();
     final rhs = right();
-    final sorted = lhs.results.notDiscarded.toList()..sort();
+    final sorted = lhs.results.toList()..sort();
     final numToDrop = rhs.totalOrDefault(() => 1); // if missing, assume '1'
     final Iterable<RolledDie> results;
     final Iterable<RolledDie> dropped;
@@ -315,11 +308,8 @@ class DropHighLowOp extends Binary {
     return RollResult(
       expression: toString(),
       opType: OpType.drop,
-      results: [
-        ...results,
-        ...dropped.map(RolledDie.discard),
-        ...lhs.results.discarded,
-      ],
+      results: [...results],
+      discarded: [...dropped.map(RolledDie.discard), ...lhs.discarded],
       left: lhs,
       right: rhs,
     );
@@ -343,7 +333,7 @@ class ClampOp extends Binary {
     });
 
     final newResults = <RolledDie>[];
-    for (final d in lhs.results.notDiscarded) {
+    for (final d in lhs.results) {
       if (name == 'c>' && d.result > target) {
         newResults.add(RolledDie.copyWith(d, result: target, clampHigh: true));
       } else if (name == 'c<' && d.result < target) {
@@ -355,7 +345,8 @@ class ClampOp extends Binary {
     return RollResult(
       expression: toString(),
       opType: OpType.clamp,
-      results: [...newResults, ...lhs.results.discarded],
+      results: newResults,
+      discarded: lhs.discarded,
       left: lhs,
       right: rhs,
     );
@@ -459,6 +450,7 @@ class D66Dice extends UnaryDice {
   RollResult eval() {
     final lhs = left();
     final ndice = lhs.totalOrDefault(() => 1);
+    // TODO: capture the rolls as discarded.
     final results = [
       for (var i = 0; i < ndice; i++)
         roller.roll(1, 6).total * 10 + roller.roll(1, 6).total,
@@ -563,7 +555,7 @@ class RerollDice extends BinaryDice {
     }
 
     final results = <RolledDie>[];
-    lhs.results.notDiscarded.forEachIndexed((i, v) {
+    lhs.results.forEachIndexed((i, v) {
       if (test(v)) {
         RolledDie rerolled;
         var rerollCount = 0;
@@ -584,7 +576,8 @@ class RerollDice extends BinaryDice {
     return RollResult(
       expression: toString(),
       opType: OpType.reroll,
-      results: [...results, ...lhs.results.discarded],
+      results: results,
+      discarded: lhs.discarded,
       left: lhs,
       right: rhs,
     );
@@ -638,7 +631,8 @@ class CompoundingDice extends BinaryDice {
     }
 
     final results = <RolledDie>[];
-    lhs.results.notDiscarded.forEachIndexed((i, v) {
+    final discarded = <RolledDie>[];
+    lhs.results.forEachIndexed((i, v) {
       if (test(v)) {
         var sum = v.result;
         RolledDie rerolled;
@@ -647,10 +641,13 @@ class CompoundingDice extends BinaryDice {
           rerolled = roller
               .roll(1, v.nsides, '(compound ind $i,  #$numCompounded)')
               .results[0];
+          discarded.add(
+            RolledDie.copyWith(rerolled, discarded: true, compounded: true),
+          );
           sum += rerolled.result;
           numCompounded++;
         } while (test(rerolled) && numCompounded < limit);
-        results.add(RolledDie.copyWith(v, result: sum, compounded: true));
+        results.add(RolledDie.copyWith(v, result: sum, compoundedFinal: true));
       } else {
         results.add(v);
       }
@@ -659,7 +656,8 @@ class CompoundingDice extends BinaryDice {
     return RollResult(
       expression: toString(),
       opType: OpType.compound,
-      results: [...results, ...lhs.results.discarded],
+      results: results,
+      discarded: lhs.discarded + discarded,
       left: lhs,
       right: rhs,
     );
@@ -713,27 +711,24 @@ class ExplodingDice extends BinaryDice {
     }
 
     final newResults = <RolledDie>[];
-    for (final rolledDie in lhs.results.notDiscarded.where(test)) {
+    for (final rolledDie in lhs.results.where(test)) {
+      newResults.add(RolledDie.copyWith(rolledDie, exploded: true));
       var numExplosions = 0;
       RolledDie rerolledDie;
       do {
         rerolledDie = roller
             .roll(1, rolledDie.nsides, '(explode #${numExplosions + 1})')
             .results[0];
         numExplosions++;
-        newResults.add(RolledDie.copyWith(rolledDie, exploded: true));
         newResults.add(RolledDie.copyWith(rerolledDie, explosion: true));
       } while (test(rerolledDie) && numExplosions < limit);
     }
 
     return RollResult(
       expression: toString(),
       opType: OpType.explode,
-      results: [
-        ...newResults,
-        ...lhs.results.notDiscarded.whereNot(test),
-        ...lhs.results.discarded,
-      ],
+      results: [...newResults, ...lhs.results.whereNot(test)],
+      discarded: lhs.discarded,
       left: lhs,
       right: rhs,
     );

lib/src/parser.dart

@@ -4,6 +4,8 @@ import 'ast.dart';
 import 'dice_expression.dart';
 import 'dice_roller.dart';
 
+// TODO: support commas `(<expr>,<expr>,<expr>)kh` -- evaluate each subexpression into a new die result, discarding the ones that had been combined
+
 Parser<DiceExpression> parserBuilder(DiceRoller roller) {
   final builder = ExpressionBuilder<DiceExpression>();
   // numbers