【UE4_C++】<5>处理事件和代理 (Delegate)

最新推荐文章于 2023-03-30 22:53:07 发布
最新推荐文章于 2023-03-30 22:53:07 发布
阅读量678 收藏 2
点赞数 1
分类专栏： UE4 C++教程 UE4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34261504/article/details/104953752
版权

本章包含以下内容：

  • 处理通过虚函数实现的事件

  • 创建绑定到UFUNCTION的代理

  • 注销代理

  • 创建接受输入参数的代理

  • 使用代理绑定传递有效负载数据

  • 创建多播代理

  • 创建自定义事件

  • 创建一个钟表盘的时间处理器

  • 为第一人称射击游戏创建一个重新生成的拾取道具

一、处理通过虚函数实现的事件

Unreal 提供的一些 Actor 和 Component 类包括虚函数形式的事件处理程序。 这一小节将讲述如何通过重写问题中的虚拟函数来自定义这些处理程序。

创建新类：
在这里插入图片描述
添加代码：

MyTriggerVolume.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/BoxComponent.h"
#include "MyTriggerVolume.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AMyTriggerVolume : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AMyTriggerVolume();
    UPROPERTY()
        UBoxComponent* TriggerZone;

    UFUNCTION()
        virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;

    UFUNCTION()
        virtual void NotifyActorEndOverlap(AActor* OtherActor) override;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

MyTriggerVolume.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "MyTriggerVolume.h"
#include "Engine/Engine.h"


// Sets default values
AMyTriggerVolume::AMyTriggerVolume()
{
    // 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;

    // Create a new component for the instance and initializeit
    TriggerZone = CreateDefaultSubobject<UBoxComponent>("TriggerZone"); 
    TriggerZone->SetBoxExtent(FVector(200, 200, 100));
}

void AMyTriggerVolume::NotifyActorBeginOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s entered me"),*(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
}

void AMyTriggerVolume::NotifyActorEndOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s left me"),*(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
}

// Called when the game starts or when spawned
void AMyTriggerVolume::BeginPlay()
{
    Super::BeginPlay();
    
}

// Called every frame
void AMyTriggerVolume::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

编译并且再编辑器中在场景中添加：

在这里插入图片描述
运行结果如下：
角色进入时：
在这里插入图片描述
角色离开时：

在这里插入图片描述

二、创建绑定到UFUNCTION的代理

指针是一个强大的工具，因为我们能够在运行时分配它们，并可以改变它们在内存中指向的位置。 除了标准类型之外，我们还可以创建指向函数的指针，但是这些原始函数指针不适合使用，原因有很多。代理是一个更安全的函数指针版本，它使我们能够灵活地调用函数，而不必知道哪个函数被赋值，直到被调用的那一刻。 这种灵活性是选择代理而非静态函数的主要原因之一。 这个例子将会讲述如何将 UFUNCTION 关联到代理，以便在执行代理时调用该代理。

我们将使用到上一个例子中创建的MyTriggerVolume，和Demo中已有的InventoryGameMode来进行该例子的讲解：

首先创建新类：
在这里插入图片描述
添加代码：
MyTriggerVolume.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/BoxComponent.h"
#include "MyTriggerVolume.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AMyTriggerVolume : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AMyTriggerVolume();
    UPROPERTY()
        UBoxComponent* TriggerZone;

    UFUNCTION()
        virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;

    UFUNCTION()
        virtual void NotifyActorEndOverlap(AActor* OtherActor) override;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

MyTriggerVolume.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "MyTriggerVolume.h"
#include "Engine/Engine.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/GameModeBase.h"
#include "RPG/InventoryGameMode.h"
#include "Engine/World.h"


// Sets default values
AMyTriggerVolume::AMyTriggerVolume()
{
    // 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;

    // Create a new component for the instance and initializeit
    TriggerZone = CreateDefaultSubobject<UBoxComponent>("TriggerZone"); 
    TriggerZone->SetBoxExtent(FVector(200, 200, 100));
}

void AMyTriggerVolume::NotifyActorBeginOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s entered me"),*(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
    // Call our delegate 
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode =UGameplayStatics::GetGameMode(TheWorld); 
        AInventoryGameMode * MyGameMode =Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr)
        { 
            MyGameMode->MyStandardDelegate.ExecuteIfBound(); 
        }
    }
}

void AMyTriggerVolume::NotifyActorEndOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s left me"),*(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
}

// Called when the game starts or when spawned
void AMyTriggerVolume::BeginPlay()
{
    Super::BeginPlay();
    
}

// Called every frame
void AMyTriggerVolume::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

InventoryGameMode.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "InventoryCharacter.h"
#include "InventoryGameMode.generated.h"

DECLARE_DELEGATE(FStandardDelegateSignature)
/**
 * 
 */
UCLASS()
class NEWTUTORIALPROJECT_API AInventoryGameMode : public AGameModeBase
{
    GENERATED_BODY()
public:
    AInventoryGameMode();
    
    FStandardDelegateSignature MyStandardDelegate;
    
};

InventoryGameMode.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "InventoryGameMode.h"

