UEC++ 虚幻5 “类魂”游戏笔记（三）

已于 2024-03-07 10:42:09 修改
阅读量1.2k 收藏 25
点赞数 22
分类专栏： UE魂类游戏笔记 文章标签： c++ ue5 游戏
于 2024-01-21 19:19:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44924388/article/details/135712351
版权
该博客围绕UE5游戏中UI与角色行为制作展开，详细介绍了将刀剑绑定到角色身上、武器切换逻辑、人物持剑动画混合空间配置、持剑攻击逻辑及优化、攻击动画蒙太奇配置、刀风效果设置、持剑翻滚与滑行逻辑等内容，还涉及相关类文件的编写。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

UI与角色行为制作(二)

将刀剑绑定到角色身上

  • 在角色骨骼添加两个插槽用来放剑与剑鞘
    在这里插入图片描述
    在这里插入图片描述
  • 在PlayerCharacte类中创建剑鞘的静态网格与剑的骨骼组件
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
	class UStaticMeshComponent* ScabbardMesh;

	UPROPERTY(EditDefaultSOnly, BlueprintReadOnly, Category = "Weapon")
	class USkeletalMeshComponent* Sword;
  • 将组件添加到插槽
APlayerCharacter::APlayerCharacter()
{
	ScabbardMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ScabbardMesh"));
	ScabbardMesh->SetupAttachment(GetMesh(), "Scabbard");

	Sword = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Sword"));
	Sword->SetupAttachment(GetMesh(), "Sword");

	LastMeleeIndex = 0;
	MeleeBehaviorStateWarToCommon = 10.;//默认十秒
}

  • 剑鞘骨骼网格体导出静态网格体
    在这里插入图片描述

  • 然后在角色蓝图中进行添加剑与剑鞘模型
    在这里插入图片描述
    在这里插入图片描述

武器切换逻辑

  • 调节好右手持剑的位置
    在这里插入图片描述
  • 在SoulBaseCharacte类中添加输入操作换武器，添加虚函数武器切换方法
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
UInputAction* ChangeWeaponAction;

	//攻击
	virtual void Attack();
	//翻滚
	virtual void Rolling();
	//滑行（近战：翻跟头/持剑：滑行翻滚）
	virtual void Slide();
	//切换武器
	virtual void ChangeWeapon();
  • 在子类PlayerCharacte类中重写切换武器方法
	//重写Attack
	virtual void Attack() override;
	//重写Rolling
	virtual void Rolling() override;
	//重写Slide
	virtual void Slide() override;
	//重写ChangeWeapon
	virtual void ChangeWeapon() override;
  • 绑定输入操作映射
void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
	if (EnhancedInputComponent)
	{
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ASoulBaseCharacter::Move);
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ASoulBaseCharacter::Look);
		EnhancedInputComponent->BindAction(RunAction, ETriggerEvent::Triggered, this, &ASoulBaseCharacter::Run);
		EnhancedInputComponent->BindAction(RunAction, ETriggerEvent::Completed, this, &ASoulBaseCharacter::StopRun);
		EnhancedInputComponent->BindAction(AttackAction, ETriggerEvent::Started, this, &APlayerCharacter::Attack);
		EnhancedInputComponent->BindAction(RollingAction, ETriggerEvent::Started, this, &APlayerCharacter::Rolling);
		EnhancedInputComponent->BindAction(SlideAction, ETriggerEvent::Started, this, &APlayerCharacter::Slide);
		EnhancedInputComponent->BindAction(ChangeWeaponAction, ETriggerEvent::Started, this, &APlayerCharacter::ChangeWeapon);
	
	}
}
  • 添加逻辑bool函数，当前是否能切换武器
	bool CanChangeWeapon();
  • 是否能切换武器逻辑
bool APlayerCharacter::CanChangeWeapon()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE)
	{
		return true;
	}
	return false;
}
  • 然后我们需要标记装备武器的状态，在SoulBaseCharacter类中添加一个bool变量来表示是否当前状态有装备武器， 默认为false
	//是否装备武器
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Attack")
	bool bEquipWeapon;

bEquipWeapon = false;
  • 重写切换武器函数逻辑
void APlayerCharacter::ChangeWeapon()
{
	if (CanChangeWeapon())
	{
		if (WeaponType == EWeaponType::EWT_MELEE)
		{
			//改为持剑状态
			WeaponType = EWeaponType::EWT_SWORD;
			//将武器添加到右手
			Sword->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, "WEAPON_R");
			bEquipWeapon = true;
		}
		else if (WeaponType == EWeaponType::EWT_SWORD)
		{
			//改为普通状态
			WeaponType = EWeaponType::EWT_MELEE;
			//将武器放回剑鞘
			Sword->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, "Sword");
			bEquipWeapon = false;
		}
	}
}
  • 虚幻中添加输入操作并且绑定到映射，添加到角色蓝图上
    在这里插入图片描述
    在这里插入图片描述

配置人物持剑动画混合空间

  • 配置持剑动画资产，创建动画混合空间
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 然后在动画蓝图开始配置逻辑
  • 获取到是否准备武器状态bool变量，到时候切换状态的条件值
    在这里插入图片描述
  • 新建持剑的动画状态机
    在这里插入图片描述
  • 切换逻辑就是那个bool变量值
    在这里插入图片描述
    在这里插入图片描述
  • 添加动画混合空间
    在这里插入图片描述
  • 战备状态的动画也可以像持剑动画转换，转换条件是是否持剑
    在这里插入图片描述
    在这里插入图片描述
  • 微调持剑状态穿模，也可以设置一下平滑速度
    在这里插入图片描述
    在这里插入图片描述

人物持剑攻击逻辑

  • 人物持剑攻击逻辑与普通拳法攻击逻辑是差不多的
  • 在PlayerCharacte类中定义判断是否能持剑攻击的函数方法
	//是否可以持剑攻击
	bool CanSwodAttack();
  • 在SoulBaseCharacte类中新建持剑攻击衰减值变量并初始化
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float SwordAttackSubStamina;//持剑攻击消耗体力值

SwordAttackSubStamina= 12.f;
  • PlayerCharacter类中CanSwordAttack方法逻辑
