Epic 官方视频教程《 Battery Collector》源码+超详细注释【C++】【UE4】

视频教程链接：

优酷链接

油管链接 【需要梯子】

首先来看效果图：

1. 电池随机从天空掉落，玩家按C键收集电池的能量（闪电粒子效果）来补充血条（每秒都会自动衰减）



2.玩家的颜色随着血条的减少，逐渐变黑



3.当血条为空时，玩家（黑色的那一坨）死亡，游戏结束；如果玩家提前集满血条则获胜。



以下是完整的源代码，并配套详细解释：

Pickup.h

[cpp] view
plain copy

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

#pragma once// 防止多次引用头文件

#include "GameFramework/Actor.h"

#include "Pickup.generated.h" // 必须是最后 include 的头文件，它是UHT（Unreal Header Tool）根据你声明的宏自动生成的

// 该宏将类暴露给 Unreal 的反射系统，允许我们在运行时检查和迭代对象的属性（比如 GC 中的对对象引用计数的管理）

// 1. 意味着当你创建一个对象，UE4会帮助你进行内存管理（智能指针来自动对垃圾内存进行回收），但前提是遵循了 UE4 的构造/销毁规范（比如自己手动 new 出的对象就不能被 UE4 回收）；

// 2. 默认使得该类可以被编辑器和蓝图访问；

// 3. 如果将 Bluerpintable 改为 Blueprinttype，那么该类在蓝图中就只能作为 variable 访问了。（还有 NotBlueprintType 类型；Blueprintable 和 BlueprintType 兼容）

UCLASS(Blueprintable)

class BATTERYCOLLECTOR_API APickup : public AActor // BATTERYCOLLECTOR_API也是由UHT创建的宏，确保该类正确输出到 DLL 中

{

GENERATED_BODY()// 导入一些 UE 系统需要的自动生成的方法。与 GENERATED_CLASS_BODY 的区别 http://blog.csdn.net/a359877454/article/details/52511893
// 为类声明一个 Log Category

DECLARE_LOG_CATEGORY_CLASS(Pickup, Log, All);

public:

// Sets default values for this actor's properties

APickup();

// Called when the game starts or when spawned

virtual void BeginPlay() override;

// Called every frame

virtual void Tick( float DeltaSeconds ) override;

// 返回 pickup 模型（注意，内联方法和UFUNCTION不兼容）

FORCEINLINE class UStaticMeshComponent* GetMesh() const { return PickupMesh; }

// BlueprintPure / BlueprintCallable 表示两者都可以从蓝图端被调用，

// BlueprintPure 意味着该方法不会修改成员数据，且只要 output pin 被使用其就会执行（它也没有exec input pin）；

// 但 BlueprintCallable 的执行需要连接exec input pin ，然后结果由 output pin 输出。

UFUNCTION(BlueprintPure, Category = "Pickup")

bool IsActive();

// 安全地修改 bIsActive 成员【UFUNCTION 的好处：1.通过添加一些额外的代码，使其可以被蓝图重写；2.在游戏运行时，可以通过命令行来调用，便于调试】

UFUNCTION(BlueprintCallable, Category = "Pickup")

void SetActive(bool NewPickupState);

// 当 pickup 被收集时需要调用的方法

// BlueprintNativeEvent：表示该方法既在 C++ 中定义一些行为，也可以被蓝图中定义一些行为 (C++方法为蓝图同名方法的父方法)

// 注意和 BlueprintImplementableEvents 的区别（既可以通知蓝图有C++层的事件发生，还可以为它额外提供一些信息）

UFUNCTION(BlueprintNativeEvent)

void WasCollected();

virtual void WasCollected_Implementation(); // ❤

protected:

// pickup 是否被激活

bool bIsActive;

private:

// 关卡中的可拾取物（静态模型）—— pickup

// 1. VisibleAnywhere：表示 PickupMesh 属性在 Class Defaults 和它的实例（将蓝图拖动到关卡中） 中都是可见的，但不可编辑【 参见 search “放大镜”右侧的 "Open Selection in Property Matrix" 图标】

// http://blog.csdn.net/xi_niuniu/article/details/54409648
//

// 2. 如果没有 AllowPrivateAccess 的话，BlueprintReadOnly 在 private 下就会编译失败（通常是 public），其作用使得 PickMesh 在蓝图编辑器中可以 Get 到

// 3. BlueprintReadOnly ：表示在蓝图下只能 Get，不能 Set; BlueprintDefaultsOnly: 表示在运行前蓝图中的默认值是可以修改的，但运行中蓝图就不能修改它

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Pickup", meta = (AllowPrivateAccess = "true"))

class UStaticMeshComponent* PickupMesh;// Actor subobject

};

