"Slow is smooth, smooth is fast. The fastest drivers are the ones who waste the least grip."

Week 1: History & Design Theory

The Origin

Simulation racing games have pursued the same goal since the beginning: make the player feel what it is like to drive a real car at the limit. The genre's roots trace to Indianapolis 500: The Simulation (1989) by Papyrus Design Group, which modeled tire wear, fuel consumption, and car setup for the first time in a consumer game. But it was Gran Turismo (1997) that brought simulation racing to a mass audience. Creator Kazunori Yamauchi obsessed over accuracy: every car was laser-scanned, every engine modeled from manufacturer data, every tire curve tuned to match real-world behavior. The result sold over 10 million copies and proved that simulation did not have to mean inaccessible.

What separates simulation racing from arcade racing is not complexity for its own sake — it is the emergent depth that comes from modeling real physics. When tire grip is finite and shared between turning and acceleration, the player must manage that grip budget through every corner. Speed comes from understanding the physics, respecting the limits, and finding the thin line between control and disaster.

How the Genre Evolved

Gran Turismo (Polyphony Digital, 1997) — Defined consumer simulation racing. GT combined a realistic tire model with a massive car collection and RPG-style progression. Players earned money, bought cars, upgraded them, and worked through license tests teaching real driving techniques: heel-toe downshifting, trail braking, the racing line. Its lasting contribution was demonstrating that simulation could be aspirational.

iRacing (iRacing.com Motorsport Simulations, 2008) — Moved simulation racing online with a subscription model and safety rating system that punished reckless driving. iRacing laser-scans real tracks to millimeter accuracy. Its contribution was proving that the social and competitive structure matters as much as the physics.

Assetto Corsa (Kunos Simulazioni, 2014) — An Italian studio's love letter to driving physics. Its tire model is based on the Pacejka "Magic Formula" used by real tire engineers. Its open modding community has added thousands of cars and tracks. It showed that a small team with deep physics expertise could compete with massive studios.

What Makes It "Great"

A great simulation racing game makes you feel the tires. Not through rumble feedback or screen shake — through the car's behavior. When you enter a corner too fast, the front tires gradually lose grip, the steering goes light, and the car drifts wide. When you brake hard, the weight shifts forward, and if you are turning at the same time, the rear might step out. Every one of these behaviors emerges naturally from a good tire model. The best simulation racers do not need to script dramatic moments because the physics generates them.

The Essential Mechanic

Managing tire grip — the fundamental physical constraint that every driving decision revolves around.

---

Week 2: Build the MVP

What You're Building

A top-down simulation racing game where a single car drives around a track. The car uses a tire grip model where grip is finite and shared between steering and acceleration. The player must manage braking zones, find the racing line, and feel the difference between surfaces. The game includes a telemetry display showing speed, throttle, brake, and steering data in real time.

Core Concepts

1. Tire Grip Model

Each tire has a finite amount of grip, determined by its load and the surface it is on. Grip is shared between longitudinal forces (acceleration/braking) and lateral forces (turning). This is modeled as a "grip circle" (also called a friction circle or traction circle): the combined force from acceleration and turning cannot exceed the tire's maximum grip.

MAX_GRIP_COEFFICIENT = 1.0

class Tire:
    load: float              // weight on this tire (Newtons)
    grip_coefficient: float  // surface-dependent: 1.0 asphalt, 0.4 gravel
    slip_angle: float
    slip_ratio: float

function calculate_tire_forces(tire, throttle_force, steering_angle):
    max_grip = tire.load * tire.grip_coefficient

    longitudinal = throttle_force
    lateral = max_grip * sin(clamp(tire.slip_angle * 3.0, -PI/2, PI/2))

    // grip circle: combined force cannot exceed max grip
    combined = sqrt(longitudinal^2 + lateral^2)
    if combined > max_grip:
        scale = max_grip / combined
        longitudinal *= scale
        lateral *= scale

    return {longitudinal, lateral}

Why it matters: The tire grip model is the single most important system in a simulation racer. Everything the player feels — understeer, oversteer, traction loss — emerges from this one model. The grip circle is the physical truth that real racing drivers live by: you cannot accelerate and turn at full force simultaneously because the tire has a finite grip budget.

2. Suspension Simulation

When the car brakes, weight shifts forward, increasing grip on the front tires and decreasing it on the rear. When accelerating, weight shifts backward. When turning, weight shifts to the outside tires. This weight transfer directly affects the grip available to each tire.

class CarPhysics:
    mass: float = 1200           // kg
    wheelbase: float = 2.5       // meters
    track_width: float = 1.8     // meters
    center_of_gravity_height: float = 0.5

function calculate_weight_transfer(car, accel, lateral_accel):
    long_transfer = (car.mass * accel * car.cg_height) / car.wheelbase
    lat_transfer = (car.mass * lateral_accel * car.cg_height) / car.track_width

    tires = {
        front_left:  base_weight + long_transfer - lat_transfer,
        front_right: base_weight + long_transfer + lat_transfer,
        rear_left:   base_weight - long_transfer - lat_transfer,
        rear_right:  base_weight - long_transfer + lat_transfer
    }

Why it matters: Weight transfer is why simulation racing feels different from arcade racing. In an arcade racer, all four tires have the same grip all the time. In a simulation, braking shifts weight forward — which is why a car can spin if you brake and turn simultaneously. Trail braking works because you are gradually transferring weight from the front back to the rear.

3. Braking Zones and Racing Line

