subtr-actor 0.8.2

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

use super::*;

pub(crate) fn rigid_body(position: glam::Vec3, velocity: glam::Vec3) -> boxcars::RigidBody {
    boxcars::RigidBody {
        sleeping: false,
        location: glam_to_vec(&position),
        rotation: boxcars::Quaternion {
            x: 0.0,
            y: 0.0,
            z: 0.0,
            w: 1.0,
        },
        linear_velocity: Some(glam_to_vec(&velocity)),
        angular_velocity: Some(glam_to_vec(&glam::Vec3::ZERO)),
    }
}

pub(crate) fn player(position: glam::Vec3, velocity: glam::Vec3) -> PlayerSample {
    PlayerSample {
        player_id: boxcars::RemoteId::Steam(1),
        is_team_0: true,
        rigid_body: Some(rigid_body(position, velocity)),
        boost_amount: None,
        last_boost_amount: None,
        boost_active: false,
        dodge_active: false,
        powerslide_active: false,
        match_goals: None,
        match_assists: None,
        match_saves: None,
        match_shots: None,
        match_score: None,
    }
}

pub(crate) fn ball(position: glam::Vec3, velocity: glam::Vec3) -> BallFrameState {
    BallFrameState::Present(BallSample {
        rigid_body: rigid_body(position, velocity),
    })
}

pub(crate) fn frame(frame_number: usize, time: f32) -> FrameInfo {
    FrameInfo {
        frame_number,
        time,
        dt: 0.2,
        seconds_remaining: None,
    }
}

pub(crate) fn touch_state() -> TouchState {
    TouchState {
        last_touch_player: Some(boxcars::RemoteId::Steam(1)),
        ..TouchState::default()
    }
}

pub(crate) fn touch_state_with_touch(frame: usize, time: f32) -> TouchState {
    let player_id = boxcars::RemoteId::Steam(1);
    TouchState {
        touch_events: vec![TouchEvent {
            time,
            frame,
            team_is_team_0: true,
            player: Some(player_id.clone()),
            closest_approach_distance: None,
        }],
        last_touch: Some(TouchEvent {
            time,
            frame,
            team_is_team_0: true,
            player: Some(player_id.clone()),
            closest_approach_distance: None,
        }),
        last_touch_player: Some(player_id),
        last_touch_team_is_team_0: Some(true),
    }
}

#[derive(Default)]
pub(crate) struct BallCarryHarness {
    tracker: ContinuousBallControlTracker<BallCarryKind>,
    state: ContinuousBallControlState,
    pub(crate) calculator: BallCarryCalculator,
}

impl BallCarryHarness {
    pub(crate) fn update(
        &mut self,
        frame: &FrameInfo,
        ball: &BallFrameState,
        players: &PlayerFrameState,
        touch_state: &TouchState,
        live_play_state: &LivePlayState,
    ) {
        let candidate = if frame.dt > 0.0 {
            BallCarryCalculator::control_candidate(
                ball,
                players,
                live_play_state.is_live_play,
                touch_state,
            )
        } else {
            None
        };

        let player_statuses = BallCarryCalculator::control_player_statuses(players);
        let touches = BallCarryCalculator::control_touches(touch_state, players);
        self.state.completed_sequences.extend(self.tracker.update(
            frame,
            candidate,
            &player_statuses,
            &touches,
            BallCarryCalculator::min_duration_for_kind,
            BallCarryCalculator::kind_requires_airborne,
        ));
        self.calculator.update(&self.state).unwrap();
    }

    pub(crate) fn finish(&mut self) {
        if let Some(sequence) = self
            .tracker
            .finish(BallCarryCalculator::min_duration_for_kind)
        {
            self.state.completed_sequences.push(sequence);
        }
        self.calculator.update(&self.state).unwrap();
    }
}