volleyballsimtypes 0.0.393 → 0.0.395

package/dist/esm/src/service/team/lineup-function.js

@@ -0,0 +1,60 @@
+import { RoleEnum } from '../player';
+import { RotationSystemEnum } from './rotation-system';
+// Flat multiplier applied to EVERY action a player performs while played out of their preferred position.
+// Roles are a player's preference/specialisation (decoupled from raw stats), so this is the single standalone
+// signal for "played out of position" and is not double-counting any stat disadvantage. Single tunable knob.
+export const OUT_OF_POSITION_PENALTY = 0.85;
+// The balanced-lineup function pattern by rotational offset from the main setter (in serving order):
+//   0 setter, 1 outside, 2 middle, 3 opposite (the second setter in 4-2/6-2), 4 outside, 5 middle.
+// Offset is rotation-invariant (the whole team rotates together), so a player's slot function is constant for the
+// match until a substitution changes the personnel.
+const PATTERN = [
+    RoleEnum.SETTER,
+    RoleEnum.OUTSIDE_HITTER,
+    RoleEnum.MIDDLE_BLOCKER,
+    RoleEnum.OPPOSITE_HITTER,
+    RoleEnum.OUTSIDE_HITTER,
+    RoleEnum.MIDDLE_BLOCKER
+];
+// The slot function for a player at `position`, given the main setter sits at `setterPosition`, in `system`.
+// In 4-2/6-2 the opposite slot (offset 3) is the second setter, so it maps to SETTER rather than OPPOSITE.
+export function slotFunctionAt(system, setterPosition, position) {
+    const offset = (((position - setterPosition) % 6) + 6) % 6;
+    const fn = PATTERN[offset];
+    if (fn === RoleEnum.OPPOSITE_HITTER &&
+        (system === RotationSystemEnum.FOUR_TWO || system === RotationSystemEnum.SIX_TWO)) {
+        return RoleEnum.SETTER;
+    }
+    return fn;
+}
+// Map each starter's id -> the role their lineup slot requires. Empty for 6-0 (no functions => no penalty), or if
+// the main setter is not among the starters (misconfigured -> degrade gracefully to no penalty).
+// Designated setters are forced to SETTER so a slightly off lineup never penalises a correctly-rostered setter
+// (validation enforces the opposite-slot rule upstream).
+export function getLineupFunctions(system, designatedSetterIds, starters) {
+    const functions = new Map();
+    if (system === RotationSystemEnum.SIX_ZERO)
+        return functions;
+    const mainSetter = starters.find(s => s.playerId === designatedSetterIds[0]);
+    if (mainSetter == null)
+        return functions;
+    for (const slot of starters) {
+        functions.set(slot.playerId, slotFunctionAt(system, mainSetter.position, slot.position));
+    }
+    for (const id of designatedSetterIds) {
+        if (functions.has(id))
+            functions.set(id, RoleEnum.SETTER);
+    }
+    return functions;
+}
+// True when a player's slot requires a role they do not hold (i.e. they are played out of position). A missing
+// function (6-0, or unknown player) is never out of position.
+export function isOutOfPosition(roles, fn) {
+    if (fn == null)
+        return false;
+    return !roles.includes(fn);
+}
+// The action multiplier for a player given their slot function: penalised if out of position, else neutral.
+export function outOfPositionPenalty(roles, fn) {
+    return isOutOfPosition(roles, fn) ? OUT_OF_POSITION_PENALTY : 1;
+}

package/dist/esm/src/service/team/offensive-preference.d.ts

@@ -0,0 +1,5 @@
+import { Player } from '../player';
+export interface OffensivePreference {
+    readonly rotation: number;
+    readonly order: Player[];
+}

package/dist/esm/src/service/team/offensive-preference.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/team/rotation-system.d.ts

@@ -0,0 +1,8 @@
+export declare enum RotationSystemEnum {
+    FIVE_ONE = "5-1",
+    FOUR_TWO = "4-2",
+    SIX_TWO = "6-2",
+    SIX_ZERO = "6-0"
+}
+export type RotationSystem = RotationSystemEnum;
+export declare function setterCountFor(system: RotationSystemEnum): number;

package/dist/esm/src/service/team/rotation-system.js

