5.3.1 Bouncing Ball — Gravity and Collisions

Overview

A bouncing ball is the smallest non-trivial physics simulation. It has one moving object, one constant force (gravity), and one event type (wall collision). That is enough to require Euler integration, velocity-clamp collision response, and a per-frame loop — and those three primitives recur in every later simulation in the module, from N-body gravity to cloth dynamics. Get the bouncing ball right and you have most of the toolbox. Get it wrong — for example, by forgetting to clamp the position to the wall after a collision — and the same bug will haunt you for ten lessons. This lesson keeps the physics as small as possible so the bugs are easy to see.

Learning objectives

1. Apply Euler integration with a constant gravity term — velocity += gravity, position += velocity.
2. Detect wall collisions by checking each side of the canvas and respond by reflecting the velocity component.
3. Use a damping factor on bounces to model inelastic collisions — energy loss per impact.
4. Visualise motion with a fading trail of past positions, without storing the full history forever.

Quick start — gravity and bounce

Three lines do the physics. The first two are integration; the third is collision.

self.vy += GRAVITY
self.x += self.vx
self.y += self.vy

if self.y + self.radius > HEIGHT:
    self.y = HEIGHT - self.radius            # clamp to wall
    self.vy = -self.vy * BOUNCE_DAMPING       # reflect velocity

Core concepts

Concept 1 — Euler integration with constant force

Gravity is a constant force. Every frame, it adds a fixed amount to the downward velocity. Then velocity moves the position. This is Euler’s method for solving a differential equation, and it is the simplest integrator that exists.

self.vy += GRAVITY        # 1. constant force → velocity change
self.x += self.vx         # 2. velocity → position change
self.y += self.vy

Order matters slightly. The version above is semi-implicit Euler (velocity first, then position) — slightly more stable than naive Euler for systems with oscillation. Setting GRAVITY = 0.5 does not mean anything physical (it is “pixels per frame²”); we tune until the motion looks right.

Concept 2 — Collision = clamp + reflect

A naive collision check (“if y > HEIGHT, reverse vy”) has a famous bug: it lets the ball penetrate the wall before reflecting. On the next frame the ball is below the wall and vy has flipped — it should be moving up, but the same check triggers again and flips it back. The ball jitters at the wall.

The fix is to clamp first, then reflect:

if self.y + self.radius > HEIGHT:
    self.y = HEIGHT - self.radius           # 1. clamp position to wall
    self.vy = -self.vy * BOUNCE_DAMPING      # 2. reflect velocity, lose some energy

Now no matter how fast the ball was moving, it ends the frame exactly touching the wall, not penetrating it. The reflect step flips the sign of the component of velocity normal to the wall. For an axis-aligned wall that is just the relevant vx or vy.

Concept 3 — Trails by storing past positions

To show motion paths, store the last N positions in a list and draw each one with a brightness that fades into the past.

self.trail.append((self.x, self.y))
if len(self.trail) > TRAIL_LEN:
    self.trail.pop(0)

for i, (tx, ty) in enumerate(ball.trail):
    fade = (i + 1) / len(ball.trail)
    colour = tuple(int(c * fade) for c in TRAIL_COLOUR)
    draw.ellipse([tx - r, ty - r, tx + r, ty + r], fill=colour)

The trail is bounded (TRAIL_LEN is constant), the fade is linear in age, and each drawn dot can shrink as it ages too — those three knobs are everything that distinguishes a comet tail from a fairy-dust shimmer.

Exercises

Three exercises in Execute → Modify → Create order.

if self.x - self.radius < 0:
    self.x = self.radius
    self.vx = -self.vx * BOUNCE_DAMPING
elif self.x + self.radius > WIDTH:
    self.x = WIDTH - self.radius
    self.vx = -self.vx * BOUNCE_DAMPING

if self.y - self.radius < 0:
    self.y = self.radius
    self.vy = -self.vy * BOUNCE_DAMPING
elif self.y + self.radius > HEIGHT:
    self.y = HEIGHT - self.radius
    self.vy = -self.vy * BOUNCE_DAMPING

Downloads

Summary

Common pitfalls to avoid

• Reflecting velocity without clamping position. The ball penetrates the wall and the simulation jitters at the boundary.
• Adding gravity twice — once in step, once in the wall response. The ball accelerates at every bounce.
• Storing the trail forever. Memory grows linearly with simulation length.
• Drawing the trail after the ball. The ball is hidden by its own trail tail.
• Using int for position. Sub-pixel motion vanishes and slow balls freeze.

References