Pickup.cpp

[cpp] view
plain copy

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

#include "BatteryCollector.h" // 切记放在第一个

#include "Pickup.h"

DEFINE_LOG_CATEGORY_CLASS(APickup, Pickup)

//#define _DEBUG_ 1

// 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 = false; // true

// 所有 pickup 默认为 true

bIsActive = true;

// 创建一个静态模型

PickupMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("PickupMesh"));// subobject的名字为“PickupMesh”

RootComponent = PickupMesh;

}

// Called when the game starts or when spawned

void APickup::BeginPlay()

{

Super::BeginPlay();

}

// Called every frame

void APickup::Tick( float DeltaTime )

{

Super::Tick( DeltaTime );

}

bool APickup::IsActive()

{

return bIsActive;

}

void APickup::SetActive(bool NewPickupState)

{

bIsActive = NewPickupState;

}

void APickup::WasCollected_Implementation()

{

#ifdef _DEBUG_

FString PickupDebugString = GetName();

UE_LOG(Pickup, Warning, TEXT("You have collected %s"), *PickupDebugString);

#endif

}

BatteryPick.h

[cpp] view
plain copy

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

#pragma once

#include "Pickup.h"

#include "BatteryPickup.generated.h"

/**

*

*/

UCLASS()

class BATTERYCOLLECTOR_API ABatteryPickup : public APickup

{

GENERATED_BODY()

public:

ABatteryPickup();

// BlueprintNativeEvent

void WasCollected_Implementation() override;

// 获取 battery power（注意：此方法蓝图不可调用）

float GetPower();

protected:

// BlueprintProtected：表示只有继承了这个类的蓝图才可以修改这个变量

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

float BatteryPower;

};

BatteryPick.cpp

[cpp] view
plain copy

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

#include "BatteryCollector.h" // 切记放在第一个

#include "BatteryPickup.h"

ABatteryPickup::ABatteryPickup()

{

// 记得为 SM_Batter_Medium 设置 Collision

GetMesh()->SetSimulatePhysics(true);

BatteryPower = 150.f;

}

void ABatteryPickup::WasCollected_Implementation()

{

// 调用父类的方法

Super::WasCollected_Implementation();

// 销毁 battery

Destroy();// 相关方法：SetLifeSpan，允许在destroy方法调用之后，坚挺若干时间

}

float ABatteryPickup::GetPower()

{

return BatteryPower;

}

SpawnVolume.h

[cpp] view
plain copy

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

#pragma once

#include "GameFramework/Actor.h"

#include "SpawnVolume.generated.h"

UCLASS()

class BATTERYCOLLECTOR_API ASpawnVolume : public AActor