AInventoryGameMode::AInventoryGameMode()
{
    DefaultPawnClass = AInventoryCharacter::StaticClass();
}

DelegateListener.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/PointLightComponent.h"
#include "DelegateListener.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API ADelegateListener : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    ADelegateListener();
    UFUNCTION()
        void EnableLight();
    UPROPERTY()
        UPointLightComponent* PointLight;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

DelegateListener.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "DelegateListener.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/GameModeBase.h"
#include "RPG/InventoryGameMode.h"
#include "Engine/World.h"


// Sets default values
ADelegateListener::ADelegateListener()
{
    // 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;
    // Create a point light 
    PointLight = CreateDefaultSubobject<UPointLightComponent>("PointLight"); RootComponent = PointLight;

// Turn it off at the beginning so we can turn it on later
// through code 
    PointLight->SetVisibility(false);

// Set the color to blue to make it easier to see 
    PointLight->SetLightColor(FLinearColor::Blue);
}

void ADelegateListener::EnableLight()
{
    PointLight->SetVisibility(true);
}

// Called when the game starts or when spawned
void ADelegateListener::BeginPlay()
{
    Super::BeginPlay();
    UWorld* TheWorld = GetWorld();
    if (TheWorld != nullptr) 
    {
        AGameModeBase* GameMode = UGameplayStatics::GetGameMode(TheWorld);
        AInventoryGameMode * MyGameMode = Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr) 
        {
            MyGameMode->MyStandardDelegate.BindUObject(this, &ADelegateListener::EnableLight); 
        }
    }
}

// Called every frame
void ADelegateListener::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

在编辑器中将DelegateListener拖拽到场景中：

在这里插入图片描述
运行程序：
当我将角色移动进入触发体中时，可以看到灯亮了起来
在这里插入图片描述

三、注销代理

我们使用代理来处理事件时 有时，需要删除绑定。 这就像设置一个函数指针对象到 nullptr，这样它就不再引用已经被删除的对象。
上一例子中DelegateListener我们对EndPlay进行重写代码如下：

DelegateListener.h


   virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

DelegateListener.cpp

void ADelegateListener::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode =UGameplayStatics::GetGameMode(TheWorld);
        AInventoryGameMode * MyGameMode =   Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr)
        {
            MyGameMode->MyStandardDelegate.Unbind();
        }
    }
}

这样可以做到当Actor销毁时代理自动注销。

四、创建接受输入参数的代理

前面例子主要是没有接受任何输入参数的代理，这个例子会讲解如何更改代理的签名让其接受某些输入。
我们还是使用上面例子中的GameMode

创建一个新类：
在这里插入图片描述
添加代码：

MyTriggerVolume.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/BoxComponent.h"
#include "MyTriggerVolume.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AMyTriggerVolume : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AMyTriggerVolume();
    UPROPERTY()
        UBoxComponent* TriggerZone;

    UFUNCTION()
        virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;

    UFUNCTION()
        virtual void NotifyActorEndOverlap(AActor* OtherActor) override;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

MyTriggerVolume.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "MyTriggerVolume.h"
#include "Engine/Engine.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/GameModeBase.h"
#include "RPG/InventoryGameMode.h"
#include "Engine/World.h"


// Sets default values
AMyTriggerVolume::AMyTriggerVolume()
{
    // 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;

    // Create a new component for the instance and initializeit
    TriggerZone = CreateDefaultSubobject<UBoxComponent>("TriggerZone"); 
    TriggerZone->SetBoxExtent(FVector(200, 200, 100));
}

void AMyTriggerVolume::NotifyActorBeginOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s entered me"),*(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
    // Call our delegate 
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode =UGameplayStatics::GetGameMode(TheWorld); 
        AInventoryGameMode * MyGameMode =Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr)
        { 
            MyGameMode->MyStandardDelegate.ExecuteIfBound(); 
            // Call the function using a parameter 
            auto Color = FLinearColor(1, 0, 0, 1);
            MyGameMode->MyParameterDelegate.ExecuteIfBound(Color);
        }
    }

}

void AMyTriggerVolume::NotifyActorEndOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s left me"),*(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
}

// Called when the game starts or when spawned
void AMyTriggerVolume::BeginPlay()
{
    Super::BeginPlay();
    
}

// Called every frame
void AMyTriggerVolume::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

InventoryGameMode.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "InventoryCharacter.h"
#include "InventoryGameMode.generated.h"

DECLARE_DELEGATE(FStandardDelegateSignature)
DECLARE_DELEGATE_OneParam(FParamDelegateSignature, FLinearColor)
/**
 * 
 */
UCLASS()
class NEWTUTORIALPROJECT_API AInventoryGameMode : public AGameModeBase
{
    GENERATED_BODY()
public:
    AInventoryGameMode();
    
    FStandardDelegateSignature MyStandardDelegate;
    
    FParamDelegateSignature MyParameterDelegate;
};

InventoryGameMode.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "InventoryGameMode.h"




AInventoryGameMode::AInventoryGameMode()
{
    DefaultPawnClass = AInventoryCharacter::StaticClass();
}

