@swrpg-online/dice 0.9.0 → 1.0.4

package/src/pools.ts

@@ -1,56 +0,0 @@
-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)
-});

package/src/types.ts

@@ -1,30 +0,0 @@
-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/tests/dice.test.ts

@@ -1,351 +0,0 @@
-import { roll } from '../src/dice';
-import { DicePool, RollResult } from '../src/types';
-
-// Mock Math.random for deterministic tests
-const mockMathRandom = (value: number) => {
-    const originalRandom = Math.random;
-    Math.random = jest.fn().mockReturnValue(value);
-    return () => {
-        Math.random = originalRandom;
-    };
-};
-
-describe('SWRPG Dice Rolling', () => {
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    describe('Detailed Roll Breakdown', () => {
-        test('returns detailed results for each die', () => {
-            const cleanup = mockMathRandom(0.5); // mid-range roll
-            const pool: DicePool = {
-                boostDice: 1,
-                abilityDice: 1
-            };
-            
-            const result = roll(pool);
-            
-            expect(result).toHaveProperty('results');
-            expect(result).toHaveProperty('summary');
-            expect(Array.isArray(result.results)).toBe(true);
-            expect(result.results).toHaveLength(2);
-            
-            // Check structure of detailed results
-            result.results.forEach(dieResult => {
-                expect(dieResult).toHaveProperty('type');
-                expect(dieResult).toHaveProperty('roll');
-                expect(dieResult).toHaveProperty('result');
-                expect(['boost', 'ability']).toContain(dieResult.type);
-                expect(typeof dieResult.roll).toBe('number');
-            });
-            
-            cleanup();
-        });
-        
-        test('properly identifies die types', () => {
-            const cleanup = mockMathRandom(0.5);
-            const pool: DicePool = {
-                boostDice: 1,
-                abilityDice: 1,
-                proficiencyDice: 1,
-                setBackDice: 1,
-                difficultyDice: 1,
-                challengeDice: 1
-            };
-            
-            const result = roll(pool);
-            const dieTypes = result.results.map(r => r.type);
-            
-            expect(dieTypes).toContain('boost');
-            expect(dieTypes).toContain('ability');
-            expect(dieTypes).toContain('proficiency');
-            expect(dieTypes).toContain('setback');
-            expect(dieTypes).toContain('difficulty');
-            expect(dieTypes).toContain('challenge');
-            
-            cleanup();
-        });
-    });
-
-    describe('Individual Die Results', () => {
-        describe('Boost Die (d6)', () => {
-            test.each([
-                [1, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [2, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [3, { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [4, { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [5, { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 }],
-                [6, { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }]
-            ])('face value %i should return correct results', (value, expected) => {
-                const cleanup = mockMathRandom((value - 1) / 6);
-                const pool: DicePool = { boostDice: 1 };
-                expect(roll(pool).summary).toEqual(expected);
-                cleanup();
-            });
-        });
-
-        describe('Ability Die (d8)', () => {
-            test.each([
-                [1, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [2, { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [3, { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [4, { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [5, { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [6, { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [7, { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [8, { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 }]
-            ])('face value %i should return correct results', (value, expected) => {
-                const cleanup = mockMathRandom((value - 1) / 8);
-                const pool: DicePool = { abilityDice: 1 };
-                expect(roll(pool).summary).toEqual(expected);
-                cleanup();
-            });
-        });
-
-        describe('Proficiency Die (d12)', () => {
-            test.each([
-                [1, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [2, { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [3, { successes: 1, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [4, { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [5, { successes: 2, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [6, { successes: 0, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [7, { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [8, { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [9, { successes: 1, failures: 0, advantages: 1, threats: 0, triumphs: 0, despair: 0 }],
-                [10, { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 }],
-                [11, { successes: 0, failures: 0, advantages: 2, threats: 0, triumphs: 0, despair: 0 }],
-                [12, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 1, despair: 0 }]
-            ])('face value %i should return correct results', (value, expected) => {
-                const cleanup = mockMathRandom((value - 1) / 12);
-                const pool: DicePool = { proficiencyDice: 1 };
-                expect(roll(pool).summary).toEqual(expected);
-                cleanup();
-            });
-        });
-
-        describe('Setback Die (d6)', () => {
-            test.each([
-                [1, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [2, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [3, { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [4, { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [5, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [6, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }]
-            ])('face value %i should return correct results', (value, expected) => {
-                const cleanup = mockMathRandom((value - 1) / 6);
-                const pool: DicePool = { setBackDice: 1 };
-                expect(roll(pool).summary).toEqual(expected);
-                cleanup();
-            });
-        });
-
-        describe('Difficulty Die (d8)', () => {
-            test.each([
-                [1, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [2, { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [3, { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [4, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [5, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [6, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [7, { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 }],
-                [8, { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 }]
-            ])('face value %i should return correct results', (value, expected) => {
-                const cleanup = mockMathRandom((value - 1) / 8);
-                const pool: DicePool = { difficultyDice: 1 };
-                expect(roll(pool).summary).toEqual(expected);
-                cleanup();
-            });
-        });
-
-        describe('Challenge Die (d12)', () => {
-            test.each([
-                [1, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [2, { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [3, { successes: 0, failures: 1, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [4, { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [5, { successes: 0, failures: 2, advantages: 0, threats: 0, triumphs: 0, despair: 0 }],
-                [6, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [7, { successes: 0, failures: 0, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [8, { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [9, { successes: 0, failures: 1, advantages: 0, threats: 1, triumphs: 0, despair: 0 }],
-                [10, { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 }],
-                [11, { successes: 0, failures: 0, advantages: 0, threats: 2, triumphs: 0, despair: 0 }],
-                [12, { successes: 0, failures: 0, advantages: 0, threats: 0, triumphs: 0, despair: 1 }]
-            ])('face value %i should return correct results', (value, expected) => {
-                const cleanup = mockMathRandom((value - 1) / 12);
-                const pool: DicePool = { challengeDice: 1 };
-                expect(roll(pool).summary).toEqual(expected);
-                cleanup();
-            });
-        });
-    });
-
-    describe('Edge Cases', () => {
-        test('negative numbers default to 0', () => {
-            const pool: DicePool = {
-                boostDice: -1,
-                abilityDice: -2,
-                proficiencyDice: -1,
-                setBackDice: -3,
-                difficultyDice: -2,
-                challengeDice: -1
-            };
-            const expected = {
-                successes: 0,
-                failures: 0,
-                advantages: 0,
-                threats: 0,
-                triumphs: 0,
-                despair: 0
-            };
-            expect(roll(pool).summary).toEqual(expected);
-        });
-
-        test('undefined values default to 0', () => {
-            const pool: DicePool = {
-                boostDice: undefined,
-                abilityDice: undefined,
-                proficiencyDice: undefined,
-                setBackDice: undefined,
-                difficultyDice: undefined,
-                challengeDice: undefined
-            };
-            const expected = {
-                successes: 0,
-                failures: 0,
-                advantages: 0,
-                threats: 0,
-                triumphs: 0,
-                despair: 0
-            };
-            expect(roll(pool).summary).toEqual(expected);
-        });
-
-        test('empty pool returns zero results', () => {
-            const pool: DicePool = {};
-            const expected = {
-                successes: 0,
-                failures: 0,
-                advantages: 0,
-                threats: 0,
-                triumphs: 0,
-                despair: 0
-            };
-            expect(roll(pool).summary).toEqual(expected);
-        });
-    });
-
-    describe('Result Accumulation', () => {
-        test('successes and failures cancel out', () => {
-            // Mock to generate one success and one failure
-            const cleanup1 = mockMathRandom(1/8); // ability die success (face value 2)
-            const cleanup2 = mockMathRandom(1/8); // difficulty die failure (face value 2)
-            
-            const pool: DicePool = {
-                abilityDice: 1,
-                difficultyDice: 1
-            };
-            
-            const result = roll(pool);
-            expect(result.summary.successes).toBe(0);
-            expect(result.summary.failures).toBe(0);
-            
-            cleanup1();
-            cleanup2();
-        });
-
-        test('advantages and threats accumulate independently', () => {
-            // Mock to generate advantages and threats
-            const cleanup1 = mockMathRandom(4/6); // boost die success + advantage
-            const cleanup2 = mockMathRandom(6/8); // difficulty die threat
-            
-            const pool: DicePool = {
-                boostDice: 1,
-                difficultyDice: 1
-            };
-            
-            const result = roll(pool);
-            expect(result.summary.advantages).toBeGreaterThan(0);
-            expect(result.summary.threats).toBeGreaterThan(0);
-            
-            cleanup1();
-            cleanup2();
-        });
-
-        test('triumphs and despair count independently', () => {
-            // Mock to generate one triumph and one despair
-            const cleanup1 = mockMathRandom(11/12); // proficiency die triumph
-            const cleanup2 = mockMathRandom(11/12); // challenge die despair
-            
-            const pool: DicePool = {
-                proficiencyDice: 1,
-                challengeDice: 1
-            };
-            
-            const result = roll(pool);
-            expect(result.summary.triumphs).toBe(1);
-            expect(result.summary.despair).toBe(1);
-            
-            cleanup1();
-            cleanup2();
-        });
-    });
-
-    describe('Complex Combinations', () => {
-        test('realistic skill check - standard difficulty', () => {
-            const pool: DicePool = {
-                abilityDice: 2,
-                proficiencyDice: 1,
-                difficultyDice: 2
-            };
-            
-            const result = roll(pool);
-            
-            // Verify result structure
-            expect(result.summary).toHaveProperty('successes');
-            expect(result.summary).toHaveProperty('failures');
-            expect(result.summary).toHaveProperty('advantages');
-            expect(result.summary).toHaveProperty('threats');
-            expect(result.summary).toHaveProperty('triumphs');
-            expect(result.summary).toHaveProperty('despair');
-            
-            // Verify ranges
-            expect(result.summary.successes).toBeGreaterThanOrEqual(0);
-            expect(result.summary.failures).toBeGreaterThanOrEqual(0);
-            expect(result.summary.advantages).toBeGreaterThanOrEqual(0);
-            expect(result.summary.threats).toBeGreaterThanOrEqual(0);
-            expect(result.summary.triumphs).toBeGreaterThanOrEqual(0);
-            expect(result.summary.despair).toBeGreaterThanOrEqual(0);
-        });
-
-        test('opposed check - combat scenario', () => {
-            const pool: DicePool = {
-                abilityDice: 1,
-                proficiencyDice: 1,
-                boostDice: 1,
-                difficultyDice: 1,
-                challengeDice: 1,
-                setBackDice: 1
-            };
-            
-            const result = roll(pool);
-            
-            // Verify ranges
-            expect(result.summary.successes).toBeGreaterThanOrEqual(0);
-            expect(result.summary.failures).toBeGreaterThanOrEqual(0);
-            expect(result.summary.advantages).toBeGreaterThanOrEqual(0);
-            expect(result.summary.threats).toBeGreaterThanOrEqual(0);
-            expect(result.summary.triumphs).toBeGreaterThanOrEqual(0);
-            expect(result.summary.despair).toBeGreaterThanOrEqual(0);
-            
-            // Check detailed results
-            expect(result.results).toHaveLength(6); // One result per die
-            result.results.forEach(dieResult => {
-                expect(dieResult).toHaveProperty('type');
-                expect(dieResult).toHaveProperty('roll');
-                expect(dieResult).toHaveProperty('result');
-            });
-        });
-    });
-});

package/tests/pools.test.ts

@@ -1,86 +0,0 @@
-import {
-    createSkillCheck,
-    createCombatCheck,
-    createOpposedCheck,
-    createDifficultyPool
-} from '../src/pools';
-
-describe('Dice Pool Convenience Methods', () => {
-    describe('createSkillCheck', () => {
-        test('creates basic skill check pool', () => {
-            const pool = createSkillCheck(2, 1);
-            expect(pool).toEqual({
-                abilityDice: 2,
-                proficiencyDice: 1
-            });
-        });
-
-        test('creates pool with zero dice', () => {
-            const pool = createSkillCheck(0, 0);
-            expect(pool).toEqual({
-                abilityDice: 0,
-                proficiencyDice: 0
-            });
-        });
-    });
-
-    describe('createCombatCheck', () => {
-        test('creates combat check pool with boost', () => {
-            const pool = createCombatCheck(2, 1, 1);
-            expect(pool).toEqual({
-                abilityDice: 2,
-                proficiencyDice: 1,
-                boostDice: 1
-            });
-        });
-
-        test('creates combat check pool without boost', () => {
-            const pool = createCombatCheck(2, 1);
-            expect(pool).toEqual({
-                abilityDice: 2,
-                proficiencyDice: 1,
-                boostDice: 0
-            });
-        });
-    });
-
-    describe('createOpposedCheck', () => {
-        test('creates opposed check pool with challenge', () => {
-            const pool = createOpposedCheck(2, 1, 2, 1);
-            expect(pool).toEqual({
-                abilityDice: 2,
-                proficiencyDice: 1,
-                difficultyDice: 2,
-                challengeDice: 1
-            });
-        });
-
-        test('creates opposed check pool without challenge', () => {
-            const pool = createOpposedCheck(2, 1, 2);
-            expect(pool).toEqual({
-                abilityDice: 2,
-                proficiencyDice: 1,
-                difficultyDice: 2,
-                challengeDice: 0
-            });
-        });
-    });
-
-    describe('createDifficultyPool', () => {
-        test('creates difficulty pool with challenge', () => {
-            const pool = createDifficultyPool(2, 1);
-            expect(pool).toEqual({
-                difficultyDice: 2,
-                challengeDice: 1
-            });
-        });
-
-        test('creates difficulty pool without challenge', () => {
-            const pool = createDifficultyPool(2);
-            expect(pool).toEqual({
-                difficultyDice: 2,
-                challengeDice: 0
-            });
-        });
-    });
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es2018",
-        "module": "commonjs",
-        "declaration": true,
-        "outDir": "./dist",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true
-    },
-    "include": ["src/**/*"],
-    "exclude": ["node_modules", "**/*.test.ts"]
-}