@@ -0,0 +1,21 @@
+// The offensive rotation system a team runs. Drives base-positioning, who sets each rally (the rally-setter),
+// and the out-of-position penalty. '6-0' (treat '6-6' as an alias) is the neutral default: no designated setter,
+// base positions = the rotational layout, so an unconfigured team plays exactly as before this feature.
+export var RotationSystemEnum;
+(function (RotationSystemEnum) {
+    RotationSystemEnum["FIVE_ONE"] = "5-1";
+    RotationSystemEnum["FOUR_TWO"] = "4-2";
+    RotationSystemEnum["SIX_TWO"] = "6-2";
+    RotationSystemEnum["SIX_ZERO"] = "6-0";
+})(RotationSystemEnum || (RotationSystemEnum = {}));
+// How many designated setters each system expects: 5-1 has one; 4-2 and 6-2 have two (main + the opposite slot,
+// which acts as the second setter); 6-0 has none.
+export function setterCountFor(system) {
+    switch (system) {
+        case RotationSystemEnum.FIVE_ONE: return 1;
+        case RotationSystemEnum.FOUR_TWO: return 2;
+        case RotationSystemEnum.SIX_TWO: return 2;
+        case RotationSystemEnum.SIX_ZERO: return 0;
+        default: return 0;
+    }
+}

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
+import { RotationSystemEnum } from '../rotation-system';
 export declare const TacticsInputSchema: z.ZodObject<{
     lineup: z.ZodObject<{
         4: z.ZodCustom<Player, Player>;
@@ -47,5 +48,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>>;
     substitutionBand: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<typeof EnergyBand>, z.ZodLiteral<"NEVER">]>>;
+    rotationSystem: z.ZodDefault<z.ZodEnum<typeof RotationSystemEnum>>;
+    designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
+    offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        rotation: z.ZodNumber;
+        order: z.ZodArray<z.ZodCustom<Player, Player>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type TacticsInput = z.infer<typeof TacticsInputSchema>;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
+import { RotationSystemEnum, setterCountFor } from '../rotation-system';
 import { DesignatedSubSchema, SubBandSchema } from './designated-sub.z';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
@@ -43,6 +44,12 @@ const lineupSchema = z.object({
         });
     }
 });
