volleyballsimtypes 0.0.72 → 0.0.74

package/dist/esm/src/service/event/score.test.js

@@ -1,26 +1,26 @@
-import { beforeEach, describe, expect, test } from '@jest/globals';
-import { Score } from './score';
-import { player } from '../player/__stubs__';
-import { team } from '../team/__stubs__';
-import { EventType } from './rally-event';
-describe('Score Test Module', () => {
-    let score;
-    beforeEach(() => {
-        score = new Score({
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            eventType: EventType.SCORE,
-            player: player,
-            team
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(score.eventType).toBe(EventType.SCORE);
-        expect(score.player.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
-        expect(score.team.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
-    });
-    // printEvent Test
-    test('Should print event properly', () => {
-        expect(score.printEvent()).toBe('event: SCORE, team: Yodo [YOD]');
-    });
-});
+import { beforeEach, describe, expect, test } from '@jest/globals';
+import { Score } from './score';
+import { player } from '../player/__stubs__';
+import { team } from '../team/__stubs__';
+import { EventType } from './rally-event';
+describe('Score Test Module', () => {
+    let score;
+    beforeEach(() => {
+        score = new Score({
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            eventType: EventType.SCORE,
+            player: player,
+            team
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(score.eventType).toBe(EventType.SCORE);
+        expect(score.player.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
+        expect(score.team.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
+    });
+    // printEvent Test
+    test('Should print event properly', () => {
+        expect(score.printEvent()).toBe('event: SCORE, team: Yodo [YOD]');
+    });
+});

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

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

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

@@ -1,27 +1,27 @@
-import { InPlayEvent } from './in-play-event';
-export var ServeType;
-(function (ServeType) {
-    ServeType[ServeType["UNDERHAND"] = 0] = "UNDERHAND";
-    ServeType[ServeType["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
-    ServeType[ServeType["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
-    ServeType[ServeType["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
-    ServeType[ServeType["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
-})(ServeType || (ServeType = {}));
-export var ServeFailure;
-(function (ServeFailure) {
-    ServeFailure[ServeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ServeFailure[ServeFailure["FAULT"] = 1] = "FAULT";
-    ServeFailure[ServeFailure["MISS"] = 2] = "MISS";
-    ServeFailure[ServeFailure["NET"] = 3] = "NET";
-    ServeFailure[ServeFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(ServeFailure || (ServeFailure = {}));
-export class Serve extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier) {
-        return Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier;
-    }
-}
+import { InPlayEvent } from './in-play-event';
+export var ServeType;
+(function (ServeType) {
+    ServeType[ServeType["UNDERHAND"] = 0] = "UNDERHAND";
+    ServeType[ServeType["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
+    ServeType[ServeType["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
+    ServeType[ServeType["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
+    ServeType[ServeType["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
+})(ServeType || (ServeType = {}));
+export var ServeFailure;
+(function (ServeFailure) {
+    ServeFailure[ServeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ServeFailure[ServeFailure["FAULT"] = 1] = "FAULT";
+    ServeFailure[ServeFailure["MISS"] = 2] = "MISS";
+    ServeFailure[ServeFailure["NET"] = 3] = "NET";
+    ServeFailure[ServeFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(ServeFailure || (ServeFailure = {}));
+export class Serve extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
+        super({ id, order, score, player, target, eventType, modifier });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier) {
+        return Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier;
+    }
+}

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

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

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

@@ -1,47 +1,47 @@
-import { describe, expect, test } from '@jest/globals';
-import { Serve, ServeFailure, ServeType } from './serve';
-import { player } from '../player/__stubs__';
-import { CourtTarget } from '../match';
-import { EventType } from './rally-event';
-describe('Serve Test Module', () => {
-    let serve;
-    let failed;
-    beforeEach(() => {
-        serve = new Serve({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: ServeFailure.NO_FAILURE,
-            type: ServeType.JUMP_TOPSPIN,
-            eventType: EventType.SERVE,
-            modifier: 1
-        });
-        failed = new Serve({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: ServeFailure.NET,
-            type: ServeType.UNDERHAND,
-            eventType: EventType.SERVE,
-            modifier: 1
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(serve.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(serve.type).toBe(ServeType.JUMP_TOPSPIN);
-        expect(serve.eventType).toBe(EventType.SERVE);
-        expect(serve.player.id).toBe(player.id);
-        expect(serve.failure).toBe(ServeFailure.NO_FAILURE);
-        expect(failed.failure).toBe(ServeFailure.NET);
-        expect(serve.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Serve types', () => {
-        expect(Serve.getScore(serve.player.stats, serve.type, 1)).toBe(6);
-        expect(Serve.getScore(failed.player.stats, failed.type, 1)).toBe(3);
-    });
-});
+import { describe, expect, test } from '@jest/globals';
+import { Serve, ServeFailure, ServeType } from './serve';
+import { player } from '../player/__stubs__';
+import { CourtTarget } from '../match';
+import { EventType } from './rally-event';
+describe('Serve Test Module', () => {
+    let serve;
+    let failed;
+    beforeEach(() => {
+        serve = new Serve({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: ServeFailure.NO_FAILURE,
+            type: ServeType.JUMP_TOPSPIN,
+            eventType: EventType.SERVE,
+            modifier: 1
+        });
+        failed = new Serve({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.NO_TARGET,
+            failure: ServeFailure.NET,
+            type: ServeType.UNDERHAND,
+            eventType: EventType.SERVE,
+            modifier: 1
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(serve.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(serve.type).toBe(ServeType.JUMP_TOPSPIN);
+        expect(serve.eventType).toBe(EventType.SERVE);
+        expect(serve.player.id).toBe(player.id);
+        expect(serve.failure).toBe(ServeFailure.NO_FAILURE);
+        expect(failed.failure).toBe(ServeFailure.NET);
+        expect(serve.modifier).toBe(1);
+    });
+    // getScore Tests
+    test('Should get the correct score for all Serve types', () => {
+        expect(Serve.getScore(serve.player.stats, serve.type, 1)).toBe(6);
+        expect(Serve.getScore(failed.player.stats, failed.type, 1)).toBe(3);
+    });
+});

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

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

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

@@ -1,26 +1,26 @@
-import { InPlayEvent } from './in-play-event';
-export var SetType;
-(function (SetType) {
-    SetType[SetType["OVERHAND"] = 0] = "OVERHAND";
-    SetType[SetType["UNDERHAND"] = 1] = "UNDERHAND";
-    SetType[SetType["SPIKE"] = 2] = "SPIKE";
-    SetType[SetType["DUMP"] = 3] = "DUMP";
-})(SetType || (SetType = {}));
-export var SetFailure;
-(function (SetFailure) {
-    SetFailure[SetFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SetFailure[SetFailure["FAULT"] = 1] = "FAULT";
-    SetFailure[SetFailure["MISS"] = 2] = "MISS";
-    SetFailure[SetFailure["BAD_PASS"] = 3] = "BAD_PASS";
-    SetFailure[SetFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(SetFailure || (SetFailure = {}));
-export class Set extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier) {
-        return Set.calculateScore(stats, 'SET', SetType[type]) * modifier;
-    }
-}
+import { InPlayEvent } from './in-play-event';
+export var SetType;
+(function (SetType) {
+    SetType[SetType["OVERHAND"] = 0] = "OVERHAND";
+    SetType[SetType["UNDERHAND"] = 1] = "UNDERHAND";
+    SetType[SetType["SPIKE"] = 2] = "SPIKE";
+    SetType[SetType["DUMP"] = 3] = "DUMP";
+})(SetType || (SetType = {}));
+export var SetFailure;
+(function (SetFailure) {
+    SetFailure[SetFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SetFailure[SetFailure["FAULT"] = 1] = "FAULT";
+    SetFailure[SetFailure["MISS"] = 2] = "MISS";
+    SetFailure[SetFailure["BAD_PASS"] = 3] = "BAD_PASS";
+    SetFailure[SetFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(SetFailure || (SetFailure = {}));
+export class Set extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
+        super({ id, order, score, player, target, eventType, modifier });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier) {
+        return Set.calculateScore(stats, 'SET', SetType[type]) * modifier;
+    }
+}

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

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

package/dist/esm/src/service/event/set.test.js

@@ -1,47 +1,47 @@
-import { describe, expect, test } from '@jest/globals';
-import { Set, SetFailure, SetType } from './set';
-import { player } from '../player/__stubs__';
-import { CourtTarget } from '../match';
-import { EventType } from './rally-event';
-describe('Set Test Module', () => {
-    let set;
-    let failed;
-    beforeEach(() => {
-        set = new Set({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: SetFailure.NO_FAILURE,
-            type: SetType.OVERHAND,
-            eventType: EventType.SET,
-            modifier: 1
-        });
-        failed = new Set({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: SetFailure.OUT_OF_BOUNDS,
-            type: SetType.DUMP,
-            eventType: EventType.SET,
-            modifier: 1
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(set.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(set.type).toBe(SetType.OVERHAND);
-        expect(set.eventType).toBe(EventType.SET);
-        expect(set.player.id).toBe(player.id);
-        expect(set.failure).toBe(SetFailure.NO_FAILURE);
-        expect(failed.failure).toBe(SetFailure.OUT_OF_BOUNDS);
-        expect(set.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Set types', () => {
-        expect(Set.getScore(set.player.stats, set.type, 1)).toBe(3);
-        expect(Set.getScore(failed.player.stats, failed.type, 1)).toBe(6);
-    });
-});
+import { describe, expect, test } from '@jest/globals';
+import { Set, SetFailure, SetType } from './set';
+import { player } from '../player/__stubs__';
+import { CourtTarget } from '../match';
+import { EventType } from './rally-event';
+describe('Set Test Module', () => {
+    let set;
+    let failed;
+    beforeEach(() => {
+        set = new Set({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: SetFailure.NO_FAILURE,
+            type: SetType.OVERHAND,
+            eventType: EventType.SET,
+            modifier: 1
+        });
+        failed = new Set({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.NO_TARGET,
+            failure: SetFailure.OUT_OF_BOUNDS,
+            type: SetType.DUMP,
+            eventType: EventType.SET,
+            modifier: 1
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(set.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(set.type).toBe(SetType.OVERHAND);
+        expect(set.eventType).toBe(EventType.SET);
+        expect(set.player.id).toBe(player.id);
+        expect(set.failure).toBe(SetFailure.NO_FAILURE);
+        expect(failed.failure).toBe(SetFailure.OUT_OF_BOUNDS);
+        expect(set.modifier).toBe(1);
+    });
+    // getScore Tests
+    test('Should get the correct score for all Set types', () => {
+        expect(Set.getScore(set.player.stats, set.type, 1)).toBe(3);
+        expect(Set.getScore(failed.player.stats, failed.type, 1)).toBe(6);
+    });
+});

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

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

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

@@ -1,32 +1,32 @@
-import { InPlayEvent } from './in-play-event';
-export var SpikeType;
-(function (SpikeType) {
-    SpikeType[SpikeType["CROSS_SHOT"] = 0] = "CROSS_SHOT";
-    SpikeType[SpikeType["LINE_SHOT"] = 1] = "LINE_SHOT";
-    SpikeType[SpikeType["TOOL_SHOT"] = 2] = "TOOL_SHOT";
-    SpikeType[SpikeType["TIP"] = 3] = "TIP";
-    SpikeType[SpikeType["DOWN_BALL"] = 4] = "DOWN_BALL";
-    SpikeType[SpikeType["OVERHAND"] = 5] = "OVERHAND";
-})(SpikeType || (SpikeType = {}));
-export var SpikeFailure;
-(function (SpikeFailure) {
-    SpikeFailure[SpikeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SpikeFailure[SpikeFailure["FAULT"] = 1] = "FAULT";
-    SpikeFailure[SpikeFailure["MISS"] = 2] = "MISS";
-    SpikeFailure[SpikeFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    SpikeFailure[SpikeFailure["NET"] = 4] = "NET";
-})(SpikeFailure || (SpikeFailure = {}));
-export class Spike extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(player, type, modifier, isBackRow) {
-        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeType[type]);
-        if (![SpikeType.DOWN_BALL, SpikeType.OVERHAND, SpikeType.TIP].includes(type) && isBackRow) {
-            score = score * 0.7 + player.stats.backAttack * 0.3;
-        }
-        return score * modifier;
-    }
-}
+import { InPlayEvent } from './in-play-event';
+export var SpikeType;
+(function (SpikeType) {
+    SpikeType[SpikeType["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeType[SpikeType["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeType[SpikeType["TOOL_SHOT"] = 2] = "TOOL_SHOT";
+    SpikeType[SpikeType["TIP"] = 3] = "TIP";
+    SpikeType[SpikeType["DOWN_BALL"] = 4] = "DOWN_BALL";
+    SpikeType[SpikeType["OVERHAND"] = 5] = "OVERHAND";
+})(SpikeType || (SpikeType = {}));
+export var SpikeFailure;
+(function (SpikeFailure) {
+    SpikeFailure[SpikeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SpikeFailure[SpikeFailure["FAULT"] = 1] = "FAULT";
+    SpikeFailure[SpikeFailure["MISS"] = 2] = "MISS";
+    SpikeFailure[SpikeFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    SpikeFailure[SpikeFailure["NET"] = 4] = "NET";
+})(SpikeFailure || (SpikeFailure = {}));
+export class Spike extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
+        super({ id, order, score, player, target, eventType, modifier });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(player, type, modifier, isBackRow) {
+        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeType[type]);
+        if (![SpikeType.DOWN_BALL, SpikeType.OVERHAND, SpikeType.TIP].includes(type) && isBackRow) {
+            score = score * 0.7 + player.stats.backAttack * 0.3;
+        }
+        return score * modifier;
+    }
+}

package/dist/esm/src/service/event/spike.test.d.ts

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