volleyballsimtypes 0.0.162 → 0.0.164

package/dist/esm/src/service/match/match-rating.js

@@ -0,0 +1,61 @@
+import { MatchScore } from '.';
+export class MatchRating {
+    constructor({ match, competitionType }) {
+        this.match = match;
+        this.weight = MatchRating.MWF[competitionType];
+    }
+    getPoints(team) {
+        const rankingValue = MatchRating.SSV[this.match.getScore()] - this.getExpectedResult();
+        const weighted = rankingValue * this.weight / MatchRating.K;
+        if (this.match.isWinner(team))
+            return weighted;
+        else
+            return weighted * -1;
+    }
+    static calculateProbability(z) {
+        let area = 0.0;
+        const rectangles = 100000;
+        const width = (z - (-10)) / rectangles;
+        for (let i = 0; i < rectangles; i++) {
+            area += width * Math.exp(-Math.pow((width * i + (-10)), 2) / 2) / Math.sqrt(2 * Math.PI);
+        }
+        return area;
+    }
+    getExpectedResult() {
+        const D = MatchRating.K * (this.match.homeTeam.rating - this.match.awayTeam.rating) / 1000; // Strength difference between the teams
+        const P1 = MatchRating.calculateProbability(MatchRating.C1 + D); // 3-0
+        const P2 = MatchRating.calculateProbability(MatchRating.C2 + D) -
+            MatchRating.calculateProbability(MatchRating.C1 + D); // 3-1
+        const P3 = MatchRating.calculateProbability(MatchRating.C3 + D) -
+            MatchRating.calculateProbability(MatchRating.C2 + D); // 3-2
+        const P4 = MatchRating.calculateProbability(MatchRating.C4 + D) -
+            MatchRating.calculateProbability(MatchRating.C3 + D); // 2-3
+        const P5 = MatchRating.calculateProbability(MatchRating.C5 + D) -
+            MatchRating.calculateProbability(MatchRating.C4 + D); // 1-3
+        const P6 = 1 - MatchRating.calculateProbability(MatchRating.C5 + D); // 0-3
+        return P1 * MatchRating.SSV['3-0'] +
+            P2 * MatchRating.SSV['3-1'] +
+            P3 * MatchRating.SSV['3-2'] +
+            P4 * MatchRating.SSV['2-3'] +
+            P5 * MatchRating.SSV['1-3'] +
+            P6 * MatchRating.SSV['0-3']; // Expected Match Result EMR
+    }
+}
+MatchRating.K = 8; // Standard scaling factor
+MatchRating.SSV = {
+    [MatchScore['3-0']]: 2,
+    [MatchScore['3-1']]: 1.5,
+    [MatchScore['3-2']]: 1,
+    [MatchScore['2-3']]: -1,
+    [MatchScore['1-3']]: -1.5,
+    [MatchScore['0-3']]: -2
+};
+MatchRating.C1 = -1.060;
+MatchRating.C2 = -0.394;
+MatchRating.C3 = 0;
+MatchRating.C4 = 0.394;
+MatchRating.C5 = 1.060;
+MatchRating.MWF = {
+    TOURNAMENT: 50,
+    LEAGUE: 35
+};

package/dist/esm/src/service/match/match-set.d.ts

