@swrpg-online/dice 1.3.0 → 1.4.1

package/dist/cli.js

@@ -22,6 +22,115 @@ 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",
+                    "ls",
+                    "lightside",
+                    "ds",
+                    "darkside",
+                    "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;
+                        case "ls":
+                        case "lightside":
+                            pool.automaticLightSide = (pool.automaticLightSide || 0) + value;
+                            break;
+                        case "ds":
+                        case "darkside":
+                            pool.automaticDarkSide = (pool.automaticDarkSide || 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 +246,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 +256,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);