ParamDelegateListener.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/PointLightComponent.h"
#include "ParamDelegateListener.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AParamDelegateListener : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AParamDelegateListener();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    UFUNCTION() 
        void SetLightColor(FLinearColor LightColor);

    UPROPERTY() 
        UPointLightComponent* PointLight;
    
    UFUNCTION()
        virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
};

ParamDelegateListener.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "ParamDelegateListener.h"
#include "RPG/InventoryGameMode.h"
#include "GameFramework/GameModeBase.h"
#include "Kismet/GameplayStatics.h"
#include "Engine/World.h"


// Sets default values
AParamDelegateListener::AParamDelegateListener()
{
    // 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;

    PointLight = CreateDefaultSubobject<UPointLightComponent>("PointLight");
    RootComponent = PointLight;
}

// Called when the game starts or when spawned
void AParamDelegateListener::BeginPlay()
{
    Super::BeginPlay();

    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode =UGameplayStatics::GetGameMode(TheWorld);   
        AInventoryGameMode * MyGameMode =Cast<AInventoryGameMode>(GameMode);

        if (MyGameMode != nullptr)
        {
            MyGameMode->MyParameterDelegate.BindUObject(this,&AParamDelegateListener::SetLightColor);
        }
    }
}

// Called every frame
void AParamDelegateListener::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

void AParamDelegateListener::SetLightColor(FLinearColor LightColor)
{
    PointLight->SetLightColor(LightColor);
}

void AParamDelegateListener::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode = UGameplayStatics::GetGameMode(TheWorld);
        AInventoryGameMode * MyGameMode = Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr)
        {
            MyGameMode->MyParameterDelegate.Unbind();
        }
    }
}

编译完成后将ParamDelegateListener拖拽到场景中：
在这里插入图片描述
角色进入之后可见原先的白色灯变为红色。
在这里插入图片描述

五、使用代理绑定传递有效负载数据

我们将上一例子中的代码进行一些小修改：
在这里插入图片描述
编译后，我们运行程序将角色移动到触发体中：
可以看到灯被关掉了
在这里插入图片描述

六、创建多播代理

到目前为止，我们在本章中使用的标准代理本质上是函数指针: 它们允许您对一个特定的对象实例调用一个特定的函数。 多播代理是函数指针的集合，每个指针都可能位于不同的对象上，所有这些指针都将在广播代理时调用。

本例子之前我们已经处理通过虚函数实现的事件，知道了如何创建 TriggerVolume ，本例将它用于广播多播代理。

创建新类：
在这里插入图片描述
添加代码：

MyTriggerVolume.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/BoxComponent.h"
#include "MyTriggerVolume.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AMyTriggerVolume : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AMyTriggerVolume();
    UPROPERTY()
        UBoxComponent* TriggerZone;

    UFUNCTION()
        virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;

    UFUNCTION()
        virtual void NotifyActorEndOverlap(AActor* OtherActor) override;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

MyTriggerVolume.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "MyTriggerVolume.h"
#include "Engine/Engine.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/GameModeBase.h"
#include "RPG/InventoryGameMode.h"
#include "Engine/World.h"


// Sets default values
AMyTriggerVolume::AMyTriggerVolume()
{
    // 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;

    // Create a new component for the instance and initializeit
    TriggerZone = CreateDefaultSubobject<UBoxComponent>("TriggerZone");
    TriggerZone->SetBoxExtent(FVector(200, 200, 100));
}

void AMyTriggerVolume::NotifyActorBeginOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s entered me"), *(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
    // Call our delegate 
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode = UGameplayStatics::GetGameMode(TheWorld);
        AInventoryGameMode * MyGameMode = Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr)
        {
            MyGameMode->MyStandardDelegate.ExecuteIfBound();
            // Call the function using a parameter 
            auto Color = FLinearColor(1, 0, 0, 1);
            MyGameMode->MyParameterDelegate.ExecuteIfBound(Color);
            MyGameMode->MyMulticastDelegate.Broadcast();
        }
    }

}

void AMyTriggerVolume::NotifyActorEndOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s left me"), *(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
}

// Called when the game starts or when spawned
void AMyTriggerVolume::BeginPlay()
{
    Super::BeginPlay();

}

// Called every frame
void AMyTriggerVolume::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

InventoryGameMode.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "InventoryCharacter.h"
#include "InventoryGameMode.generated.h"

DECLARE_DELEGATE(FStandardDelegateSignature)
DECLARE_DELEGATE_OneParam(FParamDelegateSignature, FLinearColor)
DECLARE_MULTICAST_DELEGATE(FMulticastDelegateSignature)
/**
 * 
 */
UCLASS()
class NEWTUTORIALPROJECT_API AInventoryGameMode : public AGameModeBase
{
    GENERATED_BODY()
public:
    AInventoryGameMode();
    
    FStandardDelegateSignature MyStandardDelegate;
    
    FParamDelegateSignature MyParameterDelegate;

    FMulticastDelegateSignature MyMulticastDelegate;
};

InventoryGameMode.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "InventoryGameMode.h"




AInventoryGameMode::AInventoryGameMode()
{
    DefaultPawnClass = AInventoryCharacter::StaticClass();
}

