UEC++个人速查

个人速查

这里是鄙人在学习U++时候整理的部分笔记，后面也会把自己用到的补充上来。这个笔记存在的唯一原因只是UE的API太过简陋，所以自己找教程看，把基础内容写过来用于copy。接下来自己的学习安排是，打算做一个相对复杂点的蓝图项目熟悉下游戏架构，再将一些蓝图替换成C++，简单的C++游戏已经抄了俩了。后面再看怎么做小型的网络游戏(排队游戏的某个关卡
之类的)。

创建Actor和组件挂载

组件头文件

1. Components/SceneComponent.h(挂载点，任何组件都必须挂载在挂载点上)
2. Components/StaticMeshComponent.h(网格体组件)
3. Components/BoxComponent.h(碰撞组件)
4. Particles/ParticleSystemComponent.h(粒子系统组件)
5. Components/AudioComponent.h(声音组件)
   只有Actor能挂组件哦。

声明

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class USceneComponent* MyScene;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UStaticMeshComponent* MyMesh;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UParticleSystemComponent* MyParticle;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UBoxComponent* MyBox;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UAudioComponent* MyAudio;

挂载和定义

一般常在构造函数中声明并挂载

定义

MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("CustomSceneName"));

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

MyParticle = CreateDefaultSubobject<UParticleSystemcComponent>(TEXT("MyCustomParticleSystemName"));

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

MyAudio = CreateDefaultSubobject<UAudioComponent>(TEXT("MyCustomAudio"));

挂载

因为只能挂载到DefaultSubobject,所以最好让RootComponent为DefaultSubobject这样就能挂更多组件。一般常在构造方法挂载。

RootComponent = MyScene;

MyMesh->SetupAttachment(MyScene);

MyParticle->SetupAttachment(MyScene);

MyBox->SetupAttachment(MyScene);

MyAudio->SetupAttachment(MyBox);

静态加载

静态加载资源

资源文件写死，在确定组件的层级结构后，传入资源并指定到组件对象的某个属性上。声明定义挂载后的下一个选择环节。

FObjectFinder中的参数可以去蓝图中看，蓝图中这些组件的detail中引入用的啥参数就用啥参数。静态加载的时候定义必须写在构造方法中。

//.h
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class USceneComponent* MyScene;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UStaticMeshComponent* MyMesh;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UParticleSystemComponent* MyParticle;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UBoxComponent* MyBox;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UAudioComponent* MyAudio;


//.cpp
static ConstructorHelpers::FObjectFinder<UStaticMesh>TempStaticMesh(TEXT(“网格体模型资产的引用”));
MyMesh->SetStaticMesh(TempStaticMesh.Object);

static ConstructorHelpers::FObjectFinder<UParticleSystem>TempParticleSystem(TEXT("粒子特效的资产引用"));
MyParticle->SetTemplate(TemParticleSystem.Object); 

static ConstructorHelpers::FObjectFinder<USoundWave>TempSound(TEXT("音效资产引用"));
MyAudio->SetSound(TempSound.Object);

静态加载资源类

不再通过class 加组件的形式前向声明了，而是通过TSubclassOf来实现声明。静态加载的时候定义必须写在构造方法中。同样是将一个资源用一个指针储存，但是涉及到蓝图的类型，所以试用TSubclassOf用一个对象存储任何AActor的子类，

//。h
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MyClass")
TSubclassOf<AActor> MyActor;

//.cpp
static ConstructorHelpers::FClassFinder<AActor> TempMyActor(TEXT("蓝图类资源引用_C"));
MyActor = TempMyActor.class;

动态加载

动态加载资源

动态加载放在构造方法外的其他位置，比如BeginPlay中。相对于静态加载资源没啥变化

UStaticMesh* MyTempStaticMesh = LoadObject<UStaticMesh>(nullptr,TEXT("资源引用"));
if(MyTempStaticMesh)MyMesh->SetStaticMesh(MyTempStaticMesh);

动态加载类资源

UClass* MyTempClass = LoadClass<AActor>(this,TEXT("蓝图类资源引用_C"));
if(MyTempClass)AActor* SpawnActor = GetWorld()->SpawnActor<AActor>(MyTempClass,FVector::ZeroVector,FRotator::ZeroRotator);

相机和相机臂

类型选择

1. 必然Pawn或者character这样的panw子类了。

头文件

1. GameFramework/SpringArmComponent.h(相机臂)
2. Camera/CameraComponent.h(相机组件)

声明

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
USceneComponent* MyRoot;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
USpringArmComponent* MySprintArm;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
UCameraComponent* MyCamera;

挂载和定义

定义

在构造方法中实现初始化定义。

MyRoot = CreateDefaultSubobject<USceneComponent>(TEXT("MyRootComponent"));

MySpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("MySpringArmComponent"));

MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCameraComponent"));

挂载

这里挂载也放在构造函数

RootComponent = MyRoot;

MySpringArm->SetupAttachment(MyRoot);

MyCamera->SetupAttachment(MySpringArm);

其他配置

MySpringArm->bDoCollisionTest = false;//取消摄像机的碰撞

按键映射和鼠标滑轮

类型选择

一般常用PlayerController。因为它提供了很多接口，重载就行，无需造轮子。

似乎PlayerController本身就自带了一个InputComponent,换句话说，如果自己不使用playercontroller只用pawn就得将InputComponent给导入并在构造函数创建即可(不需要挂载)，在beginplay启动输入并调用手动实现的setupinputcomponent。其他相同。

头文件导入

PlayerController控制的那个Pawn的头文件，想要控制Pawn上的摄像机臂或者pawn的位置，必须有其引用。

声明

重载接口函数

virtual void SetupInputComponent();

声明映射函数

void WheelUpFunction();
void WheelDownFUnction();

//我是一个辅助函数
void Zoom(bool Direction,ZoomSpeed);

定义

在SetupInputComponent()函数中将按键设置和触发类型以及回调函数绑定到inputComponent上来。

Super::SetuupInputComponent();

InputComponent->BindAction(“按键配置名”,IE_Pressed,this,&AmyPlayerController::WheelUpFunction);

InputComponent->BindAction(“按键配置名”,IE_Pressed,this,&AmyPlayerController::WheelDownFunction);

在映射函数中WheelUpFunction();通过PlayerController的GetPawn获取受控的引用经过类型判断后进行摄像机臂处理。

if(GetPawn())
{
	AMyPawn* MyCameraPawn = Cast<AMyPawn>(GetPawn());
	if(MyCameraPawn)
	{
		MyCameraPawn->Zoom(1,10);
	}
}

在Zoom(Direction,ZoomSpeed)函数;根据传入方向和速度进行弹簧臂的拉近和延伸。

if(Direction)
{
	if(MySpringArm->TargetArmLength >=300 && MySpringArm->TargetArmLength<5000)
		MySpringArm->TargetArmLength+=(ZoomSpeed*2);
}
else
{
	if(MySpringArm->TargetArmLength>300 && MySpringArm->TargetArmLength<=5000)
		MySpringArm->TargetArmLength0-(ZoomSpeed*2);
}

Actor的位置偏移

类型选择

1. Actor及其子类因为相关的Actor类都实现了。

使用

相对于根节点移动

控制整个Actor的移动，相对于根节点的移动(根节点不动)

1. 需要一个MyOffset表示某个对象移动的方向和距离。
2. 是否忽略碰撞
3. 需要一个HitResult的引用存储是否发生了碰撞作

FVector MyOffset = FVector(1,0,0);
FHitResult HitResult;
AddActorLocalOffset(MyOffset,false,&HitResult);

相对于世界的移动

参数同上

AddActorWorldOffset(MyOffset,false,&HitResult);

Actor的碰撞-Overlap

头文件

1. Components/BoxComponent.h(碰撞组件)

声明

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

定义与挂载

定义

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

挂载

MyBox->SetupAttachment(MyScene);

使用

绑定

MyBox->OnComponentBeginOverlap.AddDynamic(this,&AMyActor::BeginOverlapFunction);

MyBox->OnComponentBeginOverlap.AddDynamic(this,&AMyActor::EndOverlapFunction);

其他配置--待绑定函数的声明

1. 当前actor的碰撞盒组件
2. 另一个碰撞actor
3. 另一个碰撞actor的碰撞组件
4. 对方组件的body索引(无视)
5. 一个物体是否是主动带着速度撞过来的
6. 主动撞过来时的命中等信息

 UFUNCTION()
 void BeginOverlapFunction(
	 UPrimitiveComponent* OverlappedComponent,
	 AActor* OtherActor,
	 UPrimitiveComponent* OtherComp,
	 int32 OtherBodyIndex,
	 bool bFromSweep,
	 const FHitResult& SweepResult);

UFUNCTION()
void EndOverlapFunction(
	UPrimitiveComponent* OverlappedComponent,
	AActor* OtherActor,
	UPrimitiveComponent* OtherComp,
	int32 OtherBodyIndex);

其他配置--待绑定函数的实现

void AMyActor::BeinOverlapFunction(UPrimitiveComponent* OverlappedComponent,
	 AActor* OtherActor,
	 UPrimitiveComponent* OtherComp,
	 int32 OtherBodyIndex,
	 bool bFromSweep,
	 const FHitResult& SweepResult)
{
	UELOG(......)
}

Actor的碰撞Hit

hit不同于beginoverlap的第一次碰撞才触发，hit只要有接触就会触发。

头文件

1. Components/BoxComponent.h(碰撞组件)

声明

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

定义与挂载

定义

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

挂载

MyBox->SetupAttachment(MyScene);

使用

绑定

MyBox->OnComponentHit.AddDynamic(this,&AMyActor::HitFunction)

其他配置--带绑定函数的声明

UFUNCTION()
void HitFunction(
	UPrimitiveComponent* HitComponent,
	AActor* OtherActor,
	UPrimitiveComponent* OtherComp,
	FVector NormalImpulse,
	const FHitResult& Hit);

Actor的碰撞设置

头文件

1. Components/BoxComponent.h(碰撞组件)

声明

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

定义与挂载

定义

MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));

挂载