{

GENERATED_BODY()

DECLARE_LOG_CATEGORY_CLASS(SpawnVolume, Log, All); // 为类声明一个 Log Category

public:

// Sets default values for this actor's properties

ASpawnVolume();

// Called when the game starts or when spawned

virtual void BeginPlay() override;

// Called every frame

virtual void Tick( float DeltaSeconds ) override;

FORCEINLINE class UBoxComponent* GetWhereToSpawn() const { return WhereToSpawn; }

// 返回一个 BoxComponent 范围内的随机点

// 注意：它不会改变 SpawnVolume，也不会改变 SpawnVolume 的行为

UFUNCTION(BlueprintPure, Category = "Spawning")

FVector GetRandomPointInVolume();

// 是否继续产生电池

UFUNCTION(BlueprintCallable, Category = "Spawning")

void SetSpawningActive(bool bShouldSpawn);

protected:

// 产生的 pickup，同时限制了蓝图上显示的类型必须是继承自 Pickup 类

UPROPERTY(EditAnywhere, Category = "Spawning")

TSubclassOf<class APickup> WhatToSpawn;// 具体可以参考 <UE4 Scripting with C++ Cookbook> p49 (NewObject<>, ConstructObject<>, ConditionalBeginDestroy)

// 如果是自定义的C++类指针，且非UObject的派生类（已有引用计数），那么可以使用TSharedPtr, TWeakPtr, TAutoPtr（非线程安全）TScopedPointer 来自动管理内存

// 计时器的句柄，可以用它来 cancel 定时器

FTimerHandle SpawnTimer;

// 最小延迟

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")

float SpawnDelayRangeLow;

// 最大延迟

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")

float SpawnDelayRangeHigh;

private:

// Box 组件，指定 Pickup 在哪里产生

// VisibleAnywhere

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Spawning", meta = (AllowPrivateAccess = "true"))

class UBoxComponent* WhereToSpawn;

void SpawnPickup();

// 真实的延迟

float SpawnDelay;

};

SpawnVolume.cpp

[cpp] view
plain copy

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

#include "BatteryCollector.h" // 切记放在第一个

#include "EngineGlobals.h"

#include "Runtime/Engine/Classes/Engine/Engine.h"

//#include "UnrealMathUtility.h"

#include "Kismet/KismetMathLibrary.h"

#include "Pickup.h"

#include "SpawnVolume.h"

DEFINE_LOG_CATEGORY_CLASS(ASpawnVolume, SpawnVolume)

//#define _DEBUG_ 1

// Sets default values

ASpawnVolume::ASpawnVolume()

{

// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.

PrimaryActorTick.bCanEverTick = false;

WhereToSpawn = CreateDefaultSubobject<UBoxComponent>(TEXT("WhereToSpawn"));

RootComponent = WhereToSpawn;

SpawnDelayRangeLow = 1.f;

SpawnDelayRangeHigh = 4.5f;

}

// Called when the game starts or when spawned

void ASpawnVolume::BeginPlay()

{

Super::BeginPlay();

}

// Called every frame

void ASpawnVolume::Tick( float DeltaTime )

{

Super::Tick( DeltaTime );

}

FVector ASpawnVolume::GetRandomPointInVolume()

{

FVector SpawnOrigin = WhereToSpawn->Bounds.Origin;

FVector SpawnExtend = WhereToSpawn->Bounds.BoxExtent;

// ❤

//FBox box = FBox::BuildAABB(SpawnOrigin, SpawnExtend);

//FVector SpawnRand = FMath::RandPointInBox(box);

FVector SpawnRand = UKismetMathLibrary::RandomPointInBoundingBox(SpawnOrigin, SpawnExtend);

#ifdef _DEBUG_

// Output Log

//UE_LOG(SpawnVolume,

// Warning,

// TEXT("SpawnRand is (%3.2f, %3.2f, %3.2f)"),

// SpawnRand.X, SpawnRand.Y, SpawnRand.Z);

// Screen Log

GEngine->AddOnScreenDebugMessage(-1,

5.f,

FColor::Yellow,

FString::Printf(TEXT("SpawnRand: x: %f, y: %f, z: %f"),

SpawnRand.X, SpawnRand.Y, SpawnRand.Z));

#endif

return SpawnRand;

}

void ASpawnVolume::SpawnPickup()

