volleyballsimtypes 0.0.139 → 0.0.141

package/dist/esm/formula/events.d.ts

@@ -0,0 +1,125 @@
+export declare const eventsFormula: {
+    SERVE: {
+        UNDERHAND: {
+            serve: number;
+            penalty: number;
+        };
+        OVERHAND_TOPSPIN: {
+            serve: number;
+            penalty: number;
+        };
+        OVERHAND_FLOAT: {
+            serve: number;
+            penalty: number;
+        };
+        JUMP_TOPSPIN: {
+            serve: number;
+            jump: number;
+            penalty: number;
+        };
+        JUMP_FLOAT: {
+            serve: number;
+            jump: number;
+        };
+    };
+    RECEPTION: {
+        DIG: {
+            defense: number;
+            reception: number;
+            pass: number;
+        };
+        OVERHAND: {
+            defense: number;
+            reception: number;
+            pass: number;
+            penalty: number;
+        };
+        ONE_HAND: {
+            defense: number;
+            reception: number;
+            pass: number;
+            penalty: number;
+        };
+        OTHER_BODY_PART: {
+            defense: number;
+            reception: number;
+            penalty: number;
+        };
+    };
+    SET: {
+        OVERHAND: {
+            setting: number;
+            pass: number;
+            awareness: number;
+        };
+        UNDERHAND: {
+            setting: number;
+            pass: number;
+            reception: number;
+            penalty: number;
+        };
+        SPIKE: {
+            spike: number;
+            jump: number;
+            awareness: number;
+        };
+        DUMP: {
+            spike: number;
+            jump: number;
+            awareness: number;
+        };
+    };
+    SPIKE: {
+        CROSS_SHOT: {
+            spike: number;
+            jump: number;
+        };
+        LINE_SHOT: {
+            spike: number;
+            jump: number;
+            awareness: number;
+        };
+        TOOL_SHOT: {
+            spike: number;
+            jump: number;
+            awareness: number;
+        };
+        TIP: {
+            spike: number;
+            jump: number;
+            awareness: number;
+        };
+        DOWN_BALL: {
+            spike: number;
+            serve: number;
+            penalty: number;
+        };
+        OVERHAND: {
+            serve: number;
+            pass: number;
+            awareness: number;
+            penalty: number;
+        };
+    };
+    BLOCK: {
+        NO_BLOCKER: {
+            block: number;
+            penalty: number;
+        };
+        SINGLE: {
+            jump: number;
+            block: number;
+            defense: number;
+        };
+        DOUBLE: {
+            jump: number;
+            block: number;
+            defense: number;
+        };
+        TRIPLE: {
+            jump: number;
+            block: number;
+            defense: number;
+        };
+    };
+};

package/dist/esm/formula/events.js

@@ -0,0 +1,2 @@
+import events from './event.formula.json';
+export const eventsFormula = events;

package/dist/esm/formula/index.d.ts

@@ -0,0 +1,3 @@
+export * from './stats';
+export * from './events';
+export * from './roles';

package/dist/esm/formula/index.js

@@ -0,0 +1,3 @@
+export * from './stats';
+export * from './events';
+export * from './roles';

package/dist/esm/formula/roles.d.ts

@@ -0,0 +1,20 @@
+export declare const ALL_ROLES: string[];
+export type RolesTuple = typeof ALL_ROLES;
+export type Roles = RolesTuple[number];
+export interface RolesFormula {
+    'role': Roles;
+    'weight': {
+        'serve': number;
+        'setting': number;
+        'pass': number;
+        'reception': number;
+        'spike': number;
+        'backAttack': number;
+        'jump': number;
+        'block': number;
+        'awareness': number;
+        'defense': number;
+        'stamina': number;
+    };
+}
+export declare const rolesFormula: RolesFormula[];

package/dist/esm/formula/roles.js

@@ -0,0 +1,3 @@
+import roles from './role.formula.json';
+export const ALL_ROLES = ['SETTER', 'LIBERO', 'OUTSIDE_HITTER', 'OPPOSITE_HITTER', 'MIDDLE_BLOCKER', 'DEFENSIVE_SPECIALIST'];
+export const rolesFormula = roles;

package/dist/esm/formula/stats.d.ts