MulticastDelegateListener.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/PointLightComponent.h"
#include "MulticastDelegateListener.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AMulticastDelegateListener : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AMulticastDelegateListener();

    UFUNCTION() 
        void ToggleLight();

    UFUNCTION() 
        virtual void EndPlay(const EEndPlayReason::Type EndPlayReason)override;

    UPROPERTY() 
        UPointLightComponent* PointLight;

    FDelegateHandle MyDelegateHandle;

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

MulticastDelegateListener.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "MulticastDelegateListener.h"
#include "Engine/World.h"
#include "GameFramework/GameModeBase.h"
#include "RPG/InventoryGameMode.h"
#include "Kismet/GameplayStatics.h"


// Sets default values
AMulticastDelegateListener::AMulticastDelegateListener()
{
    // 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;
    PointLight = CreateDefaultSubobject<UPointLightComponent>("PointLight"); RootComponent = PointLight;
}

void AMulticastDelegateListener::ToggleLight()
{
    PointLight->ToggleVisibility();
}

void AMulticastDelegateListener::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);

    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode = UGameplayStatics::GetGameMode(TheWorld);

        AInventoryGameMode * MyGameMode =Cast<AInventoryGameMode>(GameMode);

        if (MyGameMode != nullptr)
        {
            MyGameMode -> MyMulticastDelegate.Remove(MyDelegateHandle);
        }
    }
}

// Called when the game starts or when spawned
void AMulticastDelegateListener::BeginPlay()
{
    Super::BeginPlay();
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr) {
        AGameModeBase* GameMode = UGameplayStatics::GetGameMode(TheWorld);

        AInventoryGameMode * MyGameMode = Cast<AInventoryGameMode>(GameMode);

        if (MyGameMode != nullptr) 
        {
            MyDelegateHandle = MyGameMode -> MyMulticastDelegate.AddUObject(this,&AMulticastDelegateListener::ToggleLight);
        }
    }
}

// Called every frame
void AMulticastDelegateListener::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

编译后在编辑器中将4个MultiCastDelegateListener拖拽到创建中：
角色进入触发体后四个灯同时灭掉了：
角色出来触发体再重新进去四个灯又同时亮了：
在这里插入图片描述
在这里插入图片描述
以下做一个小验证，将前面例子中的蓝灯再复制一个，运行程序让角色走进触发体中：
在这里插入图片描述
可以看到后来复制出来的才有效果，这个验证说明，这个非多播代理只有最后一个绑定的代理的对象才能绑定成功，出现新的绑定，之前的绑定会被作废。
在这里插入图片描述

七、创建自定义事件

自定义代理非常有用，但是它们的一个局限性是可以由其他第三方类在外部广播; 也就是说，它们的 execute / broadcast 方法是可公开访问的。
有时，我们可能需要一个代理，该代理可由其他类在外部分配，但只能由包含它们的类广播。 这是事件的主要目的。

这一小节，还是基于前面的GameMode和MyTriggerVolume来进行。

创建新类：
在这里插入图片描述
添加代码:

MyTriggerVolume.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/BoxComponent.h"
#include "MyTriggerVolume.generated.h"


DECLARE_EVENT(AMyTriggerVolume, FPlayerEntered)

UCLASS()
class NEWTUTORIALPROJECT_API AMyTriggerVolume : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AMyTriggerVolume();
    UPROPERTY()
        UBoxComponent* TriggerZone;

    UFUNCTION()
        virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;

    UFUNCTION()
        virtual void NotifyActorEndOverlap(AActor* OtherActor) override;


    FPlayerEntered OnPlayerEntered;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

MyTriggerVolume.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "MyTriggerVolume.h"
#include "Engine/Engine.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/GameModeBase.h"
#include "RPG/InventoryGameMode.h"
#include "Engine/World.h"


// Sets default values
AMyTriggerVolume::AMyTriggerVolume()
{
    // 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;

    // Create a new component for the instance and initializeit
    TriggerZone = CreateDefaultSubobject<UBoxComponent>("TriggerZone");
    TriggerZone->SetBoxExtent(FVector(200, 200, 100));
}

void AMyTriggerVolume::NotifyActorBeginOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s entered me"), *(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
    // Call our delegate 
    UWorld* TheWorld = GetWorld();

    if (TheWorld != nullptr)
    {
        AGameModeBase* GameMode = UGameplayStatics::GetGameMode(TheWorld);
        AInventoryGameMode * MyGameMode = Cast<AInventoryGameMode>(GameMode);
        if (MyGameMode != nullptr)
        {
            MyGameMode->MyStandardDelegate.ExecuteIfBound();
            // Call the function using a parameter 
            auto Color = FLinearColor(1, 0, 0, 1);
            MyGameMode->MyParameterDelegate.ExecuteIfBound(Color);
            MyGameMode->MyMulticastDelegate.Broadcast();
            OnPlayerEntered.Broadcast();
        }
    }

}

void AMyTriggerVolume::NotifyActorEndOverlap(AActor* OtherActor)
{
    auto Message = FString::Printf(TEXT("%s left me"), *(OtherActor->GetName()));
    GEngine->AddOnScreenDebugMessage(-1, 1, FColor::Red, Message);
}

