volleyballsimtypes 0.0.217 → 0.0.356

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

@@ -1,17 +0,0 @@
-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

@@ -1,38 +0,0 @@
-import { MatchSet } from './match-set';
-import { Team } from '../team';
-import { MatchTeam } from './match-team';
-import { StatusEnum } from '../../data';
-import { VPER } from './vper';
-interface MatchParams {
-    readonly id: string;
-    readonly homeTeam: Team;
-    readonly awayTeam: Team;
-    readonly scheduledDate: Date;
-    readonly sets: MatchSet[];
-    readonly status: StatusEnum;
-    readonly VPERs: VPER[];
-    homeScore?: number;
-    awayScore?: number;
-    winner?: Team;
-}
-export type MatchScore = '3-0' | '3-1' | '3-2' | '2-3' | '1-3' | '0-3';
-export type SetScore = 0 | 1 | 2 | 3;
-export declare class Match {
-    readonly id: string;
-    readonly homeTeam: Team;
-    readonly awayTeam: Team;
-    readonly sets: MatchSet[];
-    readonly scheduledDate: Date;
-    readonly VPERs: VPER[];
-    homeScore?: number;
-    awayScore?: number;
-    winner?: Team;
-    status: StatusEnum;
-    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner, VPERs }: MatchParams);
-    addSet(set: MatchSet): void;
-    getTeamSets(team: MatchTeam): SetScore;
-    getScore(): MatchScore;
-    isOver(): boolean;
-    getWinner(): Team;
-}
-export {};

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

@@ -1,48 +0,0 @@
-import { validateUUID } from '../utils';
-import { MatchTeam } from './match-team';
-import { StatusEnum } from '../../data';
-export class Match {
-    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner, VPERs }) {
-        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;
-        this.VPERs = VPERs;
-    }
-    addSet(set) {
-        if (this.sets.length >= 5)
-            throw new Error('SET_AMOUNT_EXCEEDED');
-        this.sets.push(set);
-    }
-    getTeamSets(team) {
-        const sets = this.sets.reduce((sets, set) => sets + (!set.isOver() ? 0 : set.getWinner() === team ? 1 : 0), 0);
-        if (sets > 3 || sets < 0)
-            throw new Error(`INCORRECT_SET_VALUE: ${sets}`);
-        return sets;
-    }
-    getScore() {
-        return `${this.getTeamSets(MatchTeam.HOME)}-${this.getTeamSets(MatchTeam.AWAY)}`;
-    }
-    isOver() {
-        if (this.status === StatusEnum.COMPLETE)
-            return true;
-        const setsToWin = 3;
-        const homeSets = this.getTeamSets(MatchTeam.HOME);
-        const awaySets = this.getTeamSets(MatchTeam.AWAY);
-        return !(homeSets < setsToWin && awaySets < setsToWin);
-    }
-    getWinner() {
-        if (!this.isOver()) {
-            throw new Error(`UNFINISHED_MATCH: ${this.id}, homeSets=[${this.sets.map(s => s.homeScore).join(', ')}], awaySets=[${this.sets.map(s => s.awayScore).join(', ')}], status=${this.status}`);
-        }
-        const homeSets = this.getTeamSets(MatchTeam.HOME);
-        const awaySets = this.getTeamSets(MatchTeam.AWAY);
-        return homeSets > awaySets ? this.homeTeam : this.awayTeam;
-    }
-}

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

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

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

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

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

@@ -1,13 +0,0 @@
-import { BoxScore } from './box-score';
-export interface VPERParams {
-    readonly playerId: string;
-    readonly matchId: string;
-    readonly value: number;
-}
-export declare class VPER {
-    readonly playerId: string;
-    readonly matchId: string;
-    readonly value: number;
-    constructor({ playerId, matchId, value }: VPERParams);
-    static computeVPERForMatch(boxScores: BoxScore[]): number;
-}

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