@@ -0,0 +1,22 @@
+import { PerformanceStats } from '../service';
+export declare const ALL_STATS: string[];
+export type StatsTuple = typeof ALL_STATS;
+export type Stats = StatsTuple[number];
+export interface StatFormula {
+    statName: Stats;
+    weight: {
+        serve: number;
+        setting: number;
+        pass: number;
+        reception: number;
+        spike: number;
+        backAttack: number;
+        jump: number;
+        block: number;
+        awareness: number;
+        defense: number;
+        stamina: number;
+    };
+}
+export declare const statsFormula: StatFormula[];
+export declare function calculateScore(performanceStats: PerformanceStats, statName: Stats): number;

package/dist/esm/formula/stats.js

@@ -0,0 +1,11 @@
+import stats from './stat.formula.json';
+export const ALL_STATS = ['ATTACK', 'DEFENSE', 'SERVE', 'PHYSICAL'];
+export const statsFormula = stats;
+export function calculateScore(performanceStats, statName) {
+    const weights = stats.find((s) => s.statName === statName);
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const score = Object.entries(weights.weight)
+        .reduce((score, [key, value]) => score + (performanceStats[key] * value), 0);
+    return Math.round(score);
+}

package/dist/esm/{src/service → service}/player/index.d.ts

@@ -2,4 +2,3 @@ export * from './player';
 export * from './performance-stats';
 export * from './role';
 export * from './trait';
-export * from './stats';

package/dist/esm/{src/service → service}/player/index.js

@@ -2,4 +2,3 @@ export * from './player';
 export * from './performance-stats';
 export * from './role';
 export * from './trait';
-export * from './stats';

package/dist/{cjs/src → esm}/service/player/player.d.ts

@@ -2,12 +2,12 @@ import { PerformanceStats } from './performance-stats';
 import { Role } from './role';
 import { Trait } from './trait';
 import { Country } from '../country';
