@swrpg-online/dice 0.5.0

package/dist/pools.d.ts

@@ -0,0 +1,32 @@
+import { DicePool } from './types';
+/**
+ * Creates a basic skill check dice pool
+ * @param ability Number of ability (green) dice
+ * @param proficiency Number of proficiency (yellow) dice
+ * @returns DicePool configured for a basic skill check
+ */
+export declare const createSkillCheck: (ability: number, proficiency: number) => 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
+ * @returns DicePool configured for a combat check
+ */
+export declare const createCombatCheck: (ability: number, proficiency: number, boost?: number) => 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
+ * @returns DicePool configured for an opposed check
+ */
+export declare const createOpposedCheck: (ability: number, proficiency: number, difficulty: number, challenge?: number) => DicePool;
+/**
+ * Creates a difficulty check dice pool
+ * @param difficulty Number of difficulty (purple) dice
+ * @param challenge Number of challenge (red) dice
+ * @returns DicePool configured for a pure difficulty check
+ */
+export declare const createDifficultyPool: (difficulty: number, challenge?: number) => DicePool;

package/dist/pools.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ * @returns DicePool configured for a basic skill check
+ */
+const createSkillCheck = (ability, proficiency) => ({
+    abilityDice: Math.max(0, ability),
+    proficiencyDice: Math.max(0, proficiency)
+});
+exports.createSkillCheck = createSkillCheck;
+/**
+ * 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
+ * @returns DicePool configured for a combat check
+ */
+const createCombatCheck = (ability, proficiency, boost = 0) => ({
+    abilityDice: Math.max(0, ability),
+    proficiencyDice: Math.max(0, proficiency),
+    boostDice: Math.max(0, boost)
+});
+exports.createCombatCheck = createCombatCheck;
+/**
+ * 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
+ * @returns DicePool configured for an opposed check
+ */
+const createOpposedCheck = (ability, proficiency, difficulty, challenge = 0) => ({
+    abilityDice: Math.max(0, ability),
+    proficiencyDice: Math.max(0, proficiency),
+    difficultyDice: Math.max(0, difficulty),
+    challengeDice: Math.max(0, challenge)
+});
+exports.createOpposedCheck = createOpposedCheck;
+/**
+ * Creates a difficulty check dice pool
+ * @param difficulty Number of difficulty (purple) dice
+ * @param challenge Number of challenge (red) dice
+ * @returns DicePool configured for a pure difficulty check
+ */
+const createDifficultyPool = (difficulty, challenge = 0) => ({
+    difficultyDice: Math.max(0, difficulty),
+    challengeDice: Math.max(0, challenge)
+});
+exports.createDifficultyPool = createDifficultyPool;

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export type DicePool = {
+    boostDice?: number;
+    abilityDice?: number;
+    proficiencyDice?: number;
+    setBackDice?: number;
+    difficultyDice?: number;
+    challengeDice?: number;
+};
+export type DiceResult = {
+    successes: number;
+    failures: number;
+    advantages: number;
+    threats: number;
+    triumphs: number;
+    despair: number;
+};
+export type DieType = 'boost' | 'ability' | 'proficiency' | 'setback' | 'difficulty' | 'challenge';
+export type DetailedDieResult = {
+    type: DieType;
+    roll: number;
+    result: DiceResult;
+};
+export type RollResult = {
+    results: DetailedDieResult[];
+    summary: DiceResult;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['**/tests/**/*.test.ts'],
+    collectCoverage: true,
+    collectCoverageFrom: ['src/**/*.ts']
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@swrpg-online/dice",
+  "version": "0.5.0",
+  "description": "A TypeScript library for simulating Star Wars RPG narrative dice rolls.",
+  "main": "jest.config.js",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "npx jest --verbose"
+  },
+  "keywords": [],
+  "author": "Chris Pan",
+  "license": "MIT",
+  "dependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2"
+  },
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/swrpg-online/dice"
+  }
+}