{

if (WhatToSpawn != NULL)

{

UWorld* const World = GetWorld();// 当前的 UWorld 实例

if (World)

{

FActorSpawnParameters SpawnParams;

SpawnParams.Owner = this;

SpawnParams.Instigator = Instigator;

// 随机 pickup 的位置

FVector SpawnLocation = GetRandomPointInVolume();

// 随机 pickup 的方向

FRotator SpawnRotation;

SpawnRotation.Pitch = FMath::FRand() * 360.f; // 绕 Y 轴旋转 Right Axis

SpawnRotation.Yaw = FMath::FRand() * 360.f; // 绕 Z 轴旋转 Up Axis

SpawnRotation.Roll = FMath::FRand() * 360.f; // 绕 X 轴旋转 Forward Axis

// 生产 pickup

APickup* const SpawnedPickup = World->SpawnActor<APickup>(WhatToSpawn, SpawnLocation, SpawnRotation, SpawnParams);

// 重新随机一个延时

SpawnDelay = FMath::FRandRange(SpawnDelayRangeLow, SpawnDelayRangeHigh);

// 绑定一个延时方法到全局计时器（不循环执行）

GetWorldTimerManager().SetTimer(SpawnTimer, this, &ASpawnVolume::SpawnPickup, SpawnDelay, false);

}

}

}

void ASpawnVolume::SetSpawningActive(bool bShouldSpawn)

{

if (bShouldSpawn)

{

// 随机一个延时

SpawnDelay = FMath::FRandRange(SpawnDelayRangeLow, SpawnDelayRangeHigh);

// 绑定一个延时方法到全局定时器（不循环执行），即在 SpawnDelay 秒之后执行 SpawnPickup 方法

GetWorldTimerManager().SetTimer(SpawnTimer, this, &ASpawnVolume::SpawnPickup, SpawnDelay, false);

}

else

{

// 清除定时器

GetWorldTimerManager().ClearTimer(SpawnTimer);

}

}

BatteryCollectorGameMode.h

[cpp] view
plain copy

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.

#pragma once

#include "GameFramework/GameModeBase.h"

#include "BatteryCollectorGameMode.generated.h"

// 用于存储 gameplay 当前状态的枚举

UENUM(BlueprintType)

enum class EBatteryPlayState

{

EPlaying,

EGameOver,

EWon,

EUnknow

};

UCLASS(minimalapi)

class ABatteryCollectorGameMode : public AGameModeBase

{

GENERATED_BODY()

// 为类声明一个 Log Category

DECLARE_LOG_CATEGORY_CLASS(BatteryCollectorGameMode, Log, All);

public:

ABatteryCollectorGameMode(); // GameMode类负责定义游戏的规则

// 该方法在构造方法之后，在 tick 方法之前执行,

// 那时所有东西已经注册完毕了。

// 确保执行该方法时 character 已经构建完成

virtual void BeginPlay() override;

virtual void Tick(float DeltaTime) override;

UFUNCTION(BlueprintPure, Category = "Power")

float GetPowerToWin() const;

// 获取当前的游戏状态

UFUNCTION(BlueprintPure, Category = "Power")

EBatteryPlayState GetCurrentState() const;

void SetCurrentState(EBatteryPlayState NewState);

protected:

// character 的 power 的衰减率

//（可以通过设置不同的衰减率，设计不同难度的关卡，只需要切换GameMode即可）

// 该属性只有Class Defulats Detail 窗口可以编辑，拖入关卡的蓝图实例 Detail 窗口无法编辑（如果可拖拽到关卡中）

UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

float DecayRate;

UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

float PowerToWin;

// 用于 HUD 的 Widget 类（限制必须继承与 UUserWidget）

UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

TSubclassOf<class UUserWidget> HUDWidgetClass;

// HUD 实例

UPROPERTY() // 利用 GC 【GetWorld()->ForceGarbageCollection(true) 会强制 GC】

class UUserWidget* CurrentWidget;

private:

// 记录当前游戏的状态

EBatteryPlayState CurrentState;

// 记录关卡中所有的 SpawnActor 【即使不想在蓝图中编辑，也最好声明为 UPROPERTY()，让UE4管理 TArray 的内存】

TArray<class ASpawnVolume*> SpawnVolumeActors;

void HandleNewState(EBatteryPlayState NewState);

};

BatteryCollectorGameMode.cpp

[cpp] view
plain copy

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.

#include "BatteryCollector.h" // 切记放在第一个

#include "EngineGlobals.h"

#include "Runtime/Engine/Classes/Engine/Engine.h"

#include "Kismet/GameplayStatics.h"