MyBox->SetupAttachment(MyScene);

使用

碰撞设置

MyBox->SetCollisionEnabled(ECollisionEnabled::NoCollision);

MyBox->SetCollisionEnabled(ECollisionEnabled::QueryOnly);

MyBox->SetCollisionEnabled(ECollisionEnabled::PhysicsOnly);

MyBox->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);

MyBox->SetCollisionEnabled(ECollisionEnabled::ProbeOnly);

MyBox->SetCollisionEnabled(ECollisionEnabled::QueryAndProbe);

碰撞类型

MyBox->SetCollisionObjectType(ECC_WorldStatic);

MyBox->SetCollisionObjectType(ECC_WorldDynamic);

MyBox->SetCollisionObjectType(ECC_Pawn);

MyBox->SetCollisionObjectType(ECC_PhysicsBody);

MyBox->SetCollisionObjectType(ECC_Vehicle);

MyBox->SetCollisionObjectType(ECC_Destructible);

碰撞响应

多个通道

MyBox->SetCollisionResponseToALllChannels(ECR_Block); //设置所有通道响应为block

MyBox->SetCollisionResponseToAllChannels(ECR_Overlap);//设所有通道响应为重叠

MyBox->SetCollisionResponseToAllChannels(ECR_Ignore);//设所有通道响应为忽略

单个通道

MyBox->SetCollisionResponseToChannel(ECR_Pawn,ECR_Overlap);//对pawn设置为重叠

MyBox->SetCollisionResponseToChannel(ECC_WorldStatic,ECR_Block);//对世界静态设置为阻挡

MyBox->SetCollisionResponseToChannel(ECC_WorldDynamic,ECR_Block);//对世界动态设置为忽略

Actor的粒子特效的激活和失效

头文件

1. Particles/ParticleSystemComponent.h(粒子系统组件)

声明

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class USceneComponent* MyScene;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UStaticMeshComponent* MyMesh;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UParticleSystemComponent* MyParticle;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UBoxComponent* MyBox;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UAudioComponent* MyAudio;

挂载和定义

一般常在构造函数中声明并挂载

定义

MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("CustomSceneName"));

MyParticle = CreateDefaultSubobject<UParticleSystemcComponent>(TEXT("MyCustomParticleSystemName"));

挂载

因为只能挂载到DefaultSubobject,所以最好让RootComponent为DefaultSubobject这样就能挂更多组件。一般常在构造方法挂载。

RootComponent = MyScene;

MyParticle->SetupAttachment(MyScene);

使用-激活和失效

MyParticle->Activate();

MyParticle->Deactivate();

用户控件--按钮

类型选择

1. 选择C++的Widget的UserWidget类进行派生
2. 选则一个PlayerController处理控件的显示。

头文件

1. 控件父类：
   1. Components/Button.h
2. PlayerController类
   1. Blueprint/UserWidget.h

声明

1. 使用meta的bindwidget相当于将控件名为ButtonStart和ButtonQuit的两个控件的操作句柄暴露给C++方法了。

UPROPERTY(meta=(BindWidget))
UButton* ButtonStart;

UPROPERTY(meta=(BindWidget))
UButton* ButtonQuit;

virtual bool Initialize() override;

定义

bool UMyUserWidget::Initialize()
{
	if(!Super::Initialize())
	{
		return false;
	}
	ButtonStart->OnClicked.AddDynaic(this,&UMyUserWidget::Start());
	ButtonQuit->OnClicked.AddDynaic(this,&UMyUserWidget::Quit());
	return ture;
}

其他配置--待绑定方法声明和定义

//声明：
UFUNCTION()
void Start();

UFUNCTION()
void Quit();

//定义
void UMyUserWidget::Start(){
	GEngine->AddOnScreenDebugMessage(-1,5.0f,FColor::Red,TEXT("Start"));
}
void UMyUserWidget::Quit(){
	GEngine->AddOnScreenDebugMessage(-1,5.0f,FColor::Red,TEXT("Quit"));
}

使用--这里用了动态加载。

1. 进入一个PlayerController类，其实选其他类也是可以的，但是Pawn可能会死，可能会换，World需要手动管理声明周期，而playercontroller几乎贯穿玩家和游戏交互的全流程，因此选择PlayerController。
2. 先将蓝图子类加载到内存，在用UUserWidget这个控件父类指针去指向基于蓝图子类创建出来的Widget。所以LoadClass真的只是读取一个类而不是一个对象,通过指针将控件添加到视口。类似于TSubClassOf，指针存储底稿，运行时根据底稿来创建副本并进行修改。

void AMyPlayerController::BeinPlay()
{
	Super::BeginPlay();
	UClass* widgetClass = LoadClass<UUserWidget>(NULL,TEXT("控件的蓝图子类的资源引用_C"));
	UUserWidget* MyWidgetClass = nullptr;
	MyWidgetClass = CreateWidget<UUserWidget>(GetWorld(),widgetClass);
	MyWidgetClass->AddToViewPort();
}

用户控件--进度条

类型选择

1. 选择C++的Widget的UserWidget类进行派生
2. 选则一个PlayerController处理控件的显示。

头文件

1. 控件父类：
   1. Components/ProgressBar.h
2. PlayerController类
   1. Blueprint/UserWidget.h

声明

UPROPERTY(meta=(BindWidget))
UProgressBar* ProgressBarHealth;


UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MyHealth")
float CurrentHealth = 100.0f;

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MyHealth")
float MaxHealth = 100.0f;

void UpdateHealth(); 

定义

void UMyUserWidget::UpdateHealth()
{
	float Percent = FMath::Clamp(CurrentHealth/MaxHealth,0.f,1.f);
	if(ProgressBarHealth)ProgressBarHealth->SetPercent(Percent);
	if (CurrentHealth <= 0)
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Death"));
	else
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("-10"));
}

其他配置

找一个函数负责调用UpdateHealth().

void UMyUserWidget::Start()
{
	UpdateHealth();
}

代理--单播

类型选择

选了Actor来派生

代理的声明

1. 代理的声明依靠一个宏，这个宏会在预编译阶段被替换成对一个类的声明，也就是会根据代理名替换城几个类NoParamDelegate,OneParamDelegate,TwoParamDelegate,ThreeParamDelegate,RevalDelegate这些类。

DECLARE_DELEGATE(NoParamDelegate);
DECLARE_DELEGATE_OneParam(OneParamDelegate,FString);
DECLARE_DELEGATE_TwoParams(TwoParamDelegate,FString,int32);
DECLARE_DELEGATE_ThreeParams(ThreeParamsDelegate,FString,int32,float);
DECLARE_DELEGATE_RetVal(FString,RevalDelegate);

2. 通过宏声明了代理后(创建了代理类后)就需要实例化这个所谓的代理(感觉所谓的代理就是一个容器，负责在调用的时候将绑定上去的函数一起执行掉)

NoParamDelegate NoParamDelegate;
OneParamDelegate OneParamDelegate;
TwoParamDelegate TwoParamDelegate;
ThreeParamsDelegate ThreeParamDelegate;
RevalDelegate RevalDelegate;

3. 我觉得是函数容器也并非空穴来风，因为真的很像，这里就是在声明函数了。

void NoParamFunction();
void OneParamFunction(FString str);
void TwoParamFunction(FString str,int32 value);
void ThreeParamFunction(FString str,int32 value,float value1);
FString RevalParamFunction();

定义

void AMyDelegateActor::NoParamFunction()
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, TEXT("NoParamDelegate"));
}

void AMyDelegateActor::OneParamFunction(FString str)
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, FString::Printf(TEXT("%s"), *str));
}

void AMyDelegateActor::TwoParamFunction(FString str, int32 value)
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, FString::Printf(TEXT("%s %d"), *str,value));
}

void AMyDelegateActor::ThreeParamFunction(FString str, int32 value, float value1)
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, FString::Printf(TEXT("%s %d %f"), *str, value,value1));
}

FString AMyDelegateActor::RevalParamFunction()
{
	FString str = FString::Printf(TEXT("RevalParamDelegate"));
	return str; 
}

使用

1. 绑定方法到代理----在构造方法中将函数绑定到容器中。

NoParamDelegate.BindUObject(this, &AMyDelegateActor::NoParamFunction);
OneParamDelegate.BindUObject(this, &AMyDelegateActor::OneParamFunction);
TwoParamDelegate.BindUObject(this, &AMyDelegateActor::TwoParamFunction);
ThreeParamDelegate.BindUObject(this, &AMyDelegateActor::ThreeParamFunction);
RevalDelegate.BindUObject(this, &AMyDelegateActor::RevalParamFunction);

2. 执行代理---此处在beginplay执行

 void AMyDelegateActor::BeingPlay()
 {
	 SUper::BeginPlay();
	 NoParamDelegate.ExecuteIfBound();
	 OneParamDelegate.ExecuteIfBound("OneParamDelegate");
	 TwoParamDelegate.ExecuteIfBound("TwoParamDelegate",10);
	 ThreeParamDelegate.ExecuteIfBound("ThreeParamDelegate",10,5.0);
	 FString strValue = RevalDelegate.Execute();
}

代理--多播

类型选择

同上单播

代理的声明

我说实话，多播感觉就更像一个容器了。

1. 代理声明

DECLARE_MULTICAST_DELEGATE_OneParam(OneParamMultiDelegate,FString)

2. 代理实例化

OneParamMultiDelegate OneParamMultiDelegate;

3. 绑定函数的声明

UFUNCTION()
void MultiDelegateFunction1(FString str);

UFUNCTION()
void MultiDelegateFunction2(FString str);

UFUNCTION()
void MultiDelegateFUnction3(FString str);

定义

定义函数

void AMyDelegateActor::MultiDelegateFunction1(FString str)
{
	FString TempStr = str.Append("1");
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *TempStr));
}

void AMyDelegateActor::MultiDelegateFunction2(FString str)
{
	FString TempStr = str.Append("2");
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *TempStr));
}

void AMyDelegateActor::MultiDelegateFUnction3(FString str)
{
	FString TempStr = str.Append("3");
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *TempStr));
}

使用

