@swrpg-online/dice 0.9.0 → 1.0.4

package/README.md

@@ -1,31 +1,40 @@
-# swrpg-dice
+# dice
 
-A TypeScript library for simulating Star Wars RPG narrative dice rolls.
+![npm version](https://img.shields.io/npm/v/@swrpg-online/dice)
+![build](https://github.com/swrpg-online/dice/actions/workflows/release.yml/badge.svg)
+[![codecov](https://codecov.io/gh/swrpg-online/dice/graph/badge.svg?token=BQIFNBWKI8)](https://codecov.io/gh/swrpg-online/dice)
+[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
+
+A TypeScript library that creates dice rolls using the [narrative dice system](https://star-wars-rpg-ffg.fandom.com/wiki/Narrative_Dice) for the Star Wars Role-Playing Game by [Fantasy Flight Games](https://www.fantasyflightgames.com/en/starwarsrpg/) and [Edge Studio](https://www.edge-studio.net/categories-games/starwarsrpg/).
 
 ## Installation
 
 ```bash
-npm install swrpg-dice
+npm i @swrpg-online/dice
 ```
 
+or optionally to use as a CLI command you can install globally with `npm i -g @swrpg-online/dice`
+
 ## Features
 
 - Complete narrative dice system implementation
 - Detailed roll breakdown for each die
 - Comprehensive test coverage
 - TypeScript type safety
+- roll from a CLI
 
 ## Usage
 
-Basic usage:
+via code:
 
 ```typescript
-import { roll, DicePool } from 'swrpg-dice';
+import { roll, DicePool } from '@swrpg-online/dice';
 
 const pool: DicePool = {
-  proficiencyDice: 2,
-  abilityDice: 1,
-  difficultyDice: 2
+    abilityDice: 2,
+    proficiencyDice: 1,
+    difficultyDice: 1,
+    challengeDice: 1
 };
 
 const result = roll(pool);
@@ -33,11 +42,97 @@ const result = roll(pool);
 // Access detailed results
 console.log(result.results);  // Array of individual die results
 console.log(result.summary);  // Summary of total successes, advantages, etc.
+
+=> {
+  "results": [
+    {
+      "type": "ability",
+      "roll": 5,
+      "result": {
+        "successes": 0,
+        "failures": 0,
+        "advantages": 1,
+        "threats": 0,
+        "triumphs": 0,
+        "despair": 0
+      }
+    },
+    {
+      "type": "ability",
+      "roll": 3,
+      "result": {
+        "successes": 1,
+        "failures": 0,
+        "advantages": 0,
+        "threats": 0,
+        "triumphs": 0,
+        "despair": 0
+      }
+    },
+    {
+      "type": "proficiency",
+      "roll": 10,
+      "result": {
+        "successes": 0,
+        "failures": 0,
+        "advantages": 2,
+        "threats": 0,
+        "triumphs": 0,
+        "despair": 0
+      }
+    },
+    {
+      "type": "difficulty",
+      "roll": 2,
+      "result": {
+        "successes": 0,
+        "failures": 1,
+        "advantages": 0,
+        "threats": 0,
+        "triumphs": 0,
+        "despair": 0
+      }
+    },
+    {
+      "type": "challenge",
+      "roll": 11,
+      "result": {
+        "successes": 0,
+        "failures": 0,
+        "advantages": 0,
+        "threats": 2,
+        "triumphs": 0,
+        "despair": 0
+      }
+    }
+  ],
+  "summary": {
+    "successes": 0,
+    "failures": 0,
+    "advantages": 3,
+    "threats": 2,
+    "triumphs": 0,
+    "despair": 0
+  }
+}
 ```
 
 Each roll result includes:
+
 - Detailed breakdown of each die roll
 - Die type identification
 - Individual results per die
 - Overall summary of the roll
 
+# Roadmap or Under Review
+
+- implement the Force die
+- implement ability to add success, failure, and so on to dice pools
+- ship combat?
+- crits?
+- polyhedral dice for convenience?
+- anything else?
+
+# Contribution
+
+This is a new library for a game with not a lot of open source tooling available - feedback and pull requests welcome!

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { DicePool } from "./types";
+export declare function parseDiceNotation(input: string): DicePool;
+export declare function formatResult(result: any): string;

package/dist/cli.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiceNotation = parseDiceNotation;
+exports.formatResult = formatResult;
+const dice_1 = require("./dice");
+// import * as path from 'path';
+function parseDiceNotation(input) {
+    const pool = {
+        boostDice: 0,
+        abilityDice: 0,
+        proficiencyDice: 0,
+        setBackDice: 0,
+        difficultyDice: 0,
+        challengeDice: 0,
+    };
+    // function getImagePath(type: string): string {
+    //     const basePath = path.join(__dirname, 'images');
+    //     switch (type) {
+    //       case 'successes':
+    //         return path.join(basePath, 'success.svg'); // Adjust path and extension as needed
+    //       case 'failures':
+    //         return path.join(basePath, 'failure.svg');
+    //       case 'advantages':
+    //         return path.join(basePath, 'advantage.svg');
+    //       case 'threats':
+    //         return path.join(basePath, 'threat.svg');
+    //       case 'triumphs':
+    //         return path.join(basePath, 'triumph.svg');
+    //       case 'despair':
+    //         return path.join(basePath, 'despair.svg');
+    //       default:
+    //         return '';
+    //     }
+    //   }
+    const parts = input.toLowerCase().trim().split(" ");
+    for (const part of parts) {
+        const count = parseInt(part);
+        const color = part.slice(String(count).length);
+        switch (color) {
+            // y/pro = Yellow/Proficiency
+            case "y":
+                pool.proficiencyDice = count;
+                break;
+            case "pro":
+                pool.proficiencyDice = count;
+                break;
+            // g/a = Green/Ability
+            case "g":
+                pool.abilityDice = count;
+                break;
+            case "a":
+                pool.abilityDice = count;
+                break;
+            // b/boo = Blue/Boost
+            case "b":
+                pool.setBackDice = count;
+                break;
+            case "boo":
+                pool.setBackDice = count;
+                break;
+            // r/c = Red/ Challenge
+            case "r":
+                pool.challengeDice = count;
+                break;
+            case "c":
+                pool.challengeDice = count;
+                break;
+            // p/diff = Purple/ Difficulty
+            case "p":
+                pool.difficultyDice = count;
+                break;
+            case "diff":
+                pool.difficultyDice = count;
+                break;
+            // blk/k/sb/s = Black/Setback
+            case "blk":
+                pool.setBackDice = count;
+                break;
+            case "k":
+                pool.setBackDice = count;
+                break;
+            case "sb":
+                pool.setBackDice = count;
+                break;
+            case "s":
+                pool.setBackDice = count;
+                break;
+            // w/f = White/Force
+            // TODO
+        }
+    }
+    return pool;
+}
+function formatResult(result) {
+    const parts = [];
+    if (result.summary.successes > 0)
+        parts.push(`${result.summary.successes} Success(es)`);
+    if (result.summary.failures > 0)
+        parts.push(`${result.summary.failures} Failure(s)`);
+    if (result.summary.advantages > 0)
+        parts.push(`${result.summary.advantages} Advantage(s)`);
+    if (result.summary.threats > 0)
+        parts.push(`${result.summary.threats} Threat(s)`);
+    if (result.summary.triumphs > 0)
+        parts.push(`${result.summary.triumphs} Triumph(s)`);
+    if (result.summary.despair > 0)
+        parts.push(`${result.summary.despair} Despair(s)`);
+    return parts.join(", ") || "No effects";
+}
+const main = () => {
+    const input = process.argv.slice(2).join(" ");
+    if (!input) {
+        console.log(`Usage: > swrpg-dice 2y 1g 2p 1r
+        - y/pro = Yellow / Proficiency
+        - g/a = Green / Ability
+        - b/boo = Blue / Boost
+        - r/c = Red / Challenge
+        - p/diff = Purple / Difficulty
+        - blk/k/sb/s = Black / Setback
+    `);
+        process.exit(1);
+    }
+    const pool = parseDiceNotation(input);
+    const result = (0, dice_1.roll)(pool);
+    console.log(formatResult(result));
+};
+if (require.main === module) {
+    main();
+}

package/dist/dice.d.ts

@@ -1,2 +1,2 @@
-import { DicePool, RollResult } from './types';
+import { DicePool, RollResult } from "./types";
 export declare const roll: (pool: DicePool) => RollResult;