caper 0.13.0

Minimalist game framework
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
130
131
132
133

/// enum to return the informaiton on a collision test
#[derive(PartialEq)]
pub enum CollisionInfo {
    /// Represents the distance of separation in 3d space
    Separate3D {
        /// The overlapping distance at the front of the objects (slightly confusing used for parity
        /// with Separate 2D)
        top: f32,
        /// The overlapping distance at the back of the objects (slightly confusing used for parity
        /// with Separate 2D)
        bottom: f32,
        /// The overlapping distance at the right of the objects
        right: f32,
        /// The overlapping distance at the left of the objects
        left: f32,
        /// The overlapping distance above the objects
        up: f32,
        /// The overlapping distance below the objects
        down: f32,
    },
    /// Represents the distance of separation in 2d space
    Separate2D {
        /// The overlapping distance at the top of the objects
        top: f32,
        /// The overlapping distance at the bottom of the objects
        bottom: f32,
        /// The overlapping distance at the left of the objects
        right: f32,
        /// The overlapping distance at the right of the objects
        left: f32,
    },
    /// Used for if two objects are overlapping each other
    Overlapping,
    /// When no collision has taken place
    NoCollision,
}

/// returns true if the given squares with width are overlapping
pub fn overlapping(
    pos_a: &(f32, f32),
    size_a: &(f32, f32),
    pos_b: &(f32, f32),
    size_b: &(f32, f32),
    separate: bool,
) -> CollisionInfo {
    let (left_a, left_b) = (pos_a.0, pos_b.0);
    let (right_a, right_b) = (pos_a.0 + size_a.0, pos_b.0 + size_b.0);
    let (top_a, top_b) = (pos_a.1, pos_b.1);
    let (bottom_a, bottom_b) = (pos_a.1 + size_a.1, pos_b.1 + size_b.1);

    if bottom_a <= top_b {
        return CollisionInfo::NoCollision;
    }
    if top_a >= bottom_b {
        return CollisionInfo::NoCollision;
    }
    if right_a <= left_b {
        return CollisionInfo::NoCollision;
    }
    if left_a >= right_b {
        return CollisionInfo::NoCollision;
    }

    if separate {
        let bottom_diff = (bottom_a - top_b).abs();
        let top_diff = (top_a - bottom_b).abs();
        let right_diff = (right_a - left_b).abs();
        let left_diff = (left_a - right_b).abs();

        return CollisionInfo::Separate2D {
            top: top_diff,
            bottom: bottom_diff,
            right: right_diff,
            left: left_diff,
        };
    }

    CollisionInfo::Overlapping
}

/// returns true if the given cubes with size overlap
pub fn overlapping_3d(
    pos_a: &(f32, f32, f32),
    size_a: &(f32, f32, f32),
    pos_b: &(f32, f32, f32),
    size_b: &(f32, f32, f32),
    separate: bool,
) -> CollisionInfo {
    // check collision in 2d
    let check_2d = overlapping(
        &(pos_a.0, pos_a.2),
        &(size_a.0, size_a.2),
        &(pos_b.0, pos_b.2),
        &(size_b.0, size_b.2),
        separate,
    );
    // return if there is no collision in 2d
    if let CollisionInfo::NoCollision = check_2d {
        return check_2d;
    }

    let (up_a, up_b) = (pos_a.1, pos_b.1);
    let (down_a, down_b) = (pos_a.1 + size_a.1, pos_b.1 + size_b.1);

    if down_a <= up_b {
        return CollisionInfo::NoCollision;
    }
    if up_a >= down_b {
        return CollisionInfo::NoCollision;
    }

    if let CollisionInfo::Separate2D {
        top: t,
        bottom: b,
        right: r,
        left: l,
    } = check_2d
    {
        let up_diff = (up_a - down_b).abs();
        let down_diff = (down_a - up_b).abs();

        return CollisionInfo::Separate3D {
            top: t,
            bottom: b,
            right: r,
            left: l,
            up: up_diff,
            down: down_diff,
        };
    }

    CollisionInfo::Overlapping
}