motion 0.1.6

A bare metal physics engine.
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 crate::obj::obj_2d::Object2d;
pub mod shape;
use shape::Shape;

/// Represents a 2D collision detection between two objects.
pub struct Collision2d {
    /// The first object involved in the collision.
    pub obj1: Object2d,
    /// The second object involved in the collision.
    pub obj2: Object2d,
}

impl Collision2d {
    /// Creates a new `Collision2d` instance with the specified objects.
    ///
    /// # Parameters
    ///
    /// - `obj1`: The first object involved in the collision.
    /// - `obj2`: The second object involved in the collision.
    ///
    /// # Returns
    ///
    /// A new `Collision2d` instance.
    ///
    /// # Examples
    ///
    /// ```
    /// let obj1 = Object2d::new(/* parameters */);
    /// let obj2 = Object2d::new(/* parameters */);
    /// let collision = Collision2d::new(obj1, obj2);
    /// ```
    #[must_use]
    pub fn new(obj1: Object2d, obj2: Object2d) -> Self {
        Self { obj1, obj2 }
    }

    /// Detects if a collision occurs between the two objects.
    ///
    /// # Returns
    ///
    /// `true` if a collision is detected, `false` otherwise.
    ///
    /// # Examples
    ///
    /// ```
    /// let obj1 = Object2d::new(/* parameters */);
    /// let obj2 = Object2d::new(/* parameters */);
    /// let collision = Collision2d::new(obj1, obj2);
    /// if collision.collider() {
    ///     println!("Collision detected!");
    /// }
    /// ```
    #[must_use]
    pub fn collider(&self) -> bool {
        match (&self.obj1.shape, &self.obj2.shape) {
            (Shape::Circle, Shape::Circle) => self.circle_collision(),
            (Shape::AABB(_, _), Shape::AABB(_, _)) => self.aabb_collision(),
            _ => false,
        }
    }

    /// Detects if a collision occurs between two circular shapes.
    ///
    /// # Returns
    ///
    /// `true` if a collision is detected, `false` otherwise.
    ///
    /// # Panics
    ///
    /// Panics if either shape is not a circle.
    fn circle_collision(&self) -> bool {
        if self.obj2.shape != Shape::Circle || self.obj1.shape != Shape::Circle {
            return false;
        }
        let distance = self.obj1.vec.distance(self.obj2.vec);
        let radius1 = self.obj1.radius;
        let radius2 = self.obj2.radius;
        distance <= (radius1 + radius2)
    }

    /// Detects if a collision occurs between two axis-aligned bounding boxes (AABBs).
    ///
    /// # Returns
    ///
    /// `true` if a collision is detected, `false` otherwise.
    fn aabb_collision(&self) -> bool {
        let vec1 = self.obj1.shape.get_aabb();
        let vec2 = self.obj2.shape.get_aabb();
        vec1.0.x < vec2.1.x && vec1.1.x > vec2.0.x && vec1.0.y < vec2.1.y && vec1.1.y > vec2.0.y
    }
}