volleyballsimtypes 0.0.359 → 0.0.361

package/dist/cjs/src/service/player/improvement.test.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const rarity_1 = require("./rarity");
+const improvement_1 = require("./improvement");
+const stats_1 = require("./stats");
+// ─── getStatCap ───────────────────────────────────────────────────────────────
+(0, globals_1.describe)('getStatCap()', () => {
+    globals_1.it.each([
+        [rarity_1.RarityEnum.COMMON, 59],
+        [rarity_1.RarityEnum.RARE, 69],
+        [rarity_1.RarityEnum.LEGENDARY, 79],
+        [rarity_1.RarityEnum.MYTHIC, 89],
+        [rarity_1.RarityEnum.SPECIAL, 99]
+    ])('%s → cap %i', (rarity, expected) => {
+        (0, globals_1.expect)((0, improvement_1.getStatCap)(rarity)).toBe(expected);
+    });
+    (0, globals_1.it)('throws UNKNOWN_RARITY for an unrecognised rarity string', () => {
+        (0, globals_1.expect)(() => (0, improvement_1.getStatCap)('DIVINE')).toThrow('UNKNOWN_RARITY');
+    });
+});
+// ─── getRarityMultiplier ──────────────────────────────────────────────────────
+(0, globals_1.describe)('getRarityMultiplier()', () => {
+    globals_1.it.each([
+        [rarity_1.RarityEnum.COMMON, 1.0],
+        [rarity_1.RarityEnum.RARE, 1.15],
+        [rarity_1.RarityEnum.LEGENDARY, 1.3],
+        [rarity_1.RarityEnum.MYTHIC, 1.5],
+        [rarity_1.RarityEnum.SPECIAL, 1.75]
+    ])('%s → multiplier %f', (rarity, expected) => {
+        (0, globals_1.expect)((0, improvement_1.getRarityMultiplier)(rarity)).toBeCloseTo(expected, 5);
+    });
+    (0, globals_1.it)('throws UNKNOWN_RARITY for an unrecognised rarity string', () => {
+        (0, globals_1.expect)(() => (0, improvement_1.getRarityMultiplier)('DIVINE')).toThrow('UNKNOWN_RARITY');
+    });
+});
+// ─── getImprovementThreshold ──────────────────────────────────────────────────
+(0, globals_1.describe)('getImprovementThreshold()', () => {
+    (0, globals_1.it)('at statTotal=6 the curve exponent term is 0 → threshold = round(100 / rarityMultiplier)', () => {
+        // COMMON (multiplier 1.0): round(100 / 1.0) = 100
+        (0, globals_1.expect)((0, improvement_1.getImprovementThreshold)(6, rarity_1.RarityEnum.COMMON)).toBe(100);
+        // LEGENDARY (multiplier 1.3): round(100 / 1.3) = 77
+        (0, globals_1.expect)((0, improvement_1.getImprovementThreshold)(6, rarity_1.RarityEnum.LEGENDARY)).toBe(Math.round(100 / 1.3));
+    });
+    (0, globals_1.it)('threshold increases as statTotal grows beyond 6', () => {
+        const low = (0, improvement_1.getImprovementThreshold)(10, rarity_1.RarityEnum.COMMON);
+        const high = (0, improvement_1.getImprovementThreshold)(50, rarity_1.RarityEnum.COMMON);
+        (0, globals_1.expect)(high).toBeGreaterThan(low);
+    });
+    (0, globals_1.it)('higher rarity multiplier yields lower threshold (easier improvement)', () => {
+        const common = (0, improvement_1.getImprovementThreshold)(30, rarity_1.RarityEnum.COMMON);
+        const legendary = (0, improvement_1.getImprovementThreshold)(30, rarity_1.RarityEnum.LEGENDARY);
+        (0, globals_1.expect)(legendary).toBeLessThan(common);
+    });
+    (0, globals_1.it)('returns an integer (Math.round applied)', () => {
+        (0, globals_1.expect)(Number.isInteger((0, improvement_1.getImprovementThreshold)(20, rarity_1.RarityEnum.RARE))).toBe(true);
+    });
+});
+// ─── getCoachMultiplier ───────────────────────────────────────────────────────
+(0, globals_1.describe)('getCoachMultiplier()', () => {
+    globals_1.it.each([
+        [rarity_1.RarityEnum.COMMON, 2.0],
+        [rarity_1.RarityEnum.RARE, 1.5],
+        [rarity_1.RarityEnum.LEGENDARY, 1.0],
+        [rarity_1.RarityEnum.MYTHIC, 0.85],
+        [rarity_1.RarityEnum.SPECIAL, 0.65]
+    ])('%s → %f', (rarity, expected) => {
+        (0, globals_1.expect)((0, improvement_1.getCoachMultiplier)(rarity)).toBeCloseTo(expected, 10);
+    });
+    (0, globals_1.it)('higher rarity → lower coach multiplier (rarer players improve more slowly)', () => {
+        (0, globals_1.expect)((0, improvement_1.getCoachMultiplier)(rarity_1.RarityEnum.COMMON)).toBeGreaterThan((0, improvement_1.getCoachMultiplier)(rarity_1.RarityEnum.LEGENDARY));
+    });
+});
+// ─── selectImprovableStat ─────────────────────────────────────────────────────
+/** Builds a stat record (DB column names) with every value set to `value`. */
+function allStats(value) {
+    return {
+        setting: value,
+        serve: value,
+        spike: value,
+        quick: value,
+        power: value,
+        awareness: value,
+        attack: value,
+        back_attack: value,
+        reception: value,
+        overhand: value,
+        bump: value,
+        block: value,
+        read: value,
+        commit: value,
+        focus: value,
+        defense: value,
+        stamina: value,
+        reflex: value
+    };
+}
+(0, globals_1.describe)('selectImprovableStat()', () => {
+    (0, globals_1.it)('returns null when every stat is at or above the rarity cap', () => {
+        const cap = (0, improvement_1.getStatCap)(rarity_1.RarityEnum.COMMON); // 59
+        (0, globals_1.expect)((0, improvement_1.selectImprovableStat)(rarity_1.RarityEnum.COMMON, stats_1.StatsEnum.ATTACK, allStats(cap))).toBeNull();
+    });
+    (0, globals_1.it)('returns a stat from the SERVE focus pool (serve, awareness, attack)', () => {
+        const focusPool = new Set(['serve', 'awareness', 'attack']);
+        const stats = allStats(1);
+        // Run many times to confirm we never escape the focus pool
+        for (let i = 0; i < 100; i++) {
+            const result = (0, improvement_1.selectImprovableStat)(rarity_1.RarityEnum.COMMON, stats_1.StatsEnum.SERVE, stats);
+            (0, globals_1.expect)(result).not.toBeNull();
+            (0, globals_1.expect)(focusPool.has(result)).toBe(true);
+        }
+    });
+    (0, globals_1.it)('returns a stat from the RECEIVE focus pool (reception, overhand, bump, focus, defense, reflex)', () => {
+        const focusPool = new Set(['reception', 'overhand', 'bump', 'focus', 'defense', 'reflex']);
+        const stats = allStats(1);
+        for (let i = 0; i < 100; i++) {
+            const result = (0, improvement_1.selectImprovableStat)(rarity_1.RarityEnum.COMMON, stats_1.StatsEnum.RECEIVE, stats);
+            (0, globals_1.expect)(result).not.toBeNull();
+            (0, globals_1.expect)(focusPool.has(result)).toBe(true);
+        }
+    });
+    (0, globals_1.it)('falls back to any improvable stat when all focus-pool stats are capped', () => {
+        const cap = (0, improvement_1.getStatCap)(rarity_1.RarityEnum.COMMON);
+        // Cap the SERVE focus stats: serve, awareness, attack
+        const stats = { ...allStats(1), serve: cap, awareness: cap, attack: cap };
+        for (let i = 0; i < 50; i++) {
+            const result = (0, improvement_1.selectImprovableStat)(rarity_1.RarityEnum.COMMON, stats_1.StatsEnum.SERVE, stats);
+            (0, globals_1.expect)(result).not.toBeNull();
+            // Must never return one of the capped focus stats
+            (0, globals_1.expect)(['serve', 'awareness', 'attack']).not.toContain(result);
+        }
+    });
+    (0, globals_1.it)('returns a string (DB column name) not a PerformanceStatsKey', () => {
+        const stats = allStats(1);
+        const result = (0, improvement_1.selectImprovableStat)(rarity_1.RarityEnum.COMMON, stats_1.StatsEnum.ATTACK, stats);
+        // back_attack is the DB column for backAttack — verify the column naming convention
+        if (result === 'back_attack') {
+            (0, globals_1.expect)(result).toBe('back_attack');
+        }
+        else {
+            (0, globals_1.expect)(typeof result).toBe('string');
+        }
+    });
+});

