volleyballsimtypes 0.0.217 → 0.0.358

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

@@ -1,12 +1,12 @@
-import { PerformanceStats } from './performance-stats';
-export declare enum StatsEnum {
-    ATTACK = "ATTACK",
-    SET = "SET",
-    RECEIVE = "RECEIVE",
-    SERVE = "SERVE",
-    BLOCK = "BLOCK",
-    STAMINA = "STAMINA"
-}
-export type Stats = StatsEnum.ATTACK | StatsEnum.SET | StatsEnum.RECEIVE | StatsEnum.SERVE | StatsEnum.BLOCK | StatsEnum.STAMINA;
-export declare function calculateStatScore(performanceStats: PerformanceStats, statName: Stats): number;
-export declare function getMultipliers(statName: Stats, performanceStats?: PerformanceStats): any;
+import { PerformanceStats, PerformanceStatsKey } from './performance-stats';
+export declare enum StatsEnum {
+    ATTACK = "ATTACK",
+    SET = "SET",
+    RECEIVE = "RECEIVE",
+    SERVE = "SERVE",
+    BLOCK = "BLOCK",
+    STAMINA = "STAMINA"
+}
+export type Stats = StatsEnum.ATTACK | StatsEnum.SET | StatsEnum.RECEIVE | StatsEnum.SERVE | StatsEnum.BLOCK | StatsEnum.STAMINA;
+export declare function calculateStatScore(performanceStats: PerformanceStats, statName: Stats): number;
+export declare function getMultipliers(statName: Stats, performanceStats?: PerformanceStats): Partial<Record<PerformanceStatsKey, number>>;

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

