subtr-actor 1.0.0

Rocket League replay transformer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use super::*;

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, ts_rs::TS)]
#[ts(export)]
pub struct PassPlayerStats {
    pub completed_pass_count: u32,
    pub received_pass_count: u32,
    pub total_pass_distance: f32,
    pub total_pass_advance: f32,
    pub longest_pass_distance: f32,
    pub is_last_completed_pass: bool,
    pub last_completed_pass_time: Option<f32>,
    pub last_completed_pass_frame: Option<usize>,
    pub time_since_last_completed_pass: Option<f32>,
    pub frames_since_last_completed_pass: Option<usize>,
}

impl PassPlayerStats {
    pub fn average_pass_distance(&self) -> f32 {
        if self.completed_pass_count == 0 {
            0.0
        } else {
            self.total_pass_distance / self.completed_pass_count as f32
        }
    }

    pub fn average_pass_advance(&self) -> f32 {
        if self.completed_pass_count == 0 {
            0.0
        } else {
            self.total_pass_advance / self.completed_pass_count as f32
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, ts_rs::TS)]
#[ts(export)]
pub struct PassTeamStats {
    pub completed_pass_count: u32,
    pub total_pass_distance: f32,
    pub total_pass_advance: f32,
    pub longest_pass_distance: f32,
}

impl PassTeamStats {
    pub fn average_pass_distance(&self) -> f32 {
        if self.completed_pass_count == 0 {
            0.0
        } else {
            self.total_pass_distance / self.completed_pass_count as f32
        }
    }

    pub fn average_pass_advance(&self) -> f32 {
        if self.completed_pass_count == 0 {
            0.0
        } else {
            self.total_pass_advance / self.completed_pass_count as f32
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct PassStatsAccumulator {
    player_stats: HashMap<PlayerId, PassPlayerStats>,
    team_zero_stats: PassTeamStats,
    team_one_stats: PassTeamStats,
    current_last_completed_pass_player: Option<PlayerId>,
}

impl PassStatsAccumulator {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn player_stats(&self) -> &HashMap<PlayerId, PassPlayerStats> {
        &self.player_stats
    }

    pub fn team_zero_stats(&self) -> &PassTeamStats {
        &self.team_zero_stats
    }

    pub fn team_one_stats(&self) -> &PassTeamStats {
        &self.team_one_stats
    }

    pub fn current_last_completed_pass_player(&self) -> Option<&PlayerId> {
        self.current_last_completed_pass_player.as_ref()
    }

    pub fn begin_sample(&mut self, frame: &FrameInfo) {
        for stats in self.player_stats.values_mut() {
            stats.is_last_completed_pass = false;
            stats.time_since_last_completed_pass = stats
                .last_completed_pass_time
                .map(|time| (frame.time - time).max(0.0));
            stats.frames_since_last_completed_pass = stats
                .last_completed_pass_frame
                .map(|last_frame| frame.frame_number.saturating_sub(last_frame));
        }
    }

    pub fn clear_current_last(&mut self) {
        self.current_last_completed_pass_player = None;
    }

    pub fn set_current_last_completed_pass_player(&mut self, player: Option<PlayerId>) {
        self.current_last_completed_pass_player = player;
    }

    pub fn apply_event(&mut self, frame: &FrameInfo, event: &PassEvent) {
        let passer_stats = self.player_stats.entry(event.passer.clone()).or_default();
        passer_stats.completed_pass_count += 1;
        passer_stats.total_pass_distance += event.ball_travel_distance;
        passer_stats.total_pass_advance += event.ball_advance_distance;
        passer_stats.longest_pass_distance = passer_stats
            .longest_pass_distance
            .max(event.ball_travel_distance);
        passer_stats.last_completed_pass_time = Some(event.time);
        passer_stats.last_completed_pass_frame = Some(event.frame);
        passer_stats.time_since_last_completed_pass = Some((frame.time - event.time).max(0.0));
        passer_stats.frames_since_last_completed_pass =
            Some(frame.frame_number.saturating_sub(event.frame));

        self.player_stats
            .entry(event.receiver.clone())
            .or_default()
            .received_pass_count += 1;

        let team_stats = if event.is_team_0 {
            &mut self.team_zero_stats
        } else {
            &mut self.team_one_stats
        };
        team_stats.completed_pass_count += 1;
        team_stats.total_pass_distance += event.ball_travel_distance;
        team_stats.total_pass_advance += event.ball_advance_distance;
        team_stats.longest_pass_distance = team_stats
            .longest_pass_distance
            .max(event.ball_travel_distance);

        self.current_last_completed_pass_player = Some(event.passer.clone());
    }

    pub fn finish_sample(&mut self) {
        if let Some(player_id) = self.current_last_completed_pass_player.as_ref() {
            if let Some(stats) = self.player_stats.get_mut(player_id) {
                stats.is_last_completed_pass = true;
            }
        }
    }
}