设置角色动作

1. 首先，登录到 Epic Games启动程序，通过 新建（New）>游戏（Games）>空白（Blank）>项目（Project） 创建名为 **CharacterMovement 的项目。

   

2. 要为角色制作动画，你将需要 动画初学者包（Animation Starter Pack），可从Epic Games虚幻商城免费下载。 点击 免费（Free） 按钮，下载动画初学者包，并将其添加到 Epic Games库。

   

3. 从 库（Library） 中，搜索 动画初学者包（Animation Starter Pack），点击 添加到项目（Add to Project），然后从 选择要向其添加资产的项目（Select the Project to Add the Asset to） 菜单，搜索并选择 CharacterMovement 项目文件，然后点击 添加到项目（Add to Project）。

   

4. 将动画初学者包添加到你的项目中后，你将在 内容浏览器（Content Browser） 中看到它。

   

1. 首先，点击 新建（New）> 游戏（Games）> 空白（Blank）> C++ 创建名为 CharacterMovement 的项目。

   

2. 要为角色制作动画，你将需要 动画初学者包（Animation Starter Pack），可从Epic Games虚幻商城免费下载。 点击 免费（Free） 按钮，下载动画初学者包，并将其添加到 Epic Games库。

   

3. 从 库（Library） 中，搜索 动画初学者包（Animation Starter Pack），点击 添加到项目（Add to Project），然后从 选择要向其添加资产的项目（Select the Project to Add the Asset to） 菜单，搜索并选择 CharacterMovement 项目文件，然后点击 添加到项目（Add to Project）。

   

4. 将动画初学者包添加到你的项目中后，你将在 内容浏览器（Content Browser） 中看到它。

   

玩家需要角色类进行控制。角色是带有角色动作组件的Pawn，可为类人角色提供移动系统以便在你的世界中穿行。按照以下步骤设置角色。

1. 点击 添加/导入（Add/Import） 按钮新建蓝图 角色 类，将其命名为 BP_PlayerCharacter。

   

2. 双击 BP_PlayerCharacter 打开 类默认值，然后在组件（components）选项卡中，选择 网格体(CharacterMesh0) 骨骼网格体组件（Skeletal Mesh Component），并导航至 细节面板（Details panel）。

   点击查看大图。

3. 在 网格体（Mesh） 类别中，选择 骨骼网格体变量（Skeletal Mesh variable） 旁边的下拉箭头，并从下拉菜单中选择 SK_Mannequin。

   

4. 从 细节面板（Details panel） 导航到 变换类别（Transform category） ，将网格体的 位置（Location） 和 旋转（Rotation） 设置为（0,0,-90）。

   

5. 角色的 骨骼网格体 现在将出现在朝前的 箭头组件 方向，如下图所示。

   

6. 导航至 组件选项卡（Components tab），选择网格体组件，然后点击 添加组件（Add Component），在下拉菜单中搜索并选择SpringArm，然后将 弹簧臂组件（Spring Arm Component） 命名为“SpringArmComp”。

   

7. 导航至 细节面板（Details panel），在 摄像机设置（Camera Settings） 类别，启用 使用Pawn控制旋转（Use Pawn Control Rotation）。

   

   启用使用Pawn控制旋转将使摄像机相对于弹簧臂旋转。

8. 在 摄像机类别（Camera category） 中，将 套接字偏移（socket offset） 设置为（0,0,30），然后导航至 变换类别（Transform category），并将 SpringArmComp的位置（SpringArmComp’s Location） 设置为（0,0,50）。

   

9. 选择SpringArmComp后，点击 添加组件（Add Component） 按钮，然后，在下拉菜单搜索和选择摄像机，以便添加名为 CameraComp 的 摄像机组件（Camera Component）。

   

10.在 组件（Components） 选项卡中，选择 角色动作组件（Character Movement Component），然后导航至 细节面板（Details panel），在 角色动作（Character Movement）（旋转设置（Rotation Settings））类别，启用 使用控制器所需旋转（Use Controller Desired Rotation） 和 将旋转定向到动作（Orient Rotation To Movement）。

11.在 角色动作：行走（Character Movement:Walking） 类别，启用 忽略基地旋转（Ignore Base Rotation） 变量。

将忽略基地旋转设置为true将告知角色保持其当前世界旋转，并忽略它所站立基地旋转的任何变化。

