📝 Lesson 2.2: Physics and Collisions

Rigidbody + Collider

Physics in Unity is a partnership between two components. Neither does the job alone:

Add a Rigidbody to a cube above a floor, press Play, and it falls and lands — no code required. Primitive objects (Cube, Sphere) already come with a matching Collider; empty objects and imported models you add one to yourself.

Moving with Physics

Lesson 2.1 warned: don't set the Transform of a physics object — it teleports past colliders. Instead you tell the Rigidbody what to do, and it moves the object through the world, respecting collisions. There are three main ways, and all belong in FixedUpdate (the physics step, Lesson 1.2).

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class BallController : MonoBehaviour
{
    [SerializeField] private float moveForce = 10f;
    private Rigidbody body;
    private Vector2 input;

    void Awake() => body = GetComponent<Rigidbody>();

    void Update()
    {
        // Read input every frame (Lesson 1.2 rule)…
        input.x = Input.GetAxisRaw("Horizontal");
        input.y = Input.GetAxisRaw("Vertical");
    }

    void FixedUpdate()
    {
        // …but APPLY physics on the fixed step.
        Vector3 force = new Vector3(input.x, 0f, input.y) * moveForce;
        body.AddForce(force);
    }
}

💡 Read in Update, apply in FixedUpdate. Notice the split above: input is polled in Update (so no press is missed) and stored, then the stored value drives the physics in FixedUpdate. This is the pattern promised back in Lesson 1.2, now in action.

Collision Callbacks

When two solid colliders touch, Unity calls event functions on both objects' scripts — just like the lifecycle messages from Lesson 1.2, but triggered by contact. The three collision messages:

public class Crate : MonoBehaviour
{
    void OnCollisionEnter(Collision collision)
    {
        // 'collision' describes WHAT we hit and HOW.
        Debug.Log($"Hit by {collision.gameObject.name}");

        // Contact details are available too:
        float impact = collision.relativeVelocity.magnitude;
        if (impact > 5f)
            Debug.Log("That was a hard hit!");
    }
}

Triggers: Detect Without Blocking

Sometimes you want to know something entered an area without physically stopping it — a coin to collect, a checkpoint, a damage zone. That's a trigger: tick Is Trigger on the collider, and it stops being solid but still reports overlaps through a separate set of callbacks.

public class Coin : MonoBehaviour
{
    // Note: OnTriggerEnter takes a Collider, NOT a Collision.
    void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            Debug.Log("Coin collected!");
            Destroy(gameObject);   // remove the coin (Lesson 1.1)
        }
    }
}

💡 Triggers also have Stay/Exit: OnTriggerStay(Collider) and OnTriggerExit(Collider) mirror the collision versions — great for "while inside the damage zone" or "left the safe area."

Who Needs a Rigidbody?

Here's the rule that trips up nearly every beginner: for collision/trigger callbacks to fire, at least one of the two objects in the contact must have a Rigidbody. Two purely static colliders touching produce no callbacks — the physics engine isn't simulating either of them.

In the example above, the coin has no Rigidbody, yet the trigger still fires — because the player that walked into it does. That's the usual arrangement: the moving thing (player, projectile) carries the Rigidbody; static pickups and zones just have a trigger collider.

Reacting to the Right Objects

A trigger fires for anything that enters it. Usually you only care about specific things — a coin should react to the player, not to a stray crate. Two tools filter contacts:

Tags — identify individual objects

A tag is a label you assign in the Inspector ("Player", "Enemy", "Coin"). Check it with CompareTag:

void OnTriggerEnter(Collider other)
{
    if (!other.CompareTag("Player")) return;   // ignore everything else
    Collect();
}

Layers — group objects for the physics engine

A layer groups objects so physics can decide, via the Layer Collision Matrix (Project Settings → Physics), which layers even interact. Put projectiles on a "PlayerBullets" layer that only collides with "Enemies," and enemy-to-enemy or bullet-to-bullet contacts are skipped entirely — cheaper and simpler than filtering in code.

💡 Rule of thumb: use tags to identify a specific object inside a callback, and layers to stop unwanted collisions from happening at all. Filtering with layers is more efficient because those contacts are never even generated.

Exercise & Quiz

using UnityEngine;

public class Coin : MonoBehaviour
{
    void OnTriggerEnter(Collider other)
    {
        // TODO: if 'other' is tagged "Player", destroy this coin.
    }
}

using UnityEngine;

public class Coin : MonoBehaviour
{
    [SerializeField] private int value = 1;

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

        Debug.Log($"Collected coin worth {value}");
        Destroy(gameObject);
    }
}

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class BallController : MonoBehaviour
{
    [SerializeField] private float moveForce = 10f;
    private Rigidbody body;
    private Vector2 input;

    void Awake() => body = GetComponent<Rigidbody>();

    void Update()
    {
        input.x = Input.GetAxisRaw("Horizontal");
        input.y = Input.GetAxisRaw("Vertical");
    }

    void FixedUpdate()
    {
        body.AddForce(new Vector3(input.x, 0f, input.y) * moveForce);
    }

    // Optional: log solid hits with crates.
    void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.CompareTag("Crate"))
            Debug.Log($"Pushed {collision.gameObject.name}");
    }
}

Summary

📚 Additional Resources

• Scripting Reference — Rigidbody
• Scripting Reference — OnCollisionEnter
• Scripting Reference — OnTriggerEnter
• Manual — Colliders & the collision action matrix

🚀 What's Next?

Objects now collide and react — but our coins were placed by hand. In Lesson 2.3, Instantiating and Destroying Objects, we spawn objects at runtime from prefabs (fire bullets, spawn enemies) and manage their lifecycle cleanly.