volleyballsimtypes 0.0.356 → 0.0.358

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

@@ -0,0 +1,257 @@
+"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 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, maxValue) {
+            return performance_stats_1.PerformanceStats.create(Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => {
+                if (weights[key] > 0)
+                    return [key, maxValue];
+                else
+                    return [key, Math.round((0, node_crypto_1.randomInt)(rarity_1.RarityRanges.COMMON[0], maxValue - 5))];
+            })));
+        }
+        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[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[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[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[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[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);
+        return player_1.Player.create({ id: (0, uuid_1.v4)(), name, country, stats, roles, traits, rarity });
+    }
+    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,40 @@
+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';
+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 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;
+}

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = exports.Name = exports.Stat = void 0;
+const performance_stats_1 = require("./performance-stats");
+const stats_1 = require("./stats");
+const role_1 = require("./role");
+const player_z_1 = require("./schemas/player.z");
+class Stat {
+    constructor({ name, value }) {
+        this.name = name;
+        this.value = value;
+    }
+    toString() {
+        return `${this.name}: ${this.value}`;
+    }
+}
+exports.Stat = Stat;
+class Name {
+    static create(input) {
+        const result = player_z_1.NameInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_NAME: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Name(result.data);
+    }
+    constructor({ first, last }) {
+        this.first = first;
+        this.last = last;
+    }
+    toString() {
+        return `${this.first} ${this.last}`;
+    }
+}
+exports.Name = Name;
+class Player {
+    static create(input) {
+        const result = player_z_1.PlayerInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_PLAYER: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Player({
+            ...result.data,
+            name: Name.create(result.data.name),
+            stats: performance_stats_1.PerformanceStats.create(result.data.stats)
+        });
+    }
+    constructor({ id, name, country, stats, roles, traits, rarity, boxScores, boxScoreTotals }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.stats = stats;
+        this.roles = roles;
+        this.traits = traits;
+        this.rarity = rarity;
+        this.boxScores = boxScores;
+        this.boxScoreTotals = boxScoreTotals;
+        this.generalStats = Object.values(stats_1.StatsEnum).map((stat) => ({
+            name: stat,
+            value: (0, stats_1.calculateStatScore)(stats, stat)
+        }));
+    }
+    // Used as a base sorting function for players
+    static sortPlayers(roles) {
+        return (p1, p2) => roles.reduce((x, role) => {
+            const p2Score = (0, role_1.calculateRoleScore)(p2.stats, role);
+            const p1Score = (0, role_1.calculateRoleScore)(p1.stats, role);
+            return x + p2Score - p1Score;
+        }, 0);
+    }
+    static compareStats(p1, p2) {
+        const compareFn = (acc, current) => {
+            let x = current.value;
+            switch (current.name) {
+                case stats_1.StatsEnum.ATTACK:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.SET:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.RECEIVE:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.BLOCK:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.SERVE:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.STAMINA:
+                    x *= 0.05;
+                    break;
+                default:
+                    x *= 0;
+            }
+            return acc + x;
+        };
+        const s1 = p1.generalStats.reduce(compareFn, 0);
+        const s2 = p2.generalStats.reduce(compareFn, 0);
+        return s2 - s1;
+    }
+    toString() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name.toString(),
+            country: this.country.toString(),
+            stats: this.stats.toString(),
+            rarity: this.rarity,
+            roles: `[${this.roles.map(r => r.toString()).join(',')}]`,
+            traits: `[${this.traits.map(t => t.toString()).join(',')}]`,
+            generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
+        });
+    }
+}
+exports.Player = Player;

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

