volleyballsimtypes 0.0.165 → 0.0.167

package/dist/esm/src/data/models/player.d.ts

@@ -1,11 +1,12 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { CountryId, CountryModel, DraftPickId, DraftPickModel, MatchSetId, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, PlayerTraitId, PlayerTraitModel, SetPositionId, SetPositionModel, TeamId, TeamModel, TraitId, TraitModel } from '.';
-import { Rarity } from '../../service';
+import { CountryId, CountryModel, DraftPickId, DraftPickModel, MatchSetId, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, SetPositionId, SetPositionModel, TeamId, TeamModel } from '.';
+import { Rarity, Role, Trait } from '../../service';
 export interface PlayerAttributes {
     player_id: string;
-    roles: RoleType[];
-    rarity: PlayerRarity;
+    roles: Role[];
+    traits: Trait[];
+    rarity: Rarity;
     first_name: string;
     last_name: string;
     country_id: string;
@@ -13,14 +14,13 @@ export interface PlayerAttributes {
     MatchSetStats?: MatchSetStatsAttributes[];
 }
 export type PlayerPk = 'player_id';
-export type RoleType = 'SETTER' | 'LIBERO' | 'OUTSIDE_HITTER' | 'OPPOSITE_HITTER' | 'MIDDLE_BLOCKER';
-export type PlayerRarity = Rarity.COMMON | Rarity.RARE | Rarity.LEGENDARY | Rarity.MYTHIC | Rarity.SPECIAL;
 export type PlayerId = PlayerModel[PlayerPk];
 export type PlayerCreationAttributes = PlayerAttributes;
 export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationAttributes> implements PlayerAttributes {
     player_id: string;
-    roles: RoleType[];
-    rarity: PlayerRarity;
+    roles: Role[];
+    traits: Trait[];
+    rarity: Rarity;
     first_name: string;
     last_name: string;
     country_id: string;
@@ -80,17 +80,6 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasPlayerTeam: Sequelize.HasManyHasAssociationMixin<PlayerTeamModel, PlayerTeamId>;
     hasPlayerTeams: Sequelize.HasManyHasAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
     countPlayerTeams: Sequelize.HasManyCountAssociationsMixin;
-    PlayerTraits: PlayerTraitModel[];
-    getPlayerTraits: Sequelize.HasManyGetAssociationsMixin<PlayerTraitModel>;
-    setPlayerTraits: Sequelize.HasManySetAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
-    addPlayerTrait: Sequelize.HasManyAddAssociationMixin<PlayerTraitModel, PlayerTraitId>;
-    addPlayerTraits: Sequelize.HasManyAddAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
-    createPlayerTrait: Sequelize.HasManyCreateAssociationMixin<PlayerTraitModel>;
-    removePlayerTrait: Sequelize.HasManyRemoveAssociationMixin<PlayerTraitModel, PlayerTraitId>;
-    removePlayerTraits: Sequelize.HasManyRemoveAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
-    hasPlayerTrait: Sequelize.HasManyHasAssociationMixin<PlayerTraitModel, PlayerTraitId>;
-    hasPlayerTraits: Sequelize.HasManyHasAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
-    countPlayerTraits: Sequelize.HasManyCountAssociationsMixin;
     SetPositions: SetPositionModel[];
     getSetPositions: Sequelize.HasManyGetAssociationsMixin<SetPositionModel>;
     setSetPositions: Sequelize.HasManySetAssociationsMixin<SetPositionModel, SetPositionId>;
@@ -113,16 +102,5 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasTeam: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
     hasTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
     countTeams: Sequelize.BelongsToManyCountAssociationsMixin;
-    Traits: TraitModel[];
-    getTraits: Sequelize.BelongsToManyGetAssociationsMixin<TraitModel>;
-    setTraits: Sequelize.BelongsToManySetAssociationsMixin<TraitModel, TraitId>;
-    addTrait: Sequelize.BelongsToManyAddAssociationMixin<TraitModel, TraitId>;
-    addTraits: Sequelize.BelongsToManyAddAssociationsMixin<TraitModel, TraitId>;
-    createTrait: Sequelize.BelongsToManyCreateAssociationMixin<TraitModel>;
-    removeTrait: Sequelize.BelongsToManyRemoveAssociationMixin<TraitModel, TraitId>;
-    removeTraits: Sequelize.BelongsToManyRemoveAssociationsMixin<TraitModel, TraitId>;
-    hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
-    hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
-    countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
     static initModel(sequelize: Sequelize.Sequelize): typeof PlayerModel;
 }

package/dist/esm/src/data/models/player.js

@@ -1,5 +1,5 @@
 import { DataTypes, Model } from 'sequelize';
-import { Rarity } from '../../service';
+import { RarityDataType, RoleDataType, TraitDataType } from '../../service';
 export class PlayerModel extends Model {
     static initModel(sequelize) {
         return PlayerModel.init({
@@ -9,11 +9,15 @@ export class PlayerModel extends Model {
                 primaryKey: true
             },
             roles: {
-                type: DataTypes.ARRAY(DataTypes.ENUM('SETTER', 'LIBERO', 'OUTSIDE_HITTER', 'OPPOSITE_HITTER', 'MIDDLE_BLOCKER')),
+                type: DataTypes.ARRAY(RoleDataType),
+                allowNull: false
+            },
+            traits: {
+                type: DataTypes.ARRAY(TraitDataType),
                 allowNull: false
             },
             rarity: {
-                type: DataTypes.ENUM(...Object.values(Rarity)),
+                type: DataTypes.ENUM(RarityDataType),
                 allowNull: false
             },
             first_name: {

package/dist/esm/src/data/transformers/index.d.ts

@@ -16,10 +16,8 @@ export * from './performance-stats';
 export * from './player';
 export * from './rally';
 export * from './set-position';
-export * from './role';
 export * from './season';
 export * from './season-match';
 export * from './player-team';
 export * from './match-rating';
 export * from './team';
-export * from './trait';

package/dist/esm/src/data/transformers/index.js

@@ -16,10 +16,8 @@ export * from './performance-stats';
 export * from './player';
 export * from './rally';
 export * from './set-position';
-export * from './role';
 export * from './season';
 export * from './season-match';
 export * from './player-team';
 export * from './match-rating';
 export * from './team';
-export * from './trait';

package/dist/esm/src/data/transformers/performance-stats.js

@@ -4,30 +4,44 @@ function transformToAttributes(player) {
         player_id: player.id,
         back_attack: player.stats.backAttack,
         block: player.stats.block,
+        read: player.stats.read,
+        commit: player.stats.commit,
+        focus: player.stats.focus,
         awareness: player.stats.awareness,
         defense: player.stats.defense,
-        jump: player.stats.jump,
-        pass: player.stats.pass,
+        quick: player.stats.quick,
+        power: player.stats.power,
+        attack: player.stats.attack,
         serve: player.stats.serve,
         reception: player.stats.reception,
+        overhand: player.stats.overhand,
+        bump: player.stats.bump,
         setting: player.stats.setting,
         spike: player.stats.spike,
-        stamina: player.stats.stamina
+        stamina: player.stats.stamina,
+        saving: player.stats.saving
     };
 }
 function transformToObject(model) {
     return new PerformanceStats({
-        awareness: model.awareness,
-        defense: model.defense,
-        jump: model.jump,
-        pass: model.pass,
-        serve: model.serve,
-        reception: model.reception,
         setting: model.setting,
+        serve: model.serve,
         spike: model.spike,
-        stamina: model.stamina,
+        quick: model.quick,
+        power: model.power,
+        awareness: model.awareness,
+        attack: model.attack,
+        backAttack: model.back_attack,
+        reception: model.reception,
+        overhand: model.overhand,
+        bump: model.bump,
         block: model.block,
-        backAttack: model.back_attack
+        read: model.read,
+        commit: model.commit,
+        focus: model.focus,
+        defense: model.defense,
+        stamina: model.stamina,
+        saving: model.saving
     });
 }
 export { transformToObject as transformToPerformanceStats, transformToAttributes as transformFromPerformanceStats };

package/dist/esm/src/data/transformers/player.js

@@ -1,12 +1,13 @@
 import { Player } from '../../service';
-import { transformFromPerformanceStats, transformFromRole, transformToCountry, transformToPerformanceStats, transformToRole, transformToTrait } from '.';
+import { transformFromPerformanceStats, transformToCountry, transformToPerformanceStats } from '.';
 function transformToAttributes(player) {
     return {
         player_id: player.id,
         country_id: player.country.id,
         first_name: player.name.first,
         last_name: player.name.last,
-        roles: player.roles.map(transformFromRole),
+        roles: player.roles,
+        traits: player.traits,
         PerformanceStat: transformFromPerformanceStats(player),
         rarity: player.rarity
     };
@@ -19,8 +20,8 @@ function transformToObject(model) {
             last: model.last_name
         },
         country: transformToCountry(model.country),
-        roles: model.roles.map(transformToRole),
-        traits: model.Traits.map(transformToTrait),
+        roles: model.roles,
+        traits: model.traits,
         stats: transformToPerformanceStats(model.PerformanceStat),
         rarity: model.rarity
     });

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

@@ -1,3 +1,2 @@
 export * from './service';
 export * from './data';
-export * from './formula';

package/dist/esm/src/index.js

@@ -1,3 +1,2 @@
 export * from './service';
 export * from './data';
-export * from './formula';

package/dist/esm/src/service/coach/formation.js

@@ -1,4 +1,4 @@
-import { Role } from '../player';
+import { RoleEnum } from '../player';
 import { CourtPosition } from '../match';
 export class Formation {
     constructor({ name, initialRotation, base, draftingPriorities, liberoSubPriority }) {
@@ -15,29 +15,29 @@ export class Formation {
 Formation['5-1'] = new Formation({
     name: '5-1',
     initialRotation: {
-        1: [Role.SETTER],
-        2: [Role.OUTSIDE_HITTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OPPOSITE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.MIDDLE_BLOCKER]
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OUTSIDE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OPPOSITE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.MIDDLE_BLOCKER]
     },
     base: {
-        1: [Role.OPPOSITE_HITTER, Role.SETTER],
-        2: [Role.OPPOSITE_HITTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OUTSIDE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.LIBERO]
+        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO]
     },
     draftingPriorities: [
-        [Role.SETTER, Role.OPPOSITE_HITTER],
-        [Role.OPPOSITE_HITTER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.OUTSIDE_HITTER],
-        [Role.OUTSIDE_HITTER],
-        [Role.LIBERO]
+        [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.LIBERO]
     ],
     liberoSubPriority: {
         MIDDLE_BLOCKER: 1,
@@ -50,29 +50,29 @@ Formation['5-1'] = new Formation({
 Formation['4-2'] = new Formation({
     name: '4-2',
     initialRotation: {
-        1: [Role.MIDDLE_BLOCKER],
-        2: [Role.SETTER],
-        3: [Role.OUTSIDE_HITTER],
-        4: [Role.MIDDLE_BLOCKER],
-        5: [Role.SETTER],
-        6: [Role.OPPOSITE_HITTER]
+        1: [RoleEnum.MIDDLE_BLOCKER],
+        2: [RoleEnum.SETTER],
+        3: [RoleEnum.OUTSIDE_HITTER],
+        4: [RoleEnum.MIDDLE_BLOCKER],
+        5: [RoleEnum.SETTER],
+        6: [RoleEnum.OPPOSITE_HITTER]
     },
     base: {
-        1: [Role.SETTER],
-        2: [Role.OPPOSITE_HITTER, Role.SETTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OUTSIDE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.LIBERO]
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO]
     },
     draftingPriorities: [
-        [Role.SETTER, Role.OPPOSITE_HITTER],
-        [Role.SETTER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.OUTSIDE_HITTER],
-        [Role.OUTSIDE_HITTER],
-        [Role.LIBERO]
+        [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.SETTER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.LIBERO]
     ],
     liberoSubPriority: {
         MIDDLE_BLOCKER: 1,
@@ -85,29 +85,29 @@ Formation['4-2'] = new Formation({
 Formation['6-2'] = new Formation({
     name: '6-2',
     initialRotation: {
-        1: [Role.OPPOSITE_HITTER, Role.SETTER],
-        2: [Role.OUTSIDE_HITTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OPPOSITE_HITTER, Role.SETTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.MIDDLE_BLOCKER]
+        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        2: [RoleEnum.OUTSIDE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.MIDDLE_BLOCKER]
     },
     base: {
-        1: [Role.SETTER],
-        2: [Role.OPPOSITE_HITTER, Role.SETTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OUTSIDE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.LIBERO]
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO]
     },
     draftingPriorities: [
-        [Role.SETTER, Role.OPPOSITE_HITTER],
-        [Role.OPPOSITE_HITTER, Role.SETTER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.OUTSIDE_HITTER],
-        [Role.OUTSIDE_HITTER],
-        [Role.LIBERO]
+        [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.LIBERO]
     ],
     liberoSubPriority: {
         MIDDLE_BLOCKER: 1,

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

@@ -1,5 +1,6 @@
 export * from './player';
 export * from './performance-stats';
-export * from './role';
 export * from './trait';
 export * from './rarity';
+export * from './role';
+export * from './stats';

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

@@ -1,5 +1,6 @@
 export * from './player';
 export * from './performance-stats';
-export * from './role';
 export * from './trait';
 export * from './rarity';
+export * from './role';
+export * from './stats';

package/dist/esm/src/service/player/performance-stats.d.ts

@@ -1,30 +1,10 @@
-export interface PerformanceStatsParams {
-    readonly setting: number;
-    readonly pass: number;
-    readonly reception: number;
-    readonly spike: number;
-    readonly backAttack: number;
-    readonly jump: number;
-    readonly block: number;
-    readonly awareness: number;
-    readonly serve: number;
-    readonly defense: number;
-    readonly stamina: number;
+export declare const performanceStatKeys: readonly ["setting", "serve", "spike", "quick", "power", "awareness", "attack", "backAttack", "reception", "overhand", "bump", "block", "read", "commit", "focus", "defense", "stamina", "saving"];
+export type PerformanceStatsKey = typeof performanceStatKeys[number];
+export type PerformanceStatsParams = Record<PerformanceStatsKey, number>;
+export interface PerformanceStats extends PerformanceStatsParams {
 }
-export type PerformanceStatsKey = keyof PerformanceStatsParams;
 export declare class PerformanceStats {
-    readonly setting: number;
-    readonly pass: number;
-    readonly reception: number;
-    readonly spike: number;
-    readonly backAttack: number;
-    readonly jump: number;
-    readonly block: number;
-    readonly awareness: number;
-    readonly serve: number;
-    readonly defense: number;
-    readonly stamina: number;
     constructor(opts: PerformanceStatsParams);
+    static fromAverage(avg: number): PerformanceStats;
     toString(): string;
-    static fromAverage(average: number): PerformanceStats;
 }

package/dist/esm/src/service/player/performance-stats.js

@@ -1,34 +1,15 @@
-import { getKeys } from '../utils';
+export const performanceStatKeys = ['setting', 'serve', 'spike', 'quick', 'power', 'awareness', 'attack', 'backAttack',
+    'reception', 'overhand', 'bump', 'block', 'read', 'commit', 'focus', 'defense', 'stamina', 'saving'];
 export class PerformanceStats {
     constructor(opts) {
-        this.serve = opts.serve;
-        this.pass = opts.pass;
-        this.setting = opts.setting;
-        this.reception = opts.reception;
-        this.spike = opts.spike;
-        this.backAttack = opts.backAttack;
-        this.jump = opts.jump;
-        this.block = opts.block;
-        this.awareness = opts.awareness;
-        this.defense = opts.defense;
-        this.stamina = opts.stamina;
+        Object.assign(this, opts);
     }
-    toString() {
-        return getKeys(this).map(key => `${key}: ${this[key]}`).join(', ');
+    static fromAverage(avg) {
+        const opts = Object.fromEntries(performanceStatKeys.map((key) => [key, avg]));
+        return new PerformanceStats(opts);
     }
-    static fromAverage(average) {
-        return new PerformanceStats({
-            setting: average,
-            pass: average,
-            reception: average,
-            spike: average,
-            backAttack: average,
-            jump: average,
-            block: average,
-            awareness: average,
-            serve: average,
-            defense: average,
-            stamina: average
-        });
+    toString() {
+        return performanceStatKeys.map((key) => `${key}: ${this[key]}`)
+            .join(', ');
     }
 }

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

@@ -1,14 +1,14 @@
 import { PerformanceStats } from './performance-stats';
-import { Role } from './role';
 import { Trait } from './trait';
 import { Country } from '../country';
-import * as GeneralStat from '../../formula/stats';
 import { Rarity } from './rarity';
+import { Stats } from './stats';
+import { Role } from './role';
 export declare class Stat {
-    readonly name: GeneralStat.Stats;
+    readonly name: Stats;
     readonly value: number;
     constructor({ name, value }: {
-        name: GeneralStat.Stats;
+        name: Stats;
         value: number;
     });
     toString(): string;
@@ -43,7 +43,6 @@ export declare class Player {
     constructor({ id, name, country, stats, roles, traits, rarity }: PlayerParams);
     static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
     static compareStats(p1: Player, p2: Player): number;
-    canPlayLibero(): boolean;
     toString(): string;
 }
 export {};

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

@@ -1,6 +1,6 @@
-import { Role } from './role';
 import { validateUUID } from '../utils';
-import * as GeneralStat from '../../formula/stats';
+import { calculateStatScore, StatsEnum } from './stats';
+import { calculateRoleScore } from './role';
 export class Stat {
     constructor({ name, value }) {
         this.name = name;
@@ -29,16 +29,16 @@ export class Player {
         this.roles = roles;
         this.traits = traits;
         this.rarity = rarity;
-        this.generalStats = GeneralStat.ALL_STATS.map(stat => ({
+        this.generalStats = Object.values(StatsEnum).map((stat) => ({
             name: stat,
-            value: GeneralStat.calculateScore(stats, stat)
+            value: calculateStatScore(stats, stat)
         }));
     }
     // Used as a base sorting function for players
     static sortPlayers(roles) {
         return (p1, p2) => roles.reduce((x, role) => {
-            const p2Score = Role.calculateScore(p2.stats, role);
-            const p1Score = Role.calculateScore(p1.stats, role);
+            const p2Score = calculateRoleScore(p2.stats, role);
+            const p1Score = calculateRoleScore(p1.stats, role);
             return x + p2Score - p1Score;
         }, 0);
     }
@@ -46,17 +46,23 @@ export class Player {
         const compareFn = (acc, current) => {
             let x = current.value;
             switch (current.name) {
-                case 'ATTACK':
-                    x *= 0.35;
+                case StatsEnum.ATTACK:
+                    x *= 0.19;
                     break;
-                case 'DEFENSE':
-                    x *= 0.35;
+                case StatsEnum.SET:
+                    x *= 0.19;
                     break;
-                case 'SERVE':
-                    x *= 0.2;
+                case StatsEnum.RECEIVE:
+                    x *= 0.19;
                     break;
-                case 'PHYSICAL':
-                    x *= 0.1;
+                case StatsEnum.BLOCK:
+                    x *= 0.19;
+                    break;
+                case StatsEnum.SERVE:
+                    x *= 0.19;
+                    break;
+                case StatsEnum.STAMINA:
+                    x *= 0.05;
                     break;
                 default:
                     x *= 0;
@@ -67,9 +73,6 @@ export class Player {
         const s2 = p2.generalStats.reduce(compareFn, 0);
         return s2 - s1;
     }
-    canPlayLibero() {
-        return this.roles.includes(Role.LIBERO);
-    }
     toString() {
         return JSON.stringify({
             id: this.id,
@@ -78,7 +81,7 @@ export class Player {
             stats: this.stats.toString(),
             rarity: this.rarity,
             roles: `[${this.roles.map(r => r.toString()).join(',')}]`,
-            traits: `[${this.traits.map(r => r.toString()).join(',')}]`,
+            traits: `[${this.traits.map(t => t.toString()).join(',')}]`,
             generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
         });
     }

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

@@ -1,10 +1,12 @@
-export declare enum Rarity {
+import { EnumDataType } from 'sequelize';
+export declare enum RarityEnum {
     COMMON = "COMMON",
     RARE = "RARE",
     LEGENDARY = "LEGENDARY",
     MYTHIC = "MYTHIC",
     SPECIAL = "SPECIAL"
 }
+export type Rarity = RarityEnum.COMMON | RarityEnum.RARE | RarityEnum.LEGENDARY | RarityEnum.MYTHIC | RarityEnum.SPECIAL;
 export declare const RarityRanges: {
     COMMON: number[];
     RARE: number[];
@@ -12,3 +14,4 @@ export declare const RarityRanges: {
     MYTHIC: number[];
     SPECIAL: number[];
 };
+export declare const RarityDataType: EnumDataType<RarityEnum>;

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

@@ -1,15 +1,17 @@
-export var Rarity;
-(function (Rarity) {
-    Rarity["COMMON"] = "COMMON";
-    Rarity["RARE"] = "RARE";
-    Rarity["LEGENDARY"] = "LEGENDARY";
-    Rarity["MYTHIC"] = "MYTHIC";
-    Rarity["SPECIAL"] = "SPECIAL";
-})(Rarity || (Rarity = {}));
+import { DataTypes } from 'sequelize';
+export var RarityEnum;
+(function (RarityEnum) {
+    RarityEnum["COMMON"] = "COMMON";
+    RarityEnum["RARE"] = "RARE";
+    RarityEnum["LEGENDARY"] = "LEGENDARY";
+    RarityEnum["MYTHIC"] = "MYTHIC";
+    RarityEnum["SPECIAL"] = "SPECIAL";
+})(RarityEnum || (RarityEnum = {}));
 export const RarityRanges = {
-    [Rarity.COMMON]: [0, 50],
-    [Rarity.RARE]: [51, 70],
-    [Rarity.LEGENDARY]: [71, 85],
-    [Rarity.MYTHIC]: [86, 98],
-    [Rarity.SPECIAL]: [99, 100]
+    [RarityEnum.COMMON]: [0, 50],
+    [RarityEnum.RARE]: [51, 70],
+    [RarityEnum.LEGENDARY]: [71, 85],
+    [RarityEnum.MYTHIC]: [86, 98],
+    [RarityEnum.SPECIAL]: [99, 100]
 };
+export const RarityDataType = DataTypes.ENUM(...Object.values(RarityEnum));