Golden Shells: Subclass + override for Polymorphic Pickups

Coral the flamingo has been watching you stack up wins on South Shores: you can wire a button, push a HUD message, count shells in a var, and keep your functions to one responsibility each. Today she struts up with something shiny tucked under one wing — a golden shell — and your first real taste of object-oriented Verse. You'll write a base shell class, then a golden_shell subclass that uses the <override> specifier to change what happens on pickup, while the collection code never has to know which shell it just handled. That trick has a grown-up name — polymorphism — but on this beach we just call it "the rare one plays by richer rules."

What you will build

The Shell-Hunt capstone (lesson 17) needs one rare golden shell worth 3 points with a bonus effect, collected through the same code path as every ordinary shell. That's exactly what you build here:

• A base shell class with an OnCollected() : int method — the ordinary 1-point pickup.
• A golden_shell subclass that marks OnCollected<override>() to return 3 points and fire a sparkle VFX burst.
• A collector device that keeps every shell in one []shell array and calls OnCollected() without a single if this is golden check.

When Shell-Hunt's CollectShell() handler later scoops up whatever the player found, the golden shell quietly does its own thing — no special cases, no duplicate wiring.

Walkthrough

Step 1 — Place the devices

In your South Shores project:

1. Place a Button device on the sand (our stand-in for "player grabbed a shell" — lesson 4's trigger zones take over in the capstone).
2. Place a HUD Message device to announce the running score.
3. Place a VFX Spawner device set to a burst effect — the golden shell's little firework moment.
4. Create a new Verse file (shell_collector.verse), paste the code below, build, and wire the three @editable slots in the Details panel. The GoldenShell slot expands so you can point its SparkleVFX at the VFX Spawner.

Step 2 — The code

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# ── Base class: an ordinary beach shell, worth 1 point ──
shell := class:
    # Every shell knows how to be collected. Returns the points earned.
    OnCollected() : int =
        Print("Shell collected: +1 point")
        1

# ── Rare subclass: the golden shell — 3 points and a sparkle burst ──
golden_shell := class<concrete>(shell):
    @editable
    SparkleVFX : vfx_spawner_device = vfx_spawner_device{}

    # <override> replaces the base behaviour — same name, same signature.
    OnCollected<override>() : int =
        SparkleVFX.Restart()   # burst-mode VFX celebrates the rare find
        Print("GOLDEN shell: +3 points!")
        3

# ── The collector device placed on the island ──
shell_collector_device := class(creative_device):

    @editable
    CollectButton : button_device = button_device{}

    @editable
    ScoreHUD : hud_message_device = hud_message_device{}

    @editable
    GoldenShell : golden_shell = golden_shell{}

    var Score : int = 0
    var NextShell : int = 0
    var BeachShells : []shell = array{}

    OnBegin<override>()<suspends>:void =
        # One array, mixed types — the golden shell hides among plain ones.
        set BeachShells = array{shell{}, shell{}, GoldenShell, shell{}}
        CollectButton.InteractedWithEvent.Subscribe(OnCollect)

    # ONE shared collection path for EVERY shell type.
    OnCollect(Agent : agent) : void =
        if (Found := BeachShells[NextShell]):
            Points := Found.OnCollected()   # dispatches to the REAL type
            set Score += Points
            set NextShell += 1
            ScoreHUD.SetText(ScoreMsg(Score))
            ScoreHUD.Show(Agent)

ScoreMsg<localizes>(Points : int) : message = "Shells banked: {Points} points"

Step 3 — Line by line

Step 4 — Test it

Launch a session and press the button four times. The first two presses bank 1 point each. The third press is the golden shell: the VFX bursts and the HUD jumps by 3. The fourth banks 1 again. Notice what you did not write: OnCollect has zero golden-shell logic in it. The subclass carried its own rules into the shared path — that's polymorphism doing the lifting.

Common patterns

Pattern 1 — Override the data, inherit the behaviour

Sometimes the subclass only changes a number, not the logic. Verse lets you override a field with <override> and keep the inherited method, which now reads the new value:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

beach_shell := class:
    Points : int = 1
    OnCollected() : int =
        Print("Collected: +{Points}")
        Points

golden_beach_shell := class(beach_shell):
    # Override the DATA, inherit the behaviour.
    Points<override> : int = 3

field_override_demo_device := class(creative_device):
    OnBegin<override>()<suspends>:void =
        Shells : []beach_shell = array{beach_shell{}, golden_beach_shell{}}
        for (S : Shells):
            S.OnCollected()

golden_beach_shell never redefines OnCollected — it just swaps Points to 3 and the inherited method does the rest. Smallest possible subclass, same polymorphic payoff.

Pattern 2 — Tally a whole beach polymorphically

The capstone will ask "how many points is this beach worth?" One loop over the base type answers it, no matter how the rares are sprinkled in:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

tide_shell := class:
    OnCollected() : int = 1

golden_tide_shell := class(tide_shell):
    OnCollected<override>() : int = 3

tide_pool_tally_device := class(creative_device):
    OnBegin<override>()<suspends>:void =
        Beach : []tide_shell = array{tide_shell{}, golden_tide_shell{}, tide_shell{}}
        var Total : int = 0
        for (S : Beach):
            set Total += S.OnCollected()
        Print("This beach is worth {Total} points")

Add a pearl_shell worth 10 tomorrow and this tally code doesn't change by one character. That's the extensibility you're buying with <override>.

Where this goes next

• Lesson 16 — Powerup Pickups upgrades the golden shell's bonus effect from a sparkle to a real speed powerup, so finding the rare one makes you faster at finding the rest.
• Lesson 17 — the Shell-Hunt capstone drops your shell / golden_shell pair into the full 90-second beach scavenger: Verse-spawned bobbing shell props, trigger-zone pickups, and one shared CollectShell() handler that calls exactly the OnCollected() you wrote today. The capstone also imports your ShellHuntKit module from lesson 9 — so keep these classes tidy; they're about to become residents.

Coral's parting wisdom, delivered on one leg: "When the rare one shows up, don't rewrite the beach — just let it override the rules."