// Called when the game starts or when spawned
void AMyTriggerVolume::BeginPlay()
{
    Super::BeginPlay();

}

// Called every frame
void AMyTriggerVolume::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

TriggerVolEventListener.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "MyTriggerVolume.h"
#include "Components/PointLightComponent.h"
#include "TriggerVolEventListener.generated.h"


UCLASS()
class NEWTUTORIALPROJECT_API ATriggerVolEventListener : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    ATriggerVolEventListener();

    UPROPERTY() 
        UPointLightComponent* PointLight;

    UPROPERTY(EditAnywhere)
        AMyTriggerVolume* TriggerEventSource;

    UFUNCTION() 
        void OnTriggerEvent();
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

TriggerVolEventListener.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "TriggerVolEventListener.h"


// Sets default values
ATriggerVolEventListener::ATriggerVolEventListener()
{
    // 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;
    PointLight = CreateDefaultSubobject<UPointLightComponent>("PointLight"); 
    RootComponent = PointLight;
}

void ATriggerVolEventListener::OnTriggerEvent()
{
    PointLight->SetLightColor(FLinearColor(0, 1, 0, 1));
}

// Called when the game starts or when spawned
void ATriggerVolEventListener::BeginPlay()
{
    Super::BeginPlay();
    if (TriggerEventSource != nullptr) 
    {       
        TriggerEventSource->OnPlayerEntered.AddUObject(this,&ATriggerVolEventListener::OnTriggerEvent);
    }
}

// Called every frame
void ATriggerVolEventListener::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

编译完成后。在编辑器中我们拖拽一个TriggerVolEventListener到场景中，并且使用滴管选取MyTriggerVolume：
在这里插入图片描述
运行程序后，角色进去触发体后TriggerVolEventListener中的灯就亮起来了。
在这里插入图片描述

八、创建一个钟表盘的时间处理器

这个例子将会讲述如何使用前面例子中引入的概念来创建一个Actor，告知其他Actor游戏中的时间流逝。

创建新类：
在这里插入图片描述
Clock的截图是后面补上去的可以忽略掉报错提示信息。
在这里插入图片描述
添加代码：

TimeOfDayHandler.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

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


DECLARE_MULTICAST_DELEGATE_TwoParams(FOnTimeChangedSignature, int32,int32)
UCLASS()
class NEWTUTORIALPROJECT_API ATimeOfDayHandler : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    ATimeOfDayHandler();

    FOnTimeChangedSignature OnTimeChanged;

    UPROPERTY()
        int32 TimeScale;
    UPROPERTY()
        int32 Hours;
    UPROPERTY()
        int32 Minutes;
    UPROPERTY()
        float ElapsedSeconds;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

TimeOfDayHandler.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "TimeOfDayHandler.h"


// Sets default values
ATimeOfDayHandler::ATimeOfDayHandler()
{
    // 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;

    TimeScale = 60; Hours = 0; Minutes = 0; ElapsedSeconds = 0;
}

// Called when the game starts or when spawned
void ATimeOfDayHandler::BeginPlay()
{
    Super::BeginPlay();
    
}

// Called every frame
void ATimeOfDayHandler::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    ElapsedSeconds += (DeltaTime * TimeScale);

    if (ElapsedSeconds > 60) {
        ElapsedSeconds -= 60; 
        Minutes++;

        if (Minutes > 60) 
        { 
            Minutes -= 60; Hours++;
        }

        OnTimeChanged.Broadcast(Hours, Minutes);
    }
}

Clock.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/SceneComponent.h"
#include "Components/StaticMeshComponent.h"
#include "IDelegateInstance.h"
#include "Clock.generated.h"

UCLASS()
class NEWTUTORIALPROJECT_API AClock : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    AClock();
    UPROPERTY() 
        USceneComponent* RootSceneComponent;

    UPROPERTY()
        UStaticMeshComponent* ClockFace;

    UPROPERTY()
        USceneComponent* HourHandle;

    UPROPERTY()
        UStaticMeshComponent* HourHand;

    UPROPERTY() 
        USceneComponent* MinuteHandle;

    UPROPERTY() 
        UStaticMeshComponent* MinuteHand;

    UFUNCTION() 
        void TimeChanged(int32 Hours, int32 Minutes);

    FDelegateHandle MyDelegateHandle;
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

Clock.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "Clock.h"
#include "ConstructorHelpers.h"
#include "Kismet/GameplayStatics.h"
#include "TimeOfDayHandler.h"


