volleyballsimtypes 0.0.359 → 0.0.360

package/dist/esm/src/service/utils/rng-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fisher-Yates shuffle algorithm
+ * Shuffles array IN-PLACE
+ * @param {any[]} array
+ */
+export declare function shuffle<Type>(array: Type[]): Type[];
+export declare function calculateProbability(score: number, scale: number, minP: number, maxP: number): number;
+export declare function createUniqueRandomPicker(min: number, max: number, rng?: () => number): {
+    next: () => number;
+    reset: () => void;
+};

package/dist/esm/src/service/utils/rng-utils.js

@@ -0,0 +1,55 @@
+import { clamp } from './number-utils';
+/**
+ * Fisher-Yates shuffle algorithm
+ * Shuffles array IN-PLACE
+ * @param {any[]} array
+ */
+export function shuffle(array) {
+    let m = array.length;
+    let t;
+    let i;
+    // While there remain elements to shuffle…
+    while (m > 0) {
+        // Pick a remaining element…
+        i = Math.floor(Math.random() * m--);
+        // And swap it with the current element.
+        t = array[m];
+        array[m] = array[i];
+        array[i] = t;
+    }
+    return array;
+}
+export function calculateProbability(score, scale, minP, maxP) {
+    const x = score / scale;
+    const sigmoid = 1 / (1 + Math.exp(-x));
+    const p = minP + (maxP - minP) * sigmoid;
+    return clamp(0, 1, p);
+}
+export function createUniqueRandomPicker(min, max, rng = Math.random) {
+    if (!Number.isInteger(min) || !Number.isInteger(max) || min > max) {
+        throw new Error('Invalid range');
+    }
+    let pool = [];
+    function refill() {
+        pool = [];
+        for (let i = min; i <= max; i++)
+            pool.push(i);
+        // Fisher–Yates shuffle
+        for (let i = pool.length - 1; i > 0; i--) {
+            const j = Math.floor(rng() * (i + 1));
+            [pool[i], pool[j]] = [pool[j], pool[i]];
+        }
+    }
+    refill();
+    return {
+        next() {
+            const aux = pool.pop();
+            if (aux == null)
+                return NaN;
+            return aux;
+        },
+        reset() {
+            refill();
+        }
+    };
+}

package/dist/esm/src/service/utils/rng-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/utils/rng-utils.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from '@jest/globals';
+import { shuffle, calculateProbability, createUniqueRandomPicker } from './rng-utils';
+// ─── shuffle ─────────────────────────────────────────────────────────────────
+describe('shuffle()', () => {
+    it('returns the same array reference (in-place)', () => {
+        const arr = [1, 2, 3, 4, 5];
+        expect(shuffle(arr)).toBe(arr);
+    });
+    it('preserves all elements', () => {
+        const original = [1, 2, 3, 4, 5];
+        const result = shuffle([...original]);
+        expect(result.sort((a, b) => a - b)).toEqual(original);
+    });
+    it('handles an empty array', () => {
+        expect(shuffle([])).toEqual([]);
+    });
+    it('handles a single-element array', () => {
+        expect(shuffle([42])).toEqual([42]);
+    });
+    it('works with string elements', () => {
+        const original = ['a', 'b', 'c', 'd'];
+        const result = shuffle([...original]);
+        expect(result.sort()).toEqual(original.sort());
+    });
+});
+// ─── calculateProbability ────────────────────────────────────────────────────
+describe('calculateProbability()', () => {
+    it('returns 0.5 when score is 0 over full [0, 1] range', () => {
+        expect(calculateProbability(0, 100, 0, 1)).toBeCloseTo(0.5, 5);
+    });
+    it('always returns a value within [0, 1]', () => {
+        for (const score of [-1000, -100, -10, 0, 10, 100, 1000]) {
+            const p = calculateProbability(score, 50, 0, 1);
+            expect(p).toBeGreaterThanOrEqual(0);
+            expect(p).toBeLessThanOrEqual(1);
+        }
+    });
+    it('clamps to maxP for very high scores', () => {
+        expect(calculateProbability(1e9, 1, 0.1, 0.9)).toBeCloseTo(0.9, 5);
+    });
+    it('clamps to minP for very negative scores', () => {
+        expect(calculateProbability(-1e9, 1, 0.1, 0.9)).toBeCloseTo(0.1, 5);
+    });
+    it('returns a higher probability for a higher score (monotone)', () => {
+        const p1 = calculateProbability(10, 100, 0, 1);
+        const p2 = calculateProbability(50, 100, 0, 1);
+        expect(p2).toBeGreaterThan(p1);
+    });
+});
+// ─── createUniqueRandomPicker ────────────────────────────────────────────────
+describe('createUniqueRandomPicker()', () => {
+    it('throws when min > max', () => {
+        expect(() => createUniqueRandomPicker(5, 3)).toThrow('Invalid range');
+    });
+    it('throws for non-integer min', () => {
+        expect(() => createUniqueRandomPicker(0.5, 3)).toThrow('Invalid range');
+    });
+    it('throws for non-integer max', () => {
+        expect(() => createUniqueRandomPicker(0, 2.5)).toThrow('Invalid range');
+    });
+    it('yields each number in [min, max] exactly once per cycle', () => {
+        const picker = createUniqueRandomPicker(1, 5);
+        const results = [];
+        for (let i = 0; i < 5; i++)
+            results.push(picker.next());
+        expect(results.sort((a, b) => a - b)).toEqual([1, 2, 3, 4, 5]);
+    });
+    it('returns NaN after exhausting the pool before reset', () => {
+        const picker = createUniqueRandomPicker(1, 2);
+        picker.next();
+        picker.next();
+        expect(picker.next()).toBeNaN();
+    });
+    it('replenishes the full pool after reset()', () => {
+        const picker = createUniqueRandomPicker(1, 3);
+        for (let i = 0; i < 3; i++)
+            picker.next();
+        picker.reset();
+        const results = [];
+        for (let i = 0; i < 3; i++)
+            results.push(picker.next());
+        expect(results.sort((a, b) => a - b)).toEqual([1, 2, 3]);
+    });
+    it('works for a single-value range', () => {
+        const picker = createUniqueRandomPicker(7, 7);
+        expect(picker.next()).toBe(7);
+        expect(picker.next()).toBeNaN();
+    });
+    it('accepts min === 0', () => {
+        const picker = createUniqueRandomPicker(0, 2);
+        const results = [picker.next(), picker.next(), picker.next()];
+        expect(results.sort((a, b) => a - b)).toEqual([0, 1, 2]);
+    });
+    it('uses a custom rng deterministically', () => {
+        // rng always returns 0 → j=0 in every Fisher-Yates step → pool reversed
+        const picker = createUniqueRandomPicker(0, 2, () => 0);
+        const results = [picker.next(), picker.next(), picker.next()];
+        expect(results.sort((a, b) => a - b)).toEqual([0, 1, 2]);
+    });
+});

