volleyballsimtypes 0.0.356 → 0.0.358

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

@@ -0,0 +1,80 @@
+import { RarityEnum } from './rarity';
+import { randomInt } from 'node:crypto';
+import rawTraits from '../../stat-config/traits.json';
+import { shuffle } from '../utils';
+const traits = rawTraits;
+export var TraitEnum;
+(function (TraitEnum) {
+    /**
+     * When triggered, all actions before the net crossing have a bonus.
+     * Can only be triggered during the first or second touch.
+     */
+    TraitEnum["MASTER_MIND"] = "MASTER_MIND";
+    /**
+     * When this player is part of the front row, they will always be part of the blocking block
+     */
+    TraitEnum["MOVING_WALL"] = "MOVING_WALL";
+    /**
+     * Enables the player making the second touch to spike or dump
+     */
+    TraitEnum["SURPRISE_ATTACK"] = "SURPRISE_ATTACK";
+    /**
+     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
+     */
+    TraitEnum["MARKSMAN"] = "MARKSMAN";
+    /**
+     * The server will perform an extra strong serve.
+     */
+    TraitEnum["METEOR_SERVE"] = "METEOR_SERVE";
+    /**
+     * The player has a 50% chance to perform an action with no energy decrease
+     */
+    TraitEnum["VIGOROUS"] = "VIGOROUS";
+    /**
+     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
+     */
+    TraitEnum["GUARDIAN"] = "GUARDIAN";
+    /**
+     * Enables the server to perform a float serve, which checks against receiver overhand instead.
+     */
+    TraitEnum["FLOAT_SERVE"] = "FLOAT_SERVE";
+    /**
+     * Gives the player a chance to perform a perfect reception.
+     */
+    TraitEnum["DEFENSIVE_SPECIALIST"] = "DEFENSIVE_SPECIALIST";
+})(TraitEnum || (TraitEnum = {}));
+export function assignTraits(roles, rarity, maxTraits) {
+    let traitCount;
+    switch (rarity) {
+        case RarityEnum.COMMON: {
+            traitCount = maxTraits === true ? 0 : randomInt(0, 1);
+            break;
+        }
+        case RarityEnum.RARE: {
+            traitCount = maxTraits === true ? 1 : randomInt(0, 2);
+            break;
+        }
+        case RarityEnum.LEGENDARY: {
+            traitCount = maxTraits === true ? 2 : randomInt(1, 3);
+            break;
+        }
+        case RarityEnum.MYTHIC: {
+            traitCount = maxTraits === true ? 3 : randomInt(2, 4);
+            break;
+        }
+        case RarityEnum.SPECIAL: {
+            traitCount = 4;
+            break;
+        }
+        default:
+            throw new Error('INVALID_RARITY');
+    }
+    if (traitCount < 1)
+        return [];
+    const filteredTraits = traits.filter((trait) => {
+        const setA = new Set(trait.roles);
+        return roles.some(el => setA.has(el));
+    }).map(trait => trait.name);
+    return shuffle(filteredTraits).slice(0, traitCount);
+}
+export const traitMap = new Map(traits.map((trait) => [trait.name, trait]));

package/dist/esm/src/service/team/formation.d.ts

@@ -0,0 +1,30 @@
+import { Role } from '../player';
+import { CourtPosition } from '../match';
+interface PositionRole {
+    readonly [CourtPosition.LEFT_FRONT]: Role[];
+    readonly [CourtPosition.MIDDLE_FRONT]: Role[];
+    readonly [CourtPosition.RIGHT_FRONT]: Role[];
+    readonly [CourtPosition.LEFT_BACK]: Role[];
+    readonly [CourtPosition.MIDDLE_BACK]: Role[];
+    readonly [CourtPosition.RIGHT_BACK]: Role[];
+}
+export interface SubPriority {
+    readonly MIDDLE_BLOCKER: number;
+    readonly OUTSIDE_HITTER: number;
+    readonly OPPOSITE_HITTER: number;
+    readonly SETTER: number;
+    readonly LIBERO: number;
+}
+export declare class Formation {
+    static readonly '5-1': Formation;
+    static readonly '4-2': Formation;
+    static readonly '6-2': Formation;
+    readonly name: string;
+    readonly initialRotation: PositionRole;
+    readonly base: PositionRole;
+    readonly liberoSubPriority: SubPriority;
+    static create(input: unknown): Formation;
+    private constructor();
+    static getFormations(): Formation[];
+}
+export {};

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