1. 绑定代理，感觉多播更像容器了---这里在构造方法绑定的

OneParamMultiDelegate.AddUObject(this, &AMyDelegateActor::MultiDelegateFunction1);
OneParamMultiDelegate.AddUObject(this, &AMyDelegateActor::MultiDelegateFunction2);
OneParamMultiDelegate.AddUObject(this, &AMyDelegateActor::MultiDelegateFUnction3);

2. 执行代理---这里再Beginplay执行的

OneParamMultiDelegate.Broadcast("OneParamMultiDelegate");

代理--动态多播

类型选择

同上单播,动态多播好像是可以给蓝图用。

代理的声明

1. 声明代理，动态多播必须用F开头作为标识

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDynamicMultiDelegate, FString, param);

2. 实例化

UPROPERTY(BlueprintAssignable)
FDynamicMultiDelegate DynamicMultiDelegate;

使用

因为动态多播可以给蓝图用，所以不需要实现函数并绑定(当然也可以),那就只剩执行了---这里放在Beginplay中了

DynamicMultiDelegate.Broadcast("DynamicMultiDelegate");

发射物类

基类选择

Actor

头文件

1. Components/StaticMeshComponent.h(子弹怎么能没有网格体呢？)
2. Components/CapsuleComponent.h(子弹必须有碰撞网格，最好是胶囊体)
3. GameFramework/ProjectileMovementComponent.h(发射物运动组件，发射物必备)

声明

public:
	UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MyComponent")
	UStaticMeshComponent* MyBullet;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "MyComponent")
	UCapsuleComponent* MyCapsule;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "MyComponent")
	UProjectileMovementComponent* MyProjectile;

定义

在构造方法进行初始化

1. 创建组件并完成挂载
2. 静态加载网格体模型
3. 设置Bullet相对于的根节点大小
4. UMovementComponent提供了一批移动转向相关的函数，其子类负责实现在tick中调用这些函数实现运动逻辑
5. SetupDatedComponent后面跟的就是打算将移动委托给移动组件处理的一个组件
6. InitialSpeed发射瞬间速度，MaxSpeed飞行速度上限，bRotationFollowsVelocity弹头是否使用面朝飞行方向，bIsHomingProjectile是否启用追踪效果，ProjectileGravityScale重力倍率

MyBullet = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyBulletComponent"));
MyCapsule = CreateDefaultSubobject<UCapsuleComponent>(TEXT("MyCapsuleComponent"));
MyProjectile = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("MyProjectileComponent"));

static ConstructorHelpers::FObjectFinder<UStaticMesh> TmpStaticMesh(TEXT("网格体引用"));
MyBullet->SetStaticMesh(TmpStaticMesh.Object);

MyBullet->SetRelativeScale3D(FVector(0.4, 0.4, 0.4));

RootComponent = MyBullet;
MyCapsule->SetupAttachment(MyBullet);

MyProjectile->SetUpdatedComponent(MyBullet);
MyProjectile->InitialSpeed = 1200.0f;
MyProjectile->MaxSpeed = 2400.f;
MyProjectile->bRotationFollowsVelocity = true;
MyProjectile->bIsHomingProjectile = true;
MyProjectile->ProjectileGravityScale = 1.5f;

Character和增强输入

派生方式

派生自一个Character类

Build配置

添加"EnhancedInput"于Build.cs

头文件

1. InputActionValue.h
2. EnhancedInputComponent.h
3. EnhancedInputSubsystems.h
4. GameFramework/Controller.h
5. GameFramework/SpringArmComponent.h
6. Camera/CameraComponent.h
7. GameFramework/CharacterMovementComponent.h

声明

1. 两个摄像机相关组件
2. 一个映射上下文组件(个人理解：老输入映射方式是在项目配置里写，实际上是更类似于宏一样的方式，很死板，增强输入引入一个资产用于保存输入输出映射，这个资产就是UInputMappingContext。而UInputAction就是UInputMappingContext的字段，只不过得写在同级的属性中。)

public:
	UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MySceneComponent")
	USpringArmComponent* MySpringArm;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "MySceneComponent")
	UCameraComponent* MyCamera;

	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	class UInputMappingContext* DefaultMappingContext;

	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	class UInputAction* MoveAction;

	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	class UInputAction* LookAction;

	void Move(const FInputActionValue& Value);
	void Look(const FInputActionValue& Value);

定义

1. 初始化
   1. 创建组件并命名
   2. 进行配置
      1. 配置相机臂长度
      2. 将角色的yaw,poll,pitch,的旋转和摄像机隔离开，方便摄像机环顾而角色朝向独立(ARPG)
   3. 将角色朝向锁定到移动的方向
2. BeginPlay
   1. 在当前character为玩家控制时，获取输入系统并利用这个子系统将输入方案挂载到玩家上。(个人理解，子系统就是个翻译，它会查UInputMappingContext表并返回输入映射数据)
   2. 指定要查的表UInputMappingContext.
3. SetupPlayerInputComponent
   1. 绑定函数到表中的两个字段
4. Move
   1. Value是在组件内就绑定在委托上的输入了。
   2. 获取相机朝向并抽取XOY平面上的朝向
   3. 将朝向这个向量拆分成两个X轴和Y轴的分向量，并将移动信息替换到位置信息。

AMyCharacter::AMyCharacter()
{
 	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;
	
	//创建组件并命名挂载
	MySpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("MySpringArmComponent"));
	MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCameraComponent"));
	MyCamera->SetupAttachment(MySpringArm);
	MySpringArm->SetupAttachment(RootComponent);
	/*1. 配置相机臂长度
	1. 将角色的yaw,poll,pitch,的旋转和摄像机隔离开，方便摄像机环顾而角色朝向独立(ARPG)*/
	MySpringArm->TargetArmLength = 400.0f;
	bUseControllerRotationPitch = false;
	bUseControllerRotationYaw = false;
	bUseControllerRotationRoll = false;

	//将角色朝向锁定到移动的方向
	GetCharacterMovement()->bOrientRotationToMovement = true;

	//
	MySpringArm->bUsePawnControlRotation = true;

}
void AMyCharacter::BeginPlay()
{
	Super::BeginPlay();

	if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
	{
		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
		{
			Subsystem->AddMappingContext(DefaultMappingContext,0);
		}
	}
}
void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
	{
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AMyCharacter::Move);
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AMyCharacter::Look);
	}
}

void AMyCharacter::Move(const FInputActionValue& Value)
{
	FVector2D MovementVector = Value.Get<FVector2D>();
	if (Controller!=nullptr)
	{
		const FRotator Rotation = Controller->GetControlRotation();
		const FRotator YawRotation(0, Rotation.Yaw, 0);
		const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
		const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
		AddMovementInput(ForwardDirection, MovementVector.Y);
		AddMovementInput(RightDirection, MovementVector.X);
	}
}

void AMyCharacter::Look(const FInputActionValue& Value)
{
	FVector2D LookAxisVector = Value.Get<FVector2D>();
	if (Controller != nullptr)
	{
		AddControllerYawInput(LookAxisVector.X);
		AddControllerPitchInput(LookAxisVector.Y);
	}
}

接口

选择类型

1. Interface进行派生
2. MyCharacter类

头文件

1. MyCharacter:Myinterface.h

声明

接口是一个给别的类继承的抽象类,所以只有什么没有定义，定义在其他类

public:
	virtual void Attack() {};
	virtual void CalculateHealth() {};

重载声明

class XXXXXXX_API AMyCharacter : public ACharacter,public IMyInterface
{
public:

	virtual void Attack() override;
	virtual void CalculateHealth() override;
}

定义

void AMyCharacter::Attack()
{
	IMyInterface::Attack();
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Attack"));
}

void AMyCharacter::CalculateHealth()
{
	IMyInterface::CalculateHealth();
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("CalculateHealth"));
}

使用

尝试载beginplay中调用。

TimeHndle定时器

派生方式

派生自Scharacter,还是之前的MyCharacter类。

头文件

1. TimeManager.h

声明

1. 声明一个操纵定时器的句柄

FTimerHandle Time;

其他配置--回调函数

//声明
void PrintF();

//定义
void AMyCharacter::PrintF()
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Time"));
}

使用

1. 设置定时器--常在Beginplay里
2. 参数：定时器句柄，this，回调函数，定时器时间长度s,是否循环定时。
3. UWorld中管理着所有定时器，gettimermanager可以返回一个单例，这个单例有存放句柄的素组，这个单例提供了设置定时器句柄数组的方式入SetTimer和ClearTimer.

void AMyCharacter::BeginPlay()
{
	GetWorld()->GetTimerManager().SetTimer(Time, this, &AMyCharacter::PrintF, 1.0, true);
	if(Time.IsValid())
	{
		GetWorld()->GetTimerManager().ClearTimer(Time);
	}
}

3DWidget

派生方式

1. 使用UserWidget进行派生->MyHealthWidget
2. 做出来的控件给MyCharacter类调用

头文件

1. MyCharacter类
   1. Components/WidgetComponent.h(用父类指针指向蓝图子类对象)
2. MyHealthWidget
   1. 无（因为这里没有使用控件组件,按钮之类的，所有视觉元素都在蓝图中构建的。)

声明

1. MyHealthWidget类

public:
	UPROPERTY(EditAnywhere,BlueprintReadWrite,Category="MyWidget")
	float CurrentHealth=100.0f;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="MyWidget")
	float MaxHealth = 100.0f;

2. MyCharacter类

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "MySceneComponent")
UWidgetComponent* MyWidgetHealth;

定义

1. MyHealthWidget类：没有源文件定义，定义(如UI,函数等)写在对应控件蓝图子类中。
2. MyCharacter类
   1. 创建一个控件组件并命名且挂载
   2. 静态读取资源类引用
   3. 配置一个空间蓝图的蓝图类资源句柄到控件组件上，并配置组件的位置，再让UI贴在屏幕上，和缩放。