package/dist/esm/src/stat-config/decline-profiles.json

@@ -0,0 +1,6 @@
+[
+    { "profile": "PRODIGY", "startAge": 27, "initTicks": 13.0, "accel": 1.00, "peakTicks": 16.0 },
+    { "profile": "STANDARD", "startAge": 29, "initTicks": 9.0, "accel": 1.75, "peakTicks": 16.0 },
+    { "profile": "VETERAN", "startAge": 32, "initTicks": 10.0, "accel": 1.50, "peakTicks": 16.0 },
+    { "profile": "IRONMAN", "startAge": 34, "initTicks": 10.0, "accel": 1.50, "peakTicks": 16.0 }
+]

package/dist/esm/src/stat-config/index.d.ts

@@ -0,0 +1,5 @@
+import rolesJSON from './roles.json';
+import traitsJSON from './traits.json';
+import statCapsJSON from './stat-caps.json';
+import declineProfilesJSON from './decline-profiles.json';
+export { rolesJSON, traitsJSON, statCapsJSON, declineProfilesJSON };

package/dist/esm/src/stat-config/index.js

@@ -0,0 +1,5 @@
+import rolesJSON from './roles.json';
+import traitsJSON from './traits.json';
+import statCapsJSON from './stat-caps.json';
+import declineProfilesJSON from './decline-profiles.json';
+export { rolesJSON, traitsJSON, statCapsJSON, declineProfilesJSON };

package/dist/esm/src/stat-config/roles.json

