volleyballsimtypes 0.0.393 → 0.0.395

package/dist/cjs/src/api/index.d.ts

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, PinchCondition, SubBand } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, PinchCondition, RotationSystemEnum, SubBand } from '../service';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -64,6 +64,10 @@ export interface ApiDesignatedSub {
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
 }
+export interface ApiOffensivePreference {
+    rotation: number;
+    order: string[];
+}
 export interface Tactics {
     lineup: StartingLineup;
     substitutionTolerance: number;
@@ -72,6 +76,9 @@ export interface Tactics {
     receiveRotationOffset: boolean;
     designatedSubs: ApiDesignatedSub[];
     substitutionBand: SubBand;
+    rotationSystem: RotationSystemEnum;
+    designatedSetters: string[];
+    offensivePreferences: ApiOffensivePreference[];
 }
 export type Team = Omit<DataProps<_Team>, 'roster' | '_rating' | 'rating' | 'tactics'> & {
     roster: Player[];

package/dist/cjs/src/data/models/tactics.d.ts

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { ConditionLogic, CourtPosition, PinchCondition, SubBand } from '../../service';
+import { ConditionLogic, CourtPosition, PinchCondition, RotationSystemEnum, SubBand } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -21,6 +21,10 @@ export interface DesignatedSubAttributes {
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
 }
+export interface OffensivePreferenceAttributes {
+    rotation: number;
+    order: PlayerId[];
+}
 export interface TacticsAttributes {
     team_id: string;
     substitution_tolerance: number;
@@ -30,10 +34,13 @@ export interface TacticsAttributes {
     receive_rotation_offset: boolean;
     designated_subs: DesignatedSubAttributes[];
     substitution_band: SubBand;
+    rotation_system: RotationSystemEnum;
+    designated_setters: PlayerId[];
+    offensive_preferences: OffensivePreferenceAttributes[];
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band';
+export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'rotation_system' | 'designated_setters' | 'offensive_preferences';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -44,6 +51,9 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     receive_rotation_offset: boolean;
     designated_subs: DesignatedSubAttributes[];
     substitution_band: SubBand;
+    rotation_system: RotationSystemEnum;
+    designated_setters: PlayerId[];
+    offensive_preferences: OffensivePreferenceAttributes[];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

package/dist/cjs/src/data/models/tactics.js

@@ -49,6 +49,21 @@ class TacticsModel extends sequelize_1.Model {
                 type: sequelize_1.DataTypes.STRING,
                 allowNull: false,
                 defaultValue: 'TIRED'
+            },
+            rotation_system: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                defaultValue: '6-0'
+            },
+            designated_setters: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.UUID),
+                allowNull: false,
+                defaultValue: []
+            },
+            offensive_preferences: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: []
             }
         }, {
             sequelize,

package/dist/cjs/src/data/transformers/tactics.js

@@ -49,6 +49,12 @@ function transformToAttributes(tactics, teamId) {
             fatigueBand: ds.fatigueBand,
             conditions: ds.conditions,
             conditionLogic: ds.conditionLogic
+        })),
+        rotation_system: tactics.rotationSystem,
+        designated_setters: tactics.designatedSetters.map((s) => s.id),
+        offensive_preferences: tactics.offensivePreferences.map(p => ({
+            rotation: p.rotation,
+            order: p.order.map((a) => a.id)
         }))
     };
 }
@@ -74,6 +80,12 @@ function transformToObject(model, roster) {
             fatigueBand: d.fatigueBand,
             conditions: d.conditions,
             conditionLogic: d.conditionLogic
+        })),
+        rotationSystem: model.rotation_system,
+        designatedSetters: (model.designated_setters ?? []).map((id) => findPlayer(id, roster)),
+        offensivePreferences: (model.offensive_preferences ?? []).map(p => ({
+            rotation: p.rotation,
+            order: p.order.map((id) => findPlayer(id, roster))
         }))
     });
 }

package/dist/cjs/src/service/team/base-position.d.ts