bool APlayerCharacter::CanSwodAttack()
{

	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= SwordAttackSubStamina)
	{
		return true;
	}
	else if (Stamina < SwordAttackSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}
  • 添加持剑攻击蒙太奇数组，用来存储持剑攻击的蒙太奇
	//近战攻击蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeAttackAnim;
	//近战翻滚蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeRollingAnim;
	//近战滑行蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeSlideAnim;
	//持剑攻击蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordAttackAnim;
  • SwordAttack方法逻辑
void APlayerCharacter::SwordAttack()
{
	if (CanSwodAttack())
	{
		UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		if (CurAnimInstance)
		{
			//将状态改变为攻击状态
			PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
			Stamina -= SwordAttackSubStamina;
			//播放随机动画
			int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, SwordAttackAnim.Num() - 1);
			if (AttackAnimIndex != LastMeleeIndex)
			{
				LastMeleeIndex = AttackAnimIndex;
				CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
			}
			else
			{
				if (AttackAnimIndex == 0)
				{
					int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, SwordAttackAnim.Num() - 2);
					AttackAnimIndex += AddIndexNum;
					LastMeleeIndex = AttackAnimIndex;
					CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
				}
				else
				{
					AttackAnimIndex--;
					LastMeleeIndex = AttackAnimIndex;
					CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
				}
			}
		}
	}
}

优化人物持剑逻辑

  • 人物持剑与拳法随机攻击是一样的，可以在SoulBaseCharacte类中建立一个函数将公共逻辑包含进去，这样只调用函数即可，优化代码
  • 新建一个随机攻击函数方法，然后将子类中的LastAttackAnimIndex拿到基类SoulBaseCharacte中来，并且新增一个记录上一个持剑攻击动作的标志变量
	//记录上一个拳击攻击动作的标志变量
	int32 LastMeleeIndex;
	//记录上一个持剑攻击动作的标志变量
	int32 LastSwordIndex;

//记录上一个攻击动作的标志变量
LastMeleeIndex = 0;
LastSwordIndex = 0;
//-------------------------------------------------
	//随机攻击算法
	void RandomAttack(TArray<UAnimMontage*> NeedAnim, int32& LastAttackAnimIndex);
  • 随机攻击算法逻辑
void ASoulBaseCharacter::RandomAttack(TArray<UAnimMontage*> NeedAnim, int32& LastAttackAnimIndex)
{
	UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
	if (CurAnimInstance)
	{
		//播放随机动画
		int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, NeedAnim.Num() - 1);
		if (AttackAnimIndex != LastAttackAnimIndex)
		{
			LastAttackAnimIndex = AttackAnimIndex;
			CurAnimInstance->Montage_Play(NeedAnim[AttackAnimIndex]);
		}
		else
		{
			if (AttackAnimIndex == 0)
			{
				int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, NeedAnim.Num() - 2);
				AttackAnimIndex += AddIndexNum;
				LastAttackAnimIndex = AttackAnimIndex;
				CurAnimInstance->Montage_Play(NeedAnim[AttackAnimIndex]);
			}
			else
			{
				AttackAnimIndex--;
				LastAttackAnimIndex = AttackAnimIndex;
				CurAnimInstance->Montage_Play(NeedAnim[AttackAnimIndex]);
			}
		}
	}
}
  • PlayerCharacter类中的MeleeAttack方法就该这样写了
void APlayerCharacter::MeleeAttack()
{
	if (CanMeleeAttack())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//将状态改变为攻击状态
		//	PlayerBehavior = EPlayerBehavior::EPB_ATTACK;

		//	//将状态改变为备战状态
		//	MeleeState = EMeleeState::EMS_PREPARE;
		//	MeleeBehaviorStateWarToCommon = 10.f;//每次攻击后重新置为10秒计时

		//	//每次攻击都得减去体力值
		//	Stamina -= MeleeAttackSubStamina;

		//	//摄像机震动反馈
		//	CameraShakeFeedBack();

		//	//播放随机动画
		//	int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, MeleeAttackAnim.Num() - 1);
		//	if (AttackAnimIndex != LastMeleeIndex)
		//	{
		//		LastMeleeIndex = AttackAnimIndex;//更新上一个动作
		//		CurAnimInstance->Montage_Play(MeleeAttackAnim[AttackAnimIndex]);
		//	}
		//	else
		//	{
		//		if (AttackAnimIndex == 0)
		//		{
		//			int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, MeleeAttackAnim.Num() - 2);
		//			AttackAnimIndex += AddIndexNum;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(MeleeAttackAnim[AttackAnimIndex]);
		//		}
		//		else
		//		{
		//			AttackAnimIndex--;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(MeleeAttackAnim[AttackAnimIndex]);
		//		}
		//	}		
		//}
		//将状态改变为攻击状态
		PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
		//每次攻击都得减去体力值
		Stamina -= MeleeAttackSubStamina;
		//将状态改变为备战状态
		MeleeState = EMeleeState::EMS_PREPARE;
		MeleeBehaviorStateWarToCommon = 10.f;//每次攻击后重新置为10秒计时
		//摄像机震动反馈
		CameraShakeFeedBack();
		RandomAttack(MeleeAttackAnim, LastMeleeIndex);
	}
}
  • SwordAttack函数方法逻辑
void APlayerCharacter::SwordAttack()
{
	if (CanSwodAttack())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//将状态改变为攻击状态
		//	PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
		//	Stamina -= SwordAttackSubStamina;
		//	//播放随机动画
		//	int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, SwordAttackAnim.Num() - 1);
		//	if (AttackAnimIndex != LastMeleeIndex)
		//	{
		//		LastMeleeIndex = AttackAnimIndex;
		//		CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
		//	}
		//	else
		//	{
		//		if (AttackAnimIndex == 0)
		//		{
		//			int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, SwordAttackAnim.Num() - 2);
		//			AttackAnimIndex += AddIndexNum;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
		//		}
		//		else
		//		{
		//			AttackAnimIndex--;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
		//		}
		//	}
		//}
		//将状态改变为攻击状态
		PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
		//每次攻击都得减去体力值
		Stamina -= SwordAttackSubStamina;
		//摄像机震动反馈
		CameraShakeFeedBack();
		RandomAttack(SwordAttackAnim, LastSwordIndex);
	}
}