// Sets default values
AClock::AClock()
{
    // 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;
    RootSceneComponent = CreateDefaultSubobject<USceneComponent>("RootSceneComponent");
    ClockFace = CreateDefaultSubobject<UStaticMeshComponent>("ClockFace");
    HourHand = CreateDefaultSubobject<UStaticMeshComponent>("HourHand");
    MinuteHand = CreateDefaultSubobject<UStaticMeshComponent>("MinuteHand");
    HourHandle = CreateDefaultSubobject<USceneComponent>("HourHandle");
    MinuteHandle = CreateDefaultSubobject<USceneComponent>("MinuteHandle");

    auto MeshAsset = ConstructorHelpers::FObjectFinder<UStaticMesh>(TEXT("StaticMesh'/Engine/BasicShapes/Cylinder.Cylinder'"));

    if (MeshAsset.Object != nullptr)
    {
        ClockFace->SetStaticMesh(MeshAsset.Object);
        HourHand->SetStaticMesh(MeshAsset.Object);
        MinuteHand->SetStaticMesh(MeshAsset.Object);
    }

    RootComponent = RootSceneComponent;

    HourHand->AttachToComponent(HourHandle,FAttachmentTransformRules::KeepRelativeTransform);

    MinuteHand->AttachToComponent(MinuteHandle,FAttachmentTransformRules::KeepRelativeTransform);

    HourHandle->AttachToComponent(RootSceneComponent,FAttachmentTransformRules::KeepRelativeTransform);

    MinuteHandle->AttachToComponent(RootSceneComponent,FAttachmentTransformRules::KeepRelativeTransform);

    ClockFace->AttachToComponent(RootSceneComponent,FAttachmentTransformRules::KeepRelativeTransform);

    ClockFace->SetRelativeTransform(FTransform(FRotator(90, 0, 0),FVector(10, 0, 0),FVector(2, 2, 0.1)));

    HourHand->SetRelativeTransform(FTransform(FRotator(0, 0, 0),FVector(0, 0, 25),FVector(0.1, 0.1, 0.5)));

    MinuteHand->SetRelativeTransform(FTransform(FRotator(0, 0, 0),FVector(0, 0, 50),FVector(0.1, 0.1, 1)));
}

void AClock::TimeChanged(int32 Hours, int32 Minutes)
{
    HourHandle->SetRelativeRotation(FRotator(0, 0, 30 * Hours));
    MinuteHandle->SetRelativeRotation(FRotator(0, 0, 6 * Minutes));
}

// Called when the game starts or when spawned
void AClock::BeginPlay()
{
    Super::BeginPlay();

    TArray<AActor*> TimeOfDayHandlers;
    UGameplayStatics::GetAllActorsOfClass(GetWorld(),ATimeOfDayHandler::StaticClass(),TimeOfDayHandlers);
    if (TimeOfDayHandlers.Num() != 0)
    {
        auto TimeOfDayHandler = Cast<ATimeOfDayHandler>(TimeOfDayHandlers[0]); 
        MyDelegateHandle = TimeOfDayHandler->OnTimeChanged.AddUObject(this,&AClock::TimeChanged);
    }
}

// Called every frame
void AClock::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

编译完成后打开编辑器将Clock和TimeOfDayHandler拖拽到场景中：
在这里插入图片描述
运行程序我们会看到秒针开始动：
在这里插入图片描述
快速运行验证分针转动的方式则是 slomo 20 后面是数字是运行倍数。

九、为第一人称射击游戏创建一个重新生成的拾取道具

这个例子将会讲述如何创建一个可以防止的拾取道具，它会在一定的时间后重生，适合作为第一人称射击游戏的弹药或者其他可拾取道具

首先，创建新类：
在这里插入图片描述
在这里插入图片描述
添加代码：

Pickup.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "GameFramework/RotatingMovementComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Pickup.generated.h"



DECLARE_DELEGATE(FPickedupEventSignature)
UCLASS()
class NEWTUTORIALPROJECT_API APickup : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    APickup();

    virtual void NotifyActorBeginOverlap(AActor* OtherActor)override;

    UPROPERTY()
        UStaticMeshComponent* MyMesh;

    UPROPERTY()
        URotatingMovementComponent* RotatingComponent;

    FPickedupEventSignature OnPickedUp;

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

Pickup.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "Pickup.h"
#include "ConstructorHelpers.h"


// Sets default values
APickup::APickup()
{
    // 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;

    MyMesh = CreateDefaultSubobject<UStaticMeshComponent>("MyMesh");

    RotatingComponent =CreateDefaultSubobject<URotatingMovementComponent>("RotatingComponent"); RootComponent = MyMesh;

    auto MeshAsset = ConstructorHelpers::FObjectFinder<UStaticMesh>(TEXT("StaticMesh'/Engine/BasicShapes/Cube.Cube'"));

    if (MeshAsset.Object != nullptr) 
    { 
        MyMesh->SetStaticMesh(MeshAsset.Object); 
    }

    MyMesh->SetCollisionProfileName(TEXT("OverlapAllDynamic")); RotatingComponent->RotationRate = FRotator(10, 0, 10);
}

void APickup::NotifyActorBeginOverlap(AActor* OtherActor)
{
    OnPickedUp.ExecuteIfBound();
}

// Called when the game starts or when spawned
void APickup::BeginPlay()
{
    Super::BeginPlay();
    
}

// Called every frame
void APickup::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

PickupSpawner.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Pickup.h"
#include "Components/SceneComponent.h"
#include "PickupSpawner.generated.h"


