Forces

Chapter 1: Newton's Laws

Isaac Newton gave us three laws of motion. Together, they explain why things move (or don't).

Before Newton, people followed Aristotle's idea: things stop unless something keeps pushing them. Newton flipped it: things keep going unless something stops them. A hockey puck on frictionless ice would slide forever. It's forces (friction, air resistance) that slow things down.

In code, this means: if no forces act on an object, its velocity stays constant. We don't need to "keep pushing" it each frame.

Push against a wall. The wall pushes back on you with equal force. Push a friend on roller skates — they slide backward, but you might too (depending on mass and friction). The forces are equal; the outcomes depend on each object's properties.

In our simulations, we won't always model both sides of a force pair. When we apply "wind" to a ball, we won't bother modeling the force the ball exerts back on the air. We're inspired by physics, not slaves to it.

Chapter 2: F = ma

Newton's second law is the star of this chapter. It's usually written as:

But for us programmers, the more useful form is:

Acceleration is directly proportional to force and inversely proportional to mass. Push harder, you accelerate more. Be heavier, you accelerate less. This single equation turns any force vector into an acceleration vector.

For simplicity, let's start with mass = 1. Then a = F / 1 = F. The acceleration is the force. This is a perfectly fine starting point, and it's what we'll use until we introduce mass in a few chapters.

pseudocode
function applyForce(force):
  acceleration = force   # mass = 1, so a = F

Chapter 3: Force Accumulation

Here's a problem. Say we want gravity and wind to act on our ball. If applyForce() just sets acceleration to the force, the second call overwrites the first:

pseudocode
applyForce(wind)     # acceleration = wind
applyForce(gravity)  # acceleration = gravity (wind is lost!)

The fix is force accumulation: we add each force to acceleration instead of replacing it.

The net force is the sum of all forces. Divide by mass and you get acceleration.

pseudocode
function applyForce(force):
  acceleration = acceleration + force  # accumulate!

pseudocode
function update():
  velocity = velocity + acceleration
  location = location + velocity
  acceleration = (0, 0)  # clear for next frame

Now we can throw as many forces as we want — 1, 5, 100 — and they'll all combine naturally. Gravity pulling down? Wind pushing right? Friction slowing you? They all add up into one net acceleration.

Chapter 4: Gravity & Wind

Let's apply two of the simplest forces: gravity (a constant downward pull) and wind (a horizontal push).

Gravity is easy to model. Near Earth's surface, every object experiences the same gravitational acceleration: about 9.8 m/s² downward. In pixel-land, we'll use a much smaller number:

Wind is equally simple — a constant horizontal force:

Each frame, we apply both forces, then update:

pseudocode
each frame:
  mover.applyForce(gravity)
  mover.applyForce(wind)
  mover.update()
  mover.display()
  mover.checkEdges()

Edge-checking is also simple: if the ball hits the bottom, reverse its y-velocity (bounce). If it hits a side, reverse its x-velocity. Multiply by a damping factor (like 0.9) for energy loss on each bounce.

Chapter 5: Mass

Time to bring mass into the picture. Newton's second law is F = ma, which means a = F/m. A heavier object accelerates less from the same force.

pseudocode
function applyForce(force):
  f = force / mass             # a = F / m
  acceleration = acceleration + f

Now imagine two balls — one with mass 1 and another with mass 10 — both experiencing the same gravity force. The light ball accelerates 10 times faster than the heavy one. Add in a wind force and watch how differently they move.

Chapter 6: Friction

So far our forces have been push-forward forces. But some forces resist motion. Friction is the most common one: it acts in the opposite direction of an object's velocity and slows it down.

The formula for kinetic friction is:

Let's break this apart:

pseudocode
function computeFriction(mover):
  friction = mover.velocity.copy()
  friction.normalize()       # direction of motion
  friction.mult(-1)          # reverse it
  friction.mult(mu)          # scale by coefficient
  return friction

Chapter 7: Drag

When an object moves through a fluid (air, water), it experiences drag — a resistive force that increases with speed. The faster you move, the harder the fluid pushes back.

That's the full equation. We'll simplify it for our simulation by rolling the density, area, and drag coefficient into one constant c:

The key difference from friction: drag is proportional to the square of velocity. Going twice as fast means four times the drag. This is why terminal velocity exists — at some speed, drag equals gravity and acceleration stops.

pseudocode
function computeDrag(mover, c):
  speed = mover.velocity.mag()
  dragMag = c * speed * speed  # proportional to v^2
  drag = mover.velocity.copy()
  drag.normalize()
  drag.mult(-1)
  drag.mult(dragMag)
  return drag

Chapter 8: Forces Playground

Everything comes together here. Below, multiple balls with different masses fall under gravity, experience wind (click and hold to apply wind), and encounter friction along the ground. Watch how mass changes everything.

Chapter 9: Summary

Forces are the bridge between "things that move" and "things that move believably." Here's what we built: