Add Multiply modifier

src/modifiers/CriticalFailureModifier.js

@@ -21,7 +21,7 @@ class CriticalFailureModifier extends ComparisonModifier {
     super(comparePoint);
 
     // set the modifier's sort order
-    this.order = 9;
+    this.order = 10;
   }
 
   /* eslint-disable class-methods-use-this */

src/modifiers/CriticalSuccessModifier.js

@@ -21,7 +21,7 @@ class CriticalSuccessModifier extends ComparisonModifier {
     super(comparePoint);
 
     // set the modifier's sort order
-    this.order = 8;
+    this.order = 9;
   }
 
   /* eslint-disable class-methods-use-this */

src/modifiers/MultiplyModifier.js

@@ -0,0 +1,106 @@
+import { isNumeric } from '../utilities/math.js';
+import ComparisonModifier from './ComparisonModifier.js';
+
+const factorSymbol = Symbol('factor');
+
+class MultiplyModifier extends ComparisonModifier {
+  constructor(factor, comparePoint = null) {
+    super(comparePoint);
+
+    this.factor = factor;
+
+    // set the modifier's sort order
+    this.order = 8;
+  }
+
+  /**
+   * The multiplication factor.
+   *
+   * @return {Number}
+   */
+  get factor() {
+    return this[factorSymbol];
+  }
+
+  /**
+   * Set the multiplication factor.
+   *
+   * @param {number} value
+   */
+  set factor(value) {
+    if (!isNumeric(value)) {
+      throw new TypeError('factor must be a positive, non-zero number');
+    }
+    this[factorSymbol] = value;
+  }
+
+  /* eslint-disable class-methods-use-this */
+  /**
+   * The name of the modifier.
+   *
+   * @returns {string} 'max'
+   */
+  get name() {
+    return 'multiply';
+  }
+  /* eslint-enable class-methods-use-this */
+
+  /**
+   * The modifier's notation.
+   *
+   * @returns {string}
+   */
+  get notation() {
+    return `mul${this.factor}${super.notation}`;
+  }
+
+  /**
+   * Run the modifier on the results.
+   *
+   * @param {RollResults} results The results to run the modifier against
+   * @param {StandardDice|RollGroup} _context The object that the modifier is attached to
+   *
+   * @returns {RollResults} The modified results
+   */
+  run(results, _context) {
+    const { rolls } = results;
+
+    /* eslint-disable no-param-reassign */
+    rolls.forEach((roll) => {
+      // if there's no compare point, or the compare point matches then multiply the value
+      if (!this.comparePoint || this.isComparePoint(roll.value)) {
+        roll.modifiers.add('multiply');
+        roll.calculationValue *= this.factor;
+      }
+    });
+    /* eslint-enable */
+
+    return results;
+  }
+
+  /**
+   * Return an object for JSON serialising.
+   *
+   * This is called automatically when JSON encoding the object.
+   *
+   * @return {{
+   *  notation: string,
+   *  name: string,
+   *  type: string,
+   *  comparePoint: (ComparePoint|undefined),
+   *  factor: Number
+   * }}
+   */
+  toJSON() {
+    const { factor } = this;
+
+    return Object.assign(
+      super.toJSON(),
+      {
+        factor,
+      },
+    );
+  }
+}
+
+export default MultiplyModifier;

src/modifiers/SortingModifier.js

@@ -23,7 +23,7 @@ class SortingModifier extends Modifier {
     this.direction = direction;
 
     // set the modifier's sort order
-    this.order = 10;
+    this.order = 11;
   }
 
   /**

src/modifiers/index.js

@@ -7,6 +7,7 @@ import KeepModifier from './KeepModifier.js';
 import MaxModifier from './MaxModifier.js';
 import MinModifier from './MinModifier.js';
 import Modifier from './Modifier.js';
+import MultiplyModifier from './MultiplyModifier.js';
 import ReRollModifier from './ReRollModifier.js';
 import SortingModifier from './SortingModifier.js';
 import TargetModifier from './TargetModifier.js';
@@ -21,6 +22,7 @@ export {
   MaxModifier,
   MinModifier,
   Modifier,
+  MultiplyModifier,
   ReRollModifier,
   SortingModifier,
   TargetModifier,

src/modifiers/modifier-flags.js

@@ -8,11 +8,12 @@ const flags = {
   drop: 'd',
   max: 'v',
   min: '^',
+  multiply: '*',
   penetrate: 'p',
   're-roll': 'r',
   're-roll-once': 'ro',
-  'target-failure': '_',
-  'target-success': '*',
+  'target-failure': '-',
+  'target-success': '+',
 };
 
 /**

src/parser/grammars/grammar.pegjs

@@ -59,6 +59,7 @@ Modifier
   / SortingModifier
   / MaxModifier
   / MinModifier
+  / MultiplyModifier
 
 // Explode, Penetrate, Compound modifier
 ExplodeModifier
@@ -96,6 +97,12 @@ MinModifier
     return new Modifiers.MinModifier(min);
   }
 
+// Multiply roll values
+MultiplyModifier
+  = "mul" factor:FloatNumber comparePoint:ComparePoint? {
+    return new Modifiers.MultiplyModifier(factor, comparePoint);
+  }
+
 // Re-rolling Dice (Including Re-roll Once)
 ReRollModifier
   = "r" once:"o"? comparePoint:ComparePoint? {

tests/DiceRoll.test.js

@@ -621,7 +621,7 @@ describe('DiceRoll', () => {
       const notation = '4d6>5f<=2';
       const diceRoller = new DiceRoll(notation);
 
-      expect(diceRoller.output).toEqual(`${notation}: [6*, 2_, 5, 8*] = 1`);
+      expect(diceRoller.output).toEqual(`${notation}: [6+, 2-, 5, 8+] = 1`);
 
       jest.restoreAllMocks();
     });
@@ -639,7 +639,7 @@ describe('DiceRoll', () => {
       const notation = '4d6>5f<=2+2d6';
       const diceRoller = new DiceRoll(notation);
 
-      expect(diceRoller.output).toEqual(`${notation}: [6*, 2_, 5, 8*]+[3, 5] = 9`);
+      expect(diceRoller.output).toEqual(`${notation}: [6+, 2-, 5, 8+]+[3, 5] = 9`);
 
       jest.restoreAllMocks();
     });

tests/modifiers/MaxModifier.test.js

@@ -24,7 +24,7 @@ describe('MaxModifier', () => {
       }));
     });
 
-    test('constructor requires max', () => {
+    test('constructor requires `max`', () => {
       expect(() => {
         new MaxModifier();
       }).toThrow(TypeError);