@@ -0,0 +1,117 @@
+[
+    {
+        "role": "SETTER",
+        "weight": {
+            "serve": 0.2,
+            "stamina": 0.05,
+            "setting": 0.7,
+            "block": 0.05,
+            "spike": 0,
+            "quick": 0,
+            "power": 0,
+            "backAttack": 0,
+            "awareness": 0,
+            "attack": 0,
+            "reception": 0,
+            "overhand": 0,
+            "bump": 0,
+            "read": 0,
+            "commit": 0,
+            "focus": 0,
+            "defense": 0,
+            "reflex": 0
+        }
+    },
+    {
+        "role": "LIBERO",
+        "weight": {
+            "spike": 0,
+            "quick": 0,
+            "power": 0,
+            "backAttack": 0,
+            "awareness": 0,
+            "attack": 0,
+            "serve": 0,
+            "stamina": 0.15,
+            "setting": 0.15,
+            "reception": 0.7,
+            "overhand": 0,
+            "bump": 0,
+            "block": 0,
+            "read": 0,
+            "commit": 0,
+            "focus": 0,
+            "defense": 0,
+            "reflex": 0
+        }
+    },
+    {
+        "role": "OUTSIDE_HITTER",
+        "weight": {
+            "spike": 0.3,
+            "quick": 0,
+            "power": 0,
+            "backAttack": 0.1,
+            "awareness": 0,
+            "attack": 0,
+            "serve": 0.1,
+            "stamina": 0.1,
+            "setting": 0,
+            "reception": 0.2,
+            "overhand": 0,
+            "bump": 0,
+            "block": 0.2,
+            "read": 0,
+            "commit": 0,
+            "focus": 0,
+            "defense": 0,
+            "reflex": 0
+        }
+    },
+    {
+        "role": "OPPOSITE_HITTER",
+        "weight": {
+            "spike": 0.6,
+            "quick": 0,
+            "power": 0,
+            "backAttack": 0.2,
+            "awareness": 0,
+            "attack": 0,
+            "serve": 0.15,
+            "stamina": 0.05,
+            "setting": 0,
+            "reception": 0,
+            "overhand": 0,
+            "bump": 0,
+            "block": 0,
+            "read": 0,
+            "commit": 0,
+            "focus": 0,
+            "defense": 0,
+            "reflex": 0
+        }
+    },
+    {
+        "role": "MIDDLE_BLOCKER",
+        "weight": {
+            "spike": 0.2,
+            "quick": 0,
+            "power": 0,
+            "backAttack": 0,
+            "awareness": 0,
+            "attack": 0,
+            "serve": 0,
+            "stamina": 0.1,
+            "setting": 0,
+            "reception": 0,
+            "overhand": 0,
+            "bump": 0,
+            "block": 0.7,
+            "read": 0,
+            "commit": 0,
+            "focus": 0,
+            "defense": 0,
+            "reflex": 0
+        }
+    }
+]

package/dist/esm/src/stat-config/stat-caps.json

@@ -0,0 +1,7 @@
+[
+    { "rarity": "COMMON", "cap": 59, "rarityMultiplier": 1.0 },
+    { "rarity": "RARE", "cap": 69, "rarityMultiplier": 1.15 },
+    { "rarity": "LEGENDARY", "cap": 79, "rarityMultiplier": 1.3 },
+    { "rarity": "MYTHIC", "cap": 89, "rarityMultiplier": 1.5 },
+    { "rarity": "SPECIAL", "cap": 99, "rarityMultiplier": 1.75 }
+]

package/dist/esm/src/stat-config/traits.json

@@ -0,0 +1,94 @@
+[
+    {
+        "name": "MASTER_MIND",
+        "modifier": 1.1,
+        "chance": 0.2,
+        "roles": [
+            "SETTER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "SURPRISE_ATTACK",
+        "modifier": 1.2,
+        "chance": 0.07,
+        "roles": [
+            "SETTER",
+            "OPPOSITE_HITTER"
+        ]
+    },
+    {
+        "name": "MOVING_WALL",
+        "modifier": 1.1,
+        "chance": 0.5,
+        "roles": [
+            "MIDDLE_BLOCKER",
+            "OPPOSITE_HITTER",
+            "SETTER"
+        ]
+    },
+    {
+        "name": "MARKSMAN",
+        "modifier": 1.05,
+        "chance": 0.5,
+        "roles": [
+            "SETTER",
+            "OPPOSITE_HITTER",
+            "OUTSIDE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "METEOR_SERVE",
+        "modifier": 1.2,
+        "chance": 0.5,
+        "roles": [
+            "SETTER",
+            "OPPOSITE_HITTER",
+            "OUTSIDE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "FLOAT_SERVE",
+        "modifier": 1.2,
+        "chance": 0.5,
+        "roles": [
+            "SETTER",
+            "OPPOSITE_HITTER",
+            "LIBERO",
+            "OUTSIDE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "VIGOROUS",
+        "modifier": 1,
+        "chance": 0.5,
+        "roles": [
+            "SETTER",
+            "OPPOSITE_HITTER",
+            "LIBERO",
+            "OUTSIDE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "GUARDIAN",
+        "chance": 0.2,
+        "modifier": 1.05,
+        "roles": [
+            "LIBERO",
+            "OUTSIDE_HITTER"
+        ]
+    },
+    {
+        "name": "DEFENSIVE_SPECIALIST",
+        "chance": 0.2,
+        "modifier": 1.2,
+        "roles": [
+            "LIBERO",
+            "OUTSIDE_HITTER"
+        ]
+    }
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.359",
+  "version": "0.0.360",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",