12.在 角色动作导航动作类别（Character Movement Nav Movement category），导航至 移动能力（Movement Capabilities），并选择下拉箭头查看更多变量设置，导航至 Can Crouch布尔（Can Crouch Boolean），并点击启用它。

13.编译（Compile） 并 保存（Save）。

玩家需要角色类进行控制。角色是带有角色动作组件的Pawn，可为类人角色提供移动系统以便在你的世界中穿行。按照以下步骤设置角色。

1. 在 C++类向导（C++ Class Wizard） 中，新建名为 PlayerCharacter 的 角色（Character） 类，然后导航到 PlayerCharacter 文件，并声明以下类定义：

                protected:
   		
                //跟随玩家背后摄像机的弹簧臂组件
                UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
                class USpringArmComponent* SpringArmComp;
   		
                //玩家跟随摄像机
                UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
                class UCameraComponent* CameraComp;
   Copy full snippet

   protected: //跟随玩家背后摄像机的弹簧臂组件 UPROPERTY(VisibleAnywhere, BlueprintReadWrite) class USpringArmComponent* SpringArmComp; //玩家跟随摄像机 UPROPERTY(VisibleAnywhere, BlueprintReadWrite) class UCameraComponent* CameraComp;

2. 导航至 PlayerCharactor.cpp 文件并添加以下类库：

                #include "Camera/CameraComponent.h"
                #include "GameFramework/SpringArmComponent.h"
                #include "GameFramework/CharacterMovementComponent.h"
   Copy full snippet

   #include "Camera/CameraComponent.h" #include "GameFramework/SpringArmComponent.h" #include "GameFramework/CharacterMovementComponent.h"

3. 在 APlayerCharactor::APlayerCharacter 构造函数方法中，声明以下内容

                //实例化你的类组件
   		
                SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArmComp"));
   		
                CameraComp = CreateDefaultSubobject<UCameraComponent>(TEXT("CameraComp"));
   		
                //设置角色网格体变换的位置和旋转
   		
                GetMesh()->SetRelativeLocationAndRotation(FVector(0.0f, 0.0f, -90.0f), FQuat(FRotator(0.0f, -90.0f, 0.0f)));
   		
                //将你的类组件附加到默认角色的骨骼网格体组件。
   		
                SpringArmComp->SetupAttachment(GetMesh());
   		
                CameraComp->SetupAttachment(SpringArmComp,USpringArmComponent::SocketName);
   		
                //设置弹簧臂的类变量
   		
                SpringArmComp->bUsePawnControlRotation = true;
   		
                //设置角色动作组件的类变量
   		
                GetCharacterMovement()->bOrientRotationToMovement = true;
   		
                GetCharacterMovement()->bUseControllerDesiredRotation = true;
   		
                GetCharacterMovement()->bIgnoreBaseRotation = true;
   Copy full snippet

   //实例化你的类组件 SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArmComp")); CameraComp = CreateDefaultSubobject<UCameraComponent>(TEXT("CameraComp")); //设置角色网格体变换的位置和旋转 GetMesh()->SetRelativeLocationAndRotation(FVector(0.0f, 0.0f, -90.0f), FQuat(FRotator(0.0f, -90.0f, 0.0f))); //将你的类组件附加到默认角色的骨骼网格体组件。 SpringArmComp->SetupAttachment(GetMesh()); CameraComp->SetupAttachment(SpringArmComp,USpringArmComponent::SocketName); //设置弹簧臂的类变量 SpringArmComp->bUsePawnControlRotation = true; //设置角色动作组件的类变量 GetCharacterMovement()->bOrientRotationToMovement = true; GetCharacterMovement()->bUseControllerDesiredRotation = true; GetCharacterMovement()->bIgnoreBaseRotation = true;

4. 编译 你的代码。

5. 在 编辑器（Editor） 中，导航至 C++类文件夹，然后右键点击 PlayerCharacter 类，在 C++类操作（C++ Class Actions） 下拉菜单中，选择 基于PlayerCharacter创建蓝图类（Create Blueprint class based on PlayerCharacter）。将蓝图命名为 Bp_PlayerCharacter。

点击查看大图。

1. 双击 BP_PlayerCharacter 打开 类默认值，然后在 组件（Components） 选项卡中，选择 网格体（CharacterMesh0） 骨骼网格体组件（Skeletal Mesh Component），并导航至 细节面板（Details panel）。

点击查看大图。