@@ -0,0 +1,104 @@
+import { RoleEnum } from '../player';
+import { CourtPosition } from '../match';
+import { FormationInputSchema } from './schemas/formation.z';
+export class Formation {
+    static create(input) {
+        const result = FormationInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_FORMATION: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Formation(result.data);
+    }
+    constructor({ name, initialRotation, base, liberoSubPriority }) {
+        this.name = name;
+        this.initialRotation = initialRotation;
+        this.base = base;
+        this.liberoSubPriority = liberoSubPriority;
+    }
+    static getFormations() {
+        return [this['4-2'], this['5-1'], this['6-2']];
+    }
+}
+Formation['5-1'] = Formation.create({
+    name: '5-1',
+    initialRotation: {
+        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: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER]
+    },
+    liberoSubPriority: {
+        MIDDLE_BLOCKER: 1,
+        OUTSIDE_HITTER: 10,
+        OPPOSITE_HITTER: 100,
+        SETTER: 1000,
+        LIBERO: 10000
+    }
+});
+Formation['4-2'] = Formation.create({
+    name: '4-2',
+    initialRotation: {
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OUTSIDE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.SETTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.MIDDLE_BLOCKER]
+    },
+    base: {
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.SETTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER]
+    },
+    liberoSubPriority: {
+        MIDDLE_BLOCKER: 1,
+        OUTSIDE_HITTER: 10,
+        OPPOSITE_HITTER: 100,
+        SETTER: 1000,
+        LIBERO: 10000
+    }
+});
+Formation['6-2'] = Formation.create({
+    name: '6-2',
+    initialRotation: {
+        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER, RoleEnum.OUTSIDE_HITTER],
+        2: [RoleEnum.OUTSIDE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER, RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.MIDDLE_BLOCKER]
+    },
+    base: {
+        1: [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        2: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER]
+    },
+    liberoSubPriority: {
+        MIDDLE_BLOCKER: 1,
+        OUTSIDE_HITTER: 10,
+        OPPOSITE_HITTER: 100,
+        SETTER: 1000,
+        LIBERO: 10000
+    }
+});

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

@@ -0,0 +1,4 @@
+export * from './team';
+export * from './team-generator';
+export * from './formation';
+export * from './tactics';

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

@@ -0,0 +1,4 @@
+export * from './team';
+export * from './team-generator';
+export * from './formation';
+export * from './tactics';

