volleyballsimtypes 0.0.451 → 0.0.453

package/dist/cjs/src/service/event/event-types.d.ts

@@ -1,7 +1,8 @@
 import type { BlockFailure, BlockType } from './block';
+import type { FreeBallFailure, FreeBallType } from './free-ball';
 import type { ReceptionFailure, ReceptionType } from './reception';
 import type { ServeFailure, ServeType } from './serve';
 import type { SetFailure, SetType } from './set';
 import type { SpikeFailure, SpikeType } from './spike';
-export type EventSubType = BlockType | ReceptionType | ServeType | SetType | SpikeType;
-export type EventFailureType = BlockFailure | ReceptionFailure | ServeFailure | SetFailure | SpikeFailure;
+export type EventSubType = BlockType | FreeBallType | ReceptionType | ServeType | SetType | SpikeType;
+export type EventFailureType = BlockFailure | FreeBallFailure | ReceptionFailure | ServeFailure | SetFailure | SpikeFailure;

package/dist/cjs/src/service/event/free-ball.d.ts

@@ -0,0 +1,17 @@
+import { InPlayEvent } from './in-play-event';
+export declare enum FreeBallTypeEnum {
+    OVER = 0,
+    STAY = 1
+}
+export type FreeBallType = FreeBallTypeEnum.OVER | FreeBallTypeEnum.STAY;
+export declare enum FreeBallFailureEnum {
+    NO_FAILURE = 0
+}
+export type FreeBallFailure = FreeBallFailureEnum.NO_FAILURE;
+export declare class FreeBall extends InPlayEvent<FreeBallFailure, FreeBallType> {
+    readonly failure: FreeBallFailure;
+    readonly type: FreeBallType;
+    static create(input: unknown): FreeBall;
+    private constructor();
+    toString(): string;
+}

