volleyballsimtypes 0.0.139 → 0.0.141

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

@@ -1,28 +0,0 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { PerformanceStats, Trait } from '../player';
-export declare enum ServeTypeEnum {
-    UNDERHAND = 0,
-    OVERHAND_TOPSPIN = 1,
-    OVERHAND_FLOAT = 2,
-    JUMP_TOPSPIN = 3,
-    JUMP_FLOAT = 4
-}
-export declare enum ServeFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    NET = 3,
-    OUT_OF_BOUNDS = 4
-}
-interface ServeOpts extends InPlayEventOpts {
-    readonly type: ServeTypeEnum;
-    readonly failure: ServeFailureEnum;
-}
-export declare class Serve extends InPlayEvent {
-    readonly failure: ServeFailureEnum;
-    readonly type: ServeTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
-    static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

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

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serve = exports.ServeFailureEnum = exports.ServeTypeEnum = void 0;
-const in_play_event_1 = require("./in-play-event");
-var ServeTypeEnum;
-(function (ServeTypeEnum) {
-    ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
-    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
-})(ServeTypeEnum = exports.ServeTypeEnum || (exports.ServeTypeEnum = {}));
-var ServeFailureEnum;
-(function (ServeFailureEnum) {
-    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
-    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
-    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
-    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(ServeFailureEnum = exports.ServeFailureEnum || (exports.ServeFailureEnum = {}));
-class Serve 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 = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            score *= trait.modifier;
-        }
-        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.Serve = Serve;

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

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

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

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Set = exports.SetFailureEnum = exports.SetTypeEnum = void 0;
-const player_1 = require("../player");
-const in_play_event_1 = require("./in-play-event");
-var SetTypeEnum;
-(function (SetTypeEnum) {
-    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
-    SetTypeEnum[SetTypeEnum["UNDERHAND"] = 1] = "UNDERHAND";
-    SetTypeEnum[SetTypeEnum["SPIKE"] = 2] = "SPIKE";
-    SetTypeEnum[SetTypeEnum["DUMP"] = 3] = "DUMP";
-})(SetTypeEnum = exports.SetTypeEnum || (exports.SetTypeEnum = {}));
-var SetFailureEnum;
-(function (SetFailureEnum) {
-    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
-    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
-    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
-    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(SetFailureEnum = exports.SetFailureEnum || (exports.SetFailureEnum = {}));
-class Set 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 = Set.calculateScore(stats, 'SET', SetTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.MASTER_MIND: {
-                    score *= player_1.Trait.MASTER_MIND.modifier;
-                    break;
-                }
-                case trait === player_1.Trait.MARKSMAN: {
-                    if ([SetTypeEnum.DUMP, SetTypeEnum.SPIKE].includes(type))
-                        score *= player_1.Trait.MARKSMAN.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.Set = Set;

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

@@ -1,29 +0,0 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { Player, Trait } from '../player';
-export declare enum SpikeTypeEnum {
-    CROSS_SHOT = 0,
-    LINE_SHOT = 1,
-    TOOL_SHOT = 2,
-    TIP = 3,
-    DOWN_BALL = 4,
-    OVERHAND = 5
-}
-export declare enum SpikeFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    NET = 4
-}
-interface SpikeOpts extends InPlayEventOpts {
-    readonly type: SpikeTypeEnum;
-    readonly failure: SpikeFailureEnum;
-}
-export declare class Spike extends InPlayEvent {
-    readonly failure: SpikeFailureEnum;
-    readonly type: SpikeTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
-    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Spike = exports.SpikeFailureEnum = exports.SpikeTypeEnum = void 0;
-const in_play_event_1 = require("./in-play-event");
-const player_1 = require("../player");
-var SpikeTypeEnum;
-(function (SpikeTypeEnum) {
-    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["TOOL_SHOT"] = 2] = "TOOL_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
-    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
-    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
-})(SpikeTypeEnum = exports.SpikeTypeEnum || (exports.SpikeTypeEnum = {}));
-var SpikeFailureEnum;
-(function (SpikeFailureEnum) {
-    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
-    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
-    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
-})(SpikeFailureEnum = exports.SpikeFailureEnum || (exports.SpikeFailureEnum = {}));
-class Spike 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(player, type, modifier, isBackRow, activeTraits) {
-        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeTypeEnum[type]);
-        if (![SpikeTypeEnum.DOWN_BALL, SpikeTypeEnum.OVERHAND, SpikeTypeEnum.TIP].includes(type) && isBackRow) {
-            score = score * 0.7 + player.stats.backAttack * 0.3;
-        }
-        score *= modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.MASTER_MIND: {
-                    score *= player_1.Trait.MASTER_MIND.modifier;
-                    break;
-                }
-                case trait === player_1.Trait.MARKSMAN: {
-                    score *= player_1.Trait.MARKSMAN.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.Spike = Spike;

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

@@ -1,11 +0,0 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Player } from '../player';
-interface SubstitutionOpts extends RallyEventOpts {
-    readonly playerOut: Player;
-}
-export declare class Substitution extends RallyEvent {
-    readonly playerOut: string;
-    constructor({ playerOut, player, eventType }: SubstitutionOpts);
-    toString(): string;
-}
-export {};

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Substitution = void 0;
-const rally_event_1 = require("./rally-event");
-class Substitution extends rally_event_1.RallyEvent {
-    constructor({ playerOut, player, eventType }) {
-        super({ eventType, player });
-        this.playerOut = playerOut.id;
-    }
-    toString() {
-        return `{"player":"${this.player}","playerOut":"${this.playerOut}","eventType":${this.eventType}}`;
-    }
-}
-exports.Substitution = Substitution;

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

@@ -1,11 +0,0 @@
-import { PerformanceStats } from './performance-stats';
-export declare enum GeneralStat {
-    ATTACK = "ATTACK",
-    DEFENSE = "DEFENSE",
-    SERVE = "SERVE",
-    PHYSICAL = "PHYSICAL"
-}
-export declare namespace GeneralStat {
-    function getStats(): GeneralStat[];
-    function calculateScore(performanceStats: PerformanceStats, statName: GeneralStat): number;
-}

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

@@ -1,31 +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.GeneralStat = void 0;
-const stat_formula_json_1 = __importDefault(require("../../../data/stat.formula.json"));
-var GeneralStat;
-(function (GeneralStat) {
-    GeneralStat["ATTACK"] = "ATTACK";
-    GeneralStat["DEFENSE"] = "DEFENSE";
-    GeneralStat["SERVE"] = "SERVE";
-    GeneralStat["PHYSICAL"] = "PHYSICAL";
-})(GeneralStat = exports.GeneralStat || (exports.GeneralStat = {}));
-// eslint-disable-next-line @typescript-eslint/no-namespace
-(function (GeneralStat) {
-    const STATS = [GeneralStat.ATTACK, GeneralStat.DEFENSE, GeneralStat.SERVE, GeneralStat.PHYSICAL];
-    function getStats() {
-        return [...STATS];
-    }
-    GeneralStat.getStats = getStats;
-    function calculateScore(performanceStats, statName) {
-        const weights = stat_formula_json_1.default.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);
-    }
-    GeneralStat.calculateScore = calculateScore;
-})(GeneralStat = exports.GeneralStat || (exports.GeneralStat = {}));

package/dist/esm/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/esm/src/service/event/block.js

@@ -1,64 +0,0 @@
-import { InPlayEvent } from './in-play-event';
-import { Trait } from '../player';
-export 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 || (BlockFailureEnum = {}));
-export 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 || (BlockTypeEnum = {}));
-export class Block extends 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 === Trait.MOVING_WALL: {
-                    score *= 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(',')}]}`;
-    }
-}

package/dist/esm/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/esm/src/service/event/in-play-event.js

@@ -1,20 +0,0 @@
-import { RallyEvent } from './rally-event';
-import formula from '../../../data/event.formula.json';
-import { getKeys } from '../utils';
-export class InPlayEvent extends 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 = formula[eventType][type];
-        const penalty = weight.penalty ?? 0;
-        const score = getKeys(weight).reduce((score, key) => {
-            return score + (key === 'penalty' ? 0 : stats[key] * weight[key]);
-        }, 0);
-        return Math.round(score * (1 - penalty));
-    }
-}

package/dist/esm/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/esm/src/service/event/libero-replacement.js

@@ -1,16 +0,0 @@
-import { RallyEvent } from './rally-event';
-export var LiberoReplacementTypeEnum;
-(function (LiberoReplacementTypeEnum) {
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
-})(LiberoReplacementTypeEnum || (LiberoReplacementTypeEnum = {}));
-export class LiberoReplacement extends 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}"}`;
-    }
-}

