volleyballsimtypes 0.0.500 → 0.0.502

package/dist/esm/src/data/models/box-score.js

@@ -36,6 +36,11 @@ export class BoxScoreModel extends Model {
                 allowNull: false,
                 defaultValue: 0
             },
+            attack_blocked: {
+                type: DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0
+            },
             // Serve
             serve_attempts: {
                 type: DataTypes.SMALLINT,
@@ -68,6 +73,16 @@ export class BoxScoreModel extends Model {
                 allowNull: false,
                 defaultValue: 0
             },
+            reception_ok: {
+                type: DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0
+            },
+            reception_negative: {
+                type: DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0
+            },
             reception_overpasses: {
                 type: DataTypes.SMALLINT,
                 allowNull: false,
@@ -121,6 +136,21 @@ export class BoxScoreModel extends Model {
                 allowNull: false,
                 defaultValue: 0
             },
+            defense_digs_perfect: {
+                type: DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0
+            },
+            defense_digs_mediocre: {
+                type: DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0
+            },
+            defense_digs_bad: {
+                type: DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0
+            },
             defense_errors: {
                 type: DataTypes.SMALLINT,
                 allowNull: false,

package/dist/esm/src/data/models/views/box-score-totals.d.ts

@@ -6,12 +6,15 @@ export interface BoxScoreTotalsAttributes {
     attack_attempts: number;
     attack_kills: number;
     attack_errors: number;
+    attack_blocked: number;
     serve_attempts: number;
     serve_aces: number;
     serve_errors: number;
     reception_attempts: number;
     reception_perfect: number;
     reception_positive: number;
+    reception_ok: number;
+    reception_negative: number;
     reception_overpasses: number;
     reception_errors: number;
     block_solo: number;
@@ -22,6 +25,9 @@ export interface BoxScoreTotalsAttributes {
     setting_errors: number;
     setting_pass: number;
     defense_digs: number;
+    defense_digs_perfect: number;
+    defense_digs_mediocre: number;
+    defense_digs_bad: number;
     defense_errors: number;
     misc_points_played: number;
     misc_points_won_on_court: number;
@@ -39,12 +45,15 @@ export declare class BoxScoreTotalsModel extends Model<BoxScoreTotalsAttributes,
     attack_attempts: number;
     attack_kills: number;
     attack_errors: number;
+    attack_blocked: number;
     serve_attempts: number;
     serve_aces: number;
     serve_errors: number;
     reception_attempts: number;
     reception_perfect: number;
     reception_positive: number;
+    reception_ok: number;
+    reception_negative: number;
     reception_overpasses: number;
     reception_errors: number;
     block_solo: number;
@@ -55,6 +64,9 @@ export declare class BoxScoreTotalsModel extends Model<BoxScoreTotalsAttributes,
     setting_errors: number;
     setting_pass: number;
     defense_digs: number;
+    defense_digs_perfect: number;
+    defense_digs_mediocre: number;
+    defense_digs_bad: number;
     defense_errors: number;
     misc_points_played: number;
     misc_points_won_on_court: number;

package/dist/esm/src/data/models/views/box-score-totals.js

@@ -23,6 +23,10 @@ export class BoxScoreTotalsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false
             },
+            attack_blocked: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
             serve_attempts: {
                 type: DataTypes.INTEGER,
                 allowNull: false
@@ -47,6 +51,14 @@ export class BoxScoreTotalsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false
             },
+            reception_ok: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            reception_negative: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
             reception_overpasses: {
                 type: DataTypes.INTEGER,
                 allowNull: false
@@ -87,6 +99,18 @@ export class BoxScoreTotalsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false
             },
+            defense_digs_perfect: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            defense_digs_mediocre: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            defense_digs_bad: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
             defense_errors: {
                 type: DataTypes.INTEGER,
                 allowNull: false

package/dist/esm/src/data/transformers/box-score.js

@@ -6,12 +6,15 @@ function transformToAttributes(boxScore) {
         attack_attempts: boxScore.attack.attempts,
         attack_kills: boxScore.attack.kills,
         attack_errors: boxScore.attack.errors,
+        attack_blocked: boxScore.attack.blocked,
         serve_attempts: boxScore.serve.attempts,
         serve_aces: boxScore.serve.aces,
         serve_errors: boxScore.serve.errors,
         reception_attempts: boxScore.reception.attempts,
         reception_perfect: boxScore.reception.perfect,
         reception_positive: boxScore.reception.positive,
+        reception_ok: boxScore.reception.ok,
+        reception_negative: boxScore.reception.negative,
         reception_overpasses: boxScore.reception.overpasses,
         reception_errors: boxScore.reception.errors,
         block_solo: boxScore.block.solo,
@@ -22,6 +25,9 @@ function transformToAttributes(boxScore) {
         setting_errors: boxScore.setting.errors,
         setting_pass: boxScore.setting.pass,
         defense_digs: boxScore.defense.digs,
+        defense_digs_perfect: boxScore.defense.digsPerfect,
+        defense_digs_mediocre: boxScore.defense.digsMediocre,
+        defense_digs_bad: boxScore.defense.digsBad,
         defense_errors: boxScore.defense.errors,
         misc_points_played: boxScore.misc.pointsPlayed,
         misc_points_won_on_court: boxScore.misc.pointsWonOnCourt,
@@ -37,7 +43,8 @@ function transformToObject(model) {
         attack: {
             attempts: model.attack_attempts,
             kills: model.attack_kills,
-            errors: model.attack_errors
+            errors: model.attack_errors,
+            blocked: model.attack_blocked
         },
         serve: {
             attempts: model.serve_attempts,
@@ -48,6 +55,8 @@ function transformToObject(model) {
             attempts: model.reception_attempts,
             perfect: model.reception_perfect,
             positive: model.reception_positive,
+            ok: model.reception_ok,
+            negative: model.reception_negative,
             overpasses: model.reception_overpasses,
             errors: model.reception_errors
         },
@@ -64,6 +73,9 @@ function transformToObject(model) {
         },
         defense: {
             digs: model.defense_digs,
+            digsPerfect: model.defense_digs_perfect,
+            digsMediocre: model.defense_digs_mediocre,
+            digsBad: model.defense_digs_bad,
             errors: model.defense_errors
         },
         misc: {

package/dist/esm/src/data/transformers/player.js

@@ -33,7 +33,8 @@ function transformToBoxScoreTotals(model) {
         attack: {
             attempts: toNumberStrict(model.attack_attempts, 'attack_attempts'),
             kills: toNumberStrict(model.attack_kills, 'attack_kills'),
-            errors: toNumberStrict(model.attack_errors, 'attack_errors')
+            errors: toNumberStrict(model.attack_errors, 'attack_errors'),
+            blocked: toNumberStrict(model.attack_blocked, 'attack_blocked')
         },
         serve: {
             attempts: toNumberStrict(model.serve_attempts, 'serve_attempts'),
@@ -44,6 +45,8 @@ function transformToBoxScoreTotals(model) {
             attempts: toNumberStrict(model.reception_attempts, 'reception_attempts'),
             perfect: toNumberStrict(model.reception_perfect, 'reception_perfect'),
             positive: toNumberStrict(model.reception_positive, 'reception_positive'),
+            ok: toNumberStrict(model.reception_ok, 'reception_ok'),
+            negative: toNumberStrict(model.reception_negative, 'reception_negative'),
             overpasses: toNumberStrict(model.reception_overpasses, 'reception_overpasses'),
             errors: toNumberStrict(model.reception_errors, 'reception_errors')
         },
@@ -60,6 +63,9 @@ function transformToBoxScoreTotals(model) {
         },
         defense: {
             digs: toNumberStrict(model.defense_digs, 'defense_digs'),
+            digsPerfect: toNumberStrict(model.defense_digs_perfect, 'defense_digs_perfect'),
+            digsMediocre: toNumberStrict(model.defense_digs_mediocre, 'defense_digs_mediocre'),
+            digsBad: toNumberStrict(model.defense_digs_bad, 'defense_digs_bad'),
             errors: toNumberStrict(model.defense_errors, 'defense_errors')
         },
         misc: {

package/dist/esm/src/data/transformers/rally-event-positional.test.d.ts

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

package/dist/esm/src/data/transformers/rally-event-positional.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { DigQualityEnum, Reception, ReceptionFailureEnum, ReceptionTypeEnum, Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
+import { transformToCompact, transformToReception, transformToSpike } from './rally-event';
+describe('rally-event compact round trip -- positional fields (coords / speed / dig quality)', () => {
+    const playerId = uuidv4();
+    const roster = [playerId];
+    const playerIndex = new Map(roster.map((id, i) => [id, i]));
+    it('packs contact/landing/speed and round-trips them, 2-dp rounded', () => {
+        const spike = Spike.create({
+            playerId,
+            score: 60,
+            target: 4,
+            failure: SpikeFailureEnum.NO_FAILURE,
+            type: SpikeTypeEnum.CROSS_SHOT,
+            contact: { x: 1.234, y: -0.5 },
+            landing: { x: -2.5, y: 6.789 },
+            speed: 92.456
+        });
+        const compact = transformToCompact(spike, playerIndex);
+        expect(compact.c).toEqual([1.23, -0.5]);
+        expect(compact.g).toEqual([-2.5, 6.79]);
+        expect(compact.v).toBe(92.46);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.contact).toEqual({ x: 1.23, y: -0.5 });
+        expect(decoded.landing).toEqual({ x: -2.5, y: 6.79 });
+        expect(decoded.speed).toBe(92.46);
+    });
+    it('packs dig quality on a reception and round-trips it', () => {
+        const dig = Reception.create({
+            playerId,
+            score: 40,
+            target: 3,
+            failure: ReceptionFailureEnum.NO_FAILURE,
+            type: ReceptionTypeEnum.DIG,
+            digQuality: DigQualityEnum.MEDIOCRE
+        });
+        const compact = transformToCompact(dig, playerIndex);
+        expect(compact.q).toBe(DigQualityEnum.MEDIOCRE);
+        const decoded = transformToReception(compact, roster);
+        expect(decoded.digQuality).toBe(DigQualityEnum.MEDIOCRE);
+    });
+    it('omits the positional keys when absent, and a legacy event decodes them as undefined', () => {
+        const spike = Spike.create({ playerId, score: 60, target: 4, failure: SpikeFailureEnum.NO_FAILURE, type: SpikeTypeEnum.CROSS_SHOT });
+        const compact = transformToCompact(spike, playerIndex);
+        expect('c' in compact).toBe(false);
+        expect('v' in compact).toBe(false);
+        expect('q' in compact).toBe(false);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.contact).toBeUndefined();
+        expect(decoded.speed).toBeUndefined();
+        expect(decoded.digQuality).toBeUndefined();
+    });
+});

package/dist/esm/src/data/transformers/rally-event.d.ts

@@ -13,6 +13,10 @@ export interface CompactEvent {
     i?: number;
     h?: number;
     m?: number;
+    c?: number[];
+    g?: number[];
+    v?: number;
+    q?: number;
 }
 export declare function transformToCompact(evt: RallyEvent, playerIndex: Map<string, number>): CompactEvent;
 export declare function transformToBlock(event: CompactEvent, roster: string[]): Block;

package/dist/esm/src/data/transformers/rally-event.js

@@ -1,4 +1,18 @@
 import { Block, FreeBall, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+// Rebuild the optional positional fields (contact / landing / speed / digQuality) from a compact event, for the
+// event .create() inputs. Loosely typed since create() validates via its Zod schema.
+function positionalFromCompact(e) {
+    const out = {};
+    if (e.c != null)
+        out.contact = { x: e.c[0], y: e.c[1] };
+    if (e.g != null)
+        out.landing = { x: e.g[0], y: e.g[1] };
+    if (e.v != null)
+        out.speed = e.v;
+    if (e.q != null)
+        out.digQuality = e.q;
+    return out;
+}
 // Incident packing for the compact key 'i': values below 10 are injury severities, 10+ are knock tiers.
 function incidentToCompact(incident) {
     if (incident == null)
@@ -31,6 +45,14 @@ export function transformToCompact(evt, playerIndex) {
                 out.h = playerIndex.get(evt.incident.playerId);
             }
         }
+        if (evt.contact != null)
+            out.c = [evt.contact.x, evt.contact.y];
+        if (evt.landing != null)
+            out.g = [evt.landing.x, evt.landing.y];
+        if (evt.speed != null)
+            out.v = evt.speed;
+        if (evt.digQuality != null)
+            out.q = evt.digQuality;
         if (evt instanceof Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
@@ -57,7 +79,8 @@ export function transformToBlock(event, roster) {
         target: event.a,
         blockers: (event.b ?? []).map(i => roster[i]),
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 export function transformToLiberoReplacement(event, roster) {
@@ -74,7 +97,8 @@ export function transformToReception(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 export function transformToServe(event, roster) {
@@ -84,7 +108,8 @@ export function transformToServe(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 export function transformToSet(event, roster) {
@@ -95,7 +120,8 @@ export function transformToSet(event, roster) {
         target: event.a,
         score: event.s,
         incident: incidentFromCompact(event.i, event.h, roster),
-        tempo: event.m
+        tempo: event.m,
+        ...positionalFromCompact(event)
     });
 }
 export function transformToSpike(event, roster) {
@@ -105,7 +131,8 @@ export function transformToSpike(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 // FreeBall (Last Resort save) is a plain InPlayEvent with no incident of its own, so it decodes from f/t/a/s
@@ -116,7 +143,8 @@ export function transformToFreeBall(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        ...positionalFromCompact(event)
     });
 }
 export function transformToSubstitution(event, roster) {

package/dist/esm/src/service/competition/event-rewards.d.ts

@@ -1,4 +1,4 @@
-export type EventRewardBand = 'PARTICIPATION' | 'TOP_20' | 'TOP_10' | 'TOP_5' | 'TOP_3' | 'TOP_1';
+export type EventRewardBand = 'PARTICIPATION' | 'FINAL_GROUP' | 'TOP_10' | 'TOP_5' | 'TOP_3' | 'TOP_1';
 export interface EventRewardRow {
     readonly band: EventRewardBand;
     /** Best final position that earns this row; PARTICIPATION has none. */
@@ -15,7 +15,8 @@ export interface EventRewardRow {
 export declare const EVENT_REWARDS: readonly EventRewardRow[];
 /**
  * The band a finish falls into. `position` is the place in the FINAL table; null means the team never reached
- * the final, and so does any position past the last banded row, which both count as taking part.
+ * the final (it went out in the group stage) and takes the participation row. The final holds MAX_FINAL_SIZE
+ * teams and the widest banded row (FINAL_GROUP) covers exactly that, so every finalist earns a banded row.
  */
 export declare function eventRewardBandFor(position: number | null): EventRewardBand;
 export interface EventPayout {

package/dist/esm/src/service/competition/event-rewards.js

@@ -3,6 +3,7 @@
 // One source of truth for three consumers: the simulator grants from it, the About view lists it, and the
 // accolades page names the band. Rewards are CUMULATIVE, so a team collects every row from Participation down
 // to its own placement.
+import { MAX_FINAL_SIZE } from './event-schedule';
 /**
  * Best band first. A team earns its own row and every row BELOW it, which is what "cumulative" means: first
  * place collects all six.
@@ -12,18 +13,19 @@ export const EVENT_REWARDS = [
     { band: 'TOP_3', maxPosition: 3, packs: 0, coins: 500 },
     { band: 'TOP_5', maxPosition: 5, packs: 0, coins: 1000 },
     { band: 'TOP_10', maxPosition: 10, packs: 1, coins: 0 },
-    { band: 'TOP_20', maxPosition: 20, packs: 0, coins: 1000 },
+    { band: 'FINAL_GROUP', maxPosition: MAX_FINAL_SIZE, packs: 0, coins: 1000 },
     { band: 'PARTICIPATION', maxPosition: null, packs: 1, coins: 1000 }
 ];
 /**
  * The band a finish falls into. `position` is the place in the FINAL table; null means the team never reached
- * the final, and so does any position past the last banded row, which both count as taking part.
+ * the final (it went out in the group stage) and takes the participation row. The final holds MAX_FINAL_SIZE
+ * teams and the widest banded row (FINAL_GROUP) covers exactly that, so every finalist earns a banded row.
  */
 export function eventRewardBandFor(position) {
     if (position == null)
         return 'PARTICIPATION';
     // Rows are ordered best-first, so the FIRST row the position satisfies is the narrowest band it earns.
-    // Scanning to the end instead would always land on the widest, handing first place a "top 20" badge.
+    // Scanning to the end instead would always land on the widest, handing first place a "final group" badge.
     for (const row of EVENT_REWARDS) {
         if (row.maxPosition != null && position <= row.maxPosition)
             return row.band;

package/dist/esm/src/service/competition/event-rewards.test.js

@@ -9,11 +9,11 @@ describe('eventRewardBandFor()', () => {
         [5, 'TOP_5'],
         [6, 'TOP_10'],
         [10, 'TOP_10'],
-        [11, 'TOP_20'],
-        [20, 'TOP_20'],
-        // Inside a 24-team final but outside every banded row, so it counts as taking part.
-        [21, 'PARTICIPATION'],
-        [24, 'PARTICIPATION']
+        [11, 'FINAL_GROUP'],
+        [20, 'FINAL_GROUP'],
+        // The final holds 24 teams and FINAL_GROUP covers all of them.
+        [21, 'FINAL_GROUP'],
+        [24, 'FINAL_GROUP']
     ])('places a finish of %i in %s', (position, band) => {
         expect(eventRewardBandFor(position)).toBe(band);
     });
@@ -24,9 +24,9 @@ describe('eventRewardBandFor()', () => {
 describe('eventPayoutFor()', () => {
     it.each([
         // position, packs, coins. Cumulative: every row from Participation down to the finish.
-        [null, 1, 1000], // group stage: 1 pack + 1000
-        [24, 1, 1000], // in the final but outside the top 20: still just participation
-        [20, 1, 2000], // + top 20's 1000
+        [null, 1, 1000], // never reached the final (group stage): 1 pack + 1000
+        [24, 1, 2000], // last of the 24-team final: final group's 1000 on top of participation
+        [20, 1, 2000], // + final group's 1000
         [11, 1, 2000],
         [10, 2, 2000], // + top 10's pack
         [6, 2, 2000],
@@ -48,7 +48,7 @@ describe('eventPayoutFor()', () => {
         }
     });
     it('adds up to the owner-defined table for a winner', () => {
-        // 1x pack + 1000 (participation), +1000 (top 20), +1 pack (top 10), +1000 (top 5), +500 (top 3), +1 pack (top 1)
+        // 1x pack + 1000 (participation), +1000 (final group), +1 pack (top 10), +1000 (top 5), +500 (top 3), +1 pack (top 1)
         const total = EVENT_REWARDS.reduce((acc, row) => ({ packs: acc.packs + row.packs, coins: acc.coins + row.coins }), { packs: 0, coins: 0 });
         expect(eventPayoutFor(1)).toEqual(total);
         expect(total).toEqual({ packs: 3, coins: 3500 });

package/dist/esm/src/service/event/block.js

@@ -31,8 +31,8 @@ export class Block extends InPlayEvent {
         }
         return new Block(result.data);
     }
-    constructor({ score, playerId, target, failure, type, blockers, activeTraits, incident }) {
-        super({ score, playerId, target, activeTraits, incident, eventType });
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits, incident, contact, landing, speed, digQuality }) {
+        super({ score, playerId, target, activeTraits, incident, eventType, contact, landing, speed, digQuality });
         this.type = type;
         this.failure = failure;
         this.blockers = blockers;

package/dist/esm/src/service/event/free-ball.js

@@ -30,8 +30,8 @@ export class FreeBall extends InPlayEvent {
         }
         return new FreeBall(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, contact, landing, speed, digQuality }) {
+        super({ score, playerId, target, activeTraits, eventType, contact, landing, speed, digQuality });
         this.type = type;
         this.failure = failure;
     }

package/dist/esm/src/service/event/in-play-event.d.ts

@@ -6,11 +6,25 @@ export interface EventIncident {
     readonly severity: number;
     readonly playerId?: string;
 }
+export declare enum DigQualityEnum {
+    PERFECT = 0,
+    MEDIOCRE = 1,
+    BAD = 2
+}
+export type DigQuality = DigQualityEnum.PERFECT | DigQualityEnum.MEDIOCRE | DigQualityEnum.BAD;
+export interface EventCoord {
+    readonly x: number;
+    readonly y: number;
+}
 export interface InPlayEventOpts extends RallyEventOpts {
     readonly target: CourtTarget;
     readonly score: number;
     readonly activeTraits: Trait[];
     readonly incident?: EventIncident;
+    readonly contact?: EventCoord;
+    readonly landing?: EventCoord;
+    readonly speed?: number;
+    readonly digQuality?: DigQuality;
 }
 export declare abstract class InPlayEvent<F, T> extends RallyEvent {
     abstract failure: F;
@@ -19,5 +33,9 @@ export declare abstract class InPlayEvent<F, T> extends RallyEvent {
     readonly score: number;
     readonly activeTraits: Trait[];
     readonly incident?: EventIncident;
-    protected constructor({ eventType, playerId, target, score, activeTraits, incident }: InPlayEventOpts);
+    readonly contact?: EventCoord;
+    readonly landing?: EventCoord;
+    readonly speed?: number;
+    readonly digQuality?: DigQuality;
+    protected constructor({ eventType, playerId, target, score, activeTraits, incident, contact, landing, speed, digQuality }: InPlayEventOpts);
 }

package/dist/esm/src/service/event/in-play-event.js

@@ -1,10 +1,25 @@
 import { RallyEvent } from './rally-event';
+// The quality of a DEFENSIVE dig (positional engine, effort gating): a PERFECT dig sets up a clean in-system
+// counter, MEDIOCRE is out of position, BAD is a scramble. Persisted on the Reception (dig) event's 'q' key.
+export var DigQualityEnum;
+(function (DigQualityEnum) {
+    DigQualityEnum[DigQualityEnum["PERFECT"] = 0] = "PERFECT";
+    DigQualityEnum[DigQualityEnum["MEDIOCRE"] = 1] = "MEDIOCRE";
+    DigQualityEnum[DigQualityEnum["BAD"] = 2] = "BAD";
+})(DigQualityEnum || (DigQualityEnum = {}));
+function roundCoord(c) {
+    return c != null ? { x: Number(c.x.toFixed(2)), y: Number(c.y.toFixed(2)) } : undefined;
+}
 export class InPlayEvent extends RallyEvent {
-    constructor({ eventType, playerId, target, score, activeTraits, incident }) {
+    constructor({ eventType, playerId, target, score, activeTraits, incident, contact, landing, speed, digQuality }) {
         super({ playerId, eventType });
         this.target = target;
         this.score = Number(score.toFixed(2));
         this.activeTraits = activeTraits;
         this.incident = incident;
+        this.contact = roundCoord(contact);
+        this.landing = roundCoord(landing);
+        this.speed = speed != null ? Number(speed.toFixed(2)) : undefined;
+        this.digQuality = digQuality;
     }
 }

package/dist/esm/src/service/event/reception.js

@@ -33,8 +33,8 @@ export class Reception extends InPlayEvent {
         }
         return new Reception(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
-        super({ score, playerId, target, activeTraits, incident, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident, contact, landing, speed, digQuality }) {
+        super({ score, playerId, target, activeTraits, incident, eventType, contact, landing, speed, digQuality });
         this.type = type;
         this.failure = failure;
     }

package/dist/esm/src/service/event/schemas/block.z.d.ts

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const BlockInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

package/dist/esm/src/service/event/schemas/block.z.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
+import { positionalEventFields } from './positional.z';
 const blockTypeValues = [0, 1, 2, 3];
 const blockFailureValues = [0, 1, 2, 3, 4, 5];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -12,7 +13,8 @@ export const BlockInputSchema = z.object({
     failure: z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
     type: z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
     blockers: z.array(z.uuid()),
-    incident: EventIncidentSchema.optional()
+    incident: EventIncidentSchema.optional(),
+    ...positionalEventFields
 }).superRefine((data, ctx) => {
     // The block type IS the blocker count (NO_BLOCKER=0, SINGLE=1, DOUBLE=2, TRIPLE=3), so the two must agree.
     if (data.blockers.length !== data.type) {

package/dist/esm/src/service/event/schemas/free-ball.z.d.ts

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const FreeBallInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

package/dist/esm/src/service/event/schemas/free-ball.z.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { positionalEventFields } from './positional.z';
 const freeBallTypeValues = [0, 1];
 const freeBallFailureValues = [0];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -9,5 +10,6 @@ export const FreeBallInputSchema = z.object({
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => freeBallFailureValues.includes(v), { message: 'INVALID_FREE_BALL_FAILURE' }),
-    type: z.number().int().refine((v) => freeBallTypeValues.includes(v), { message: 'INVALID_FREE_BALL_TYPE' })
+    type: z.number().int().refine((v) => freeBallTypeValues.includes(v), { message: 'INVALID_FREE_BALL_TYPE' }),
+    ...positionalEventFields
 });