+// One rotation's ranked attacker priority. `rotation` is the main setter's rotational slot (1..6); `order` lists
+// the attackers ranked best-first. Cross-field checks (starters only, no dupes) live in the superRefine below.
+const offensivePreferenceSchema = z.object({
+    rotation: z.number().int().min(1).max(6),
+    order: z.array(playerInstanceSchema)
+});
 export const TacticsInputSchema = z.object({
     lineup: lineupSchema,
     substitutionTolerance: z.number().int().min(1).max(50),
@@ -53,5 +60,64 @@ export const TacticsInputSchema = z.object({
         Array.from(v.entries()).every(([k, val]) => k instanceof Player && val instanceof Player), { message: 'INVALID_PINCH_SERVER_SUBS' }),
     // New (designated-subs feature). Defaults keep every existing Tactics.create({...}) call valid.
     designatedSubs: z.array(DesignatedSubSchema).default([]),
-    substitutionBand: SubBandSchema.default(EnergyBand.TIRED)
+    substitutionBand: SubBandSchema.default(EnergyBand.TIRED),
+    // Advanced tactics (rotation systems). Defaults (6-0 / no setters / no preferences) keep every existing
+    // Tactics.create({...}) call valid and make an unconfigured team play exactly as before.
+    rotationSystem: z.nativeEnum(RotationSystemEnum).default(RotationSystemEnum.SIX_ZERO),
+    designatedSetters: z.array(playerInstanceSchema).default([]),
+    offensivePreferences: z.array(offensivePreferenceSchema).default([])
+}).superRefine((data, ctx) => {
+    // Cross-field rules for the rotation system. These keep an invalid config from ever reaching the sim (the
+    // pinch-server outage was caused by an unvalidated tactics payload).
+    const slots = [
+        [RIGHT_BACK, data.lineup[RIGHT_BACK]],
+        [RIGHT_FRONT, data.lineup[RIGHT_FRONT]],
+        [MIDDLE_FRONT, data.lineup[MIDDLE_FRONT]],
+        [LEFT_FRONT, data.lineup[LEFT_FRONT]],
+        [LEFT_BACK, data.lineup[LEFT_BACK]],
+        [MIDDLE_BACK, data.lineup[MIDDLE_BACK]]
+    ];
+    // If the lineup itself failed to parse, its own issues are already reported; skip the cross-field checks
+    // rather than dereferencing a missing starter.
+    if (slots.some(([, player]) => player == null))
+        return;
+    const starters = slots.map(([position, player]) => ({ position, id: player.id }));
+    const starterIds = new Set(starters.map(s => s.id));
+    const positionById = new Map(starters.map(s => [s.id, s.position]));
+    // Designated setters: count must match the system, and each must be an on-court starter.
+    const expectedSetters = setterCountFor(data.rotationSystem);
+    if (data.designatedSetters.length !== expectedSetters) {
+        ctx.addIssue({ code: 'custom', message: `DESIGNATED_SETTERS_COUNT_${data.rotationSystem}_EXPECTED_${expectedSetters}`, path: ['designatedSetters'] });
+    }
+    for (const setter of data.designatedSetters) {
+        if (!starterIds.has(setter.id)) {
+            ctx.addIssue({ code: 'custom', message: 'DESIGNATED_SETTER_NOT_A_STARTER', path: ['designatedSetters'] });
+        }
+    }
+    // 4-2 / 6-2: the two setters sit in opposite slots (3 rotations apart).
+    if ((data.rotationSystem === RotationSystemEnum.FOUR_TWO || data.rotationSystem === RotationSystemEnum.SIX_TWO) &&
+        data.designatedSetters.length === 2) {
+        const a = positionById.get(data.designatedSetters[0].id);
+        const b = positionById.get(data.designatedSetters[1].id);
+        if (a != null && b != null && ((((a - b) % 6) + 6) % 6) !== 3) {
+            ctx.addIssue({ code: 'custom', message: 'DESIGNATED_SETTERS_NOT_IN_OPPOSITE_SLOTS', path: ['designatedSetters'] });
+        }
+    }
+    // Offensive preferences: unique rotations, and each order lists only on-court starters with no duplicates.
+    const seenRotations = new Set();
+    for (const pref of data.offensivePreferences) {
+        if (seenRotations.has(pref.rotation)) {
+            ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ROTATION', path: ['offensivePreferences'] });
+        }
+        seenRotations.add(pref.rotation);
+        const ids = pref.order.map(p => p.id);
+        if (new Set(ids).size !== ids.length) {
+            ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ATTACKER', path: ['offensivePreferences'] });
+        }
+        for (const id of ids) {
+            if (!starterIds.has(id)) {
+                ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER', path: ['offensivePreferences'] });
+            }
+        }
+    }
 });

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

@@ -55,6 +55,12 @@ export declare const TeamInputSchema: z.ZodObject<{
             conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>>;
         substitutionBand: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").EnergyBand>, z.ZodLiteral<"NEVER">]>>;
+        rotationSystem: z.ZodDefault<z.ZodEnum<typeof import("..").RotationSystemEnum>>;
+        designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
+        offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            rotation: z.ZodNumber;
+            order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TeamInput = z.infer<typeof TeamInputSchema>;

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

@@ -2,6 +2,8 @@ import { CourtPosition } from '../match';
 import { Player } from '../player';
 import { DesignatedSub } from './designated-sub';
 import { SubBand } from './energy-band';
+import { RotationSystemEnum } from './rotation-system';
+import { OffensivePreference } from './offensive-preference';
 export interface StartingLineup {
     readonly [CourtPosition.LEFT_FRONT]: Player;
     readonly [CourtPosition.MIDDLE_FRONT]: Player;
@@ -20,6 +22,9 @@ export interface TacticsOpts {
     readonly receiveRotationOffset: boolean;
     readonly designatedSubs: DesignatedSub[];
     readonly substitutionBand: SubBand;
+    readonly rotationSystem: RotationSystemEnum;
+    readonly designatedSetters: Player[];
+    readonly offensivePreferences: OffensivePreference[];
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
@@ -29,6 +34,9 @@ export declare class Tactics {
     readonly receiveRotationOffset: boolean;
     readonly designatedSubs: DesignatedSub[];
     readonly substitutionBand: SubBand;
+    readonly rotationSystem: RotationSystemEnum;
+    readonly designatedSetters: Player[];
+    readonly offensivePreferences: OffensivePreference[];
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

@@ -1,5 +1,6 @@
 import { CourtPosition } from '../match';
 import { EnergyBand } from './energy-band';
+import { RotationSystemEnum } from './rotation-system';
 import { TacticsInputSchema } from './schemas/tactics.z';
 export class Tactics {
     static create(input) {
@@ -14,7 +15,7 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED }) {
+    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [] }) {
         this.lineup = lineup;
         this.substitutionTolerance = substitutionTolerance;
         this.pinchServerSubs = pinchServerSubs;
@@ -22,6 +23,9 @@ export class Tactics {
         this.receiveRotationOffset = receiveRotationOffset;
         this.designatedSubs = designatedSubs;
         this.substitutionBand = substitutionBand;
+        this.rotationSystem = rotationSystem;
+        this.designatedSetters = designatedSetters;
+        this.offensivePreferences = offensivePreferences;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.393",
+  "version": "0.0.395",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",