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

use super::*;

fn assert_stats_event<T: StatsEvent>() {}

#[test]
fn current_event_payloads_implement_stats_event() {
    assert_stats_event::<TimelineEvent>();
    assert_stats_event::<CorePlayerScoreboardEvent>();
    assert_stats_event::<BackboardBounceEvent>();
    assert_stats_event::<CeilingShotEvent>();
    assert_stats_event::<WallAerialEvent>();
    assert_stats_event::<WallAerialShotEvent>();
    assert_stats_event::<CenterEvent>();
    assert_stats_event::<FlickEvent>();
    assert_stats_event::<DodgeResetEvent>();
    assert_stats_event::<DoubleTapEvent>();
    assert_stats_event::<OneTimerEvent>();
    assert_stats_event::<PassEvent>();
    assert_stats_event::<BallCarryEvent>();
    assert_stats_event::<FiftyFiftyEvent>();
    assert_stats_event::<RushEvent>();
    assert_stats_event::<SpeedFlipEvent>();
    assert_stats_event::<HalfFlipEvent>();
    assert_stats_event::<HalfVolleyEvent>();
    assert_stats_event::<WavedashEvent>();
    assert_stats_event::<WhiffEvent>();
    assert_stats_event::<PowerslideEvent>();
    assert_stats_event::<TouchClassificationEvent>();
    assert_stats_event::<BoostPickupEvent>();
    assert_stats_event::<RespawnEvent>();
    assert_stats_event::<BumpEvent>();
    assert_stats_event::<PossessionEvent>();
    assert_stats_event::<BallHalfEvent>();
    assert_stats_event::<BallThirdEvent>();
    assert_stats_event::<TerritorialPressureEvent>();
    assert_stats_event::<MovementEvent>();
    assert_stats_event::<PlayerActivityEvent>();
    assert_stats_event::<FieldThirdEvent>();
    assert_stats_event::<FieldHalfEvent>();
    assert_stats_event::<BallDepthEvent>();
    assert_stats_event::<DepthRoleEvent>();
    assert_stats_event::<BallProximityEvent>();
    assert_stats_event::<RotationRoleEvent>();
    assert_stats_event::<FirstManChangeEvent>();
    assert_stats_event::<FlipResetEvent>();
    assert_stats_event::<Event>();
}

#[test]
fn event_definitions_start_unknown_and_no_evidence() {
    for definition in all_event_definitions() {
        assert_eq!(
            definition.confidence, UNKNOWN_DETECTION_CONFIDENCE,
            "{} should start with unknown confidence metadata",
            definition.id
        );
        assert!(definition.limitations.is_empty());
    }
}

#[test]
fn mechanic_event_definitions_have_documented_approaches() {
    for definition in all_event_definitions() {
        if definition.category != EventCategory::Mechanic {
            continue;
        }

        assert_ne!(
            definition.summary, "Definition pending.",
            "{} should describe what the mechanic event means",
            definition.id
        );
        assert!(
            !definition.approach.is_empty(),
            "{} should describe how the mechanic event is detected",
            definition.id
        );
    }
}

#[test]
fn basic_event_definitions_cover_foundational_interactions() {
    for definition in [
        DODGE_RESET_EVENT_DEFINITION,
        DODGE_EVENT_DEFINITION,
        POWERSLIDE_EVENT_DEFINITION,
        TOUCH_CLASSIFICATION_EVENT_DEFINITION,
        DEMOLITION_EVENT_DEFINITION,
    ] {
        assert_eq!(
            definition.category,
            EventCategory::Basic,
            "{}",
            definition.id
        );
    }
}

#[test]
fn event_definition_ids_are_unique() {
    // Iterate the raw distributed slice (not the de-duplicated accessor) so an
    // accidental double registration of the same id fails loudly here.
    let mut ids = std::collections::BTreeSet::new();
    for definition in EVENT_DEFINITIONS {
        assert!(
            ids.insert(definition.id),
            "duplicate event definition id {}",
            definition.id
        );
    }
}

#[test]
fn expansion_parents_are_hidden_from_review() {
    // A parent that declares variants surfaces those instead of itself, so it
    // must be hidden or the raw parent key leaks into the review picker.
    for definition in all_event_definitions() {
        if !definition.variants.is_empty() {
            assert!(
                definition.hidden_from_review,
                "{} declares variants but is not hidden_from_review",
                definition.id
            );
        }
    }
}