Resolving Collisions

noooway edited this page Jul 31, 2018 · 12 revisions

Ok, we can detect collisions. Now it's time to deal with how our objects react on them, i.e. with the collision resolution.

When two objects overlap, it turns out convenient to return from the collisions.check_rectangles_overlap not only the fact of the overlap but also a displacement necessary to resolve the overlap. I suppose that the shape b is the one that has to be displaced, and the a should remain in place. If the center of the b is to the right from the center of the a, the b is shifted right to resolve the overlap, in the other case - left ( shift is negative ). Same for y-axis.

function collisions.check_rectangles_overlap( a, b )
   local overlap = false
   local shift_b_x, shift_b_y = 0, 0
   if not( a.x + a.width < b.x  or b.x + b.width < a.x  or
           a.y + a.height < b.y or b.y + b.height < a.y ) then
      overlap = true
      if ( a.x + a.width / 2 ) < ( b.x + b.width / 2 ) then
         shift_b_x = ( a.x + a.width ) - b.x                    --(*1a)
         shift_b_x = a.x - ( b.x + b.width )                    --(*1b)
      if ( a.y + a.height / 2 ) < ( b.y + b.height / 2 ) then
         shift_b_y = ( a.y + a.height ) - b.y                   --(*2) 
         shift_b_y = a.y - ( b.y + b.height )                   --(*2)
   return overlap, shift_b_x, shift_b_y                         --(*3)

(*1a): b to the right from the center of a; shift b to the right
(*1b): b to the left from a; shift to the left.
(*2): same for y axis.
(*3): shift is returned along with the fact of the overlap

Now, in collision-resolution functions we need to check for overlap, and if it happens - react on in. For platform-ball collision, there is no need to modify the platform, but it is necessary to change the ball direction. ball.rebound is responsible for this.

function collisions.ball_platform_collision( ball, platform )
   local overlap, shift_ball_x, shift_ball_y
   local a = { x = platform.position_x,
               y = platform.position_y,
               width = platform.width,
               height = platform.height }
   local b = { x = ball.position_x - ball.radius,
               y = ball.position_y - ball.radius,
               width = 2 * ball.radius,
               height = 2 * ball.radius }
   overlap, shift_ball_x, shift_ball_y =
      collisions.check_rectangles_overlap( a, b )   
   if overlap then
      ball.rebound( shift_ball_x, shift_ball_y )       --(*1)

(*1): if there is an overlap between the ball and the platform, make ball rebound.

In ball.rebound function the overlap values are passed. I determine the minimal one of them, zero the other one and shift the ball by the nonzero value (see the figure; todo: redraw it). Besides, the speed direction along the shift axis is reversed.

function ball.rebound( shift_ball )
   local min_shift = math.min( math.abs( shift_ball.x ),
                               math.abs( shift_ball.y ) )
   if math.abs( shift_ball.x ) == min_shift then
      shift_ball.y = 0
      shift_ball.x = 0
   ball.position = ball.position + shift_ball
   if shift_ball.x ~= 0 then
      ball.speed.x = -ball.speed.x
   if shift_ball.y ~= 0 then
      ball.speed.y = -ball.speed.y

Ball-wall collisions are resolved in a similar fashion. Platform-wall is the same, but there is no need to change the velocity of the platform.

For the ball-brick collision it is necessary to delete the brick on collision. Brick reaction on the collision is described by bricks.brick_hit_by_ball function. For now, the only reaction is to remove the brick from the bricks.current_level_bricks table. This is done by executing table.remove. To implement this, it is necessary to pass the index of the brick into bricks.current_level_bricks.

function collisions.ball_bricks_collision( ball, bricks )
   local overlap, shift_ball_x, shift_ball_y
   for i, brick in pairs( bricks.current_level_bricks ) do   
      overlap, shift_ball_x, shift_ball_y =
         collisions.check_rectangles_overlap( a, b )
      if overlap then    
         ball.rebound( shift_ball_x, shift_ball_y )
         bricks.brick_hit_by_ball( i, brick,                     --(*1)
                                   shift_ball_x, shift_ball_y )

function bricks.brick_hit_by_ball( i, brick, shift_ball_x, shift_ball_y )
   table.remove( bricks.current_level_bricks, i )                --(*2)

(*1): brick reaction on the collision is stored in the bricks.brick_hit_by_ball function.
(*2): brick is removed from the bricks.current_level_bricks

← 1.4 - Detecting Collisions           ↑ To the top           Next section: 1.6 - Levels →


Chapter 1: Prototype

  1. The Ball, The Brick, The Platform
  2. Game Objects as Lua Tables
  3. Bricks and Walls
  4. Detecting Collisions
  5. Resolving Collisions
  6. Levels

    Appendix A: Storing Levels as Strings
    Appendix B: Optimized Collision Detection (draft)

Chapter 2: General Code Structure

  1. Splitting Code into Several Files
  2. Loading Levels from Files
  3. Straightforward Gamestates
  4. Advanced Gamestates
  5. Basic Tiles
  6. Different Brick Types
  7. Basic Sound
  8. Game Over

    Appendix C: Stricter Modules (draft)
    Appendix D-1: Intro to Classes (draft)
    Appendix D-2: Chapter 2 Using Classes.

Chapter 3 (deprecated): Details

  1. Improved Ball Rebounds
  2. Ball Launch From Platform (Two Objects Moving Together)
  3. Mouse Controls
  4. Spawning Bonuses
  5. Bonus Effects
  6. Glue Bonus
  7. Add New Ball Bonus
  8. Life and Next Level Bonuses
  9. Random Bonuses
  10. Menu Buttons
  11. Wall Tiles
  12. Side Panel
  13. Score
  14. Fonts
  15. More Sounds
  16. Final Screen
  17. Packaging

    Appendix D: GUI Layouts
    Appendix E: Love-release and Love.js

Beyond Programming:

  1. Game Design
  2. Minimal Marketing (draft)
  3. Finding a Team (draft)


Clone this wiki locally
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.
Press h to open a hovercard with more details.