配置人物持剑攻击动画蒙太奇

  • 重定向资产，创建蒙太奇
    在这里插入图片描述

  • 将持剑攻击蒙太奇添加到角色蓝图
    在这里插入图片描述

  • 在持剑攻击蒙太奇上添加重置动作通知，并更换插槽，添加转向算法通知
    在这里插入图片描述

  • 动画蓝图事件表中，通知重置角色状态
    在这里插入图片描述

配置刀风效果

  • 添加Niagara粒子模块
    在这里插入图片描述
  • 在PlayerCharacter类中添加Niagara组件
	//剑风
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
	class UNiagaraComponent* SwordNiagara;
  • 创建这个组件，需要头文件 #include "NiagaraComponent.h"
APlayerCharacter::APlayerCharacter()
{
	ScabbardMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ScabbardMesh"));
	ScabbardMesh->SetupAttachment(GetMesh(), "Scabbard");

	Sword = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Sword"));
	Sword->SetupAttachment(GetMesh(), "Sword");

	SwordNiagara = CreateDefaultSubobject<UNiagaraComponent>(TEXT("SwordNiagara"));
	SwordNiagara->SetupAttachment(Sword);

	MeleeBehaviorStateWarToCommon = 10.;//默认十秒
}
  • 将Niagara特效添加到角色的Niagara组件上并且调好位置
    在这里插入图片描述
    在这里插入图片描述
  • 默认Niagara特效是不激活的，只有在挥刀的那个瞬间激活，逻辑：使用动画通知状态，开始挥刀的那个时间激活， 结束挥刀不激活
  • 默认不激活
    在这里插入图片描述
  • 新建一个动画通知状态蓝图编写逻辑
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 然后将这个动画通知状态添加到持剑攻击蒙太奇上
    在这里插入图片描述

制作持剑翻滚

  • 重定向资源
    在这里插入图片描述
  • 添加持剑翻滚蒙太奇动画重置通知，设置插槽，角色动画蓝图中重置角色状态
    在这里插入图片描述
    在这里插入图片描述
  • 持剑翻滚与普通状态的翻滚是一样的逻辑，可以优化一下代码，把播放翻滚的逻辑改为一个函数方法
  • 在SoulBaseCharacte类中新建一个函数方法专门用来播放翻滚以及滑行的逻辑，然后新建一个持剑翻滚消耗体力值的变量
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float SwordRollingSubStamina;//持剑翻滚消耗体力值

SwordRollingSubStamina = 12.f;
//翻滚算法	
void PlayerRollingOrSlideAnim(TArray<UAnimMontage*> RollingOrSlideAnim);
  • 翻滚算法逻辑
void ASoulBaseCharacter::PlayerRollingOrSlideAnim(TArray<UAnimMontage*> RollingOrSlideAnim)
{
	UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
	if (CurAnimInstance)
	{
		if (RollingForwardValue == 1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[0], RollingAnimPlayRate);
		}
		else if (RollingForwardValue == -1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[1], RollingAnimPlayRate);
		}
		else if (RollingRightValue == 1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[2], RollingAnimPlayRate);
		}
		else if (RollingRightValue == -1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[3], RollingAnimPlayRate);
		}
		else
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[0], RollingAnimPlayRate);
		}
	}
}
  • 在PlayerCharacte类中之前写的MeleeRolling方法逻辑就是这样了
void APlayerCharacter::MeleeRolling()
{
	if (CanMeleeRolling())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//每次翻滚减去体力
		//	Stamina -= MeleeRollingSubStamina;
		//	PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		//	if (RollingForwardValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[0], RollingAnimPlayRate);
		//	}
		//	else if (RollingForwardValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[1], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[2], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[3], RollingAnimPlayRate);
		//	}
		//	else
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[0], RollingAnimPlayRate);
		//	}
		//}
		//每次翻滚减去体力
		Stamina -= MeleeRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(MeleeRollingAnim);
	}
}
  • 新建是否可以持剑翻滚的方法函数和存放持剑翻滚的蒙太奇数组
	//是否可以持剑翻滚
	bool CanSwordRolling();
	
//持剑翻滚蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordRollingAnim;
  • 是否可以持剑翻滚逻辑
bool APlayerCharacter::CanSwordRolling()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= SwordRollingSubStamina)
	{
		return true;
	}
	else if (Stamina < SwordRollingSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}
  • 持剑攻击函数逻辑
void APlayerCharacter::SwordRolling()
{
	if (CanSwordRolling())
	{
		//每次翻滚减去体力
		Stamina -= SwordRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(SwordRollingAnim);
	}
}
  • 将持剑蒙太奇添加到角色蓝图上
    在这里插入图片描述

持剑滑行逻辑

  • 重定向资源
    在这里插入图片描述

  • 添加持剑滑行蒙太奇动画重置通知，设置插槽，角色动画蓝图中重置角色状态
    在这里插入图片描述
    在这里插入图片描述

  • PlayerCharacte类中之前的MeleeSlide方法也可以改写成这样

void APlayerCharacter::MeleeSlide()
{
	if (CanMeleeSlide())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//每次翻滚减去体力
		//	Stamina -= MeleeRollingSubStamina;
		//	PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		//	if (RollingForwardValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[0], RollingAnimPlayRate);
		//	}
		//	else if (RollingForwardValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[1], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[2], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[3], RollingAnimPlayRate);
		//	}
		//	else
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[0], RollingAnimPlayRate);
		//	}
		//}
		//每次翻滚减去体力
		Stamina -= MeleeRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(MeleeSlideAnim);
	}
}
  • 新建是否可以持剑滑行的方法函数和存放持剑滑行的蒙太奇数组
//是否可以切换武器
bool CanChangeWeapon();
//是否可以持剑攻击
bool CanSwodAttack();
//是否可以持剑翻滚
bool CanSwordRolling();
//是否可以持剑滑行
bool CanSwordSlide();

	//近战攻击蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeAttackAnim;
	//近战翻滚蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeRollingAnim;
	//近战滑行蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeSlideAnim;
	//持剑攻击蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordAttackAnim;
	//持剑翻滚蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordRollingAnim;
	//持剑滑行蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordSlideAnim;
  • CanSwordSlide函数逻辑
bool APlayerCharacter::CanSwordSlide()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= SwordRollingSubStamina)
	{
		return true;
	}
	else if (Stamina < SwordRollingSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}
  • 持剑滑行逻辑
