Unreal Engine 5 C++: Make Your Own Action Combat Game

Unreal Engine 5 C++: Make Your Own Action Combat Game

Unreal Engine 5 (UE5) has taken game development to new heights with its stunning graphical capabilities, optimized performance, and flexibility. 

Enroll Now

For developers aiming to build action combat games, the blend of Blueprint scripting and C++ coding provides a powerful toolkit. This combination allows for both rapid prototyping and deep customization. In this guide, we will focus on leveraging C++ in UE5 to build the foundations of an action combat game, walking through the essential mechanics like movement, attacks, combos, health systems, and more.

Setting Up Your Unreal Engine 5 Project

To get started, you’ll need to set up a new Unreal Engine 5 project. Open the Epic Games Launcher, go to the Unreal Engine tab, and create a new project. Select the "Games" category, then choose a "Blank" or "Third-Person Template" for a faster setup. We will be using C++, so ensure the C++ option is selected rather than Blueprints.

After creating the project, UE5 will generate the necessary folders and files, including your Source directory, which contains your main C++ code files.

Creating Your Character Class

The core of any action combat game is the player character. We’ll start by creating a custom C++ character class to define movement, combat abilities, and other player-related mechanics.

1. Create a New C++ Class: In the Unreal Engine Editor, navigate to the "File" menu, select "New C++ Class," and choose Character as the parent class. Name it something appropriate like CombatCharacter. This class will inherit from ACharacter, which comes with movement functionality.

   cpp
   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Character.h"
   #include "CombatCharacter.generated.h"
   
   UCLASS()
   class MYCOMBATGAME_API ACombatCharacter : public ACharacter
   {
       GENERATED_BODY()
   
   public:
       ACombatCharacter();
   
       // Declare attack function
       UFUNCTION(BlueprintCallable, Category="Combat")
       void Attack();
   };
   

2. Implement Movement Controls: After creating the class, navigate to the CombatCharacter.cpp file. In this file, we will bind the character’s movement to player inputs like walking, running, and jumping.

   cpp
   void ACombatCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
   {
       Super::SetupPlayerInputComponent(PlayerInputComponent);
   
       PlayerInputComponent->BindAxis("MoveForward", this, &ACombatCharacter::MoveForward);
       PlayerInputComponent->BindAxis("MoveRight", this, &ACombatCharacter::MoveRight);
       PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
       PlayerInputComponent->BindAction("Attack", IE_Pressed, this, &ACombatCharacter::Attack);
   }
   
   void ACombatCharacter::MoveForward(float Value)
   {
       if (Controller && Value != 0.0f)
       {
           // Get forward direction
           const FRotator Rotation = Controller->GetControlRotation();
           const FRotator YawRotation(0, Rotation.Yaw, 0);
           const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
           AddMovementInput(Direction, Value);
       }
   }
   
   void ACombatCharacter::MoveRight(float Value)
   {
       if (Controller && Value != 0.0f)
       {
           // Get right direction
           const FRotator Rotation = Controller->GetControlRotation();
           const FRotator YawRotation(0, Rotation.Yaw, 0);
           const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
           AddMovementInput(Direction, Value);
       }
   }
   

   In this code, the SetupPlayerInputComponent function binds the axis mappings (like forward/backward movement) and action mappings (like jump and attack) to the corresponding functions. The MoveForward and MoveRight methods use the player’s input to move the character accordingly.

Implementing Combat Mechanics

Now that basic movement is in place, let's implement the core combat mechanics. This includes defining an attack function and setting up a combo system to make the combat feel fluid.

1. Simple Attack

In your CombatCharacter.h file, declare the attack logic that can be triggered by the player pressing a key.

cpp
void Attack();

Then, implement the Attack() method in your CombatCharacter.cpp file. This function will later evolve into a more complex combo system, but for now, it will perform a simple attack animation.

cpp
void ACombatCharacter::Attack()
{
    if (CanAttack())
    {
        // Play attack animation
        if (AttackMontage)
        {
            PlayAnimMontage(AttackMontage);
        }
        // Apply damage or effects here
    }
}