#include "Runtime/UMG/Public/Blueprint/UserWidget.h" // 不是 <Blueprint/UserWidget>

#include "BatteryCollectorGameMode.h"

#include "BatteryCollectorCharacter.h"

#include "SpawnVolume.h"

//#define _DEBUG_ 1

DEFINE_LOG_CATEGORY_CLASS(ABatteryCollectorGameMode, BatteryCollectorGameMode)

ABatteryCollectorGameMode::ABatteryCollectorGameMode()

{

PrimaryActorTick.bCanEverTick = true; // ❤

// 将蓝图玩家类设为默认的 pawn class。 类似还有 ContructorHelpers::FObjectFinder，用于 Load Asset

static ConstructorHelpers::FClassFinder<APawn> PlayerPawnBPClass(TEXT("/Game/ThirdPersonCPP/Blueprints/ThirdPersonCharacter"));

if (PlayerPawnBPClass.Class != NULL)

{

DefaultPawnClass = PlayerPawnBPClass.Class;

}

DecayRate = .01f; // 0.01f;

}

void ABatteryCollectorGameMode::BeginPlay()

{

Super::BeginPlay();

// 查找所有的 Spawn Volume Actor

TArray<AActor*> FoundActors;

// GetWorld 返回缓存的世界指针；

// 返回指定的类在世界中的所有 actor；

// 该方法会遍历整个关卡，比较耗性能

UGameplayStatics::GetAllActorsOfClass(GetWorld(), ASpawnVolume::StaticClass(), FoundActors);

for (auto Actor : FoundActors)

{

// 如果转换成功，即该 Actor 是 SpawnVolumeActor 类型

ASpawnVolume* SpawnVolumeActor = Cast<ASpawnVolume>(Actor);

if (SpawnVolumeActor)

{

// 确保不会重复添加

SpawnVolumeActors.AddUnique(SpawnVolumeActor);

}

}

// 初始设置游戏状态

SetCurrentState(EBatteryPlayState::EPlaying);

ABatteryCollectorCharacter* MyCharacter = Cast<ABatteryCollectorCharacter>(UGameplayStatics::GetPlayerPawn(this, 0));

if (MyCharacter)

{

PowerToWin = MyCharacter->GetInitialPower() * 1.25f;

}

// UMG

if(HUDWidgetClass != nullptr)

{

CurrentWidget = CreateWidget<UUserWidget>(GetWorld(), HUDWidgetClass);

if (CurrentWidget != nullptr)

{

CurrentWidget->AddToViewport();

}

}

}

void ABatteryCollectorGameMode::Tick(float DeltaTime)

{

Super::Tick(DeltaTime);

#ifdef _DEBUG_

// Screen Log

//GEngine->AddOnScreenDebugMessage(-1,

// 5.f,

// FColor::Red,

// FString::Printf(TEXT("GameMode: %s"), TEXT("Tick")));

GEngine->AddOnScreenDebugMessage(-1,

5.f,

FColor::Red,

FString::Printf(TEXT("GameMode: Tick")));

#endif

// 获取指定 index 的 player pawn，并转化为 ABatteryCollectorCharacter

ABatteryCollectorCharacter* MyCharacter = Cast<ABatteryCollectorCharacter>(UGameplayStatics::GetPlayerPawn(this, 0));

if (MyCharacter)

{

// 如果玩家的能量已经集齐到一定值则胜利

if (MyCharacter->GetCurrentPower() > PowerToWin)

{

SetCurrentState(EBatteryPlayState::EWon);

}

// 如果玩家能量为正

else if (MyCharacter->GetCurrentPower() > 0.f)

{

// 玩家能量随时间衰减

MyCharacter->UpdatePower(-DeltaTime*DecayRate*(MyCharacter->GetInitialPower()));

}

else

{

SetCurrentState(EBatteryPlayState::EGameOver);

}

}

}

float ABatteryCollectorGameMode::GetPowerToWin() const

{

return PowerToWin;

}

EBatteryPlayState ABatteryCollectorGameMode::GetCurrentState() const

