rocketsim 0.2.0

Simulate Rocket League games at maximum efficiency
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

use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor};

use crate::shared::Aabb;

pub enum CollisionFilterGroups {
    Default = 1,
    Static = (1 << 1),
    HoopsNet = (1 << 2),
    DropshotTile = (1 << 3),
    DropshotFloor = (1 << 4),
}

impl CollisionFilterGroups {
    pub const ALL: u8 = Self::Default as u8
        | Self::Static as u8
        | Self::HoopsNet as u8
        | Self::DropshotTile as u8
        | Self::DropshotFloor as u8;
}

impl BitOrAssign<CollisionFilterGroups> for u8 {
    fn bitor_assign(&mut self, rhs: CollisionFilterGroups) {
        *self |= rhs as u8;
    }
}

impl BitAndAssign<CollisionFilterGroups> for u8 {
    fn bitand_assign(&mut self, rhs: CollisionFilterGroups) {
        *self &= rhs as u8;
    }
}

impl BitAnd<CollisionFilterGroups> for u8 {
    type Output = u8;

    fn bitand(self, rhs: CollisionFilterGroups) -> Self::Output {
        self & (rhs as u8)
    }
}

impl BitOr<CollisionFilterGroups> for u8 {
    type Output = u8;

    fn bitor(self, rhs: CollisionFilterGroups) -> Self::Output {
        self | (rhs as u8)
    }
}

impl BitXor<CollisionFilterGroups> for u8 {
    type Output = u8;

    fn bitxor(self, rhs: CollisionFilterGroups) -> Self::Output {
        self ^ (rhs as u8)
    }
}

impl BitXor for CollisionFilterGroups {
    type Output = u8;

    fn bitxor(self, rhs: Self) -> Self::Output {
        self as u8 ^ rhs as u8
    }
}

impl BitOr for CollisionFilterGroups {
    type Output = u8;

    fn bitor(self, rhs: Self) -> Self::Output {
        self as u8 | rhs as u8
    }
}

pub struct BroadphaseProxy {
    /// The index of the client `RigidBody` in `CollisionWorld`
    pub client_obj_idx: u32,
    pub collision_filter_group: u8,
    pub collision_filter_mask: u8,
    pub unique_id: u32,
    pub aabb: Aabb,
    pub cell_idx: u32,
    pub indices: [u32; 3],
}

pub struct BroadphasePair {
    pub proxy0: usize,
    pub proxy1: usize,
}

pub trait BroadphaseAabbCallback {
    fn process(&mut self, proxy: &BroadphaseProxy) -> bool;
}