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
154
155
156
157
158
159

use super::*;

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, ts_rs::TS)]
#[ts(export)]
pub struct CenterPlayerStats {
    pub count: u32,
    pub total_ball_travel_distance: f32,
    pub total_ball_advance_distance: f32,
    pub total_lateral_centering_distance: f32,
    pub longest_center_distance: f32,
    pub is_last_center: bool,
    pub last_center_time: Option<f32>,
    pub last_center_frame: Option<usize>,
    pub time_since_last_center: Option<f32>,
    pub frames_since_last_center: Option<usize>,
}

impl CenterPlayerStats {
    pub fn average_ball_travel_distance(&self) -> f32 {
        if self.count == 0 {
            0.0
        } else {
            self.total_ball_travel_distance / self.count as f32
        }
    }

    pub fn average_ball_advance_distance(&self) -> f32 {
        if self.count == 0 {
            0.0
        } else {
            self.total_ball_advance_distance / self.count as f32
        }
    }

    pub fn average_lateral_centering_distance(&self) -> f32 {
        if self.count == 0 {
            0.0
        } else {
            self.total_lateral_centering_distance / self.count as f32
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, ts_rs::TS)]
#[ts(export)]
pub struct CenterTeamStats {
    pub count: u32,
    pub total_ball_travel_distance: f32,
    pub total_ball_advance_distance: f32,
    pub total_lateral_centering_distance: f32,
    pub longest_center_distance: f32,
}

impl CenterTeamStats {
    pub fn average_ball_travel_distance(&self) -> f32 {
        if self.count == 0 {
            0.0
        } else {
            self.total_ball_travel_distance / self.count as f32
        }
    }

    pub fn average_ball_advance_distance(&self) -> f32 {
        if self.count == 0 {
            0.0
        } else {
            self.total_ball_advance_distance / self.count as f32
        }
    }

    pub fn average_lateral_centering_distance(&self) -> f32 {
        if self.count == 0 {
            0.0
        } else {
            self.total_lateral_centering_distance / self.count as f32
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct CenterStatsAccumulator {
    player_stats: HashMap<PlayerId, CenterPlayerStats>,
    team_zero_stats: CenterTeamStats,
    team_one_stats: CenterTeamStats,
    current_last_center_player: Option<PlayerId>,
}

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

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

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

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

    pub fn begin_sample(&mut self, frame: &FrameInfo) {
        for stats in self.player_stats.values_mut() {
            stats.is_last_center = false;
            stats.time_since_last_center = stats
                .last_center_time
                .map(|time| (frame.time - time).max(0.0));
            stats.frames_since_last_center = stats
                .last_center_frame
                .map(|last_frame| frame.frame_number.saturating_sub(last_frame));
        }
    }

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

    pub fn apply_event(&mut self, frame: &FrameInfo, event: &CenterEvent) {
        let player_stats = self.player_stats.entry(event.player.clone()).or_default();
        player_stats.count += 1;
        player_stats.total_ball_travel_distance += event.ball_travel_distance;
        player_stats.total_ball_advance_distance += event.ball_advance_distance;
        player_stats.total_lateral_centering_distance += event.lateral_centering_distance;
        player_stats.longest_center_distance = player_stats
            .longest_center_distance
            .max(event.ball_travel_distance);
        player_stats.last_center_time = Some(event.time);
        player_stats.last_center_frame = Some(event.frame);
        player_stats.time_since_last_center = Some((frame.time - event.time).max(0.0));
        player_stats.frames_since_last_center =
            Some(frame.frame_number.saturating_sub(event.frame));

        let team_stats = if event.is_team_0 {
            &mut self.team_zero_stats
        } else {
            &mut self.team_one_stats
        };
        team_stats.count += 1;
        team_stats.total_ball_travel_distance += event.ball_travel_distance;
        team_stats.total_ball_advance_distance += event.ball_advance_distance;
        team_stats.total_lateral_centering_distance += event.lateral_centering_distance;
        team_stats.longest_center_distance = team_stats
            .longest_center_distance
            .max(event.ball_travel_distance);

        self.current_last_center_player = Some(event.player.clone());
    }

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