10.在 网格体（Mesh） 类别中，选择 骨骼网格体变量（Skeletal Mesh variable） 旁边的下拉箭头，并从下拉菜单中选择 SK_Mannequin。

11.角色的 骨骼网格体 将出现在朝前的 箭头组件 方向，如下图所示。

12.编译（Compile） 并 保存（Save）。

你将需要设置一些自定义逻辑，以便在按下输入键（如W、A、S、D）时移动角色。

1. 导航至 编辑（Edit）>项目设置（Project Settings）>输入（Input），然后在 绑定类别（Bindings Category） 中点击 操作映射（Action Mappings） 旁边的 + 号，添加以下内容：

   动作映射	键值
   跳跃	空格键
   蹲伏	左Ctrl
   冲刺	左Shift

   

2. 在 绑定类别（Bindings Category） 中，点击 轴映射（Axis Mappings） 旁边的 + 号，添加以下 轴映射（Axis Mappings）。

   轴映射	键值	缩放
   MoveForward	W	1.0
   	S	-1.0
   MoveRight	D	1.0
   	A	-1.0
   Turn	鼠标X	1.0
   LookUp	鼠标Y	-1.0

   

3. 在 内容浏览器（Content Browser） 中，双击 BP_PlayerCharacter 打开 类默认值，然后右键点击 事件图表（Event Graph），并在下拉菜单中搜索和选择 MoveForward。

   点击查看大图。

4. 从 InputAxis MoveForward 节点拖移 执行引脚，在下拉菜单搜索并选择 Add Movement Input 节点，然后将 InputAxis MoveForward 节点的 轴值（Axis Value） 引脚连接到 Add Movement Input 节点的 缩放值（Scale Value） 引脚。

   点击查看大图。

5. 右键点击 事件图表（Event Graph），在上下文菜单搜索并选择 Get Control Rotation，然后从 旋转体返回值（Rotator Return Value） 引脚拖移，并在下拉菜单搜索和选择 Break Rotator。

   点击查看大图。

6. 从 Break Rotator 节点的 Z（Yaw）引脚拖移，在下拉菜单搜索并选择 Make Rotator 节点，然后，从 Make Rotator 节点的 旋转体返回值（Rotator Return Value） 引脚拖移，在下拉菜单搜索并选择 Get Forward Vector。

   点击查看大图。

7. 从 Get Forward Vector 节点的 矢量返回值（Vector Return Value） 引脚拖移，将其插入到 Add Movement Input 节点的 世界方向（World Direction） 引脚。

   点击查看大图。

8. 再次右键点击图表，搜索并为你的 输入轴事件 选择 向右移动（Move Right）。

   点击查看大图。

9. 从 InputAxis MoveRight 节点拖移 执行引脚，在下拉菜单搜索并选择 Add Movement Input* 节点，然后将 InputAxis MoveForward 节点的 轴值（Axis Value） 引脚连接到 Add Movement Input 节点的 缩放值（Scale Value）** 引脚。

   点击查看大图。

10.从 Make Rotator 节点的 旋转体返回值（Rotator Return Value） 引脚拖移，在下拉菜单搜索并选择 Get Right Vector 节点，然后拖移 矢量返回值（Vector Return Value） 引脚，并将其插入到 Add Movement Input 节点的 世界方向（World Direction） 引脚。

点击查看大图。

11.已完成的动作输入事件蓝图图表将如下所示。

点击查看大图。

12.右键点击 事件图表（Event Graph），然后搜索并选择 InputAxis LookUp 事件节点，然后右键点击，搜索并选择 Add Controller Pitch Input 节点。

点击查看大图。

13.从Input Axis LookUp节点的 轴值（Axis Value） 引脚拖移，并连接到 Add Controller Pitch Input 节点的 Val 引脚。从 InputAxis LookUp 节点的 执行输出引脚 拖移，并连接到 Add Controller Pitch Input 节点的 执行输入引脚。

点击查看大图。

14.右键点击 事件图表（Event Graph），然后搜索并选择 Input Axis Turn 事件节点，然后右键点击，搜索并选择 Add Controller Yaw Input 节点。

点击查看大图。

15.从 Input Axis Turn 节点的 轴值（Axis Value） 引脚拖移，并连接到 Add Controller Yaw Input 节点的 Val 引脚。从 Input Axis Turn 节点的 执行输出引脚 拖移，并连接到 Add Controller Yaw Input 节点的 执行输入引脚。

