Unity Game Engine Series Part 4: Physics & Collisions

1. Unity Physics Engines

1.1 PhysX 3D & Box2D

Unity runs two completely independent physics simulations. A Rigidbody2D will never collide with a Rigidbody, and a BoxCollider will never detect a BoxCollider2D.

1.2 Rigidbody Fundamentals

The Rigidbody component is the gateway to physics simulation. Without it, a collider is just a static obstacle. With it, an object gains mass, responds to gravity, and participates in force-based interactions.

// Rigidbody configuration for a player character
using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class RigidbodySetup : MonoBehaviour
{
    private Rigidbody rb;

    private void Awake()
    {
        rb = GetComponent<Rigidbody>();
        rb.mass = 70f;
        rb.drag = 1f;
        rb.angularDrag = 5f;
        rb.useGravity = true;
        rb.isKinematic = false;
        rb.interpolation = RigidbodyInterpolation.Interpolate;
        rb.collisionDetectionMode = CollisionDetectionMode.Continuous;

        // Prevent the player capsule from tipping over
        rb.constraints = RigidbodyConstraints.FreezeRotationX
                       | RigidbodyConstraints.FreezeRotationZ;
    }
}

1.3 CharacterController

Unity offers an alternative to Rigidbody: the CharacterController with built-in slope handling, step climbing, and collision resolution without full physics simulation.

// CharacterController-based first-person movement
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class FPSController : MonoBehaviour
{
    [SerializeField] private float walkSpeed = 6f;
    [SerializeField] private float jumpForce = 8f;
    [SerializeField] private float gravity = -20f;
    [SerializeField] private LayerMask groundMask;

    private CharacterController controller;
    private Vector3 velocity;
    private bool isGrounded;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
        controller.slopeLimit = 45f;
        controller.stepOffset = 0.4f;
    }

    private void Update()
    {
        isGrounded = Physics.CheckSphere(
            transform.position + Vector3.down * (controller.height / 2f),
            0.3f, groundMask);

        if (isGrounded && velocity.y < 0) velocity.y = -2f;

        float h = Input.GetAxisRaw("Horizontal");
        float v = Input.GetAxisRaw("Vertical");
        Vector3 moveDir = (transform.right * h + transform.forward * v).normalized;
        controller.Move(moveDir * walkSpeed * Time.deltaTime);

        if (Input.GetButtonDown("Jump") && isGrounded) velocity.y = jumpForce;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}

2. Colliders & Triggers

Colliders define the physical shape of an object for the physics engine -- the simplified "hitbox" used instead of the detailed visual mesh.

2.1 Collider Types

2.2 Trigger vs Collision

// Trigger zone for collecting items
using UnityEngine;

public class CoinPickup : MonoBehaviour
{
    [SerializeField] private int coinValue = 10;
    [SerializeField] private AudioClip pickupSound;
    [SerializeField] private GameObject sparkleEffect;

    private void OnTriggerEnter(Collider other)
    {
        if (!other.CompareTag("Player")) return;

        ScoreManager.Instance.AddScore(coinValue);
        AudioSource.PlayClipAtPoint(pickupSound, transform.position);

        if (sparkleEffect != null)
            Instantiate(sparkleEffect, transform.position, Quaternion.identity);

        Destroy(gameObject);
    }
}

2.3 Physics Materials

A Physic Material controls surface properties -- how bouncy and how frictional a collider is.

// Creating physics materials at runtime
using UnityEngine;

public class SurfaceMaterialManager : MonoBehaviour
{
    public void ApplyIceSurface(Collider col)
    {
        PhysicMaterial ice = new PhysicMaterial("Ice");
        ice.dynamicFriction = 0.05f;
        ice.staticFriction = 0.1f;
        ice.bounciness = 0f;
        ice.frictionCombine = PhysicMaterialCombine.Minimum;
        col.material = ice;
    }

    public void ApplyBouncySurface(Collider col)
    {
        PhysicMaterial bouncy = new PhysicMaterial("Bouncy");
        bouncy.dynamicFriction = 0.4f;
        bouncy.staticFriction = 0.4f;
        bouncy.bounciness = 0.95f;
        bouncy.bounceCombine = PhysicMaterialCombine.Maximum;
        col.material = bouncy;
    }
}

3. Forces & Movement

3.1 AddForce Modes

The ForceMode parameter fundamentally changes how force is applied. Understanding these modes is the key to making physics feel right.

// Demonstrating all four ForceMode types
using UnityEngine;

public class ForceDemo : MonoBehaviour
{
    [SerializeField] private float thrustPower = 10f;
    [SerializeField] private float jumpImpulse = 5f;
    private Rigidbody rb;