package/dist/esm/src/service/team/schemas/formation.z.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { RoleEnum } from '../../player';
+export declare const FormationInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    initialRotation: z.ZodObject<{
+        4: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        3: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        2: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        5: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        6: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        1: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+    }, z.core.$strip>;
+    base: z.ZodObject<{
+        4: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        3: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        2: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        5: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        6: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+        1: z.ZodArray<z.ZodEnum<{
+            SETTER: RoleEnum.SETTER;
+            LIBERO: RoleEnum.LIBERO;
+            OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+            OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+            MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+        }>>;
+    }, z.core.$strip>;
+    liberoSubPriority: z.ZodObject<{
+        MIDDLE_BLOCKER: z.ZodNumber;
+        OUTSIDE_HITTER: z.ZodNumber;
+        OPPOSITE_HITTER: z.ZodNumber;
+        SETTER: z.ZodNumber;
+        LIBERO: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FormationInput = z.infer<typeof FormationInputSchema>;

package/dist/esm/src/service/team/schemas/formation.z.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { RoleEnum } from '../../player';
+const roleSchema = z.enum(Object.values(RoleEnum));
+const LEFT_FRONT = 4;
+const MIDDLE_FRONT = 3;
+const RIGHT_FRONT = 2;
+const LEFT_BACK = 5;
+const MIDDLE_BACK = 6;
+const RIGHT_BACK = 1;
+const positionRoleSchema = z.object({
+    [LEFT_FRONT]: z.array(roleSchema).min(1),
+    [MIDDLE_FRONT]: z.array(roleSchema).min(1),
+    [RIGHT_FRONT]: z.array(roleSchema).min(1),
+    [LEFT_BACK]: z.array(roleSchema).min(1),
+    [MIDDLE_BACK]: z.array(roleSchema).min(1),
+    [RIGHT_BACK]: z.array(roleSchema).min(1)
+});
+const subPrioritySchema = z.object({
+    MIDDLE_BLOCKER: z.number().int().min(1),
+    OUTSIDE_HITTER: z.number().int().min(1),
+    OPPOSITE_HITTER: z.number().int().min(1),
+    SETTER: z.number().int().min(1),
+    LIBERO: z.number().int().min(1)
+});
+export const FormationInputSchema = z.object({
+    name: z.string().trim().min(1),
+    initialRotation: positionRoleSchema,
+    base: positionRoleSchema,
+    liberoSubPriority: subPrioritySchema
+});

package/dist/esm/src/service/team/schemas/tactics.z.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { Player } from '../../player';
+export declare const TacticsInputSchema: z.ZodObject<{
+    lineup: z.ZodObject<{
+        4: z.ZodCustom<Player, Player>;
+        3: z.ZodCustom<Player, Player>;
+        2: z.ZodCustom<Player, Player>;
+        5: z.ZodCustom<Player, Player>;
+        6: z.ZodCustom<Player, Player>;
+        1: z.ZodCustom<Player, Player>;
+        0: z.ZodOptional<z.ZodCustom<Player, Player>>;
+        bench: z.ZodArray<z.ZodCustom<Player, Player>>;
+    }, z.core.$strip>;
+    substitutionTolerance: z.ZodNumber;
+    liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+    pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
+}, z.core.$strip>;
+export type TacticsInput = z.infer<typeof TacticsInputSchema>;

package/dist/esm/src/service/team/schemas/tactics.z.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { Player } from '../../player';
+const playerInstanceSchema = z.custom((v) => v instanceof Player, {
+    message: 'INVALID_PLAYER_INSTANCE'
+});
+const LEFT_FRONT = 4;
+const MIDDLE_FRONT = 3;
+const RIGHT_FRONT = 2;
+const LEFT_BACK = 5;
+const MIDDLE_BACK = 6;
+const RIGHT_BACK = 1;
+const LIBERO_ZONE = 0;
+const lineupSchema = z.object({
+    [LEFT_FRONT]: playerInstanceSchema,
+    [MIDDLE_FRONT]: playerInstanceSchema,
+    [RIGHT_FRONT]: playerInstanceSchema,
+    [LEFT_BACK]: playerInstanceSchema,
+    [MIDDLE_BACK]: playerInstanceSchema,
+    [RIGHT_BACK]: playerInstanceSchema,
+    [LIBERO_ZONE]: playerInstanceSchema.optional(),
+    bench: z.array(playerInstanceSchema)
+}).superRefine((data, ctx) => {
+    const players = [
+        data[LEFT_FRONT],
+        data[MIDDLE_FRONT],
+        data[RIGHT_FRONT],
+        data[LEFT_BACK],
+        data[MIDDLE_BACK],
+        data[RIGHT_BACK],
+        ...(data[LIBERO_ZONE] != null ? [data[LIBERO_ZONE]] : []),
+        ...data.bench
+    ];
+    const ids = players.map(p => p.id);
+    const uniqueCount = new Set(ids).size;
+    if (uniqueCount !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'LINEUP_HAS_DUPLICATE_PLAYERS',
+            path: ['bench']
+        });
+    }
+});
+export const TacticsInputSchema = z.object({
+    lineup: lineupSchema,
+    substitutionTolerance: z.number().int().min(1).max(50),
+    liberoReplacements: z.array(playerInstanceSchema),
+    pinchServerSubs: z.custom((v) => v instanceof Map &&
+        Array.from(v.entries()).every(([k, val]) => k instanceof Player && val instanceof Player), { message: 'INVALID_PINCH_SERVER_SUBS' })
+});

