volleyballsimtypes 0.0.75 → 0.0.77

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

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RallyEvent = exports.EventType = void 0;
-var EventType;
-(function (EventType) {
-    EventType[EventType["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
-    EventType[EventType["SUBSTITUTION"] = 1] = "SUBSTITUTION";
-    EventType[EventType["SERVE"] = 2] = "SERVE";
-    EventType[EventType["RECEPTION"] = 3] = "RECEPTION";
-    EventType[EventType["SET"] = 4] = "SET";
-    EventType[EventType["SPIKE"] = 5] = "SPIKE";
-    EventType[EventType["BLOCK"] = 6] = "BLOCK";
-    EventType[EventType["SCORE"] = 7] = "SCORE";
-})(EventType = exports.EventType || (exports.EventType = {}));
+exports.RallyEvent = exports.EventTypeEnum = void 0;
+var EventTypeEnum;
+(function (EventTypeEnum) {
+    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
+    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
+    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
+    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
+    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
+    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
+    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+    EventTypeEnum[EventTypeEnum["SCORE"] = 7] = "SCORE";
+})(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
 class RallyEvent {
     constructor({ id, eventType, player, order }) {
         this.id = id;

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

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

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

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reception = exports.ReceptionFailure = exports.ReceptionType = void 0;
+exports.Reception = exports.ReceptionFailureEnum = exports.ReceptionTypeEnum = void 0;
 const in_play_event_1 = require("./in-play-event");
-var ReceptionType;
-(function (ReceptionType) {
-    ReceptionType[ReceptionType["DIG"] = 0] = "DIG";
-    ReceptionType[ReceptionType["OVERHAND"] = 1] = "OVERHAND";
-    ReceptionType[ReceptionType["ONE_HAND"] = 2] = "ONE_HAND";
-    ReceptionType[ReceptionType["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
-})(ReceptionType = exports.ReceptionType || (exports.ReceptionType = {}));
-var ReceptionFailure;
-(function (ReceptionFailure) {
-    ReceptionFailure[ReceptionFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ReceptionFailure[ReceptionFailure["FAULT"] = 1] = "FAULT";
-    ReceptionFailure[ReceptionFailure["MISS"] = 2] = "MISS";
-    ReceptionFailure[ReceptionFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    ReceptionFailure[ReceptionFailure["BAD_PASS"] = 4] = "BAD_PASS";
-})(ReceptionFailure = exports.ReceptionFailure || (exports.ReceptionFailure = {}));
+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({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
     static getScore(stats, type, modifier) {
-        return Reception.calculateScore(stats, 'RECEPTION', ReceptionType[type]) * modifier;
+        return Reception.calculateScore(stats, 'RECEPTION', ReceptionTypeEnum[type]) * modifier;
     }
 }
 exports.Reception = Reception;

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

@@ -14,31 +14,33 @@ const rally_event_1 = require("./rally-event");
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: reception_1.ReceptionFailure.NO_FAILURE,
-            type: reception_1.ReceptionType.DIG,
-            eventType: rally_event_1.EventType.RECEPTION,
-            modifier: 1
+            target: match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: reception_1.ReceptionFailureEnum.NO_FAILURE,
+            type: reception_1.ReceptionTypeEnum.DIG,
+            eventType: rally_event_1.EventTypeEnum.RECEPTION,
+            modifier: 1,
+            activeTraits: []
         });
         failed = new reception_1.Reception({
             score: 60,
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.NO_TARGET,
-            failure: reception_1.ReceptionFailure.OUT_OF_BOUNDS,
-            type: reception_1.ReceptionType.OTHER_BODY_PART,
-            eventType: rally_event_1.EventType.RECEPTION,
-            modifier: 1
+            target: match_1.CourtTargetEnum.NO_TARGET,
+            failure: reception_1.ReceptionFailureEnum.OUT_OF_BOUNDS,
+            type: reception_1.ReceptionTypeEnum.OTHER_BODY_PART,
+            eventType: rally_event_1.EventTypeEnum.RECEPTION,
+            modifier: 1,
+            activeTraits: []
         });
     });
     (0, globals_1.test)('Should instantiate object properly', () => {
-        (0, globals_1.expect)(reception.target).toBe(match_1.CourtTarget.OPPONENT_RIGHT_BACK);
-        (0, globals_1.expect)(reception.type).toBe(reception_1.ReceptionType.DIG);
-        (0, globals_1.expect)(reception.eventType).toBe(rally_event_1.EventType.RECEPTION);
+        (0, globals_1.expect)(reception.target).toBe(match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        (0, globals_1.expect)(reception.type).toBe(reception_1.ReceptionTypeEnum.DIG);
+        (0, globals_1.expect)(reception.eventType).toBe(rally_event_1.EventTypeEnum.RECEPTION);
         (0, globals_1.expect)(reception.player.id).toBe(__stubs__1.player.id);
-        (0, globals_1.expect)(reception.failure).toBe(reception_1.ReceptionFailure.NO_FAILURE);
-        (0, globals_1.expect)(failed.failure).toBe(reception_1.ReceptionFailure.OUT_OF_BOUNDS);
+        (0, globals_1.expect)(reception.failure).toBe(reception_1.ReceptionFailureEnum.NO_FAILURE);
+        (0, globals_1.expect)(failed.failure).toBe(reception_1.ReceptionFailureEnum.OUT_OF_BOUNDS);
         (0, globals_1.expect)(reception.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -11,13 +11,13 @@ const rally_event_1 = require("./rally-event");
         score = new score_1.Score({
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
-            eventType: rally_event_1.EventType.SCORE,
+            eventType: rally_event_1.EventTypeEnum.SCORE,
             player: __stubs__1.player,
             team: __stubs__2.team
         });
     });
     (0, globals_1.test)('Should instantiate object properly', () => {
-        (0, globals_1.expect)(score.eventType).toBe(rally_event_1.EventType.SCORE);
+        (0, globals_1.expect)(score.eventType).toBe(rally_event_1.EventTypeEnum.SCORE);
         (0, globals_1.expect)(score.player.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
         (0, globals_1.expect)(score.team.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
     });

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

@@ -1,13 +1,13 @@
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
 import { PerformanceStats } from '../player';
-export declare enum ServeType {
+export declare enum ServeTypeEnum {
     UNDERHAND = 0,
     OVERHAND_TOPSPIN = 1,
     OVERHAND_FLOAT = 2,
     JUMP_TOPSPIN = 3,
     JUMP_FLOAT = 4
 }
-export declare enum ServeFailure {
+export declare enum ServeFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -15,13 +15,13 @@ export declare enum ServeFailure {
     OUT_OF_BOUNDS = 4
 }
 interface ServeOpts extends InPlayEventOpts {
-    readonly type: ServeType;
-    readonly failure: ServeFailure;
+    readonly type: ServeTypeEnum;
+    readonly failure: ServeFailureEnum;
 }
 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;
+    readonly failure: ServeFailureEnum;
+    readonly type: ServeTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
+    static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serve = exports.ServeFailure = exports.ServeType = void 0;
+exports.Serve = exports.ServeFailureEnum = exports.ServeTypeEnum = void 0;
 const in_play_event_1 = require("./in-play-event");
-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 = exports.ServeType || (exports.ServeType = {}));
-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 = exports.ServeFailure || (exports.ServeFailure = {}));
+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({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
     static getScore(stats, type, modifier) {
-        return Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier;
+        return Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
     }
 }
 exports.Serve = Serve;

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

@@ -14,31 +14,33 @@ const rally_event_1 = require("./rally-event");
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: serve_1.ServeFailure.NO_FAILURE,
-            type: serve_1.ServeType.JUMP_TOPSPIN,
-            eventType: rally_event_1.EventType.SERVE,
-            modifier: 1
+            target: match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: serve_1.ServeFailureEnum.NO_FAILURE,
+            type: serve_1.ServeTypeEnum.JUMP_TOPSPIN,
+            eventType: rally_event_1.EventTypeEnum.SERVE,
+            modifier: 1,
+            activeTraits: []
         });
         failed = new serve_1.Serve({
             score: 60,
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.NO_TARGET,
-            failure: serve_1.ServeFailure.NET,
-            type: serve_1.ServeType.UNDERHAND,
-            eventType: rally_event_1.EventType.SERVE,
-            modifier: 1
+            target: match_1.CourtTargetEnum.NO_TARGET,
+            failure: serve_1.ServeFailureEnum.NET,
+            type: serve_1.ServeTypeEnum.UNDERHAND,
+            eventType: rally_event_1.EventTypeEnum.SERVE,
+            modifier: 1,
+            activeTraits: []
         });
     });
     (0, globals_1.test)('Should instantiate object properly', () => {
-        (0, globals_1.expect)(serve.target).toBe(match_1.CourtTarget.OPPONENT_RIGHT_BACK);
-        (0, globals_1.expect)(serve.type).toBe(serve_1.ServeType.JUMP_TOPSPIN);
-        (0, globals_1.expect)(serve.eventType).toBe(rally_event_1.EventType.SERVE);
+        (0, globals_1.expect)(serve.target).toBe(match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        (0, globals_1.expect)(serve.type).toBe(serve_1.ServeTypeEnum.JUMP_TOPSPIN);
+        (0, globals_1.expect)(serve.eventType).toBe(rally_event_1.EventTypeEnum.SERVE);
         (0, globals_1.expect)(serve.player.id).toBe(__stubs__1.player.id);
-        (0, globals_1.expect)(serve.failure).toBe(serve_1.ServeFailure.NO_FAILURE);
-        (0, globals_1.expect)(failed.failure).toBe(serve_1.ServeFailure.NET);
+        (0, globals_1.expect)(serve.failure).toBe(serve_1.ServeFailureEnum.NO_FAILURE);
+        (0, globals_1.expect)(failed.failure).toBe(serve_1.ServeFailureEnum.NET);
         (0, globals_1.expect)(serve.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -1,12 +1,12 @@
 import { PerformanceStats } from '../player';
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum SetType {
+export declare enum SetTypeEnum {
     OVERHAND = 0,
     UNDERHAND = 1,
     SPIKE = 2,
     DUMP = 3
 }
-export declare enum SetFailure {
+export declare enum SetFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -14,13 +14,13 @@ export declare enum SetFailure {
     OUT_OF_BOUNDS = 4
 }
 interface SetOpts extends InPlayEventOpts {
-    readonly type: SetType;
-    readonly failure: SetFailure;
+    readonly type: SetTypeEnum;
+    readonly failure: SetFailureEnum;
 }
 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;
+    readonly failure: SetFailureEnum;
+    readonly type: SetTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
+    static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Set = exports.SetFailure = exports.SetType = void 0;
+exports.Set = exports.SetFailureEnum = exports.SetTypeEnum = void 0;
 const in_play_event_1 = require("./in-play-event");
-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 = exports.SetType || (exports.SetType = {}));
-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 = exports.SetFailure || (exports.SetFailure = {}));
+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({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
     static getScore(stats, type, modifier) {
-        return Set.calculateScore(stats, 'SET', SetType[type]) * modifier;
+        return Set.calculateScore(stats, 'SET', SetTypeEnum[type]) * modifier;
     }
 }
 exports.Set = Set;

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

@@ -14,31 +14,33 @@ const rally_event_1 = require("./rally-event");
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: set_1.SetFailure.NO_FAILURE,
-            type: set_1.SetType.OVERHAND,
-            eventType: rally_event_1.EventType.SET,
-            modifier: 1
+            target: match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: set_1.SetFailureEnum.NO_FAILURE,
+            type: set_1.SetTypeEnum.OVERHAND,
+            eventType: rally_event_1.EventTypeEnum.SET,
+            modifier: 1,
+            activeTraits: []
         });
         failed = new set_1.Set({
             score: 60,
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.NO_TARGET,
-            failure: set_1.SetFailure.OUT_OF_BOUNDS,
-            type: set_1.SetType.DUMP,
-            eventType: rally_event_1.EventType.SET,
-            modifier: 1
+            target: match_1.CourtTargetEnum.NO_TARGET,
+            failure: set_1.SetFailureEnum.OUT_OF_BOUNDS,
+            type: set_1.SetTypeEnum.DUMP,
+            eventType: rally_event_1.EventTypeEnum.SET,
+            modifier: 1,
+            activeTraits: []
         });
     });
     (0, globals_1.test)('Should instantiate object properly', () => {
-        (0, globals_1.expect)(set.target).toBe(match_1.CourtTarget.OPPONENT_RIGHT_BACK);
-        (0, globals_1.expect)(set.type).toBe(set_1.SetType.OVERHAND);
-        (0, globals_1.expect)(set.eventType).toBe(rally_event_1.EventType.SET);
+        (0, globals_1.expect)(set.target).toBe(match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        (0, globals_1.expect)(set.type).toBe(set_1.SetTypeEnum.OVERHAND);
+        (0, globals_1.expect)(set.eventType).toBe(rally_event_1.EventTypeEnum.SET);
         (0, globals_1.expect)(set.player.id).toBe(__stubs__1.player.id);
-        (0, globals_1.expect)(set.failure).toBe(set_1.SetFailure.NO_FAILURE);
-        (0, globals_1.expect)(failed.failure).toBe(set_1.SetFailure.OUT_OF_BOUNDS);
+        (0, globals_1.expect)(set.failure).toBe(set_1.SetFailureEnum.NO_FAILURE);
+        (0, globals_1.expect)(failed.failure).toBe(set_1.SetFailureEnum.OUT_OF_BOUNDS);
         (0, globals_1.expect)(set.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -1,6 +1,6 @@
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
 import { Player } from '../player';
-export declare enum SpikeType {
+export declare enum SpikeTypeEnum {
     CROSS_SHOT = 0,
     LINE_SHOT = 1,
     TOOL_SHOT = 2,
@@ -8,7 +8,7 @@ export declare enum SpikeType {
     DOWN_BALL = 4,
     OVERHAND = 5
 }
-export declare enum SpikeFailure {
+export declare enum SpikeFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -16,13 +16,13 @@ export declare enum SpikeFailure {
     NET = 4
 }
 interface SpikeOpts extends InPlayEventOpts {
-    readonly type: SpikeType;
-    readonly failure: SpikeFailure;
+    readonly type: SpikeTypeEnum;
+    readonly failure: SpikeFailureEnum;
 }
 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;
+    readonly failure: SpikeFailureEnum;
+    readonly type: SpikeTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean): number;
 }
 export {};

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

@@ -1,33 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Spike = exports.SpikeFailure = exports.SpikeType = void 0;
+exports.Spike = exports.SpikeFailureEnum = exports.SpikeTypeEnum = void 0;
 const in_play_event_1 = require("./in-play-event");
-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 = exports.SpikeType || (exports.SpikeType = {}));
-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 = exports.SpikeFailure || (exports.SpikeFailure = {}));
+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({ id, order, score, player, target, failure, type, eventType, modifier }) {
-        super({ id, order, score, player, target, eventType, modifier });
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
         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) {
+        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;
         }
         return score * modifier;

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

@@ -15,43 +15,46 @@ const uuid_1 = require("uuid");
             id: (0, uuid_1.v4)(),
             order: 1,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: spike_1.SpikeFailure.NO_FAILURE,
-            type: spike_1.SpikeType.CROSS_SHOT,
-            eventType: rally_event_1.EventType.SPIKE,
+            target: match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: spike_1.SpikeFailureEnum.NO_FAILURE,
+            type: spike_1.SpikeTypeEnum.CROSS_SHOT,
+            eventType: rally_event_1.EventTypeEnum.SPIKE,
             modifier: 1,
-            score: spike_1.Spike.getScore(__stubs__1.player, spike_1.SpikeType.CROSS_SHOT, 1, false)
+            score: spike_1.Spike.getScore(__stubs__1.player, spike_1.SpikeTypeEnum.CROSS_SHOT, 1, false),
+            activeTraits: []
         });
         failed = new spike_1.Spike({
             id: (0, uuid_1.v4)(),
             order: 1,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.NO_TARGET,
-            failure: spike_1.SpikeFailure.OUT_OF_BOUNDS,
-            type: spike_1.SpikeType.TIP,
-            eventType: rally_event_1.EventType.SPIKE,
+            target: match_1.CourtTargetEnum.NO_TARGET,
+            failure: spike_1.SpikeFailureEnum.OUT_OF_BOUNDS,
+            type: spike_1.SpikeTypeEnum.TIP,
+            eventType: rally_event_1.EventTypeEnum.SPIKE,
             modifier: 1,
-            score: spike_1.Spike.getScore(__stubs__1.player, spike_1.SpikeType.TIP, 1, false)
+            score: spike_1.Spike.getScore(__stubs__1.player, spike_1.SpikeTypeEnum.TIP, 1, false),
+            activeTraits: []
         });
         backAttack = new spike_1.Spike({
             id: (0, uuid_1.v4)(),
             order: 1,
             player: __stubs__1.player,
-            target: match_1.CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: spike_1.SpikeFailure.NO_FAILURE,
-            type: spike_1.SpikeType.CROSS_SHOT,
-            eventType: rally_event_1.EventType.SPIKE,
+            target: match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: spike_1.SpikeFailureEnum.NO_FAILURE,
+            type: spike_1.SpikeTypeEnum.CROSS_SHOT,
+            eventType: rally_event_1.EventTypeEnum.SPIKE,
             modifier: 1,
-            score: spike_1.Spike.getScore(__stubs__1.player, spike_1.SpikeType.CROSS_SHOT, 1, true)
+            score: spike_1.Spike.getScore(__stubs__1.player, spike_1.SpikeTypeEnum.CROSS_SHOT, 1, true),
+            activeTraits: []
         });
     });
     (0, globals_1.test)('Should instantiate object properly', () => {
-        (0, globals_1.expect)(spike.target).toBe(match_1.CourtTarget.OPPONENT_RIGHT_BACK);
-        (0, globals_1.expect)(spike.type).toBe(spike_1.SpikeType.CROSS_SHOT);
-        (0, globals_1.expect)(spike.eventType).toBe(rally_event_1.EventType.SPIKE);
+        (0, globals_1.expect)(spike.target).toBe(match_1.CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        (0, globals_1.expect)(spike.type).toBe(spike_1.SpikeTypeEnum.CROSS_SHOT);
+        (0, globals_1.expect)(spike.eventType).toBe(rally_event_1.EventTypeEnum.SPIKE);
         (0, globals_1.expect)(spike.player.id).toBe(__stubs__1.player.id);
-        (0, globals_1.expect)(spike.failure).toBe(spike_1.SpikeFailure.NO_FAILURE);
-        (0, globals_1.expect)(failed.failure).toBe(spike_1.SpikeFailure.OUT_OF_BOUNDS);
+        (0, globals_1.expect)(spike.failure).toBe(spike_1.SpikeFailureEnum.NO_FAILURE);
+        (0, globals_1.expect)(failed.failure).toBe(spike_1.SpikeFailureEnum.OUT_OF_BOUNDS);
         (0, globals_1.expect)(spike.modifier).toBe(1);
     });
     // getScore Tests