@@ -0,0 +1,65 @@
+import { PlayerPosition, Rally } from './rally';
+import { MatchTeam } from './match-team';
+import { Player } from '../player';
+declare enum ScoreThreshold {
+    SET = 25,
+    TIE_BREAK = 15
+}
+interface MatchSetParams {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+    readonly homeScore: number;
+    readonly awayScore: number;
+    readonly stats: SetStatistics[];
+    readonly rallies: Rally[];
+}
+export interface EventStat {
+    success: number;
+    error: number;
+}
+export interface SetStatistics {
+    player: Player;
+    ace: number;
+    attempts: number;
+    contacts: number;
+    ralliesPlayed: number;
+    serve: EventStat;
+    reception: EventStat;
+    set: EventStat;
+    attack: EventStat;
+    block: EventStat;
+    kills: number;
+    killBlocks: number;
+    assists: number;
+}
+export declare class MatchSet {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+    readonly stats: SetStatistics[];
+    readonly rallies: Rally[];
+    readonly scoreThreshold: ScoreThreshold;
+    private _homeScore;
+    private _awayScore;
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, stats, rallies, homeScore, awayScore }: MatchSetParams);
+    get homeScore(): number;
+    get awayScore(): number;
+    increaseScore(team: MatchTeam): void;
+    addRally(rally: Rally): void;
+    /**
+     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver(): boolean;
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner(): MatchTeam;
+}
+export {};

package/dist/esm/src/service/match/match-set.js

@@ -0,0 +1,56 @@
+import { validateUUID } from '../utils';
+import { MatchTeam } from './match-team';
+var ScoreThreshold;
+(function (ScoreThreshold) {
+    ScoreThreshold[ScoreThreshold["SET"] = 25] = "SET";
+    ScoreThreshold[ScoreThreshold["TIE_BREAK"] = 15] = "TIE_BREAK";
+})(ScoreThreshold || (ScoreThreshold = {}));
+export class MatchSet {
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, stats, rallies, homeScore, awayScore }) {
+        validateUUID(id);
+        this.id = id;
+        this.order = order;
+        this._homeScore = homeScore;
+        this._awayScore = awayScore;
+        this.homePlayerPosition = homePlayerPosition;
+        this.awayPlayerPosition = awayPlayerPosition;
+        this.stats = stats;
+        this.rallies = rallies;
+        this.isTieBreak = isTieBreak;
+        this.scoreThreshold = isTieBreak ? ScoreThreshold.TIE_BREAK : ScoreThreshold.SET;
+    }
+    get homeScore() {
+        return this._homeScore;
+    }
+    get awayScore() {
+        return this._awayScore;
+    }
+    increaseScore(team) {
+        if (team === MatchTeam.HOME)
+            this._homeScore++;
+        else if (team === MatchTeam.AWAY)
+            this._awayScore++;
+        else
+            throw new Error('UNKNOWN_TEAM');
+    }
+    addRally(rally) {
+        this.rallies.push(rally);
+    }
+    /**
+     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver() {
+        return Math.abs(this.homeScore - this.awayScore) > 1 &&
+            (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
+    }
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_SET');
+        return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY;
+    }
+}

package/dist/esm/src/service/match/match-team.d.ts

@@ -0,0 +1,7 @@
+export declare enum MatchTeam {
+    HOME = "homeTeam",
+    AWAY = "awayTeam"
+}
+export declare namespace MatchTeam {
+    function otherTeam(team: MatchTeam): MatchTeam;
+}

package/dist/esm/src/service/match/match-team.js

@@ -0,0 +1,17 @@
+export var MatchTeam;
+(function (MatchTeam) {
+    MatchTeam["HOME"] = "homeTeam";
+    MatchTeam["AWAY"] = "awayTeam";
+})(MatchTeam || (MatchTeam = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (MatchTeam) {
+    function otherTeam(team) {
+        if (team === MatchTeam.HOME)
+            return MatchTeam.AWAY;
+        else if (team === MatchTeam.AWAY)
+            return MatchTeam.HOME;
+        else
+            throw new Error('UNKNOWN_MATCH_TEAM');
+    }
+    MatchTeam.otherTeam = otherTeam;
+})(MatchTeam || (MatchTeam = {}));

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

@@ -0,0 +1,44 @@
+import { MatchSet } from './match-set';
+import { Team } from '../team';
+import { MatchTeam } from './match-team';
+import { StatusEnum } from '../../data';
+interface MatchParams {
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly scheduledDate: Date;
+    readonly sets: MatchSet[];
+    readonly status: StatusEnum;
+    readonly homeScore?: number;
+    readonly awayScore?: number;
+    readonly winner?: Team;
+}
+export declare enum MatchScore {
+    '3-0' = "3-0",
+    '3-1' = "3-1",
+    '3-2' = "3-2",
+    '2-3' = "2-3",
+    '1-3' = "1-3",
+    '0-3' = "0-3"
+}
+export declare class Match {
+    static readonly BEST_OF = 5;
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly sets: MatchSet[];
+    readonly scheduledDate: Date;
+    readonly homeScore?: number;
+    readonly awayScore?: number;
+    readonly winner?: Team;
+    status: StatusEnum;
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner }: MatchParams);
+    addSet(set: MatchSet): void;
+    getTeamSets(team: MatchTeam): number;
+    getScore(): MatchScore;
+    isOver(): boolean;
+    getWinner(): Team;
+    isWinner(team: MatchTeam): boolean;
+    isSimulated(): boolean;
+}
+export {};

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

@@ -0,0 +1,64 @@
+import { validateUUID } from '../utils';
+import { MatchTeam } from './match-team';
+import { StatusEnum } from '../../data';
+export var MatchScore;
+(function (MatchScore) {
+    MatchScore["3-0"] = "3-0";
+    MatchScore["3-1"] = "3-1";
+    MatchScore["3-2"] = "3-2";
+    MatchScore["2-3"] = "2-3";
+    MatchScore["1-3"] = "1-3";
+    MatchScore["0-3"] = "0-3";
+})(MatchScore || (MatchScore = {}));
+export class Match {
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner }) {
+        validateUUID(id);
+        this.id = id;
+        this.homeTeam = homeTeam;
+        this.awayTeam = awayTeam;
+        this.scheduledDate = scheduledDate;
+        this.sets = sets;
+        this.status = status;
+        this.homeScore = homeScore;
+        this.awayScore = awayScore;
+        this.winner = winner;
+    }
+    addSet(set) {
+        if (this.sets.length >= Match.BEST_OF)
+            throw new Error('SET_AMOUNT_EXCEEDED');
+        this.sets.push(set);
+    }
+    getTeamSets(team) {
+        return this.sets.reduce((sets, set) => sets + (!set.isOver() ? 0 : set.getWinner() === team ? 1 : 0), 0);
+    }
+    getScore() {
+        return `${this.getTeamSets(MatchTeam.HOME)}-${this.getTeamSets(MatchTeam.AWAY)}`;
+    }
+    isOver() {
+        const gamesRequired = Math.ceil(Match.BEST_OF / 2);
+        const lastSet = this.sets.at(-1);
+        if (lastSet == null || !lastSet.isOver() || this.sets.length < gamesRequired)
+            return false;
+        const homeSets = this.getTeamSets(MatchTeam.HOME);
+        const awaySets = this.getTeamSets(MatchTeam.AWAY);
+        // Check if any of the teams has enough sets to win.
+        return !(homeSets < gamesRequired && awaySets < gamesRequired);
+    }
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_MATCH');
+        const homeSets = this.getTeamSets(MatchTeam.HOME);
+        const awaySets = this.getTeamSets(MatchTeam.AWAY);
+        return homeSets > awaySets ? this.homeTeam : this.awayTeam;
+    }
+    isWinner(team) {
+        if (team === MatchTeam.HOME && this.getWinner() === this.homeTeam)
+            return true;
+        else
+            return team === MatchTeam.AWAY && this.getWinner() === this.awayTeam;
+    }
+    isSimulated() {
+        return this.status === StatusEnum.COMPLETE;
+    }
+}
+Match.BEST_OF = 5;

package/dist/esm/src/service/match/rally.d.ts

@@ -0,0 +1,22 @@
+import { Team } from '../team';
+import { CourtPosition } from './court-position';
+import { RallyEvent } from '../event';
+interface RallyParams {
+    readonly id: string;
+    readonly order: number;
+    readonly servingTeam: Team;
+    readonly events: RallyEvent[];
+}
+export interface PlayerPosition {
+    position: CourtPosition;
+    playerId: string;
+}
+export declare class Rally {
+    readonly id: string;
+    readonly servingTeam: Team;
+    readonly events: RallyEvent[];
+    readonly order: number;
+    constructor({ id, order, servingTeam, events }: RallyParams);
+    addEvent(event: RallyEvent): void;
+}
+export {};

package/dist/esm/src/service/match/rally.js

@@ -0,0 +1,13 @@
+import { validateUUID } from '../utils';
+export class Rally {
+    constructor({ id, order, servingTeam, events }) {
+        validateUUID(id);
+        this.id = id;
+        this.order = order;
+        this.servingTeam = servingTeam;
+        this.events = events;
+    }
+    addEvent(event) {
+        this.events.push(event);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,30 @@
+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 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);
+    toString(): string;
+    static fromAverage(average: number): PerformanceStats;
+}

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

@@ -0,0 +1,34 @@
+import { getKeys } from '../utils';
+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;
+    }
+    toString() {
+        return getKeys(this).map(key => `${key}: ${this[key]}`).join(', ');
+    }
+    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
+        });
+    }
+}

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

@@ -0,0 +1,49 @@
+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';
+export declare class Stat {
+    readonly name: GeneralStat.Stats;
+    readonly value: number;
+    constructor({ name, value }: {
+        name: GeneralStat.Stats;
+        value: number;
+    });
+    toString(): string;
+}
+interface PlayerParams {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+    readonly rarity: Rarity;
+}
+export declare class Name {
+    readonly first: string;
+    readonly last: string;
+    constructor({ first, last }: {
+        first: string;
+        last: string;
+    });
+    toString(): string;
+}
+export declare class Player {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+    readonly generalStats: Stat[];
+    readonly rarity: Rarity;
+    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

@@ -0,0 +1,85 @@
+import { Role } from './role';
+import { validateUUID } from '../utils';
+import * as GeneralStat from '../../formula/stats';
+export class Stat {
+    constructor({ name, value }) {
+        this.name = name;
+        this.value = value;
+    }
+    toString() {
+        return `${this.name}: ${this.value}`;
+    }
+}
+export class Name {
+    constructor({ first, last }) {
+        this.first = first;
+        this.last = last;
+    }
+    toString() {
+        return `${this.first} ${this.last}`;
+    }
+}
+export class Player {
+    constructor({ id, name, country, stats, roles, traits, rarity }) {
+        validateUUID(id);
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.stats = stats;
+        this.roles = roles;
+        this.traits = traits;
+        this.rarity = rarity;
+        this.generalStats = GeneralStat.ALL_STATS.map(stat => ({
+            name: stat,
+            value: GeneralStat.calculateScore(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);
+            return x + p2Score - p1Score;
+        }, 0);
+    }
+    static compareStats(p1, p2) {
+        const compareFn = (acc, current) => {
+            let x = current.value;
+            switch (current.name) {
+                case 'ATTACK':
+                    x *= 0.35;
+                    break;
+                case 'DEFENSE':
+                    x *= 0.35;
+                    break;
+                case 'SERVE':
+                    x *= 0.2;
+                    break;
+                case 'PHYSICAL':
+                    x *= 0.1;
+                    break;
+                default:
+                    x *= 0;
+            }
+            return acc + x;
+        };
+        const s1 = p1.generalStats.reduce(compareFn, 0);
+        const s2 = p2.generalStats.reduce(compareFn, 0);
+        return s2 - s1;
+    }
+    canPlayLibero() {
+        return this.roles.includes(Role.LIBERO);
+    }
+    toString() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name.toString(),
+            country: this.country.toString(),
+            stats: this.stats.toString(),
+            rarity: this.rarity,
+            roles: `[${this.roles.map(r => r.toString()).join(',')}]`,
+            traits: `[${this.traits.map(r => r.toString()).join(',')}]`,
+            generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+export declare enum Rarity {
+    COMMON = "COMMON",
+    RARE = "RARE",
+    LEGENDARY = "LEGENDARY",
+    MYTHIC = "MYTHIC",
+    SPECIAL = "SPECIAL"
+}
+export declare const RarityRanges: {
+    COMMON: number[];
+    RARE: number[];
+    LEGENDARY: number[];
+    MYTHIC: number[];
+    SPECIAL: number[];
+};

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

@@ -0,0 +1,15 @@
+export var Rarity;
+(function (Rarity) {
+    Rarity["COMMON"] = "COMMON";
+    Rarity["RARE"] = "RARE";
+    Rarity["LEGENDARY"] = "LEGENDARY";
+    Rarity["MYTHIC"] = "MYTHIC";
+    Rarity["SPECIAL"] = "SPECIAL";
+})(Rarity || (Rarity = {}));
+export const RarityRanges = {
+    [Rarity.COMMON]: [0, 50],
+    [Rarity.RARE]: [51, 70],
+    [Rarity.LEGENDARY]: [71, 85],
+    [Rarity.MYTHIC]: [86, 98],
+    [Rarity.SPECIAL]: [99, 100]
+};

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

@@ -0,0 +1,16 @@
+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[];
+}

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

@@ -0,0 +1,40 @@
+import { rolesFormula } from '../../formula';
+export class Role {
+    constructor(name) {
+        this.name = name;
+    }
+    toString() {
+        return this.name;
+    }
+    static getRoles() {
+        return [...Role.ROLES];
+    }
+    static calculateScore(stats, role) {
+        const weights = 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);
+    }
+    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;
+    }
+}
+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];