@@ -1,52 +0,0 @@
-const WEIGHTS = {
-    // terminal positive
-    ATTACK_KILL: 1.0,
-    SERVE_ACE: 1.0,
-    BLOCK_SOLO: 1.0,
-    BLOCK_ASSIST: 0.5,
-    // creation / continuation
-    SETTING_ASSIST: 0.7,
-    BLOCK_TOUCH: 0.2,
-    DEFENSE_DIG: 0.25,
-    SETTING_PASS: 0.15,
-    // reception quality
-    RECEPTION_PERFECT: 0.35,
-    RECEPTION_POSITIVE: 0.15,
-    RECEPTION_OVERPASS: -0.6,
-    // terminal errors (always point against)
-    TERMINAL_ERROR: -1.0
-};
-export class VPER {
-    constructor({ playerId, matchId, value }) {
-        this.matchId = matchId;
-        this.playerId = playerId;
-        this.value = value;
-    }
-    static computeVPERForMatch(boxScores) {
-        let rawSum = 0;
-        let pointsPlayedSum = 0;
-        for (const box of boxScores) {
-            const w = WEIGHTS;
-            const positive = w.ATTACK_KILL * box.attack.kills +
-                w.SERVE_ACE * box.serve.aces +
-                w.BLOCK_SOLO * box.block.solo +
-                w.BLOCK_ASSIST * box.block.assists +
-                w.SETTING_ASSIST * box.setting.assists +
-                w.BLOCK_TOUCH * box.block.touches +
-                w.DEFENSE_DIG * box.defense.digs +
-                w.SETTING_PASS * box.setting.pass +
-                w.RECEPTION_PERFECT * box.reception.perfect +
-                w.RECEPTION_POSITIVE * box.reception.positive;
-            const negative = w.RECEPTION_OVERPASS * box.reception.overpasses +
-                w.TERMINAL_ERROR * (box.attack.errors +
-                    box.serve.errors +
-                    box.reception.errors +
-                    box.defense.errors +
-                    box.block.errors +
-                    box.setting.errors);
-            rawSum += positive + negative;
-            pointsPlayedSum += box.misc.pointsPlayed;
-        }
-        return 100 * rawSum / Math.max(1, pointsPlayedSum);
-    }
-}

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

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

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

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

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

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

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

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

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