void APlayerCharacter::SwordSlide()
{
	if (CanSwordSlide())
	{
		Stamina -= SwordRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(SwordSlideAnim);
	}
}
  • 添加蒙太奇动画到角色蓝图上
    在这里插入图片描述

PlayerCharacte.h

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

#pragma once

#include "CoreMinimal.h"
#include "DarkSoulsGame/Characters/SoulBaseCharacter.h"
#include "PlayerCharacter.generated.h"

/**
 * 
 */
UCLASS()
class DARKSOULSGAME_API APlayerCharacter : public ASoulBaseCharacter
{
	GENERATED_BODY()
public:
	APlayerCharacter();

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
	class UStaticMeshComponent* ScabbardMesh;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
	class USkeletalMeshComponent* Sword;

	//剑风
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
	class UNiagaraComponent* SwordNiagara;

	// Called when the game starts or when spawned
	virtual void BeginPlay() override;
	// Called to bind functionality to input
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
	virtual void Tick(float DeltaTime) override;

	//重写Attack
	virtual void Attack() override;
	//重写Rolling
	virtual void Rolling() override;
	//重写Slide
	virtual void Slide() override;
	//重写ChangeWeapon
	virtual void ChangeWeapon() override;

	void MeleeAttack();
	void SwordAttack();
	bool CanMeleeAttack();

	void MeleeRolling();
	void SwordRolling();
	bool CanMeleeRolling();

	void MeleeSlide();
	void SwordSlide();
	bool CanMeleeSlide();

	//是否可以切换武器
	bool CanChangeWeapon();
	//是否可以持剑攻击
	bool CanSwodAttack();
	//是否可以持剑翻滚
	bool CanSwordRolling();
	//是否可以持剑滑行
	bool CanSwordSlide();


	//记录从备战状态到普通状态的变量时间
	float MeleeBehaviorStateWarToCommon;

protected:

private:
	//近战攻击蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeAttackAnim;
	//近战翻滚蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeRollingAnim;
	//近战滑行蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> MeleeSlideAnim;
	//持剑攻击蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordAttackAnim;
	//持剑翻滚蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordRollingAnim;
	//持剑滑行蒙太奇
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AnimMontage", meta = (AllowPrivateAccess = "true"))
	TArray<UAnimMontage*> SwordSlideAnim;
};

PlayerCharacte.cpp

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


#include "PlayerCharacter.h"
#include "DarkSoulsGame/DarkSoulPlayerController.h"
#include "Kismet/KismetMathLibrary.h"
#include "Components/SkeletalMeshComponent.h"
#include "Engine/SkeletalMeshSocket.h"
#include "NiagaraComponent.h"

APlayerCharacter::APlayerCharacter()
{
	ScabbardMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ScabbardMesh"));
	ScabbardMesh->SetupAttachment(GetMesh(), "Scabbard");

	Sword = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Sword"));
	Sword->SetupAttachment(GetMesh(), "Sword");

	SwordNiagara = CreateDefaultSubobject<UNiagaraComponent>(TEXT("SwordNiagara"));
	SwordNiagara->SetupAttachment(Sword);

	MeleeBehaviorStateWarToCommon = 10.;//默认十秒
}

void APlayerCharacter::BeginPlay()
{
	Super::BeginPlay();
	ADarkSoulPlayerController* PlayerController = Cast<ADarkSoulPlayerController>(Controller);
	if (PlayerController)
	{
		UEnhancedInputLocalPlayerSubsystem* Subsystem =
			ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer());
		if (Subsystem)
		{
			Subsystem->AddMappingContext(PlayerMappingContext, 0);
		}
	}
}

void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
	if (EnhancedInputComponent)
	{
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ASoulBaseCharacter::Move);
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ASoulBaseCharacter::Look);
		EnhancedInputComponent->BindAction(RunAction, ETriggerEvent::Triggered, this, &ASoulBaseCharacter::Run);
		EnhancedInputComponent->BindAction(RunAction, ETriggerEvent::Completed, this, &ASoulBaseCharacter::StopRun);
		EnhancedInputComponent->BindAction(AttackAction, ETriggerEvent::Started, this, &APlayerCharacter::Attack);
		EnhancedInputComponent->BindAction(RollingAction, ETriggerEvent::Started, this, &APlayerCharacter::Rolling);
		EnhancedInputComponent->BindAction(SlideAction, ETriggerEvent::Started, this, &APlayerCharacter::Slide);
		EnhancedInputComponent->BindAction(ChangeWeaponAction, ETriggerEvent::Started, this, &APlayerCharacter::ChangeWeapon);
	
	}
}

void APlayerCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	//角色非攻击防御状态，体力小于100的时候才能开始恢复状态
	if (Stamina < 100.f && PlayerBehavior != EPlayerBehavior::EPB_ATTACK && PlayerBehavior != EPlayerBehavior::EPB_DEFENCE)
	{
		Stamina += DeltaTime * IncreaseStamina;
		GEngine->AddOnScreenDebugMessage(-1, 10, FColor::Red,
			FString::Printf(TEXT("Stamina：%f"), Stamina));
	}

	//记录攻击倒计时，10秒之后无攻击动作才能解除备战状态
	if (MeleeState == EMeleeState::EMS_PREPARE && PlayerBehavior != EPlayerBehavior::EPB_ATTACK)
	{
		MeleeBehaviorStateWarToCommon -= DeltaTime;
		/*
		GEngine->AddOnScreenDebugMessage(-1, 10, FColor::Red,
			FString::Printf(TEXT("MeleeBehaviorStateWarToCommon：%f"), MeleeBehaviorStateWarToCommon));
		*/
		if (MeleeBehaviorStateWarToCommon <= 0)
		{
			MeleeState = EMeleeState::EMS_COMMON;
			MeleeBehaviorStateWarToCommon = 10.f;
		}
	}
}

void APlayerCharacter::Attack()
{
	switch (WeaponType)
	{
	case EWeaponType::EWT_NONE:
		break;
	case EWeaponType::EWT_MELEE:
		MeleeAttack();
		break;
	case EWeaponType::EWT_SWORD:
		SwordAttack();
		break;
	default:
		break;
	}
}

void APlayerCharacter::Rolling()
{
	switch (WeaponType)
	{
	case EWeaponType::EWT_MELEE:
		MeleeRolling();
		break;
	case EWeaponType::EWT_SWORD:
		SwordRolling();
		break;
	}
}