@@ -0,0 +1,25 @@
+import { CourtPosition } from '../match';
+import { Role } from '../player';
+import { RotationSystemEnum } from './rotation-system';
+export declare enum BaseContext {
+    SERVE_RECEIVE = "SERVE_RECEIVE",
+    BASE = "BASE"
+}
+export interface BasePlayer {
+    readonly playerId: string;
+    readonly position: CourtPosition;
+    readonly roles: Role[];
+}
+export interface BaseResolverInput {
+    readonly system: RotationSystemEnum;
+    readonly designatedSetterIds: string[];
+    readonly players: BasePlayer[];
+    readonly liberoId?: string;
+}
+export type BaseMap = Map<string, CourtPosition>;
+export interface ResolvedBases {
+    readonly serveReceive: BaseMap;
+    readonly base: BaseMap;
+}
+export declare function rallySetterId(system: RotationSystemEnum, designatedSetterIds: string[], players: BasePlayer[]): string | undefined;
+export declare function resolveBases(input: BaseResolverInput): ResolvedBases;

package/dist/cjs/src/service/team/base-position.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContext = void 0;
+exports.rallySetterId = rallySetterId;
+exports.resolveBases = resolveBases;
+const match_1 = require("../match");
+const player_1 = require("../player");
+const rotation_system_1 = require("./rotation-system");
+const lineup_function_1 = require("./lineup-function");
+// The rally phase a base lookup is resolved against. Two contexts are enough in the 6-zone model:
+//  - SERVE_RECEIVE: first contact when receiving serve. The passers (libero + outsides) hold the back row; the
+//    setter(s) and the opposite are hidden in the front (not passers). Serves are aimed at the back-row passers,
+//    so the setter / penetrating setter / opposite never receive by default (they can be deliberately hunted).
+//  - BASE: open play (offense AND defense). In the discrete 6-zone model these coincide: every player is at their
+//    one specialist lane whether attacking or digging. There is no visual layer and no benefit to splitting them.
+var BaseContext;
+(function (BaseContext) {
+    BaseContext["SERVE_RECEIVE"] = "SERVE_RECEIVE";
+    BaseContext["BASE"] = "BASE";
+})(BaseContext || (exports.BaseContext = BaseContext = {}));
+// The specialist zone a function occupies given its current row. Outsides play left (z4 front / z5 back), middles
+// the middle (z3 / z6), setter and opposite the right (z2 / z1). Because each same-zone pair (setter+opposite, the
+// two middles, the two outsides) sits 3 rotations apart, exactly one is front and one is back at any rotation, so
+// the six players always map to the six distinct zones (a bijection).
+function specialistZone(fn, front) {
+    switch (fn) {
+        case player_1.RoleEnum.OUTSIDE_HITTER: return front ? match_1.CourtPosition.LEFT_FRONT : match_1.CourtPosition.LEFT_BACK;
+        case player_1.RoleEnum.MIDDLE_BLOCKER: return front ? match_1.CourtPosition.MIDDLE_FRONT : match_1.CourtPosition.MIDDLE_BACK;
+        case player_1.RoleEnum.OPPOSITE_HITTER:
+        case player_1.RoleEnum.SETTER: return front ? match_1.CourtPosition.RIGHT_FRONT : match_1.CourtPosition.RIGHT_BACK;
+        default: return front ? match_1.CourtPosition.MIDDLE_FRONT : match_1.CourtPosition.MIDDLE_BACK;
+    }
+}
+// Who takes the second touch this rally: 5-1 the single setter; 4-2 the front-row setter; 6-2 the back-row
+// (penetrating) setter. Returns undefined for 6-0 or when no designated setter is on court (the sim picks a
+// front-row setter by stat in that case).
+function rallySetterId(system, designatedSetterIds, players) {
+    const setters = designatedSetterIds
+        .map(id => players.find(p => p.playerId === id))
+        .filter((p) => p != null);
+    if (setters.length === 0)
+        return undefined;
+    switch (system) {
+        case rotation_system_1.RotationSystemEnum.FIVE_ONE:
+            return setters[0].playerId;
+        case rotation_system_1.RotationSystemEnum.FOUR_TWO:
+            return (setters.find(s => (0, match_1.isFrontRow)(s.position)) ?? setters[0]).playerId;
+        case rotation_system_1.RotationSystemEnum.SIX_TWO:
+            return (setters.find(s => !(0, match_1.isFrontRow)(s.position)) ?? setters[0]).playerId;
+        default:
+            return undefined;
+    }
+}
+function identityBases(players) {
+    const make = () => new Map(players.map(p => [p.playerId, p.position]));
+    return { serveReceive: make(), base: make() };
+}
+// Resolve the two context base maps for the six on-court players. 6-0 (or a misconfigured lineup) keeps the
+// rotational layout in both contexts (= pre-feature behavior). Each returned map is a bijection over {1..6}; the
+// sim asserts this after applying it.
+function resolveBases(input) {
+    const { system, designatedSetterIds, players, liberoId } = input;
+    if (system === rotation_system_1.RotationSystemEnum.SIX_ZERO)
+        return identityBases(players);
+    const mainSetter = players.find(p => p.playerId === designatedSetterIds[0]);
+    if (mainSetter == null)
+        return identityBases(players);
+    // BASE (open play): every player releases to their specialist lane.
+    const base = new Map();
+    for (const p of players) {
+        const fn = (0, lineup_function_1.slotFunctionAt)(system, mainSetter.position, p.position);
+        base.set(p.playerId, specialistZone(fn, (0, match_1.isFrontRow)(p.position)));
+    }
+    return { serveReceive: buildServeReceive(system, designatedSetterIds, players, mainSetter, liberoId), base };
+}
+// The serve-receive base. Only the back row handles the serve, so the three back-row zones go to the actual
+// passers (the libero + the two outside-hitter slots) and the three front zones hide the non-passers (the
+// setter(s), the opposite, and a middle). This keeps the opposite -- which shares the right lane with the setter
+// in open play -- out of the passing lanes; a server can still deliberately hunt the hidden setter or opposite
+// (handled sim-side). Without a libero on court the back-row middle fills the third passing slot. Always a
+// bijection over {1..6} (three front + three back, distinct zones).
+function buildServeReceive(system, designatedSetterIds, players, mainSetter, liberoId) {
+    // Zone order, declared in-function so CourtPosition is read at call time, not module load: the service<->match
+    // import cycle leaves CourtPosition unbound while this module is first evaluated, so a module-level array would
+    // crash. Hidden players fill the front (rally-setter first -> RIGHT_FRONT); passers fill the back (libero first
+    // -> MIDDLE_BACK).
+    const frontZones = [match_1.CourtPosition.RIGHT_FRONT, match_1.CourtPosition.LEFT_FRONT, match_1.CourtPosition.MIDDLE_FRONT];
+    const backZones = [match_1.CourtPosition.MIDDLE_BACK, match_1.CourtPosition.LEFT_BACK, match_1.CourtPosition.RIGHT_BACK];
+    const setterId = rallySetterId(system, designatedSetterIds, players);
+    const fnOf = (p) => (0, lineup_function_1.slotFunctionAt)(system, mainSetter.position, p.position);
+    const passers = [];
+    const middles = [];
+    const hidden = []; // setter(s) + opposite
+    for (const p of players) {
+        if (p.playerId === liberoId || fnOf(p) === player_1.RoleEnum.OUTSIDE_HITTER)
+            passers.push(p);
+        else if (fnOf(p) === player_1.RoleEnum.MIDDLE_BLOCKER)
+            middles.push(p);
+        else
+            hidden.push(p);
+    }
+    // Fill to three passers from the middles (back-row first, so a front-row middle stays hidden); the rest hide.
+    middles.sort((a, b) => Number((0, match_1.isFrontRow)(a.position)) - Number((0, match_1.isFrontRow)(b.position)));
+    while (passers.length < 3 && middles.length > 0)
+        passers.push(middles.shift());
+    hidden.push(...middles);
+    hidden.sort((a, b) => Number(b.playerId === setterId) - Number(a.playerId === setterId));
+    passers.sort((a, b) => Number(b.playerId === liberoId) - Number(a.playerId === liberoId));
+    const sr = new Map();
+    hidden.forEach((p, i) => sr.set(p.playerId, frontZones[i]));
+    passers.forEach((p, i) => sr.set(p.playerId, backZones[i]));
+    return sr;
+}