AMyCharacter::AMyCharacter()
{
	MyWidgetHealth = CreateDefaultSubobject<UWidgetComponent>(TEXT("MyWidgetComponent"));
	MyWidgetHealth->SetupAttachment(RootComponent);
	static ConstructorHelpers::FClassFinder<UUserWidget>WidgetClass(TEXT("蓝图资源引用_C"));
	MyWidgetHealth->SetWidgetClass(WidgetClass.Class);
	MyWidgetHealth->SetRelativeLocation(FVector(0, 0, 100));
	MyWidgetHealth->SetWidgetSpace(EWidgetSpace::Screen);
	MyWidgetHealth->SetDrawSize(FVector2D(400,20));
}

Damage相关

派生方式

MyActor

头文件

1. Kismet/GameplayStatic.h
2. MyCharacter.h

声明

1. AMyCharacter--重载并声明TakeDamage方法

virtual float TakeDamage(float DamageAmount,struct FDamageEvent const & DamageEvnt,class AController* EventInstigator,AActor* DamageCause) override;

定义

1. AMyCharacter

float AMyCharacter::TakeDamage(float DamageAmount, struct FDamageEvent const& DamageEvnt,
	class AController* EventInstigator, AActor* DamageCause)
{
	UMyHealthWidget* MyWidget = Cast<UMyHealthWidget>(MyWidgetHealth->GetUserWidgetObject());
	if (MyWidget)
	{
		if (MyWidget->CurrentHealth <=0)
		{
			return 0.0f;
		}
		MyWidget->CurrentHealth -= 5.0;
	}
	return 0.0f;
}

使用

1. AMyActor，施加伤害---常用在碰撞事件中.
   1. 这是一个用于绑定到6参数委托上的函数
   2. 将另外一个Actor尝试转换，如果另一个Actor是MyCharacter那就调用施加伤害的函数
   3. 参数：待受伤Actor，伤害数值，伤害施加者的控制器(为空可能来源于陷阱)，伤害世家这，上海类型

void AMyActor::BeingOverlapFunction(UPrimitiveComponent* OverlappedComponent,
	 AActor* OtherActor,
	 UPrimitiveComponent* OtherComp,
	 int32 OtherBodyIndex,
	 bool bFromSweep,
	 const FHitResult& SweepResult)
{
	AMyCharacter* MyCharacter = Cast<AMyCharacter>(OtherActor);
	if(MyCharacter)
	{
		UGameplayStatics::ApplyDamage(MyCharacter,5.0f,nullptr,this,UDamageType::StaticClass());
	}
}

Timeline开关门

派生方式

Actor

头文件

1. Components/BoxComponent.h
2. Components/TimelineComponent.h
3. MyCharacter.h(涉及类型转换,特定类型去触发)

声明

FOnTimelineFloat TimelineDelegate;
FOnTimelineEvent TimelineFinishedDelegate;

UFUNCTION()
void TimelineStart(float value);

UFUNCTION()
void TimelineFinished(float value);

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MySceneComponent")
USceneComponent* MyScene;

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MySceneComponent")
UStaticMeshComponent* MyStaticMesh;

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category ="MySceneComponent")
UBoxComponent* MyBox;

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MyCurve")
UCurveFloat* MyCurveFloat;

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MySceneComponet")
UTimelineComponent* MyTimeline;

UFUNCTION()
void BeginOverlapFunction(
	UPrimitiveComponent* OverlappedComponent,
	AActor* OtherActor,
	UPrimitiveComponent* OtherComp,
	int32 OtherBodyIndex,
	bool bFromSweep,
	const FHitResult& SweepResult);

UFUNCTION()
void EndOverlapFunction(
	UPrimitiveComponent* OverlappedComponent,
	AActor* OtherActor,
	UPrimitiveComponent* OtherComp,
	int32 OtherBodyIndex);

定义

1. 构造函数初始化
   1. 创建并声明组件MyTimelineComponent,MySene,StaticMesh,Box
   2. 静态加载网格体
   3. 构建挂载层级
   4. 配置碰撞盒的大小,位置
2. BeginPlay进行配置
   1. 将帧更新的回调绑定到TimelineStart函数
   2. 将播放完成的回调绑定到TimelineFinished函数
   3. 使用曲线去驱动浮点量
   4. 播放完就停,设置为不循环
   5. 设置未从0秒开始播放
   6. 设置立即开始播放
   7. 把播放结束回调给timeline
   8. 绑定两个回调函数到碰撞盒

AMyTimelineActor::AMyTimelineActor()
{
 	// 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;

	MyTimeline = CreateDefaultSubobject<UTimelineComponent>(TEXT("MyTimelineComponent"));
	MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("MySceneComponent"));
	MyStaticMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyStaticMeshComponent"));
	MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyBoxComponent"));
	static ConstructorHelpers::FObjectFinder<UStaticMesh>TmpStaticMesh(TEXT("资源引用"));
	if (TmpStaticMesh.Succeeded())
	{
		MyStaticMesh->SetStaticMesh(TmpStaticMesh.Object);
	}
	RootComponent = MyScene;
	MyStaticMesh->SetupAttachment(MyScene);
	MyBox->SetupAttachment(MyScene);
	MyBox->SetBoxExtent(FVector(200, 100, 100));
	MyBox->SetRelativeLocation(FVector(200, 0, 0));
}

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

	TimelineDelegate.BindUFunction(this, TEXT("TimelineStart"));
	TimelineFinishedDelegate.BindUFunction(this, TEXT("TimelineFinished"));
	MyTimeline->AddInterpFloat(MyCurveFloat, TimelineDelegate);
	MyTimeline->SetLooping(false);
	MyTimeline->PlayFromStart();
	MyTimeline->Play();
	MyTimeline->SetTimelineFinishedFunc(TimelineFinishedDelegate);
	
	MyBox->OnComponentBeginOverlap.AddDynamic(this, &AMyTimelineActor::BeginOverlapFunction);
	MyBox->OnComponentEndOverlap.AddDynamic(this, &AMyTimelineActor::EndOverlapFunction);
}

其他配置--待绑定函数的定义

void AMyTimelineActor::TimelineStart(float value)
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Timelineplay"));
	float YawRotation = FMath::Lerp(0, 90, value);
	MyStaticMesh->SetRelativeRotation(FRotator(0, YawRotation, 0));

}

void AMyTimelineActor::TimelineFinished(float value)
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("TimelineFinished"));
}

void AMyTimelineActor::BeginOverlapFunction(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
	UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
	AMyCharacter* TmpCharacter = Cast<AMyCharacter>(OtherActor);
	if (TmpCharacter)
	{
		MyTimeline->PlayFromStart();
	}
}

void AMyTimelineActor::EndOverlapFunction(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
	UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	AMyCharacter* TmpCharacter = Cast<AMyCharacter>(OtherActor);
	if (TmpCharacter)
	{
		MyTimeline->ReverseFromEnd();
	}
}

射线检测

派生方式

Actor

声明

FVector StartLocation;
FVector ForwardVector;
FVector EndLocation;
FHitResult HitResult;

使用

1. 通道检测
   1. 需要起始点位置和起始点朝向，终点位置
   2. 进行Visibility通道的射线检测，命中单位写入HitResult中
   3. 如果命中了，就获取命中结果中的Actor，并抽取命中的表面点(ImpactPoint)

void AMyCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	StartLocation = MyCamera->GetComponentLocation();
	ForwardVector = MyCamera->GetForwardVector();
	EndLocation = StartLocation + ForwardVector * 9999;
	bool bHit = GetWorld()->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_Visibility);
	if (bHit)
	{
		AActor* HitActor = HitResult.GetActor();
		FVector ImpactPoint = HitResult.ImpactPoint;
		FVector HitLocation = HitResult.Location;
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitActor->GetName()));
	}
}

1. 对象检测
   1. 构建射线的发出点和方向，和重点位置
   2. 构建对象类型查询列表FCollisionObjectQueryParams实例
   3. 想列表添加类型

void AMyCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	StartLocation = MyCamera->GetComponentLocation();
	ForwardVector = MyCamera->GetForwardVector();
	EndLocation = StartLocation + ForwardVector * 9999;
	FCollisionObjectQueryParams objectType;
	objectType.AddObjectTypesToQuery(ECC_WorldDynamic);
	bool bHit2 = GetWorld()->LineTraceSingleByObjectType(HitResult, StartLocation, EndLocation, objectType);
	if (bHit2)
	{
		AActor* HitActor2 = HitResult.GetActor();
		FVector ImpactPoint2 = HitResult.ImpactPoint;
		FVector HitLocation2 = HitResult.Location;
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitActor2->GetName()));
	}
}

多射线通道检测和对象检测

派生方式

Actor

声明

//射线检测
FVector StartLocation;
FVector ForwardVector;
FVector EndLocation;

//多通道射线检测
TArray<FHitResult> HitResults;

使用

1. 多通道检测和单通道检测的区别在于多通道有穿透。

void AMyCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	StartLocation = MyCamera->GetComponentLocation();
	ForwardVector = MyCamera->GetForwardVector();
	EndLocation = StartLocation + ForwardVector * 9999;
	bool HitMulti = GetWorld()->LineTraceMultiByChannel(HitResults, StartLocation, EndLocation, ECC_Visibility);
	if (HitMulti)
	{
		for (int32 i = 0;i<HitResults.Num();i++)
		{
			AActor* HitMultiActor = HitResults[i].GetActor();
			FVector HitLocation = HitResults[i].Location;
			FVector HitImpactPoint = HitResults[i].ImpactPoint;
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitMultiActor->GetName()));
		}
	}
}

2. 多对象检测

void AMyCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	StartLocation = MyCamera->GetComponentLocation();
	ForwardVector = MyCamera->GetForwardVector();
	EndLocation = StartLocation + ForwardVector * 9999;
	FCollisionObjectQueryParams objectType;
	objectType.AddObjectTypesToQuery(ECC_WorldStatic);
	bool HitMulti = GetWorld()->LineTraceMultiByObjectType(HitResults, StartLocation, EndLocation, ECC_Visibility);
	if (HitMulti)
	{
		for (int32 i =0;i<HitResults.Num();i++)
		{
			AActor* HitMultiActor = HitResults[i].GetActor();
			FVector HitLocation = HitResults[i].Location;
			FVector HitImpactPoint = HitResults[i].ImpactPoint;
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitMultiActor->GetName()));
		}
	}
}