void APlayerCharacter::Slide()
{
	switch (WeaponType)
	{
	case EWeaponType::EWT_MELEE:
		MeleeSlide();
		break;
	case EWeaponType::EWT_SWORD:
		SwordSlide();
		break;
	}
}

void APlayerCharacter::ChangeWeapon()
{
	if (CanChangeWeapon())
	{

		if (WeaponType == EWeaponType::EWT_MELEE)
		{
			//改为持剑状态
			WeaponType = EWeaponType::EWT_SWORD;
			//将武器添加到右手
			Sword->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, "WEAPON_R");
			bEquipWeapon = true;
		}
		else if (WeaponType == EWeaponType::EWT_SWORD)
		{
			//改为普通状态
			WeaponType = EWeaponType::EWT_MELEE;
			//将武器放回剑鞘
			Sword->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, "Sword");
			bEquipWeapon = false;
		}
	}
}

void APlayerCharacter::MeleeAttack()
{
	if (CanMeleeAttack())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//将状态改变为攻击状态
		//	PlayerBehavior = EPlayerBehavior::EPB_ATTACK;

		//	//将状态改变为备战状态
		//	MeleeState = EMeleeState::EMS_PREPARE;
		//	MeleeBehaviorStateWarToCommon = 10.f;//每次攻击后重新置为10秒计时

		//	//每次攻击都得减去体力值
		//	Stamina -= MeleeAttackSubStamina;

		//	//摄像机震动反馈
		//	CameraShakeFeedBack();

		//	//播放随机动画
		//	int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, MeleeAttackAnim.Num() - 1);
		//	if (AttackAnimIndex != LastMeleeIndex)
		//	{
		//		LastMeleeIndex = AttackAnimIndex;//更新上一个动作
		//		CurAnimInstance->Montage_Play(MeleeAttackAnim[AttackAnimIndex]);
		//	}
		//	else
		//	{
		//		if (AttackAnimIndex == 0)
		//		{
		//			int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, MeleeAttackAnim.Num() - 2);
		//			AttackAnimIndex += AddIndexNum;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(MeleeAttackAnim[AttackAnimIndex]);
		//		}
		//		else
		//		{
		//			AttackAnimIndex--;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(MeleeAttackAnim[AttackAnimIndex]);
		//		}
		//	}		
		//}

		//将状态改变为攻击状态
		PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
		//每次攻击都得减去体力值
		Stamina -= MeleeAttackSubStamina;
		//将状态改变为备战状态
		MeleeState = EMeleeState::EMS_PREPARE;
		MeleeBehaviorStateWarToCommon = 10.f;//每次攻击后重新置为10秒计时
		//摄像机震动反馈
		CameraShakeFeedBack();
		RandomAttack(MeleeAttackAnim, LastMeleeIndex);
	}
	
}

void APlayerCharacter::SwordAttack()
{
	if (CanSwodAttack())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//将状态改变为攻击状态
		//	PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
		//	Stamina -= SwordAttackSubStamina;
		//	//播放随机动画
		//	int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, SwordAttackAnim.Num() - 1);
		//	if (AttackAnimIndex != LastMeleeIndex)
		//	{
		//		LastMeleeIndex = AttackAnimIndex;
		//		CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
		//	}
		//	else
		//	{
		//		if (AttackAnimIndex == 0)
		//		{
		//			int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, SwordAttackAnim.Num() - 2);
		//			AttackAnimIndex += AddIndexNum;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
		//		}
		//		else
		//		{
		//			AttackAnimIndex--;
		//			LastMeleeIndex = AttackAnimIndex;
		//			CurAnimInstance->Montage_Play(SwordAttackAnim[AttackAnimIndex]);
		//		}
		//	}
		//}
		//将状态改变为攻击状态
		PlayerBehavior = EPlayerBehavior::EPB_ATTACK;
		//每次攻击都得减去体力值
		Stamina -= SwordAttackSubStamina;
		//摄像机震动反馈
		CameraShakeFeedBack();
		RandomAttack(SwordAttackAnim, LastSwordIndex);
	}
}

bool APlayerCharacter::CanMeleeAttack()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= MeleeAttackSubStamina)
	{
		return true;
	}
	else if (Stamina < MeleeAttackSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}

void APlayerCharacter::MeleeRolling()
{
	if (CanMeleeRolling())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//每次翻滚减去体力
		//	Stamina -= MeleeRollingSubStamina;
		//	PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		//	if (RollingForwardValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[0], RollingAnimPlayRate);
		//	}
		//	else if (RollingForwardValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[1], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[2], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[3], RollingAnimPlayRate);
		//	}
		//	else
		//	{
		//		CurAnimInstance->Montage_Play(MeleeRollingAnim[0], RollingAnimPlayRate);
		//	}
		//}
		//每次翻滚减去体力
		Stamina -= MeleeRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(MeleeRollingAnim);
	}
}

void APlayerCharacter::SwordRolling()
{
	if (CanSwordRolling())
	{
		//每次翻滚减去体力
		Stamina -= SwordRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(SwordRollingAnim);
	}
}

bool APlayerCharacter::CanMeleeRolling()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= MeleeRollingSubStamina)
	{
		return true;
	}
	else if (Stamina < MeleeRollingSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}

void APlayerCharacter::MeleeSlide()
{
	if (CanMeleeSlide())
	{
		//UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
		//if (CurAnimInstance)
		//{
		//	//每次翻滚减去体力
		//	Stamina -= MeleeRollingSubStamina;
		//	PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		//	if (RollingForwardValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[0], RollingAnimPlayRate);
		//	}
		//	else if (RollingForwardValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[1], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == 1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[2], RollingAnimPlayRate);
		//	}
		//	else if (RollingRightValue == -1)
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[3], RollingAnimPlayRate);
		//	}
		//	else
		//	{
		//		CurAnimInstance->Montage_Play(MeleeSlideAnim[0], RollingAnimPlayRate);
		//	}
		//}
		//每次翻滚减去体力
		Stamina -= MeleeRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(MeleeSlideAnim);
	}
}

void APlayerCharacter::SwordSlide()
{
	if (CanSwordSlide())
	{
		Stamina -= SwordRollingSubStamina;
		PlayerBehavior = EPlayerBehavior::EPB_ROLLING;
		PlayerRollingOrSlideAnim(SwordSlideAnim);
	}
}