    private void Awake() { rb = GetComponent<Rigidbody>(); }

    private void FixedUpdate()
    {
        // ForceMode.Force -- continuous (rocket engine). Heavier = slower.
        if (Input.GetKey(KeyCode.W))
            rb.AddForce(transform.forward * thrustPower, ForceMode.Force);

        // ForceMode.Acceleration -- uniform (like gravity). Mass-independent.
        if (Input.GetKey(KeyCode.G))
            rb.AddForce(Vector3.down * 15f, ForceMode.Acceleration);
    }

    private void Update()
    {
        // ForceMode.Impulse -- instant kick. Heavier = less velocity.
        if (Input.GetKeyDown(KeyCode.Space))
            rb.AddForce(Vector3.up * jumpImpulse, ForceMode.Impulse);

        // ForceMode.VelocityChange -- instant, mass-independent.
        // Consistent jump height regardless of character mass.
        if (Input.GetKeyDown(KeyCode.V))
            rb.AddForce(Vector3.up * jumpImpulse, ForceMode.VelocityChange);
    }
}

3.2 Velocity, Gravity & Drag

// Advanced platformer physics with custom gravity curves
using UnityEngine;

public class PlatformerPhysics : MonoBehaviour
{
    [Header("Movement")]
    [SerializeField] private float maxSpeed = 8f;
    [SerializeField] private float accelForce = 40f;

    [Header("Custom Gravity")]
    [SerializeField] private float fallGravityMultiplier = 2.5f;
    [SerializeField] private float lowJumpGravityMultiplier = 2f;

    [Header("Jump Assists")]
    [SerializeField] private float jumpVelocity = 12f;
    [SerializeField] private float coyoteTime = 0.12f;
    [SerializeField] private float jumpBufferTime = 0.15f;

    private Rigidbody rb;
    private float coyoteTimer, jumpBufferTimer;
    private bool isGrounded;

    private void Awake() { rb = GetComponent<Rigidbody>(); }

    private void FixedUpdate()
    {
        float inputX = Input.GetAxisRaw("Horizontal");
        Vector3 vel = rb.velocity;

        // Accelerate toward target speed
        float targetVelX = inputX * maxSpeed;
        vel.x = Mathf.MoveTowards(vel.x, targetVelX, accelForce * Time.fixedDeltaTime);

        // --- Custom Gravity (the secret to great jump feel) ---
        // Faster fall = snappier descent
        if (vel.y < 0)
            vel.y += Physics.gravity.y * (fallGravityMultiplier - 1) * Time.fixedDeltaTime;
        // Variable jump height: release button early = short hop
        else if (vel.y > 0 && !Input.GetButton("Jump"))
            vel.y += Physics.gravity.y * (lowJumpGravityMultiplier - 1) * Time.fixedDeltaTime;

        rb.velocity = vel;

        // Coyote time: jump briefly after leaving a ledge
        coyoteTimer = isGrounded ? coyoteTime : coyoteTimer - Time.fixedDeltaTime;

        // Jump buffer: remember input pressed just before landing
        jumpBufferTimer = Input.GetButtonDown("Jump")
            ? jumpBufferTime : jumpBufferTimer - Time.fixedDeltaTime;

        if (jumpBufferTimer > 0 && coyoteTimer > 0)
        {
            vel = rb.velocity;
            vel.y = jumpVelocity;
            rb.velocity = vel;
            jumpBufferTimer = 0;
            coyoteTimer = 0;
        }
    }
}

3.3 MovePosition & Kinematic Bodies

// Moving platform using kinematic Rigidbody
using UnityEngine;

public class MovingPlatform : MonoBehaviour
{
    [SerializeField] private Transform pointA, pointB;
    [SerializeField] private float speed = 2f;

    private Rigidbody rb;
    private Vector3 target;

    private void Awake()
    {
        rb = GetComponent<Rigidbody>();
        rb.isKinematic = true;
        rb.interpolation = RigidbodyInterpolation.Interpolate;
        target = pointB.position;
    }

    private void FixedUpdate()
    {
        Vector3 newPos = Vector3.MoveTowards(
            rb.position, target, speed * Time.fixedDeltaTime);
        rb.MovePosition(newPos);

        if (Vector3.Distance(rb.position, target) < 0.01f)
            target = (target == pointA.position) ? pointB.position : pointA.position;
    }

    private void OnCollisionEnter(Collision col)
    {
        if (col.gameObject.CompareTag("Player")) col.transform.SetParent(transform);
    }

    private void OnCollisionExit(Collision col)
    {
        if (col.gameObject.CompareTag("Player")) col.transform.SetParent(null);
    }
}

4. Collision Detection

4.1 Continuous vs Discrete

4.2 Collision & Trigger Callbacks