package/dist/cjs/src/service/player/index.d.ts

@@ -0,0 +1,9 @@
+export * from './player';
+export * from './improvement';
+export * from './decline';
+export * from './player-generator';
+export * from './performance-stats';
+export * from './trait';
+export * from './rarity';
+export * from './role';
+export * from './stats';

package/dist/cjs/src/service/player/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./player"), exports);
+__exportStar(require("./improvement"), exports);
+__exportStar(require("./decline"), exports);
+__exportStar(require("./player-generator"), exports);
+__exportStar(require("./performance-stats"), exports);
+__exportStar(require("./trait"), exports);
+__exportStar(require("./rarity"), exports);
+__exportStar(require("./role"), exports);
+__exportStar(require("./stats"), exports);

package/dist/cjs/src/service/player/performance-stats-keys.d.ts

@@ -0,0 +1,2 @@
+export declare const performanceStatKeys: readonly ["setting", "serve", "spike", "quick", "power", "awareness", "attack", "backAttack", "reception", "overhand", "bump", "block", "read", "commit", "focus", "defense", "stamina", "reflex"];
+export type PerformanceStatsKey = typeof performanceStatKeys[number];

package/dist/cjs/src/service/player/performance-stats-keys.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performanceStatKeys = void 0;
+exports.performanceStatKeys = ['setting', 'serve', 'spike', 'quick', 'power', 'awareness', 'attack', 'backAttack',
+    'reception', 'overhand', 'bump', 'block', 'read', 'commit', 'focus', 'defense', 'stamina', 'reflex'];