@@ -0,0 +1,15 @@
+export declare enum RarityEnum {
+    COMMON = "COMMON",
+    RARE = "RARE",
+    LEGENDARY = "LEGENDARY",
+    MYTHIC = "MYTHIC",
+    SPECIAL = "SPECIAL"
+}
+export type Rarity = RarityEnum.COMMON | RarityEnum.RARE | RarityEnum.LEGENDARY | RarityEnum.MYTHIC | RarityEnum.SPECIAL;
+export declare const RarityRanges: {
+    COMMON: number[];
+    RARE: number[];
+    LEGENDARY: number[];
+    MYTHIC: number[];
+    SPECIAL: number[];
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RarityRanges = exports.RarityEnum = void 0;
+var RarityEnum;
+(function (RarityEnum) {
+    RarityEnum["COMMON"] = "COMMON";
+    RarityEnum["RARE"] = "RARE";
+    RarityEnum["LEGENDARY"] = "LEGENDARY";
+    RarityEnum["MYTHIC"] = "MYTHIC";
+    RarityEnum["SPECIAL"] = "SPECIAL";
+})(RarityEnum || (exports.RarityEnum = RarityEnum = {}));
+exports.RarityRanges = {
+    [RarityEnum.COMMON]: [1, 59],
+    [RarityEnum.RARE]: [51, 69],
+    [RarityEnum.LEGENDARY]: [71, 79],
+    [RarityEnum.MYTHIC]: [80, 89],
+    [RarityEnum.SPECIAL]: [90, 99]
+};

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

@@ -0,0 +1,28 @@
+import { PerformanceStats, PerformanceStatsParams } from './performance-stats';
+import { Rarity } from './rarity';
+export declare enum RoleEnum {
+    SETTER = "SETTER",
+    LIBERO = "LIBERO",
+    OUTSIDE_HITTER = "OUTSIDE_HITTER",
+    OPPOSITE_HITTER = "OPPOSITE_HITTER",
+    MIDDLE_BLOCKER = "MIDDLE_BLOCKER"
+}
+export type Role = RoleEnum.SETTER | RoleEnum.LIBERO | RoleEnum.MIDDLE_BLOCKER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER;
+export type RoleEventAction = 'reception' | 'set' | 'spike' | 'block';
+export interface RolesFormula {
+    role: Role;
+    weight: PerformanceStatsParams;
+}
+export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
+export declare function assignRoles(stats: PerformanceStats, rarity: Rarity): Role[];
+/**
+ * Returns the role-based multiplier for a player performing a given action.
+ * When the player holds multiple roles, the least-penalising role wins.
+ * Defaults to the harshest penalty for that action if roles is empty.
+ */
+export declare function getRoleEventPenalty(roles: Role[], action: Exclude<RoleEventAction, 'block'>): number;
+/**
+ * Returns the role-based multiplier for a block sequence.
+ * If any blocker holds MIDDLE_BLOCKER, the whole block has no penalty.
+ */
+export declare function getBlockRolePenalty(blockerRoles: Role[][]): number;

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

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleEnum = void 0;
+exports.calculateRoleScore = calculateRoleScore;
+exports.assignRoles = assignRoles;
+exports.getRoleEventPenalty = getRoleEventPenalty;
+exports.getBlockRolePenalty = getBlockRolePenalty;
+const rarity_1 = require("./rarity");
+const roles_json_1 = __importDefault(require("../../stat-config/roles.json"));
+var RoleEnum;
+(function (RoleEnum) {
+    RoleEnum["SETTER"] = "SETTER";
+    RoleEnum["LIBERO"] = "LIBERO";
+    RoleEnum["OUTSIDE_HITTER"] = "OUTSIDE_HITTER";
+    RoleEnum["OPPOSITE_HITTER"] = "OPPOSITE_HITTER";
+    RoleEnum["MIDDLE_BLOCKER"] = "MIDDLE_BLOCKER";
+})(RoleEnum || (exports.RoleEnum = RoleEnum = {}));
+const rolesFormula = roles_json_1.default;
+// ─── Role score ───────────────────────────────────────────────────────────────
+function calculateRoleScore(stats, role) {
+    const weights = rolesFormula.find(r => r.role === role);
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const score = Object.keys(weights.weight)
+        .reduce((score, key) => {
+        const stat = stats[key];
+        const weight = weights.weight[key];
+        return score + (stat * weight);
+    }, 0);
+    return Math.round(score);
+}
+// ─── Role assignment ──────────────────────────────────────────────────────────
+function getRoleCountRange(rarity) {
+    switch (rarity) {
+        case rarity_1.RarityEnum.COMMON: return [1, 2];
+        case rarity_1.RarityEnum.RARE: return [1, 3];
+        case rarity_1.RarityEnum.LEGENDARY: return [1, 4];
+        case rarity_1.RarityEnum.MYTHIC: return [2, 4];
+        case rarity_1.RarityEnum.SPECIAL: return [3, 5];
+        default: return [1, 2];
+    }
+}
+function assignRoles(stats, rarity) {
+    const scores = Object.values(RoleEnum)
+        .map((role) => ({
+        role,
+        score: calculateRoleScore(stats, role)
+    }))
+        .sort((x, y) => y.score - x.score);
+    const [min, max] = getRoleCountRange(rarity);
+    const count = min + Math.floor(Math.random() * (max - min + 1));
+    return scores.slice(0, count).map(s => s.role);
+}
+// ─── Role event penalties ─────────────────────────────────────────────────────
+const ROLE_PENALTY_TABLE = {
+    [RoleEnum.LIBERO]: { reception: 1.00, set: 0.98, spike: 0.90 },
+    [RoleEnum.SETTER]: { reception: 0.92, set: 1.00, spike: 0.98 },
+    [RoleEnum.OUTSIDE_HITTER]: { reception: 0.95, set: 0.95, spike: 1.00 },
+    [RoleEnum.OPPOSITE_HITTER]: { reception: 0.92, set: 0.95, spike: 1.00 },
+    [RoleEnum.MIDDLE_BLOCKER]: { reception: 0.85, set: 0.90, spike: 0.95 }
+};
+/**
+ * Returns the role-based multiplier for a player performing a given action.
+ * When the player holds multiple roles, the least-penalising role wins.
+ * Defaults to the harshest penalty for that action if roles is empty.
+ */
+function getRoleEventPenalty(roles, action) {
+    if (roles.length === 0) {
+        // fallback: use MIDDLE_BLOCKER penalties (most penalised for non-block actions)
+        return ROLE_PENALTY_TABLE[RoleEnum.MIDDLE_BLOCKER][action];
+    }
+    return Math.max(...roles.map(role => ROLE_PENALTY_TABLE[role][action]));
+}
+/**
+ * Returns the role-based multiplier for a block sequence.
+ * If any blocker holds MIDDLE_BLOCKER, the whole block has no penalty.
+ */
+function getBlockRolePenalty(blockerRoles) {
+    const anyMB = blockerRoles.some(roles => roles.includes(RoleEnum.MIDDLE_BLOCKER));
+    return anyMB ? 1.00 : 0.90;
+}

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

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