@@ -1,53 +0,0 @@
-import { PerformanceStats } from './performance-stats';
-import { Trait } from './trait';
-import { Country } from '../country';
-import { Rarity } from './rarity';
-import { Stats } from './stats';
-import { Role } from './role';
-import { BoxScore, BoxScoreTotals } from '../match';
-export declare class Stat {
-    readonly name: Stats;
-    readonly value: number;
-    constructor({ name, value }: {
-        name: 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;
-    readonly boxScores?: BoxScore[];
-    readonly boxScoreTotals?: BoxScoreTotals;
-}
-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;
-    readonly boxScores?: BoxScore[];
-    readonly boxScoreTotals?: BoxScoreTotals;
-    constructor({ id, name, country, stats, roles, traits, rarity, boxScores, boxScoreTotals }: PlayerParams);
-    static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
-    static compareStats(p1: Player, p2: Player): number;
-    toString(): string;
-}
-export {};

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

@@ -1,90 +0,0 @@
-import { validateUUID } from '../utils';
-import { calculateStatScore, StatsEnum } from './stats';
-import { calculateRoleScore } from './role';
-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, boxScores, boxScoreTotals }) {
-        validateUUID(id);
-        this.id = id;
-        this.name = name;
-        this.country = country;
-        this.stats = stats;
-        this.roles = roles;
-        this.traits = traits;
-        this.rarity = rarity;
-        this.boxScores = boxScores;
-        this.boxScoreTotals = boxScoreTotals;
-        this.generalStats = Object.values(StatsEnum).map((stat) => ({
-            name: 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 = calculateRoleScore(p2.stats, role);
-            const p1Score = calculateRoleScore(p1.stats, role);
-            return x + p2Score - p1Score;
-        }, 0);
-    }
-    static compareStats(p1, p2) {
-        const compareFn = (acc, current) => {
-            let x = current.value;
-            switch (current.name) {
-                case StatsEnum.ATTACK:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.SET:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.RECEIVE:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.BLOCK:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.SERVE:
-                    x *= 0.19;
-                    break;
-                case StatsEnum.STAMINA:
-                    x *= 0.05;
-                    break;
-                default:
-                    x *= 0;
-            }
-            return acc + x;
-        };
-        const s1 = p1.generalStats.reduce(compareFn, 0);
-        const s2 = p2.generalStats.reduce(compareFn, 0);
-        return s2 - s1;
-    }
-    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(t => t.toString()).join(',')}]`,
-            generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
-        });
-    }
-}

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

@@ -1,15 +0,0 @@
-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[];
-    LEGENDARY: number[];
-    MYTHIC: number[];
-    SPECIAL: number[];
-};

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

@@ -1,15 +0,0 @@
-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 = {
-    [RarityEnum.COMMON]: [0, 50],
-    [RarityEnum.RARE]: [51, 70],
-    [RarityEnum.LEGENDARY]: [71, 85],
-    [RarityEnum.MYTHIC]: [86, 98],
-    [RarityEnum.SPECIAL]: [99, 100]
-};

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

@@ -1,15 +0,0 @@
-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 interface RolesFormula {
-    role: Role;
-    weight: PerformanceStatsParams;
-}
-export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
-export declare function assignRoles(stats: PerformanceStats): Role[];

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

@@ -1,44 +0,0 @@
-import roles from '../../stat-config/roles.json';
-export 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 || (RoleEnum = {}));
-const rolesFormula = roles;
-export 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);
-}
-export 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);
-    }
-    if (scores[2].score >= 82) {
-        out.push(scores[2].role);
-    }
-    if (scores[3].score >= 89) {
-        out.push(scores[3].role);
-    }
-    if (scores[4].score >= 95) {
-        out.push(scores[4].role);
-    }
-    return out;
-}

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

@@ -1,12 +0,0 @@
-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/esm/src/service/player/stats.js

@@ -1,63 +0,0 @@
-export var StatsEnum;
-(function (StatsEnum) {
-    StatsEnum["ATTACK"] = "ATTACK";
-    StatsEnum["SET"] = "SET";
-    StatsEnum["RECEIVE"] = "RECEIVE";
-    StatsEnum["SERVE"] = "SERVE";
-    StatsEnum["BLOCK"] = "BLOCK";
-    StatsEnum["STAMINA"] = "STAMINA";
-})(StatsEnum || (StatsEnum = {}));
-export 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);
-}
-export 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.75,
-                overhand: 0.1,
-                awareness: 0.075,
-                attack: 0.075
-            };
-        case StatsEnum.RECEIVE:
-            return {
-                reception: 0.75,
-                overhand: 0.015,
-                bump: 0.15,
-                focus: 0.015,
-                defense: 0.055,
-                reflex: 0.015
-            };
-        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.04,
-                defense: 0.04,
-                reflex: 0.02
-            };
-        case StatsEnum.STAMINA:
-            return { stamina: 1 };
-        default:
-            throw new Error('INVALID_STAT');
-    }
-}

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

@@ -1,51 +0,0 @@
-import { Rarity } from './rarity';
-import { Role } from './role';
-interface TraitProps {
-    readonly name: Trait;
-    readonly modifier: number;
-    readonly chance: number;
-    readonly roles: Role[];
-}
-export declare enum TraitEnum {
-    /**
-     * When triggered, all actions before the net crossing have a bonus.
-     * Can only be triggered during the first or second touch.
-     */
-    MASTER_MIND = "MASTER_MIND",
-    /**
-     * When this player is part of the front row, they will always be part of the blocking block
-     */
-    MOVING_WALL = "MOVING_WALL",
-    /**
-     * Enables the player making the second touch to spike or dump
-     */
-    SURPRISE_ATTACK = "SURPRISE_ATTACK",
-    /**
-     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
-     */
-    MARKSMAN = "MARKSMAN",
-    /**
-     * The server will perform an extra strong serve.
-     */
-    METEOR_SERVE = "METEOR_SERVE",
-    /**
-     * The player has a 50% chance to perform an action with no energy decrease
-     */
-    VIGOROUS = "VIGOROUS",
-    /**
-     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
-     */
-    GUARDIAN = "GUARDIAN",
-    /**
-     * Enables the server to perform a float serve, which checks against receiver overhand instead.
-     */
-    FLOAT_SERVE = "FLOAT_SERVE",
-    /**
-     * Gives the player a chance to perform a perfect reception.
-     */
-    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
-}
-export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.SURPRISE_ATTACK | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS | TraitEnum.DEFENSIVE_SPECIALIST;
-export declare function assignTraits(roles: Role[], rarity: Rarity): Trait[];
-export declare const traitMap: Map<Trait, TraitProps>;
-export {};