volleyballsimtypes 0.0.423 → 0.0.425

package/dist/cjs/src/service/match/rally-metrics.d.ts

@@ -16,7 +16,9 @@ export interface RallyMetricsSet {
 export interface RotationMetrics {
     setterZone: number | null;
     rotation: number;
+    serves: number;
     servePoints: number;
+    receptions: number;
     sideoutPoints: number;
     points: number;
 }
@@ -31,6 +33,9 @@ export interface TeamRallyMetrics {
     modReceptions: number;
     modSideoutWins: number;
     modSideoutPct: number;
+    fbsoWins: number;
+    fbsoPct: number;
+    modFbsoPct: number;
     rotations: RotationMetrics[];
 }
 export interface SetRallyMetrics {

package/dist/cjs/src/service/match/rally-metrics.js

@@ -4,12 +4,18 @@ exports.computeRallyMetrics = computeRallyMetrics;
 const event_1 = require("../event");
 const court_position_1 = require("./court-position");
 function newAcc() {
-    return { serves: 0, breakpointWins: 0, receptions: 0, sideoutWins: 0, serviceErrorsReceived: 0, rotations: new Map() };
+    return { serves: 0, breakpointWins: 0, receptions: 0, sideoutWins: 0, serviceErrorsReceived: 0, fbsoWins: 0, rotations: new Map() };
 }
 function isServiceError(rally) {
     const serve = rally.events.find(e => e.eventType === event_1.EventTypeEnum.SERVE);
     return serve != null && (serve.failure ?? 0) > 0;
 }
+// A first-ball sideout is won on the receiving team's first attack: the rally has exactly one spike (the
+// engine scores a second spike as a transition). This counts first-ball kills and the block errors forced
+// on that first attack, and excludes service-error sideouts (no spike) and dig-and-transition rallies (2+).
+function spikeCount(rally) {
+    return rally.events.reduce((n, e) => e.eventType === event_1.EventTypeEnum.SPIKE ? n + 1 : n, 0);
+}
 // The setter's zone after (rotationIndex - 1) rotations from their start zone, using the engine's own
 // rotatePosition (each rotation moves a player one zone: 2->1, 1->6, ...). null when no setter.
 function setterZoneAt(startZone, rotationIndex) {
@@ -20,17 +26,16 @@ function setterZoneAt(startZone, rotationIndex) {
         zone = (0, court_position_1.rotatePosition)(zone);
     return zone;
 }
-function addRotationPoint(acc, setterZone, rotation, kind) {
+// Get (or create) a team's rotation bucket, keyed by setter zone when known (so the total sums by zone
+// across sets), else by the rotation index.
+function rotationEntry(acc, setterZone, rotation) {
     const key = setterZone != null ? `z${setterZone}` : `r${rotation}`;
     let entry = acc.rotations.get(key);
     if (entry == null) {
-        entry = { setterZone, rotation, servePoints: 0, sideoutPoints: 0 };
+        entry = { setterZone, rotation, servePoints: 0, sideoutPoints: 0, serves: 0, receptions: 0 };
         acc.rotations.set(key, entry);
     }
-    if (kind === 'serve')
-        entry.servePoints++;
-    else
-        entry.sideoutPoints++;
+    return entry;
 }
 // Walk one set, folding its rallies into the home/away accumulators (used for both per-set and total).
 function accumulateSet(set, homeId, awayId, homeAcc, awayAcc) {
@@ -47,22 +52,27 @@ function accumulateSet(set, homeId, awayId, homeAcc, awayAcc) {
         const winnerId = i < rallies.length - 1 ? rallies[i + 1].servingTeamId : setWinnerId;
         const serving = accOf(servingId);
         const receiving = accOf(receivingId);
-        const winner = accOf(winnerId);
-        if (serving == null || receiving == null || winner == null)
+        if (serving == null || receiving == null || (winnerId !== servingId && winnerId !== receivingId))
             continue;
         serving.serves++;
         receiving.receptions++;
         if (isServiceError(rallies[i]))
             receiving.serviceErrorsReceived++;
-        const rotIdx = rotation[winnerId];
-        const zone = setterZoneAt(startZone[winnerId], rotIdx);
+        // Per-rotation attempts: both teams play this rally in their current rotation. The point below is
+        // attributed to the winner, whose bucket is the same serve (breakpoint) or reception (sideout) entry.
+        const serveEntry = rotationEntry(serving, setterZoneAt(startZone[servingId], rotation[servingId]), rotation[servingId]);
+        const recEntry = rotationEntry(receiving, setterZoneAt(startZone[receivingId], rotation[receivingId]), rotation[receivingId]);
+        serveEntry.serves++;
+        recEntry.receptions++;
         if (winnerId === servingId) {
             serving.breakpointWins++;
-            addRotationPoint(winner, zone, rotIdx, 'serve');
+            serveEntry.servePoints++;
         }
         else {
             receiving.sideoutWins++;
-            addRotationPoint(winner, zone, rotIdx, 'sideout');
+            if (spikeCount(rallies[i]) === 1)
+                receiving.fbsoWins++;
+            recEntry.sideoutPoints++;
         }
         // The sideout winner gains serve, so they rotate (after the point is attributed to their old rotation).
         if (winnerId === receivingId)
@@ -86,6 +96,9 @@ function finalizeTeam(acc) {
         modReceptions,
         modSideoutWins,
         modSideoutPct: modReceptions > 0 ? (modSideoutWins / modReceptions) * 100 : 0,
+        fbsoWins: acc.fbsoWins,
+        fbsoPct: acc.receptions > 0 ? (acc.fbsoWins / acc.receptions) * 100 : 0,
+        modFbsoPct: modReceptions > 0 ? (acc.fbsoWins / modReceptions) * 100 : 0,
         rotations
     };
 }

package/dist/cjs/src/service/match/rally-metrics.test.js

@@ -48,12 +48,45 @@ describe('computeRallyMetrics()', () => {
     it('per-set rotations labeled by setter zone, split serve vs sideout', () => {
         expect(m.sets).toHaveLength(1);
         expect(m.sets[0].home.rotations).toEqual([
-            { setterZone: 1, rotation: 2, servePoints: 1, sideoutPoints: 0, points: 1 },
-            { setterZone: 2, rotation: 1, servePoints: 1, sideoutPoints: 1, points: 2 }
+            { setterZone: 1, rotation: 2, serves: 1, servePoints: 1, receptions: 0, sideoutPoints: 0, points: 1 },
+            { setterZone: 2, rotation: 1, serves: 2, servePoints: 1, receptions: 2, sideoutPoints: 1, points: 2 }
         ]);
         expect(m.sets[0].away.rotations).toEqual([
-            { setterZone: 1, rotation: 1, servePoints: 0, sideoutPoints: 1, points: 1 },
-            { setterZone: 6, rotation: 2, servePoints: 1, sideoutPoints: 0, points: 1 }
+            { setterZone: 1, rotation: 1, serves: 0, servePoints: 0, receptions: 2, sideoutPoints: 1, points: 1 },
+            { setterZone: 6, rotation: 2, serves: 2, servePoints: 1, receptions: 1, sideoutPoints: 0, points: 1 }
         ]);
     });
 });
+// First ball sideout: a sideout won on the receiving team's first attack (exactly one spike in the rally).
+const serveEv = (failure = 0) => ({ eventType: event_1.EventTypeEnum.SERVE, failure });
+const spikeEv = () => ({ eventType: event_1.EventTypeEnum.SPIKE, failure: 0 });
+// serving H, A, H, A ; winners A, H, A, A (A 3 - H 1). Setter-agnostic, so no setters.
+const fbsoSet = {
+    homePoints: 1,
+    awayPoints: 3,
+    homeSetterStartZone: null,
+    awaySetterStartZone: null,
+    rallies: [
+        { servingTeamId: HOME, events: [serveEv(), spikeEv()] }, // A sideout on 1 spike -> A FBSO
+        { servingTeamId: AWAY, events: [serveEv(), spikeEv(), spikeEv()] }, // H sideout on 2 spikes -> transition, not FBSO
+        { servingTeamId: HOME, events: [serveEv(1)] }, // A sideout via H service error, 0 spikes -> not FBSO
+        { servingTeamId: AWAY, events: [serveEv(), spikeEv()] } // A breakpoint (A serving) -> not a reception win
+    ]
+};
+const fm = (0, rally_metrics_1.computeRallyMetrics)([fbsoSet], HOME, AWAY);
+describe('computeRallyMetrics() first ball sideout', () => {
+    it('counts only sideouts won on the first attack (one spike)', () => {
+        expect(fm.total.away.receptions).toBe(2);
+        expect(fm.total.away.fbsoWins).toBe(1);
+        expect(fm.total.away.fbsoPct).toBeCloseTo(50, 5);
+    });
+    it('modified FBSO excludes opponent service errors from the denominator', () => {
+        expect(fm.total.away.serviceErrorsReceived).toBe(1);
+        expect(fm.total.away.modFbsoPct).toBeCloseTo(100, 5);
+    });
+    it('ignores transition sideouts (2+ spikes) and reception losses', () => {
+        expect(fm.total.home.fbsoWins).toBe(0);
+        expect(fm.total.home.fbsoPct).toBe(0);
+        expect(fm.total.home.modFbsoPct).toBe(0);
+    });
+});

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

@@ -16,7 +16,9 @@ export interface RallyMetricsSet {
 export interface RotationMetrics {
     setterZone: number | null;
     rotation: number;
+    serves: number;
     servePoints: number;
+    receptions: number;
     sideoutPoints: number;
     points: number;
 }
@@ -31,6 +33,9 @@ export interface TeamRallyMetrics {
     modReceptions: number;
     modSideoutWins: number;
     modSideoutPct: number;
+    fbsoWins: number;
+    fbsoPct: number;
+    modFbsoPct: number;
     rotations: RotationMetrics[];
 }
 export interface SetRallyMetrics {

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

@@ -1,12 +1,18 @@
 import { EventTypeEnum } from '../event';
 import { rotatePosition } from './court-position';
 function newAcc() {
-    return { serves: 0, breakpointWins: 0, receptions: 0, sideoutWins: 0, serviceErrorsReceived: 0, rotations: new Map() };
+    return { serves: 0, breakpointWins: 0, receptions: 0, sideoutWins: 0, serviceErrorsReceived: 0, fbsoWins: 0, rotations: new Map() };
 }
 function isServiceError(rally) {
     const serve = rally.events.find(e => e.eventType === EventTypeEnum.SERVE);
     return serve != null && (serve.failure ?? 0) > 0;
 }
+// A first-ball sideout is won on the receiving team's first attack: the rally has exactly one spike (the
+// engine scores a second spike as a transition). This counts first-ball kills and the block errors forced
+// on that first attack, and excludes service-error sideouts (no spike) and dig-and-transition rallies (2+).
+function spikeCount(rally) {
+    return rally.events.reduce((n, e) => e.eventType === EventTypeEnum.SPIKE ? n + 1 : n, 0);
+}
 // The setter's zone after (rotationIndex - 1) rotations from their start zone, using the engine's own
 // rotatePosition (each rotation moves a player one zone: 2->1, 1->6, ...). null when no setter.
 function setterZoneAt(startZone, rotationIndex) {
@@ -17,17 +23,16 @@ function setterZoneAt(startZone, rotationIndex) {
         zone = rotatePosition(zone);
     return zone;
 }
-function addRotationPoint(acc, setterZone, rotation, kind) {
+// Get (or create) a team's rotation bucket, keyed by setter zone when known (so the total sums by zone
+// across sets), else by the rotation index.
+function rotationEntry(acc, setterZone, rotation) {
     const key = setterZone != null ? `z${setterZone}` : `r${rotation}`;
     let entry = acc.rotations.get(key);
     if (entry == null) {
-        entry = { setterZone, rotation, servePoints: 0, sideoutPoints: 0 };
+        entry = { setterZone, rotation, servePoints: 0, sideoutPoints: 0, serves: 0, receptions: 0 };
         acc.rotations.set(key, entry);
     }
-    if (kind === 'serve')
-        entry.servePoints++;
-    else
-        entry.sideoutPoints++;
+    return entry;
 }
 // Walk one set, folding its rallies into the home/away accumulators (used for both per-set and total).
 function accumulateSet(set, homeId, awayId, homeAcc, awayAcc) {
@@ -44,22 +49,27 @@ function accumulateSet(set, homeId, awayId, homeAcc, awayAcc) {
         const winnerId = i < rallies.length - 1 ? rallies[i + 1].servingTeamId : setWinnerId;
         const serving = accOf(servingId);
         const receiving = accOf(receivingId);
-        const winner = accOf(winnerId);
-        if (serving == null || receiving == null || winner == null)
+        if (serving == null || receiving == null || (winnerId !== servingId && winnerId !== receivingId))
             continue;
         serving.serves++;
         receiving.receptions++;
         if (isServiceError(rallies[i]))
             receiving.serviceErrorsReceived++;
-        const rotIdx = rotation[winnerId];
-        const zone = setterZoneAt(startZone[winnerId], rotIdx);
+        // Per-rotation attempts: both teams play this rally in their current rotation. The point below is
+        // attributed to the winner, whose bucket is the same serve (breakpoint) or reception (sideout) entry.
+        const serveEntry = rotationEntry(serving, setterZoneAt(startZone[servingId], rotation[servingId]), rotation[servingId]);
+        const recEntry = rotationEntry(receiving, setterZoneAt(startZone[receivingId], rotation[receivingId]), rotation[receivingId]);
+        serveEntry.serves++;
+        recEntry.receptions++;
         if (winnerId === servingId) {
             serving.breakpointWins++;
-            addRotationPoint(winner, zone, rotIdx, 'serve');
+            serveEntry.servePoints++;
         }
         else {
             receiving.sideoutWins++;
-            addRotationPoint(winner, zone, rotIdx, 'sideout');
+            if (spikeCount(rallies[i]) === 1)
+                receiving.fbsoWins++;
+            recEntry.sideoutPoints++;
         }
         // The sideout winner gains serve, so they rotate (after the point is attributed to their old rotation).
         if (winnerId === receivingId)
@@ -83,6 +93,9 @@ function finalizeTeam(acc) {
         modReceptions,
         modSideoutWins,
         modSideoutPct: modReceptions > 0 ? (modSideoutWins / modReceptions) * 100 : 0,
+        fbsoWins: acc.fbsoWins,
+        fbsoPct: acc.receptions > 0 ? (acc.fbsoWins / acc.receptions) * 100 : 0,
+        modFbsoPct: modReceptions > 0 ? (acc.fbsoWins / modReceptions) * 100 : 0,
         rotations
     };
 }

package/dist/esm/src/service/match/rally-metrics.test.js

@@ -46,12 +46,45 @@ describe('computeRallyMetrics()', () => {
     it('per-set rotations labeled by setter zone, split serve vs sideout', () => {
         expect(m.sets).toHaveLength(1);
         expect(m.sets[0].home.rotations).toEqual([
-            { setterZone: 1, rotation: 2, servePoints: 1, sideoutPoints: 0, points: 1 },
-            { setterZone: 2, rotation: 1, servePoints: 1, sideoutPoints: 1, points: 2 }
+            { setterZone: 1, rotation: 2, serves: 1, servePoints: 1, receptions: 0, sideoutPoints: 0, points: 1 },
+            { setterZone: 2, rotation: 1, serves: 2, servePoints: 1, receptions: 2, sideoutPoints: 1, points: 2 }
         ]);
         expect(m.sets[0].away.rotations).toEqual([
-            { setterZone: 1, rotation: 1, servePoints: 0, sideoutPoints: 1, points: 1 },
-            { setterZone: 6, rotation: 2, servePoints: 1, sideoutPoints: 0, points: 1 }
+            { setterZone: 1, rotation: 1, serves: 0, servePoints: 0, receptions: 2, sideoutPoints: 1, points: 1 },
+            { setterZone: 6, rotation: 2, serves: 2, servePoints: 1, receptions: 1, sideoutPoints: 0, points: 1 }
         ]);
     });
 });
+// First ball sideout: a sideout won on the receiving team's first attack (exactly one spike in the rally).
+const serveEv = (failure = 0) => ({ eventType: EventTypeEnum.SERVE, failure });
+const spikeEv = () => ({ eventType: EventTypeEnum.SPIKE, failure: 0 });
+// serving H, A, H, A ; winners A, H, A, A (A 3 - H 1). Setter-agnostic, so no setters.
+const fbsoSet = {
+    homePoints: 1,
+    awayPoints: 3,
+    homeSetterStartZone: null,
+    awaySetterStartZone: null,
+    rallies: [
+        { servingTeamId: HOME, events: [serveEv(), spikeEv()] }, // A sideout on 1 spike -> A FBSO
+        { servingTeamId: AWAY, events: [serveEv(), spikeEv(), spikeEv()] }, // H sideout on 2 spikes -> transition, not FBSO
+        { servingTeamId: HOME, events: [serveEv(1)] }, // A sideout via H service error, 0 spikes -> not FBSO
+        { servingTeamId: AWAY, events: [serveEv(), spikeEv()] } // A breakpoint (A serving) -> not a reception win
+    ]
+};
+const fm = computeRallyMetrics([fbsoSet], HOME, AWAY);
+describe('computeRallyMetrics() first ball sideout', () => {
+    it('counts only sideouts won on the first attack (one spike)', () => {
+        expect(fm.total.away.receptions).toBe(2);
+        expect(fm.total.away.fbsoWins).toBe(1);
+        expect(fm.total.away.fbsoPct).toBeCloseTo(50, 5);
+    });
+    it('modified FBSO excludes opponent service errors from the denominator', () => {
+        expect(fm.total.away.serviceErrorsReceived).toBe(1);
+        expect(fm.total.away.modFbsoPct).toBeCloseTo(100, 5);
+    });
+    it('ignores transition sideouts (2+ spikes) and reception losses', () => {
+        expect(fm.total.home.fbsoWins).toBe(0);
+        expect(fm.total.home.fbsoPct).toBe(0);
+        expect(fm.total.home.modFbsoPct).toBe(0);
+    });
+});

package/package.json

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