package/dist/esm/src/service/team/schemas/team.z.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { Player } from '../../player';
+import { Country } from '../../country';
+export declare const TeamInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    rating: z.ZodNumber;
+    name: z.ZodString;
+    shortName: z.ZodString;
+    divisionId: z.ZodUUID;
+    roster: z.ZodArray<z.ZodCustom<Player, Player>>;
+    country: z.ZodCustom<Country, Country>;
+    tactics: z.ZodOptional<z.ZodObject<{
+        lineup: z.ZodObject<{
+            4: z.ZodCustom<Player, Player>;
+            3: z.ZodCustom<Player, Player>;
+            2: z.ZodCustom<Player, Player>;
+            5: z.ZodCustom<Player, Player>;
+            6: z.ZodCustom<Player, Player>;
+            1: z.ZodCustom<Player, Player>;
+            0: z.ZodOptional<z.ZodCustom<Player, Player>>;
+            bench: z.ZodArray<z.ZodCustom<Player, Player>>;
+        }, z.core.$strip>;
+        substitutionTolerance: z.ZodNumber;
+        liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+        pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TeamInput = z.infer<typeof TeamInputSchema>;

package/dist/esm/src/service/team/schemas/team.z.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { Player } from '../../player';
+import { Country } from '../../country';
+import { TacticsInputSchema } from './tactics.z';
+const playerInstanceSchema = z.custom((v) => v instanceof Player, {
+    message: 'INVALID_PLAYER_INSTANCE'
+});
+const countrySchema = z.custom((v) => v instanceof Country, {
+    message: 'INVALID_COUNTRY_INSTANCE'
+});
+export const TeamInputSchema = z.object({
+    id: z.uuid(),
+    rating: z.number().finite(),
+    name: z.string().trim().min(1),
+    shortName: z.string().trim().min(1),
+    divisionId: z.uuid(),
+    roster: z.array(playerInstanceSchema),
+    country: countrySchema,
+    tactics: TacticsInputSchema.optional()
+}).superRefine((data, ctx) => {
+    const ids = data.roster.map(p => p.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'TEAM_ROSTER_HAS_DUPLICATE_PLAYERS',
+            path: ['roster']
+        });
+    }
+});

package/dist/esm/src/service/team/tactics.d.ts

@@ -0,0 +1,27 @@
+import { CourtPosition } from '../match';
+import { Player } from '../player';
+export interface StartingLineup {
+    readonly [CourtPosition.LEFT_FRONT]: Player;
+    readonly [CourtPosition.MIDDLE_FRONT]: Player;
+    readonly [CourtPosition.RIGHT_FRONT]: Player;
+    readonly [CourtPosition.LEFT_BACK]: Player;
+    readonly [CourtPosition.MIDDLE_BACK]: Player;
+    readonly [CourtPosition.RIGHT_BACK]: Player;
+    readonly [CourtPosition.LIBERO_ZONE]?: Player;
+    readonly bench: Player[];
+}
+export interface TacticsOpts {
+    readonly lineup: StartingLineup;
+    readonly substitutionTolerance: number;
+    readonly liberoReplacements: Player[];
+    readonly pinchServerSubs: Map<Player, Player>;
+}
+export declare class Tactics {
+    readonly lineup: StartingLineup;
+    readonly substitutionTolerance: number;
+    readonly liberoReplacements: Player[];
+    readonly pinchServerSubs: Map<Player, Player>;
+    static create(input: unknown): Tactics;
+    private constructor();
+    findPlayerInLineup(id: string): CourtPosition | undefined;
+}

package/dist/esm/src/service/team/tactics.js

@@ -0,0 +1,40 @@
+import { CourtPosition } from '../match';
+import { TacticsInputSchema } from './schemas/tactics.z';
+export class Tactics {
+    static create(input) {
+        const result = TacticsInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_TACTICS: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Tactics(result.data);
+    }
+    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1 }) {
+        this.lineup = lineup;
+        this.substitutionTolerance = substitutionTolerance;
+        this.pinchServerSubs = pinchServerSubs;
+        this.liberoReplacements = liberoReplacements;
+    }
+    findPlayerInLineup(id) {
+        if (this.lineup.bench.some(p => p.id === id))
+            return CourtPosition.NOT_IN_COURT;
+        if (this.lineup[CourtPosition.LEFT_FRONT].id === id)
+            return CourtPosition.LEFT_FRONT;
+        if (this.lineup[CourtPosition.MIDDLE_FRONT].id === id)
+            return CourtPosition.MIDDLE_FRONT;
+        if (this.lineup[CourtPosition.RIGHT_FRONT].id === id)
+            return CourtPosition.RIGHT_FRONT;
+        if (this.lineup[CourtPosition.LEFT_BACK].id === id)
+            return CourtPosition.LEFT_BACK;
+        if (this.lineup[CourtPosition.MIDDLE_BACK].id === id)
+            return CourtPosition.MIDDLE_BACK;
+        if (this.lineup[CourtPosition.RIGHT_BACK].id === id)
+            return CourtPosition.RIGHT_BACK;
+        if (this.lineup[CourtPosition.LIBERO_ZONE]?.id === id)
+            return CourtPosition.LIBERO_ZONE;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Player, RarityEnum, Role } from '../player';
+import { Team } from './team';
+import { Country } from '../country';
+import { Tactics } from './tactics';
+export declare class TeamGenerator {
+    static readonly TEAM_PER_DIVISION = 16;
+    static readonly RARITIES: RarityEnum[];
+    static readonly ROLES: Role[];
+    private static getFormation;
+    private static comparePlayers;
+    static createRoster(country: Country): Player[];
+    static createTeams(divisionId: string, country: Country): Team[];
+    static createTactics(roster: Player[]): Tactics;
+    private static createLineup;
+}

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