package/dist/esm/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/esm/src/service/event/reception.js

@@ -1,39 +0,0 @@
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export 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 || (ReceptionTypeEnum = {}));
-export 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 || (ReceptionFailureEnum = {}));
-export class Reception extends 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 === Trait.GUARDIAN: {
-                    score *= 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(',')}]}`;
-    }
-}

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

@@ -1,28 +0,0 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { PerformanceStats, Trait } from '../player';
-export declare enum ServeTypeEnum {
-    UNDERHAND = 0,
-    OVERHAND_TOPSPIN = 1,
-    OVERHAND_FLOAT = 2,
-    JUMP_TOPSPIN = 3,
-    JUMP_FLOAT = 4
-}
-export declare enum ServeFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    NET = 3,
-    OUT_OF_BOUNDS = 4
-}
-interface ServeOpts extends InPlayEventOpts {
-    readonly type: ServeTypeEnum;
-    readonly failure: ServeFailureEnum;
-}
-export declare class Serve extends InPlayEvent {
-    readonly failure: ServeFailureEnum;
-    readonly type: ServeTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
-    static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

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

@@ -1,34 +0,0 @@
-import { InPlayEvent } from './in-play-event';
-export var ServeTypeEnum;
-(function (ServeTypeEnum) {
-    ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
-    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
-})(ServeTypeEnum || (ServeTypeEnum = {}));
-export var ServeFailureEnum;
-(function (ServeFailureEnum) {
-    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
-    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
-    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
-    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(ServeFailureEnum || (ServeFailureEnum = {}));
-export class Serve extends 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 = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            score *= trait.modifier;
-        }
-        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(',')}]}`;
-    }
-}

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

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