refactor collide code (Adopted) (#11106)

# Objective

- Refactor collide code and add tests.

## Solution

- Rebase the changes made in #4485.

Co-authored-by: Eduardo Canellas de Oliveira <eduardo.canellas@bemobi.com>
This commit is contained in:
Tygyh 2024-01-01 17:57:27 +01:00 committed by GitHub
parent 8baefa1570
commit 55c9958dd0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23

View file

@ -12,8 +12,29 @@ pub enum Collision {
Inside,
}
struct CollisionBox {
pub top: f32,
pub bottom: f32,
pub left: f32,
pub right: f32,
}
impl CollisionBox {
pub fn new(pos: Vec3, size: Vec2) -> Self {
Self {
top: pos.y + size.y / 2.,
bottom: pos.y - size.y / 2.,
left: pos.x - size.x / 2.,
right: pos.x + size.x / 2.,
}
}
}
// TODO: ideally we can remove this once bevy gets a physics system
/// Axis-aligned bounding box collision with "side" detection
/// Axis-aligned bounding box collision with "side" detection.
///
/// The [Collision], in case it occurred, is the side of `b` where `a` hit.
///
/// * `a_pos` and `b_pos` are the center positions of the rectangles, typically obtained by
/// extracting the `translation` field from a [`Transform`](bevy_transform::components::Transform) component
/// * `a_size` and `b_size` are the dimensions (width and height) of the rectangles.
@ -23,30 +44,25 @@ pub enum Collision {
/// If the collision occurs on multiple sides, the side with the shallowest penetration is returned.
/// If all sides are involved, [`Collision::Inside`] is returned.
pub fn collide(a_pos: Vec3, a_size: Vec2, b_pos: Vec3, b_size: Vec2) -> Option<Collision> {
let a_min = a_pos.truncate() - a_size / 2.0;
let a_max = a_pos.truncate() + a_size / 2.0;
let b_min = b_pos.truncate() - b_size / 2.0;
let b_max = b_pos.truncate() + b_size / 2.0;
let a = CollisionBox::new(a_pos, a_size);
let b = CollisionBox::new(b_pos, b_size);
// check to see if the two rectangles are intersecting
if a_min.x < b_max.x && a_max.x > b_min.x && a_min.y < b_max.y && a_max.y > b_min.y {
if a.left < b.right && a.right > b.left && a.bottom < b.top && a.top > b.bottom {
// check to see if we hit on the left or right side
let (x_collision, x_depth) = if a_min.x < b_min.x && a_max.x > b_min.x && a_max.x < b_max.x
{
(Collision::Left, b_min.x - a_max.x)
} else if a_min.x > b_min.x && a_min.x < b_max.x && a_max.x > b_max.x {
(Collision::Right, a_min.x - b_max.x)
let (x_collision, x_depth) = if a.left < b.left && a.right > b.left && a.right < b.right {
(Collision::Left, b.left - a.right)
} else if a.left > b.left && a.left < b.right && a.right > b.right {
(Collision::Right, a.left - b.right)
} else {
(Collision::Inside, -f32::INFINITY)
};
// check to see if we hit on the top or bottom side
let (y_collision, y_depth) = if a_min.y < b_min.y && a_max.y > b_min.y && a_max.y < b_max.y
{
(Collision::Bottom, b_min.y - a_max.y)
} else if a_min.y > b_min.y && a_min.y < b_max.y && a_max.y > b_max.y {
(Collision::Top, a_min.y - b_max.y)
let (y_collision, y_depth) = if a.bottom < b.bottom && a.top > b.bottom && a.top < b.top {
(Collision::Bottom, b.bottom - a.top)
} else if a.bottom > b.bottom && a.bottom < b.top && a.top > b.top {
(Collision::Top, a.bottom - b.top)
} else {
(Collision::Inside, -f32::INFINITY)
};
@ -63,9 +79,98 @@ pub fn collide(a_pos: Vec3, a_size: Vec2, b_pos: Vec3, b_size: Vec2) -> Option<C
}
#[cfg(test)]
mod test {
mod tests {
use super::*;
///
///
/// ______
/// | |
/// | A |
/// ----|----|----
/// | |____| |
/// | B |
/// |____________|
///
#[test]
fn top_collision() {
let a = Vec3::new(0., 30., 0.);
let b = Vec3::new(0., 0., 0.);
check(a, b, Some(Collision::Top));
}
///
///
/// --------------
/// | B |
/// | _____ |
/// |___|____|___|
/// | |
/// | A |
/// | |
/// -----
#[test]
fn bottom_collision() {
let a = Vec3::new(0., -30., 0.);
let b = Vec3::new(0., 0., 0.);
check(a, b, Some(Collision::Bottom));
}
///
/// ______
/// | --|-----------
/// | | | |
/// | A | | B |
/// | |_|__________|
/// |_____|
///
#[test]
fn left_collision() {
let a = Vec3::new(0., 0., 0.);
let b = Vec3::new(30., 0., 0.);
check(a, b, Some(Collision::Left));
}
///
/// ______
/// -----------|-- |
/// | B | | |
/// | | | A |
/// |__________|_| |
/// |_____|
#[test]
fn right_collision() {
let a = Vec3::new(0., 0., 0.);
let b = Vec3::new(-30., 0., 0.);
check(a, b, Some(Collision::Right));
}
///
/// ______
/// ----|----|----
/// | | | |
/// | | | B |
/// |___|____|___|
/// | A |
/// |____|
#[test]
fn without_corners_on_intersection_area() {
let a = Vec3::new(0., 0., 0.);
let b = Vec3::new(0., 0., 0.);
check(a, b, Some(Collision::Inside));
}
fn check(a: Vec3, b: Vec3, expected: Option<Collision>) {
let a_size = Vec2::new(30., 50.);
let b_size = Vec2::new(50., 30.);
assert_eq!(collide(a, a_size, b, b_size), expected);
}
fn collide_two_rectangles(
// (x, y, size x, size y)
a: (f32, f32, f32, f32),