点击查看大图。

16.点击 编译（Compile） 并 保存（Save）。

半成品蓝图

此时，你的蓝图图表应如下图所示。

点击查看大图。

你将需要设置一些自定义逻辑，以便在按下输入键（如W、A、S、D）时移动角色。

1. 导航至 编辑（Edit）>项目设置（Project Settings）>输入（Input），然后在 绑定（Bindings） 类别，点击 操作映射（Action Mappings） 旁边的 + 号，添加以下 操作映射（Action mappings）。

   操作映射	键值
   跳跃	空格键
   蹲伏	左Ctrl
   冲刺	左Shift

   

2. 在 绑定类别（Bindings Category） 中，点击 轴映射（Axis Mappings） 旁边的 + 号，添加以下 轴映射（Axis Mappings）。

   轴映射	键值	缩放
   MoveForward	W	1.0
   	S	-1.0
   MoveRight	D	1.0
   	A	-1.0
   Turn	鼠标X	1.0
   LookUp	鼠标Y	-1.0

   

3. 在PlayerCharacter.h中，声明以下类方法

                protected:
   		
                //为向前/向后输入而调用
   		
                void MoveForward(float InputAxis);
   		
                //为左/右侧输入而调用
   		
                void MoveRight(float InputAxis);
   Copy full snippet

   protected: //为向前/向后输入而调用 void MoveForward(float InputAxis); //为左/右侧输入而调用 void MoveRight(float InputAxis);

