subtr_actor/stats/calculators/
ball_carry.rs

1use super::*;
2
3#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, ts_rs::TS)]
4#[ts(export)]
5pub struct BallCarryStats {
6    pub carry_count: u32,
7    pub total_carry_time: f32,
8    pub total_straight_line_distance: f32,
9    pub total_path_distance: f32,
10    pub longest_carry_time: f32,
11    pub furthest_carry_distance: f32,
12    pub fastest_carry_speed: f32,
13    pub carry_speed_sum: f32,
14    pub average_horizontal_gap_sum: f32,
15    pub average_vertical_gap_sum: f32,
16}
17
18impl BallCarryStats {
19    fn pct_count_average(&self, value: f32) -> f32 {
20        if self.carry_count == 0 {
21            0.0
22        } else {
23            value / self.carry_count as f32
24        }
25    }
26
27    pub fn average_carry_time(&self) -> f32 {
28        self.pct_count_average(self.total_carry_time)
29    }
30
31    pub fn average_straight_line_distance(&self) -> f32 {
32        self.pct_count_average(self.total_straight_line_distance)
33    }
34
35    pub fn average_path_distance(&self) -> f32 {
36        self.pct_count_average(self.total_path_distance)
37    }
38
39    pub fn average_carry_speed(&self) -> f32 {
40        self.pct_count_average(self.carry_speed_sum)
41    }
42
43    pub fn average_horizontal_gap(&self) -> f32 {
44        self.pct_count_average(self.average_horizontal_gap_sum)
45    }
46
47    pub fn average_vertical_gap(&self) -> f32 {
48        self.pct_count_average(self.average_vertical_gap_sum)
49    }
50}
51
52#[derive(Debug, Clone, PartialEq, Serialize)]
53pub struct BallCarryEvent {
54    pub player_id: PlayerId,
55    pub is_team_0: bool,
56    pub start_frame: usize,
57    pub end_frame: usize,
58    pub start_time: f32,
59    pub end_time: f32,
60    pub duration: f32,
61    pub straight_line_distance: f32,
62    pub path_distance: f32,
63    pub average_horizontal_gap: f32,
64    pub average_vertical_gap: f32,
65    pub average_speed: f32,
66}
67
68#[derive(Debug, Clone)]
69struct ActiveBallCarry {
70    player_id: PlayerId,
71    is_team_0: bool,
72    start_frame: usize,
73    last_frame: usize,
74    start_time: f32,
75    last_time: f32,
76    start_position: glam::Vec3,
77    last_position: glam::Vec3,
78    duration: f32,
79    path_distance: f32,
80    horizontal_gap_integral: f32,
81    vertical_gap_integral: f32,
82    speed_integral: f32,
83}
84
85#[derive(Debug, Clone, Copy)]
86struct BallCarryFrameSample {
87    player_position: glam::Vec3,
88    horizontal_gap: f32,
89    vertical_gap: f32,
90    speed: f32,
91}
92
93#[derive(Debug, Clone, Default)]
94pub struct BallCarryCalculator {
95    player_stats: HashMap<PlayerId, BallCarryStats>,
96    team_zero_stats: BallCarryStats,
97    team_one_stats: BallCarryStats,
98    carry_events: Vec<BallCarryEvent>,
99    active_carry: Option<ActiveBallCarry>,
100    last_touch_player: Option<PlayerId>,
101}
102
103impl BallCarryCalculator {
104    pub fn new() -> Self {
105        Self::default()
106    }
107
108    pub fn player_stats(&self) -> &HashMap<PlayerId, BallCarryStats> {
109        &self.player_stats
110    }
111
112    pub fn team_zero_stats(&self) -> &BallCarryStats {
113        &self.team_zero_stats
114    }
115
116    pub fn team_one_stats(&self) -> &BallCarryStats {
117        &self.team_one_stats
118    }
119
120    pub fn carry_events(&self) -> &[BallCarryEvent] {
121        &self.carry_events
122    }
123
124    fn carry_frame_sample(
125        player: &PlayerSample,
126        ball: &BallSample,
127    ) -> Option<BallCarryFrameSample> {
128        let player_position = player.position()?;
129        let ball_position = ball.position();
130        if !(BALL_CARRY_MIN_BALL_Z..=BALL_CARRY_MAX_BALL_Z).contains(&ball_position.z) {
131            return None;
132        }
133
134        let horizontal_gap = player_position
135            .truncate()
136            .distance(ball_position.truncate());
137        if horizontal_gap > BALL_CARRY_MAX_HORIZONTAL_GAP {
138            return None;
139        }
140
141        let vertical_gap = ball_position.z - player_position.z;
142        if !(0.0..=BALL_CARRY_MAX_VERTICAL_GAP).contains(&vertical_gap) {
143            return None;
144        }
145
146        Some(BallCarryFrameSample {
147            player_position,
148            horizontal_gap,
149            vertical_gap,
150            speed: player.speed().unwrap_or(0.0),
151        })
152    }
153
154    fn begin_carry(
155        &self,
156        frame: &FrameInfo,
157        player: &PlayerSample,
158        frame_sample: BallCarryFrameSample,
159    ) -> ActiveBallCarry {
160        let start_time = (frame.time - frame.dt).max(0.0);
161        let start_frame = frame.frame_number.saturating_sub(1);
162        ActiveBallCarry {
163            player_id: player.player_id.clone(),
164            is_team_0: player.is_team_0,
165            start_frame,
166            last_frame: frame.frame_number,
167            start_time,
168            last_time: frame.time,
169            start_position: frame_sample.player_position,
170            last_position: frame_sample.player_position,
171            duration: frame.dt,
172            path_distance: 0.0,
173            horizontal_gap_integral: frame_sample.horizontal_gap * frame.dt,
174            vertical_gap_integral: frame_sample.vertical_gap * frame.dt,
175            speed_integral: frame_sample.speed * frame.dt,
176        }
177    }
178
179    fn extend_carry(
180        active_carry: &mut ActiveBallCarry,
181        frame: &FrameInfo,
182        frame_sample: BallCarryFrameSample,
183    ) {
184        active_carry.duration += frame.dt;
185        active_carry.path_distance += frame_sample
186            .player_position
187            .distance(active_carry.last_position);
188        active_carry.last_position = frame_sample.player_position;
189        active_carry.last_time = frame.time;
190        active_carry.last_frame = frame.frame_number;
191        active_carry.horizontal_gap_integral += frame_sample.horizontal_gap * frame.dt;
192        active_carry.vertical_gap_integral += frame_sample.vertical_gap * frame.dt;
193        active_carry.speed_integral += frame_sample.speed * frame.dt;
194    }
195
196    fn finalize_active_carry(&mut self) {
197        let Some(active_carry) = self.active_carry.take() else {
198            return;
199        };
200        if active_carry.duration < BALL_CARRY_MIN_DURATION {
201            return;
202        }
203
204        let event = BallCarryEvent {
205            player_id: active_carry.player_id.clone(),
206            is_team_0: active_carry.is_team_0,
207            start_frame: active_carry.start_frame,
208            end_frame: active_carry.last_frame,
209            start_time: active_carry.start_time,
210            end_time: active_carry.last_time,
211            duration: active_carry.duration,
212            straight_line_distance: active_carry
213                .start_position
214                .truncate()
215                .distance(active_carry.last_position.truncate()),
216            path_distance: active_carry.path_distance,
217            average_horizontal_gap: active_carry.horizontal_gap_integral / active_carry.duration,
218            average_vertical_gap: active_carry.vertical_gap_integral / active_carry.duration,
219            average_speed: active_carry.speed_integral / active_carry.duration,
220        };
221        self.record_carry_event(event);
222    }
223
224    fn record_carry_event(&mut self, event: BallCarryEvent) {
225        let player_stats = self
226            .player_stats
227            .entry(event.player_id.clone())
228            .or_default();
229        Self::apply_carry_event(player_stats, &event);
230
231        let team_stats = if event.is_team_0 {
232            &mut self.team_zero_stats
233        } else {
234            &mut self.team_one_stats
235        };
236        Self::apply_carry_event(team_stats, &event);
237        self.carry_events.push(event);
238    }
239
240    fn apply_carry_event(stats: &mut BallCarryStats, event: &BallCarryEvent) {
241        stats.carry_count += 1;
242        stats.total_carry_time += event.duration;
243        stats.total_straight_line_distance += event.straight_line_distance;
244        stats.total_path_distance += event.path_distance;
245        stats.longest_carry_time = stats.longest_carry_time.max(event.duration);
246        stats.furthest_carry_distance = stats
247            .furthest_carry_distance
248            .max(event.straight_line_distance);
249        stats.fastest_carry_speed = stats.fastest_carry_speed.max(event.average_speed);
250        stats.carry_speed_sum += event.average_speed;
251        stats.average_horizontal_gap_sum += event.average_horizontal_gap;
252        stats.average_vertical_gap_sum += event.average_vertical_gap;
253    }
254
255    fn process_sample(
256        &mut self,
257        frame: &FrameInfo,
258        ball: &BallFrameState,
259        players: &PlayerFrameState,
260        live_play: bool,
261        controlling_player: Option<PlayerId>,
262    ) -> SubtrActorResult<()> {
263        let carry_candidate = if live_play && frame.dt > 0.0 {
264            if let (Some(ball), Some(player_id)) = (ball.sample(), controlling_player.as_ref()) {
265                players
266                    .players
267                    .iter()
268                    .find(|player| &player.player_id == player_id)
269                    .and_then(|player| {
270                        Self::carry_frame_sample(player, ball)
271                            .map(|frame_sample| (player, frame_sample))
272                    })
273            } else {
274                None
275            }
276        } else {
277            None
278        };
279
280        match (self.active_carry.as_mut(), carry_candidate) {
281            (Some(active_carry), Some((player, frame_sample)))
282                if active_carry.player_id == player.player_id =>
283            {
284                Self::extend_carry(active_carry, frame, frame_sample);
285            }
286            (Some(_), Some((player, frame_sample))) => {
287                self.finalize_active_carry();
288                self.active_carry = Some(self.begin_carry(frame, player, frame_sample));
289            }
290            (Some(_), None) => {
291                self.finalize_active_carry();
292            }
293            (None, Some((player, frame_sample))) => {
294                self.active_carry = Some(self.begin_carry(frame, player, frame_sample));
295            }
296            (None, None) => {}
297        }
298
299        if let Some(active_carry) = &self.active_carry {
300            if controlling_player.as_ref() != Some(&active_carry.player_id) {
301                self.finalize_active_carry();
302            }
303        }
304
305        self.last_touch_player = controlling_player;
306        Ok(())
307    }
308
309    pub fn update(
310        &mut self,
311        frame: &FrameInfo,
312        ball: &BallFrameState,
313        players: &PlayerFrameState,
314        touch_state: &TouchState,
315        live_play_state: &LivePlayState,
316    ) -> SubtrActorResult<()> {
317        self.process_sample(
318            frame,
319            ball,
320            players,
321            live_play_state.is_live_play,
322            touch_state.last_touch_player.clone(),
323        )
324    }
325    pub fn finish_calculation(&mut self) -> SubtrActorResult<()> {
326        self.finalize_active_carry();
327        Ok(())
328    }
329}
subtr_actor/stats/calculators/ball_carry.rs

subtr_actor/stats/calculators/
ball_carry.rs
