C++ in Unreal Engine 5 for Complete Beginners: Build Your First Collectible

What is C++?

C++ is a programming language used to describe rules and behavior. In a game, those rules can decide how a character moves, when an enemy takes damage, what happens when an item is collected, or how a save file is written.

Think of code as a precise set of instructions. Unreal Engine provides the rendering, physics, animation, audio, editor, and many ready-made systems. Your C++ classes tell those systems what your game should do.

How Unreal Engine uses C++

Unreal C++ is normal C++ combined with Unreal-specific classes and macros. The most important beginner concepts are:

• Class: a reusable definition. For example, a collectible class describes what every collectible can do.
• Object: one real instance of that class inside the game.
• Actor: an Unreal object that can be placed or spawned in a level.
• Component: one part of an Actor, such as a mesh, collision shape, camera, or movement behavior.
• UPROPERTY: tells Unreal that a variable should participate in reflection, the editor, serialization, or other engine systems.
• UFUNCTION: tells Unreal that a function participates in engine features such as overlap events.

Actors can own a hierarchy of components, and their root component provides the transform used for location, rotation, and scale. That is why our collectible will be one Actor made from several components.

What you will build

This is small, but it uses the same core ideas found in larger systems: classes, components, editor properties, events, and runtime behavior.

Step 1: create a C++ project

1. Open Unreal Engine.
2. Create a new Games project.
3. Choose a Blank template.
4. Select C++ instead of Blueprint.
5. Name the project something simple, such as BeginnerCppGame.
6. Create the project and allow Unreal to generate the source files.

Step 2: create the Actor class

1. In Unreal Editor, open Tools → New C++ Class.
2. Select Actor as the parent class.
3. Name the class RotatingCollectible.
4. Create the class and open the generated files in Visual Studio or Rider.

Unreal creates two important files:

Step 3: replace the header file

Open RotatingCollectible.h, remove its current contents, and paste this code.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "RotatingCollectible.generated.h"

class UPrimitiveComponent;
class USphereComponent;
class UStaticMeshComponent;
class URotatingMovementComponent;
struct FHitResult;

UCLASS()
class ARotatingCollectible : public AActor
{
    GENERATED_BODY()

public:
    ARotatingCollectible();

protected:
    virtual void BeginPlay() override;

private:
    UPROPERTY(VisibleAnywhere, Category = "Collectible")
    TObjectPtr<UStaticMeshComponent> Mesh;

    UPROPERTY(VisibleAnywhere, Category = "Collectible")
    TObjectPtr<USphereComponent> Trigger;

    UPROPERTY(VisibleAnywhere, Category = "Collectible")
    TObjectPtr<URotatingMovementComponent> RotatingMovement;

    UPROPERTY(EditAnywhere, Category = "Collectible", meta = (ClampMin = "0.0"))
    float RotationSpeed = 90.0f;

    UFUNCTION()
    void HandleOverlap(
        UPrimitiveComponent* OverlappedComponent,
        AActor* OtherActor,
        UPrimitiveComponent* OtherComponent,
        int32 OtherBodyIndex,
        bool bFromSweep,
        const FHitResult& SweepResult
    );
};

Step 4: replace the source file

Open RotatingCollectible.cpp, remove its current contents, and paste this code.

#include "RotatingCollectible.h"

#include "Components/SphereComponent.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/RotatingMovementComponent.h"

ARotatingCollectible::ARotatingCollectible()
{
    PrimaryActorTick.bCanEverTick = false;

    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    SetRootComponent(Mesh);
    Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);

    Trigger = CreateDefaultSubobject<USphereComponent>(TEXT("Trigger"));
    Trigger->SetupAttachment(Mesh);
    Trigger->SetSphereRadius(90.0f);
    Trigger->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    Trigger->SetCollisionResponseToAllChannels(ECR_Ignore);
    Trigger->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
    Trigger->OnComponentBeginOverlap.AddDynamic(
        this,
        &ARotatingCollectible::HandleOverlap
    );

    RotatingMovement = CreateDefaultSubobject<URotatingMovementComponent>(
        TEXT("RotatingMovement")
    );
}

void ARotatingCollectible::BeginPlay()
{
    Super::BeginPlay();

    RotatingMovement->RotationRate = FRotator(
        0.0f,
        RotationSpeed,
        0.0f
    );
}

void ARotatingCollectible::HandleOverlap(
    UPrimitiveComponent* OverlappedComponent,
    AActor* OtherActor,
    UPrimitiveComponent* OtherComponent,
    int32 OtherBodyIndex,
    bool bFromSweep,
    const FHitResult& SweepResult
)
{
    if (!IsValid(OtherActor) || OtherActor == this)
    {
        return;
    }

    UE_LOG(
        LogTemp,
        Display,
        TEXT("Collectible picked up by %s"),
        *OtherActor->GetName()
    );

    Destroy();
}

Step 5: compile and use the collectible

1. Save both files.
2. Build the project from Visual Studio or Rider. For small implementation changes, Live Coding may also work, but after reflected class-layout changes it is safer to rebuild and restart the Editor.
3. Return to Unreal Editor.
4. Find RotatingCollectible under the project C++ Classes folder.
5. Right-click it and create a Blueprint child named BP_RotatingCollectible.
6. Open that Blueprint child and select the Mesh component.
7. Assign any Static Mesh, such as a cube, sphere, coin, or crystal.
8. Drag BP_RotatingCollectible into the level.
9. Press Play and walk into it.

What the code is doing

The class does not use Tick(). Unreal’s rotating movement component performs the continuous rotation, which keeps the example simple and avoids unnecessary per-frame code.

Common beginner errors

Your next challenge: make collectibles worth points

Add this property inside the class, next to RotationSpeed:

UPROPERTY(EditAnywhere, Category = "Collectible", meta = (ClampMin = "1"))
int32 Points = 10;

Now every collectible can have a different value in the Editor. The next proper step would be to create a score component or player-state system and send the point value to it before calling Destroy().

Official Unreal Engine references

• Unreal Engine C++ Quick Start
• Actors in Unreal Engine
• Components in Unreal Engine
• Unreal Engine UProperties