4. 在PlayerCharacter.Cpp中，为 APlayerCharacter::MoveForward 和 APlayerCharacter::MoveRight 类方法实现以下逻辑。

                void APlayerCharacter::MoveForward(float AxisValue)
                {
                    if ((Controller != nullptr) && (AxisValue != 0.0f))
                    {
                        // 找出向前方向
                        const FRotator Rotation = Controller->GetControlRotation();
                        const FRotator YawRotation(0, Rotation.Yaw, 0);
   		
                        // 获取向前矢量
                        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
                        AddMovementInput(Direction, AxisValue);
                    }
                }
   		
                void APlayerCharacter::MoveRight(float AxisValue)
                {
                    if ((Controller != nullptr) && (AxisValue != 0.0f))
                    {
                        // 找出向右方向
                        const FRotator Rotation = Controller->GetControlRotation();
                        const FRotator YawRotation(0, Rotation.Yaw, 0);
   		
                        // 获取向右矢量
                        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
   		
                        // 添加该方向动作
                        AddMovementInput(Direction, AxisValue);
                    }
                }
   Copy full snippet

   void APlayerCharacter::MoveForward(float AxisValue) { if ((Controller != nullptr) && (AxisValue != 0.0f)) { // 找出向前方向 const FRotator Rotation = Controller->GetControlRotation(); const FRotator YawRotation(0, Rotation.Yaw, 0); // 获取向前矢量 const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X); AddMovementInput(Direction, AxisValue); } } void APlayerCharacter::MoveRight(float AxisValue) { if ((Controller != nullptr) && (AxisValue != 0.0f)) { // 找出向右方向 const FRotator Rotation = Controller->GetControlRotation(); const FRotator YawRotation(0, Rotation.Yaw, 0); // 获取向右矢量 const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y); // 添加该方向动作 AddMovementInput(Direction, AxisValue); } }

5. 接下来导航至 APlayerCharacter::SetupPlayerInputComponent 方法，并实现以下代码。

                //为将功能绑定到输入而调用
                void APlayerCharacter::SetupPlayerInputComponent(UInputComponent*)
                {
                    Super::SetupPlayerInputComponent(PlayerInputComponent);
   		
                    PlayerInputComponent->BindAxis("MoveForward", this, &APlayerCharacter::MoveForward);
                    PlayerInputComponent->BindAxis("MoveRight", this, &APlayerCharacter::MoveRight);
                    PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
                    PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
   		
                }
   Copy full snippet

   //为将功能绑定到输入而调用 void APlayerCharacter::SetupPlayerInputComponent(UInputComponent*) { Super::SetupPlayerInputComponent(PlayerInputComponent); PlayerInputComponent->BindAxis("MoveForward", this, &APlayerCharacter::MoveForward); PlayerInputComponent->BindAxis("MoveRight", this, &APlayerCharacter::MoveRight); PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput); PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput); }

6. 编译 你的代码

阶段性代码

PlayerCharacter.h

		#include "CoreMinimal.h"
		#include "GameFramework/Character.h"
		#include "PlayerCharacter.generated.h"

		UCLASS()
		class CHARACTERMOVEMENT_API APlayerCharacter : public ACharacter
		{
			GENERATED_BODY()

		public:
			// 为此角色的属性设置默认值
			APlayerCharacter();

		protected:
			// 当游戏开始或重生（Spawn）时被调用
			virtual void BeginPlay() override;

			//跟随玩家背后摄像机的弹簧臂组件
			UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
			class USpringArmComponent* SpringArmComp;

			//玩家跟随摄像机
			UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
			class UCameraComponent* CameraComp;

			//为向前/向后输入而调用
			void MoveForward(float InputAxis);

			//为左/右侧输入而调用
			void MoveRight(float InputAxis);

		public:	
			// 每一帧都调用
			virtual void Tick(float DeltaTime) override;

			// 为将功能绑定到输入而调用
			virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
		};
Copy full snippet

PlayerCharacter.Cpp

		#include "PlayerCharacter.h"
		#include "Camera/CameraComponent.h"
		#include "GameFramework/SpringArmComponent.h"
		#include "GameFramework/CharacterMovementComponent.h"

		// 设置默认值
		APlayerCharacter::APlayerCharacter()
		{
			// 将此角色设置为每帧调用Tick()。 如果你不需要此特性，你可以关闭以提升性能。
			PrimaryActorTick.bCanEverTick = true;

			//实例化你的类组件
			SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArmComp"));
			CameraComp = CreateDefaultSubobject<UCameraComponent>(TEXT("CameraComp"));

			//设置角色网格体变换的位置和旋转
			GetMesh()->SetRelativeLocationAndRotation(FVector(0.0f, 0.0f, -90.0f), FQuat(FRotator(0.0f, -90.0f, 0.0f)));

			//将你的类组件附加到默认角色的骨骼网格体组件。
			SpringArmComp->SetupAttachment(GetMesh());
			CameraComp->SetupAttachment(SpringArmComp,USpringArmComponent::SocketName);

			//设置弹簧臂的类变量
			SpringArmComp->bUsePawnControlRotation = true;

			//设置角色动作组件的类变量
			GetCharacterMovement()->bOrientRotationToMovement = true;
			GetCharacterMovement()->bUseControllerDesiredRotation = true;
			GetCharacterMovement()->bIgnoreBaseRotation = true;

		}

		// 当游戏开始或重生（Spawn）时被调用
		void APlayerCharacter::BeginPlay()

		{
			Super::BeginPlay();

		}

		void APlayerCharacter::MoveForward(float AxisValue)

		{
			if ((Controller != nullptr) && (AxisValue != 0.0f))
			{
				// 找出向前方向
				const FRotator Rotation = Controller->GetControlRotation();
				const FRotator YawRotation(0, Rotation.Yaw, 0);

				// 获取向前矢量
				const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
				AddMovementInput(Direction, AxisValue);
			}
		}

		void APlayerCharacter::MoveRight(float AxisValue)
		{
			if ((Controller != nullptr) && (AxisValue != 0.0f))
			{
				// 找出向右方向
				const FRotator Rotation = Controller->GetControlRotation();
				const FRotator YawRotation(0, Rotation.Yaw, 0);

				// 获取向右矢量
				const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

				// 添加该方向动作
				AddMovementInput(Direction, AxisValue);
			}
		}

		// 每一帧都调用
		void APlayerCharacter::Tick(float DeltaTime)
		{
			Super::Tick(DeltaTime);

		}

		// 为将功能绑定到输入而调用
		void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
		{
			Super::SetupPlayerInputComponent(PlayerInputComponent);
			PlayerInputComponent->BindAxis("MoveForward",this, &APlayerCharacter::MoveForward);
			PlayerInputComponent->BindAxis("MoveRight", this, &APlayerCharacter::MoveRight);
			PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
			PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
		}			
Copy full snippet

现在你已完成向前移动、向右移动、向上看和转向输入事件的蓝图脚本逻辑，你将需要完成为跳跃、蹲伏和冲刺输入事件完成实现操作映射。

1. 右键点击 事件图表（Event Graph），然后在 此蓝图的所有操作（All Actions for this Blueprint） 下拉菜单中，搜索并选择 跳跃操作事件（Jump Action Event）。

   点击查看大图。

2. 从 InputAction Jump 节点的 Pressed执行引脚 拖移，然后在下拉菜单中，搜索并选择角色函数 Jump。

   

3. 将 InputAction Jump 节点的 执行引脚 连接到 Jump 节点的 执行引脚。

   点击查看大图。

4. 从 InputAction Jump 节点的 Released执行引脚 拖移，然后在下拉菜单中，搜索并选择角色函数 Stop Jumping。

   点击查看大图。

5. 右键点击 事件图表（Event Graph），然后在下拉菜单中，搜索并选择 输入操作冲刺（Input Action Sprint）。

   

6. 导航至 组件选项卡（Components tab） ，然后点击 角色动作组件（Character Movement Component） 并将其拖放到 事件图表（Event Graph）。

   点击查看大图。

7. 拖移 角色动作引脚（Character Movement pin），并从下拉菜单搜索和选择 Set Max Walk Speed。将 最高行走速度浮点值 设置为 1000，然后将 InputAction Sprint 节点的 Pressed执行引脚 连接到 Set Max Walk Speed 的 输入执行 引脚。

   点击查看大图。

8. 从 角色动作引脚（Character Movement pin） 拖移，然后搜索并选择另一 Max Walk Speed 节点。将 最高行走速度浮点值 设置为 600，然后将 InputAction Sprint 节点的 Pressed执行引脚 连接到 设置最高行走速度执行输入引脚。

   点击查看大图。

9. 右键点击 事件图表（Event Graph），然后在下拉菜单中，搜索并选择 Input Action Crouch。

   

10.从 InputAction Crouch 节点的 Pressed执行引脚 拖移，然后在下拉菜单中，搜索并选择角色类函数 Crouch。

点击查看大图。

11.从 InputAction Crouch 节点的 Released执行引脚 拖移，然后在下拉菜单中，搜索并选择角色类函数 Un Crouch。

点击查看大图。

12.编译（Compile） 并 保存（Save） 蓝图。

完成后的蓝图

完成后的蓝图如下图所示。

点击查看大图。

现在你已经完成了 向前移动、向右移动、向上看 和 转向输入事件 的代码脚本逻辑，你将需要为 跳跃、蹲伏 和 冲刺 输入事件完成实现 操作映射。

1. 导航至PlayerCharacter.h文件并声明以下类方法

                protected:
   		
                    //将角色移动速度设置为冲刺值。
                    void BeginSprint();
   		
                    //将角色移动速度设置回默认速度值。
                    void EndSprint();
   		
                    //角色蹲伏请求
                    void BeginCrouch();
   		
                    //角色结束蹲伏请求
                    void EndCrouch();
   Copy full snippet

   protected: //将角色移动速度设置为冲刺值。 void BeginSprint(); //将角色移动速度设置回默认速度值。 void EndSprint(); //角色蹲伏请求 void BeginCrouch(); //角色结束蹲伏请求 void EndCrouch();

2. 在PlayerCharacter.cpp文件中，为 APlayerCharacter::BeginSprint 和 APlayerCharacter::EndSprint 类方法实现以下逻辑。

                void APlayerCharacter::BeginSprint()
                {
                    GetCharacterMovementComponent()->MaxWalkSpeed = 1000.0f;	
                }
   		
                void APlayerCharacter::EndSprint()
                {
                    GetCharacterMovementComponent()->MaxWalkSpeed = 600.f;
                }
   Copy full snippet

   void APlayerCharacter::BeginSprint() { GetCharacterMovementComponent()->MaxWalkSpeed = 1000.0f; } void APlayerCharacter::EndSprint() { GetCharacterMovementComponent()->MaxWalkSpeed = 600.f; }

3. 为 APlayerCharacter::BeginCrouch 和 APlayerCharacter::EndCrouch 方法实现以下逻辑。

                void APlayerCharacter::BeginCrouch()
                {
                    Crouch();
                }
   		
                void APlayerCharacter::EndCrouch()
                {
                    UnCrouch();
                }
   Copy full snippet

   void APlayerCharacter::BeginCrouch() { Crouch(); } void APlayerCharacter::EndCrouch() { UnCrouch(); }

4. 导航至 APlayerCharacter:: ::SetupPlayerInputComponent 方法，并声明以下代码：

                void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
                {
   		
                    PlayerInputComponent->BindAction("Jump",IE_Pressed,this,&ACharacter::Jump);
                    PlayerInputComponent->BindAction("Jump",IE_Released,this,&ACharacter::StopJumping);
                    PlayerInputComponent->BindAction("Crouch",IE_Pressed,this,&APlayerCharacter::BeginCrouch);
                    PlayerInputComponent->BindAction("Crouch",IE_Released,this,&APlayerCharacter::EndCrouch);
                    PlayerInputComponent->BindAction("Sprint",IE_Pressed,this,&APlayerCharacter::BeginSprint);
                    PlayerInputComponent->BindAction("Sprint",IE_Released,this,&APlayerCharacter::EndSprint);
   		
                }
   Copy full snippet

   void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) { PlayerInputComponent->BindAction("Jump",IE_Pressed,this,&ACharacter::Jump); PlayerInputComponent->BindAction("Jump",IE_Released,this,&ACharacter::StopJumping); PlayerInputComponent->BindAction("Crouch",IE_Pressed,this,&APlayerCharacter::BeginCrouch); PlayerInputComponent->BindAction("Crouch",IE_Released,this,&APlayerCharacter::EndCrouch); PlayerInputComponent->BindAction("Sprint",IE_Pressed,this,&APlayerCharacter::BeginSprint); PlayerInputComponent->BindAction("Sprint",IE_Released,this,&APlayerCharacter::EndSprint); }

5. 编译 你的代码。

完成后的代码

PlayerCharacter.h

		#pragma once

		#include "CoreMinimal.h"
		#include "GameFramework/Character.h"
		#include "PlayerCharacter.generated.h"

		UCLASS()
		class CHARACTERMOVEMENT_API APlayerCharacter : public ACharacter
		{
			GENERATED_BODY()

		public:
			// 为此角色的属性设置默认值
			APlayerCharacter();

		protected:
			// 当游戏开始或重生（Spawn）时被调用
			virtual void BeginPlay() override;

			//跟随玩家背后摄像机的弹簧臂组件
			UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
			class USpringArmComponent* SpringArmComp;

			//玩家跟随摄像机
			UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
			class UCameraComponent* CameraComp;

			//为向前/向后输入而调用
			void MoveForward(float InputAxis);

			//为左/右侧输入而调用
			void MoveRight(float InputAxis);

			//将角色移动速度设置为冲刺值。
			void BeginSprint();

			//将角色移动速度设置回默认速度值。
			void EndSprint();

			//角色蹲伏请求
			void BeginCrouch();

			//角色结束蹲伏请求
			void EndCrouch();

		public:	

			// 每一帧都调用
			virtual void Tick(float DeltaTime) override;

			// 为将功能绑定到输入而调用
			virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

		};
Copy full snippet

PlayerCharacter.cpp

		#include "PlayerCharacter.h"
		#include "Camera/CameraComponent.h"
		#include "GameFramework/SpringArmComponent.h"
		#include "GameFramework/CharacterMovementComponent.h"

		// 设置默认值
		APlayerCharacter::APlayerCharacter()
		{
			// 将此角色设置为每帧调用Tick()。 如果你不需要此特性，你可以关闭以提升性能。
			PrimaryActorTick.bCanEverTick = true;

			//实例化你的类组件
			SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArmComp"));
			CameraComp = CreateDefaultSubobject<UCameraComponent>(TEXT("CameraComp"));

			//设置角色网格体变换的位置和旋转
			GetMesh()->SetRelativeLocationAndRotation(FVector(0.0f, 0.0f, -90.0f), FQuat(FRotator(0.0f, -90.0f, 0.0f)));

			//将你的类组件附加到默认角色的骨骼网格体组件。
			SpringArmComp->SetupAttachment(GetMesh());
			CameraComp->SetupAttachment(SpringArmComp,USpringArmComponent::SocketName);

			//设置弹簧臂的类变量
			SpringArmComp->bUsePawnControlRotation = true;

			//设置角色动作组件的类变量
			GetCharacterMovement()->bOrientRotationToMovement = true;
			GetCharacterMovement()->bUseControllerDesiredRotation = true;
			GetCharacterMovement()->bIgnoreBaseRotation = true;
		}

		// 当游戏开始或重生（Spawn）时被调用
		void APlayerCharacter::BeginPlay()
		{
			Super::BeginPlay();

		}

		void APlayerCharacter::MoveForward(float AxisValue)
		{
			if ((Controller != nullptr) && (AxisValue != 0.0f))
			{
				// 找出向前方向
				const FRotator Rotation = Controller->GetControlRotation();
				const FRotator YawRotation(0, Rotation.Yaw, 0);

				// 获取向前矢量
				const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
				AddMovementInput(Direction, AxisValue);
			}
		}

		void APlayerCharacter::MoveRight(float AxisValue)
		{
			if ((Controller != nullptr) && (AxisValue != 0.0f))
			{
				// 找出向右方向
				const FRotator Rotation = Controller->GetControlRotation();
				const FRotator YawRotation(0, Rotation.Yaw, 0);

				// 获取向右矢量
				const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

				// 添加该方向动作
				AddMovementInput(Direction, AxisValue);
			}
		}

		void APlayerCharacter::BeginSprint()
		{
		GetCharacterMovementComponent()->MaxWalkSpeed = 1000.0f;
		}

		void APlayerCharacter::EndSprint()
		{
			GetCharacterMovementComponent()->MaxWalkSpeed = 600.f;
		}

		void APlayerCharacter::BeginCrouch()
		{
			Crouch();
		}

		void APlayerCharacter::EndCrouch()
		{
			UnCrouch();
		}

		// 每一帧都调用
		void APlayerCharacter::Tick(float DeltaTime)
		{
			Super::Tick(DeltaTime);
		}

		// 为将功能绑定到输入而调用
		void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
		{
			Super::SetupPlayerInputComponent(PlayerInputComponent);
			PlayerInputComponent->BindAxis("MoveForward",this, &APlayerCharacter::MoveForward);
			PlayerInputComponent->BindAxis("MoveRight", this, &APlayerCharacter::MoveRight);
			PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
			PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
			PlayerInputComponent->BindAction("Jump",IE_Pressed,this, &ACharacter::Jump);
			PlayerInputComponent->BindAction("Jump",IE_Released,this, &ACharacter::StopJumping);
			PlayerInputComponent->BindAction("Crouch",IE_Pressed,this,&APlayerCharacter::BeginCrouch);
			PlayerInputComponent->BindAction("Crouch",IE_Released,this,&APlayerCharacter::EndCrouch);
			PlayerInputComponent->BindAction("Sprint",IE_Pressed,this, &APlayerCharacter::BeginSprint);
			PlayerInputComponent->BindAction("Sprint",IE_Released,this, &APlayerCharacter::EndSprint);
		}
Copy full snippet

游戏模式定义游戏的一组规则。这些规则包括游戏启动时玩家将生成的默认Pawn。你需要设置这些规则才能生成你已创建的玩家角色。

1. 在 内容浏览器（Content Browser） 中，点击 添加/导入（Add/Import） 按钮，并创建新的 蓝图（Blueprint） 类，当 选择父类（Pick a Parent Class） 菜单显示时，选择 游戏模式基础（Game Mode Base），并将新游戏模式类命名为 Bp_GameMode。

   点击查看大图。

2. 双击 Bp_GameMode 打开类默认值，然后导航至 细节面板类类别（Details panel Classes category），默认Pawn类选择Bp_PlayerCharacter。

   

3. 编译（Compile） 并 保存（Save） 蓝图。

   

4. 导航至 编辑（Edit）>项目设置（Project Settings）>地图和模式（Maps & Modes），在 默认模式类别（Default Modes category），选择 Bp_GameMode。

   点击查看大图。

游戏模式定义游戏的一组规则。这些规则包括游戏启动时玩家将生成的默认Pawn。你需要设置这些规则才能生成你已创建的玩家角色。

1. 在编辑器中导航至你的C++类文件夹。右键点击CharacterMovementGameModeBase，从 C+类操作（+C++ Class Actions） 菜单，基于CharacterMovementGameModeBase创建蓝图类，然后命名新Gamemode类为 Bp_GameMode。

点击查看大图。

1. 双击 Bp_GameMode 打开 类默认值，然后导航至 详情面板类类别（Details panel Classes category），默认Pawn类选择Bp_PlayerCharacter。

   

2. 编译（Compile） 并 保存（Save） 蓝图。

   

3. 导航至 编辑（Edit）>项目设置（Project Settings）>地图和模式（Maps & Modes），在 默认模式类别（Default Modes category），选择 Bp_GameMode。

点击查看大图。