Gamedev Physics

Game physics & collision

Make bodies collide, move, and stay stable across Godot, Unity, and Unreal. This skill owns the mental model (body types, colliders, layers/masks, character controllers, joints, queries, determinism) and maps every concept onto each engine's real API. When physics "feels broken" — jitter, tunneling, sinking, ghost collisions — the cause is almost always one of: wrong body type, a layer/mask mismatch, or moving/integrating outside the fixed physics tick. Check those first.

Version contract — read first (never emit these)

If you are unsure a symbol exists in the user's exact version, say so instead of inventing it.

When to use / When NOT to use

Use when: designing which body type a thing should be; something falls through, sinks into, or passes through geometry; a rigid body jitters, drifts, or launches; setting up collision layers/masks/channels; building or fixing a character/player controller; adding joints; casting rays/shapes or overlap tests; or physics behaves differently at different frame rates.

When NOT to use (delegate):

• Visual-only wobble, shader/vertex animation, material or lighting issues → gamedev-shaders.
• AI moving along a path, navmesh, A*, steering, avoidance → gamedev-pathing (physics only executes the move; pathing decides where).
• Deep, engine-specific project setup / editor / build questions → godot, unity, unreal.
• Netcode, lockstep sync, server-authoritative movement → gamedev-multiplayer (this skill gives you the deterministic fixed-tick foundation multiplayer builds on).

1. Body types — pick before you touch anything

Three categories exist in every engine; choosing wrong is the root of most bugs.

• Static — never moves, infinite mass, cheap. Level geometry, walls, floors. Do not move a static body every frame; the broadphase caches it. If it must move, it is not static.
• Kinematic / character — moved by you (code/animation), pushes dynamics but is not pushed by them, ignores forces and gravity unless you add them. Players, moving platforms, doors, elevators.
• Dynamic (rigid) — fully simulated: gravity, forces, impulses, collision response. Crates, ragdolls, debris, vehicles. You influence it with forces/impulses, never by writing its transform.

Move each the right way:

A Godot RigidBody can be temporarily frozen: set freeze = true with freeze_mode = FREEZE_MODE_KINEMATIC to move it by transform without waking the solver wrongly. Prefer AnimatableBody for a permanent kinematic mover.

2. Colliders / shapes

Collider ≠ visual mesh. Give every body a separate, simpler collision shape.

• Primitives (box, sphere/circle, capsule) — cheapest and most stable. Prefer a capsule for characters (rounded ends slide over steps and seams). Use these whenever possible.
• Convex hull — dynamic bodies can use a convex approximation; a concave prop needs multiple convex pieces (a compound), not one concave hull.
• Concave / trimesh — exact triangle mesh, but static-only in every engine. A moving concave-mesh collider is a top cause of tunneling and solver blowups. Never put a trimesh on a dynamic body.
• Compound — several child shapes on one body. Godot: multiple CollisionShape children. Unity: multiple Collider components. Unreal: multiple primitives / a body setup.
• Triggers / areas — detect overlap, no physical response. Godot Area2D/3D (signals body_entered / area_entered); Unity collider Is Trigger (OnTriggerEnter/Stay/Exit); Unreal set response to Overlap + Generate Overlap Events (OnComponentBeginOverlap). Use for pickups, damage zones, checkpoints, sensors.

3. Collision layers & masks — the #1 confusion

Layer = "what I am." Mask = "what I scan for." They are separate bit sets.

• Godot: two bodies interact when one's collision_mask includes the other's collision_layer — it is an OR, so detection can be asymmetric (A sees B without B seeing A). Keep them symmetric unless you deliberately want one-way detection. An Area's mask decides what it detects; its layer decides what detects it.
• Unity: GameObject Layers + the Layer Collision Matrix (Project Settings → Physics) decide which layer pairs collide. Raycasts/overlaps take a LayerMask argument. Toggle a pair at runtime with Physics.IgnoreLayerCollision.
• Unreal: Object Type (channel) = what I am; per-channel Response = Block / Overlap / Ignore. Package as a reusable Collision Preset. Trace channels (Visibility, Camera) are for queries; object channels are for physical collision.

Full worked examples (player/enemy/pickup/wall, bit math, one-way platforms) → references/layers-and-masks.md.

4. Character controllers

Two philosophies — decide up front, don't mix:

• Kinematic character (recommended for most players): you compute velocity and move via a sweeping helper that resolves collisions and slides. Precise, snappy, no solver fighting. Godot CharacterBody, Unity CharacterController, Unreal CharacterMovementComponent.
• Dynamic (rigidbody) character: physical pushing/being-pushed for free, but needs high friction or a physics material, angular constraints (freeze rotation), and tuning to stop tipping/sliding.

Godot 4 (2D — the 3D version is identical with Vector3 and get_gravity()):

extends CharacterBody2D

const SPEED := 300.0
const JUMP_VELOCITY := -400.0

func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity += get_gravity() * delta        # accumulate accel: scale by delta
    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = JUMP_VELOCITY
    var dir := Input.get_axis("move_left", "move_right")
    velocity.x = dir * SPEED if dir else move_toward(velocity.x, 0.0, SPEED)
    move_and_slide()                              # Godot 4: NO args, uses `velocity`, already delta-scaled

is_on_floor() / is_on_wall(), floor_max_angle (slope limit), floor_snap_length (stick to ground on ramps/stairs), and up_direction handle ground/slope/step behavior. get_gravity() is Godot 4.3+; on older 4.x read ProjectSettings gravity. Full per-engine controllers (Unity CharacterController + custom gravity, Unreal movement modes, ground detection, slopes, steps, moving platforms) → references/character-controllers.md.