软引用和同异步资源加载

概念

UE提供了两种引用软引用和应引用

1. 硬引用，拥有资源对象的属性,硬引用被加载在内存中，则被引用的资源也会被载入到内存，如直接的指针，或者TSubclassOf引用，或者组件子对象
2. 软引用，仅存储资源路径，只有在需要时才会被加载到内存中。

派生方式

Actor->派生一个MySoftActor

头文件

1. Engine/AssetManager.h

声明

UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "Path")
FSoftObjectPath AssetObjectPath;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Path")
FSoftClassPath AssetClassPath;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Path")
TSoftObjectPtr<AActor> AssetObjectPtr;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Path")
TSoftClassPtr<AActor> AssetClassPtr;

使用

异步加载资源

1. 初始化资源加载的路径
2. 用指针存储待会要异步加载的资源的句柄但是暂时还不加载
3. 通过句柄进行异步加载，仅在GetLoadedAsset()的时候才加载资源

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

	FSoftObjectPath Path1 = TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Props/SM_Chair.SM_Chair'");
	TSharedPtr<FStreamableHandle>SyncStreamHandle = UAssetManager::GetStreamableManager().RequestAsyncLoad(Path1);
	if (SyncStreamHandle)
	{
		UTexture2D* Image1 = Cast<UTexture2D>(SyncStreamHandle->GetLoadedAsset());
		if (Image1)
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *Image1->GetName(())));
		}
	}
}

同步加载

void AMySoftActor::BeginPlay()
{
	Super::BeginPlay();  
	FSoftObjectPath Path2 = TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Props/SM_Chair.SM_Chair'");
	TSharedPtr<FStreamableHandle> SyncStreamHandle = UAssetManager::GetStreamableManager().RequestSyncLoad(Path2);
	if (SyncStreamHandle)
	{
		UTexture2D* Image2 = Cast<UTexture2D>(SyncStreamHandle->GetLoadedAsset());
		if (Image2)
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *Image2->GetName()));
		}
	}
}

UE共享指针和引用以及弱指针

派生方式

Actor->派生MySmartPtrActor

辅助工具

class TestA
{
public:
	int a = 0;
	float b = 0;

	TestA()
	{
		a = 0;
		b = 0;
	};

	TestA(int a, float b)
	{
		this->a = a;
		this->b = b;
	}

	~TestA()
	{
		UE_LOG(LogTemp, Warning, TEXT("xigou"));
	};

};

使用

共享指针

1. 共享指针时可以初始化为空的并用MakeSharedable进行重新赋值。
2. ESPMode::ThreadSafe可以用于创造线程安全的共享指针，本质上是让操作原子化,保证读取只能读取写入完的数据或者未写入的数据，不存在写了几个字节没写完的数据。

%% 原始的指针需要手动delete %%
TestA* ptr1 = new TestA(1,2.0f);

%% 用裸指针左值赋值共享指针，可能会导致裸指针释放后共享指针再次释放 %%
TSharedPtr<TestA> Sharedptr2(ptr1);
ptr1 = nullptr;

%% 共享指针右值初始化,资源在创建的时候理解被共享指针接管，无所有权歧义 %%
TSharedPtr<TestA>Sharedptr3(new TestA(3, 4.0f));

%% 拷贝构造函数初始化，同类数据左值传入 %%
TSharedPtr<TestA>Sharedptr4(Sharedptr3);

%% UE的方式初始化共享指针，共享指针时可以初始化未空的，通过MakeShareable再赋值 %%
TSharedPtr<TestA>Sharedptr5 = nullptr;
Sharedptr5 = MakeShareable(new TestA(5, 6.0f));

%% 线程安全的共享指针 %%
TSharedPtr<TestA, ESPMode::ThreadSafe>Sharedptr6(new TestA(7, 8.0f));

1. SharedRef创建一个共享引用。
2. SharedPtr类的ToSharedRef方法可以创建指向数据的一个引用并返回
3. SharedPtr类的GetSharedReferenceCount可以获取引用数
4. IsUnique判断是否引用计数为1
5. Get方法获取裸指针
6. Reset()将指针充值为nullptr，并将引用计数减一。本质上来说是让此共享指针放弃所有权。

if (Sharedptr5.IsValid())
{
	TSharedRef<TestA>SharedRef1(new TestA(9, 10.0));
	SharedRef1 = Sharedptr5.ToSharedRef();
	int32 Count1 = Sharedptr5.GetSharedReferenceCount();//获取引用计数
	UE_LOG(LogTemp, Warning, TEXT("Count1 is %d"), Count1);

	if (!Sharedptr5.IsUnique())
	{
		UE_LOG(LogTemp, Warning, TEXT("sharedptr is not unique"));
	}
	Sharedptr5.Get()->a;//Get方法解引用。
	UE_LOG(LogTemp, Warning, TEXT("sharedptr is %d"), Sharedptr5.Get()->a);
	Sharedptr5.Reset();//把共享指针包裹的裸指针置为null。
	int32 Count2 = Sharedptr5.GetSharedReferenceCount();
	UE_LOG(LogTemp, Warning, TEXT("Count2 is %d"), Count2);
}

共享引用

1. 类似于引用，是不存在空这种状态的。
2. 底层实现和共享指针完全一样，所以还是用->解引用
3. 共享引用转共享指针无开销

%% 共享引用初始化时必须指向一个有效的对象 %%
TSharedRef<TestA> SharedRef2(new TestA(7, 8.0f));
if (SharedRef2.IsUnique())
{
	%% 共享引用也用指针访问 %%
	SharedRef2->a;
	UE_LOG(LogTemp, Warning, TEXT("Sharedref2a is %"), SharedRef2->a);

	%% 共享引用->共享指针 %%
	TSharedPtr<TestA> SharedPtr6;
	SharedPtr6 = SharedRef2;
	SharedPtr6.Get()->b;
	UE_LOG(LogTemp, Warning, TEXT("Sharedptr6 b is %f"), SharedPtr6.Get()->b);
}

弱指针

1. 弱指针用于循环引用，可以不占用引用计数
2. 不能组织对象被销毁
3. 在堆上创建一个数据并用共享指针指向。
4. 创建一个引用，应用着堆上一个对象
5. 声明弱指针，指向两个指针的数据，不拥有，只查看
6. 判断对象是否存活，强引用计数大于0才存活
7. Pin用于提升弱指针到强指针，只要pin时对象存在就会将引用计数加一并返回共享指针。

%% 弱指针解决了循环引用，只对弱指针保留引用权，不增加引用计数 %%
%% 不能阻止对象被销毁。 %%
TSharedPtr<TestA>Sharedptr7 = MakeShareable(new TestA(10, 11.0f));
TSharedRef<TestA>SharedRef3(new TestA(12, 13.0f));

//声明弱指针
TWeakPtr<TestA>WeakPtr1(Sharedptr7);
TWeakPtr<TestA>WeakPtr2(SharedRef3);
if (WeakPtr1.IsValid())
{
	TSharedPtr<TestA>Sharedptr8(WeakPtr1.Pin());
	if (Sharedptr8.IsValid())
	{
		Sharedptr8.Get()->a;
		UE_LOG(LogTemp, Warning, TEXT("Sharedptr8a is %d"), Sharedptr8.Get()->a);
	}
}

常用函数

派生方式

这里用的Actor，但是并不重要，这里是函数的列表查看吧。

头文件

1. Kismet/GameplayStatics.h

声明

public:
	UFUNCTION(BlueprintCallable,Category="MyTestFunction")
	void MyOpenlevel();

	UFUNCTION(BlueprintCallable, Category = "MyTestFunction")
	void MyCurrentLevelName();

	UFUNCTION(BlueprintCallable, Category = "MyTestFunction")
	void MyQuitGame();

定义

1. BeginPlay
   1. GetAllActorOfClass()：查找关卡世界中所有StaticClass类的对象并塞入OutActors容器。
   2. 遍历并输出容器中actor的名称
2. MyOpenLevel
   1. 打开名称指定的地图
3. MyCurrentLevelName
   1. 获取当前关卡的名称并输出
4. MyQuitGame
   1. 调用退出游戏命令。

void AMyFunctionLibraryActor::BeginPlay()
{
	Super::BeginPlay();
	TArray<AActor*>OutActors;
	UGameplayStatics::GetAllActorsOfClass(GetWorld(), AActor::StaticClass(), OutActors);
	for (int32 i =0;i<OutActors.Num();i++)
	{
		UE_LOG(LogTemp, Warning, TEXT("Actor is %s"), *OutActors[i]->GetName());
	}
}

void AMyFunctionLibraryActor::MyOpenLevel()
{
	UGameplayStatics::OpenLevel(GetWorld(), TEXT("关卡名称"));
}


void AMyFunctionLibraryActor::MyCurrentLevelName()
{
	FString MyCurrentLevelName = UGameplayStatics::GetCurrentLevelName(GetWorld());
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("MyCurrentLevelName is %s"), *MyCurrentLevelName));
}

void AMyFunctionLibraryActor::MyQuitGame()
{
	UGameplayStatics::GetPlayerController(GetWorld(), 0)->ConsoleCommand("quit");
}

字符串操作

派生方式

Actor->派生MyStringActor

头文件

1. Kismet/KismetStringLibrary.h

使用

1. 查看是否存在指定字符

%% 查找字符串是否包含指定字符。 %%
bool isFind1 = MyString.Contains("b", ESearchCase::IgnoreCase, ESearchDir::FromStart);
bool isFind2 = UKismetStringLibrary::Contains(MyString, "b", ESearchCase::CaseSensitive, ESearchDir::FromStart);

2. 判断两子妇产是否相等

bool isFind3 = MyString.Equals("123");

3. 拼接字符串

FString MyString2 = MyString.Append("OBJ");

4. 字符串长度

int32 Num = MyString.Len();
int32 Num2 = UKismetStringLibrary::Len(MyString);

5. 字符串是否为空

