subtr_actor/stats/calculators/
touch_state.rs1use super::*;
2
3#[derive(Debug, Clone, Default)]
4pub struct TouchState {
5 pub touch_events: Vec<TouchEvent>,
6 pub last_touch: Option<TouchEvent>,
7 pub last_touch_player: Option<PlayerId>,
8 pub last_touch_team_is_team_0: Option<bool>,
9}
10
11#[derive(Default)]
12pub struct TouchStateCalculator {
13 previous_ball_linear_velocity: Option<glam::Vec3>,
14 previous_ball_angular_velocity: Option<glam::Vec3>,
15 current_last_touch: Option<TouchEvent>,
16 recent_touch_candidates: HashMap<PlayerId, TouchEvent>,
17}
18
19impl TouchStateCalculator {
20 pub fn new() -> Self {
21 Self::default()
22 }
23
24 fn prune_recent_touch_candidates(&mut self, current_frame: usize) {
25 const TOUCH_CANDIDATE_WINDOW_FRAMES: usize = 4;
26
27 self.recent_touch_candidates.retain(|_, candidate| {
28 current_frame.saturating_sub(candidate.frame) <= TOUCH_CANDIDATE_WINDOW_FRAMES
29 });
30 }
31
32 fn current_ball_angular_velocity(ball: &BallFrameState) -> Option<glam::Vec3> {
33 ball.sample()
34 .map(|ball| {
35 ball.rigid_body
36 .angular_velocity
37 .unwrap_or(boxcars::Vector3f {
38 x: 0.0,
39 y: 0.0,
40 z: 0.0,
41 })
42 })
43 .map(|velocity| vec_to_glam(&velocity))
44 }
45
46 fn current_ball_linear_velocity(ball: &BallFrameState) -> Option<glam::Vec3> {
47 ball.velocity()
48 }
49
50 fn is_touch_candidate(&self, frame: &FrameInfo, ball: &BallFrameState) -> bool {
51 const BALL_GRAVITY_Z: f32 = -650.0;
52 const TOUCH_LINEAR_IMPULSE_THRESHOLD: f32 = 120.0;
53 const TOUCH_ANGULAR_VELOCITY_DELTA_THRESHOLD: f32 = 0.5;
54
55 let Some(current_linear_velocity) = Self::current_ball_linear_velocity(ball) else {
56 return false;
57 };
58 let Some(previous_linear_velocity) = self.previous_ball_linear_velocity else {
59 return false;
60 };
61 let Some(current_angular_velocity) = Self::current_ball_angular_velocity(ball) else {
62 return false;
63 };
64 let Some(previous_angular_velocity) = self.previous_ball_angular_velocity else {
65 return false;
66 };
67
68 let expected_linear_delta = glam::Vec3::new(0.0, 0.0, BALL_GRAVITY_Z * frame.dt.max(0.0));
69 let residual_linear_impulse =
70 current_linear_velocity - previous_linear_velocity - expected_linear_delta;
71 let angular_velocity_delta = current_angular_velocity - previous_angular_velocity;
72
73 residual_linear_impulse.length() > TOUCH_LINEAR_IMPULSE_THRESHOLD
74 || angular_velocity_delta.length() > TOUCH_ANGULAR_VELOCITY_DELTA_THRESHOLD
75 }
76
77 fn proximity_touch_candidates(
78 &self,
79 frame: &FrameInfo,
80 ball: &BallFrameState,
81 players: &PlayerFrameState,
82 max_collision_distance: f32,
83 ) -> Vec<TouchEvent> {
84 const OCTANE_HITBOX_LENGTH: f32 = 118.01;
85 const OCTANE_HITBOX_WIDTH: f32 = 84.2;
86 const OCTANE_HITBOX_HEIGHT: f32 = 36.16;
87 const OCTANE_HITBOX_OFFSET: f32 = 13.88;
88 const OCTANE_HITBOX_ELEVATION: f32 = 17.05;
89
90 let Some(ball) = ball.sample() else {
91 return Vec::new();
92 };
93 let ball_position = vec_to_glam(&ball.rigid_body.location);
94
95 let mut candidates = players
96 .players
97 .iter()
98 .filter_map(|player| {
99 let rigid_body = player.rigid_body.as_ref()?;
100 let player_position = vec_to_glam(&rigid_body.location);
101 let local_ball_position = quat_to_glam(&rigid_body.rotation).inverse()
102 * (ball_position - player_position);
103
104 let x_distance = if local_ball_position.x
105 < -OCTANE_HITBOX_LENGTH / 2.0 + OCTANE_HITBOX_OFFSET
106 {
107 (-OCTANE_HITBOX_LENGTH / 2.0 + OCTANE_HITBOX_OFFSET) - local_ball_position.x
108 } else if local_ball_position.x > OCTANE_HITBOX_LENGTH / 2.0 + OCTANE_HITBOX_OFFSET
109 {
110 local_ball_position.x - (OCTANE_HITBOX_LENGTH / 2.0 + OCTANE_HITBOX_OFFSET)
111 } else {
112 0.0
113 };
114 let y_distance = if local_ball_position.y < -OCTANE_HITBOX_WIDTH / 2.0 {
115 (-OCTANE_HITBOX_WIDTH / 2.0) - local_ball_position.y
116 } else if local_ball_position.y > OCTANE_HITBOX_WIDTH / 2.0 {
117 local_ball_position.y - OCTANE_HITBOX_WIDTH / 2.0
118 } else {
119 0.0
120 };
121 let z_distance = if local_ball_position.z
122 < -OCTANE_HITBOX_HEIGHT / 2.0 + OCTANE_HITBOX_ELEVATION
123 {
124 (-OCTANE_HITBOX_HEIGHT / 2.0 + OCTANE_HITBOX_ELEVATION) - local_ball_position.z
125 } else if local_ball_position.z
126 > OCTANE_HITBOX_HEIGHT / 2.0 + OCTANE_HITBOX_ELEVATION
127 {
128 local_ball_position.z - (OCTANE_HITBOX_HEIGHT / 2.0 + OCTANE_HITBOX_ELEVATION)
129 } else {
130 0.0
131 };
132
133 let collision_distance =
134 glam::Vec3::new(x_distance, y_distance, z_distance).length();
135 if collision_distance > max_collision_distance {
136 return None;
137 }
138
139 Some(TouchEvent {
140 time: frame.time,
141 frame: frame.frame_number,
142 team_is_team_0: player.is_team_0,
143 player: Some(player.player_id.clone()),
144 closest_approach_distance: Some(collision_distance),
145 })
146 })
147 .collect::<Vec<_>>();
148
149 candidates.sort_by(|left, right| {
150 let left_distance = left.closest_approach_distance.unwrap_or(f32::INFINITY);
151 let right_distance = right.closest_approach_distance.unwrap_or(f32::INFINITY);
152 left_distance.total_cmp(&right_distance)
153 });
154 candidates
155 }
156
157 fn candidate_touch_event(
158 &self,
159 frame: &FrameInfo,
160 ball: &BallFrameState,
161 players: &PlayerFrameState,
162 ) -> Option<TouchEvent> {
163 const TOUCH_COLLISION_DISTANCE_THRESHOLD: f32 = 300.0;
164
165 self.proximity_touch_candidates(frame, ball, players, TOUCH_COLLISION_DISTANCE_THRESHOLD)
166 .into_iter()
167 .next()
168 }
169
170 fn update_recent_touch_candidates(
171 &mut self,
172 frame: &FrameInfo,
173 ball: &BallFrameState,
174 players: &PlayerFrameState,
175 ) {
176 const PROXIMITY_CANDIDATE_DISTANCE_THRESHOLD: f32 = 220.0;
177
178 for candidate in self.proximity_touch_candidates(
179 frame,
180 ball,
181 players,
182 PROXIMITY_CANDIDATE_DISTANCE_THRESHOLD,
183 ) {
184 let Some(player_id) = candidate.player.clone() else {
185 continue;
186 };
187
188 self.recent_touch_candidates.insert(player_id, candidate);
189 }
190 }
191
192 fn candidate_for_player(&self, player_id: &PlayerId) -> Option<TouchEvent> {
193 self.recent_touch_candidates.get(player_id).cloned()
194 }
195
196 fn contested_touch_candidates(&self, primary: &TouchEvent) -> Vec<TouchEvent> {
197 const CONTESTED_TOUCH_DISTANCE_MARGIN: f32 = 80.0;
198
199 let primary_distance = primary.closest_approach_distance.unwrap_or(f32::INFINITY);
200
201 let best_opposing_candidate = self
202 .recent_touch_candidates
203 .values()
204 .filter(|candidate| candidate.team_is_team_0 != primary.team_is_team_0)
205 .filter(|candidate| {
206 candidate.closest_approach_distance.unwrap_or(f32::INFINITY)
207 <= primary_distance + CONTESTED_TOUCH_DISTANCE_MARGIN
208 })
209 .min_by(|left, right| {
210 let left_distance = left.closest_approach_distance.unwrap_or(f32::INFINITY);
211 let right_distance = right.closest_approach_distance.unwrap_or(f32::INFINITY);
212 left_distance.total_cmp(&right_distance)
213 })
214 .cloned();
215
216 best_opposing_candidate.into_iter().collect()
217 }
218
219 fn confirmed_touch_events(
220 &self,
221 frame: &FrameInfo,
222 ball: &BallFrameState,
223 players: &PlayerFrameState,
224 events: &FrameEventsState,
225 ) -> Vec<TouchEvent> {
226 let mut touch_events = Vec::new();
227 let mut confirmed_players = HashSet::new();
228
229 if self.is_touch_candidate(frame, ball) {
230 if let Some(candidate) = self.candidate_touch_event(frame, ball, players) {
231 for contested_candidate in self.contested_touch_candidates(&candidate) {
232 if let Some(player_id) = contested_candidate.player.clone() {
233 confirmed_players.insert(player_id);
234 }
235 touch_events.push(contested_candidate);
236 }
237 if let Some(player_id) = candidate.player.clone() {
238 confirmed_players.insert(player_id);
239 }
240 touch_events.push(candidate);
241 }
242 }
243
244 for dodge_refresh in &events.dodge_refreshed_events {
245 if !confirmed_players.insert(dodge_refresh.player.clone()) {
246 continue;
247 }
248 let Some(candidate) = self.candidate_for_player(&dodge_refresh.player) else {
249 continue;
250 };
251 touch_events.push(candidate);
252 }
253
254 touch_events
255 }
256
257 pub fn update(
258 &mut self,
259 frame: &FrameInfo,
260 ball: &BallFrameState,
261 players: &PlayerFrameState,
262 events: &FrameEventsState,
263 live_play_state: &LivePlayState,
264 ) -> TouchState {
265 let touch_events = if live_play_state.is_live_play {
266 self.prune_recent_touch_candidates(frame.frame_number);
267 self.update_recent_touch_candidates(frame, ball, players);
268 self.confirmed_touch_events(frame, ball, players, events)
269 } else {
270 self.current_last_touch = None;
271 self.recent_touch_candidates.clear();
272 Vec::new()
273 };
274
275 if let Some(last_touch) = touch_events.last() {
276 self.current_last_touch = Some(last_touch.clone());
277 }
278 self.previous_ball_linear_velocity = Self::current_ball_linear_velocity(ball);
279 self.previous_ball_angular_velocity = Self::current_ball_angular_velocity(ball);
280
281 TouchState {
282 touch_events,
283 last_touch: self.current_last_touch.clone(),
284 last_touch_player: self
285 .current_last_touch
286 .as_ref()
287 .and_then(|touch| touch.player.clone()),
288 last_touch_team_is_team_0: self
289 .current_last_touch
290 .as_ref()
291 .map(|touch| touch.team_is_team_0),
292 }
293 }
294}
295
296#[cfg(test)]
297#[path = "touch_state_tests.rs"]
298mod tests;