// Complete collision and trigger callback reference
using UnityEngine;

public class CollisionHandler : MonoBehaviour
{
    [SerializeField] private GameObject impactEffect;
    [SerializeField] private float damageMultiplier = 1f;

    // --- COLLISION (isTrigger = false) ---
    private void OnCollisionEnter(Collision collision)
    {
        // Rich contact data: impact force, contact points, surface normal
        float impactForce = collision.impulse.magnitude;
        ContactPoint contact = collision.GetContact(0);

        Instantiate(impactEffect, contact.point,
            Quaternion.LookRotation(contact.normal));

        if (collision.gameObject.CompareTag("Enemy"))
        {
            var health = collision.gameObject.GetComponent<HealthComponent>();
            health?.TakeDamage(impactForce * damageMultiplier);
        }
    }

    private void OnCollisionStay(Collision collision)
    {
        // Every physics frame while touching. Use sparingly (expensive).
    }

    private void OnCollisionExit(Collision collision)
    {
        // Once when objects separate. Reset ground state, end effects.
    }

    // --- TRIGGERS (isTrigger = true) ---
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
            Debug.Log("Player entered the zone");
    }

    private void OnTriggerStay(Collider other)
    {
        // Every physics frame inside trigger. Good for DOT zones.
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
            Debug.Log("Player left the zone");
    }
}

5. Raycasting

Raycasting fires an invisible ray and reports what it hits -- a laser pointer that detects walls, enemies, and surfaces without any physical object moving through the scene.

5.1 Physics.Raycast & SphereCast

// Practical raycasting: weapon, ground check, explosion
using UnityEngine;

public class RaycastExamples : MonoBehaviour
{
    [SerializeField] private float weaponRange = 100f;
    [SerializeField] private float weaponDamage = 25f;
    [SerializeField] private LayerMask hitLayers;
    [SerializeField] private Camera playerCamera;

    // Hitscan weapon (instant bullet)
    public void FireWeapon()
    {
        Ray ray = playerCamera.ScreenPointToRay(
            new Vector3(Screen.width / 2f, Screen.height / 2f, 0));

        if (Physics.Raycast(ray, out RaycastHit hit, weaponRange, hitLayers))
        {
            if (hit.collider.TryGetComponent<HealthComponent>(out var health))
            {
                float mult = hit.collider.CompareTag("Head") ? 3f : 1f;
                health.TakeDamage(weaponDamage * mult);
            }
            Debug.DrawLine(ray.origin, hit.point, Color.green, 0.5f);
        }
    }

    // Ground check (SphereCast is more forgiving than Raycast)
    public bool IsGrounded()
    {
        return Physics.SphereCast(transform.position, 0.3f,
            Vector3.down, out _, 1.1f, hitLayers);
    }

    // Explosion radius
    public void Explode(Vector3 center, float radius, float force, float damage)
    {
        Collider[] hits = Physics.OverlapSphere(center, radius, hitLayers);
        foreach (var hit in hits)
        {
            float falloff = 1f - Vector3.Distance(center, hit.transform.position) / radius;

            if (hit.TryGetComponent<HealthComponent>(out var health))
                health.TakeDamage(damage * Mathf.Max(0, falloff));
            if (hit.TryGetComponent<Rigidbody>(out var rb))
                rb.AddExplosionForce(force, center, radius, 1f, ForceMode.Impulse);
        }
    }
}

5.2 LayerMask & Filtering

// LayerMask usage patterns
using UnityEngine;

public class LayerMaskGuide : MonoBehaviour
{
    [SerializeField] private LayerMask groundLayers;  // Inspector dropdown

    private void Examples()
    {
        // By name
        int mask = LayerMask.GetMask("Ground", "Platform", "Terrain");

        // Combine layers with bitwise OR
        int enemies = LayerMask.GetMask("Enemy");
        int destructibles = LayerMask.GetMask("Destructible");
        int combined = enemies | destructibles;

        // Invert: everything EXCEPT these layers
        int ignorePlayer = ~LayerMask.GetMask("Player", "PlayerProjectile");

        // Check object's layer
        if (gameObject.layer == LayerMask.NameToLayer("Enemy"))
            Debug.Log("This is an enemy!");
    }
}

5.3 Debug Visualization

// Physics debug visualization
using UnityEngine;

public class PhysicsDebugger : MonoBehaviour
{
    [SerializeField] private float rayDistance = 10f;
    [SerializeField] private float sphereRadius = 0.5f;