@@ -0,0 +1,97 @@
+import { v4 as uuidv4 } from 'uuid';
+import { calculateRoleScore, Player, PlayerGenerator, RarityEnum, RoleEnum } from '../player';
+import { generateGenericTeamNames, randomNumber } from '../utils';
+import { Team } from './team';
+import { Tactics } from './tactics';
+import { Formation } from './formation';
+import { CourtPosition } from '../match';
+import logger from '../../logger';
+const buildBlock = (rarity, count) => Array.from({ length: count }, () => rarity);
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class TeamGenerator {
+    static getFormation() {
+        const n = Math.floor(Math.random() * 3);
+        switch (n) {
+            case 0:
+                return Formation['4-2'];
+            case 1:
+                return Formation['5-1'];
+            case 2:
+                return Formation['6-2'];
+            default:
+                throw new Error('INVALID NUMBER');
+        }
+    }
+    static comparePlayers(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 createRoster(country) {
+        return TeamGenerator.RARITIES.map((rarity, i) => PlayerGenerator.generatePlayer(country, rarity, this.ROLES[i % TeamGenerator.ROLES.length]));
+    }
+    static createTeams(divisionId, country) {
+        const names = generateGenericTeamNames(country.locales, TeamGenerator.TEAM_PER_DIVISION);
+        logger.info(`Creating teams for division: ${divisionId}`);
+        return names.map((name) => {
+            logger.info(`Creating players for team: ${name}`);
+            const roster = TeamGenerator.createRoster(country);
+            const tactics = TeamGenerator.createTactics(roster);
+            const shortName = name.replace(/\s+/g, '')
+                .slice(0, 3)
+                .toUpperCase();
+            return Team.create({
+                id: uuidv4(),
+                divisionId,
+                name,
+                shortName,
+                roster,
+                country,
+                tactics,
+                rating: 100
+            });
+        });
+    }
+    static createTactics(roster) {
+        const lineup = TeamGenerator.createLineup(roster, TeamGenerator.getFormation());
+        return Tactics.create({
+            lineup,
+            liberoReplacements: [lineup[3], lineup[6]],
+            pinchServerSubs: new Map(),
+            substitutionTolerance: Math.round(randomNumber(1, 50))
+        });
+    }
+    static createLineup(players, formation) {
+        if (players.length < 6)
+            throw new Error('NOT_ENOUGH_PLAYERS_FOR_TEAM_1');
+        const out = {};
+        let courtPlayer;
+        const libero = players.filter((player) => player.roles.includes(RoleEnum.LIBERO))
+            .sort(TeamGenerator.comparePlayers([RoleEnum.LIBERO]))
+            .shift();
+        if (libero == null)
+            throw new Error('UNDEFINED_LIBERO');
+        const filtered = players.filter(player => player.id !== libero.id);
+        for (let i = 1; i < 7; i++) {
+            courtPlayer = filtered.sort(TeamGenerator.comparePlayers(formation.initialRotation[i]))
+                .shift();
+            if (courtPlayer == null)
+                throw new Error('NOT_ENOUGH_PLAYERS_FOR_TEAM_2');
+            out[i] = courtPlayer;
+        }
+        // Can only have 12 players in the team.
+        out.bench = filtered.sort(Player.compareStats)
+            .slice(0, 5);
+        out[CourtPosition.LIBERO_ZONE] = libero;
+        return out;
+    }
+}
+TeamGenerator.TEAM_PER_DIVISION = 16;
+TeamGenerator.RARITIES = [
+    ...buildBlock(RarityEnum.COMMON, 7),
+    ...buildBlock(RarityEnum.RARE, 5),
+    ...buildBlock(RarityEnum.LEGENDARY, 2)
+];
+TeamGenerator.ROLES = [RoleEnum.LIBERO, RoleEnum.MIDDLE_BLOCKER, RoleEnum.OPPOSITE_HITTER, RoleEnum.OUTSIDE_HITTER, RoleEnum.SETTER];