@swrpg-online/dice 1.3.0 → 1.4.0

package/dist/cli.js

@@ -22,6 +22,103 @@ function parseDiceNotation(input) {
         .split(" ")
         .filter((p) => p.length > 0);
     for (const part of parts) {
+        // Check for modifiers (start with + or -)
+        // Only treat as modifier if it has a known modifier suffix
+        if (part.startsWith("+") || (part.startsWith("-") && part.length > 2)) {
+            const isPositive = part.startsWith("+");
+            const modPart = part.slice(1);
+            const count = parseInt(modPart);
+            if (isNaN(count)) {
+                // If it starts with + but has no number, skip as invalid modifier
+                if (part.startsWith("+")) {
+                    warnings.push(`Invalid modifier notation: "${part}" - number not found`);
+                    continue;
+                }
+                // Otherwise treat as regular dice notation (for negative numbers)
+            }
+            else {
+                const modifier = modPart.slice(String(count).length).toLowerCase();
+                // Check if this is actually a modifier (has a known suffix)
+                const knownModifiers = [
+                    "s",
+                    "success",
+                    "f",
+                    "failure",
+                    "a",
+                    "advantage",
+                    "t",
+                    "threat",
+                    "tr",
+                    "triumph",
+                    "d",
+                    "despair",
+                    "ua",
+                    "upgradeability",
+                    "ud",
+                    "upgradedifficulty",
+                    "dp",
+                    "downgradeproficiency",
+                    "dc",
+                    "downgradechallenge",
+                ];
+                if (knownModifiers.includes(modifier)) {
+                    const value = isPositive ? count : -count;
+                    switch (modifier) {
+                        // Automatic symbols
+                        case "s":
+                        case "success":
+                            pool.automaticSuccesses = (pool.automaticSuccesses || 0) + value;
+                            break;
+                        case "f":
+                        case "failure":
+                            pool.automaticFailures = (pool.automaticFailures || 0) + value;
+                            break;
+                        case "a":
+                        case "advantage":
+                            pool.automaticAdvantages =
+                                (pool.automaticAdvantages || 0) + value;
+                            break;
+                        case "t":
+                        case "threat":
+                            pool.automaticThreats = (pool.automaticThreats || 0) + value;
+                            break;
+                        case "tr":
+                        case "triumph":
+                            pool.automaticTriumphs = (pool.automaticTriumphs || 0) + value;
+                            break;
+                        case "d":
+                        case "despair":
+                            pool.automaticDespairs = (pool.automaticDespairs || 0) + value;
+                            break;
+                        // Upgrades and downgrades
+                        case "ua":
+                        case "upgradeability":
+                            pool.upgradeAbility = (pool.upgradeAbility || 0) + value;
+                            break;
+                        case "ud":
+                        case "upgradedifficulty":
+                            pool.upgradeDifficulty = (pool.upgradeDifficulty || 0) + value;
+                            break;
+                        case "dp":
+                        case "downgradeproficiency":
+                            pool.downgradeProficiency =
+                                (pool.downgradeProficiency || 0) + value;
+                            break;
+                        case "dc":
+                        case "downgradechallenge":
+                            pool.downgradeChallenge = (pool.downgradeChallenge || 0) + value;
+                            break;
+                    }
+                    continue;
+                }
+                else if (part.startsWith("+")) {
+                    // If it starts with + but has unknown suffix, warn and skip
+                    warnings.push(`Invalid modifier type: "${modifier}" in "${part}"`);
+                    continue;
+                }
+                // If it starts with - and has no known modifier suffix, treat as negative dice count
+            }
+        }
         const count = parseInt(part);
         // Check if parseInt returned NaN
         if (isNaN(count)) {
@@ -137,7 +234,8 @@ const main = () => {
         : args.join(" ");
     if (!diceNotation.trim()) {
         console.log(`Usage: swrpg-dice <dice-notation> <dice-options>
-      Example: swrpg-dice 2y 1g 1p 1b 1sb --hints
+      Example: swrpg-dice 2y 1g 1p 1b 1sb +2s +1a --hints
+      
       Dice Options:
         - y/pro = Yellow / Proficiency
         - g/a = Green / Ability
@@ -146,6 +244,22 @@ const main = () => {
         - p/diff = Purple / Difficulty
         - blk/k/sb/s = Black / Setback
         - w/f = White/Force
+      
+      Modifiers (use + or - prefix):
+        Automatic Symbols:
+          - +Ns/success = Add N successes
+          - +Nf/failure = Add N failures
+          - +Na/advantage = Add N advantages
+          - +Nt/threat = Add N threats
+          - +Ntr/triumph = Add N triumphs
+          - +Nd/despair = Add N despairs
+        
+        Dice Upgrades/Downgrades:
+          - +Nua = Upgrade N ability dice to proficiency
+          - +Nud = Upgrade N difficulty dice to challenge
+          - +Ndp = Downgrade N proficiency dice to ability
+          - +Ndc = Downgrade N challenge dice to difficulty
+      
       Options:
         --hints  Show possible actions based on roll results`);
         process.exit(1);

package/dist/dice.js

@@ -487,7 +487,68 @@ const forceDieResult = (roll) => {
             };
     }
 };
-const sumResults = (results, options) => {
+/**
+ * Applies dice upgrades and downgrades to a pool.
+ * Upgrades are applied first, then downgrades.
+ *
+ * @param pool - The dice pool to modify
+ * @returns A new dice pool with upgrades/downgrades applied
+ */
+const applyDiceModifications = (pool) => {
+    const modifiedPool = { ...pool };
+    // Apply upgrades first (per game rules)
+    if (pool.upgradeAbility && pool.upgradeAbility > 0) {
+        let upgradesToApply = pool.upgradeAbility;
+        const currentAbility = modifiedPool.abilityDice || 0;
+        // Upgrade existing ability dice to proficiency
+        const upgradedDice = Math.min(currentAbility, upgradesToApply);
+        modifiedPool.abilityDice = currentAbility - upgradedDice;
+        modifiedPool.proficiencyDice =
+            (modifiedPool.proficiencyDice || 0) + upgradedDice;
+        upgradesToApply -= upgradedDice;
+        // Add remaining upgrades as new proficiency dice
+        if (upgradesToApply > 0) {
+            modifiedPool.proficiencyDice =
+                (modifiedPool.proficiencyDice || 0) + upgradesToApply;
+        }
+    }
+    if (pool.upgradeDifficulty && pool.upgradeDifficulty > 0) {
+        let upgradesToApply = pool.upgradeDifficulty;
+        const currentDifficulty = modifiedPool.difficultyDice || 0;
+        // Upgrade existing difficulty dice to challenge
+        const upgradedDice = Math.min(currentDifficulty, upgradesToApply);
+        modifiedPool.difficultyDice = currentDifficulty - upgradedDice;
+        modifiedPool.challengeDice =
+            (modifiedPool.challengeDice || 0) + upgradedDice;
+        upgradesToApply -= upgradedDice;
+        // Add remaining upgrades as new challenge dice
+        if (upgradesToApply > 0) {
+            modifiedPool.challengeDice =
+                (modifiedPool.challengeDice || 0) + upgradesToApply;
+        }
+    }
+    // Apply downgrades after upgrades
+    if (pool.downgradeProficiency && pool.downgradeProficiency > 0) {
+        const currentProficiency = modifiedPool.proficiencyDice || 0;
+        const downgradesToApply = Math.min(currentProficiency, pool.downgradeProficiency);
+        // Downgrade proficiency dice to ability dice
+        modifiedPool.proficiencyDice = currentProficiency - downgradesToApply;
+        modifiedPool.abilityDice =
+            (modifiedPool.abilityDice || 0) + downgradesToApply;
+        // Excess downgrades are ignored (per requirements)
+    }
+    if (pool.downgradeChallenge && pool.downgradeChallenge > 0) {
+        const currentChallenge = modifiedPool.challengeDice || 0;
+        const downgradesToApply = Math.min(currentChallenge, pool.downgradeChallenge);
+        // Downgrade challenge dice to difficulty dice
+        modifiedPool.challengeDice = currentChallenge - downgradesToApply;
+        modifiedPool.difficultyDice =
+            (modifiedPool.difficultyDice || 0) + downgradesToApply;
+        // Excess downgrades are ignored (per requirements)
+    }
+    return modifiedPool;
+};
+const sumResults = (results, automaticSymbols, options) => {
     const sums = results.reduce((acc, curr) => ({
         successes: acc.successes + curr.successes,
         failures: acc.failures + curr.failures,
@@ -498,12 +559,12 @@ const sumResults = (results, options) => {
         lightSide: acc.lightSide + (curr.lightSide || 0),
         darkSide: acc.darkSide + (curr.darkSide || 0),
     }), {
-        successes: 0,
-        failures: 0,
-        advantages: 0,
-        threats: 0,
-        triumphs: 0,
-        despair: 0,
+        successes: (automaticSymbols === null || automaticSymbols === void 0 ? void 0 : automaticSymbols.successes) || 0,
+        failures: (automaticSymbols === null || automaticSymbols === void 0 ? void 0 : automaticSymbols.failures) || 0,
+        advantages: (automaticSymbols === null || automaticSymbols === void 0 ? void 0 : automaticSymbols.advantages) || 0,
+        threats: (automaticSymbols === null || automaticSymbols === void 0 ? void 0 : automaticSymbols.threats) || 0,
+        triumphs: (automaticSymbols === null || automaticSymbols === void 0 ? void 0 : automaticSymbols.triumphs) || 0,
+        despair: (automaticSymbols === null || automaticSymbols === void 0 ? void 0 : automaticSymbols.despairs) || 0,
         lightSide: 0,
         darkSide: 0,
     });
@@ -519,11 +580,24 @@ const sumResults = (results, options) => {
     else {
         netFailures = sums.failures - sums.successes;
     }
+    // Advantages and threats cancel each other out
+    let netAdvantages = 0;
+    let netThreats = 0;
+    if (sums.advantages === sums.threats) {
+        netAdvantages = 0;
+        netThreats = 0;
+    }
+    else if (sums.advantages > sums.threats) {
+        netAdvantages = sums.advantages - sums.threats;
+    }
+    else {
+        netThreats = sums.threats - sums.advantages;
+    }
     const result = {
         successes: netSuccesses,
         failures: netFailures,
-        advantages: sums.advantages,
-        threats: sums.threats,
+        advantages: netAdvantages,
+        threats: netThreats,
         triumphs: sums.triumphs,
         despair: sums.despair,
         lightSide: sums.lightSide,
@@ -545,13 +619,15 @@ const sumResults = (results, options) => {
  */
 const roll = (pool, options) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const boostCount = (_a = pool.boostDice) !== null && _a !== void 0 ? _a : 0;
-    const abilityCount = (_b = pool.abilityDice) !== null && _b !== void 0 ? _b : 0;
-    const proficiencyCount = (_c = pool.proficiencyDice) !== null && _c !== void 0 ? _c : 0;
-    const setBackCount = (_d = pool.setBackDice) !== null && _d !== void 0 ? _d : 0;
-    const difficultyCount = (_e = pool.difficultyDice) !== null && _e !== void 0 ? _e : 0;
-    const challengeCount = (_f = pool.challengeDice) !== null && _f !== void 0 ? _f : 0;
-    const forceCount = (_g = pool.forceDice) !== null && _g !== void 0 ? _g : 0;
+    // Apply dice modifications (upgrades/downgrades)
+    const modifiedPool = applyDiceModifications(pool);
+    const boostCount = (_a = modifiedPool.boostDice) !== null && _a !== void 0 ? _a : 0;
+    const abilityCount = (_b = modifiedPool.abilityDice) !== null && _b !== void 0 ? _b : 0;
+    const proficiencyCount = (_c = modifiedPool.proficiencyDice) !== null && _c !== void 0 ? _c : 0;
+    const setBackCount = (_d = modifiedPool.setBackDice) !== null && _d !== void 0 ? _d : 0;
+    const difficultyCount = (_e = modifiedPool.difficultyDice) !== null && _e !== void 0 ? _e : 0;
+    const challengeCount = (_f = modifiedPool.challengeDice) !== null && _f !== void 0 ? _f : 0;
+    const forceCount = (_g = modifiedPool.forceDice) !== null && _g !== void 0 ? _g : 0;
     // Get limits from options or use defaults
     const maxDicePerType = (_h = options === null || options === void 0 ? void 0 : options.maxDicePerType) !== null && _h !== void 0 ? _h : exports.DEFAULT_MAX_DICE_PER_TYPE;
     const maxTotalDice = (_j = options === null || options === void 0 ? void 0 : options.maxTotalDice) !== null && _j !== void 0 ? _j : exports.DEFAULT_MAX_TOTAL_DICE;
@@ -670,7 +746,15 @@ const roll = (pool, options) => {
             result: forceDieResult(roll),
         });
     }
-    const summary = sumResults(detailedResults.map((r) => r.result));
+    const automaticSymbols = {
+        successes: pool.automaticSuccesses,
+        failures: pool.automaticFailures,
+        advantages: pool.automaticAdvantages,
+        threats: pool.automaticThreats,
+        triumphs: pool.automaticTriumphs,
+        despairs: pool.automaticDespairs,
+    };
+    const summary = sumResults(detailedResults.map((r) => r.result), automaticSymbols, options);
     if (options === null || options === void 0 ? void 0 : options.hints) {
         const applicableHints = hints_1.hints.filter((hint) => {
             const { cost } = hint;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { roll } from "./dice";
-export type { DicePool, RollResult } from "./types";
-export { createSkillCheck, createCombatCheck, createOpposedCheck, createDifficultyPool, } from "./pools";
+export type { DicePool, RollResult, DiceResult, RollOptions } from "./types";
+export { createSkillCheck, createCombatCheck, createOpposedCheck, createDifficultyPool, applyTalentModifiers, } from "./pools";
+export type { PoolModifiers } from "./pools";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDifficultyPool = exports.createOpposedCheck = exports.createCombatCheck = exports.createSkillCheck = exports.roll = void 0;
+exports.applyTalentModifiers = exports.createDifficultyPool = exports.createOpposedCheck = exports.createCombatCheck = exports.createSkillCheck = exports.roll = void 0;
 var dice_1 = require("./dice");
 Object.defineProperty(exports, "roll", { enumerable: true, get: function () { return dice_1.roll; } });
 var pools_1 = require("./pools");
@@ -8,3 +8,4 @@ Object.defineProperty(exports, "createSkillCheck", { enumerable: true, get: func
 Object.defineProperty(exports, "createCombatCheck", { enumerable: true, get: function () { return pools_1.createCombatCheck; } });
 Object.defineProperty(exports, "createOpposedCheck", { enumerable: true, get: function () { return pools_1.createOpposedCheck; } });
 Object.defineProperty(exports, "createDifficultyPool", { enumerable: true, get: function () { return pools_1.createDifficultyPool; } });
+Object.defineProperty(exports, "applyTalentModifiers", { enumerable: true, get: function () { return pools_1.applyTalentModifiers; } });

package/dist/pools.d.ts

@@ -1,32 +1,59 @@
 import { DicePool } from "./types";
+/**
+ * Options for applying talent or equipment modifiers to a dice pool
+ */
+export type PoolModifiers = {
+    automaticSuccesses?: number;
+    automaticFailures?: number;
+    automaticAdvantages?: number;
+    automaticThreats?: number;
+    automaticTriumphs?: number;
+    automaticDespairs?: number;
+    upgradeAbility?: number;
+    upgradeDifficulty?: number;
+    downgradeProficiency?: number;
+    downgradeChallenge?: number;
+};
 /**
  * Creates a basic skill check dice pool
  * @param ability Number of ability (green) dice
  * @param proficiency Number of proficiency (yellow) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for a basic skill check
  */
-export declare const createSkillCheck: (ability: number, proficiency: number) => DicePool;
+export declare const createSkillCheck: (ability: number, proficiency: number, modifiers?: PoolModifiers) => DicePool;
 /**
  * Creates a combat check dice pool with optional boost die
  * @param ability Number of ability (green) dice
  * @param proficiency Number of proficiency (yellow) dice
  * @param boost Number of boost (blue) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for a combat check
  */
-export declare const createCombatCheck: (ability: number, proficiency: number, boost?: number) => DicePool;
+export declare const createCombatCheck: (ability: number, proficiency: number, boost?: number, modifiers?: PoolModifiers) => DicePool;
 /**
  * Creates an opposed check dice pool
  * @param ability Number of ability (green) dice
  * @param proficiency Number of proficiency (yellow) dice
  * @param difficulty Number of difficulty (purple) dice
  * @param challenge Number of challenge (red) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for an opposed check
  */
-export declare const createOpposedCheck: (ability: number, proficiency: number, difficulty: number, challenge?: number) => DicePool;
+export declare const createOpposedCheck: (ability: number, proficiency: number, difficulty: number, challenge?: number, modifiers?: PoolModifiers) => DicePool;
 /**
  * Creates a difficulty check dice pool
  * @param difficulty Number of difficulty (purple) dice
  * @param challenge Number of challenge (red) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for a pure difficulty check
  */
-export declare const createDifficultyPool: (difficulty: number, challenge?: number) => DicePool;
+export declare const createDifficultyPool: (difficulty: number, challenge?: number, modifiers?: PoolModifiers) => DicePool;
+/**
+ * Applies talent modifiers to an existing dice pool
+ * Common use case for talents that add automatic advantages, successes, or upgrade dice
+ * @param pool The base dice pool
+ * @param modifiers The modifiers to apply
+ * @returns A new dice pool with modifiers applied
+ */
+export declare const applyTalentModifiers: (pool: DicePool, modifiers: PoolModifiers) => DicePool;

package/dist/pools.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDifficultyPool = exports.createOpposedCheck = exports.createCombatCheck = exports.createSkillCheck = void 0;
+exports.applyTalentModifiers = exports.createDifficultyPool = exports.createOpposedCheck = exports.createCombatCheck = exports.createSkillCheck = void 0;
 /**
  * Creates a basic skill check dice pool
  * @param ability Number of ability (green) dice
  * @param proficiency Number of proficiency (yellow) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for a basic skill check
  */
-const createSkillCheck = (ability, proficiency) => ({
+const createSkillCheck = (ability, proficiency, modifiers) => ({
     abilityDice: Math.max(0, ability),
     proficiencyDice: Math.max(0, proficiency),
+    ...modifiers,
 });
 exports.createSkillCheck = createSkillCheck;
 /**
@@ -17,12 +19,14 @@ exports.createSkillCheck = createSkillCheck;
  * @param ability Number of ability (green) dice
  * @param proficiency Number of proficiency (yellow) dice
  * @param boost Number of boost (blue) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for a combat check
  */
-const createCombatCheck = (ability, proficiency, boost = 0) => ({
+const createCombatCheck = (ability, proficiency, boost = 0, modifiers) => ({
     abilityDice: Math.max(0, ability),
     proficiencyDice: Math.max(0, proficiency),
     boostDice: Math.max(0, boost),
+    ...modifiers,
 });
 exports.createCombatCheck = createCombatCheck;
 /**
@@ -31,23 +35,48 @@ exports.createCombatCheck = createCombatCheck;
  * @param proficiency Number of proficiency (yellow) dice
  * @param difficulty Number of difficulty (purple) dice
  * @param challenge Number of challenge (red) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for an opposed check
  */
-const createOpposedCheck = (ability, proficiency, difficulty, challenge = 0) => ({
+const createOpposedCheck = (ability, proficiency, difficulty, challenge = 0, modifiers) => ({
     abilityDice: Math.max(0, ability),
     proficiencyDice: Math.max(0, proficiency),
     difficultyDice: Math.max(0, difficulty),
     challengeDice: Math.max(0, challenge),
+    ...modifiers,
 });
 exports.createOpposedCheck = createOpposedCheck;
 /**
  * Creates a difficulty check dice pool
  * @param difficulty Number of difficulty (purple) dice
  * @param challenge Number of challenge (red) dice
+ * @param modifiers Optional modifiers from talents, equipment, etc.
  * @returns DicePool configured for a pure difficulty check
  */
-const createDifficultyPool = (difficulty, challenge = 0) => ({
+const createDifficultyPool = (difficulty, challenge = 0, modifiers) => ({
     difficultyDice: Math.max(0, difficulty),
     challengeDice: Math.max(0, challenge),
+    ...modifiers,
 });
 exports.createDifficultyPool = createDifficultyPool;
+/**
+ * Applies talent modifiers to an existing dice pool
+ * Common use case for talents that add automatic advantages, successes, or upgrade dice
+ * @param pool The base dice pool
+ * @param modifiers The modifiers to apply
+ * @returns A new dice pool with modifiers applied
+ */
+const applyTalentModifiers = (pool, modifiers) => ({
+    ...pool,
+    automaticSuccesses: (pool.automaticSuccesses || 0) + (modifiers.automaticSuccesses || 0),
+    automaticFailures: (pool.automaticFailures || 0) + (modifiers.automaticFailures || 0),
+    automaticAdvantages: (pool.automaticAdvantages || 0) + (modifiers.automaticAdvantages || 0),
+    automaticThreats: (pool.automaticThreats || 0) + (modifiers.automaticThreats || 0),
+    automaticTriumphs: (pool.automaticTriumphs || 0) + (modifiers.automaticTriumphs || 0),
+    automaticDespairs: (pool.automaticDespairs || 0) + (modifiers.automaticDespairs || 0),
+    upgradeAbility: (pool.upgradeAbility || 0) + (modifiers.upgradeAbility || 0),
+    upgradeDifficulty: (pool.upgradeDifficulty || 0) + (modifiers.upgradeDifficulty || 0),
+    downgradeProficiency: (pool.downgradeProficiency || 0) + (modifiers.downgradeProficiency || 0),
+    downgradeChallenge: (pool.downgradeChallenge || 0) + (modifiers.downgradeChallenge || 0),
+});
+exports.applyTalentModifiers = applyTalentModifiers;

package/dist/types.d.ts

@@ -6,6 +6,16 @@ export type DicePool = {
     difficultyDice?: number;
     challengeDice?: number;
     forceDice?: number;
+    automaticSuccesses?: number;
+    automaticFailures?: number;
+    automaticAdvantages?: number;
+    automaticThreats?: number;
+    automaticTriumphs?: number;
+    automaticDespairs?: number;
+    upgradeAbility?: number;
+    upgradeDifficulty?: number;
+    downgradeProficiency?: number;
+    downgradeChallenge?: number;
 };
 export type DiceResult = {
     successes: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swrpg-online/dice",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "A TypeScript library that creates dice rolls using the narrative dice system for the Star Wars Roleplaying Game by Fantasy Flight Games and Edge Studio.",
   "keywords": [
     "swrpg",