UCLASS()
class NEWTUTORIALPROJECT_API APickupSpawner : public AActor
{
    GENERATED_BODY()
    
public: 
    // Sets default values for this actor's properties
    APickupSpawner();

    UPROPERTY() 
        USceneComponent* SpawnLocation;

    UFUNCTION() 
        void PickupCollected();

    UFUNCTION() 
        void SpawnPickup();

    UPROPERTY() 
        APickup* CurrentPickup;

    FTimerHandle MyTimer;

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    
    
};

PickupSpawner.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "PickupSpawner.h"
#include "Engine/World.h"
#include "Pickup.h"


// Sets default values
APickupSpawner::APickupSpawner()
{
    // 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;
    SpawnLocation = CreateDefaultSubobject<USceneComponent>("SpawnLocation");
}

void APickupSpawner::PickupCollected()
{
    GetWorld()->GetTimerManager().SetTimer(MyTimer,this,&APickupSpawner::SpawnPickup,10,false);
    CurrentPickup->OnPickedUp.Unbind();
    CurrentPickup->Destroy();
}

void APickupSpawner::SpawnPickup()
{
    UWorld* MyWorld = GetWorld();

    if (MyWorld != nullptr)
    {
        CurrentPickup = MyWorld->SpawnActor<APickup>(APickup::StaticClass(),GetTransform());

        CurrentPickup->OnPickedUp.BindUObject(this,&APickupSpawner::PickupCollected);
    }
}

// Called when the game starts or when spawned
void APickupSpawner::BeginPlay()
{
    Super::BeginPlay();
    SpawnPickup();
}

// Called every frame
void APickupSpawner::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

编译完之后，在编辑器中将PickupSpawner拖拽到场景中：
运行之后我们会看到生成了一个Pickup：
在这里插入图片描述
我们将角色移动到Pickup上会发现Pickup被销毁掉，也就是所谓的被拾取：
在这里插入图片描述
等待10s,会发现又生成了一个新的Pickup
在这里插入图片描述