bool APlayerCharacter::CanMeleeSlide()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= MeleeRollingSubStamina)
	{
		return true;
	}
	else if (Stamina < MeleeRollingSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}

bool APlayerCharacter::CanChangeWeapon()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE)
	{
		return true;
	}
	return false;
}

bool APlayerCharacter::CanSwodAttack()
{

	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= SwordAttackSubStamina)
	{
		return true;
	}
	else if (Stamina < SwordAttackSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}

bool APlayerCharacter::CanSwordRolling()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= SwordRollingSubStamina)
	{
		return true;
	}
	else if (Stamina < SwordRollingSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}

bool APlayerCharacter::CanSwordSlide()
{
	if (PlayerBehavior == EPlayerBehavior::EPB_IDLE && Stamina >= SwordRollingSubStamina)
	{
		return true;
	}
	else if (Stamina < SwordRollingSubStamina)
	{
		ShowStaminaNotEnoughText();
	}
	return false;
}

SoulBaseCharacter.h

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

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "InputActionValue.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "../SoulEnumType.h"
#include "SoulBaseCharacter.generated.h"

UCLASS()
class DARKSOULSGAME_API ASoulBaseCharacter : public ACharacter
{
	GENERATED_BODY()

public:
	// Sets default values for this character's properties
	ASoulBaseCharacter();
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
	class UInputMappingContext* PlayerMappingContext;

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

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

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
	class UInputAction* RunAction;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
	class UInputAction* AttackAction;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
	UInputAction* RollingAction;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
	UInputAction* SlideAction;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Input")
	UInputAction* ChangeWeaponAction;

	//角色状态
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character Properties")
	bool bIsRun;
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character Attribute")
	EWeaponType WeaponType;
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character Attribute")
	EPlayerBehavior PlayerBehavior;
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character Attribute")
	EMeleeState MeleeState;

	//角色机制
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float Stamina;//体力值
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float MaxStamina;//最大体力值
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float MeleeAttackSubStamina;//攻击消耗体力值
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float MeleeRollingSubStamina;//翻滚消耗体力值
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float SwordRollingSubStamina;//持剑翻滚消耗体力值
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float SwordAttackSubStamina;//持剑攻击消耗体力值
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Attribute")
	float IncreaseStamina;//增长体力值

	//攻击时转向的目标值
	FRotator DesiredRotation;

	//翻滚的朝向值(前后)
	int32 RollingForwardValue;
	//翻滚的朝向值(左右)
	int32 RollingRightValue;
	//翻滚蒙太奇播放速率
	float RollingAnimPlayRate;

	//是否装备武器
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Attack")
	bool bEquipWeapon;

	//记录上一个拳击攻击动作的标志变量
	int32 LastMeleeIndex;
	//记录上一个持剑攻击动作的标志变量
	int32 LastSwordIndex;
protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

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

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

	//攻击
	virtual void Attack();
	//翻滚
	virtual void Rolling();
	//滑行（近战：翻跟头/持剑：滑行翻滚）
	virtual void Slide();
	//切换武器
	virtual void ChangeWeapon();

	UFUNCTION(BlueprintCallable,BlueprintPure)
	float GetCurStamina();//获取体力
	UFUNCTION(BlueprintCallable, BlueprintPure)
	float GetMaxStamina();//获取最大体力

	//摄像机震动反馈
	UFUNCTION(BlueprintImplementableEvent)
	void CameraShakeFeedBack();

	//获取UI并显示提示文本
	void ShowStaminaNotEnoughText();

	//计算按键的方向
	FRotator CalculateRotation();

	//线性插入旋转值
	UFUNCTION(BlueprintCallable)
	void RInterpRotation();

	//随机攻击算法
	void RandomAttack(TArray<UAnimMontage*> NeedAnim, int32& LastAttackAnimIndex);

	//翻滚算法
	void PlayerRollingOrSlideAnim(TArray<UAnimMontage*> RollingOrSlideAnim);

private:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Camera", meta = (AllowPrivateAccess = "true"))
	class USpringArmComponent* SpringArm;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Camera", meta = (AllowPrivateAccess = "true"))
	class UCameraComponent* FollowCamera;

};

SoulBaseCharacter.cpp

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


#include "SoulBaseCharacter.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Engine/Engine.h"
#include <DarkSoulsGame/DarkSoulPlayerController.h>
#include <DarkSoulsGame/DarkSoulHUD.h>
#include <DarkSoulsGame/UI/UI_FightMain.h>
#include "Kismet/KismetMathLibrary.h"

// Sets default values
ASoulBaseCharacter::ASoulBaseCharacter()
{
 	// 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;
	
	SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
	SpringArm->SetupAttachment(GetRootComponent());
	SpringArm->TargetArmLength = 300.f;
	SpringArm->bUsePawnControlRotation = true;

	FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
	FollowCamera->SetupAttachment(SpringArm);

	//默认是不奔跑的
	bIsRun = false;
	WeaponType = EWeaponType::EWT_MELEE;//拳击
	MeleeState = EMeleeState::EMS_COMMON;//普通状态
	PlayerBehavior = EPlayerBehavior::EPB_IDLE;//空闲状态
	//默认武器装备为false
	bEquipWeapon = false;

	MaxStamina = 100.f;
	Stamina = MaxStamina;
	MeleeAttackSubStamina = 10.f;
	MeleeRollingSubStamina = 15.f;
	SwordAttackSubStamina = 12.f;
	SwordRollingSubStamina = 12.f;
	IncreaseStamina = 1.f;

	//攻击转向默认值为0
	DesiredRotation = FRotator(0., 0., 0.);

	//翻滚方向值默认值为0
	RollingForwardValue = 0.0;
	RollingRightValue = 0.0;

	//翻滚动画播放速率
	RollingAnimPlayRate = 1.0;

	bUseControllerRotationPitch = false;
	bUseControllerRotationRoll = false;
	bUseControllerRotationYaw = false;

	GetCharacterMovement()->bOrientRotationToMovement = true;

	//记录上一个攻击动作的标志变量
	LastMeleeIndex = 0;
	LastSwordIndex = 0;
}