The Attack() method checks if the character is allowed to attack by calling CanAttack() and then triggers an attack animation montage. Montages in Unreal Engine allow for a sequence of animations, perfect for chaining combo attacks.

2. Combo System

For action combat games, a smooth combo system is vital. We can achieve this by linking several attack animations and transitioning between them based on timing and player input.

• Variables for Combo System:

In the CombatCharacter.h file, add the following member variables:

cpp
private:
   int32 ComboIndex;
   bool bIsComboActive;
   FTimerHandle ComboResetTimer;

protected:
   void ResetCombo();
   UFUNCTION(BlueprintCallable, Category="Combat")
   bool CanAttack() const;

The ComboIndex tracks the current combo position, bIsComboActive checks if the combo chain is still active, and the timer ensures that combos reset if the player pauses.

• Implementing the Combo Logic:

Now, in your Attack function, you can enhance the logic for handling different combos.

cpp
void ACombatCharacter::Attack()
{
    if (CanAttack())
    {
        // Play combo based on ComboIndex
        if (AttackMontage)
        {
            switch (ComboIndex)
            {
                case 0:
                    PlayAnimMontage(FirstAttackMontage);
                    break;
                case 1:
                    PlayAnimMontage(SecondAttackMontage);
                    break;
                case 2:
                    PlayAnimMontage(ThirdAttackMontage);
                    break;
                default:
                    ResetCombo();
                    break;
            }
            ComboIndex++;
            bIsComboActive = true;

            // Reset combo after a delay
            GetWorldTimerManager().SetTimer(ComboResetTimer, this, &ACombatCharacter::ResetCombo, 1.5f, false);
        }
    }
}

void ACombatCharacter::ResetCombo()
{
    ComboIndex = 0;
    bIsComboActive = false;
}

bool ACombatCharacter::CanAttack() const
{
    return !bIsComboActive || ComboIndex < MaxCombo;
}

With this setup, when the player presses the attack button repeatedly, different animations play in sequence, forming a combo. The ResetCombo() method ensures that the combo is reset if the player waits too long between attacks.

Health and Damage System

A good action game needs a health and damage system for both the player and enemies. Let’s implement a basic health system in C++.

1. Adding Health Variables

In CombatCharacter.h, add variables to store the character’s health:

cpp
protected:
   UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats")
   float MaxHealth;

   UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Stats")
   float CurrentHealth;

public:
   UFUNCTION(BlueprintCallable, Category="Health")
   void TakeDamage(float DamageAmount);

2. Implementing the Damage Logic

In CombatCharacter.cpp, implement the TakeDamage() function, which will reduce the character’s health and handle the death logic:

cpp
void ACombatCharacter::TakeDamage(float DamageAmount)
{
    CurrentHealth -= DamageAmount;

    if (CurrentHealth <= 0.0f)
    {
        Die();
    }
}

void ACombatCharacter::Die()
{
    // Play death animation, disable movement, etc.
}

When the player or enemy takes damage, the TakeDamage() function decreases health and triggers death if health reaches zero.

Final Touches and Optimization

At this point, you have the foundation for a basic action combat game. You can expand the system by adding additional mechanics like special attacks, enemy AI, blocking, and dodge rolls. You can also tweak animations, add visual effects like particle systems, and optimize performance for smooth gameplay. By incorporating Blueprint scripting alongside your C++ logic, you can quickly test out new ideas and create dynamic, engaging combat mechanics.

Conclusion

Building an action combat game in Unreal Engine 5 using C++ allows for deep control over game mechanics, from movement and attacks to combo systems and health management. While Blueprints can handle much of this functionality, combining it with C++ enables you to optimize, customize, and scale your game effectively. With UE5's powerful rendering and physics capabilities, your action combat game can be not only mechanically engaging but also visually stunning.

How To Get A Job In The Video Game Industry Udemy