package/dist/cjs/src/service/event/free-ball.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeBall = exports.FreeBallFailureEnum = exports.FreeBallTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+const free_ball_z_1 = require("./schemas/free-ball.z");
+var FreeBallTypeEnum;
+(function (FreeBallTypeEnum) {
+    // The save sent the ball over the net as a free ball -- the opponent plays it out.
+    FreeBallTypeEnum[FreeBallTypeEnum["OVER"] = 0] = "OVER";
+    // The save kept the ball on the team's side -- the team plays out its remaining touch(es).
+    FreeBallTypeEnum[FreeBallTypeEnum["STAY"] = 1] = "STAY";
+})(FreeBallTypeEnum || (exports.FreeBallTypeEnum = FreeBallTypeEnum = {}));
+var FreeBallFailureEnum;
+(function (FreeBallFailureEnum) {
+    // A Last Resort save is guaranteed -- it always produces a free ball, never an error.
+    FreeBallFailureEnum[FreeBallFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+})(FreeBallFailureEnum || (exports.FreeBallFailureEnum = FreeBallFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.FREE_BALL;
+// A FREE_BALL event is a Last Resort save: the libero digs a ball that would otherwise have lost the rally and
+// puts it back in play as a neutral free ball (over to the opponent, or staying on side). It is a real in-play
+// event (score + target) so the next receiver handles it like any free ball.
+class FreeBall extends in_play_event_1.InPlayEvent {
+    static create(input) {
+        const result = free_ball_z_1.FreeBallInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_FREE_BALL: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new FreeBall(result.data);
+    }
+    constructor({ score, playerId, target, failure, type, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        return `{${this._toString()},${failure},${type}}`;
+    }
+}
+exports.FreeBall = FreeBall;

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

@@ -1,5 +1,6 @@
 export * from './block';
 export * from './event-types';
+export * from './free-ball';
 export * from './in-play-event';
 export * from './libero-replacement';
 export * from './rally-event';

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

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./block"), exports);
 __exportStar(require("./event-types"), exports);
+__exportStar(require("./free-ball"), exports);
 __exportStar(require("./in-play-event"), exports);
 __exportStar(require("./libero-replacement"), exports);
 __exportStar(require("./rally-event"), exports);

package/dist/cjs/src/service/event/rally-event.d.ts

@@ -5,9 +5,10 @@ export declare enum EventTypeEnum {
     RECEPTION = 3,
     SET = 4,
     SPIKE = 5,
-    BLOCK = 6
+    BLOCK = 6,
+    FREE_BALL = 7
 }
-export type EventType = EventTypeEnum.LIBERO_REPLACEMENT | EventTypeEnum.SUBSTITUTION | EventTypeEnum.SERVE | EventTypeEnum.RECEPTION | EventTypeEnum.SET | EventTypeEnum.SPIKE | EventTypeEnum.BLOCK;
+export type EventType = EventTypeEnum.LIBERO_REPLACEMENT | EventTypeEnum.SUBSTITUTION | EventTypeEnum.SERVE | EventTypeEnum.RECEPTION | EventTypeEnum.SET | EventTypeEnum.SPIKE | EventTypeEnum.BLOCK | EventTypeEnum.FREE_BALL;
 export interface RallyEventOpts {
     readonly playerId: string;
     readonly eventType: EventType;

package/dist/cjs/src/service/event/rally-event.js

@@ -10,6 +10,7 @@ var EventTypeEnum;
     EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
     EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
     EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+    EventTypeEnum[EventTypeEnum["FREE_BALL"] = 7] = "FREE_BALL";
 })(EventTypeEnum || (exports.EventTypeEnum = EventTypeEnum = {}));
 class RallyEvent {
     constructor({ eventType, playerId }) {

package/dist/cjs/src/service/event/schemas/block.z.d.ts

@@ -14,6 +14,15 @@ export declare const BlockInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/cjs/src/service/event/schemas/free-ball.z.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const FreeBallInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        MASTER_MIND: TraitEnum.MASTER_MIND;
+        MOVING_WALL: TraitEnum.MOVING_WALL;
+        SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
+        MARKSMAN: TraitEnum.MARKSMAN;
+        METEOR_SERVE: TraitEnum.METEOR_SERVE;
+        VIGOROUS: TraitEnum.VIGOROUS;
+        GUARDIAN: TraitEnum.GUARDIAN;
+        FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
+        DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
+    }>>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+}, z.core.$strip>;
+export type FreeBallInput = z.infer<typeof FreeBallInputSchema>;

package/dist/cjs/src/service/event/schemas/free-ball.z.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeBallInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const freeBallTypeValues = [0, 1];
+const freeBallFailureValues = [0];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+exports.FreeBallInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    score: zod_1.z.number().finite(),
+    target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
+    failure: zod_1.z.number().int().refine((v) => freeBallFailureValues.includes(v), { message: 'INVALID_FREE_BALL_FAILURE' }),
+    type: zod_1.z.number().int().refine((v) => freeBallTypeValues.includes(v), { message: 'INVALID_FREE_BALL_TYPE' })
+});

package/dist/cjs/src/service/event/schemas/reception.z.d.ts

@@ -14,6 +14,15 @@ export declare const ReceptionInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/cjs/src/service/event/schemas/serve.z.d.ts

@@ -14,6 +14,15 @@ export declare const ServeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/cjs/src/service/event/schemas/set.z.d.ts

@@ -14,6 +14,15 @@ export declare const SetInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/cjs/src/service/event/schemas/spike.z.d.ts

@@ -14,6 +14,15 @@ export declare const SpikeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

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

@@ -53,6 +53,15 @@ export declare const PlayerInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>;
     rarity: z.ZodEnum<{
         COMMON: RarityEnum.COMMON;

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

@@ -5,6 +5,7 @@ interface TraitProps {
     readonly modifier?: number;
     readonly chance: number;
     readonly roles: Role[];
+    readonly maxRarity?: Rarity;
 }
 export declare enum TraitEnum {
     /**
@@ -45,9 +46,53 @@ export declare enum TraitEnum {
     /**
      * Gives the player a chance to perform a perfect reception.
      */
-    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
+    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST",
+    /**
+     * Three good receptions/digs/sets in a row make the next reception/dig/set a guaranteed critical that
+     * cannot fail.
+     */
+    QUICK_LEARNER = "QUICK_LEARNER",
+    /**
+     * Each successful attack ramps up the spike, and a kill ramps it more. Starts with a small penalty and
+     * resets on an attacking error.
+     */
+    MOMENTUM_ADDICT = "MOMENTUM_ADDICT",
+    /**
+     * A front-row kill demoralizes the opponents who faced it, debuffing them for a few rallies.
+     */
+    LOUDMOUTH = "LOUDMOUTH",
+    /**
+     * When a teammate makes a non-block mistake, that teammate's next action cannot fail.
+     */
+    TRUE_LEADER = "TRUE_LEADER",
+    /**
+     * Reacting to a strong opponent action (block/receive), this player can rise to match it. Limited to
+     * Mythic rarity and below.
+     */
+    OVERACHIEVER = "OVERACHIEVER",
+    /**
+     * Opponents who interact with this player's serve or attack spend twice the energy (VIGOROUS is nullified).
+     */
+    CRAFTY = "CRAFTY",
+    /**
+     * When the team loses several points in a row, the whole on-court team gets a buff that grows with the
+     * streak and disappears the moment they win a point.
+     */
+    TENACIOUS = "TENACIOUS",
+    /**
+     * Serve trait, rolled before the ambient setter/opposite hunt: a chance to serve a precise target (the
+     * setter, opposite, or best back-row attacker, depending on serve type and rotation), bypassing GUARDIAN,
+     * with a slight serve bonus and reducing the hunted player's attack involvement that rally.
+     */
+    HUNTER = "HUNTER",
+    /**
+     * Libero only. When a teammate's touch would lose the rally (a reception/dig error, a set error, or a failed
+     * dig of a blocked-back ball) and a save is still legal, a small chance the libero digs it into a neutral free
+     * ball, keeping the rally alive (over the net, or staying on side, depending on the touch).
+     */
+    LAST_RESORT = "LAST_RESORT"
 }
-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 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 | TraitEnum.QUICK_LEARNER | TraitEnum.MOMENTUM_ADDICT | TraitEnum.LOUDMOUTH | TraitEnum.TRUE_LEADER | TraitEnum.OVERACHIEVER | TraitEnum.CRAFTY | TraitEnum.TENACIOUS | TraitEnum.HUNTER | TraitEnum.LAST_RESORT;
 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

@@ -10,6 +10,14 @@ 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;
+// Ascending rarity order, used by the maxRarity trait-eligibility gate in assignTraits.
+const RARITY_RANK = {
+    [rarity_1.RarityEnum.COMMON]: 0,
+    [rarity_1.RarityEnum.RARE]: 1,
+    [rarity_1.RarityEnum.LEGENDARY]: 2,
+    [rarity_1.RarityEnum.MYTHIC]: 3,
+    [rarity_1.RarityEnum.SPECIAL]: 4
+};
 var TraitEnum;
 (function (TraitEnum) {
     /**
@@ -51,6 +59,50 @@ var TraitEnum;
      * Gives the player a chance to perform a perfect reception.
      */
     TraitEnum["DEFENSIVE_SPECIALIST"] = "DEFENSIVE_SPECIALIST";
+    /**
+     * Three good receptions/digs/sets in a row make the next reception/dig/set a guaranteed critical that
+     * cannot fail.
+     */
+    TraitEnum["QUICK_LEARNER"] = "QUICK_LEARNER";
+    /**
+     * Each successful attack ramps up the spike, and a kill ramps it more. Starts with a small penalty and
+     * resets on an attacking error.
+     */
+    TraitEnum["MOMENTUM_ADDICT"] = "MOMENTUM_ADDICT";
+    /**
+     * A front-row kill demoralizes the opponents who faced it, debuffing them for a few rallies.
+     */
+    TraitEnum["LOUDMOUTH"] = "LOUDMOUTH";
+    /**
+     * When a teammate makes a non-block mistake, that teammate's next action cannot fail.
+     */
+    TraitEnum["TRUE_LEADER"] = "TRUE_LEADER";
+    /**
+     * Reacting to a strong opponent action (block/receive), this player can rise to match it. Limited to
+     * Mythic rarity and below.
+     */
+    TraitEnum["OVERACHIEVER"] = "OVERACHIEVER";
+    /**
+     * Opponents who interact with this player's serve or attack spend twice the energy (VIGOROUS is nullified).
+     */
+    TraitEnum["CRAFTY"] = "CRAFTY";
+    /**
+     * When the team loses several points in a row, the whole on-court team gets a buff that grows with the
+     * streak and disappears the moment they win a point.
+     */
+    TraitEnum["TENACIOUS"] = "TENACIOUS";
+    /**
+     * Serve trait, rolled before the ambient setter/opposite hunt: a chance to serve a precise target (the
+     * setter, opposite, or best back-row attacker, depending on serve type and rotation), bypassing GUARDIAN,
+     * with a slight serve bonus and reducing the hunted player's attack involvement that rally.
+     */
+    TraitEnum["HUNTER"] = "HUNTER";
+    /**
+     * Libero only. When a teammate's touch would lose the rally (a reception/dig error, a set error, or a failed
+     * dig of a blocked-back ball) and a save is still legal, a small chance the libero digs it into a neutral free
+     * ball, keeping the rally alive (over the net, or staying on side, depending on the touch).
+     */
+    TraitEnum["LAST_RESORT"] = "LAST_RESORT";
 })(TraitEnum || (exports.TraitEnum = TraitEnum = {}));
 function assignTraits(roles, rarity, maxTraits) {
     let traitCount;
@@ -82,7 +134,9 @@ function assignTraits(roles, rarity, maxTraits) {
         return [];
     const filteredTraits = traits.filter((trait) => {
         const setA = new Set(trait.roles);
-        return roles.some(el => setA.has(el));
+        const roleMatch = roles.some(el => setA.has(el));
+        const rarityOk = trait.maxRarity == null || RARITY_RANK[rarity] <= RARITY_RANK[trait.maxRarity];
+        return roleMatch && rarityOk;
     }).map(trait => trait.name);
     return (0, utils_1.shuffle)(filteredTraits).slice(0, traitCount);
 }

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

@@ -90,5 +90,92 @@
             "OUTSIDE_HITTER",
             "MIDDLE_BLOCKER"
         ]
+    },
+    {
+        "name": "QUICK_LEARNER",
+        "chance": 1,
+        "roles": [
+            "SETTER",
+            "LIBERO",
+            "OUTSIDE_HITTER"
+        ]
+    },
+    {
+        "name": "MOMENTUM_ADDICT",
+        "chance": 1,
+        "roles": [
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER"
+        ]
+    },
+    {
+        "name": "LOUDMOUTH",
+        "chance": 0.3333,
+        "roles": [
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "TRUE_LEADER",
+        "chance": 0.3,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "OVERACHIEVER",
+        "chance": 0.2,
+        "maxRarity": "MYTHIC",
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "CRAFTY",
+        "chance": 0.25,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "TENACIOUS",
+        "chance": 1,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "HUNTER",
+        "chance": 0.15,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "LAST_RESORT",
+        "chance": 0.05,
+        "roles": [
+            "LIBERO"
+        ]
     }
 ]

package/dist/esm/src/service/event/event-types.d.ts

@@ -1,7 +1,8 @@
 import type { BlockFailure, BlockType } from './block';
+import type { FreeBallFailure, FreeBallType } from './free-ball';
 import type { ReceptionFailure, ReceptionType } from './reception';
 import type { ServeFailure, ServeType } from './serve';
 import type { SetFailure, SetType } from './set';
 import type { SpikeFailure, SpikeType } from './spike';
-export type EventSubType = BlockType | ReceptionType | ServeType | SetType | SpikeType;
-export type EventFailureType = BlockFailure | ReceptionFailure | ServeFailure | SetFailure | SpikeFailure;
+export type EventSubType = BlockType | FreeBallType | ReceptionType | ServeType | SetType | SpikeType;
+export type EventFailureType = BlockFailure | FreeBallFailure | ReceptionFailure | ServeFailure | SetFailure | SpikeFailure;

package/dist/esm/src/service/event/free-ball.d.ts

@@ -0,0 +1,17 @@
+import { InPlayEvent } from './in-play-event';
+export declare enum FreeBallTypeEnum {
+    OVER = 0,
+    STAY = 1
+}
+export type FreeBallType = FreeBallTypeEnum.OVER | FreeBallTypeEnum.STAY;
+export declare enum FreeBallFailureEnum {
+    NO_FAILURE = 0
+}
+export type FreeBallFailure = FreeBallFailureEnum.NO_FAILURE;
+export declare class FreeBall extends InPlayEvent<FreeBallFailure, FreeBallType> {
+    readonly failure: FreeBallFailure;
+    readonly type: FreeBallType;
+    static create(input: unknown): FreeBall;
+    private constructor();
+    toString(): string;
+}

package/dist/esm/src/service/event/free-ball.js

@@ -0,0 +1,43 @@
+import { EventTypeEnum } from './rally-event';
+import { InPlayEvent } from './in-play-event';
+import { FreeBallInputSchema } from './schemas/free-ball.z';
+export var FreeBallTypeEnum;
+(function (FreeBallTypeEnum) {
+    // The save sent the ball over the net as a free ball -- the opponent plays it out.
+    FreeBallTypeEnum[FreeBallTypeEnum["OVER"] = 0] = "OVER";
+    // The save kept the ball on the team's side -- the team plays out its remaining touch(es).
+    FreeBallTypeEnum[FreeBallTypeEnum["STAY"] = 1] = "STAY";
+})(FreeBallTypeEnum || (FreeBallTypeEnum = {}));
+export var FreeBallFailureEnum;
+(function (FreeBallFailureEnum) {
+    // A Last Resort save is guaranteed -- it always produces a free ball, never an error.
+    FreeBallFailureEnum[FreeBallFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+})(FreeBallFailureEnum || (FreeBallFailureEnum = {}));
+const eventType = EventTypeEnum.FREE_BALL;
+// A FREE_BALL event is a Last Resort save: the libero digs a ball that would otherwise have lost the rally and
+// puts it back in play as a neutral free ball (over to the opponent, or staying on side). It is a real in-play
+// event (score + target) so the next receiver handles it like any free ball.
+export class FreeBall extends InPlayEvent {
+    static create(input) {
+        const result = FreeBallInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_FREE_BALL: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new FreeBall(result.data);
+    }
+    constructor({ score, playerId, target, failure, type, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        return `{${this._toString()},${failure},${type}}`;
+    }
+}

package/dist/esm/src/service/event/index.d.ts

@@ -1,5 +1,6 @@
 export * from './block';
 export * from './event-types';
+export * from './free-ball';
 export * from './in-play-event';
 export * from './libero-replacement';
 export * from './rally-event';

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

@@ -1,5 +1,6 @@
 export * from './block';
 export * from './event-types';
+export * from './free-ball';
 export * from './in-play-event';
 export * from './libero-replacement';
 export * from './rally-event';

package/dist/esm/src/service/event/rally-event.d.ts

@@ -5,9 +5,10 @@ export declare enum EventTypeEnum {
     RECEPTION = 3,
     SET = 4,
     SPIKE = 5,
-    BLOCK = 6
+    BLOCK = 6,
+    FREE_BALL = 7
 }
-export type EventType = EventTypeEnum.LIBERO_REPLACEMENT | EventTypeEnum.SUBSTITUTION | EventTypeEnum.SERVE | EventTypeEnum.RECEPTION | EventTypeEnum.SET | EventTypeEnum.SPIKE | EventTypeEnum.BLOCK;
+export type EventType = EventTypeEnum.LIBERO_REPLACEMENT | EventTypeEnum.SUBSTITUTION | EventTypeEnum.SERVE | EventTypeEnum.RECEPTION | EventTypeEnum.SET | EventTypeEnum.SPIKE | EventTypeEnum.BLOCK | EventTypeEnum.FREE_BALL;
 export interface RallyEventOpts {
     readonly playerId: string;
     readonly eventType: EventType;

package/dist/esm/src/service/event/rally-event.js

@@ -7,6 +7,7 @@ export var EventTypeEnum;
     EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
     EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
     EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+    EventTypeEnum[EventTypeEnum["FREE_BALL"] = 7] = "FREE_BALL";
 })(EventTypeEnum || (EventTypeEnum = {}));
 export class RallyEvent {
     constructor({ eventType, playerId }) {

package/dist/esm/src/service/event/schemas/block.z.d.ts

@@ -14,6 +14,15 @@ export declare const BlockInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/esm/src/service/event/schemas/free-ball.z.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const FreeBallInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        MASTER_MIND: TraitEnum.MASTER_MIND;
+        MOVING_WALL: TraitEnum.MOVING_WALL;
+        SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
+        MARKSMAN: TraitEnum.MARKSMAN;
+        METEOR_SERVE: TraitEnum.METEOR_SERVE;
+        VIGOROUS: TraitEnum.VIGOROUS;
+        GUARDIAN: TraitEnum.GUARDIAN;
+        FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
+        DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
+    }>>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+}, z.core.$strip>;
+export type FreeBallInput = z.infer<typeof FreeBallInputSchema>;

package/dist/esm/src/service/event/schemas/free-ball.z.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+const freeBallTypeValues = [0, 1];
+const freeBallFailureValues = [0];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+export const FreeBallInputSchema = z.object({
+    playerId: z.uuid(),
+    score: z.number().finite(),
+    target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
+    failure: z.number().int().refine((v) => freeBallFailureValues.includes(v), { message: 'INVALID_FREE_BALL_FAILURE' }),
+    type: z.number().int().refine((v) => freeBallTypeValues.includes(v), { message: 'INVALID_FREE_BALL_TYPE' })
+});

package/dist/esm/src/service/event/schemas/reception.z.d.ts

@@ -14,6 +14,15 @@ export declare const ReceptionInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/esm/src/service/event/schemas/serve.z.d.ts

@@ -14,6 +14,15 @@ export declare const ServeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/esm/src/service/event/schemas/set.z.d.ts

@@ -14,6 +14,15 @@ export declare const SetInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

package/dist/esm/src/service/event/schemas/spike.z.d.ts

@@ -14,6 +14,15 @@ export declare const SpikeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;

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

@@ -53,6 +53,15 @@ export declare const PlayerInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+        QUICK_LEARNER: TraitEnum.QUICK_LEARNER;
+        MOMENTUM_ADDICT: TraitEnum.MOMENTUM_ADDICT;
+        LOUDMOUTH: TraitEnum.LOUDMOUTH;
+        TRUE_LEADER: TraitEnum.TRUE_LEADER;
+        OVERACHIEVER: TraitEnum.OVERACHIEVER;
+        CRAFTY: TraitEnum.CRAFTY;
+        TENACIOUS: TraitEnum.TENACIOUS;
+        HUNTER: TraitEnum.HUNTER;
+        LAST_RESORT: TraitEnum.LAST_RESORT;
     }>>;
     rarity: z.ZodEnum<{
         COMMON: RarityEnum.COMMON;

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

@@ -5,6 +5,7 @@ interface TraitProps {
     readonly modifier?: number;
     readonly chance: number;
     readonly roles: Role[];
+    readonly maxRarity?: Rarity;
 }
 export declare enum TraitEnum {
     /**
@@ -45,9 +46,53 @@ export declare enum TraitEnum {
     /**
      * Gives the player a chance to perform a perfect reception.
      */
-    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
+    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST",
+    /**
+     * Three good receptions/digs/sets in a row make the next reception/dig/set a guaranteed critical that
+     * cannot fail.
+     */
+    QUICK_LEARNER = "QUICK_LEARNER",
+    /**
+     * Each successful attack ramps up the spike, and a kill ramps it more. Starts with a small penalty and
+     * resets on an attacking error.
+     */
+    MOMENTUM_ADDICT = "MOMENTUM_ADDICT",
+    /**
+     * A front-row kill demoralizes the opponents who faced it, debuffing them for a few rallies.
+     */
+    LOUDMOUTH = "LOUDMOUTH",
+    /**
+     * When a teammate makes a non-block mistake, that teammate's next action cannot fail.
+     */
+    TRUE_LEADER = "TRUE_LEADER",
+    /**
+     * Reacting to a strong opponent action (block/receive), this player can rise to match it. Limited to
+     * Mythic rarity and below.
+     */
+    OVERACHIEVER = "OVERACHIEVER",
+    /**
+     * Opponents who interact with this player's serve or attack spend twice the energy (VIGOROUS is nullified).
+     */
+    CRAFTY = "CRAFTY",
+    /**
+     * When the team loses several points in a row, the whole on-court team gets a buff that grows with the
+     * streak and disappears the moment they win a point.
+     */
+    TENACIOUS = "TENACIOUS",
+    /**
+     * Serve trait, rolled before the ambient setter/opposite hunt: a chance to serve a precise target (the
+     * setter, opposite, or best back-row attacker, depending on serve type and rotation), bypassing GUARDIAN,
+     * with a slight serve bonus and reducing the hunted player's attack involvement that rally.
+     */
+    HUNTER = "HUNTER",
+    /**
+     * Libero only. When a teammate's touch would lose the rally (a reception/dig error, a set error, or a failed
+     * dig of a blocked-back ball) and a save is still legal, a small chance the libero digs it into a neutral free
+     * ball, keeping the rally alive (over the net, or staying on side, depending on the touch).
+     */
+    LAST_RESORT = "LAST_RESORT"
 }
-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 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 | TraitEnum.QUICK_LEARNER | TraitEnum.MOMENTUM_ADDICT | TraitEnum.LOUDMOUTH | TraitEnum.TRUE_LEADER | TraitEnum.OVERACHIEVER | TraitEnum.CRAFTY | TraitEnum.TENACIOUS | TraitEnum.HUNTER | TraitEnum.LAST_RESORT;
 export declare function assignTraits(roles: Role[], rarity: Rarity, maxTraits?: boolean): Trait[];
 export declare const traitMap: Map<Trait, TraitProps>;
 export {};

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

@@ -3,6 +3,14 @@ import { randomInt } from 'node:crypto';
 import rawTraits from '../../stat-config/traits.json';
 import { shuffle } from '../utils';
 const traits = rawTraits;
+// Ascending rarity order, used by the maxRarity trait-eligibility gate in assignTraits.
+const RARITY_RANK = {
+    [RarityEnum.COMMON]: 0,
+    [RarityEnum.RARE]: 1,
+    [RarityEnum.LEGENDARY]: 2,
+    [RarityEnum.MYTHIC]: 3,
+    [RarityEnum.SPECIAL]: 4
+};
 export var TraitEnum;
 (function (TraitEnum) {
     /**
@@ -44,6 +52,50 @@ export var TraitEnum;
      * Gives the player a chance to perform a perfect reception.
      */
     TraitEnum["DEFENSIVE_SPECIALIST"] = "DEFENSIVE_SPECIALIST";
+    /**
+     * Three good receptions/digs/sets in a row make the next reception/dig/set a guaranteed critical that
+     * cannot fail.
+     */
+    TraitEnum["QUICK_LEARNER"] = "QUICK_LEARNER";
+    /**
+     * Each successful attack ramps up the spike, and a kill ramps it more. Starts with a small penalty and
+     * resets on an attacking error.
+     */
+    TraitEnum["MOMENTUM_ADDICT"] = "MOMENTUM_ADDICT";
+    /**
+     * A front-row kill demoralizes the opponents who faced it, debuffing them for a few rallies.
+     */
+    TraitEnum["LOUDMOUTH"] = "LOUDMOUTH";
+    /**
+     * When a teammate makes a non-block mistake, that teammate's next action cannot fail.
+     */
+    TraitEnum["TRUE_LEADER"] = "TRUE_LEADER";
+    /**
+     * Reacting to a strong opponent action (block/receive), this player can rise to match it. Limited to
+     * Mythic rarity and below.
+     */
+    TraitEnum["OVERACHIEVER"] = "OVERACHIEVER";
+    /**
+     * Opponents who interact with this player's serve or attack spend twice the energy (VIGOROUS is nullified).
+     */
+    TraitEnum["CRAFTY"] = "CRAFTY";
+    /**
+     * When the team loses several points in a row, the whole on-court team gets a buff that grows with the
+     * streak and disappears the moment they win a point.
+     */
+    TraitEnum["TENACIOUS"] = "TENACIOUS";
+    /**
+     * Serve trait, rolled before the ambient setter/opposite hunt: a chance to serve a precise target (the
+     * setter, opposite, or best back-row attacker, depending on serve type and rotation), bypassing GUARDIAN,
+     * with a slight serve bonus and reducing the hunted player's attack involvement that rally.
+     */
+    TraitEnum["HUNTER"] = "HUNTER";
+    /**
+     * Libero only. When a teammate's touch would lose the rally (a reception/dig error, a set error, or a failed
+     * dig of a blocked-back ball) and a save is still legal, a small chance the libero digs it into a neutral free
+     * ball, keeping the rally alive (over the net, or staying on side, depending on the touch).
+     */
+    TraitEnum["LAST_RESORT"] = "LAST_RESORT";
 })(TraitEnum || (TraitEnum = {}));
 export function assignTraits(roles, rarity, maxTraits) {
     let traitCount;
@@ -75,7 +127,9 @@ export function assignTraits(roles, rarity, maxTraits) {
         return [];
     const filteredTraits = traits.filter((trait) => {
         const setA = new Set(trait.roles);
-        return roles.some(el => setA.has(el));
+        const roleMatch = roles.some(el => setA.has(el));
+        const rarityOk = trait.maxRarity == null || RARITY_RANK[rarity] <= RARITY_RANK[trait.maxRarity];
+        return roleMatch && rarityOk;
     }).map(trait => trait.name);
     return shuffle(filteredTraits).slice(0, traitCount);
 }

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

@@ -90,5 +90,92 @@
             "OUTSIDE_HITTER",
             "MIDDLE_BLOCKER"
         ]
+    },
+    {
+        "name": "QUICK_LEARNER",
+        "chance": 1,
+        "roles": [
+            "SETTER",
+            "LIBERO",
+            "OUTSIDE_HITTER"
+        ]
+    },
+    {
+        "name": "MOMENTUM_ADDICT",
+        "chance": 1,
+        "roles": [
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER"
+        ]
+    },
+    {
+        "name": "LOUDMOUTH",
+        "chance": 0.3333,
+        "roles": [
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "TRUE_LEADER",
+        "chance": 0.3,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "OVERACHIEVER",
+        "chance": 0.2,
+        "maxRarity": "MYTHIC",
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "CRAFTY",
+        "chance": 0.25,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "TENACIOUS",
+        "chance": 1,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER",
+            "LIBERO"
+        ]
+    },
+    {
+        "name": "HUNTER",
+        "chance": 0.15,
+        "roles": [
+            "SETTER",
+            "OUTSIDE_HITTER",
+            "OPPOSITE_HITTER",
+            "MIDDLE_BLOCKER"
+        ]
+    },
+    {
+        "name": "LAST_RESORT",
+        "chance": 0.05,
+        "roles": [
+            "LIBERO"
+        ]
     }
 ]

package/package.json

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