package/dist/cjs/src/service/player/performance-stats.d.ts

@@ -0,0 +1,12 @@
+import { PerformanceStatsKey, performanceStatKeys } from './performance-stats-keys';
+export { performanceStatKeys };
+export type { PerformanceStatsKey };
+export type PerformanceStatsParams = Record<PerformanceStatsKey, number>;
+export interface PerformanceStats extends PerformanceStatsParams {
+}
+export declare class PerformanceStats {
+    static create(input: unknown): PerformanceStats;
+    private constructor();
+    static fromAverage(avg: number): PerformanceStats;
+    toString(): string;
+}

package/dist/cjs/src/service/player/performance-stats.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceStats = exports.performanceStatKeys = void 0;
+const performance_stats_z_1 = require("./schemas/performance-stats.z");
+const performance_stats_keys_1 = require("./performance-stats-keys");
+Object.defineProperty(exports, "performanceStatKeys", { enumerable: true, get: function () { return performance_stats_keys_1.performanceStatKeys; } });
+class PerformanceStats {
+    static create(input) {
+        const result = performance_stats_z_1.PerformanceStatsInputSchema.safeParse(input);
+        if (!result.success) {
+            const received = (() => {
+                try {
+                    return JSON.stringify(input);
+                }
+                catch {
+                    return String(input);
+                }
+            })();
+            throw new Error(`INVALID_PERFORMANCE_STATS: ${result.error.message}. RECEIVED=${received}`);
+        }
+        return new PerformanceStats(result.data);
+    }
+    constructor(opts) {
+        Object.assign(this, opts);
+    }
+    static fromAverage(avg) {
+        const opts = Object.fromEntries(performance_stats_keys_1.performanceStatKeys.map((key) => [key, avg]));
+        return PerformanceStats.create(opts);
+    }
+    toString() {
+        return performance_stats_keys_1.performanceStatKeys.map((key) => `${key}: ${this[key]}`)
+            .join(', ');
+    }
+}
+exports.PerformanceStats = PerformanceStats;

package/dist/cjs/src/service/player/player-generator.d.ts