@@ -1,68 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMultipliers = exports.calculateStatScore = exports.StatsEnum = void 0;
-var StatsEnum;
-(function (StatsEnum) {
-    StatsEnum["ATTACK"] = "ATTACK";
-    StatsEnum["SET"] = "SET";
-    StatsEnum["RECEIVE"] = "RECEIVE";
-    StatsEnum["SERVE"] = "SERVE";
-    StatsEnum["BLOCK"] = "BLOCK";
-    StatsEnum["STAMINA"] = "STAMINA";
-})(StatsEnum = exports.StatsEnum || (exports.StatsEnum = {}));
-function calculateStatScore(performanceStats, statName) {
-    const multipliers = getMultipliers(statName, performanceStats);
-    const score = Object.entries(multipliers)
-        .reduce((total, [key, value]) => total + value * performanceStats[key], 0);
-    return Math.round(score);
-}
-exports.calculateStatScore = calculateStatScore;
-function getMultipliers(statName, performanceStats) {
-    switch (statName) {
-        case StatsEnum.ATTACK:
-            return {
-                spike: 0.55,
-                backAttack: 0.1,
-                power: performanceStats == null ? 0.125 : performanceStats.power > performanceStats.quick ? 0.2 : 0.05,
-                quick: performanceStats == null ? 0.125 : performanceStats.quick > performanceStats.power ? 0.2 : 0.05,
-                awareness: 0.05,
-                attack: 0.05
-            };
-        case StatsEnum.SET:
-            return {
-                setting: 0.75,
-                overhand: 0.1,
-                awareness: 0.075,
-                attack: 0.075
-            };
-        case StatsEnum.RECEIVE:
-            return {
-                reception: 0.75,
-                overhand: 0.015,
-                bump: 0.15,
-                focus: 0.015,
-                defense: 0.055,
-                reflex: 0.015
-            };
-        case StatsEnum.SERVE:
-            return {
-                serve: 0.85,
-                awareness: 0.075,
-                attack: 0.075
-            };
-        case StatsEnum.BLOCK:
-            return {
-                block: 0.65,
-                read: performanceStats == null ? 0.125 : performanceStats.read > performanceStats.commit ? 0.2 : 0.05,
-                commit: performanceStats == null ? 0.125 : performanceStats.commit > performanceStats.read ? 0.2 : 0.05,
-                focus: 0.04,
-                defense: 0.04,
-                reflex: 0.02
-            };
-        case StatsEnum.STAMINA:
-            return { stamina: 1 };
-        default:
-            throw new Error('INVALID_STAT');
-    }
-}
-exports.getMultipliers = getMultipliers;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsEnum = void 0;
+exports.calculateStatScore = calculateStatScore;
+exports.getMultipliers = getMultipliers;
+var StatsEnum;
+(function (StatsEnum) {
+    StatsEnum["ATTACK"] = "ATTACK";
+    StatsEnum["SET"] = "SET";
+    StatsEnum["RECEIVE"] = "RECEIVE";
+    StatsEnum["SERVE"] = "SERVE";
+    StatsEnum["BLOCK"] = "BLOCK";
+    StatsEnum["STAMINA"] = "STAMINA";
+})(StatsEnum || (exports.StatsEnum = StatsEnum = {}));
+function calculateStatScore(performanceStats, statName) {
+    const multipliers = getMultipliers(statName, performanceStats);
+    const score = Object.entries(multipliers)
+        .reduce((total, [key, value]) => total + value * performanceStats[key], 0);
+    return Math.round(score);
+}
+function getMultipliers(statName, performanceStats) {
+    switch (statName) {
+        case StatsEnum.ATTACK:
+            return {
+                spike: 0.55,
+                backAttack: 0.1,
+                power: performanceStats == null ? 0.125 : performanceStats.power > performanceStats.quick ? 0.2 : 0.05,
+                quick: performanceStats == null ? 0.125 : performanceStats.quick > performanceStats.power ? 0.2 : 0.05,
+                awareness: 0.05,
+                attack: 0.05
+            };
+        case StatsEnum.SET:
+            return {
+                setting: 0.75,
+                overhand: 0.1,
+                awareness: 0.075,
+                attack: 0.075
+            };
+        case StatsEnum.RECEIVE:
+            return {
+                reception: 0.75,
+                overhand: 0.015,
+                bump: 0.15,
+                focus: 0.015,
+                defense: 0.055,
+                reflex: 0.015
+            };
+        case StatsEnum.SERVE:
+            return {
+                serve: 0.85,
+                awareness: 0.075,
+                attack: 0.075
+            };
+        case StatsEnum.BLOCK:
+            return {
+                block: 0.65,
+                read: performanceStats == null ? 0.125 : performanceStats.read > performanceStats.commit ? 0.2 : 0.05,
+                commit: performanceStats == null ? 0.125 : performanceStats.commit > performanceStats.read ? 0.2 : 0.05,
+                focus: 0.04,
+                defense: 0.04,
+                reflex: 0.02
+            };
+        case StatsEnum.STAMINA:
+            return { stamina: 1 };
+        default:
+            throw new Error('INVALID_STAT');
+    }
+}

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

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

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const stats_1 = require("./stats");
+const performance_stats_1 = require("./performance-stats");
+const performance_stats_keys_1 = require("./performance-stats-keys");
+// ─── helpers ─────────────────────────────────────────────────────────────────
+/** Builds a PerformanceStats with all keys set to `base`, then applies overrides. */
+function makeStats(base = 50, overrides = {}) {
+    const data = Object.fromEntries(performance_stats_keys_1.performanceStatKeys.map(k => [k, base]));
+    return performance_stats_1.PerformanceStats.create({ ...data, ...overrides });
+}
+// ─── getMultipliers ───────────────────────────────────────────────────────────
+(0, globals_1.describe)('getMultipliers()', () => {
+    (0, globals_1.describe)('ATTACK', () => {
+        (0, globals_1.it)('boosts power weight (0.2) when power > quick', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.ATTACK, makeStats(50, { power: 80, quick: 20 }));
+            (0, globals_1.expect)(m.power).toBe(0.2);
+            (0, globals_1.expect)(m.quick).toBe(0.05);
+        });
+        (0, globals_1.it)('boosts quick weight (0.2) when quick > power', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.ATTACK, makeStats(50, { quick: 80, power: 20 }));
+            (0, globals_1.expect)(m.quick).toBe(0.2);
+            (0, globals_1.expect)(m.power).toBe(0.05);
+        });
+        (0, globals_1.it)('uses balanced weights (0.125) when performanceStats is omitted', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.ATTACK);
+            (0, globals_1.expect)(m.power).toBe(0.125);
+            (0, globals_1.expect)(m.quick).toBe(0.125);
+        });
+        (0, globals_1.it)('multipliers sum to 1 when power > quick', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.ATTACK, makeStats(50, { power: 80, quick: 20 }));
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            (0, globals_1.expect)(total).toBeCloseTo(1, 10);
+        });
+    });
+    (0, globals_1.describe)('SET', () => {
+        (0, globals_1.it)('multipliers sum to 1', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SET);
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            (0, globals_1.expect)(total).toBeCloseTo(1, 10);
+        });
+        (0, globals_1.it)('setting has the highest weight (0.75)', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SET);
+            const max = Math.max(...Object.values(m).map(v => v ?? 0));
+            (0, globals_1.expect)(m.setting).toBe(max);
+        });
+    });
+    (0, globals_1.describe)('RECEIVE', () => {
+        (0, globals_1.it)('multipliers sum to 1', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.RECEIVE);
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            (0, globals_1.expect)(total).toBeCloseTo(1, 10);
+        });
+        (0, globals_1.it)('reception has the highest weight (0.75)', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.RECEIVE);
+            const max = Math.max(...Object.values(m).map(v => v ?? 0));
+            (0, globals_1.expect)(m.reception).toBe(max);
+        });
+    });
+    (0, globals_1.describe)('SERVE', () => {
+        (0, globals_1.it)('multipliers sum to 1', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SERVE);
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            (0, globals_1.expect)(total).toBeCloseTo(1, 10);
+        });
+        (0, globals_1.it)('serve has the highest weight (0.85)', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SERVE);
+            const max = Math.max(...Object.values(m).map(v => v ?? 0));
+            (0, globals_1.expect)(m.serve).toBe(max);
+        });
+    });
+    (0, globals_1.describe)('BLOCK', () => {
+        (0, globals_1.it)('boosts read weight (0.2) when read > commit', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.BLOCK, makeStats(50, { read: 90, commit: 10 }));
+            (0, globals_1.expect)(m.read).toBe(0.2);
+            (0, globals_1.expect)(m.commit).toBe(0.05);
+        });
+        (0, globals_1.it)('boosts commit weight (0.2) when commit > read', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.BLOCK, makeStats(50, { commit: 90, read: 10 }));
+            (0, globals_1.expect)(m.commit).toBe(0.2);
+            (0, globals_1.expect)(m.read).toBe(0.05);
+        });
+        (0, globals_1.it)('uses balanced weights (0.125) when performanceStats is omitted', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.BLOCK);
+            (0, globals_1.expect)(m.read).toBe(0.125);
+            (0, globals_1.expect)(m.commit).toBe(0.125);
+        });
+        (0, globals_1.it)('multipliers sum to 1 when read > commit', () => {
+            const m = (0, stats_1.getMultipliers)(stats_1.StatsEnum.BLOCK, makeStats(50, { read: 90, commit: 10 }));
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            (0, globals_1.expect)(total).toBeCloseTo(1, 10);
+        });
+    });
+    (0, globals_1.describe)('STAMINA', () => {
+        (0, globals_1.it)('returns exactly { stamina: 1 }', () => {
+            (0, globals_1.expect)((0, stats_1.getMultipliers)(stats_1.StatsEnum.STAMINA)).toEqual({ stamina: 1 });
+        });
+    });
+});
+// ─── calculateStatScore ───────────────────────────────────────────────────────
+(0, globals_1.describe)('calculateStatScore()', () => {
+    (0, globals_1.it)('STAMINA score equals the stamina stat value (weight 1.0)', () => {
+        (0, globals_1.expect)((0, stats_1.calculateStatScore)(makeStats(1, { stamina: 77 }), stats_1.StatsEnum.STAMINA)).toBe(77);
+    });
+    (0, globals_1.it)('SET score equals stat value when all stats are uniform (multipliers sum to 1)', () => {
+        // setting*0.75 + overhand*0.1 + awareness*0.075 + attack*0.075 = s * 1.0
+        (0, globals_1.expect)((0, stats_1.calculateStatScore)(makeStats(50), stats_1.StatsEnum.SET)).toBe(50);
+    });
+    (0, globals_1.it)('SERVE score equals stat value when all stats are uniform (multipliers sum to 1)', () => {
+        // serve*0.85 + awareness*0.075 + attack*0.075 = s * 1.0
+        (0, globals_1.expect)((0, stats_1.calculateStatScore)(makeStats(50), stats_1.StatsEnum.SERVE)).toBe(50);
+    });
+    (0, globals_1.it)('RECEIVE score equals stat value when all stats are uniform (multipliers sum to 1)', () => {
+        // reception*0.75 + overhand*0.015 + bump*0.15 + focus*0.015 + defense*0.055 + reflex*0.015 = s * 1.0
+        (0, globals_1.expect)((0, stats_1.calculateStatScore)(makeStats(50), stats_1.StatsEnum.RECEIVE)).toBe(50);
+    });
+    (0, globals_1.it)('always returns an integer (Math.round applied)', () => {
+        const score = (0, stats_1.calculateStatScore)(makeStats(50), stats_1.StatsEnum.SERVE);
+        (0, globals_1.expect)(Number.isInteger(score)).toBe(true);
+    });
+    (0, globals_1.it)('returns a higher score for a player with better relevant stats', () => {
+        const weak = (0, stats_1.calculateStatScore)(makeStats(20), stats_1.StatsEnum.SERVE);
+        const strong = (0, stats_1.calculateStatScore)(makeStats(80), stats_1.StatsEnum.SERVE);
+        (0, globals_1.expect)(strong).toBeGreaterThan(weak);
+    });
+    (0, globals_1.it)('SERVE: serve=99 dominates, contributing 0.85 of the total', () => {
+        // All other serve-relevant stats at 1: awareness=1, attack=1
+        // score ≈ 99*0.85 + 1*0.075 + 1*0.075 = 84.15 + 0.15 = 84.3 → 84
+        const stats = makeStats(1, { serve: 99 });
+        (0, globals_1.expect)((0, stats_1.calculateStatScore)(stats, stats_1.StatsEnum.SERVE)).toBe(84);
+    });
+});

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

