volleyballsimtypes 0.0.358 → 0.0.359

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

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

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

@@ -1,2 +0,0 @@
-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/esm/src/service/player/performance-stats-keys.js

@@ -1,2 +0,0 @@
-export const performanceStatKeys = ['setting', 'serve', 'spike', 'quick', 'power', 'awareness', 'attack', 'backAttack',
-    'reception', 'overhand', 'bump', 'block', 'read', 'commit', 'focus', 'defense', 'stamina', 'reflex'];

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

@@ -1,12 +0,0 @@
-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/esm/src/service/player/performance-stats.js

@@ -1,31 +0,0 @@
-import { PerformanceStatsInputSchema } from './schemas/performance-stats.z';
-import { performanceStatKeys } from './performance-stats-keys';
-export { performanceStatKeys };
-export class PerformanceStats {
-    static create(input) {
-        const result = 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(performanceStatKeys.map((key) => [key, avg]));
-        return PerformanceStats.create(opts);
-    }
-    toString() {
-        return performanceStatKeys.map((key) => `${key}: ${this[key]}`)
-            .join(', ');
-    }
-}

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

@@ -1,36 +0,0 @@
-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/esm/src/service/player/player-generator.js

@@ -1,251 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { randomInt } from 'node:crypto';
-import { RarityEnum, RarityRanges } from './rarity';
-import { performanceStatKeys, PerformanceStats } from './performance-stats';
-import { assignRoles } from './role';
-import { getMultipliers, StatsEnum } from './stats';
-import { rolesJSON } from '../../stat-config';
-import { shuffle, generatePlayerName } from '../utils';
-import { Player } from './player';
-import { assignTraits } from './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
-export const 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
-export const 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)
-export const 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
-};
-export 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 = RarityEnum.SPECIAL;
-    }
-    else if (roll < tMythic) {
-        rarity = RarityEnum.MYTHIC;
-    }
-    else if (roll < tLegendary) {
-        rarity = RarityEnum.LEGENDARY;
-    }
-    else if (roll < tRare) {
-        rarity = RarityEnum.RARE;
-    }
-    else {
-        rarity = RarityEnum.COMMON;
-    }
-    const hitLegendaryPlus = rarity === RarityEnum.LEGENDARY || rarity === RarityEnum.MYTHIC || rarity === RarityEnum.SPECIAL;
-    const hitMythicPlus = rarity === RarityEnum.MYTHIC || rarity === 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 === RarityEnum.SPECIAL ? 0 : pity.specialPity + SPECIAL_PITY_STEP
-    };
-    return { rarity, pity: updatedPity };
-}
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-export class PlayerGenerator {
-    constructor() { }
-    static generatePerformance(rarity, role) {
-        const ATTACK = getMultipliers(StatsEnum.ATTACK);
-        const SET = getMultipliers(StatsEnum.SET);
-        const RECEIVE = getMultipliers(StatsEnum.RECEIVE);
-        const BLOCK = getMultipliers(StatsEnum.BLOCK);
-        const SERVE = getMultipliers(StatsEnum.SERVE);
-        const STAMINA = getMultipliers(StatsEnum.STAMINA);
-        function buildPerformanceFromRole(weights, maxValue) {
-            return PerformanceStats.create(Object.fromEntries(performanceStatKeys.map((key) => {
-                if (weights[key] > 0)
-                    return [key, maxValue];
-                else
-                    return [key, Math.round(randomInt(RarityRanges.COMMON[0], maxValue - 5))];
-            })));
-        }
-        switch (rarity) {
-            case RarityEnum.COMMON: {
-                if (role != null) {
-                    const weights = rolesJSON.find(entry => entry.role === role)?.weight;
-                    if (weights != null) {
-                        return buildPerformanceFromRole(weights, RarityRanges.COMMON[1]);
-                    }
-                }
-                return PerformanceStats.create(Object.fromEntries(performanceStatKeys.map((key) => [key, Math.round(randomInt(RarityRanges.COMMON[0], RarityRanges.COMMON[1]))])));
-            }
-            case RarityEnum.RARE: {
-                if (role != null) {
-                    const weights = rolesJSON.find(entry => entry.role === role)?.weight;
-                    if (weights != null) {
-                        return buildPerformanceFromRole(weights, RarityRanges.RARE[1]);
-                    }
-                }
-                const stats = shuffle([ATTACK, SET, SERVE, RECEIVE, BLOCK]);
-                const performance = Object.fromEntries(performanceStatKeys.map((key) => [key, 1]));
-                for (let i = 0; i < 3; i++) {
-                    assignValues(stats[i], RarityRanges.RARE[0], RarityRanges.RARE[1], performance);
-                }
-                for (let i = 3; i < 5; i++) {
-                    assignValues(stats[i], RarityRanges.COMMON[0], RarityRanges.COMMON[1], performance);
-                }
-                assignValues(STAMINA, RarityRanges.COMMON[0], RarityRanges.RARE[1], performance);
-                return PerformanceStats.create(performance);
-            }
-            case RarityEnum.LEGENDARY: {
-                if (role != null) {
-                    const weights = rolesJSON.find(entry => entry.role === role)?.weight;
-                    if (weights != null) {
-                        return buildPerformanceFromRole(weights, RarityRanges.LEGENDARY[1]);
-                    }
-                }
-                const s1 = shuffle([ATTACK, SET, RECEIVE, BLOCK]);
-                const s2 = shuffle([SERVE, STAMINA]);
-                const performance = Object.fromEntries(performanceStatKeys.map((key) => [key, 1]));
-                assignValues(s1[0], RarityRanges.LEGENDARY[0], RarityRanges.LEGENDARY[1], performance);
-                for (let i = 1; i < 4; i++) {
-                    assignValues(s1[i], RarityRanges.RARE[0], RarityRanges.RARE[1], performance);
-                }
-                for (let i = 0; i < 2; i++) {
-                    assignValues(s2[i], RarityRanges.COMMON[0], RarityRanges.RARE[1], performance);
-                }
-                return PerformanceStats.create(performance);
-            }
-            case RarityEnum.MYTHIC: {
-                if (role != null) {
-                    const weights = rolesJSON.find(entry => entry.role === role)?.weight;
-                    if (weights != null) {
-                        return buildPerformanceFromRole(weights, RarityRanges.MYTHIC[1]);
-                    }
-                }
-                const stats = shuffle([ATTACK, SET, RECEIVE, BLOCK]);
-                const performance = Object.fromEntries(performanceStatKeys.map((key) => [key, 1]));
-                assignValues(stats[0], RarityRanges.MYTHIC[0], RarityRanges.MYTHIC[1], performance);
-                assignValues(stats[1], RarityRanges.LEGENDARY[0], RarityRanges.LEGENDARY[1], performance);
-                for (let i = 2; i < 4; i++) {
-                    assignValues(stats[i], RarityRanges.RARE[0], RarityRanges.RARE[1], performance);
-                }
-                assignValues(SERVE, RarityRanges.LEGENDARY[0], RarityRanges.LEGENDARY[1], performance);
-                assignValues(STAMINA, RarityRanges.COMMON[0], RarityRanges.MYTHIC[1], performance);
-                return PerformanceStats.create(performance);
-            }
-            case RarityEnum.SPECIAL: {
-                if (role != null) {
-                    const weights = rolesJSON.find(entry => entry.role === role)?.weight;
-                    if (weights != null) {
-                        return buildPerformanceFromRole(weights, RarityRanges.SPECIAL[1]);
-                    }
-                }
-                const stats = shuffle([ATTACK, SERVE, SET, RECEIVE, BLOCK]);
-                const performance = Object.fromEntries(performanceStatKeys.map((key) => [key, 1]));
-                assignValues(stats[0], RarityRanges.SPECIAL[0], RarityRanges.SPECIAL[1], performance);
-                for (let i = 1; i < 3; i++) {
-                    assignValues(stats[i], RarityRanges.MYTHIC[0], RarityRanges.MYTHIC[1], performance);
-                }
-                for (let i = 3; i < 5; i++) {
-                    assignValues(stats[i], RarityRanges.LEGENDARY[0], RarityRanges.LEGENDARY[1], performance);
-                }
-                assignValues(STAMINA, RarityRanges.LEGENDARY[0], RarityRanges.SPECIAL[1], performance);
-                return 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 = generatePlayerName(country.locales, 1)[0];
-        const stats = PlayerGenerator.generatePerformance(rarity, role);
-        const roles = assignRoles(stats, rarity);
-        const traits = assignTraits(roles, rarity, maxTraits);
-        return Player.create({ id: uuidv4(), 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;
-    }
-}
-export 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) {
-    performanceStatKeys.filter((key) => stat[key] != null && stat[key] > 0)
-        .forEach((key) => {
-        const value = randomInt(low, high);
-        performance[key] = performance[key] < value ? value : performance[key];
-    });
-}

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

@@ -1,40 +0,0 @@
-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/esm/src/service/player/player.js

@@ -1,118 +0,0 @@
-import { PerformanceStats } from './performance-stats';
-import { calculateStatScore, StatsEnum } from './stats';
-import { calculateRoleScore } from './role';
-import { NameInputSchema, PlayerInputSchema } from './schemas/player.z';
-export class Stat {
-    constructor({ name, value }) {
-        this.name = name;
-        this.value = value;
-    }
-    toString() {
-        return `${this.name}: ${this.value}`;
-    }
-}
-export class Name {
-    static create(input) {
-        const result = 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}`;
-    }
-}
-export class Player {
-    static create(input) {
-        const result = 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: 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(StatsEnum).map((stat) => ({
-            name: stat,
-            value: calculateStatScore(stats, stat)
-        }));
-    }
-    // Used as a base sorting function for players
-    static sortPlayers(roles) {
-        return (p1, p2) => roles.reduce((x, role) => {
-            const p2Score = calculateRoleScore(p2.stats, role);
-            const p1Score = 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 StatsEnum.ATTACK:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.SET:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.RECEIVE:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.BLOCK:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.SERVE:
-                    x *= 0.19;
-                    break;
-                case 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(',')}]`
-        });
-    }
-}

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

