implement penetrating dice

Author: stevesea

CHANGELOG.md

@@ -14,6 +14,9 @@ whether it was counted as a success/failure.
 
 - upgrade to dart 3.8.0
 - upgrade to petitparser 7.0.0
+- implement penetrating dice ala Hackmaster
+  - `1d6p` -- roll d6, if 6 is rolled explode with d6s subtracting one each time.
+  - `1d100p20` -- roll a d100, if 100 is rolled penetrate with d20s
 - added dependency on fast_immutable_collections
 - remove metadata & score from RollResult
 - allow compounding, exploding, and rerolls for 'odd' die (`dF, D66, and d[vals]`)

README.md

@@ -54,6 +54,8 @@ void main() {
     * `1D66` -- roll `1` D66, aka `1d6*10 + 1d6`
         * **_NOTE_**: you _must_ use uppercase `D66`, lowercase `d66` will be interpreted as a 66-sided die
     * `2d[2,3,5,7]`-- roll 2 dice with values `[2,3,5,7]`
+    * `4d6p` -- penetrating dice. Similar to exploding, and -1 is added for each subsequent reroll.
+      * `1d20p6`, `1d100p20` -- HackMaster rules say a d20 penetrates with d6s, and a d100 penetrates with d20s
 
 * exploding dice
     * `4d6!` -- roll `4` `6`-sided dice, explode if max (`6`) is rolled (re-roll and include in results)
@@ -422,7 +424,7 @@ stdout.writeln('${rollResult.opType.name} -> $rollResult');
 
 // if you want to listen for the RollSummary
 DiceExpression.registerSummaryListener((rollSummary) {
-stdout.writeln('$rollSummary');
+stdout.writeln('$rollSummary');[README.md](README.md)
 });
 
 ```
@@ -431,11 +433,7 @@ Alternatively, you may not want to know _all_ roll events, and are only interest
 the events for your specific roll. In that case, pass an 'onRoll' method to the `roll()` method
 
 ```dart 
-  DiceExpression.create
-('2d20kh
-'
-)
-.roll(
+  DiceExpression.create('2d20kh').roll(
 onRoll: (rr) => stdout.writeln('roll - $rr'),
 onSummary: (summary) => stdout.writeln('summary - $
 summary

lib/src/ast_dice.dart

@@ -1,10 +1,13 @@
+import 'package:collection/collection.dart';
 import 'package:fast_immutable_collections/fast_immutable_collections.dart';
 import 'package:petitparser/parser.dart';
 
 import 'ast_core.dart';
+import 'ast_ops.dart';
 import 'dice_roller.dart';
 import 'enums.dart';
 import 'roll_result.dart';
+import 'rolled_die.dart';
 
 /// roll fudge dice
 class FudgeDice extends UnaryDice {
@@ -57,6 +60,87 @@ class CSVDice extends UnaryDice {
   }
 }
 
+class PenetratingDice extends UnaryDice {
+  PenetratingDice(
+    super.op,
+    super.left,
+    super.roller, {
+    required String nsides,
+    required String nsidesPenetration,
+  }) : nsides = int.parse(nsides),
+       nsidesPenetration = nsidesPenetration.isEmpty
+           ? int.parse(nsides)
+           : int.parse(nsidesPenetration);
+
+  final int nsides;
+  final int nsidesPenetration;
+  final limit = defaultRerollLimit;
+
+  @override
+  String toString() => '(${left}d${nsides}p$nsidesPenetration)';
+
+  @override
+  RollResult eval() {
+    final lhs = left();
+    final ndice = lhs.totalOrDefault(() => 1);
+
+    final roll = roller.roll(ndice, nsides);
+
+    final results = <RolledDie>[];
+    final discarded = <RolledDie>[];
+    roll.results.forEachIndexed((i, rolledDie) {
+      if (rolledDie.isMaxResult) {
+        var sum = rolledDie.result;
+        RolledDie rerolled;
+        var numPenetrated = 0;
+        discarded.add(
+          RolledDie.copyWith(rolledDie, discarded: true, penetrator: true),
+        );
+        do {
+          rerolled = roller
+              .roll(
+                1,
+                nsidesPenetration,
+                '(penetration ind $i, $numPenetrated)',
+              )
+              .results
+              .first;
+          discarded.add(
+            RolledDie.copyWith(rerolled, discarded: true, penetrator: true),
+          );
+          sum += rerolled.result;
+          numPenetrated++;
+        } while (rerolled.isMaxResult && numPenetrated < limit);
+        discarded.add(
+          RolledDie.singleVal(
+            result: -numPenetrated,
+            discarded: true,
+            penetrator: true,
+          ),
+        );
+        results.add(
+          RolledDie.copyWith(
+            rolledDie,
+            result: sum - numPenetrated,
+            penetrated: true,
+            from: discarded,
+          ),
+        );
+      } else {
+        results.add(rolledDie);
+      }
+    });
+
+    return RollResult(
+      expression: toString(),
+      opType: OpType.rollPenetration,
+      results: results,
+      discarded: lhs.discarded + discarded,
+      left: lhs,
+    );
+  }
+}
+
 /// roll n % dice
 class PercentDice extends UnaryDice {
   PercentDice(super.name, super.left, super.roller);

lib/src/ast_ops.dart

@@ -377,7 +377,7 @@ class CompoundingDice extends BinaryDice {
 
     bool shouldCompound(RolledDie rolledDie) {
       final val = rolledDie.result;
-      if (!rolledDie.dieType.compoundable) {
+      if (!rolledDie.dieType.explodable) {
         logger.finest('$rolledDie cannot compound due to dieType');
         return false;
       }
@@ -409,6 +409,7 @@ class CompoundingDice extends BinaryDice {
         var sum = v.result;
         RolledDie rerolled;
         var numCompounded = 0;
+        discarded.add(RolledDie.copyWith(v, discarded: true, compounded: true));
         do {
           rerolled = roller
               .reroll(v, '(compound ind $i,  #$numCompounded)')

lib/src/enums.dart

@@ -9,21 +9,17 @@ enum DieType implements Comparable<DieType> {
   // 1d[1,3,5,7,9]
   special(hasPotentialValues: true),
   // single value (e.g. a sum or count of dice)
-  singleVal(explodable: false, compoundable: false, hasPotentialValues: true);
+  singleVal(explodable: false, hasPotentialValues: true);
 
   const DieType({
     this.explodable = true,
-    this.compoundable = true,
     this.hasPotentialValues = false,
     this.hasNSides = true,
   });
 
   /// can the die be exploded?
   final bool explodable;
 
-  /// can the die be compounded?
-  final bool compoundable;
-
   /// whether the RolledDie must have non-empty potentialValues
   final bool hasPotentialValues;
 
@@ -47,6 +43,7 @@ enum OpType {
   rollPercent,
   rollD66,
   rollVals,
+  rollPenetration,
   reroll,
   compound,
   explode,

lib/src/parser.dart

@@ -40,13 +40,27 @@ Parser<DiceExpression> parserBuilder(DiceRoller roller) {
         char(']').trim(),
       ),
       (a, op) => CSVDice(op.toString(), a, roller, op.$3),
+    )
+    ..postfix(
+      seq4(
+        char('d').trim(),
+        digit().plus().flatten().trim(),
+        char('p').trim(),
+        digit().plus().optional().flatten().trim(),
+      ),
+      (a, op) => PenetratingDice(
+        op.toString(),
+        a,
+        roller,
+        nsides: op.$2,
+        nsidesPenetration: op.$4,
+      ),
     );
   builder.group().left(
     char('d').trim(),
     (a, op, b) => StdDice(op, a, b, roller),
   );
 
-  // TODO: !p penetrating dice
   // compounding dice (has to be in separate group from exploding)
   builder.group().left(
     (string('!!') &

lib/src/roll_summary.dart

@@ -85,7 +85,6 @@ class RollSummary extends Equatable {
     return buffer.toString();
   }
 
-  // TODO: implement fromJson?
   Map<String, dynamic> toJson() =>
       {
         'expression': expression,

lib/src/rolled_die.dart

@@ -22,6 +22,8 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
     this.explosion = false,
     this.compoundedFinal = false,
     this.compounded = false,
+    this.penetrated = false,
+    this.penetrator = false,
     this.reroll = false,
     this.rerolled = false,
     this.clampCeiling = false,
@@ -65,21 +67,23 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
 
   factory RolledDie.singleVal({
     required int result,
-    Iterable<RolledDie>? from,
+    bool discarded = false,
+    bool penetrator = false,
+    Iterable<RolledDie>? from = const IList.empty(),
   }) => RolledDie(
     result: result,
     nsides: 1,
+    discarded: discarded,
+    penetrator: penetrator,
     dieType: DieType.singleVal,
     potentialValues: [result],
-    from: IList.orNull(from) ?? const IList.empty(),
+    from: IList(from),
   );
 
-  factory RolledDie.d66({required int result, Iterable<RolledDie>? from}) =>
-      RolledDie(
-        result: result,
-        dieType: DieType.d66,
-        from: IList.orNull(from) ?? const IList.empty(),
-      );
+  factory RolledDie.d66({
+    required int result,
+    Iterable<RolledDie>? from = const IList.empty(),
+  }) => RolledDie(result: result, dieType: DieType.d66, from: IList(from));
 
   factory RolledDie.copyWith(
     RolledDie other, {
@@ -93,6 +97,8 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
     bool? explosion,
     bool? compounded,
     bool? compoundedFinal,
+    bool? penetrator,
+    bool? penetrated,
     bool? reroll,
     bool? rerolled,
     bool? clampHigh,
@@ -106,6 +112,8 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
     discarded: discarded ?? other.discarded,
     success: success ?? other.success,
     failure: failure ?? other.failure,
+    penetrated: penetrated ?? other.penetrated,
+    penetrator: penetrator ?? other.penetrator,
     critSuccess: critSuccess ?? other.critSuccess,
     critFailure: critFailure ?? other.critFailure,
     exploded: exploded ?? other.exploded,
@@ -182,6 +190,12 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
   /// true if the die is the sum a multiple die due to compounding
   final bool compoundedFinal;
 
+  /// true if the die was a discarded result during penetration
+  final bool penetrator;
+
+  /// true if the die was the result of penetration
+  final bool penetrated;
+
   /// true if the (discarded) result is from a reroll
   final bool rerolled;
 
@@ -194,6 +208,8 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
   /// true if the result has been clamped via `C<`
   final bool clampFloor;
 
+  bool get isMaxResult => result == maxPotentialValue;
+
   @override
   List<Object?> get props => [
     result,
@@ -215,6 +231,8 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
     rerolled,
     clampCeiling,
     clampFloor,
+    penetrated,
+    penetrator,
   ];
 
   Map<String, dynamic> toJson() =>
@@ -236,6 +254,8 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
         'rerolled': rerolled,
         'clampHigh': clampCeiling,
         'clampLow': clampFloor,
+        'penetrated': penetrated,
+        'penetrator': penetrator,
       }..removeWhere(
         (k, v) =>
             v == null ||
@@ -278,11 +298,17 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
     if (explosion) {
       buffer.write('🔥'); //'⇪');
     }
+    if (penetrated) {
+      buffer.write('➶');
+    }
+    if (penetrator) {
+      buffer.write('⥅');
+    }
     if (compoundedFinal) {
       buffer.write('∑');
     }
     if (compounded) {
-      buffer.write('+');
+      buffer.write('⥅');
     }
     if (clampCeiling) {
       buffer.write('⌈⌉');
@@ -316,14 +342,23 @@ class RolledDie extends Equatable implements Comparable<RolledDie> {
     return buffer.toString();
   }
 
-  //TODO: should this compare other fields too?
   @override
   int compareTo(RolledDie other) => result
       .compareTo(other.result)
       .if0(dieType.compareTo(other.dieType))
-      .if0(
-        dieType == DieType.polyhedral && other.dieType == DieType.polyhedral
-            ? nsides.compareTo(other.nsides)
-            : 0,
-      );
+      .if0(nsides.compareTo(other.nsides))
+      .if0(discarded.compareTo(other.discarded))
+      .if0(success.compareTo(other.success))
+      .if0(failure.compareTo(other.failure))
+      .if0(failure.compareTo(other.failure))
+      .if0(critSuccess.compareTo(other.critSuccess))
+      .if0(critFailure.compareTo(other.critFailure))
+      .if0(exploded.compareTo(other.exploded))
+      .if0(explosion.compareTo(other.explosion))
+      .if0(compoundedFinal.compareTo(other.compoundedFinal))
+      .if0(compounded.compareTo(other.compounded))
+      .if0(reroll.compareTo(other.reroll))
+      .if0(rerolled.compareTo(other.rerolled))
+      .if0(clampCeiling.compareTo(other.clampCeiling))
+      .if0(clampFloor.compareTo(other.clampFloor));
 }