package/src/dice.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roll = void 0;
+var rollDie = function (sides) { return Math.floor(Math.random() * sides) + 1; };
+var boostDieResult = function (roll) {
+    switch (roll) {
+        case 3:
+            return { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+            return { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 5:
+            return { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 };
+        case 6:
+            return { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+var setBackDieResult = function (roll) {
+    switch (roll) {
+        case 3:
+        case 4:
+            return { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 5:
+        case 6:
+            return { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+var abilityDieResult = function (roll) {
+    switch (roll) {
+        case 2:
+        case 3:
+            return { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+            return { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 5:
+        case 6:
+            return { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 7:
+            return { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 8:
+            return { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+var difficultyDieResult = function (roll) {
+    switch (roll) {
+        case 2:
+            return { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 3:
+            return { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+        case 5:
+        case 6:
+            return { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        case 7:
+            return { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 };
+        case 8:
+            return { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+var proficiencyDieResult = function (roll) {
+    switch (roll) {
+        case 2:
+        case 3:
+            return { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+        case 5:
+            return { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 6:
+            return { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 7:
+        case 8:
+        case 9:
+            return { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 10:
+        case 11:
+            return { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 };
+        case 12:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 1, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+var challengeDieResult = function (roll) {
+    switch (roll) {
+        case 2:
+        case 3:
+            return { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+        case 5:
+            return { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 6:
+        case 7:
+            return { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        case 8:
+        case 9:
+            return { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        case 10:
+        case 11:
+            return { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 };
+        case 12:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 1 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+var sumResults = function (results) {
+    var sums = results.reduce(function (acc, curr) { return ({
+        successes: acc.successes + curr.successes,
+        failures: acc.failures + curr.failures,
+        advantages: acc.advantages + curr.advantages,
+        threats: acc.threats + curr.threats,
+        triumphs: acc.triumphs + curr.triumphs,
+        despair: acc.despair + curr.despair
+    }); }, {
+        successes: 0,
+        failures: 0,
+        advantages: 0,
+        threats: 0,
+        triumphs: 0,
+        despair: 0
+    });
+    // Calculate net successes/failures
+    var netSuccesses = 0;
+    var netFailures = 0;
+    if (sums.successes === sums.failures) {
+        netSuccesses = 0;
+        netFailures = 0;
+    }
+    else if (sums.successes > sums.failures) {
+        netSuccesses = sums.successes - sums.failures;
+    }
+    else {
+        netFailures = sums.failures - sums.successes;
+    }
+    return {
+        successes: netSuccesses,
+        failures: netFailures,
+        advantages: sums.advantages,
+        threats: sums.threats,
+        triumphs: sums.triumphs,
+        despair: sums.despair
+    };
+};
+var roll = function (pool) {
+    var _a, _b, _c, _d, _e, _f;
+    // Initialize all dice counts to 0 if undefined
+    var boostCount = (_a = pool.boostDice) !== null && _a !== void 0 ? _a : 0;
+    var abilityCount = (_b = pool.abilityDice) !== null && _b !== void 0 ? _b : 0;
+    var proficiencyCount = (_c = pool.proficiencyDice) !== null && _c !== void 0 ? _c : 0;
+    var setBackCount = (_d = pool.setBackDice) !== null && _d !== void 0 ? _d : 0;
+    var difficultyCount = (_e = pool.difficultyDice) !== null && _e !== void 0 ? _e : 0;
+    var challengeCount = (_f = pool.challengeDice) !== null && _f !== void 0 ? _f : 0;
+    // Ensure all dice counts are non-negative
+    var sanitizedPool = {
+        boostDice: Math.max(0, boostCount),
+        abilityDice: Math.max(0, abilityCount),
+        proficiencyDice: Math.max(0, proficiencyCount),
+        setBackDice: Math.max(0, setBackCount),
+        difficultyDice: Math.max(0, difficultyCount),
+        challengeDice: Math.max(0, challengeCount)
+    };
+    var detailedResults = [];
+    // Roll boost dice
+    for (var i = 0; i < sanitizedPool.boostDice; i++) {
+        var roll_1 = rollDie(6);
+        detailedResults.push({
+            type: 'boost',
+            roll: roll_1,
+            result: boostDieResult(roll_1)
+        });
+    }
+    // Roll ability dice
+    for (var i = 0; i < sanitizedPool.abilityDice; i++) {
+        var roll_2 = rollDie(8);
+        detailedResults.push({
+            type: 'ability',
+            roll: roll_2,
+            result: abilityDieResult(roll_2)
+        });
+    }
+    // Roll proficiency dice
+    for (var i = 0; i < sanitizedPool.proficiencyDice; i++) {
+        var roll_3 = rollDie(12);
+        detailedResults.push({
+            type: 'proficiency',
+            roll: roll_3,
+            result: proficiencyDieResult(roll_3)
+        });
+    }
+    // Roll setback dice
+    for (var i = 0; i < sanitizedPool.setBackDice; i++) {
+        var roll_4 = rollDie(6);
+        detailedResults.push({
+            type: 'setback',
+            roll: roll_4,
+            result: setBackDieResult(roll_4)
+        });
+    }
+    // Roll difficulty dice
+    for (var i = 0; i < sanitizedPool.difficultyDice; i++) {
+        var roll_5 = rollDie(8);
+        detailedResults.push({
+            type: 'difficulty',
+            roll: roll_5,
+            result: difficultyDieResult(roll_5)
+        });
+    }
+    // Roll challenge dice
+    for (var i = 0; i < sanitizedPool.challengeDice; i++) {
+        var roll_6 = rollDie(12);
+        detailedResults.push({
+            type: 'challenge',
+            roll: roll_6,
+            result: challengeDieResult(roll_6)
+        });
+    }
+    return {
+        results: detailedResults,
+        summary: sumResults(detailedResults.map(function (r) { return r.result; }))
+    };
+};
+exports.roll = roll;

package/src/dice.ts

@@ -0,0 +1,244 @@
+import { DicePool, RollResult, DiceResult, DetailedDieResult } from './types';
+
+const rollDie = (sides: number): number => Math.floor(Math.random() * sides) + 1;
+
+const boostDieResult = (roll: number): DiceResult => {
+    switch (roll) {
+        case 3:
+            return { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+            return { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 5:
+            return { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 };
+        case 6:
+            return { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+
+const setBackDieResult = (roll: number): DiceResult => {
+    switch (roll) {
+        case 3:
+        case 4:
+            return { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 5:
+        case 6:
+            return { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+
+const abilityDieResult = (roll: number): DiceResult => {
+    switch (roll) {
+        case 2:
+        case 3:
+            return { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+            return { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 5:
+        case 6:
+            return { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 7:
+            return { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 8:
+            return { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+
+const difficultyDieResult = (roll: number): DiceResult => {
+    switch (roll) {
+        case 2:
+            return { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 3:
+            return { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+        case 5:
+        case 6:
+            return { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        case 7:
+            return { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 };
+        case 8:
+            return { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+
+const proficiencyDieResult = (roll: number): DiceResult => {
+    switch (roll) {
+        case 2:
+        case 3:
+            return { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+        case 5:
+            return { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 6:
+            return { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 7:
+        case 8:
+        case 9:
+            return { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 };
+        case 10:
+        case 11:
+            return { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 };
+        case 12:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 1, despair: 0 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+
+const challengeDieResult = (roll: number): DiceResult => {
+    switch (roll) {
+        case 2:
+        case 3:
+            return { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 4:
+        case 5:
+            return { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+        case 6:
+        case 7:
+            return { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        case 8:
+        case 9:
+            return { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 };
+        case 10:
+        case 11:
+            return { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 };
+        case 12:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 1 };
+        default:
+            return { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 };
+    }
+};
+
+const sumResults = (results: DiceResult[]): DiceResult => {
+    const sums = results.reduce((acc, curr) => ({
+        successes: acc.successes + curr.successes,
+        failures: acc.failures + curr.failures,
+        advantages: acc.advantages + curr.advantages,
+        threats: acc.threats + curr.threats,
+        triumphs: acc.triumphs + curr.triumphs,
+        despair: acc.despair + curr.despair
+    }), {
+        successes: 0,
+        failures: 0,
+        advantages: 0,
+        threats: 0,
+        triumphs: 0,
+        despair: 0
+    });
+
+    // Calculate net successes/failures
+    let netSuccesses = 0;
+    let netFailures = 0;
+
+    if (sums.successes === sums.failures) {
+        netSuccesses = 0;
+        netFailures = 0;
+    } else if (sums.successes > sums.failures) {
+        netSuccesses = sums.successes - sums.failures;
+    } else {
+        netFailures = sums.failures - sums.successes;
+    }
+
+    return {
+        successes: netSuccesses,
+        failures: netFailures,
+        advantages: sums.advantages,
+        threats: sums.threats,
+        triumphs: sums.triumphs,
+        despair: sums.despair
+    };
+};
+
+export const roll = (pool: DicePool): RollResult => {
+    // Initialize all dice counts to 0 if undefined
+    const boostCount = pool.boostDice ?? 0;
+    const abilityCount = pool.abilityDice ?? 0;
+    const proficiencyCount = pool.proficiencyDice ?? 0;
+    const setBackCount = pool.setBackDice ?? 0;
+    const difficultyCount = pool.difficultyDice ?? 0;
+    const challengeCount = pool.challengeDice ?? 0;
+
+    // Ensure all dice counts are non-negative
+    const sanitizedPool = {
+        boostDice: Math.max(0, boostCount),
+        abilityDice: Math.max(0, abilityCount),
+        proficiencyDice: Math.max(0, proficiencyCount),
+        setBackDice: Math.max(0, setBackCount),
+        difficultyDice: Math.max(0, difficultyCount),
+        challengeDice: Math.max(0, challengeCount)
+    };
+    
+    const detailedResults: DetailedDieResult[] = [];
+
+    // Roll boost dice
+    for (let i = 0; i < sanitizedPool.boostDice; i++) {
+        const roll = rollDie(6);
+        detailedResults.push({
+            type: 'boost',
+            roll,
+            result: boostDieResult(roll)
+        });
+    }
+
+    // Roll ability dice
+    for (let i = 0; i < sanitizedPool.abilityDice; i++) {
+        const roll = rollDie(8);
+        detailedResults.push({
+            type: 'ability',
+            roll,
+            result: abilityDieResult(roll)
+        });
+    }
+
+    // Roll proficiency dice
+    for (let i = 0; i < sanitizedPool.proficiencyDice; i++) {
+        const roll = rollDie(12);
+        detailedResults.push({
+            type: 'proficiency',
+            roll,
+            result: proficiencyDieResult(roll)
+        });
+    }
+
+    // Roll setback dice
+    for (let i = 0; i < sanitizedPool.setBackDice; i++) {
+        const roll = rollDie(6);
+        detailedResults.push({
+            type: 'setback',
+            roll,
+            result: setBackDieResult(roll)
+        });
+    }
+
+    // Roll difficulty dice
+    for (let i = 0; i < sanitizedPool.difficultyDice; i++) {
+        const roll = rollDie(8);
+        detailedResults.push({
+            type: 'difficulty',
+            roll,
+            result: difficultyDieResult(roll)
+        });
+    }
+
+    // Roll challenge dice
+    for (let i = 0; i < sanitizedPool.challengeDice; i++) {
+        const roll = rollDie(12);
+        detailedResults.push({
+            type: 'challenge',
+            roll,
+            result: challengeDieResult(roll)
+        });
+    }
+
+    return {
+        results: detailedResults,
+        summary: sumResults(detailedResults.map(r => r.result))
+    };
+};

package/src/index.ts

@@ -0,0 +1,8 @@
+export { roll } from './dice';
+export type { DicePool, RollResult } from './types';
+export {
+    createSkillCheck,
+    createCombatCheck,
+    createOpposedCheck,
+    createDifficultyPool
+} from './pools';

package/src/pools.ts

@@ -0,0 +1,56 @@
+import { DicePool } from './types';
+
+/**
+ * Creates a basic skill check dice pool
+ * @param ability Number of ability (green) dice
+ * @param proficiency Number of proficiency (yellow) dice
+ * @returns DicePool configured for a basic skill check
+ */
+export const createSkillCheck = (ability: number, proficiency: number): DicePool => ({
+    abilityDice: Math.max(0, ability),
+    proficiencyDice: Math.max(0, proficiency)
+});
+
+/**
+ * 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
+ * @returns DicePool configured for a combat check
+ */
+export const createCombatCheck = (ability: number, proficiency: number, boost: number = 0): DicePool => ({
+    abilityDice: Math.max(0, ability),
+    proficiencyDice: Math.max(0, proficiency),
+    boostDice: Math.max(0, boost)
+});
+
+/**
+ * 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
+ * @returns DicePool configured for an opposed check
+ */
+export const createOpposedCheck = (
+    ability: number,
+    proficiency: number,
+    difficulty: number,
+    challenge: number = 0
+): DicePool => ({
+    abilityDice: Math.max(0, ability),
+    proficiencyDice: Math.max(0, proficiency),
+    difficultyDice: Math.max(0, difficulty),
+    challengeDice: Math.max(0, challenge)
+});
+
+/**
+ * Creates a difficulty check dice pool
+ * @param difficulty Number of difficulty (purple) dice
+ * @param challenge Number of challenge (red) dice
+ * @returns DicePool configured for a pure difficulty check
+ */
+export const createDifficultyPool = (difficulty: number, challenge: number = 0): DicePool => ({
+    difficultyDice: Math.max(0, difficulty),
+    challengeDice: Math.max(0, challenge)
+});