    private void Update()
    {
        // Debug.DrawRay -- visible in Scene view during Play mode
        Debug.DrawRay(transform.position, transform.forward * rayDistance, Color.green);

        if (Physics.Raycast(transform.position, transform.forward, out RaycastHit hit, rayDistance))
        {
            Debug.DrawLine(transform.position, hit.point, Color.green);
            Debug.DrawRay(hit.point, hit.normal, Color.red);
        }
    }

    // OnDrawGizmos -- always visible (even outside Play mode)
    private void OnDrawGizmos()
    {
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(transform.position, sphereRadius);
    }

    // OnDrawGizmosSelected -- only when this object is selected
    private void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.cyan;
        Gizmos.DrawWireSphere(transform.position, rayDistance);
    }
}

6. Advanced Physics

6.1 Joints: Hinge, Spring, Fixed

// Practical joint examples
using UnityEngine;

public class JointExamples : MonoBehaviour
{
    // Swinging door with auto-close spring
    public static void CreateSwingingDoor(GameObject door)
    {
        var hinge = door.AddComponent<HingeJoint>();
        hinge.axis = Vector3.up;
        hinge.anchor = new Vector3(-0.5f, 0, 0);

        hinge.useLimits = true;
        var limits = hinge.limits;
        limits.min = -90f;
        limits.max = 90f;
        hinge.limits = limits;

        hinge.useSpring = true;
        var spring = hinge.spring;
        spring.spring = 50f;
        spring.damper = 10f;
        spring.targetPosition = 0;
        hinge.spring = spring;
    }

    // Grappling hook connection
    public static SpringJoint CreateGrapple(GameObject player, Vector3 anchor, float length)
    {
        var spring = player.AddComponent<SpringJoint>();
        spring.autoConfigureConnectedAnchor = false;
        spring.connectedAnchor = anchor;
        spring.maxDistance = length;
        spring.minDistance = 0.5f;
        spring.spring = 80f;
        spring.damper = 7f;
        return spring;
    }

    // Breakable connection (OnJointBreak fires when force exceeded)
    public static void CreateBreakable(GameObject a, Rigidbody b, float breakForce)
    {
        var joint = a.AddComponent<FixedJoint>();
        joint.connectedBody = b;
        joint.breakForce = breakForce;
        joint.breakTorque = breakForce * 0.5f;
    }
}

6.2 Ragdoll Systems

A ragdoll is a physics-driven character: multiple Rigidbodies connected by CharacterJoints. On death, you switch from animation to ragdoll physics for unique, unrepeatable death animations.

// Ragdoll controller -- toggle between animated and physics states
using UnityEngine;

public class RagdollController : MonoBehaviour
{
    [SerializeField] private Animator animator;

    private Rigidbody[] ragdollBodies;
    private Collider[] ragdollColliders;
    private Rigidbody mainRb;
    private Collider mainCol;

    private void Awake()
    {
        ragdollBodies = GetComponentsInChildren<Rigidbody>();
        ragdollColliders = GetComponentsInChildren<Collider>();
        mainRb = GetComponent<Rigidbody>();
        mainCol = GetComponent<Collider>();
        SetRagdollActive(false);
    }

    public void ActivateRagdoll(Vector3 force, Vector3 hitPoint)
    {
        animator.enabled = false;
        mainRb.isKinematic = true;
        mainCol.enabled = false;
        SetRagdollActive(true);

        // Apply impact force to nearest bone
        Rigidbody closest = null;
        float minDist = float.MaxValue;
        foreach (var rb in ragdollBodies)
        {
            if (rb == mainRb) continue;
            float d = Vector3.Distance(rb.position, hitPoint);
            if (d < minDist) { minDist = d; closest = rb; }
        }
        closest?.AddForce(force, ForceMode.Impulse);
    }

    private void SetRagdollActive(bool active)
    {
        foreach (var rb in ragdollBodies)
            if (rb != mainRb) rb.isKinematic = !active;
        foreach (var col in ragdollColliders)
            if (col != mainCol) col.enabled = active;
    }
}

7. Case Studies

Exercises & Self-Assessment

Conclusion & Next Steps

You now have a comprehensive understanding of Unity's physics systems. Key takeaways:

• Two physics worlds: PhysX for 3D, Box2D for 2D. Never mix components.
• Rigidbody is the gateway: Use isKinematic for scripted movement that still triggers collisions.
• Collider choice matters: Prefer primitive colliders over MeshColliders. Triggers detect; collisions respond.
• ForceMode determines feel: VelocityChange for consistent jumps, Impulse for mass-dependent impacts.
• Custom gravity is essential: Asymmetric gravity + coyote time + jump buffering = great platformer feel.
• Raycasting is everywhere: Ground checks, weapons, interaction, explosions -- the swiss army knife.
• Joints and ragdolls add depth: Hinge joints for doors, spring joints for grapples, ragdolls for dynamic deaths.