subtr-actor 0.5.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

use crate::stats::analysis_graph::{self, AnalysisNodeCollector};
use crate::*;

pub struct ResolvedBoostPadCollector {
    collector: AnalysisNodeCollector,
}

impl Default for ResolvedBoostPadCollector {
    fn default() -> Self {
        Self::new()
    }
}

impl ResolvedBoostPadCollector {
    pub fn new() -> Self {
        let graph = analysis_graph::graph_with_builtin_analysis_nodes(["boost"])
            .expect("builtin boost analysis graph should be valid");
        Self {
            collector: AnalysisNodeCollector::new(graph),
        }
    }

    pub fn resolved_boost_pads(&self) -> Vec<ResolvedBoostPad> {
        self.collector
            .graph()
            .state::<BoostCalculator>()
            .map(BoostCalculator::resolved_boost_pads)
            .unwrap_or_default()
    }

    pub fn into_resolved_boost_pads(self) -> Vec<ResolvedBoostPad> {
        let graph = self.collector.into_graph();
        graph
            .state::<BoostCalculator>()
            .map(BoostCalculator::resolved_boost_pads)
            .unwrap_or_default()
    }
}

impl Collector for ResolvedBoostPadCollector {
    fn process_frame(
        &mut self,
        processor: &ReplayProcessor,
        frame: &boxcars::Frame,
        frame_number: usize,
        current_time: f32,
    ) -> SubtrActorResult<TimeAdvance> {
        self.collector
            .process_frame(processor, frame, frame_number, current_time)
    }

    fn finish_replay(&mut self, processor: &ReplayProcessor) -> SubtrActorResult<()> {
        self.collector.finish_replay(processor)
    }
}