{

return CurrentState;

}

void ABatteryCollectorGameMode::SetCurrentState(EBatteryPlayState NewState)

{

CurrentState = NewState;

HandleNewState(CurrentState);

}

void ABatteryCollectorGameMode::HandleNewState(EBatteryPlayState NewState)

{

switch (NewState)

{

case EBatteryPlayState::EPlaying:

{

for (ASpawnVolume* Volume : SpawnVolumeActors)

{

Volume->SetSpawningActive(true);

}

}

break;

case EBatteryPlayState::EWon:

{

for (ASpawnVolume* Volume : SpawnVolumeActors)

{

Volume->SetSpawningActive(false);

}

}

break;

case EBatteryPlayState::EGameOver:

{

for (ASpawnVolume* Volume : SpawnVolumeActors)

{

Volume->SetSpawningActive(false);

}

APlayerController* PlayerController = UGameplayStatics::GetPlayerController(this, 0);

if (PlayerController)

{

// 禁用部分输入，但不会隐藏玩家和 HUD

PlayerController->SetCinematicMode(true, false, false, true, true);

}

// 加入布娃娃系统

// 必须确保它是 Chacater 而不是 Pawn，因为 Character 具有额外的动作和骨骼模型

ACharacter* MyCharacter = UGameplayStatics::GetPlayerCharacter(this, 0);

if (MyCharacter)

{

// 使得玩家可以像布娃娃一样“摊倒”

//（确保 Mannequin/Character/Mesh/ 目录下的 SK_Mannequin 已创建了 Physics Asset）

// （确保 ThirdPersonCPP/Blueprints/ 目录下的 ThirdPersonCharacter，其中 Mesh 组件的 Collision 被激活 [自定义预设]）

MyCharacter->GetMesh()->SetSimulatePhysics(true);

// 禁用跳跃动作

MyCharacter->GetMovementComponent()->MovementState.bCanJump = false;

}

}

break;

default:

case EBatteryPlayState::EUnknow:

{

// 保留

}

break;

}

}

BatteryCollectorCharacter.h

[cpp] view
plain copy

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.

#pragma once

#include "GameFramework/Character.h"

#include "BatteryCollectorCharacter.generated.h"

UCLASS(config=Game)

class ABatteryCollectorCharacter : public ACharacter

{

GENERATED_BODY()

/** Camera boom positioning the camera behind the character */

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

class USpringArmComponent* CameraBoom;

/** Follow camera */

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

class UCameraComponent* FollowCamera;

// CollectionSphere 组件

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Power, meta = (AllowPrivateAccess = "true"))

class USphereComponent* CollectionSphere;

public:

ABatteryCollectorCharacter();

/** Base turn rate, in deg/sec. Other scaling may affect final turn rate. */

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)

float BaseTurnRate;

/** Base look up/down rate, in deg/sec. Other scaling may affect final rate. */

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)

float BaseLookUpRate;

// power 的 Getter 和 Setter

UFUNCTION(BlueprintPure, Category = "Power")

float GetInitialPower();

UFUNCTION(BlueprintPure, Category = "Power")

float GetCurrentPower();

UFUNCTION(BlueprintCallable, Category = "Power")

void UpdatePower(float PowerChange);

protected:

/** Resets HMD orientation in VR. */

void OnResetVR();

/** Called for forwards/backward input */

void MoveForward(float Value);

/** Called for side to side input */

void MoveRight(float Value);

/**

* Called via input to turn at a given rate.

* @param Rate This is a normalized rate, i.e. 1.0 means 100% of desired turn rate

*/

void TurnAtRate(float Rate);

/**

* Called via input to turn look up/down at a given rate.

* @param Rate This is a normalized rate, i.e. 1.0 means 100% of desired turn rate

*/

void LookUpAtRate(float Rate);

/** Handler for when a touch input begins. */

void TouchStarted(ETouchIndex::Type FingerIndex, FVector Location);

/** Handler for when a touch input stops. */

void TouchStopped(ETouchIndex::Type FingerIndex, FVector Location);

// APawn interface

virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

// End of APawn interface