The racing line is the path through a corner that minimizes time: brake in a straight line before the corner, turn in at the apex, and accelerate out. Braking zones are the sections of track where the driver must decelerate before entering a turn.

// The racing line through a corner follows three phases:
// 1. BRAKE: straight-line braking before the turn
// 2. TURN-IN: release brakes, turn the wheel
// 3. APEX & EXIT: hit the inside, then accelerate out

function calculate_brake_distance(entry_speed, exit_speed, max_decel):
    // v^2 = u^2 + 2as  =>  s = (u^2 - v^2) / (2a)
    return (entry_speed^2 - exit_speed^2) / (2 * max_decel)

Why it matters: The racing line is where physics theory meets driving practice. Braking zones give the player specific, improvable skills: "I braked too late and ran wide" is actionable feedback.

4. Car Setup / Tuning

The car has adjustable parameters that change its handling characteristics. Increasing front suspension stiffness reduces body roll but makes the front less compliant. Lowering tire pressure increases the contact patch but reduces responsiveness. Each adjustment has trade-offs.

class CarSetup:
    front_suspension_stiffness: float = 50000  // N/m
    rear_suspension_stiffness: float = 45000
    front_tire_pressure: float = 2.0           // bar
    rear_tire_pressure: float = 2.1
    brake_bias: float = 0.6                    // 60% front, 40% rear

function pressure_to_grip(pressure):
    optimal = 2.0
    deviation = abs(pressure - optimal)
    return 1.0 - (deviation * 0.3)  // each 0.1 bar off costs 3%

Why it matters: Car setup is the meta-puzzle of simulation racing. The track, weather, and driver's style all influence the optimal setup. Even three or four adjustable parameters give the player meaningful tuning decisions.

5. Telemetry System

The game records driving data — speed, throttle, brake, steering, tire temperatures — over time and displays it as graphs. Telemetry is how real racing drivers and engineers analyze performance.

function draw_telemetry_overlay(samples, current_lap_distance):
    draw_graph(data=samples.map(s => {x: s.track_position, y: s.speed}),
               color=WHITE, label="Speed (km/h)")
    draw_graph(data=samples.map(s => {x: s.track_position, y: s.throttle}),
               color=GREEN, label="Throttle")
    draw_graph(data=samples.map(s => {x: s.track_position, y: s.brake}),
               color=RED, label="Brake")

Why it matters: Telemetry transforms simulation racing from a game of feel into data-driven improvement. Comparing a slow lap to a fast lap reveals exactly where time is gained or lost.

6. Surface Model

Different surfaces provide different grip levels. Asphalt is high grip, gravel is low, grass is very low. The transition between surfaces should be smooth, not binary, because in real driving you often have two tires on track and two on the curb.

surface_properties = {
    "asphalt": {grip: 1.0, rolling_resistance: 0.02},
    "curb":    {grip: 0.85, rolling_resistance: 0.03},
    "gravel":  {grip: 0.4, rolling_resistance: 0.10},
    "grass":   {grip: 0.3, rolling_resistance: 0.12}
}

Why it matters: Surfaces add strategic depth. Running wide onto the grass is not just "out of bounds" — it is a physical consequence with physics-based punishment. The per-tire surface model means having half your car on gravel creates asymmetric forces.

7. Damage Model

Collisions and off-track excursions can damage the car, affecting performance. A hard wall impact might reduce top speed, cause the car to pull to one side, or reduce braking efficiency. Damage creates consequences for mistakes beyond lost time.

class DamageState:
    engine_health: float = 1.0
    suspension_damage: dict = {per-wheel damage}
    aero_damage: float = 0.0

function apply_damage_effects(car):
    car.max_power = car.base_max_power * car.damage.engine_health
    car.downforce_multiplier = 1.0 - car.damage.aero_damage

Why it matters: Without damage, the fastest strategy is often to slam into walls (the "wall brake" exploit). With damage, every collision has lasting consequences, teaching the player that consistency matters more than raw speed.

---

Stretch Goals

• AI opponents — Add AI cars that follow the racing line at varying speeds.
• Weather system — Implement wet conditions that reduce grip across all surfaces.
• Tire wear — Tires gradually lose grip over many laps.
• Replay system — Record full lap data and play it back from multiple camera angles.

MVP Spec

Element	Scope
View	Top-down 2D or simple low-poly 3D
Tire physics	Grip circle model: finite grip shared between steering and acceleration
Suspension	Weight transfer under braking, acceleration, and turning
Surfaces	3 types: asphalt (high grip), curb (medium), grass (low)
Track	1 track with 4-6 corners
Telemetry	Real-time speed, throttle, brake display
Damage	Basic collision damage affecting engine power and wheel alignment
Timing	Lap timer with sector splits, best lap tracking

Deliverable

A playable simulation racing game where a single car drives around a track using a tire grip model with weight transfer. The player must manage braking zones and the racing line to set fast lap times. The player should be able to feel the difference between driving within the grip limit and exceeding it.

---

Discussion Questions

1. Realism vs. Fun: Perfectly realistic tire physics can be frustrating. Where do you draw the line between accuracy and playability? Start realistic and add assists, or start forgiving and opt into realism?
2. The Telemetry Paradox: Telemetry is powerful for improvement, but most players will never look at a graph. How do you design telemetry that casual players will actually use?
3. Teaching Through Physics: The physics engine is the teacher. How would you help players connect the physical sensation (car sliding) to the underlying cause (exceeding the grip circle) without breaking immersion?
4. The Setup Rabbit Hole: Car setup tuning can consume hours. How do you expose enough options for meaningful customization without overwhelming the player?