bool isEmpty = MyString.IsEmpty();

6. 从指定位置开始的字符串返回一个子字符串

FString MyChildString = UKismetStringLibrary::GetSubstring(MyString,0,3);

7. 查看字符串中的子字符串的起始索引

int32 Index1 = UKismetStringLibrary::FindSubstring(MyString,"123",false,false,0);

8. 返回第几个字符的ascaii吗

int32 Index2 = UKismetStringLibrary::GetCharacterAsNumber(MyString,0);

9. 返回一个数组

TArray<FString>MyArrayString;
MyArrayString = UKismetStringLibrary::GetCharacterArrayFromString(MyString);

10. 大写化

FString MyUpperString = MyString.ToUpper();

11. 小写化

FString MyLowerString = MyString.ToLower();

12. 在字符串左右侧填充指定数量字符

FString MyLeftpadString = MyString.LeftPad(3);
FString MyRightpadString = MyString.RightPad(3);

13. 检查字符串中是否包含数字字符

bool IsNumber = MyString.IsNumeric();

14. 测试字符串是否以给定的字符串为开头或者结尾

bool isStart = MyString.StartsWith("abcd",ESearchCase::IgnoreCase);
bool isEnd = MyString.EndsWith("1234",ESearchCase::IgnoreCase);

15. 字符串替换,将a换成$

UKismetStringLibrary::Replace(MyString,"a","$",ESearchCase::IgnoreCase);

16. 返回最左边或最右边给定的字符数

UKismetStringLibrary::Left(MyString,2);
UKismetStringLibrary::Right(MyString,2);

17. 返回最左边或者最右边给定的字符数，从末尾切掉给定数量的字符

UKismetStringLibrary::LeftChop(MyString,1);
UKismetStringLibrary::RightChop(MyString,2);

18. 从起始位置返回count个字符的子字符串

UKismetStringLibrary::Mid(MyString,2,3);

19. 分割出左右俩字符串

FString Left;
FString Right;
MyString.Split("_",&Left,&Right,ESearchCase::IgnoreCase,ESearchDir::FromStart);

20. 从分割符划分的元字符中获取字符串数组，并可选择剔除空字符

TArray<FString> MyStringArrayParse;
MyString.ParseIntoArray(MyStringArrayParse,TEXt("_"),true);
for(auto TestArray:MyStringArrayParse){
	GEngine->AddOnScreenDebugMessage(-1,5.0f,FColor::Red,FString::Printf(TEXT("%s"),*TestArray));
}

动态材质实例

派生方式

Actor->MyMaterialActor

头文件

1. "Components/StaticMeshComponent.h"
2. "UObject/ConstructorHelpers.h"

声明

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MySceneComponent")
class USceneComponent* MyScene;

UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MySceneComponent")
class UStaticMeshComponent* MyMesh;

UMaterialInstanceDynamic* DynamicMaterial;

定义

1. AMyMaterialActor
   1. 创建组件USceneComponent,和StaticMeshComponent并命名和挂载
   2. 通过FObjectfinder同步加载网格资源到网格体组件上
2. BeginPlay()
   1. beginplay是运行时了，这里是运行时加载一个资产并生成材质
   2. 为网格体贴上材质并生成一个材质句柄返回
   3. 调整材质的两个参数

AMyMaterialActor::AMyMaterialActor()
{
 	// 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;
	MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("MyCustomScene"));
	MyMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyCustomStaticMesh"));

	RootComponent = MyScene;
	MyMesh->SetupAttachment(MyScene);

	static ConstructorHelpers::FObjectFinder<UStaticMesh>TempStaticMesh(TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Shapes/Shape_TriPyramid.Shape_TriPyramid'"));
	MyMesh->SetStaticMesh(TempStaticMesh.Object);

}

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

	UMaterialInterface* Material = LoadObject<UMaterialInterface>(nullptr, TEXT("/Script/Engine.Material'/Game/M_testMaterial.M_testMaterial'"));
	DynamicMaterial = MyMesh->CreateDynamicMaterialInstance(0, Material);
	DynamicMaterial->SetVectorParameterValue("BaseColor", FLinearColor::Red);
	DynamicMaterial->SetScalarParameterValue("BaseMetallic", 1);
}

文件操作

派生方式

BlueprintFunctionLibrary->派生

头文件

1. "Engine/Engine.h"
2. "Misc/FileHelper.h"
3. Runtime/Core/Public/HAL/FileManagerGeneric.h（处理文件夹)

声明

public:
	UFUNCTION(BlueprintCallable, Category="File")
	static bool LoadStringFromFIle(FString FilePath, FString& ResultString);

	UFUNCTION(BlueprintCallable, Category="File")
	static bool WriteStringToFile(TArray<FString>SaveFile, FString FIlePath);

	UFUNCTION(BlueprintCallable,Category="File")
	static FString GetFilePath(FString Path);

	UFUNCTION(BlueprintCallable,Category = "File")
	static FString GetFileName(FString InPath,bool bRemoveForwardPath);

	UFUNCTION(BlueprintCallable,Category="File")
	static FString GetFileExtension(FString InPath, bool bIncludeDot);


	UFUNCTION(BlueprintCallable,Category="File")
	static void CreateFolder(FString FolderName);

	UFUNCTION(BlueprintCallable, Category="FIle")
	static void RemoveFolder(FString FolderName);

	UFUNCTION(BlueprintCallable,Category="FIle")
	static bool MoveFileTo(FString To, FString From);

	UFUNCTION(BlueprintCallable,Category="File")
	static TArray<FString> FindFileFolder(FString Path,FString FileType,bool Files,bool Folders);

定义

bool UMyBlueprintFunctionLibrary::LoadStringFromFIle(FString FilePath, FString& ResultString)
{
	if (!FilePath.IsEmpty())
	{
		if (FFileHelper::LoadFileToString(ResultString,*FilePath))
		{
			return true;
		}
		else
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("error"));
		}
	}
	return false;
}

bool UMyBlueprintFunctionLibrary::WriteStringToFile(TArray<FString>SaveFile, FString FIlePath)
{
	if (!FIlePath.IsEmpty())
	{
		if (FFileHelper::SaveStringArrayToFile(SaveFile,*FIlePath))
		{
			return true;
		}
		else
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("error"));
		}
	}
	return false;
}

FString UMyBlueprintFunctionLibrary::GetFilePath(FString Path)
{
	FString result;
	result = FPaths::GetPath(*Path);
	return result;
}

FString UMyBlueprintFunctionLibrary::GetFileName(FString InPath, bool bRemoveForwardPath)
{
	return FPaths::GetBaseFilename(*InPath, bRemoveForwardPath);
}

FString UMyBlueprintFunctionLibrary::GetFileExtension(FString InPath, bool bIncludeDot)
{
	return FPaths::GetExtension(*InPath, bIncludeDot);
}

void UMyBlueprintFunctionLibrary::CreateFolder(FString FolderName)
{
	FString Path = FPaths::ProjectContentDir() / *FolderName;
	FPlatformFileManager::Get().GetPlatformFile().CreateDirectoryTree(*Path);
}

void UMyBlueprintFunctionLibrary::RemoveFolder(FString FolderName)
{
	FString Path1 = FPaths::ProjectContentDir() / *FolderName;
	FPlatformFileManager::Get().GetPlatformFile().DeleteDirectoryRecursively(*Path1);
}

bool UMyBlueprintFunctionLibrary::MoveFileTo(FString To, FString From)
{
	return IFileManager::Get().Move(*To, *From);
}

TArray<FString> UMyBlueprintFunctionLibrary::FindFileFolder(FString Path, FString FileType, bool Files, bool Folders)
{
	TArray<FString> OutPathList;
	OutPathList.Empty();
	FFileManagerGeneric::Get().FindFilesRecursive(OutPathList, *Path, *FileType, Files, Folders);
	return OutPathList;
}

Delay实现函数

派生方式

Actor->MyMaterialActor

头文件

1. Kismet/KismetSystemLibrary.h

声明

public:
	UFUNCTION()
	void DelayFunctionFinish();

使用

1. UE通过this指针和DelayFunctionFinish这个字符串反射找到UFunction中AMyMaterialActor::DelayFunctionFinish方法，再在Delay中延时回调。
2. 我只能说UE为了兼容蓝图整的操作真心有点看不懂。

void AMyMaterialActor::BeginPlay()
{
	Super::BeginPlay();
	const FLatentActionInfo LatentInfo(0, FMath::Rand(), TEXT("DelayFunctionFinish"), this);
	UKismetSystemLibrary::Delay(this,1.0f ,LatentInfo);
}

其他配置--待回调函数

void AMyMaterialActor::DelayFunctionFinish()
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Delay Finished"));
}

Destory

派生方式

Actor-->MyActor

头文件

无

使用

1. 放在碰撞函数中，调用就销毁Actor。

void AMyActor::BeingOverlapFunction(
	UPrimitiveComponent* OverlappedComponent,
	AActor* OtherActor,
	UPrimitiveComponent* OtherComp,
	int32 OtherBodyIndex,
	bool bFromSweep,
	const FHitResult& SweepResult)
{
	Destory();
}

1. 调用就销毁指定Component

void AMyActor::BeingOverlapFunction(
	UPrimitiveComponent* OverlappedComponent,
	AActor* OtherActor,
	UPrimitiveComponent* OtherComp,
	int32 OtherBodyIndex,
	bool bFromSweep,
	const FHitResult& SweepResult)
{
	MyParticle->DestroyComponent();
}

JSON文件解析

引入模块

PrivateDependencyModuleNames.AddRange(new string[]{"Json","JsonUtilities"});

派生方式

BlueprintFunctionLibrary-->MyBlueprintFunctionLibrary

声明

UFUNCTION(BlueprintCallable,Category="Json")
static void ReadJson(FString JsonValueString);

UFUNCTION(BlueprintCallable,Category = "JsonToMap")
static TMap<FString, FString> JsonToMap(FString JsonValueString);

UFUNCTION(BlueprintCallable,Category = "MapToJson")
static FString MapToJson(TMap<FString, FString> InMap);

定义

