Physics Libraries

Chapter 1: Box2D Concepts

Box2D is a 2D rigid-body physics engine originally written in C++ by Erin Catto. It's been used in thousands of games (Angry Birds, Limbo, etc.) and ported to virtually every language.

Box2D's key concepts:

Chapter 2: The World

Everything in Box2D lives inside a World object. You create the world, set gravity, and then step it forward in time each frame.

pseudocode
world = new World(gravity: (0, 10))

each frame:
  world.step(timeStep, velocityIterations, positionIterations)
  # world updates all bodies automatically
  # we just query their positions and draw

Box2D uses its own coordinate system (meters, not pixels) and its own unit scale. You'll need conversion functions to translate between Box2D's world and your screen pixels. A typical scale factor is 10 pixels per meter.

Chapter 3: Bodies & Shapes

Bodies come in three types:

Creating a dynamic body with a box shape:

pseudocode
# Define the body
bodyDef = new BodyDef()
bodyDef.type = DYNAMIC
bodyDef.position = (5, 2)  # in meters
body = world.createBody(bodyDef)

# Define the shape
shape = new PolygonShape()
shape.setAsBox(1, 1)  # half-width, half-height

# Attach via fixture
fixtureDef = new FixtureDef()
fixtureDef.shape = shape
fixtureDef.density = 1.0
fixtureDef.friction = 0.3
fixtureDef.restitution = 0.5  # bounciness
body.createFixture(fixtureDef)

Chapter 4: Joints

Joints connect two bodies together with constraints. They're what make things interesting beyond simple collisions.

Chapter 5: Collision

One of the biggest reasons to use a physics library is collision detection and response. In our hand-rolled physics, we checked for edge collisions (walls and floor). But what about objects hitting each other?

Collision detection has two phases:

Box2D handles both phases automatically. You can also register contact listeners to get callbacks when collisions happen, so you can trigger sounds, particles, damage, or score changes.

Chapter 6: toxiclibs & Springs

Box2D is built for rigid bodies. But what about soft, stretchy things? toxiclibs (by Karsten Schmidt) takes a different approach: particle-spring systems.

Instead of rigid shapes, toxiclibs gives you:

toxiclibs is ideal for cloth, soft bodies, hair, rope, and anything that stretches. You define a mesh of particles connected by springs, and the physics engine keeps them at their rest lengths (approximately).

Chapter 7: Soft Bodies

A soft body is built from particles connected by springs in a mesh pattern. Imagine a grid of particles where each one is connected to its neighbors. The springs try to maintain their rest lengths, but they can stretch and compress, creating a jelly-like object.

pseudocode
# Create a grid of particles
for row in 0..10:
  for col in 0..10:
    particle = new Particle(col * spacing, row * spacing)
    world.add(particle)

# Connect neighbors with springs
for each pair of adjacent particles:
  spring = new Spring(p1, p2, restLength, stiffness)
  world.add(spring)

The beauty of particle-spring systems is their simplicity. Each spring just pulls its two particles toward the rest length. But hundreds of springs working together create complex, organic behavior — another example of emergence from simple rules.

Chapter 8: Stacking Simulation

Below is a simplified rigid-body stacking simulation. Boxes fall from above and stack on a platform, colliding with each other. This demonstrates the core idea: the library handles all collisions and responses; we just draw.

Chapter 9: Summary