CharlesVane
关注
专栏目录
C#事件处理和委托event delegate实例简述
09-04
在C#编程语言中，事件处理和委托是两个重要的概念，它们在构建事件驱动的程序中起到核心作用。事件处理允许对象在特定情况发生时通知其他对象，而委托则是事件处理的基础，它是一种类型安全的函数指针，可以用来引用...
UE4 代理（Delegate）的使用（2）
m0_53295313的博客
10-01 174
写到这里，虚幻引擎代理者这部分差不多写完了，不敢说写出来代理的所有用法，但也基本覆盖了最常用的。这两篇文章也算是这的时间学习虚幻引擎代理的总结吧。
UE4C++Delegate的使用
weixin_41564287的博客
03-16 1318
UE4C++Delegate的使用 一.单播代理 主要分为无参数的单播代理，有参数的单播代理和带返回值的单播代理。 1.声明： 2.定义： 3.使用： 首先定义需要绑定的方法： 以带一个参数的代理OneParam和无参数的代理NoParam为例，首先在类里创建两个函数用于绑定，参数要与代理对应。 然后与代理进行绑定，ue4提供了多种不同的方式： （1）BindUObject： 参数一：需要绑定的对象，这里直接用的this，也可以根据情况绑定在玩家上等等。 参数二：绑定的方法，传递一个函数指针。 （2
C++实现UE委托
游戏弱鸡
04-05 1324
#include<iostream> #include<vector> #include "Functional" /** * 所涉及的知识点： * （1）typedef的函数指针定义方式 * （2）Using的函数指针定义方式 * （3）单播绑定和执行的过程（C++仿照UE） * （4）Function的使用——bind以及对这种包装器（std::function<void(int, int)> ）的使用 * （5）多播的实现（Fdelegate的类中的p
【UE4 C++ 基础知识】＜8＞ Delegate 委托
ttod的博客
11-06 1484
【UE4 C++ 基础知识】 Delegate 委托
[UE C++] Delegate使用详解
qq_52179126的博客
03-30 4083
Delegate的使用方法总结终于告一段落，文章比较长，若有错误，欢迎指出。学疏才浅，还请见谅。
C++实现delegate
10-14
用C++做项目的时候，尤其是写客户端的时候经常会有事件回调的设计，一般的方式是使用虚函数表，用一个虚基类包含...但这种方式和C++11的lamda不兼容，为了更方便的实现事件回调机制，使用delegate是很不错的一种方式。
UE4代理使用代码.zip
05-28
在UE4游戏开发中，代理（Delegate）是一种关键的编程机制，它允许程序员定义和实现事件处理函数。本文将深入探讨UE4代理的使用，包括单播、多播、动态单播、动态多播以及可继承的Event，这些都是在描述中提及的核心...
JavaScript事件代理和委托详解
11-23
这里介绍一下javascript delegate的用法和原理，以及Dojo，jQuery等框架中delegate的接口。 JavaScript事件代理 事件代理在JS世界中一个非常有用也很有趣的功能。当我们需要对很多元素添加事件的时候，可以通过将...
UE4代理和事件
Daniel的博客
02-22 643
UE4C++的代理delegate其实就是C#中的委托，其实是同一个东西只是C#里的教材里多数翻译成委托。 代理其实就是一个可以传递函数指针的特殊类。 UE4C++的代理还分为单播代理，多播代理，动态代理等。 单播代理只能绑定一个函数 //声明无参代理 DECLARE_DELEGATE(D_NoParam) //声明1个参数的代理 DECLARE_DELEGATE_OneParam(D_1Param, FString) //声明5个参数的代理 DECLARE_DELEGATE_Fi.
【UE4_C++】 <4> Actor和Component
qq_34261504的博客
03-16 1321
本章包含以下内容： 在C++中创建一个自定义的Actor 使用SpawnActor来实例化Actor 创建一个UFUNCTION 使用Destroy和计时器来销毁Actor 使用SetLifeSpan来使Actor在一段时间后销毁 通过组件实现Actor功能 使用FObjectFinder读取资源到组件中 通过继承实现Actor功能 附加组件来创建层次结构 ...
【UE4】事件调度器（蓝图）
weixin_44283836的博客
10-14 835
虚幻4 事件调度器（蓝图）中的相关知识点
UE4 C++事件的定义
qq_51654332的博客
02-24 883
UE4 C++的函数和事件的定义 // Fill out your copyright notice in the Description page of Project Settings. #pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "SpwanVolume.generated.h" UCLASS() class GETSTARTED_API ASpwanVolume : publi
javascript学习16：使用事件
八十岁老将的博客
02-13 231
1、使用简单事件处理器 1.1 实现简单的内联事件处理器 使用某个事件属性最直接的方式是给它指派一组JavaScript语句。当该事件被触发后,浏览器就会执行你提供的语句。 1.2 实现一个简单的事件处理函数 为了在一定程度上解决繁琐和重复添加问题，我们可以定义一个函数，并将函数名指定为元素事件属性的值。 2、使用DOM和事件对象 如果你想要进行更为复杂的处理（以及更优雅地定义事件处理器)，就需要使用DOM和JavaScript的Event对象了。 2.1 按类型区分事件 type属性会告诉你正在处理的是哪
UE4 C++：Delegate委托
最不正经的计算机专业学生
08-24 1658
UE4 C++,委托
事件处理(Handling Events)和委托（Delegate）代码示例（三）【UE4】【C++】
ShaderJoy 的兴趣技术杂货铺
03-20 4184
6. 自定义事件（Custom Event）首先添加事件声明宏到 MyTriggerVolume 类中（不是 GameMode）自定义事件声明如下：DECLARE_EVENT(AMyTriggerVolume, FPlayerEntered)第一个参数是具体实现事件的类，也是唯一能调用Broadcast 的类第二个参数是我们事件函数的签名并添加刚刚声明的事件签名的实例FPlayerEntered
基于C++代码的UE4学习（七）—— 自定义事件及触发Custom Event
虎牙维护世界和平
08-22 3957
今天讲解的是自定义事件的触发（Custom Event）。 在蓝图中是这个： 我们现在用代码来完成自定义事件的触发。这次我们并不使用GameModeBase类作为中介，而是就使用Trigger类充当中介，我们将其宏可以定义为EditAnywhere。 创建一个自定义事件，需要在UCLASS宏之前加上DECLARE_EVENT(类名, 自定义事件的名称，自己起即可)。 1 #pragma once 2 3 #include "CoreMinimal.h" 4...
最简单的 UE 4 C++ 教程 —— 注册组件的 hit 事件【十五】
ShaderJoy 的兴趣技术杂货铺
07-27 2399
原教程是基于 UE4.18，我是基于 UE 4.25】 英文原地址 接上一节教程，在本教程中，我们将学习如何在组件上注册一个 hit 事件。创建一个新的 C++ Actor 子类并将其命名为 OnComponentHit 。在头文件中，将声明一个 UBoxComponent 变量和一个当组件注册一个 hit 事件时运行的 void 函数。 下面是最终的头文件 OnHitComponent.h #pragma once #include "CoreMinimal.h" #include "Ga.
UE4 定时器和事件分发机制（C++和蓝图）
qq_51654332的博客
04-09 3090
1. 自己写的机制 2. 用C++调用Unreal的事件分发机制 3. 用蓝图调用Unreal的事件分发机制 4.蓝图调用C++写的Pawn 记得绑定好，Pawn 先是自己写的一个简单的事件分发机制（自己写的肯定有考虑不到的地方（垃圾回收什么什么。。。）） 先看自己写的机制： 一个蓝图宏库 一个发起事件者Pawn 一个接口（调用实现了这个接口的接口方法） 一个基类，然后继承这个基类做事件绑定(基类只是给了一个外观) 一个存数据的类 蓝图宏库： // Fill out your copyright noti
public delegate void Obj_GetAtts_WithNoHead(List<matt> atts, byte xiliemark); 用法
最新发布
09-19
这个委托声明 `public delegate void Obj_GetAtts_WithNoHead(List<matt> atts, byte xiliemark);` 定义了一个名为 `Obj_GetAtts_WithNoHead` 的公共委托，它接受两个参数：一个`List<matt>`类型的变量`atts`，表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值