读取Json

1. JSonReaderFactory<TJsonReader<TCHAR>>::Create是一个工厂函数，返回一个FString的Json读取器
2. 创建一个根对象，并对读取器进行反序列化到根对象上。
3. 利用根对象获取其中的数据。

void UMyBlueprintFunctionLibrary::ReadJson(FString JsonValueString)
{
	TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(JsonValueString);//通过jsonreader工厂创建一个解析器
	TSharedPtr<FJsonObject> JsonObject;
	bool isOk = FJsonSerializer::Deserialize(JsonReader, JsonObject);
	if (isOk)
	{
		int32  code = JsonObject->GetIntegerField("code");
		FString msg = JsonObject->GetStringField("msg");
		TSharedPtr<FJsonObject> DataObject = JsonObject->GetObjectField("data");
		FString MyUserName = DataObject->GetStringField("username");
		FString MyUserID = DataObject->GetStringField("userid");
		FString MyToken = DataObject->GetStringField("token");
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%d"), code));
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *msg));
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *MyUserName));
	}
}

JsonToMap

1. 使用json工厂函数创建json读取器，并序列化创建根对象。
2. 创建一个数据结构，将对象的key作为key，用指针直接指向对象中的数据。
3. 遍历数据结构，并通过指向对象中数据的指针取数据，并添加到结果中。

TMap<FString, FString> UMyBlueprintFunctionLibrary::JsonToMap(FString JsonValueString)
{
	TMap<FString, FString> result;
	TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(JsonValueString);
	TSharedPtr<FJsonObject> JsonObject;
	bool isOk = FJsonSerializer::Deserialize(JsonReader, JsonObject);
	if (isOk)
	{
		TMap<FString, TSharedPtr<FJsonValue>> keys = JsonObject->Values;
		for (auto currJson = keys.CreateIterator();currJson;++currJson)
		{
			FString key = (*currJson).Key;
			FString value = JsonObject->GetStringField(key);
			result.Add(key, value);
		}
	}

	return result;
}

MapToJson

1. 用一个工厂函数创建一个写入器并指定写入的目标。
2. 创建一个数组存放keys，通过遍历数组，获取key对应的value，并将key和value写入字符串中。
3. TCondensedJsonPrintPolicy是压缩策略(不缩进，不换行，体积最小，最不可读)，TPrettyJsonPrintPolicy会带缩进。

FString UMyBlueprintFunctionLibrary::MapToJson(TMap<FString, FString> InMap)
{
	FString JsonStr;
	TSharedRef<TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>>JsonWriter = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> ::Create(&JsonStr);
	JsonWriter->WriteObjectStart();
	TArray<FString> keys;
	InMap.GetKeys(keys);
	for (size_t i=0;i<keys.Num();i++)
	{
		FString* value = InMap.Find(keys[i]);
		JsonWriter->WriteValue(keys[i], *value);
	}
	JsonWriter->WriteObjectEnd();
	JsonWriter->Close();
	return JsonStr;

}

其他配置

实例json

{
	"code":200,
	"msg":"成功",
	"data":{
		"username":"zhangsan",
		"userid":'123456',
		"token":"adadadsdawdsadw47dad2sd5a4d"
	}
}

GameInstanceSubsystem

派生方式

GameInstanceSubsystem--->MyGameInstanceSubsystem(本质上就是一个全局的单例)

头文件

无

声明

public:
	virtual bool ShouldCreateSubsystem(UObject* Outer) const override;

	virtual void Initialize(FSubsystemCollectionBase& Collection) override;

	virtual void Deinitialize() override;

	static UMyGameInstanceSubsystem* MyInstanceSubsystem;

	UFUNCTION(BlueprintCallable, Category= "MyTestSubsystem")
	static UMyGameInstanceSubsystem* Get();

	UFUNCTION(BlueprintCallable,Category = "MyTestSubsystem")
	void  StartThread();

	UFUNCTION(BlueprintCallable, Category = "MyTestSubsystem")
	void StopThread();

定义

1. Subsystem用单例实现，单例不需要构造方法，它需要一个指向自己的指针MyInstanceSubsystem并设置为nullptr。
2. shouldCreateSubsystem，Initialize,Deinitialize方法。并在初始化中将本实例赋值给指向自己的指针。这三个函数由UE引擎负责调用(因为gamemode和level是关卡级的，而gameinstance和subsystem是游戏级的)，游戏开始根据前者决定是否init，游戏结束调用deinit。

UMyGameInstanceSubsystem* UMyGameInstanceSubsystem::MyInstanceSubsystem = nullptr;


bool UMyGameInstanceSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
	return true;
}

void UMyGameInstanceSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);
	MyInstanceSubsystem = this;
	UE_LOG(LogTemp, Warning, TEXT("Initialize MyGameInstance MySubsystem"));
}

void UMyGameInstanceSubsystem::Deinitialize()
{
	Super::Deinitialize();
	UE_LOG(LogTemp,Warning,TEXT("Deinitialize MyGameInstance MySubsystem"))
}

UMyGameInstanceSubsystem* UMyGameInstanceSubsystem::Get()
{
	return MyInstanceSubsystem;
}

void UMyGameInstanceSubsystem::StartThread()
{
	UE_LOG(LogTemp, Warning, TEXT("StartThread MyGameInstanceSubsystems"));
}

void UMyGameInstanceSubsystem::StopThread()
{
	UE_LOG(LogTemp, Warning, TEXT("StopThread MyGameInstanceSubsystems"));
}

多线程--FRunnable和FRunnableThread

派生方式

None-->MyRunnable,并将方法和类前加上F前缀。并让类继承自FRunnable

class COOPGAME_API FMyRunnable:public FRunnable
{
public:
	FMyRunnable();
	~FMyRunnable();
};

GameInstance

头文件

1. MyRunnable
   1. HAL/Runnable.h
   2. HAL/ThreadSafeBool.h
   3. MyGameInstanceSubsystem.h(Subsystem是进程级的，常用在多线程中)
2. MyGameInstanceSubsystem
   1. MyRunnable.h

声明

MyRunnable

将一个FRunnable类派生的线程对象传入FRunnableThread::Create(),这个对象会自动调用其Init的函数，再根据init函数结果的真假决定调用Run函数与否(所以需要重载)

public:
	FMyRunnable();

	FMyRunnable(FString InThreadName);

	~FMyRunnable();

	virtual bool Init() override;

	virtual uint32 Run() override;

	virtual void Stop() override;

	virtual void Exit() override;

	FString ThreadName;
	bool IsRunning;

MyGameInstanceSubsystem

protected:
	TSharedPtr<FMyRunnable> MyRunnable;
	FRunnableThread* MyRunnableThread;

定义

MyRunnable

MyRunnable这个类，负责多线程需要执行的一个函数，类似于单独存在的线程(消息队列).

1. Run方法
   1. 调整InRunning并进入循环，每三秒获取一次单例对象Instance。

FMyRunnable::FMyRunnable()
{
	UE_LOG(LogTemp,Warning,TEXT("Constructor Function0"))
}

FMyRunnable::FMyRunnable(FString InThreadName):ThreadName(InThreadName)
{
	UE_LOG(LogTemp, Warning, TEXT("Constructor Function1"))
}

FMyRunnable::~FMyRunnable()
{
	UE_LOG(LogTemp, Warning, TEXT("DeConstructor Function0"))
}

bool FMyRunnable::Init()
{
	UE_LOG(LogTemp, Warning, TEXT("Init Runnable "));
	return true;
}

uint32 FMyRunnable::Run()
{
	IsRunning = true;
	while (IsRunning)
	{
		FPlatformProcess::Sleep(3.0);
		UMyGameInstanceSubsystem* Instance = UMyGameInstanceSubsystem::Get();
		if (Instance)
		{
			UE_LOG(LogTemp, Warning, TEXT("Run Thread"));
		}
	}
	return uint32();
}

void FMyRunnable::Stop()
{
	IsRunning = false;
	UE_LOG(LogTemp, Warning, TEXT("Stop Thread"));
}

void FMyRunnable::Exit()
{
	UE_LOG(LogTemp,Warning,TEXT("Exit Thread"))
}

MyGameInstanceSubsystem

MyGameInstanceSubsystem负责线程的创建，以及线程中运行的功能。

1. StartThread
   1. 通过FMyRunnable的构造方法创建一个对象
   2. 使用FRunnableThread::Create(线程体，线程名),将一个FRunnable类派生的线程对象传入FRunnableThread::Create(),这个对象会自动调用其Init的函数，再根据init函数结果的真假决定调用Run函数与否(所以需要重载)
2. StopThread()
   1. 在线程对象合法时停止线程
   2. 在线程池合法时等待线程结束并删除线程，并将线程置为null.

void UMyGameInstanceSubsystem::StartThread()
{
	//创建对象
	MyRunnable = MakeShared<FMyRunnable>(TEXT("MyRunnable"));
	//创建线程
	MyRunnableThread = FRunnableThread::Create(MyRunnable.Get(),*(MyRunnable->ThreadName));

	UE_LOG(LogTemp, Warning, TEXT("StartThread MyGameInstanceSubsystems"));
}

void UMyGameInstanceSubsystem::StopThread()
{
	if (MyRunnable.IsValid())
	{
		MyRunnable->Stop();
	}
	if (MyRunnableThread)
	{
		MyRunnableThread->WaitForCompletion();
		delete MyRunnableThread;
		MyRunnableThread = nullptr;
	}
	UE_LOG(LogTemp, Warning, TEXT("StopThread MyGameInstanceSubsystems"));
}

多线程--AsyncTask

派生方式

None-->FMyAsyncTask
Actor-->MyAsyncTestActor(测试用)

头文件

FMyAsyncTask

1. Async/AsyncWork.h
   MyAsyncTestActor
2. FMyAsyncTask.h

声明