// 按下按键，收集一个在 collection sphere 范围内的 pickup

UFUNCTION(BlueprintCallable, Category = "Pickups")

void CollectPickups();

// character 初始的 power

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

float InitialPower;

// 玩家的速度因子

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

float SpeedFactor;

// 基础速度

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Power", Meta = (BlueprintProtected = "true"))

float BaseSpeed;

// BlueprintImplementableEvent：定义一个蓝图事件， 意味着我们不用在 C++ 中定义该方法，交给蓝图去实现

UFUNCTION(BlueprintImplementableEvent, Category = "Power")

void PowerChangeEffect();

private:

// character 当前的 power

UPROPERTY(VisibleAnywhere, Category="Power")

float CharacterPower;

public:

/** Returns CameraBoom subobject **/

FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }

/** Returns FollowCamera subobject **/

FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }

// 返回 CollectionSphere 组件

FORCEINLINE class USphereComponent* GetCollectionSphere() const { return CollectionSphere; }

};

BatteryCollectorCharacter.cpp

[cpp] view
plain copy

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.

#include "BatteryCollector.h" // 切记放在第一个

#include "Kismet/HeadMountedDisplayFunctionLibrary.h"

#include "BatteryCollectorCharacter.h"

#include "Pickup.h"

#include "BatteryPickup.h"

//////////////////////////////////////////////////////////////////////////

// ABatteryCollectorCharacter

ABatteryCollectorCharacter::ABatteryCollectorCharacter()

{

// Set size for collision capsule

GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

// set our turn rates for input

BaseTurnRate = 45.f;

BaseLookUpRate = 45.f;

// Don't rotate when the controller rotates. Let that just affect the camera.

bUseControllerRotationPitch = false;

bUseControllerRotationYaw = false;

bUseControllerRotationRoll = false;

// Configure character movement

GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...

GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate

GetCharacterMovement()->JumpZVelocity = 600.f;

GetCharacterMovement()->AirControl = 0.2f;

// Create a camera boom (pulls in towards the player if there is a collision)

CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));

CameraBoom->SetupAttachment(RootComponent);

CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character

CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller

// Create a follow camera

FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));

FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation

FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm

// 创建 collection sphere 组件

CollectionSphere = CreateDefaultSubobject<USphereComponent>(TEXT("CollectionSphere"));

// 并将其添加到 RootComponent 上

//CollectionSphere->AttachTo(RootComponent); // 过时的方法

// https://forums.unrealengine.com/showthread.php?112644-4-12-Transition-Guide
CollectionSphere->AttachToComponent(RootComponent, FAttachmentTransformRules::KeepWorldTransform);

// collection sphere 的半径范围

CollectionSphere->SetSphereRadius(200.f);

// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character)

// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)

// 为 power 赋值

InitialPower = 2000.f;

CharacterPower = InitialPower;

SpeedFactor = .75f;

BaseSpeed = 10.f;

}

//////////////////////////////////////////////////////////////////////////

// Input

void ABatteryCollectorCharacter::SetupPlayerInputComponent(class UInputComponent *PlayerInputComponent)

{

// Set up gameplay key bindings

check(PlayerInputComponent);

PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);

PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);

// Collect 键盘响应事件的绑定（Action 用于短促的响应，Axis 用于持续的响应）

PlayerInputComponent->BindAction("Collect", IE_Pressed, this, &ABatteryCollectorCharacter::CollectPickups);

PlayerInputComponent->BindAxis("MoveForward", this, &ABatteryCollectorCharacter::MoveForward);

PlayerInputComponent->BindAxis("MoveRight", this, &ABatteryCollectorCharacter::MoveRight);

// We have 2 versions of the rotation bindings to handle different kinds of devices differently

// "turn" handles devices that provide an absolute delta, such as a mouse.

// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick

PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);

PlayerInputComponent->BindAxis("TurnRate", this, &ABatteryCollectorCharacter::TurnAtRate);

PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);

PlayerInputComponent->BindAxis("LookUpRate", this, &ABatteryCollectorCharacter::LookUpAtRate);