@@ -0,0 +1,36 @@
+import { Rarity } from './rarity';
+import { Role } from './role';
+import { Country } from '../country';
+import { Player } from './player';
+export interface PityState {
+    legendaryPity: number;
+    mythicPity: number;
+    specialPity: number;
+}
+export interface RollResult {
+    rarity: Rarity;
+    pity: PityState;
+}
+export interface GachaPullConfig {
+    special: number;
+    mythic: number;
+    legendary: number;
+    rare: number;
+    applyLegendaryPity: boolean;
+    applyMythicPity: boolean;
+    applySpecialPity: boolean;
+    accumulateLegendaryPity: boolean;
+    accumulateMythicPity: boolean;
+    accumulateSpecialPity: boolean;
+}
+export declare const NORMAL_PULL_CONFIG: GachaPullConfig;
+export declare const QUALIFIER_PULL_CONFIG: GachaPullConfig;
+export declare const TOURNAMENT_PULL_CONFIG: GachaPullConfig;
+export declare function rollRarity(pity: PityState, config?: GachaPullConfig): RollResult;
+export declare class PlayerGenerator {
+    private constructor();
+    private static generatePerformance;
+    static generatePlayer(country: Country, _rarity?: Rarity, role?: Role, maxTraits?: boolean): Player;
+    static generatePlayers(count: number, countries: Country[]): Player[];
+}
+export declare function pickPlayerCountry(teamCountry: Country, allCountries: Country[]): Country;