FRotator ASoulBaseCharacter::CalculateRotation()
{
	//获取最后一次输入的向量
	FVector LastVector = GetCharacterMovement()->GetLastInputVector();
	//判断最后一次输入向量是否为0，如果是就返回这个目标值，如果不为0就返回这个Vector转换为Rotator的目标值
	if (LastVector != FVector(0,0,0))
	{
		return UKismetMathLibrary::MakeRotFromX(LastVector);
	}
	else
	{
		return DesiredRotation;
	}
}

void ASoulBaseCharacter::RInterpRotation()
{
	//实时进行转向插值
	FRotator RInterpRotation = UKismetMathLibrary::RInterpTo(GetActorRotation(), DesiredRotation, 
		GetWorld()->GetDeltaSeconds(), 5.f);
	SetActorRotation(FRotator(0., RInterpRotation.Yaw, 0.));
}

void ASoulBaseCharacter::RandomAttack(TArray<UAnimMontage*> NeedAnim, int32& LastAttackAnimIndex)
{
	UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
	if (CurAnimInstance)
	{
		//播放随机动画
		int32 AttackAnimIndex = UKismetMathLibrary::RandomIntegerInRange(0, NeedAnim.Num() - 1);
		if (AttackAnimIndex != LastAttackAnimIndex)
		{
			LastAttackAnimIndex = AttackAnimIndex;
			CurAnimInstance->Montage_Play(NeedAnim[AttackAnimIndex]);
		}
		else
		{
			if (AttackAnimIndex == 0)
			{
				int32 AddIndexNum = UKismetMathLibrary::RandomIntegerInRange(0, NeedAnim.Num() - 2);
				AttackAnimIndex += AddIndexNum;
				LastAttackAnimIndex = AttackAnimIndex;
				CurAnimInstance->Montage_Play(NeedAnim[AttackAnimIndex]);
			}
			else
			{
				AttackAnimIndex--;
				LastAttackAnimIndex = AttackAnimIndex;
				CurAnimInstance->Montage_Play(NeedAnim[AttackAnimIndex]);
			}
		}
	}
}

void ASoulBaseCharacter::PlayerRollingOrSlideAnim(TArray<UAnimMontage*> RollingOrSlideAnim)
{
	UAnimInstance* CurAnimInstance = GetMesh()->GetAnimInstance();
	if (CurAnimInstance)
	{
		if (RollingForwardValue == 1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[0], RollingAnimPlayRate);
		}
		else if (RollingForwardValue == -1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[1], RollingAnimPlayRate);
		}
		else if (RollingRightValue == 1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[2], RollingAnimPlayRate);
		}
		else if (RollingRightValue == -1)
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[3], RollingAnimPlayRate);
		}
		else
		{
			CurAnimInstance->Montage_Play(RollingOrSlideAnim[0], RollingAnimPlayRate);
		}
	}
}

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

// Called every frame
void ASoulBaseCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	//实时计算攻击转向的目标值
	DesiredRotation = CalculateRotation();
}


void ASoulBaseCharacter::Move(const FInputActionValue& Value)
{
	FVector2D MoveVector = Value.Get<FVector2D>();
	//回获取翻滚的方向值
	RollingForwardValue = MoveVector.Y;
	RollingRightValue = MoveVector.X;

	if (Controller)
	{
		FRotator Rotation = Controller->GetControlRotation();
		FRotator YawRotation = FRotator(0.f, Rotation.Yaw, 0.f);

		FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
		FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

		AddMovementInput(ForwardDirection, MoveVector.Y);
		AddMovementInput(RightDirection, MoveVector.X);

	}
	
}

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

void ASoulBaseCharacter::Run()
{
	bIsRun = true;
	GetCharacterMovement()->MaxWalkSpeed = 600.f;
	//bIsRun = !bIsRun;
	//StopRun();
	
	
}

void ASoulBaseCharacter::StopRun()
{
	bIsRun = false;
	GetCharacterMovement()->MaxWalkSpeed = 200.f;
	//float WalkSpeed = 200.0f; // 步行速度
	//float RunSpeed = 600.0f; // 奔跑速度
	//float ActualSpeed;
	//if (bIsRun)
	//{
	//	ActualSpeed = RunSpeed;
	//}
	//else
	//{
	//	ActualSpeed = WalkSpeed;
	//}
	//GetCharacterMovement()->MaxWalkSpeed = ActualSpeed;
}

void ASoulBaseCharacter::Attack()
{
}

void ASoulBaseCharacter::Rolling()
{
}

void ASoulBaseCharacter::Slide()
{
}

void ASoulBaseCharacter::ChangeWeapon()
{
}

float ASoulBaseCharacter::GetCurStamina()
{
	return Stamina;
}

float ASoulBaseCharacter::GetMaxStamina()
{
	return MaxStamina;
}

