Collisions and Damage in UE5 | Combat in Adfectus

#pragma once

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

// We define a weapon as an Actor class 
// so that we can place and move it in the world
UCLASS()
class CPPTHIRDPERSON_API AWeapon : public AActor
{
	GENERATED_BODY()

private:
    // Determines when should the weapon deal damage
	bool DealsDamage;

protected:
	// Called when the game starts or when spawned
    // It is where we will bind the collisions to their functions.
	virtual void BeginPlay() override;

public:
	// Sets default values for this actor's properties
    // It is were we initialize the mesh component.
	AWeapon();

	/** Mesh used to store the mesh that represents the weapon */
	UPROPERTY(Category = Weapon, VisibleAnywhere, BlueprintReadOnly, meta = (AllowPrivateAccess = "true"))
	class UStaticMeshComponent* WeaponMesh;

    // Function that detects a block collision with an object
	UFUNCTION(Category = Character)
	void OnHit(AActor *SelfActor, AActor *OtherActor, FVector NormalImpulse, const FHitResult &Hit);

    // Function that detects an overlap with an object
	UFUNCTION(Category = Character)
	void OnBeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp,
	                    int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

    // Amount of damage to deal when something is hit.
	UPROPERTY(Category = Weapon, EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "0", UIMin = "0"))
	float Damage = 10;
    
    // Function called to set if the weapon is dealing damage or not.
	UFUNCTION(Category = Weapon)
	void SetDealsDamage(bool dealsDamage);
};

#include "Weapon.h"
#include "Components/StaticMeshComponent.h"

// Sets default values
AWeapon::AWeapon()
{
    //... some code ...
  
    // Create the component and add it to the weapon actor.
	WeaponMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Weapon Mesh"));
    // Set it's collision profile. More on this later.
	WeaponMesh->SetCollisionProfileName(FName("Weapon"));
    // Enable collisions
	WeaponMesh->SetNotifyRigidBodyCollision(true);
	SetActorEnableCollision(true);
    // Set as root component
	RootComponent = WeaponMesh;
  
    // Does not deal damage by default.
	DealsDamage = false;
}

// Called when the game starts or when spawned
void AWeapon::BeginPlay()
{
	Super::BeginPlay();
  
    // Bind each function to its corresponding call.

	FScriptDelegate onHitDelegate;
	onHitDelegate.BindUFunction(this, "OnHit");
	OnActorHit.Add(onHitDelegate);

	FScriptDelegate onBODelegate;
	onBODelegate.BindUFunction(this, "OnBeginOverlap");
	OnActorBeginOverlap.Add(onBODelegate);
}

void AWeapon::SetDealsDamage(const bool dealsDamage)
{
    // In this example we can keep it simple.
	DealsDamage = dealsDamage;
}

void AWeapon::OnHit(AActor* SelfActor, AActor* OtherActor, FVector NormalImpulse, const FHitResult& Hit)
{
    // The code will be similar to the one below.
}

void AWeapon::OnBeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
                             UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep,
                             const FHitResult& SweepResult)
{
	// If we are not dealing damage, we can ignore the collision.
	if (!DealsDamage)
	{
		return;
	}
    
    // We will use the Damage System to deal damage to anyone else.
    // We create a generic damage event.
    FDamageEvent damageEvent;
    // We give the default damage type.
    damageEvent.DamageTypeClass = UDamageType::StaticClass();
    // And we notify the other actor that it has been damaged.
    OtherActor->TakeDamage(this->Damage, damageEvent, nullptr, Wielder);
}

// HEADER file

class ALeMainCharacter : public ACharacter, public IInteractor
{
	GENERATED_BODY()

//... more code ...

public:
	UPROPERTY(Category = "Character/Health", EditAnywhere, BlueprintReadWrite,
		meta = (ClampMin = "0", UIMin = "0"))
	float Health;

	virtual float TakeDamage(float DamageAmount, const struct FDamageEvent& DamageEvent,
	                         class AController* EventInstigator, class AActor* DamageCauser) override;
//... more code ...
}

// SOURCE file

float ALeMainCharacter::TakeDamage(float DamageAmount, const struct FDamageEvent& DamageEvent,
                                           AController* EventInstigator, AActor* DamageCauser)
{
	float damage = Super::TakeDamage(DamageAmount, DamageEvent, EventInstigator, DamageCauser);

    // If you want to deal with specific damage events, you can do it like this.
	if (DamageEvent.IsOfType(FPointDamageEvent::ClassID))
	{
		FPointDamageEvent* const PointDamageEvent = (FPointDamageEvent*) &DamageEvent;
		// In this example, the PointDamageEvent models damage applied at a specific point on the victim.
        FVector DamageLocation = PointDamageEvent->HitInfo.Location;
        // ... more code ...
	}

	Health -= damage;
  
	if (Health <= 0)
	{
        // I implemented a function to deal with death of the character.
		Die();
	}

	return damage;
}