Nutzung des OnHit-Events

Project Setup

1. Begin by creating a new Games > First Person > C++ Project named OnHit.

   

Creating the Mesh Material

1. Navigate to the Content Browser, and find the LevelPrototyping/Materials folder.

2. Select MI_SolidBlue, then duplicate (CTRL+ D) and rename the newly duplicated asset MI_Solid_Red.

   

3. Double-click to open the asset, then select and edit the Base Color to the color red.

   

4. Save the Asset.

Creating the Cube Actor

1. In the Editor, click Add(+) > New C++ Class, then choose Actor as your parent class and name your class Cube.

   

2. Declare the following class defaults in your cube.h file

   C++

   UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
            class UStaticMeshComponent* CubeMesh;
   		
            UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
            UMaterialInstance* CubeMaterial;
   		
            UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
            UMaterialInstance* DamagedCubeMaterial;
   		
            FTimerHandle DamageTimer;
   
   Expand code Copy full snippet(14 lines long)

3. Next, in your cube.cpp file, declare the following class libraries.

   C++

   #include "Kismet/GameplayStatics.h"
        #include "OnHitProjectile.h"

   Copy full snippet(2 lines long)

4. Navigate to the cube constructor and implement the following functionality.

   C++

   ACube::ACube()
        {
            CubeMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("CubeMesh"));
            DamagedCubeMaterial = CreateDefaultSubobject<UMaterialInstance>(TEXT("DamageMaterial"));
            CubeMaterial = CreateDefaultSubobject<UMaterialInstance>(TEXT("CubeMaterial"));
   		
            CubeMesh->SetSimulatePhysics(true);
        }

   Copy full snippet(8 lines long)

Implementing the Damage functionality

Now that you created a cube, you need to implement a function that sets the mesh's material when it receives damage, then after a delay resets the mesh back to its original material.

1. Declare the following code in your cube.h file.

   C++

   void OnTakeDamage();
   		
            void ResetDamage();

   Copy full snippet(3 lines long)

2. Navigate to the cube.cpp file and implement the following for the ACube::BeginPlay function.

   C++

   void ACube::BeginPlay()
        {
           CubeMesh->OnComponentHit.AddDynamic(this, &ACube::OnComponentHit);
        }

   Copy full snippet(4 lines long)

3. Implement the ACube::OnTakeDamage function.

   C++

   void ACube::OnTakeDamage()
        {
   		
            CubeMesh->SetMaterial(0, DamagedCubeMaterial);
            GetWorld()->GetTimerManager().SetTimer(DamageTimer, this, &ACube::ResetDamage, 1.5f, false);
        }

   Copy full snippet(6 lines long)

4. Next, implement the ACube::ResetDamage function.

   C++

   void ACube::ResetDamage()
        {
            CubeMesh->SetMaterial(0,CubeMaterial);
        }

   Copy full snippet(4 lines long)

5. Finally, navigate to the ACube::OnComponentHit function and implement the following code.

   C++

   void ACube::OnComponentHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
        {
        if (AOnHitProjectile* HitActor = Cast<AOnHitProjectile>(OtherActor))
        {
   		
            UGameplayStatics::ApplyDamage(this, 20.0f, nullptr, OtherActor, UDamageType::StaticClass());
            OnTakeDamage();
   		
        }
        }

   Copy full snippet(10 lines long)

6. Compile your code.

7. In the editor, navigate to C++ Classes > Cube then right-click on the Cube Actor and select Create Blueprint class based on Cube.

   

8. From the Components tab, select the Cube Mesh, then navigate to Details > Static Mesh and select the SM_ChamferCube asset.

   

9. In the class defaults of the BP_Cube, set the Cube Material to the MI_Solid_Blue asset, and the Damaged Cube Material to the MI_Solid_Red asset.

   

10. Compile and Save.

CubeActor.h

#pragma once

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

		UCLASS()
		class ONHIT_API ACube : public AActor
		{
			GENERATED_BODY()

CubeActor.cpp

#include "Cube.h"
		#include "Kismet/GameplayStatics.h"
		#include "OnHitProjectile.h"

		// Sets default values
		ACube::ACube()
		{
			// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
			PrimaryActorTick.bCanEverTick = true;

Setting up the Level

1. Drag the BP_Cube into the level from the Content Browser.

   

2. Navigate to the Outliner > Simulated Cubes, select all SM_ChauferCubes then right-click and select Replace Selected Actors with > BP_Cube.

   

3. Click Play to play in the editor and use the left-mouse button to fire a projectile at the cube.

4. When you play in the editor, you will see that when you hit the cube with the projectile fired it causes the cube to take damage and change its mesh material, and applies an impulse at the location where it was hit causing it to move opposite the direction of the projectile.

   

5. The amount of force applied is defined inside the OnHitProjectile.cpp file which uses the OnHit function to determine when the projectile actually hits something.

   C++

   void AOnHitCPPProjectile::OnHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
        {
   		
            // Only add impulse and destroy projectile if we hit a physics
            if ((OtherActor != nullptr) && (OtherActor != this) && (OtherComp != nullptr) && OtherComp->IsSimulatingPhysics())
            {
                OtherComp->AddImpulseAtLocation(GetVelocity() * 100.0f, GetActorLocation());
   		
                Destroy();
            }
   
   Expand code Copy full snippet(12 lines long)