package/dist/cjs/src/service/team/base-position.test.d.ts

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

package/dist/cjs/src/service/team/base-position.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const match_1 = require("../match");
+const player_1 = require("../player");
+const rotation_system_1 = require("./rotation-system");
+const lineup_function_1 = require("./lineup-function");
+const base_position_1 = require("./base-position");
+// Balanced 5-1 at rotation 1 (setter serving from RIGHT_BACK = 1): S, OH1, MB1, OPP, OH2, MB2 around the court.
+function baseLineup() {
+    return [
+        { playerId: 'S', position: match_1.CourtPosition.RIGHT_BACK, roles: [player_1.RoleEnum.SETTER] },
+        { playerId: 'OH1', position: match_1.CourtPosition.RIGHT_FRONT, roles: [player_1.RoleEnum.OUTSIDE_HITTER] },
+        { playerId: 'MB1', position: match_1.CourtPosition.MIDDLE_FRONT, roles: [player_1.RoleEnum.MIDDLE_BLOCKER] },
+        { playerId: 'OPP', position: match_1.CourtPosition.LEFT_FRONT, roles: [player_1.RoleEnum.OPPOSITE_HITTER] },
+        { playerId: 'OH2', position: match_1.CourtPosition.LEFT_BACK, roles: [player_1.RoleEnum.OUTSIDE_HITTER] },
+        { playerId: 'MB2', position: match_1.CourtPosition.MIDDLE_BACK, roles: [player_1.RoleEnum.MIDDLE_BLOCKER] }
+    ];
+}
+// 5-1 with the libero on court in the back-row middle slot (replacing MB2).
+function lineupWithLibero() {
+    return {
+        players: [
+            { playerId: 'S', position: match_1.CourtPosition.RIGHT_BACK, roles: [player_1.RoleEnum.SETTER] },
+            { playerId: 'OH1', position: match_1.CourtPosition.RIGHT_FRONT, roles: [player_1.RoleEnum.OUTSIDE_HITTER] },
+            { playerId: 'MB1', position: match_1.CourtPosition.MIDDLE_FRONT, roles: [player_1.RoleEnum.MIDDLE_BLOCKER] },
+            { playerId: 'OPP', position: match_1.CourtPosition.LEFT_FRONT, roles: [player_1.RoleEnum.OPPOSITE_HITTER] },
+            { playerId: 'OH2', position: match_1.CourtPosition.LEFT_BACK, roles: [player_1.RoleEnum.OUTSIDE_HITTER] },
+            { playerId: 'LIB', position: match_1.CourtPosition.MIDDLE_BACK, roles: [player_1.RoleEnum.LIBERO] }
+        ],
+        liberoId: 'LIB'
+    };
+}
+function rotate(players, times) {
+    let out = players;
+    for (let i = 0; i < times; i++)
+        out = out.map(p => ({ ...p, position: (0, match_1.rotatePosition)(p.position) }));
+    return out;
+}
+function isBijection(m) {
+    const zones = [...m.values()];
+    return zones.length === 6 && new Set(zones).size === 6 && zones.every(z => z >= 1 && z <= 6);
+}
+const SETTERS = {
+    [rotation_system_1.RotationSystemEnum.FIVE_ONE]: ['S'],
+    [rotation_system_1.RotationSystemEnum.FOUR_TWO]: ['S', 'OPP'],
+    [rotation_system_1.RotationSystemEnum.SIX_TWO]: ['S', 'OPP'],
+    [rotation_system_1.RotationSystemEnum.SIX_ZERO]: []
+};
+describe('resolveBases() bijection', () => {
+    for (const system of Object.values(rotation_system_1.RotationSystemEnum)) {
+        for (let r = 0; r < 6; r++) {
+            it(`${system} rotation ${r}: all three contexts are bijections over {1..6}`, () => {
+                const players = rotate(baseLineup(), r);
+                const bases = (0, base_position_1.resolveBases)({ system, designatedSetterIds: SETTERS[system], players });
+                expect(isBijection(bases.serveReceive)).toBe(true);
+                expect(isBijection(bases.base)).toBe(true);
+            });
+        }
+    }
+});
+describe('resolveBases() 6-0', () => {
+    it('keeps the rotational layout in every context (identity)', () => {
+        const players = rotate(baseLineup(), 3);
+        const bases = (0, base_position_1.resolveBases)({ system: rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetterIds: [], players });
+        for (const p of players) {
+            expect(bases.base.get(p.playerId)).toBe(p.position);
+            expect(bases.serveReceive.get(p.playerId)).toBe(p.position);
+        }
+    });
+});
+describe('resolveBases() serve-receive hides the setter', () => {
+    it('5-1 setter is always at RIGHT_FRONT in serve-receive, every rotation', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const bases = (0, base_position_1.resolveBases)({ system: rotation_system_1.RotationSystemEnum.FIVE_ONE, designatedSetterIds: ['S'], players });
+            expect(bases.serveReceive.get('S')).toBe(match_1.CourtPosition.RIGHT_FRONT);
+        }
+    });
+});
+describe('resolveBases() serve-receive hides the opposite (regression: opposites were receiving most serves)', () => {
+    it('5-1 opposite is hidden in the front, never in the serve-receive back row, every rotation', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const bases = (0, base_position_1.resolveBases)({ system: rotation_system_1.RotationSystemEnum.FIVE_ONE, designatedSetterIds: ['S'], players });
+            expect((0, match_1.isFrontRow)(bases.serveReceive.get('OPP'))).toBe(true);
+        }
+    });
+    it('5-1 serve-receive back row holds exactly the passers -- never the setter or the opposite', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const bases = (0, base_position_1.resolveBases)({ system: rotation_system_1.RotationSystemEnum.FIVE_ONE, designatedSetterIds: ['S'], players });
+            const backRow = [...bases.serveReceive.entries()].filter(([, z]) => !(0, match_1.isFrontRow)(z)).map(([id]) => id);
+            expect(backRow).toHaveLength(3);
+            expect(backRow).not.toContain('S');
+            expect(backRow).not.toContain('OPP');
+        }
+    });
+    it('the on-court libero is always a passer (back row) while the opposite stays hidden', () => {
+        const { players, liberoId } = lineupWithLibero();
+        const bases = (0, base_position_1.resolveBases)({ system: rotation_system_1.RotationSystemEnum.FIVE_ONE, designatedSetterIds: ['S'], players, liberoId });
+        expect((0, match_1.isFrontRow)(bases.serveReceive.get(liberoId))).toBe(false);
+        expect((0, match_1.isFrontRow)(bases.serveReceive.get('OPP'))).toBe(true);
+    });
+});
+describe('rallySetterId()', () => {
+    it('5-1 returns the single setter in every rotation', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            expect((0, base_position_1.rallySetterId)(rotation_system_1.RotationSystemEnum.FIVE_ONE, ['S'], players)).toBe('S');
+        }
+    });
+    it('4-2 returns the front-row setter, 6-2 returns the back-row setter', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const front = players.find(p => (p.playerId === 'S' || p.playerId === 'OPP') && p.position >= 2 && p.position <= 4);
+            const back = players.find(p => (p.playerId === 'S' || p.playerId === 'OPP') && (p.position === 1 || p.position === 5 || p.position === 6));
+            expect((0, base_position_1.rallySetterId)(rotation_system_1.RotationSystemEnum.FOUR_TWO, ['S', 'OPP'], players)).toBe(front?.playerId);
+            expect((0, base_position_1.rallySetterId)(rotation_system_1.RotationSystemEnum.SIX_TWO, ['S', 'OPP'], players)).toBe(back?.playerId);
+        }
+    });
+    it('6-0 has no rally setter', () => {
+        expect((0, base_position_1.rallySetterId)(rotation_system_1.RotationSystemEnum.SIX_ZERO, [], baseLineup())).toBeUndefined();
+    });
+});
+describe('getLineupFunctions()', () => {
+    it('assigns the balanced 5-1 functions', () => {
+        const fns = (0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.FIVE_ONE, ['S'], baseLineup());
+        expect(fns.get('S')).toBe(player_1.RoleEnum.SETTER);
+        expect(fns.get('OH1')).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
+        expect(fns.get('MB1')).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+        expect(fns.get('OPP')).toBe(player_1.RoleEnum.OPPOSITE_HITTER);
+        expect(fns.get('OH2')).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
+        expect(fns.get('MB2')).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+    });
+    it('maps the opposite slot to SETTER in 6-2/4-2 (the second setter)', () => {
+        const fns = (0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.SIX_TWO, ['S', 'OPP'], baseLineup());
+        expect(fns.get('OPP')).toBe(player_1.RoleEnum.SETTER);
+        expect(fns.get('S')).toBe(player_1.RoleEnum.SETTER);
+    });
+    it('is rotation-invariant', () => {
+        const r0 = (0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.FIVE_ONE, ['S'], baseLineup());
+        const r3 = (0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.FIVE_ONE, ['S'], rotate(baseLineup(), 3));
+        for (const id of ['S', 'OH1', 'MB1', 'OPP', 'OH2', 'MB2']) {
+            expect(r3.get(id)).toBe(r0.get(id));
+        }
+    });
+    it('6-0 assigns no functions', () => {
+        expect((0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.SIX_ZERO, [], baseLineup()).size).toBe(0);
+    });
+});
+describe('out-of-position penalty', () => {
+    it('penalises a specialist played in a slot whose role they lack', () => {
+        // A pure middle blocker placed in the opposite slot (function OPPOSITE_HITTER) is out of position.
+        expect((0, lineup_function_1.isOutOfPosition)([player_1.RoleEnum.MIDDLE_BLOCKER], player_1.RoleEnum.OPPOSITE_HITTER)).toBe(true);
+        expect((0, lineup_function_1.outOfPositionPenalty)([player_1.RoleEnum.MIDDLE_BLOCKER], player_1.RoleEnum.OPPOSITE_HITTER)).toBeCloseTo(lineup_function_1.OUT_OF_POSITION_PENALTY);
+    });
+    it('does not penalise a versatile player who holds the slot role', () => {
+        expect((0, lineup_function_1.isOutOfPosition)([player_1.RoleEnum.MIDDLE_BLOCKER, player_1.RoleEnum.OPPOSITE_HITTER], player_1.RoleEnum.OPPOSITE_HITTER)).toBe(false);
+        expect((0, lineup_function_1.outOfPositionPenalty)([player_1.RoleEnum.MIDDLE_BLOCKER, player_1.RoleEnum.OPPOSITE_HITTER], player_1.RoleEnum.OPPOSITE_HITTER)).toBe(1);
+    });
+    it('never penalises when there is no slot function (6-0 / unknown)', () => {
+        expect((0, lineup_function_1.isOutOfPosition)([player_1.RoleEnum.MIDDLE_BLOCKER], undefined)).toBe(false);
+        expect((0, lineup_function_1.outOfPositionPenalty)([player_1.RoleEnum.MIDDLE_BLOCKER], undefined)).toBe(1);
+    });
+});
+describe('slotFunctionAt()', () => {
+    it('is rotation-invariant for each player', () => {
+        const setterAtR0 = match_1.CourtPosition.RIGHT_BACK;
+        const setterAtR3 = (0, match_1.rotatePosition)((0, match_1.rotatePosition)((0, match_1.rotatePosition)(setterAtR0)));
+        // OPP sits opposite the setter (offset 3): OPPOSITE in 5-1.
+        expect((0, lineup_function_1.slotFunctionAt)(rotation_system_1.RotationSystemEnum.FIVE_ONE, setterAtR0, match_1.CourtPosition.LEFT_FRONT)).toBe(player_1.RoleEnum.OPPOSITE_HITTER);
+        const oppAtR3 = (0, match_1.rotatePosition)((0, match_1.rotatePosition)((0, match_1.rotatePosition)(match_1.CourtPosition.LEFT_FRONT)));
+        expect((0, lineup_function_1.slotFunctionAt)(rotation_system_1.RotationSystemEnum.FIVE_ONE, setterAtR3, oppAtR3)).toBe(player_1.RoleEnum.OPPOSITE_HITTER);
+    });
+});

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

