The collision code thinks the ball is a rectangular box, so the ball often collides with a brick even though the ball sprite itself isn't yet touching the brick. Let's see if we can figure out a more precise collision detection technique.īecause the ball is a circle-like object, an AABB is probably not the best choice for the ball's collision shape. While the collision detection does work, it's not very precise since the ball's rectangular collision shape collides with most of the bricks without the ball directly touching them. If you run the game now it'll look something like this: If we run the code now, the ball should detect collisions with each of the bricks and if the brick is not solid, the brick is destroyed.
#VECTOR 2D COLLISION UPDATE#
Then we also need to update the game's Update function: If we detect a collision, we set the brick's Destroyed property to true, which instantly stops the level from rendering this brick:įor (GameObject &box : this->Levels.Bricks) Within DoCollisions, we check for collisions between the ball object and each brick of the level. To keep the collision code a bit more organized we add an extra function to the Game class: If you have trouble visualizing this, try to draw the edges/rectangles on paper and determine this for yourself. We check if the right side of the first object is greater than the left side of the second object and if the second object's right side is greater than the first object's left side similarly for the vertical axis. We check for overlap on both axes and if so, return a collision:īool CheckCollision(GameObject &one, GameObject &two) // AABB - AABB collisionīool collisionX = + >= & Translating this concept to code is relatively straightforward. If both the horizontal and vertical edges overlap we have a collision. So we check if the horizontal edges overlap, and if the vertical edges overlap of both objects. For AABBs this is quite easy to determine due to the fact that they're aligned to the scene's axes: we check for each axis if the two object' edges on that axis overlap. the shape that determines the first object is in some way inside the shape of the second object. So how do we check for collisions? A collision occurs when two collision shapes enter each other's regions e.g. Effectively, each GameObject contains an AABB that we can use for collisions. The GameObject class that we defined already contains a top-left position (its Position vector), and we can easily calculate its bottom-right position by adding its size to the top-left position vector ( Position + Size). One of them is to define an AABB by a top-left and a bottom-right position.
This is exactly what we're going to do.Īxis aligned bounding boxes can be defined in several ways. Here we surround the ball object with an AABB:Īlmost all the objects in Breakout are rectangular based objects, so it makes perfect sense to use axis aligned bounding boxes for detecting collisions. The fact that these boxes are always aligned to the axes of the scene makes calculations easier. left and right edge are parallel to the y axis). Being axis-aligned means the rectangular box has no rotation and its edges are parallel to the base axes of the scene (e.g.
The effect is that a collision may be detected that didn't really collide with the actual object one should always keep in mind that these shapes are just approximations of the real shapes.ĪABB stands for axis-aligned bounding box, a rectangular collision shape aligned to the base axes of the scene, which in 2D aligns to the x and y axis. While the simple shapes do give us easier and more efficient collision detection algorithms, they share a common disadvantage in that these shapes usually do not fully surround the object. A few examples of such collision shapes are circles, spheres, rectangles, and boxes these are a lot simpler to work with compared to arbitrary meshes with hundreds of triangles. We then check for collisions based on these simple shapes this makes the code easier and saves a lot of performance. For this reason, it is a common practice to use more simple shapes (that usually have a nice mathematical definition) for collision detection that we overlay on top of the original object. When trying to determine if a collision occurs between two objects, we generally do not use the vertex data of the objects themselves since these objects often have complicated shapes this in turn makes the collision detection complicated. Collision detection In-Practice/2D-Game/Collisions/Collision-detection
0 kommentar(er)