package/dist/cjs/src/service/player/player-generator.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerGenerator = exports.TOURNAMENT_PULL_CONFIG = exports.QUALIFIER_PULL_CONFIG = exports.NORMAL_PULL_CONFIG = void 0;
+exports.rollRarity = rollRarity;
+exports.pickPlayerCountry = pickPlayerCountry;
+const uuid_1 = require("uuid");
+const node_crypto_1 = require("node:crypto");
+const rarity_1 = require("./rarity");
+const performance_stats_1 = require("./performance-stats");
+const role_1 = require("./role");
+const stats_1 = require("./stats");
+const stat_config_1 = require("../../stat-config");
+const utils_1 = require("../utils");
+const player_1 = require("./player");
+const trait_1 = require("./trait");
+const decline_1 = require("./decline");
+const LEGENDARY_PITY_STEP = 0.004;
+const MYTHIC_PITY_STEP = 0.00001;
+const SPECIAL_PITY_STEP = 0.000005;
+// Used for world/bot player generation — full rarity range
+const WORLD_PULL_CONFIG = {
+    special: 0.0003,
+    mythic: 0.004,
+    legendary: 0.021,
+    rare: 0.25,
+    applyLegendaryPity: true,
+    applyMythicPity: true,
+    applySpecialPity: true,
+    accumulateLegendaryPity: true,
+    accumulateMythicPity: true,
+    accumulateSpecialPity: true
+};
+// Normal gacha (x1 / x10): COMMON–MYTHIC, no special
+exports.NORMAL_PULL_CONFIG = {
+    special: 0,
+    mythic: 0.004,
+    legendary: 0.021,
+    rare: 0.25,
+    applyLegendaryPity: true,
+    applyMythicPity: true,
+    applySpecialPity: false,
+    accumulateLegendaryPity: true,
+    accumulateMythicPity: true,
+    accumulateSpecialPity: false
+};
+// Qualifier gacha (x10 per match): RARE–SPECIAL
+exports.QUALIFIER_PULL_CONFIG = {
+    special: 0.003,
+    mythic: 0.01,
+    legendary: 0.10,
+    rare: 0.887,
+    applyLegendaryPity: true,
+    applyMythicPity: true,
+    applySpecialPity: true,
+    accumulateLegendaryPity: true,
+    accumulateMythicPity: true,
+    accumulateSpecialPity: true
+};
+// Tournament gacha (x5 per match): LEGENDARY–SPECIAL, no legendary pity (floor is legendary)
+exports.TOURNAMENT_PULL_CONFIG = {
+    special: 0.01,
+    mythic: 0.04,
+    legendary: 0.95,
+    rare: 0,
+    applyLegendaryPity: false,
+    applyMythicPity: true,
+    applySpecialPity: true,
+    accumulateLegendaryPity: false,
+    accumulateMythicPity: true,
+    accumulateSpecialPity: true
+};
+function rollRarity(pity, config = WORLD_PULL_CONFIG) {
+    const roll = Math.random();
+    const tSpecial = config.special + (config.applySpecialPity ? pity.specialPity : 0);
+    const tMythic = tSpecial + config.mythic + (config.applyMythicPity ? pity.mythicPity : 0);
+    const tLegendary = tMythic + config.legendary + (config.applyLegendaryPity ? pity.legendaryPity : 0);
+    const tRare = tLegendary + config.rare;
+    let rarity;
+    if (roll < tSpecial) {
+        rarity = rarity_1.RarityEnum.SPECIAL;
+    }
+    else if (roll < tMythic) {
+        rarity = rarity_1.RarityEnum.MYTHIC;
+    }
+    else if (roll < tLegendary) {
+        rarity = rarity_1.RarityEnum.LEGENDARY;
+    }
+    else if (roll < tRare) {
+        rarity = rarity_1.RarityEnum.RARE;
+    }
+    else {
+        rarity = rarity_1.RarityEnum.COMMON;
+    }
+    const hitLegendaryPlus = rarity === rarity_1.RarityEnum.LEGENDARY || rarity === rarity_1.RarityEnum.MYTHIC || rarity === rarity_1.RarityEnum.SPECIAL;
+    const hitMythicPlus = rarity === rarity_1.RarityEnum.MYTHIC || rarity === rarity_1.RarityEnum.SPECIAL;
+    const updatedPity = {
+        legendaryPity: !config.accumulateLegendaryPity
+            ? pity.legendaryPity
+            : hitLegendaryPlus ? 0 : pity.legendaryPity + LEGENDARY_PITY_STEP,
+        mythicPity: !config.accumulateMythicPity
+            ? pity.mythicPity
+            : hitMythicPlus ? 0 : pity.mythicPity + MYTHIC_PITY_STEP,
+        specialPity: !config.accumulateSpecialPity
+            ? pity.specialPity
+            : rarity === rarity_1.RarityEnum.SPECIAL ? 0 : pity.specialPity + SPECIAL_PITY_STEP
+    };
+    return { rarity, pity: updatedPity };
+}
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+class PlayerGenerator {
+    constructor() { }
+    static generatePerformance(rarity, role) {
+        const ATTACK = (0, stats_1.getMultipliers)(stats_1.StatsEnum.ATTACK);
+        const SET = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SET);
+        const RECEIVE = (0, stats_1.getMultipliers)(stats_1.StatsEnum.RECEIVE);
+        const BLOCK = (0, stats_1.getMultipliers)(stats_1.StatsEnum.BLOCK);
+        const SERVE = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SERVE);
+        const STAMINA = (0, stats_1.getMultipliers)(stats_1.StatsEnum.STAMINA);
+        function buildPerformanceFromRole(weights, minValue, maxValue) {
+            return performance_stats_1.PerformanceStats.create(Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => {
+                if (weights[key] > 0)
+                    return [key, (0, node_crypto_1.randomInt)(minValue, maxValue + 1)];
+                else
+                    return [key, (0, node_crypto_1.randomInt)(rarity_1.RarityRanges.COMMON[0], Math.max(minValue - 1, rarity_1.RarityRanges.COMMON[0] + 1))];
+            })));
+        }
+        switch (rarity) {
+            case rarity_1.RarityEnum.COMMON: {
+                if (role != null) {
+                    const weights = stat_config_1.rolesJSON.find(entry => entry.role === role)?.weight;
+                    if (weights != null) {
+                        return buildPerformanceFromRole(weights, rarity_1.RarityRanges.COMMON[0], rarity_1.RarityRanges.COMMON[1]);
+                    }
+                }
+                return performance_stats_1.PerformanceStats.create(Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => [key, Math.round((0, node_crypto_1.randomInt)(rarity_1.RarityRanges.COMMON[0], rarity_1.RarityRanges.COMMON[1]))])));
+            }
+            case rarity_1.RarityEnum.RARE: {
+                if (role != null) {
+                    const weights = stat_config_1.rolesJSON.find(entry => entry.role === role)?.weight;
+                    if (weights != null) {
+                        return buildPerformanceFromRole(weights, rarity_1.RarityRanges.RARE[0], rarity_1.RarityRanges.RARE[1]);
+                    }
+                }
+                const stats = (0, utils_1.shuffle)([ATTACK, SET, SERVE, RECEIVE, BLOCK]);
+                const performance = Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => [key, 1]));
+                for (let i = 0; i < 3; i++) {
+                    assignValues(stats[i], rarity_1.RarityRanges.RARE[0], rarity_1.RarityRanges.RARE[1], performance);
+                }
+                for (let i = 3; i < 5; i++) {
+                    assignValues(stats[i], rarity_1.RarityRanges.COMMON[0], rarity_1.RarityRanges.COMMON[1], performance);
+                }
+                assignValues(STAMINA, rarity_1.RarityRanges.COMMON[0], rarity_1.RarityRanges.RARE[1], performance);
+                return performance_stats_1.PerformanceStats.create(performance);
+            }
+            case rarity_1.RarityEnum.LEGENDARY: {
+                if (role != null) {
+                    const weights = stat_config_1.rolesJSON.find(entry => entry.role === role)?.weight;
+                    if (weights != null) {
+                        return buildPerformanceFromRole(weights, rarity_1.RarityRanges.LEGENDARY[0], rarity_1.RarityRanges.LEGENDARY[1]);
+                    }
+                }
+                const s1 = (0, utils_1.shuffle)([ATTACK, SET, RECEIVE, BLOCK]);
+                const s2 = (0, utils_1.shuffle)([SERVE, STAMINA]);
+                const performance = Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => [key, 1]));
+                assignValues(s1[0], rarity_1.RarityRanges.LEGENDARY[0], rarity_1.RarityRanges.LEGENDARY[1], performance);
+                for (let i = 1; i < 4; i++) {
+                    assignValues(s1[i], rarity_1.RarityRanges.RARE[0], rarity_1.RarityRanges.RARE[1], performance);
+                }
+                for (let i = 0; i < 2; i++) {
+                    assignValues(s2[i], rarity_1.RarityRanges.COMMON[0], rarity_1.RarityRanges.RARE[1], performance);
+                }
+                return performance_stats_1.PerformanceStats.create(performance);
+            }
+            case rarity_1.RarityEnum.MYTHIC: {
+                if (role != null) {
+                    const weights = stat_config_1.rolesJSON.find(entry => entry.role === role)?.weight;
+                    if (weights != null) {
+                        return buildPerformanceFromRole(weights, rarity_1.RarityRanges.MYTHIC[0], rarity_1.RarityRanges.MYTHIC[1]);
+                    }
+                }
+                const stats = (0, utils_1.shuffle)([ATTACK, SET, RECEIVE, BLOCK]);
+                const performance = Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => [key, 1]));
+                assignValues(stats[0], rarity_1.RarityRanges.MYTHIC[0], rarity_1.RarityRanges.MYTHIC[1], performance);
+                assignValues(stats[1], rarity_1.RarityRanges.LEGENDARY[0], rarity_1.RarityRanges.LEGENDARY[1], performance);
+                for (let i = 2; i < 4; i++) {
+                    assignValues(stats[i], rarity_1.RarityRanges.RARE[0], rarity_1.RarityRanges.RARE[1], performance);
+                }
+                assignValues(SERVE, rarity_1.RarityRanges.LEGENDARY[0], rarity_1.RarityRanges.LEGENDARY[1], performance);
+                assignValues(STAMINA, rarity_1.RarityRanges.COMMON[0], rarity_1.RarityRanges.MYTHIC[1], performance);
+                return performance_stats_1.PerformanceStats.create(performance);
+            }
+            case rarity_1.RarityEnum.SPECIAL: {
+                if (role != null) {
+                    const weights = stat_config_1.rolesJSON.find(entry => entry.role === role)?.weight;
+                    if (weights != null) {
+                        return buildPerformanceFromRole(weights, rarity_1.RarityRanges.SPECIAL[0], rarity_1.RarityRanges.SPECIAL[1]);
+                    }
+                }
+                const stats = (0, utils_1.shuffle)([ATTACK, SERVE, SET, RECEIVE, BLOCK]);
+                const performance = Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => [key, 1]));
+                assignValues(stats[0], rarity_1.RarityRanges.SPECIAL[0], rarity_1.RarityRanges.SPECIAL[1], performance);
+                for (let i = 1; i < 3; i++) {
+                    assignValues(stats[i], rarity_1.RarityRanges.MYTHIC[0], rarity_1.RarityRanges.MYTHIC[1], performance);
+                }
+                for (let i = 3; i < 5; i++) {
+                    assignValues(stats[i], rarity_1.RarityRanges.LEGENDARY[0], rarity_1.RarityRanges.LEGENDARY[1], performance);
+                }
+                assignValues(STAMINA, rarity_1.RarityRanges.LEGENDARY[0], rarity_1.RarityRanges.SPECIAL[1], performance);
+                return performance_stats_1.PerformanceStats.create(performance);
+            }
+            default: {
+                throw new Error('INVALID_RARITY');
+            }
+        }
+    }
+    static generatePlayer(country, _rarity, role, maxTraits) {
+        const rarity = _rarity ?? rollRarity({ legendaryPity: 0, mythicPity: 0, specialPity: 0 }).rarity;
+        const name = (0, utils_1.generatePlayerName)(country.locales, 1)[0];
+        const stats = PlayerGenerator.generatePerformance(rarity, role);
+        const roles = (0, role_1.assignRoles)(stats, rarity);
+        const traits = (0, trait_1.assignTraits)(roles, rarity, maxTraits);
+        const age = (0, node_crypto_1.randomInt)(15, 21);
+        const declineProfile = decline_1.declineProfiles[(0, node_crypto_1.randomInt)(0, decline_1.declineProfiles.length)];
+        return player_1.Player.create({ id: (0, uuid_1.v4)(), name, country, stats, roles, traits, rarity, age, declineProfile });
+    }
+    static generatePlayers(count, countries) {
+        const players = [];
+        for (const country of countries) {
+            for (let i = 0; i < count; i++) {
+                players.push(PlayerGenerator.generatePlayer(country));
+            }
+        }
+        return players;
+    }
+}
+exports.PlayerGenerator = PlayerGenerator;
+function pickPlayerCountry(teamCountry, allCountries) {
+    const roll = Math.random();
+    if (roll < 0.60) {
+        return teamCountry;
+    }
+    if (roll < 0.95) {
+        const regionCode = teamCountry.region?.code;
+        const regional = regionCode != null
+            ? allCountries.filter(c => c.region?.code === regionCode && c.id !== teamCountry.id)
+            : [];
+        if (regional.length > 0) {
+            return regional[Math.floor(Math.random() * regional.length)];
+        }
+        return teamCountry;
+    }
+    return allCountries[Math.floor(Math.random() * allCountries.length)];
+}
+function assignValues(stat, low, high, performance) {
+    performance_stats_1.performanceStatKeys.filter((key) => stat[key] != null && stat[key] > 0)
+        .forEach((key) => {
+        const value = (0, node_crypto_1.randomInt)(low, high);
+        performance[key] = performance[key] < value ? value : performance[key];
+    });
+}

package/dist/cjs/src/service/player/player.d.ts

@@ -0,0 +1,43 @@
+import { PerformanceStats } from './performance-stats';
+import { Trait } from './trait';
+import { Country } from '../country';
+import { Rarity } from './rarity';
+import { Stats } from './stats';
+import { Role } from './role';
+import { BoxScore, BoxScoreTotals } from '../match';
+import { DeclineProfile } from './decline';
+export declare class Stat {
+    readonly name: Stats;
+    readonly value: number;
+    constructor({ name, value }: {
+        name: Stats;
+        value: number;
+    });
+    toString(): string;
+}
+export declare class Name {
+    readonly first: string;
+    readonly last: string;
+    static create(input: unknown): Name;
+    private constructor();
+    toString(): string;
+}
+export declare class Player {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+    readonly generalStats: Stat[];
+    readonly rarity: Rarity;
+    readonly age: number;
+    readonly declineProfile: DeclineProfile;
+    readonly boxScores?: BoxScore[];
+    readonly boxScoreTotals?: BoxScoreTotals;
+    static create(input: unknown): Player;
+    private constructor();
+    static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
+    static compareStats(p1: Player, p2: Player): number;
+    toString(): string;
+}