🗡️ Lesson 7.4: Pickups & Equipping (Mini-Project)

The Loop We're Building

Everything in this lesson is glue between systems you already own. Here is the whole flow at a glance — notice how each arrow lands on a piece from an earlier lesson:

Figure 1: The Module 7 loop. Pickups feed the inventory (7.3), equipping sets the damage a hitscan attack (7.2) deals through IDamageable (7.1), and dropping closes the circle.

World Pickups

A pickup is a GameObject in the world carrying an ItemData reference and a trigger collider. When the player walks into it, it adds itself to their inventory and disappears. Because we return the leftover from Add, we can even handle a bag that's almost full.

using UnityEngine;

[RequireComponent(typeof(Collider))]
public class Pickup : MonoBehaviour
{
    [SerializeField] ItemData item;
    [SerializeField] int amount = 1;

    void Reset()
    {
        // convenience: make the collider a trigger the moment you add this
        GetComponent<Collider>().isTrigger = true;
    }

    void OnTriggerEnter(Collider other)
    {
        // only the player picks things up
        if (!other.TryGetComponent<Inventory>(out var inventory)) return;

        int leftover = inventory.Add(item, amount);

        if (leftover == 0)
            Destroy(gameObject);          // fully collected
        else
            amount = leftover;            // bag was full — leave the rest on the ground
    }
}

That is the entire pickup. It knows nothing about the UI, damage, or equipping — it just calls Inventory.Add (Lesson 7.3) and trusts the event to refresh the grid. If the bag couldn't take everything, the pickup keeps the remainder so the player can come back for it. Below is what the moment of pickup looks like: the item leaves the world and its icon lands in the next free slot.

Equipping: Items with Effects

Some items don't just sit in the bag — you use them. A weapon changes your damage; armor changes your defense. We extend the data model so an item can describe its effect. The cleanest approach that fits this course: make a WeaponItemData that inherits from ItemData and adds the numbers a weapon needs.

using UnityEngine;

[CreateAssetMenu(fileName = "New Weapon", menuName = "Inventory/Weapon")]
public class WeaponItemData : ItemData
{
    [Header("Weapon")]
    public float damage = 25f;
    public float range = 100f;
}

Because WeaponItemData is an ItemData, it slots into the same inventory with no changes — the potion and the sword live side by side in the grid. When the player equips one, an Equipment component remembers it and applies its stats:

using System;
using UnityEngine;

public class Equipment : MonoBehaviour
{
    public WeaponItemData EquippedWeapon { get; private set; }
    public event Action<WeaponItemData> OnWeaponChanged;

    public void Equip(ItemData item)
    {
        // only weapons can be equipped
        if (item is not WeaponItemData weapon) return;

        EquippedWeapon = weapon;
        OnWeaponChanged?.Invoke(weapon);   // UI / model swap can react
        Debug.Log($"Equipped {weapon.displayName} ({weapon.damage} dmg)");
    }

    public void Unequip()
    {
        EquippedWeapon = null;
        OnWeaponChanged?.Invoke(null);
    }
}

The is not WeaponItemData weapon pattern (C# pattern matching) both checks the type and gives you the typed variable in one line — a potion silently fails to equip, a weapon goes through. Equipping raises OnWeaponChanged so a HUD icon or a visible weapon model can swap, following the same event discipline as the rest of the module.

Equipped Weapon Drives Damage

Here is the payoff that ties combat to inventory. In Lesson 7.2 the HitscanWeapon had a fixed damage. Now it asks the Equipment component what's equipped and uses that weapon's numbers — so picking up and equipping a better sword genuinely makes you hit harder.

using UnityEngine;

public class PlayerAttack : MonoBehaviour
{
    [SerializeField] Transform muzzle;
    [SerializeField] LayerMask hittable;
    [SerializeField] Equipment equipment;
    [SerializeField] float unarmedDamage = 5f;   // fists, when nothing equipped

    // call from an Input Action (Module 3), e.g. on Attack performed
    public void Attack()
    {
        var weapon = equipment.EquippedWeapon;
        float damage = weapon != null ? weapon.damage : unarmedDamage;
        float range  = weapon != null ? weapon.range  : 2f;

        if (Physics.Raycast(muzzle.position, muzzle.forward, out RaycastHit hit, range, hittable))
            hit.collider.GetComponent<IDamageable>()?.TakeDamage(damage);   // 7.1 + 7.2
    }
}

Read what just happened: the pickup filled the inventory (7.3), equipping chose a weapon, and the attack pulled that weapon's damage into the exact raycast-plus-IDamageable call from Lessons 7.1 and 7.2. Four lessons, one line of consequence. Unarmed you poke for 5 at 2 units; equip the sword and you swing for 25 at its range.

Dropping Items

Dropping closes the loop: remove one from the inventory and spawn a pickup back in the world in front of the player. It reuses Inventory.Remove (7.3) and the same Pickup prefab pickups already use.

using UnityEngine;

public class ItemDropper : MonoBehaviour
{
    [SerializeField] Inventory inventory;
    [SerializeField] Pickup pickupPrefab;   // a generic pickup we configure per-drop
    [SerializeField] Transform dropPoint;   // slightly in front of the player

    public void Drop(ItemData item)
    {
        if (!inventory.Remove(item, 1)) return;   // nothing to drop

        var dropped = Instantiate(pickupPrefab, dropPoint.position, Quaternion.identity);
        dropped.Configure(item, 1);               // small setter on Pickup
    }
}

Add a tiny Configure(ItemData, int) method to Pickup that sets its item and amount so a dropped item becomes a valid world pickup again — walk back over it and it re-enters the bag. That symmetry (drop spawns the very thing pickups consume) is what makes the world feel consistent.

💡 Save it for later. Because items are ScriptableObjects and slots are [Serializable], this whole inventory is ready for Module 5's JSON save system — you'd store each slot's item id and count, and rebuild the list on load. Data-driven design pays off across modules.

Mini-Project: The Full Loop

Put it all together into a small playable scene. This is the deliverable for Module 7.

1. Scene setup: a floor, your player (with Inventory, Equipment, PlayerAttack, ItemDropper, and a Rigidbody or CharacterController), and the inventory grid UI from Lesson 7.3.
2. Author items: a HealthPotion (ItemData) and a Sword (WeaponItemData, 25 damage). Place a few Pickup objects around the floor referencing them.
3. Targets: drop in a couple of Barrels and an Enemy from Lesson 7.1, each with a Health component and a health bar.
4. Wire input (Module 3): move the player, an Attack action, an Equip action (equip the first weapon found in the inventory), and a Drop action.
5. Play the loop: walk over pickups → they appear in the grid → equip the sword → attack a barrel and watch it take 25 (not 5) → drop the potion and see it reappear on the floor.

Hands-on Challenge

Summary

🚀 What's Next?

That wraps Module 7 — your game can now hurt things, hold things, and let the player gear up. You've spent two systems-heavy modules (AI, then Combat & Inventory) making games work. Next we make them look the part. In Lesson 8.1: URP Lighting: Real-time & Baked we open the Graphics track: light types, real-time vs. baked lighting, and how URP turns a flat gray scene into one with mood and depth.