@@ -1,51 +1,51 @@
-import { Rarity } from './rarity';
-import { Role } from './role';
-interface TraitProps {
-    readonly name: Trait;
-    readonly modifier: number;
-    readonly chance: number;
-    readonly roles: Role[];
-}
-export declare enum TraitEnum {
-    /**
-     * When triggered, all actions before the net crossing have a bonus.
-     * Can only be triggered during the first or second touch.
-     */
-    MASTER_MIND = "MASTER_MIND",
-    /**
-     * When this player is part of the front row, they will always be part of the blocking block
-     */
-    MOVING_WALL = "MOVING_WALL",
-    /**
-     * Enables the player making the second touch to spike or dump
-     */
-    SURPRISE_ATTACK = "SURPRISE_ATTACK",
-    /**
-     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
-     */
-    MARKSMAN = "MARKSMAN",
-    /**
-     * The server will perform an extra strong serve.
-     */
-    METEOR_SERVE = "METEOR_SERVE",
-    /**
-     * The player has a 50% chance to perform an action with no energy decrease
-     */
-    VIGOROUS = "VIGOROUS",
-    /**
-     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
-     */
-    GUARDIAN = "GUARDIAN",
-    /**
-     * Enables the server to perform a float serve, which checks against receiver overhand instead.
-     */
-    FLOAT_SERVE = "FLOAT_SERVE",
-    /**
-     * Gives the player a chance to perform a perfect reception.
-     */
-    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
-}
-export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.SURPRISE_ATTACK | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS | TraitEnum.DEFENSIVE_SPECIALIST;
-export declare function assignTraits(roles: Role[], rarity: Rarity): Trait[];
-export declare const traitMap: Map<Trait, TraitProps>;
-export {};
+import { Rarity } from './rarity';
+import { Role } from './role';
+interface TraitProps {
+    readonly name: Trait;
+    readonly modifier: number;
+    readonly chance: number;
+    readonly roles: Role[];
+}
+export declare enum TraitEnum {
+    /**
+     * When triggered, all actions before the net crossing have a bonus.
+     * Can only be triggered during the first or second touch.
+     */
+    MASTER_MIND = "MASTER_MIND",
+    /**
+     * When this player is part of the front row, they will always be part of the blocking block
+     */
+    MOVING_WALL = "MOVING_WALL",
+    /**
+     * Enables the player making the second touch to spike or dump
+     */
+    SURPRISE_ATTACK = "SURPRISE_ATTACK",
+    /**
+     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
+     */
+    MARKSMAN = "MARKSMAN",
+    /**
+     * The server will perform an extra strong serve.
+     */
+    METEOR_SERVE = "METEOR_SERVE",
+    /**
+     * The player has a 50% chance to perform an action with no energy decrease
+     */
+    VIGOROUS = "VIGOROUS",
+    /**
+     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
+     */
+    GUARDIAN = "GUARDIAN",
+    /**
+     * Enables the server to perform a float serve, which checks against receiver overhand instead.
+     */
+    FLOAT_SERVE = "FLOAT_SERVE",
+    /**
+     * Gives the player a chance to perform a perfect reception.
+     */
+    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
+}
+export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.SURPRISE_ATTACK | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS | TraitEnum.DEFENSIVE_SPECIALIST;
+export declare function assignTraits(roles: Role[], rarity: Rarity, maxTraits?: boolean): Trait[];
+export declare const traitMap: Map<Trait, TraitProps>;
+export {};

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