// handle touch devices

PlayerInputComponent->BindTouch(IE_Pressed, this, &ABatteryCollectorCharacter::TouchStarted);

PlayerInputComponent->BindTouch(IE_Released, this, &ABatteryCollectorCharacter::TouchStopped);

// VR headset functionality

PlayerInputComponent->BindAction("ResetVR", IE_Pressed, this, &ABatteryCollectorCharacter::OnResetVR);

}

void ABatteryCollectorCharacter::OnResetVR()

{

UHeadMountedDisplayFunctionLibrary::ResetOrientationAndPosition();

}

void ABatteryCollectorCharacter::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)

{

Jump();

}

void ABatteryCollectorCharacter::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)

{

StopJumping();

}

void ABatteryCollectorCharacter::TurnAtRate(float Rate)

{

// calculate delta for this frame from the rate information

AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());

}

void ABatteryCollectorCharacter::LookUpAtRate(float Rate)

{

// calculate delta for this frame from the rate information

AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());

}

void ABatteryCollectorCharacter::MoveForward(float Value)

{

if ((Controller != NULL) && (Value != 0.0f))

{

// find out which way is forward

const FRotator Rotation = Controller->GetControlRotation();

const FRotator YawRotation(0, Rotation.Yaw, 0);

// get forward vector

const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);

AddMovementInput(Direction, Value);

}

}

void ABatteryCollectorCharacter::MoveRight(float Value)

{

if ( (Controller != NULL) && (Value != 0.0f) )

{

// find out which way is right

const FRotator Rotation = Controller->GetControlRotation();

const FRotator YawRotation(0, Rotation.Yaw, 0);

// get right vector

const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

// add movement in that direction

AddMovementInput(Direction, Value);

}

}

void ABatteryCollectorCharacter::CollectPickups()

{

// 遍历所有覆盖区域内的 Actor，将它们存储进数组

TArray<AActor *> CollectedActors;

CollectionSphere->GetOverlappingActors(CollectedActors);

// 记录收集的电池的能量

float CollectedPower = 0.f;

// 遍历数组

for (int32 iCollected = 0; iCollected < CollectedActors.Num(); ++iCollected )

{

// 将 Actor 转化为 APickup

APickup *const TestPickup = Cast<APickup>(CollectedActors[iCollected]);

// 检查转化是否成功，还有 pickup 是否即将被销毁，是否是激活状态

if (TestPickup && !TestPickup->IsPendingKill() && TestPickup->IsActive())

{

// 收集 pickup（注意：此处不是调用的 xxx_Implementation）

TestPickup->WasCollected();

// 检查 pickup 是否是电池

ABatteryPickup* const TestBattery = Cast<ABatteryPickup>(TestPickup);

if (TestBattery)

{

// 累加收集的能量

CollectedPower += TestBattery->GetPower();

}

// 冻结 pickup

TestPickup->SetActive(false);

}

}

if (CollectedPower > 0.f)

{

UpdatePower(CollectedPower);

}

}

float ABatteryCollectorCharacter::GetInitialPower()

{

return InitialPower;

}

float ABatteryCollectorCharacter::GetCurrentPower()

{

return CharacterPower;

}

void ABatteryCollectorCharacter::UpdatePower(float PowerChange)

{

CharacterPower = CharacterPower + PowerChange;

// 所有 Character类都有 GetCharacterMovement 方法

// 根据 power 更新玩家的速度

GetCharacterMovement()->MaxWalkSpeed = BaseSpeed + SpeedFactor * CharacterPower;

// 调用蓝图实现的方法

PowerChangeEffect();

}

以及 蓝图 的设计

Battery_BP

ThirdPersonCharacter 的 Construction Scirpt

注意：该材质是动态材质实例（Dynamic Material Instance），可以实时改变

Construction Script 是一种当绑定对象上的属性发生变化就会执行的脚本（不包括关卡中的移动），和 C++ 中的构造函数有点相似

ThirdPersonCharacter

BatteryHUD

附

UE_LOG 的使用方法

字符串处理

为什么要用 TSubclassOf

（完）