@@ -1,15 +0,0 @@
-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/esm/src/service/player/rarity.js

@@ -1,15 +0,0 @@
-export var RarityEnum;
-(function (RarityEnum) {
-    RarityEnum["COMMON"] = "COMMON";
-    RarityEnum["RARE"] = "RARE";
-    RarityEnum["LEGENDARY"] = "LEGENDARY";
-    RarityEnum["MYTHIC"] = "MYTHIC";
-    RarityEnum["SPECIAL"] = "SPECIAL";
-})(RarityEnum || (RarityEnum = {}));
-export const RarityRanges = {
-    [RarityEnum.COMMON]: [1, 59],
-    [RarityEnum.RARE]: [51, 69],
-    [RarityEnum.LEGENDARY]: [71, 79],
-    [RarityEnum.MYTHIC]: [80, 89],
-    [RarityEnum.SPECIAL]: [90, 99]
-};

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

@@ -1,28 +0,0 @@
-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/esm/src/service/player/role.js

@@ -1,74 +0,0 @@
-import { RarityEnum } from './rarity';
-import roles from '../../stat-config/roles.json';
-export 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 || (RoleEnum = {}));
-const rolesFormula = roles;
-// ─── Role score ───────────────────────────────────────────────────────────────
-export 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 RarityEnum.COMMON: return [1, 2];
-        case RarityEnum.RARE: return [1, 3];
-        case RarityEnum.LEGENDARY: return [1, 4];
-        case RarityEnum.MYTHIC: return [2, 4];
-        case RarityEnum.SPECIAL: return [3, 5];
-        default: return [1, 2];
-    }
-}
-export 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.
- */
-export 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.
- */
-export function getBlockRolePenalty(blockerRoles) {
-    const anyMB = blockerRoles.some(roles => roles.includes(RoleEnum.MIDDLE_BLOCKER));
-    return anyMB ? 1.00 : 0.90;
-}

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

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