@@ -1,87 +1,87 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traitMap = exports.assignTraits = exports.TraitEnum = void 0;
-const rarity_1 = require("./rarity");
-const node_crypto_1 = require("node:crypto");
-const traits_json_1 = __importDefault(require("../../stat-config/traits.json"));
-const utils_1 = require("../utils");
-const traits = traits_json_1.default;
-var TraitEnum;
-(function (TraitEnum) {
-    /**
-     * When triggered, all actions before the net crossing have a bonus.
-     * Can only be triggered during the first or second touch.
-     */
-    TraitEnum["MASTER_MIND"] = "MASTER_MIND";
-    /**
-     * When this player is part of the front row, they will always be part of the blocking block
-     */
-    TraitEnum["MOVING_WALL"] = "MOVING_WALL";
-    /**
-     * Enables the player making the second touch to spike or dump
-     */
-    TraitEnum["SURPRISE_ATTACK"] = "SURPRISE_ATTACK";
-    /**
-     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
-     */
-    TraitEnum["MARKSMAN"] = "MARKSMAN";
-    /**
-     * The server will perform an extra strong serve.
-     */
-    TraitEnum["METEOR_SERVE"] = "METEOR_SERVE";
-    /**
-     * The player has a 50% chance to perform an action with no energy decrease
-     */
-    TraitEnum["VIGOROUS"] = "VIGOROUS";
-    /**
-     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
-     */
-    TraitEnum["GUARDIAN"] = "GUARDIAN";
-    /**
-     * Enables the server to perform a float serve, which checks against receiver overhand instead.
-     */
-    TraitEnum["FLOAT_SERVE"] = "FLOAT_SERVE";
-    /**
-     * Gives the player a chance to perform a perfect reception.
-     */
-    TraitEnum["DEFENSIVE_SPECIALIST"] = "DEFENSIVE_SPECIALIST";
-})(TraitEnum = exports.TraitEnum || (exports.TraitEnum = {}));
-function assignTraits(roles, rarity) {
-    let traitCount;
-    switch (rarity) {
-        case rarity_1.RarityEnum.COMMON: {
-            traitCount = (0, node_crypto_1.randomInt)(0, 1);
-            break;
-        }
-        case rarity_1.RarityEnum.RARE: {
-            traitCount = (0, node_crypto_1.randomInt)(0, 2);
-            break;
-        }
-        case rarity_1.RarityEnum.LEGENDARY: {
-            traitCount = (0, node_crypto_1.randomInt)(1, 3);
-            break;
-        }
-        case rarity_1.RarityEnum.MYTHIC: {
-            traitCount = (0, node_crypto_1.randomInt)(2, 4);
-            break;
-        }
-        case rarity_1.RarityEnum.SPECIAL: {
-            traitCount = 4;
-            break;
-        }
-        default:
-            throw new Error('INVALID_RARITY');
-    }
-    if (traitCount < 1)
-        return [];
-    const filteredTraits = traits.filter((trait) => {
-        const setA = new Set(trait.roles);
-        return roles.some(el => setA.has(el));
-    }).map(trait => trait.name);
-    return (0, utils_1.shuffle)(filteredTraits).slice(0, traitCount);
-}
-exports.assignTraits = assignTraits;
-exports.traitMap = new Map(traits.map((trait) => [trait.name, trait]));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traitMap = exports.TraitEnum = void 0;
+exports.assignTraits = assignTraits;
+const rarity_1 = require("./rarity");
+const node_crypto_1 = require("node:crypto");
+const traits_json_1 = __importDefault(require("../../stat-config/traits.json"));
+const utils_1 = require("../utils");
+const traits = traits_json_1.default;
+var TraitEnum;
+(function (TraitEnum) {
+    /**
+     * When triggered, all actions before the net crossing have a bonus.
+     * Can only be triggered during the first or second touch.
+     */
+    TraitEnum["MASTER_MIND"] = "MASTER_MIND";
+    /**
+     * When this player is part of the front row, they will always be part of the blocking block
+     */
+    TraitEnum["MOVING_WALL"] = "MOVING_WALL";
+    /**
+     * Enables the player making the second touch to spike or dump
+     */
+    TraitEnum["SURPRISE_ATTACK"] = "SURPRISE_ATTACK";
+    /**
+     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
+     */
+    TraitEnum["MARKSMAN"] = "MARKSMAN";
+    /**
+     * The server will perform an extra strong serve.
+     */
+    TraitEnum["METEOR_SERVE"] = "METEOR_SERVE";
+    /**
+     * The player has a 50% chance to perform an action with no energy decrease
+     */
+    TraitEnum["VIGOROUS"] = "VIGOROUS";
+    /**
+     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
+     */
+    TraitEnum["GUARDIAN"] = "GUARDIAN";
+    /**
+     * Enables the server to perform a float serve, which checks against receiver overhand instead.
+     */
+    TraitEnum["FLOAT_SERVE"] = "FLOAT_SERVE";
+    /**
+     * Gives the player a chance to perform a perfect reception.
+     */
+    TraitEnum["DEFENSIVE_SPECIALIST"] = "DEFENSIVE_SPECIALIST";
+})(TraitEnum || (exports.TraitEnum = TraitEnum = {}));
+function assignTraits(roles, rarity, maxTraits) {
+    let traitCount;
+    switch (rarity) {
+        case rarity_1.RarityEnum.COMMON: {
+            traitCount = maxTraits === true ? 0 : (0, node_crypto_1.randomInt)(0, 1);
+            break;
+        }
+        case rarity_1.RarityEnum.RARE: {
+            traitCount = maxTraits === true ? 1 : (0, node_crypto_1.randomInt)(0, 2);
+            break;
+        }
+        case rarity_1.RarityEnum.LEGENDARY: {
+            traitCount = maxTraits === true ? 2 : (0, node_crypto_1.randomInt)(1, 3);
+            break;
+        }
+        case rarity_1.RarityEnum.MYTHIC: {
+            traitCount = maxTraits === true ? 3 : (0, node_crypto_1.randomInt)(2, 4);
+            break;
+        }
+        case rarity_1.RarityEnum.SPECIAL: {
+            traitCount = 4;
+            break;
+        }
+        default:
+            throw new Error('INVALID_RARITY');
+    }
+    if (traitCount < 1)
+        return [];
+    const filteredTraits = traits.filter((trait) => {
+        const setA = new Set(trait.roles);
+        return roles.some(el => setA.has(el));
+    }).map(trait => trait.name);
+    return (0, utils_1.shuffle)(filteredTraits).slice(0, traitCount);
+}
+exports.traitMap = new Map(traits.map((trait) => [trait.name, trait]));

