About the importance of Components in Unreal

Components are one of the key features of the Unreal Engine, providing a modular and flexible way to add functionality to actors (and characters). By encapsulating specific functionality into components, code can be organized and managed in a more efficient way. In this article, we will explore the advantages of using components and how to implement them in your game.

Clean code

One of the main advantages of using components is that it allows you to avoid adding code to the Tick function and ending up with an extremely long (and hard to read) tick method. In addition, by encapsulating specific functionality into components, you can better control when and how that code is executed.

Reusable and aggregatable

Components are reusable pieces of functionality that can be easily added to actors and characters. By encapsulating specific functionality into a component, you can easily add it to multiple actors and characters, without having to rewrite the code. Components can also be aggregated on an actor, allowing for more complex behaviors to be built up from smaller, more focused components.

Easy search with FindComponentByClass

In Unreal, you can search for a component on an actor using the FindComponentByClass function. This allows you to access a specific component and modify its properties or behavior at runtime. By using this function, you can check if a such component exist on the actor and act accordinlgy.

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

	// Search for MyMovementComponent on the possessed pawn
	APawn* PossessedPawn = GetPawn();
	if (PossessedPawn)
	{
		MovementComponent = PossessedPawn->FindComponentByClass<UMyMovementComponent>();
	}
}

Conclusion

In conclusion, using components is an important part of developing games in Unreal. By encapsulating functionality into modular components, you can better manage the complexity of your codebase, make it more efficient, and make it easier to collaborate with other developers. By using the FindComponentByClass function, you can easily search for and modify specific components at runtime, making it easier to create dynamic and flexible gameplay.

Quick example to illustrate this article

MyMovementComponent.h:

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "MyMovementComponent.generated.h"

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class MYPROJECT_API UMyMovementComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UMyMovementComponent();

    UPROPERTY(EditAnywhere, Category = "Movement")
    float MoveSpeed;

    UPROPERTY(EditAnywhere, Category = "Movement")
    float JumpForce;

    void MoveForward(float Value);
    void MoveRight(float Value);
    void Jump();
};

MyMovementComponent.cpp:

#include "MyMovementComponent.h"

UMyMovementComponent::UMyMovementComponent()
{
    // Set default movement values
    MoveSpeed = 100.f;
    JumpForce = 100.f;
}

void UMyMovementComponent::MoveForward(float Value)
{
    // Move the actor forward/backward based on input value
    FVector Direction = FVector(1.f, 0.f, 0.f);
    GetOwner()->AddMovementInput(Direction, Value * MoveSpeed);
}

void UMyMovementComponent::MoveRight(float Value)
{
    // Move the actor right/left based on input value
    FVector Direction = FVector(0.f, 1.f, 0.f);
    GetOwner()->AddMovementInput(Direction, Value * MoveSpeed);
}

void UMyMovementComponent::Jump()
{
    // Jump the actor
    GetOwner()->LaunchCharacter(FVector(0.f, 0.f, JumpForce), false, false);
}