1. FNonAbandonableTask告诉线程池，此任务不可以被取消，必须dowork完才嗯释放
2. 通过友元声明将此类列入到线程管家(估计也是某个类)的友元中，让它可以访问此类的私有和受保护方法。
3. FORCENOINLINE用于强制要求编译器不可以使用内联策略(如某个函数只有一行代码运算，编译器通过内联策略，将这个函数取消替换成一行别的代码,提升了性能，但也无法从堆栈分析调试了)
4. RETURN_QUICK_DECLARE_CYCLE_STAT本质上就是返回此函数的一个生成的id(程序运行前就创建了)用于计时此线程的耗时。（两个参数分别是任务名称和任务ID）

class COOPGAME_API FMyAsyncTask : public FNonAbandonableTask
{

	friend class FAutoDeleteAsyncTask<FMyAsyncTask>;
public:
	FMyAsyncTask();
	~FMyAsyncTask();

public:
	void DoWork();

	FORCENOINLINE TStatId GetStatId() const
	{
		RETURN_QUICK_DECLARE_CYCLE_STAT(FMyAsyncTask,STATGROUP_ThreadPoolAsyncTasks);
	}
	FORCENOINLINE static const TCHAR* GetTaskName()
	{
		return TEXT("FMyAsyncTask");
	}
};

定义

FMyAsyncTask::~FMyAsyncTask()
{
	UE_LOG(LogTemp, Warning, TEXT("AsyncTask End>>>>>>>>>>>>>>"));
}

void FMyAsyncTask::DoWork()
{
	UE_LOG(LogTemp,Warning,TEXT("AsyncTask Start>>>>>>>>"));
	for (int32 i=0;i<1000;i++)
	{
		UE_LOG(LogTemp, Warning, TEXT("i=%d"),i);
	}

}

使用

在MyAsyncTaskActor中

1. FAutoDelegateAsyncTask包裹的Task会任务跑完自动Delete
2. FMyAsyncTask类必须继承自NonAbandonableTask且实现DoWork();
3. StartBackgroundTask的底层确实在经过一批判断后调用了DoWork。

void AMyAsyncTaskActor::BeginPlay()
{
	Super::BeginPlay();
	FAutoDeleteAsyncTask<FMyAsyncTask>* MyTask = new FAutoDeleteAsyncTask<FMyAsyncTask>();
	MyTask->StartBackgroundTask();//异步线程
//	MyTask->StartSynchronousTask();//当前线程
}

多线程--Async

派生方式

Actor-->MyAsyncTaskActor

头文件

Async/Async.h

使用

void AMyAsyncTaskActor::BeginPlay()
{
	Super::BeginPlay();
	Async(EAsyncExecution::ThreadPool, []
		{
			for (int32 i = 0; i < 1000; ++i)
			{
				UE_LOG(LogTemp, Warning, TEXT("i=%d"), i);
			}
		});

	
}

多线程--综述

1. AsyncTask:是一个模板类，创建按在后台线程运行的任务，它可以在任务完成后自动删除自己，很适合用于创建按一次性的异步任务。例如用于加载资源，或者进行一次复杂的计算，或者http请求后端资源。
2. Async:是一个函数，用于后台线程运行一个Lambda表达式，很适合创建简单的异步任务，如加载资源和一次复杂的计算。
3. FRunnable:是一个接口，用于创建一个在单独线程上运行的任务，它需要手动管理生命周期，适合复杂任务。例如WebSocket做与后端的长连接，长时间任务。

编码处理--Base64

我现在感觉之前网上到处找第三方实现的我像个傻叉，不过我感觉也不怪我，U++相关的api介绍真的挺少，官方的API介绍太简洁且API又太多，谁会乐意每次差一个api等半天浏览器响应呢？

声明

//字符串到base64
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static FString StringToBase64Encode(const FString& Source);

//字节到base64
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static FString BytesToBase64Encode(const TArray<uint8>& Source);

//Bas64到字符串
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static bool Base64DecodeFString(const FString& Source,FString& Dest);

//Bas64到字节
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static bool Base64DecodeBytes(const FString& Source,TArray<uint8>& Dest);

定义

FString UFileSystemBPLibrary::StringToBase64Encode(const FString& Source)
{
	return FBase64::Encode(Source);
}

FString UFileSystemBPLibrary::BytesToBase64Encode(const TArray<uint8>& Source)
{
	return FBase64::Encode(Source);
}

bool UFileSystemBPLibrary::Base64DecodeFString(const FString& Source, FString& Dest)
{
	return FBase64::Decode(Source, Dest);
}

bool UFileSystemBPLibrary::Base64DecodeBytes(const FString& Source, TArray<uint8>& Dest)
{
	return FBase64::Decode(Source, Dest);
}

编码处理--URL

头文件

GenericPlatform/GenericPlatfoormHttp.h

模块引入

http

声明

UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString URLEncode(const FString& Source);

UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString URLDecode(const FString& Source);

定义

FString UFileSystemBPLibrary::URLEncode(const FString& Source)
{
	return FGenericPlatformHttp::UrlEncode(Source);
}

FString UFileSystemBPLibrary::URLDecode(const FString& Source)
{
	return FGenericPlatformHttp::UrlDecode(Source);
}

编码处理--MD5

声明

UFUNCTION(BlueprintPure,Category = "CommonFunctionLibrary")
static FString MD5Encode(const FString& Source);

定义

FString UFileSystemBPLibrary::MD5Encode(const FString& Source)
{
	return FMD5::HashAnsiString(*Source);
}

时间戳

声明

//获得UTC时间戳
UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString GetUTCTimestamp();

//UTC毫秒级13位时间戳
UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString GetMillUTCTimestamp();

//RFC1123时间和时区表示
UFUNCTION(BlueprintPure,Category = "CommonFunctionLibrary")
static FString GetUTCRFC1123();

定义

FString UFileSystemBPLibrary::GetUTCTimestamp()
{
	FString TImestamp;
	FDateTime Time = FDateTime::UtcNow();
	int64 unixTimestamp = Time.ToUnixTimestamp();
	TImestamp = FString::Printf(TEXT("%lld"), unixTimestamp);
	return TImestamp;
}

FString UFileSystemBPLibrary::GetMillUTCTimestamp()
{
	FDateTime CurrentTime = FDateTime::UtcNow();
	int64 TimestampMillSeconds = CurrentTime.ToUnixTimestamp() * 1000 + CurrentTime.GetMillisecond();
	FString  MillTimestamp;
	MillTimestamp = FString::Printf(TEXT("%lld"), TimestampMillSeconds);
	return MillTimestamp;
}

FString UFileSystemBPLibrary::GetUTCRFC1123()
{
	return FDateTime::UtcNow().ToHttpDate();
}

单例设计

概念

让一个类有且仅有一个实例，提供一个访问该实例的节点，仅在首次请求单例对象时进行初始化。

方案

将默认构造函数设为私有，放置其他对象使用单例类的new运算符。新建一个静态构造方法作为构造函数。

派生方式

UObject---->SingletonObject

声明

1. 在类中定义一个指向本类的指针用private藏好，并初始化为nullptr。
2. 定义获取instance方法，进行首次的初始化。
3. 用static进行修饰让USingletonObject指针存放的值在此类中唯一化,即此类只能存在一个这个值，怎么new都只有一个。如果不适用static修饰需要参考原始的C++方式(手动删除构造方法，拷贝构造方法，赋值构造方法)

public:
	UFUNCTION(BlueprintCallable)
	static USingletonObject* GetSingletonObjectInstance();

	UFUNCTION(BlueprintCallable)
	void SetValue(int32 NewValue);

	UFUNCTION(BlueprintCallable)
	int32 GetValue();

private:
	static USingletonObject* SingletonObject;
	int32 value;

定义

USingletonObject* USingletonObject::SingletonObject = nullptr;

USingletonObject* USingletonObject::GetSingletonObjectInstance()
{
	if (SingletonObject == nullptr)
	{
		SingletonObject = NewObject<USingletonObject>();
	}
	return SingletonObject;
}

void USingletonObject::SetValue(int32 NewValue)
{
	value = NewValue;
}

int32 USingletonObject::GetValue()
{
	return  value;
}

简单工厂设计

概念

向一个工厂类传入参数就能创建来源于Prototype抽象类的其他类。

方案

1. 创建抽象Prototype类
2. 基于Prototype派生具体类
3. 创建工厂类，通过静态方法根据传入不通的参数从而创建不通的派生类实例。

派生方式

1. UObject---->ProtoTypeObject
2. ProtoTypeObject--->MyProductA
3. ProtoTypeObject--->MyProductB
4. UObject---->FactoryObject
5. Actor---->FactorActor(测试与使用)

头文件

FactoryObject

1. ProtoTypeObject.h

FactorActor

1. ProtoTypeObject.h
2. FactoryObject.h
3. MyProductA.h
4. MyProductB.h

声明与定义

ProtoTypeObject

1. 需指定UCLASS为Abstract，抽象类，
2. 通过virtual创建接口。

UCLASS(Abstract)
class COOPGAME_API UProtoTypeObject : public UObject
{
	GENERATED_BODY()

public:
	virtual void ShowInfo() { UE_LOG(LogTemp, Warning, TEXT("ProtoTypeObject")) };
};

ProductA和B

1. 重写ProtoType提供的接口

//ProductA
public:
	virtual void ShowInfo() override{UE_LOG(LogTemp,Warning,TEXT("This is ProductA"))};
	
	
//ProductB
public:
	virtual void ShowInfo() override{UE_LOG(LogTemp,Warning,TEXT("This is ProductB"))};

FactoryObject

1. 传入一个兼容的类对象的指针用于存放产品对象
2. 传入要生产的产品类

public:
	static UProtoTypeObject* CreateNewProduct(UObject* Outer, TSubclassOf<UProtoTypeObject> ProductClass)
	{
		return NewObject<UProtoTypeObject>(Outer, ProductClass);
	};

使用

void AMyFactoryActor::BeginPlay()
{
	Super::BeginPlay();
	UProtoTypeObject* ProductA = UFactoryObject::CreateNewProduct(this,UMyProductA::StaticClass());
	UProtoTypeObject* ProductB = UFactoryObject::CreateNewProduct(this,UMyProductB::StaticClass());
	
	ProductA->ShowInfo();
	ProductB->ShowInfo();
}