@@ -6,3 +6,7 @@ export * from './team-name';
 export * from './energy-band';
 export * from './pinch-condition';
 export * from './designated-sub';
+export * from './rotation-system';
+export * from './lineup-function';
+export * from './base-position';
+export * from './offensive-preference';

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

@@ -22,3 +22,7 @@ __exportStar(require("./team-name"), exports);
 __exportStar(require("./energy-band"), exports);
 __exportStar(require("./pinch-condition"), exports);
 __exportStar(require("./designated-sub"), exports);
+__exportStar(require("./rotation-system"), exports);
+__exportStar(require("./lineup-function"), exports);
+__exportStar(require("./base-position"), exports);
+__exportStar(require("./offensive-preference"), exports);

package/dist/cjs/src/service/team/lineup-function.d.ts

@@ -0,0 +1,13 @@
+import { CourtPosition } from '../match';
+import { Role, RoleEnum } from '../player';
+import { RotationSystemEnum } from './rotation-system';
+export type LineupFunction = RoleEnum;
+export declare const OUT_OF_POSITION_PENALTY: 0.85;
+export interface LineupSlot {
+    readonly playerId: string;
+    readonly position: CourtPosition;
+}
+export declare function slotFunctionAt(system: RotationSystemEnum, setterPosition: CourtPosition, position: CourtPosition): RoleEnum;
+export declare function getLineupFunctions(system: RotationSystemEnum, designatedSetterIds: string[], starters: LineupSlot[]): Map<string, RoleEnum>;
+export declare function isOutOfPosition(roles: Role[], fn: RoleEnum | undefined): boolean;
+export declare function outOfPositionPenalty(roles: Role[], fn: RoleEnum | undefined): number;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUT_OF_POSITION_PENALTY = void 0;
+exports.slotFunctionAt = slotFunctionAt;
+exports.getLineupFunctions = getLineupFunctions;
+exports.isOutOfPosition = isOutOfPosition;
+exports.outOfPositionPenalty = outOfPositionPenalty;
+const player_1 = require("../player");
+const rotation_system_1 = require("./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.
+exports.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 = [
+    player_1.RoleEnum.SETTER,
+    player_1.RoleEnum.OUTSIDE_HITTER,
+    player_1.RoleEnum.MIDDLE_BLOCKER,
+    player_1.RoleEnum.OPPOSITE_HITTER,
+    player_1.RoleEnum.OUTSIDE_HITTER,
+    player_1.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.
+function slotFunctionAt(system, setterPosition, position) {
+    const offset = (((position - setterPosition) % 6) + 6) % 6;
+    const fn = PATTERN[offset];
+    if (fn === player_1.RoleEnum.OPPOSITE_HITTER &&
+        (system === rotation_system_1.RotationSystemEnum.FOUR_TWO || system === rotation_system_1.RotationSystemEnum.SIX_TWO)) {
+        return player_1.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).
+function getLineupFunctions(system, designatedSetterIds, starters) {
+    const functions = new Map();
+    if (system === rotation_system_1.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, player_1.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.
+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.
+function outOfPositionPenalty(roles, fn) {
+    return isOutOfPosition(roles, fn) ? exports.OUT_OF_POSITION_PENALTY : 1;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotationSystemEnum = void 0;
+exports.setterCountFor = setterCountFor;
+// 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.
+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 || (exports.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.
+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/cjs/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>;