package/dist/cjs/src/service/team/formation.d.ts

@@ -1,30 +1,30 @@
-import { Role } from '../player';
-import { CourtPosition } from '../match';
-interface PositionRole {
-    readonly [CourtPosition.LEFT_FRONT]: Role[];
-    readonly [CourtPosition.MIDDLE_FRONT]: Role[];
-    readonly [CourtPosition.RIGHT_FRONT]: Role[];
-    readonly [CourtPosition.LEFT_BACK]: Role[];
-    readonly [CourtPosition.MIDDLE_BACK]: Role[];
-    readonly [CourtPosition.RIGHT_BACK]: Role[];
-}
-export interface SubPriority {
-    readonly MIDDLE_BLOCKER: number;
-    readonly OUTSIDE_HITTER: number;
-    readonly OPPOSITE_HITTER: number;
-    readonly SETTER: number;
-    readonly LIBERO: number;
-}
-export declare class Formation {
-    static readonly '5-1': Formation;
-    static readonly '4-2': Formation;
-    static readonly '6-2': Formation;
-    readonly name: string;
-    readonly initialRotation: PositionRole;
-    readonly base: PositionRole;
-    readonly draftingPriorities: Role[][];
-    readonly liberoSubPriority: SubPriority;
-    private constructor();
-    static getFormations(): Formation[];
-}
-export {};
+import { Role } from '../player';
+import { CourtPosition } from '../match';
+interface PositionRole {
+    readonly [CourtPosition.LEFT_FRONT]: Role[];
+    readonly [CourtPosition.MIDDLE_FRONT]: Role[];
+    readonly [CourtPosition.RIGHT_FRONT]: Role[];
+    readonly [CourtPosition.LEFT_BACK]: Role[];
+    readonly [CourtPosition.MIDDLE_BACK]: Role[];
+    readonly [CourtPosition.RIGHT_BACK]: Role[];
+}
+export interface SubPriority {
+    readonly MIDDLE_BLOCKER: number;
+    readonly OUTSIDE_HITTER: number;
+    readonly OPPOSITE_HITTER: number;
+    readonly SETTER: number;
+    readonly LIBERO: number;
+}
+export declare class Formation {
+    static readonly '5-1': Formation;
+    static readonly '4-2': Formation;
+    static readonly '6-2': Formation;
+    readonly name: string;
+    readonly initialRotation: PositionRole;
+    readonly base: PositionRole;
+    readonly liberoSubPriority: SubPriority;
+    static create(input: unknown): Formation;
+    private constructor();
+    static getFormations(): Formation[];
+}
+export {};