-import { GeneralStat } from './stats';
+import * as GeneralStat from '../../formula/stats';
 export declare class Stat {
-    readonly name: GeneralStat;
+    readonly name: GeneralStat.Stats;
     readonly value: number;
     constructor({ name, value }: {
-        name: GeneralStat;
+        name: GeneralStat.Stats;
         value: number;
     });
     toString(): string;

package/dist/esm/{src/service → service}/player/player.js

@@ -1,6 +1,6 @@
 import { Role } from './role';
 import { validateUUID } from '../utils';
-import { GeneralStat } from './stats';
+import * as GeneralStat from '../../formula/stats';
 export class Stat {
     constructor({ name, value }) {
         this.name = name;
@@ -28,8 +28,7 @@ export class Player {
         this.stats = stats;
         this.roles = roles;
         this.traits = traits;
-        this.generalStats = GeneralStat.getStats()
-            .map(stat => ({
+        this.generalStats = GeneralStat.ALL_STATS.map(stat => ({
             name: stat,
             value: GeneralStat.calculateScore(stats, stat)
         }));
@@ -46,16 +45,16 @@ export class Player {
         const compareFn = (acc, current) => {
             let x = current.value;
             switch (current.name) {
-                case GeneralStat.ATTACK:
+                case 'ATTACK':
                     x *= 0.35;
                     break;
-                case GeneralStat.DEFENSE:
+                case 'DEFENSE':
                     x *= 0.35;
                     break;
-                case GeneralStat.SERVE:
+                case 'SERVE':
                     x *= 0.2;
                     break;
-                case GeneralStat.PHYSICAL:
+                case 'PHYSICAL':
                     x *= 0.1;
                     break;
                 default:

package/dist/esm/{src/service → service}/player/role.d.ts

@@ -1,5 +1,5 @@
+import { Roles } from '../../formula';
 import { PerformanceStats } from './performance-stats';
-import { RoleType } from '../../data';
 export declare class Role {
     static readonly SETTER: Role;
     static readonly LIBERO: Role;
@@ -8,7 +8,7 @@ export declare class Role {
     static readonly MIDDLE_BLOCKER: Role;
     static readonly DEFENSIVE_SPECIALIST: Role;
     private static readonly ROLES;
-    readonly name: RoleType;
+    readonly name: Roles;
     private constructor();
     toString(): string;
     static getRoles(): Role[];

package/dist/esm/{src/service → service}/player/role.js

@@ -1,4 +1,4 @@
-import roleWeights from '../../../data/role.formula.json';
+import { rolesFormula } from '../../formula';
 export class Role {
     constructor(name) {
         this.name = name;
@@ -10,7 +10,7 @@ export class Role {
         return [...Role.ROLES];
     }
     static calculateScore(stats, role) {
-        const weights = roleWeights.find(r => r.role === role.name);
+        const weights = rolesFormula.find(r => r.role === role.name);
         if (weights == null)
             throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
         const score = Object.entries(weights.weight)

package/dist/esm/{src/service → service}/player/trait.d.ts

@@ -1,4 +1,4 @@
-import { GeneralStat } from './stats';
+import * as GeneralStat from '../../formula/stats';
 import { PerformanceStats } from './performance-stats';
 export declare class Trait {
     static readonly MASTER_MIND: Trait;
@@ -12,7 +12,7 @@ export declare class Trait {
     readonly modifier: number;
     readonly chance: number;
     readonly statThreshold: number;
-    readonly stat: GeneralStat;
+    readonly stat: GeneralStat.Stats;
     readonly weight: number;
     private constructor();
     static getTraits(): Trait[];

package/dist/esm/{src/service → service}/player/trait.js

@@ -1,4 +1,4 @@
-import { GeneralStat } from './stats';
+import * as GeneralStat from '../../formula/stats';
 export class Trait {
     constructor({ id, name, modifier, chance, statThreshold, stat, weight }) {
         this.id = id;
@@ -50,10 +50,10 @@ export class Trait {
 Trait.MASTER_MIND = new Trait({
     id: '0117a315-a743-43e3-9ec2-ad5cf700ef08',
     name: 'Master Mind',
-    modifier: 1.25,
+    modifier: 1.1,
     chance: 0.2,
     statThreshold: 80,
-    stat: GeneralStat.ATTACK,
+    stat: 'ATTACK',
     weight: 10
 });
 // Will always participate in blocking regardless of chance and adds
@@ -63,7 +63,7 @@ Trait.MOVING_WALL = new Trait({
     modifier: 1.1,
     chance: 1,
     statThreshold: 75,
-    stat: GeneralStat.DEFENSE,
+    stat: 'DEFENSE',
     weight: 5
 });
 // On attack, will always pick the worst receiver and adds a 10% to score
@@ -73,7 +73,7 @@ Trait.MARKSMAN = new Trait({
     modifier: 1.01,
     chance: 0.3,
     statThreshold: 75,
-    stat: GeneralStat.ATTACK,
+    stat: 'ATTACK',
     weight: 5
 });
 // Increases the score of the serve by 25% when serve type is Jumping.
@@ -83,7 +83,7 @@ Trait.METEOR_SERVE = new Trait({
     modifier: 1.1,
     chance: 0.1,
     statThreshold: 75,
-    stat: GeneralStat.SERVE,
+    stat: 'SERVE',
     weight: 10
 });
 // Has a 50% chance of taking an action without decreasing energy.
@@ -93,7 +93,7 @@ Trait.VIGOROUS = new Trait({
     modifier: 1,
     statThreshold: 60,
     chance: 0.5,
-    stat: GeneralStat.PHYSICAL,
+    stat: 'PHYSICAL',
     weight: 1
 });
 // Takes place of the receiver and increases reception score by 25%, guaranteeing success. Can only trigger in back-row.
@@ -103,6 +103,6 @@ Trait.GUARDIAN = new Trait({
     chance: 0.25,
     statThreshold: 75,
     modifier: 1.25,
-    stat: GeneralStat.DEFENSE,
+    stat: 'DEFENSE',
     weight: 10
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.139",
+  "version": "0.0.141",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -12,7 +12,7 @@
     "standard": "npx ts-standard --fix",
     "clean": "rimraf dist",
     "validate": "npm run standard && npm run madge",
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
     "preversion": "npm run validate && npm run build",
     "postversion": "git push --follow-tags"
   },

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

@@ -1,30 +0,0 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { Player, Trait } from '../player';
-export declare enum BlockFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    WIPE = 4,
-    TOOL = 5
-}
-export declare enum BlockTypeEnum {
-    NO_BLOCKER = 0,
-    SINGLE = 1,
-    DOUBLE = 2,
-    TRIPLE = 3
-}
-interface BlockOpts extends InPlayEventOpts {
-    readonly type: BlockTypeEnum;
-    readonly failure: BlockFailureEnum;
-    readonly blockers: Player[];
-}
-export declare class Block extends InPlayEvent {
-    readonly failure: BlockFailureEnum;
-    readonly type: BlockTypeEnum;
-    readonly blockers: string[];
-    constructor({ score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
-    static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

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

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Block = exports.BlockTypeEnum = exports.BlockFailureEnum = void 0;
-const in_play_event_1 = require("./in-play-event");
-const player_1 = require("../player");
-var BlockFailureEnum;
-(function (BlockFailureEnum) {
-    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    BlockFailureEnum[BlockFailureEnum["FAULT"] = 1] = "FAULT";
-    BlockFailureEnum[BlockFailureEnum["MISS"] = 2] = "MISS";
-    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
-    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
-})(BlockFailureEnum = exports.BlockFailureEnum || (exports.BlockFailureEnum = {}));
-var BlockTypeEnum;
-(function (BlockTypeEnum) {
-    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
-    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
-    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
-    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
-})(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
-class Block extends in_play_event_1.InPlayEvent {
-    constructor({ score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ score, player, target, modifier, eventType, activeTraits });
-        this.type = type;
-        this.failure = failure;
-        this.blockers = blockers.map(b => b.id);
-    }
-    static getScore(blockers, modifier, activeTraits) {
-        const type = blockers.length;
-        if (blockers.length > 3)
-            throw new Error('UNKNOWN_TYPE');
-        let bmod;
-        switch (type) {
-            case BlockTypeEnum.NO_BLOCKER:
-                return 0;
-            case BlockTypeEnum.SINGLE:
-                bmod = 1;
-                break;
-            case BlockTypeEnum.DOUBLE:
-                bmod = 1.2;
-                break;
-            case BlockTypeEnum.TRIPLE:
-                bmod = 1.4;
-                break;
-            default:
-                throw new Error('UNKNOWN_TYPE');
-        }
-        const total = blockers.reduce((score, player) => {
-            return score + Block.calculateScore(player.stats, 'BLOCK', BlockTypeEnum[type]);
-        }, 0);
-        const avg = total / blockers.length;
-        let score = avg * bmod * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.MOVING_WALL: {
-                    score *= player_1.Trait.MOVING_WALL.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-    toString() {
-        return `{"score":${this.score},"player":"${this.player}","target":${this.target},"failure":${this.failure},"type":${this.type},"modifier":${this.modifier},"eventType":${this.eventType},"blockers":[${this.blockers.map(b => `"${b}"`).join(',')}],"activeTraits":[${this.activeTraits.map(t => `"${t}"`).join(',')}]}`;
-    }
-}
-exports.Block = Block;

package/dist/cjs/src/service/event/in-play-event.d.ts

@@ -1,19 +0,0 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { CourtTargetEnum } from '../match';
-import { PerformanceStats, Trait } from '../player';
-export interface InPlayEventOpts extends RallyEventOpts {
-    readonly target: CourtTargetEnum;
-    readonly modifier: number;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-}
-export declare abstract class InPlayEvent extends RallyEvent {
-    abstract failure: number;
-    abstract type: number;
-    readonly target: CourtTargetEnum;
-    readonly modifier: number;
-    readonly score: number;
-    readonly activeTraits: string[];
-    protected constructor({ eventType, player, target, modifier, score, activeTraits }: InPlayEventOpts);
-    protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
-}

package/dist/cjs/src/service/event/in-play-event.js

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InPlayEvent = void 0;
-const rally_event_1 = require("./rally-event");
-const event_formula_json_1 = __importDefault(require("../../../data/event.formula.json"));
-const utils_1 = require("../utils");
-class InPlayEvent extends rally_event_1.RallyEvent {
-    constructor({ eventType, player, target, modifier, score, activeTraits }) {
-        super({ player, eventType });
-        this.target = target;
-        this.score = score;
-        this.modifier = modifier;
-        this.activeTraits = activeTraits.map(trait => trait.id);
-    }
-    static calculateScore(stats, eventType, type) {
-        const weight = event_formula_json_1.default[eventType][type];
-        const penalty = weight.penalty ?? 0;
-        const score = (0, utils_1.getKeys)(weight).reduce((score, key) => {
-            return score + (key === 'penalty' ? 0 : stats[key] * weight[key]);
-        }, 0);
-        return Math.round(score * (1 - penalty));
-    }
-}
-exports.InPlayEvent = InPlayEvent;

package/dist/cjs/src/service/event/libero-replacement.d.ts

@@ -1,18 +0,0 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Player } from '../player';
-interface LiberoReplacementOpts extends RallyEventOpts {
-    readonly player: Player;
-    readonly libero: Player;
-    readonly type: LiberoReplacementTypeEnum;
-}
-export declare enum LiberoReplacementTypeEnum {
-    LIBERO_IN = 0,
-    LIBERO_OUT = 1
-}
-export declare class LiberoReplacement extends RallyEvent {
-    readonly type: LiberoReplacementTypeEnum;
-    readonly libero: string;
-    constructor({ player, type, libero, eventType }: LiberoReplacementOpts);
-    toString(): string;
-}
-export {};

package/dist/cjs/src/service/event/libero-replacement.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiberoReplacement = exports.LiberoReplacementTypeEnum = void 0;
-const rally_event_1 = require("./rally-event");
-var LiberoReplacementTypeEnum;
-(function (LiberoReplacementTypeEnum) {
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
-})(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
-class LiberoReplacement extends rally_event_1.RallyEvent {
-    constructor({ player, type, libero, eventType }) {
-        super({ player, eventType });
-        this.type = type;
-        this.libero = libero.id;
-    }
-    toString() {
-        return `{"player":"${this.player}","type":${this.type},"eventType":${this.eventType},"libero":"${this.libero}"}`;
-    }
-}
-exports.LiberoReplacement = LiberoReplacement;

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

@@ -1,27 +0,0 @@
-import { PerformanceStats, Trait } from '../player';
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum ReceptionTypeEnum {
-    DIG = 0,
-    OVERHAND = 1,
-    ONE_HAND = 2,
-    OTHER_BODY_PART = 3
-}
-export declare enum ReceptionFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    BAD_PASS = 4
-}
-interface ReceptionOpts extends InPlayEventOpts {
-    readonly type: ReceptionTypeEnum;
-    readonly failure: ReceptionFailureEnum;
-}
-export declare class Reception extends InPlayEvent {
-    readonly failure: ReceptionFailureEnum;
-    readonly type: ReceptionTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
-    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

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

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reception = exports.ReceptionFailureEnum = exports.ReceptionTypeEnum = void 0;
-const player_1 = require("../player");
-const in_play_event_1 = require("./in-play-event");
-var ReceptionTypeEnum;
-(function (ReceptionTypeEnum) {
-    ReceptionTypeEnum[ReceptionTypeEnum["DIG"] = 0] = "DIG";
-    ReceptionTypeEnum[ReceptionTypeEnum["OVERHAND"] = 1] = "OVERHAND";
-    ReceptionTypeEnum[ReceptionTypeEnum["ONE_HAND"] = 2] = "ONE_HAND";
-    ReceptionTypeEnum[ReceptionTypeEnum["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
-})(ReceptionTypeEnum = exports.ReceptionTypeEnum || (exports.ReceptionTypeEnum = {}));
-var ReceptionFailureEnum;
-(function (ReceptionFailureEnum) {
-    ReceptionFailureEnum[ReceptionFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ReceptionFailureEnum[ReceptionFailureEnum["FAULT"] = 1] = "FAULT";
-    ReceptionFailureEnum[ReceptionFailureEnum["MISS"] = 2] = "MISS";
-    ReceptionFailureEnum[ReceptionFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
-})(ReceptionFailureEnum = exports.ReceptionFailureEnum || (exports.ReceptionFailureEnum = {}));
-class Reception extends in_play_event_1.InPlayEvent {
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier, activeTraits) {
-        let score = Reception.calculateScore(stats, 'RECEPTION', ReceptionTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.GUARDIAN: {
-                    score *= player_1.Trait.GUARDIAN.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-    toString() {
-        return `{"score":${this.score},"player":"${this.player}","target":${this.target},"failure":${this.failure},"type":${this.type},"modifier":${this.modifier},"eventType":${this.eventType},"activeTraits":[${this.activeTraits.map(t => `"${t}"`).join(',')}]}`;
-    }
-}
-exports.Reception = Reception;