volleyballsimtypes 0.0.165 → 0.0.167

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

@@ -1,38 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerformanceStats = void 0;
-const utils_1 = require("../utils");
+exports.PerformanceStats = exports.performanceStatKeys = void 0;
+exports.performanceStatKeys = ['setting', 'serve', 'spike', 'quick', 'power', 'awareness', 'attack', 'backAttack',
+    'reception', 'overhand', 'bump', 'block', 'read', 'commit', 'focus', 'defense', 'stamina', 'saving'];
 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 (0, utils_1.getKeys)(this).map(key => `${key}: ${this[key]}`).join(', ');
+    static fromAverage(avg) {
+        const opts = Object.fromEntries(exports.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 exports.performanceStatKeys.map((key) => `${key}: ${this[key]}`)
+            .join(', ');
     }
 }
 exports.PerformanceStats = PerformanceStats;

package/dist/cjs/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/cjs/src/service/player/player.js

@@ -1,32 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = exports.Name = exports.Stat = void 0;
-const role_1 = require("./role");
 const utils_1 = require("../utils");
-const GeneralStat = __importStar(require("../../formula/stats"));
+const stats_1 = require("./stats");
+const role_1 = require("./role");
 class Stat {
     constructor({ name, value }) {
         this.name = name;
@@ -57,16 +34,16 @@ class Player {
         this.roles = roles;
         this.traits = traits;
         this.rarity = rarity;
-        this.generalStats = GeneralStat.ALL_STATS.map(stat => ({
+        this.generalStats = Object.values(stats_1.StatsEnum).map((stat) => ({
             name: stat,
-            value: GeneralStat.calculateScore(stats, stat)
+            value: (0, stats_1.calculateStatScore)(stats, stat)
         }));
     }
     // Used as a base sorting function for players
     static sortPlayers(roles) {
         return (p1, p2) => roles.reduce((x, role) => {
-            const p2Score = role_1.Role.calculateScore(p2.stats, role);
-            const p1Score = role_1.Role.calculateScore(p1.stats, role);
+            const p2Score = (0, role_1.calculateRoleScore)(p2.stats, role);
+            const p1Score = (0, role_1.calculateRoleScore)(p1.stats, role);
             return x + p2Score - p1Score;
         }, 0);
     }
@@ -74,17 +51,23 @@ class Player {
         const compareFn = (acc, current) => {
             let x = current.value;
             switch (current.name) {
-                case 'ATTACK':
-                    x *= 0.35;
+                case stats_1.StatsEnum.ATTACK:
+                    x *= 0.19;
                     break;
-                case 'DEFENSE':
-                    x *= 0.35;
+                case stats_1.StatsEnum.SET:
+                    x *= 0.19;
                     break;
-                case 'SERVE':
-                    x *= 0.2;
+                case stats_1.StatsEnum.RECEIVE:
+                    x *= 0.19;
                     break;
-                case 'PHYSICAL':
-                    x *= 0.1;
+                case stats_1.StatsEnum.BLOCK:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.SERVE:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.STAMINA:
+                    x *= 0.05;
                     break;
                 default:
                     x *= 0;
@@ -95,9 +78,6 @@ class Player {
         const s2 = p2.generalStats.reduce(compareFn, 0);
         return s2 - s1;
     }
-    canPlayLibero() {
-        return this.roles.includes(role_1.Role.LIBERO);
-    }
     toString() {
         return JSON.stringify({
             id: this.id,
@@ -106,7 +86,7 @@ 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/cjs/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/cjs/src/service/player/rarity.js

@@ -1,18 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RarityRanges = exports.Rarity = void 0;
-var Rarity;
-(function (Rarity) {
-    Rarity["COMMON"] = "COMMON";
-    Rarity["RARE"] = "RARE";
-    Rarity["LEGENDARY"] = "LEGENDARY";
-    Rarity["MYTHIC"] = "MYTHIC";
-    Rarity["SPECIAL"] = "SPECIAL";
-})(Rarity = exports.Rarity || (exports.Rarity = {}));
+exports.RarityDataType = exports.RarityRanges = exports.RarityEnum = void 0;
+const sequelize_1 = require("sequelize");
+var RarityEnum;
+(function (RarityEnum) {
+    RarityEnum["COMMON"] = "COMMON";
+    RarityEnum["RARE"] = "RARE";
+    RarityEnum["LEGENDARY"] = "LEGENDARY";
+    RarityEnum["MYTHIC"] = "MYTHIC";
+    RarityEnum["SPECIAL"] = "SPECIAL";
+})(RarityEnum = exports.RarityEnum || (exports.RarityEnum = {}));
 exports.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]
 };
+exports.RarityDataType = sequelize_1.DataTypes.ENUM(...Object.values(RarityEnum));

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

@@ -1,16 +1,17 @@
-import { Roles } from '../../formula';
-import { PerformanceStats } from './performance-stats';
-export declare class Role {
-    static readonly SETTER: Role;
-    static readonly LIBERO: Role;
-    static readonly OUTSIDE_HITTER: Role;
-    static readonly OPPOSITE_HITTER: Role;
-    static readonly MIDDLE_BLOCKER: Role;
-    private static readonly ROLES;
-    readonly name: Roles;
-    private constructor();
-    toString(): string;
-    static getRoles(): Role[];
-    static calculateScore(stats: PerformanceStats, role: Role): number;
-    static assignRoles(stats: PerformanceStats): Role[];
+import { EnumDataType } from 'sequelize';
+import { PerformanceStats, PerformanceStatsParams } from './performance-stats';
+export declare enum RoleEnum {
+    SETTER = "SETTER",
+    LIBERO = "LIBERO",
+    OUTSIDE_HITTER = "OUTSIDE_HITTER",
+    OPPOSITE_HITTER = "OPPOSITE_HITTER",
+    MIDDLE_BLOCKER = "MIDDLE_BLOCKER"
 }
+export type Role = RoleEnum.SETTER | RoleEnum.LIBERO | RoleEnum.MIDDLE_BLOCKER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER;
+export declare const RoleDataType: EnumDataType<Role>;
+export interface RolesFormula {
+    role: Role;
+    weight: PerformanceStatsParams;
+}
+export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
+export declare function assignRoles(stats: PerformanceStats): Role[];

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

@@ -1,44 +1,48 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Role = void 0;
-const formula_1 = require("../../formula");
-class Role {
-    constructor(name) {
-        this.name = name;
-    }
-    toString() {
-        return this.name;
-    }
-    static getRoles() {
-        return [...Role.ROLES];
-    }
-    static calculateScore(stats, role) {
-        const weights = formula_1.rolesFormula.find(r => r.role === role.name);
-        if (weights == null)
-            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
-        const score = Object.entries(weights.weight)
-            .reduce((score, [key, value]) => score + (stats[key] * weights.weight[key]), 0);
-        return Math.round(score);
+exports.assignRoles = exports.calculateRoleScore = exports.RoleDataType = exports.RoleEnum = void 0;
+const sequelize_1 = require("sequelize");
+const roles_json_1 = __importDefault(require("../../stat-config/roles.json"));
+var RoleEnum;
+(function (RoleEnum) {
+    RoleEnum["SETTER"] = "SETTER";
+    RoleEnum["LIBERO"] = "LIBERO";
+    RoleEnum["OUTSIDE_HITTER"] = "OUTSIDE_HITTER";
+    RoleEnum["OPPOSITE_HITTER"] = "OPPOSITE_HITTER";
+    RoleEnum["MIDDLE_BLOCKER"] = "MIDDLE_BLOCKER";
+})(RoleEnum = exports.RoleEnum || (exports.RoleEnum = {}));
+exports.RoleDataType = sequelize_1.DataTypes.ENUM(...Object.values(RoleEnum));
+const rolesFormula = roles_json_1.default;
+function calculateRoleScore(stats, role) {
+    const weights = rolesFormula.find(r => r.role === role);
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const score = Object.keys(weights.weight)
+        .reduce((score, key) => {
+        const stat = stats[key];
+        const weight = weights.weight[key];
+        return score + (stat * weight);
+    }, 0);
+    return Math.round(score);
+}
+exports.calculateRoleScore = calculateRoleScore;
+function assignRoles(stats) {
+    const scores = Object.values(RoleEnum)
+        .map((role) => ({
+        role,
+        score: calculateRoleScore(stats, role)
+    }))
+        .sort((x, y) => y.score - x.score);
+    const out = [scores[0].role];
+    if (scores[1].score >= 75) {
+        out.push(scores[1].role);
     }
-    static assignRoles(stats) {
-        const scores = this.getRoles().map(role => ({
-            role,
-            score: this.calculateScore(stats, role)
-        })).sort((x, y) => y.score - x.score);
-        const out = [scores[0].role];
-        if (scores[1].score >= 75) {
-            out.push(scores[1].role);
-        }
-        if (scores[2].score >= 85) {
-            out.push(scores[2].role);
-        }
-        return out;
+    if (scores[2].score >= 85) {
+        out.push(scores[2].role);
     }
+    return out;
 }
-exports.Role = Role;
-Role.SETTER = new Role('SETTER');
-Role.LIBERO = new Role('LIBERO');
-Role.OUTSIDE_HITTER = new Role('OUTSIDE_HITTER');
-Role.OPPOSITE_HITTER = new Role('OPPOSITE_HITTER');
-Role.MIDDLE_BLOCKER = new Role('MIDDLE_BLOCKER');
-Role.ROLES = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER];
+exports.assignRoles = assignRoles;

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

@@ -0,0 +1,12 @@
+import { PerformanceStats } from './performance-stats';
+export declare enum StatsEnum {
+    ATTACK = "ATTACK",
+    SET = "SET",
+    RECEIVE = "RECEIVE",
+    SERVE = "SERVE",
+    BLOCK = "BLOCK",
+    STAMINA = "STAMINA"
+}
+export type Stats = StatsEnum.ATTACK | StatsEnum.SET | StatsEnum.RECEIVE | StatsEnum.SERVE | StatsEnum.BLOCK | StatsEnum.STAMINA;
+export declare function calculateStatScore(performanceStats: PerformanceStats, statName: Stats): number;
+export declare function getMultipliers(statName: Stats, performanceStats?: PerformanceStats): any;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultipliers = exports.calculateStatScore = exports.StatsEnum = void 0;
+var StatsEnum;
+(function (StatsEnum) {
+    StatsEnum["ATTACK"] = "ATTACK";
+    StatsEnum["SET"] = "SET";
+    StatsEnum["RECEIVE"] = "RECEIVE";
+    StatsEnum["SERVE"] = "SERVE";
+    StatsEnum["BLOCK"] = "BLOCK";
+    StatsEnum["STAMINA"] = "STAMINA";
+})(StatsEnum = exports.StatsEnum || (exports.StatsEnum = {}));
+function calculateStatScore(performanceStats, statName) {
+    const multipliers = getMultipliers(statName, performanceStats);
+    const score = Object.entries(multipliers)
+        .reduce((total, [key, value]) => total + value * performanceStats[key], 0);
+    return Math.round(score);
+}
+exports.calculateStatScore = calculateStatScore;
+function getMultipliers(statName, performanceStats) {
+    switch (statName) {
+        case StatsEnum.ATTACK:
+            return {
+                spike: 0.55,
+                backAttack: 0.1,
+                power: performanceStats == null ? 0.125 : performanceStats.power > performanceStats.quick ? 0.2 : 0.05,
+                quick: performanceStats == null ? 0.125 : performanceStats.quick > performanceStats.power ? 0.2 : 0.05,
+                awareness: 0.05,
+                attack: 0.05
+            };
+        case StatsEnum.SET:
+            return {
+                setting: 0.7,
+                overhand: 0.1,
+                bump: 0.05,
+                awareness: 0.075,
+                attack: 0.075
+            };
+        case StatsEnum.RECEIVE:
+            return {
+                reception: 0.75,
+                overhand: 0.025,
+                bump: 0.15,
+                focus: 0.025,
+                defense: 0.05
+            };
+        case StatsEnum.SERVE:
+            return {
+                serve: 0.85,
+                awareness: 0.075,
+                attack: 0.075
+            };
+        case StatsEnum.BLOCK:
+            return {
+                block: 0.65,
+                read: performanceStats == null ? 0.125 : performanceStats.read > performanceStats.commit ? 0.2 : 0.05,
+                commit: performanceStats == null ? 0.125 : performanceStats.commit > performanceStats.read ? 0.2 : 0.05,
+                focus: 0.05,
+                defense: 0.05
+            };
+        case StatsEnum.STAMINA:
+            return { stamina: 1 };
+        default:
+            throw new Error('INVALID_STAT');
+    }
+}
+exports.getMultipliers = getMultipliers;

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

@@ -1,22 +1,15 @@
-import * as GeneralStat from '../../formula/stats';
 import { PerformanceStats } from './performance-stats';
 import { Rarity } from './rarity';
-export declare class Trait {
-    static readonly MASTER_MIND: Trait;
-    static readonly MOVING_WALL: Trait;
-    static readonly MARKSMAN: Trait;
-    static readonly METEOR_SERVE: Trait;
-    static readonly VIGOROUS: Trait;
-    static readonly GUARDIAN: Trait;
-    readonly id: string;
-    readonly name: string;
-    readonly modifier: number;
-    readonly chance: number;
-    readonly statThreshold: number;
-    readonly stat: GeneralStat.Stats;
-    readonly weight: number;
-    private constructor();
-    static getTraits(): Trait[];
-    static assignTraits(performanceStats: PerformanceStats, rarity: Rarity): Trait[];
-    toString(): string;
+import { EnumDataType } from 'sequelize';
+export declare enum TraitEnum {
+    MASTER_MIND = "MASTER_MIND",
+    MOVING_WALL = "MOVING_WALL",
+    MARKSMAN = "MARKSMAN",
+    METEOR_SERVE = "METEOR_SERVE",
+    VIGOROUS = "VIGOROUS",
+    GUARDIAN = "GUARDIAN",
+    FLOAT_SERVE = "FLOAT_SERVE"
 }
+export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS;
+export declare const TraitDataType: EnumDataType<Trait>;
+export declare function assignTraits(performanceStats: PerformanceStats, rarity: Rarity): Trait[];