void ASoulBaseCharacter::ShowStaminaNotEnoughText()
{
	//获取到Controller
	ADarkSoulPlayerController* PC = Cast<ADarkSoulPlayerController>(Controller);
	if (Controller)
	{
		//获取到HUD
		ADarkSoulHUD* HUD = Cast<ADarkSoulHUD>(PC->GetHUD());
		if (HUD)
		{
			//显示提示文本
			HUD->GetFightMainUI()->ShowStaminaText();
		}
	}
}
[UE5蓝图基础二]3.使用插槽装备武器 以教程右手握法杖左手捏火球为例
qq_30584617的博客
11-17 2067
这里需要用到一个关键节点 “从类生成actor” 就是从我们前面创建的武器蓝图生成一个actor。这个变换参数就是我们之前调整的插槽位置(也就是调整的武器位置) 所以需要从角色网格体去获取。要做的效果是 一切换战斗模式就生成法杖并且添加到插槽 一退出战斗模式就隐藏法杖。复制默认的特效节点 在复制出的节点上删除不需要的一些设置如下图。添加”网格体渲染器” 在右边细节处找到网格体添加一个球。我们需要在它的基础上做修改.做出粒子向中间聚集的特效。勾选”材质重载” 然后点重载材质处的+号 添加。
UE5 与 C++ 入门教程·第二课：动画重定向
小谷的日常随笔集
07-29 1239
手把手教你UE5重定向动画，包括重定向到 Metahuman 角色，从 Mixamo 下载角色动画并重定向。
UE5学习--构造一只能被玩家控制的鸟C++
qq_45683717的博客
07-20 474
第一个参数为FName，可以直接输入“MoveForward”,如果有中文则TEXT(" MoveForward"),也可以FName("MoveForward") 此处输入的是在设置中自己定义的名字。这样我们相当于人可以控制鸟，也可以在蓝图中这个鸟中找到pawn 下的 antoposserplayer手动设置。此函数再绑定后会每一帧都被调用，value代表按键是否被按下，按下w输出我们在上面设置的1.0f，按下s输出-1.0f，否则为0.0f。将胶囊体设置为根组件，鸟的骨骼组件绑定到上面。
UE4武器绑定--将武器模型绑定到人物身上、
yuemuc的博客
05-05 3468
Ue4通过Actor+骨骼插槽讲武器绑定到人物身上。
ue4 简单战斗
three_and_five的博客
07-06 1279
主要内容：装备武器，攻击，敌人攻击，受伤，敌人受伤 事先下载好武器模型、动画等，注意的是，模型贴图、对应骨骼等可能要重新设置，材质的各项参数要重新拖入纹理连线，动画要全部重定向 一、添加武器 1、创建插槽 打开人物骨骼界面 找到左右手，分别创建一个插槽，命名为剑和盾 若要以后武器放在背上可切换，可在骨骼spine_03处加插槽，这里再加俩插槽 2、摆对背后武器的位置 播放动画序列拔武器，这时可以暂停，暂停后把武器位置调整到正确位置 ...
UEC++ 虚幻5第三人称射击游戏（二）
qq_44924388的博客
07-06 1210
为了区别头部与身体部分的受到伤害不同，我们需要将测试人偶的物理材质表面重新区分一下在项目的物理界面新建两个物理表面，一个是普通伤害，一个是高伤害表示创建两个物理材质作为到时候的区分，然后将其表面类型换成我们刚才新建的类型然后在测试人偶的物理资产里面将头部物理材质改为易受伤害的，其它为默认的。
虚幻C++入门个人笔记(2)——标记宏、结构体枚举、资源加载、代理
hoppingg的博客
09-02 2136
类UCLASS、成员属性UPROPERTY、成员函数UFUNCTION蓝图和C++的交互。
虚幻C++学习笔记01--官方案例：FloatingActor
LE_grino的博客
03-16 4153
首先接触虚幻文档中提供给新手的第一个案例 悬浮旋转方块 具体操作的步骤可以点击下方链接： 编程快速入门 | 虚幻引擎文档 (unrealengine.com)
UEC++：UKismetMathLibrary::RandomPointInBoundingBox盒体内取随机坐标的方法
arbiter2的博客
11-05 951
学习笔记：UEC++_UKismetMathLibrary::RandomPointInBoundingBox盒体内取随机坐标的方法_盒体内取随机坐标的方法，空间内随机生成物体的时候可以用到
UE C++学习笔记：增强输入
oO花花Oo的博客
11-16 917
UE C++中增强输入的写法
ue5 蓝图内修改组件附加的插槽
weixin_42666952的博客
02-06 749
Target是目标,Parent是要加到哪个骨骼上,socketName是骨骼对应的插槽。
阿赵UE学习笔记——21、武器插槽
阿赵的博客
03-26 1954
继续学习虚幻引擎的使用，这次来看看骨骼插槽的用法。
虚幻引擎图文笔记：如何让带骨骼的角色捡东西（Pickup）和扔东西（Drop）
开发游戏的老王
01-06 1963
文章目录原理步骤1. 定义被捡物体类2. 定义BPI_Picker接口3. 在骨骼上添加插槽(Socket)4. 角色蓝图捡东西扔东西 原理 在角色的骨骼上添加Socket作为被捡物的吸附位置 被捡物发生Overlap事件以后判断另一个物体是否为角色对象，如果是则将自身以及要吸附的位置作为参数传给角色 角色接收到参数以后把被捡物Attach到相应的Socket 步骤 本文依旧以第三人称模板为起点实现 1. 定义被捡物体类 组件结构：一个StaticMesh组件 注意：这个被捡物在Collision设置
UE5_建立自己的资产库
最新发布
AION的博客
11-27 1366
资产库需要用到一个插件：- 在当前项目预览其他UE项目资产（.uasset 文件）- 迁移其他UE项目资产到当前项目- 相当于UE资产管理器- 某宝上有的卖。
UE5中罕见的 ( 标识符, meta=( . . . ) )
Q1370034377的博客
10-16 1847
这篇文章总结了UE5一些很少在代码中能看见的meta标识符，但这些meta标识符在某些情况下又很有实际作用。后续如果在代码中发现有使用了一些稀有的标识符，也会陆续添加进来。本篇文章参考自https://zhuanlan.zhihu.com/p/717920216
UE5用C++的Actor类，创建网格体、粒子特效、碰撞体等组件。
qq_67841097的博客
01-22 1245
这样我们Actor类的组件就创建好了。
ue5 动画蓝图 跳，走，武器添加到角色
sunflower_2020的博客
07-20 326
uye5 动画蓝图 动画混合空间，动画状态机 走 跳
UEC++ 虚幻5 “类魂”游戏笔记（四）
qq_44924388的博客
01-23 862
人换装，角色持剑防御，BeginOverlap碰撞函数，配置场景拾取物
UE4/5 添加3DUI界面 UMG设计
shanlinhan的博客
05-07 3945
简单几步快速搭建可交互的3D UI界面，鼠标点击可触发不同控件的功能，兼顾实时性和画面效果。
uec++中写模板类
09-20
在Unreal Engine C++中，编写模板类是为了提供一种通用的编程方式，允许你创建可以接受不同类型参数的类或函数。模板类是一个基础类，它定义了通用的操作，可以在运行时被实例化为针对特定类型的版本。下面是一个简单的模板类的例子： ```cpp template <typename T> class MyClass { public: // 模板方法，可以接受T类型的参数 void add(T value) { m_value = value + static_cast<T>(0); } private: T m_value; // 类型由模板参数决定 }; ``` 在这个例子中，`MyClass`模板类可以实例化为`MyClass<int>`，`MyClass<float>`等各种版本，每个实例化的类都有各自的`add()`方法，可以根据传入的具体类型进行相应运算。 要使用这个模板类，你可以这样做： ```cpp MyClass<int> intInstance; intInstance.add(5); // 调用的是int版的add方法 MyClass<float> floatInstance; floatInstance.add(3.14f); // 调用的是float版的add方法 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值