Mastering Game Physics: Essential Math and Code Techniques

In the fascinating journey of game development, physics and mathematics are not only the foundation for building realistic worlds but also the magical tools that give games life and soul, enabling characters to move naturally, ensuring environmental coherence, and offering players endless exploration and challenge.

Game Physics and Mathematics

The book "Game Development Physics and Mathematics" covers the mathematical and physical knowledge required for game development, ranging from basic object motion simulation to complex lighting and screen transition effects, and delves into the theoretical foundations of game development. Six chapters guide readers through concepts such as proportion, functions, collision detection, and light handling, emphasizing their broad application in game design.

By providing example programs (the original book uses C++, this article supplies Python equivalents), the material demonstrates that although the required mathematics is extensive, it is not impossible to master; hands‑on practice helps translate theory into creative game design.

Object Motion

1. Uniform Linear Motion

An object moves at constant speed along a straight line. Position as a function of time is expressed by the equation position = initial_position + velocity * time . Example: a character in a platformer moves at a constant speed without external forces.

2. Diagonal Movement

Using the Pythagorean theorem and vector representation, a velocity vector can be split into horizontal and vertical components to achieve diagonal motion. Example: keyboard input determines the components for a character moving diagonally.

3. Arbitrary Direction Motion

Trigonometric functions compute direction. Given speed v and angle θ , the velocity components are vx = v * cos(θ) and vy = v * sin(θ) . Example: a soccer ball kicked in any direction.

4. Projectile Motion

Combines initial velocity and gravity. Horizontal and vertical positions over time are obtained by integration, yielding the classic parabolic trajectory. Example: bullet trajectory in a shooter game.

5. Random Splatter Motion

Random numbers generate direction and speed, using uniform or normal distributions. Example: simulating raindrop splatter.

6. Circular Motion

Described by angular velocity and centripetal force; position is expressed in polar coordinates. Example: planetary orbits in a space game.

7. Differential Equations and Numerical Solutions

Differential equations model velocity and acceleration over time; numerical methods such as Euler's method approximate solutions for complex dynamic systems. Example: simulating a hanging spring.

Scrolling

1. Background Scrolling

Background moves proportionally to camera position, creating a sense of motion. Example: a 2D side‑scroller where the background scrolls opposite to the character's movement.

<code># Background scrolling example in Python
background_positions = [0, 100, 200, 300, 400]
scroll_speed = -20  # negative for leftward scroll

def scroll_background(positions, speed):
    return [pos + speed for pos in positions]

for _ in range(5):
    background_positions = scroll_background(background_positions, scroll_speed)

print(background_positions)  # Updated positions
</code>

2. Linked Background and Character Movement

Mapping character world coordinates to screen coordinates synchronizes background scrolling with character motion.

3. Map Scrolling

Integer subtraction, bit‑shifts, and logical operations move map tiles to create seamless scrolling. Example: a strategy game where the player slides the map to view different regions.

4. Wave‑Like Scrolling

Applying sine wave mathematics creates wave‑like background motion, mimicking water surfaces.

5. Depth‑Perception Scrolling

Perspective and scaling calculations produce parallax effects, where distant background layers move slower than near ones, enhancing depth perception.

6. Perspective Theory

Perspective transforms map 3D world coordinates onto a 2D screen, essential for 3D simulation games.

Collision Detection

1. Axis‑Aligned Bounding Box (AABB) Collision

Uses De Morgan’s law and rectangle coordinates to detect overlap. Example: platformer character colliding with ground or walls.

<code># AABB collision detection example in Python
rectA = {'x': 0, 'y': 0, 'width': 50, 'height': 50}
rectB = {'x': 40, 'y': 40, 'width': 50, 'height': 50}

def aabb_collision(a, b):
    if (a['x'] < b['x'] + b['width'] and
        a['x'] + a['width'] > b['x'] and
        a['y'] < b['y'] + b['height'] and
        a['y'] + a['height'] > b['y']):
        return True
    else:
        return False

collision = aabb_collision(rectA, rectB)
print(f"Collision occurred: {collision}")
</code>

2. Circle‑Circle Collision

Collision occurs when the distance between centers is less than the sum of radii. Example: bullet (circle) hitting a target.

3. Capsule‑Circle Collision

Compute the shortest distance from the circle center to the line segment representing the capsule; if this distance is less than the radius, a collision is detected.

4. Sector Collision

Check if a point lies within a sector by first testing the radial distance and then the angular bounds.

5. 3D Collision Detection

Extends 2D methods to three dimensions, comparing x, y, and z coordinates for boxes or using 3D distance formulas for spheres.

Ray Casting

1. Object Rotation and Scaling

Rotation matrices rotate objects around an axis; scaling matrices adjust size. Example: rotating unit icons in a strategy game.

2. Ray Casting Between Two Points

Compute the unit vector from source to target to define ray direction. Example: first‑person shooter determining bullet trajectory.

<code># Ray direction calculation example in Python
import math

def unit_vector(start, end):
    dx = end['x'] - start['x']
    dy = end['y'] - start['y']
    distance = math.sqrt(dx**2 + dy**2)
    return {'x': dx / distance, 'y': dy / distance}

source = {'x': 0, 'y': 0}
target = {'x': 10, 'y': 10}
ray_dir = unit_vector(source, target)
print(f"Ray direction: {ray_dir}")
</code>

3. Ray Bending (Refraction)

Simulate light refraction through materials by applying Snell’s law to compute the bent angle.

4. Tracking Laser

Calculate the vector from laser source to target and adjust direction over time; cross product determines side orientation.

5. Highly Curved Curves

Curvature k describes how sharply a curve bends; dynamic line width and interpolation smooth the visual result.

Screen Transition Effects

1. Horizontal Scan Transition

Divides the screen into triangles and updates UV coordinates to create a smooth horizontal scan.

<code># Horizontal scan transition example in Python
initial = "Initial screen content"
target = "Target screen content"

def horizontal_scan(initial, target, step=10):
    for i in range(0, 101, step):
        if i < 100:
            print(f"{initial[:len(initial)*(100-i)//100]}{' ' * (len(target)*i//100)}", end='\r')
        else:
            print(target)

horizontal_scan(initial, target)
</code>

2. Diagonal Scan Transition

Uses a line equation with slope and intercept to clip the screen progressively along a diagonal.

3. Blur Edge Transition

Alpha blending with a blurred edge creates a smooth fade between scenes.

4. Circular Transition

Calculates distance from each pixel to a circle center; pixels inside the radius become visible.

5. Wiper Transition

Mimics a wiper’s motion by moving a mask across the screen, revealing the next scene.

6. Advanced Transitions

Combines masks, programmable shaders, and Gaussian blur to achieve professional‑grade visual effects.

Fundamental Math and Physics Theory for Game Development

1. Proportion, Linear Functions, and Line Equations

Used to calculate object trajectories and parameterized motion.

2. Expansion and Factorization

Simplifies force calculations in physics engines.

3. Quadratic Functions and Equations

Apply to projectile motion and circle equations for collision detection.

4. Trigonometric Functions

Sine and cosine compute rotation and circular paths.

5. Vectors and Matrices

Vector length, direction, and matrix transformations enable rotation, scaling, and translation in 2D/3D graphics.

6. Differential Calculus

Derivatives give instantaneous velocity and acceleration for dynamic simulations.

7. Series and Integrals

Summations and integrals calculate total distance traveled from velocity functions.