🎯 Lesson 7.2: Hit Detection: Raycasts & Hitboxes

Two Styles of Hit Detection

Almost every attack in games is one of two shapes. A hitscan hit is a line: it travels instantly from a point in a direction and reports the first thing it strikes — bullets, laser sights, "is the enemy in front of me?" A volume hit is a shape: it asks "what is inside this region right now?" — a sword's arc, an explosion's radius, a shockwave.

Here is the difference at a glance, drawn as a top-down view of the same scene:

Different queries, same ending: once you have the collider you struck, you fetch its IDamageable and call TakeDamage. The interface from Lesson 7.1 is what makes all three attack styles converge on one line.

Hitscan with Physics.Raycast

Physics.Raycast shoots an invisible line from an origin along a direction and tells you what it hit through an out RaycastHit. For a gun, the origin is the muzzle (or camera) and the direction is where it points.

using UnityEngine;

public class HitscanWeapon : MonoBehaviour
{
    [SerializeField] Transform muzzle;      // where the shot originates
    [SerializeField] float range = 100f;
    [SerializeField] float damage = 25f;
    [SerializeField] LayerMask hittable;    // set in Inspector (see next section)

    public void Fire()
    {
        // out var hit captures what we struck
        if (Physics.Raycast(muzzle.position, muzzle.forward, out RaycastHit hit, range, hittable))
        {
            Debug.DrawLine(muzzle.position, hit.point, Color.red, 0.5f);   // visualise in Scene view

            // The whole point of Lesson 7.1: we don't care WHAT we hit
            hit.collider.GetComponent<IDamageable>()?.TakeDamage(damage);
        }
    }
}

Read the arguments left to right: from muzzle.position, along muzzle.forward, put the result in hit, only within range, and only against the hittable layers. The ?. means if the thing we hit is a wall (no IDamageable), nothing happens — no crash.

Layer Masks: Hitting Only What You Mean

Without a filter, a ray hits everything with a collider — including the player's own body, trigger volumes, and invisible geometry. A LayerMask tells the physics query which layers to consider and which to ignore.

First, put objects on layers (top-right Layer dropdown in the Inspector — add custom layers via Layer ▸ Add Layer…). Typical setup: an Enemy layer, a Player layer, an Environment layer. Then expose a LayerMask field and tick the layers you want in the Inspector:

[SerializeField] LayerMask hittable;   // tick "Enemy" and "Environment"

Passing that mask as the last argument of Physics.Raycast makes the ray sail straight through anything on an unticked layer. This is how a player's own collider never blocks their shot, and how you make a sniper round pass through a chain-link fence but stop on a wall.

💡 Building a mask in code. A LayerMask is really a bitmask. To build one from a name: int mask = LayerMask.GetMask("Enemy", "Environment");. To ignore a layer instead, invert it: ~LayerMask.GetMask("Player") means "everything except Player." The Inspector field is just a friendlier way to author the same bits.

Melee: Triggers & OverlapSphere

A sword doesn't fire a line — it sweeps through space and should hit everyone in its arc. There are two common approaches.

Approach A — a trigger collider hitbox

Give the weapon (or a child "blade" object) a collider with Is Trigger ticked, enabled only during the swing's contact frames (an Animation Event from Module 1 is perfect for turning it on and off). Anything that enters reports itself via OnTriggerEnter:

using System.Collections.Generic;
using UnityEngine;

public class MeleeHitbox : MonoBehaviour
{
    [SerializeField] float damage = 40f;
    // track who we've already hit this swing so one slash = one hit each
    readonly HashSet<IDamageable> hitThisSwing = new();

    void OnTriggerEnter(Collider other)
    {
        var target = other.GetComponent<IDamageable>();
        if (target == null || hitThisSwing.Contains(target)) return;

        hitThisSwing.Add(target);
        target.TakeDamage(damage);
    }

    // call this from an Animation Event at the start of each swing
    public void BeginSwing() => hitThisSwing.Clear();
}

The HashSet stops the classic bug where a slow swing registers the same enemy on several physics frames and shreds them instantly. Clear it at the start of every swing so each new attack can hit again.

Approach B — an instant OverlapSphere

For an explosion, a ground-pound, or a simple "hit everything in front of me" swing, you don't need a persistent collider at all. Physics.OverlapSphere returns every collider inside a sphere right now:

public void GroundPound()
{
    Collider[] hits = Physics.OverlapSphere(transform.position, 3f, hittable);
    foreach (Collider c in hits)
        c.GetComponent<IDamageable>()?.TakeDamage(damage);
}

One call, all targets in radius, then loop and damage each through the same interface. There is also Physics.OverlapBox for rectangular areas and OverlapCapsule for capsule shapes — pick the shape that matches your attack.

Projectiles in Brief

A projectile — a fireball, an arrow, a grenade — is a real GameObject with a Rigidbody that travels through the world and resolves its hit on contact. Because it is physical, you use collision callbacks rather than a query. Give it velocity when you spawn it, and let physics carry it:

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class Projectile : MonoBehaviour
{
    [SerializeField] float damage = 30f;
    [SerializeField] float speed = 20f;
    [SerializeField] float lifetime = 5f;

    void Start()
    {
        GetComponent<Rigidbody>().linearVelocity = transform.forward * speed;
        Destroy(gameObject, lifetime);   // clean up if it never hits anything
    }

    void OnCollisionEnter(Collision collision)
    {
        collision.collider.GetComponent<IDamageable>()?.TakeDamage(damage);
        Destroy(gameObject);             // consumed on impact
    }
}

Note linearVelocity — in Unity 6 the old Rigidbody.velocity was renamed to linearVelocity. Same idea: set the projectile's speed once and let the physics engine move it. When it touches anything, it deals damage through — you guessed it — the same IDamageable call.

Which style should you reach for?

Figure 2: Three detection methods for three attack shapes — all funnelling into the single interface call from Lesson 7.1.

Hands-on Challenge

Summary

🚀 What's Next?

Combat now works: you can hurt anything, any way. But an action game needs stuff — potions to heal, ammo to reload, weapons to swap. In Lesson 7.3: An Inventory System we return to Module 2's ScriptableObjects to model items as data assets, then build an Inventory that holds stackable slots and raises an event to refresh the UI.