距离匹配

距离匹配

在使用距离匹配时需要先在插件中开启AnimationLocomotionLibrary和AnimationWarping这两个插件

基本概念

游戏中动画驱动有两种方式，分别为位移驱动和动画驱动。位移驱动中玩家控制角色胶囊体的运动，动画自己播放，这种方式会导致角色动画的步幅与移动速度不匹配；动画驱动是由动画的根运动来驱动角色位移，这种方式可以很好的解决角色运动中的滑步现象。

基本原理

假如我们有一个起步动画，我们将角色的位移提取为距离曲线，同时每一帧获取曲线上的值，这个值就是角色的位移距离（距离起点的距离），将该值应用到角色的位移中就可以实现步幅匹配。

提取距离曲线

DistanceCurve

提取距离曲线主要使用DistanceCurveModifier类，这个类主要包含的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
enum class EDistanceCurve_Axis : uint8
{
    X,
    Y,
    Z,
    XY,
    XZ,
    YZ,
    XYZ,
};

class UDistanceCurveModifier : public UAnimModifier
{
public:
    int32 SampleRate = 30;

    FName CurveName = "Distance";

    float StopSpeedThreshold = 5.0f;

    EDistanceCurve_Axis Axis = EDistanceCurve_Axis::XY;

    bool bStopAtEnd = false;

    virtual void OnApply_Implementation(UAnimSequence* Animation) override;
}

我们来逐个解析各个参数的含义：

  • SampleRate：采样频率，即每秒采样多少次，默认为30次，采样频率越高，曲线值与实际位置的误差越小
  • CurveName：采样的曲线名称，默认为Distance，供外部获取曲线值
  • StopSpeedThreshold：速度阈值，用于计算动画序列的最小速度
  • Axis：采样轴，即采样哪几个轴的位移，默认为XY，即采样X和Y轴的位移（水平位移）
  • bStopAtEnd：是否选择在动画结束的时间作为速度的最低时间
  • OnApply_Implementation：实际进行采样的函数，实现具体的采样逻辑

实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
void UDistanceCurveModifier::OnApply_Implementation(UAnimSequence* Animation)
{
    // 1
	if (Animation == nullptr)
	{
		UE_LOG(LogAnimation, Error, TEXT("DistanceCurveModifier failed. Reason: Invalid Animation"));
		return;
	}

	if (!Animation->HasRootMotion())
	{
		UE_LOG(LogAnimation, Error, TEXT("DistanceCurveModifier failed. Reason: Root motion is disabled on the animation (%s)"), *GetNameSafe(Animation));
		return;
	}

    // 2
	const bool bMetaDataCurve = false;
	UAnimationBlueprintLibrary::AddCurve(Animation, CurveName, ERawCurveTrackTypes::RCT_Float, bMetaDataCurve);

    // 3
	const float AnimLength = Animation->GetPlayLength();
	float SampleInterval;
	int32 NumSteps;
	float TimeOfMinSpeed;

	if(bStopAtEnd)
	{ 
		TimeOfMinSpeed = AnimLength;
	}
	else
	{
		// Perform a high resolution search to find the sample point with minimum speed.
		
		TimeOfMinSpeed = 0.f;
		float MinSpeedSq = FMath::Square(StopSpeedThreshold);

		SampleInterval = 1.f / 120.f;
		NumSteps = AnimLength / SampleInterval;
		for (int32 Step = 0; Step < NumSteps; ++Step)
		{
			const float Time = Step * SampleInterval;

			const bool bAllowLooping = false;
			const FVector RootMotionTranslation = Animation->ExtractRootMotion(Time, SampleInterval, bAllowLooping).GetTranslation();
			const float RootMotionSpeedSq = CalculateMagnitudeSq(RootMotionTranslation, Axis) / SampleInterval;

			if (RootMotionSpeedSq < MinSpeedSq)
			{
				MinSpeedSq = RootMotionSpeedSq;
				TimeOfMinSpeed = Time;
			}
		}
	}

    // 4
	SampleInterval = 1.f / SampleRate;
	NumSteps = FMath::CeilToInt(AnimLength / SampleInterval);
	float Time = 0.0f;
	for (int32 Step = 0; Step <= NumSteps && Time < AnimLength; ++Step)
	{
		Time = FMath::Min(Step * SampleInterval, AnimLength);

		// Assume that during any time before the stop/pivot point, the animation is approaching that point.
		// TODO: This works for clips that are broken into starts/stops/pivots, but needs to be rethought for more complex clips.
		const float ValueSign = (Time < TimeOfMinSpeed) ? -1.0f : 1.0f;

		const FVector RootMotionTranslation = Animation->ExtractRootMotionFromRange(TimeOfMinSpeed, Time).GetTranslation();
		UAnimationBlueprintLibrary::AddFloatCurveKey(Animation, CurveName, Time, ValueSign * CalculateMagnitude(RootMotionTranslation, Axis));
	}
}

对源码进行分析：

  • 这一步判断动画是否合法以及是否开启骨骼根运动
  • 添加一条非元数据曲线，并声明需要使用的变量
  • 寻找最低速度：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 判断是否直接使用动画结束时间作为最小速度
if(bStopAtEnd)
{ 
    TimeOfMinSpeed = AnimLength;
}
else
{
    TimeOfMinSpeed = 0.f;
    // 从阈值中获取最小速度，只有比阈值速度还小才会更新
    float MinSpeedSq = FMath::Square(StopSpeedThreshold);

    // 默认采样间隔以及采样次数
    SampleInterval = 1.f / 120.f;
    NumSteps = AnimLength / SampleInterval;
    // 实际计算最小速度
    for (int32 Step = 0; Step < NumSteps; ++Step)
    {
        // 计算每步的步进时长
        const float Time = Step * SampleInterval;

        const bool bAllowLooping = false;
        // 提取两次采样之间的根运动距离
        const FVector RootMotionTranslation = Animation->ExtractRootMotion(Time, SampleInterval, bAllowLooping).GetTranslation();
        // 根据距离和步进时长计算前进速度
        const float RootMotionSpeedSq = CalculateMagnitudeSq(RootMotionTranslation, Axis) / SampleInterval;
        // 更新最小速度以及最小速度的时间
        if (RootMotionSpeedSq < MinSpeedSq)
        {
            MinSpeedSq = RootMotionSpeedSq;
            TimeOfMinSpeed = Time;
        }
    }
}
  • 实际生成采样曲线
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // 计算采样间隔，由暴露给蓝图的值决定
    SampleInterval = 1.f / SampleRate;
    // 计算采样次数
    NumSteps = FMath::CeilToInt(AnimLength / SampleInterval);
    float Time = 0.0f;
    // 遍历采样
    for (int32 Step = 0; Step <= NumSteps && Time < AnimLength; ++Step)
    {
        // 防止采样超出动画时长
        Time = FMath::Min(Step * SampleInterval, AnimLength);
        // 用来判断是起步还是停步
        // 如果是起步动画，速度从0开始递增，速度最小值一定为正数且是开始的时候，所以TimeOfMinSpeed一定比Time小，得到的为1.0f
        // 如果是停步动画，速度逐渐递减到0，速度最小值一定为负数且在动画最后达到最小，则TimeOfMinSpeed的时间一定比Time大，得到的为-1.0f
        const float ValueSign = (Time < TimeOfMinSpeed) ? -1.0f : 1.0f;

        // 提取从TimeOfMinSpeed到Time之间的根运动距离
        const FVector RootMotionTranslation = Animation->ExtractRootMotionFromRange(TimeOfMinSpeed, Time).GetTranslation();
        // 将值添加到曲线中
        UAnimationBlueprintLibrary::AddFloatCurveKey(Animation, CurveName, Time, ValueSign * CalculateMagnitude(RootMotionTranslation, Axis));
    }

通过提取的距离曲线，我们可以实现起步与停步的步幅匹配

起步匹配

StartMatch

起步动画主要依靠AdvanceTimeByDistanceMatching，通过序列求值器选择每一帧的动画进行播放

函数声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
	 * Advance the sequence evaluator forward by distance traveled rather than time. A distance curve is required on the animation that
	 * describes the distance traveled by the root bone in the animation. See UDistanceCurveModifier.
	 * @param UpdateContext - The update context provided in the anim node function.
	 * @param SequenceEvaluator - The sequence evaluator node to operate on.
	 * @param DistanceTraveled - The distance traveled by the character since the last animation update.
	 * @param DistanceCurveName - Name of the curve we want to match 
	 * @param PlayRateClamp - A clamp on the effective play rate of the animation after distance matching. Set to (0,0) for no clamping.
	 */
	UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
	static FSequenceEvaluatorReference AdvanceTimeByDistanceMatching(const FAnimUpdateContext& UpdateContext, const FSequenceEvaluatorReference& SequenceEvaluator,
		float DistanceTraveled, FName DistanceCurveName, FVector2D PlayRateClamp = FVector2D(0.75f, 1.25f));

函数解释：根据动画前进的距离来设置动画的前进而非使用时间，这需要一个用于描述动画根骨骼位置的距离曲线，这个曲线我们可以从UDistanceCurveModifier中的来获取，这个在之前已经解释。

主要的三个参数为：
SequenceEvaluator：当前动画的序列求值器
DistanceTraveled：本帧移动的距离
DistanceCurveName：距离曲线

函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
FSequenceEvaluatorReference UAnimDistanceMatchingLibrary::AdvanceTimeByDistanceMatching(const FAnimUpdateContext& UpdateContext, const FSequenceEvaluatorReference& SequenceEvaluator,
	float DistanceTraveled, FName DistanceCurveName, FVector2D PlayRateClamp)
{
	// 1 进入时绑定了一个lambda函数作为参数一并传入CallAnimNodeFunction中被调用
	SequenceEvaluator.CallAnimNodeFunction<FAnimNode_SequenceEvaluator>(
		TEXT("AdvanceTimeByDistanceMatching"),
		[&UpdateContext, DistanceTraveled, DistanceCurveName, PlayRateClamp](FAnimNode_SequenceEvaluator& InSequenceEvaluator)
		{
			// 2.1 获取动画上下文
			if (const FAnimationUpdateContext* AnimationUpdateContext = UpdateContext.GetContext())
			{
				// 2.2 获取一个tick的时长
				const float DeltaTime = AnimationUpdateContext->GetDeltaTime(); 

				// 2.3 当tick时长与步进距离均大于0时继续执行下一步逻辑
				if (DeltaTime > 0 && DistanceTraveled > 0)
				{
					// 3.1 获取正在播放的动画并从动画中获取数据
					if (const UAnimSequenceBase* AnimSequence = Cast<UAnimSequence>(InSequenceEvaluator.GetSequence()))
					{
						// 3.2 获取当前时间，动画时长，是否循环播放
						const float CurrentTime = InSequenceEvaluator.GetExplicitTime();
						const float CurrentAssetLength = InSequenceEvaluator.GetCurrentAssetLength();
						const bool bAllowLooping = InSequenceEvaluator.IsLooping();

						// 4.1 获取在步进DistanceTraveled之后的动画时间
						// 这个函数的注释为：Advance from the current time to a new time in the animation that will result in the desired distance traveled by the authored root motion.
						// 从当前时间开始，根据根运动所经过的距离计算应到达的新的时间
						float TimeAfterDistanceTraveled = UE::Anim::DistanceMatchingUtility::GetTimeAfterDistanceTraveled(AnimSequence, CurrentTime, DistanceTraveled, DistanceCurveName, bAllowLooping);

						// 4.2 计算播放速率
						if (TimeAfterDistanceTraveled < CurrentTime)
						{
							TimeAfterDistanceTraveled += CurrentAssetLength;
						}
						float EffectivePlayRate = (TimeAfterDistanceTraveled - CurrentTime) / DeltaTime;

						// 4.3 限制播放速率
						if (PlayRateClamp.X >= 0.0f && PlayRateClamp.X < PlayRateClamp.Y)
						{
							EffectivePlayRate = FMath::Clamp(EffectivePlayRate, PlayRateClamp.X, PlayRateClamp.Y);
						}

						// 5.1 计算步进之后的动画时间
						float NewTime = CurrentTime;
						FAnimationRuntime::AdvanceTime(bAllowLooping, EffectivePlayRate * DeltaTime, NewTime, CurrentAssetLength);

						// 5.2 设置新的动画时间
						if (!InSequenceEvaluator.SetExplicitTime(NewTime))
						{
							UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set explicit time on sequence evaluator, value is not dynamic. Set it as Always Dynamic."));
						}
					}
					else
					{
						UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence evaluator does not have an anim sequence to play."));
					}
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("AdvanceTimeByDistanceMatching called with invalid context"));
			}
		});

	return SequenceEvaluator;
}

停步匹配

StopMatch

当角色停止运动时（玩家不再有运动方向的输入），此时角色会逐渐减速，这时需要计算角色的运动距离，然后将这个距离与动画进行匹配

GetPredictedStopDistance：这个函数已经提供了用于预测角色停止运动后的前进距离，在C++中为PredictGroundMovementStopLocation
DistanceMatchToTarget：这个函数用于将预测的距离与动画进行匹配

GetPredictedStopDistance

定义

1
2
3
4
5
6
7
8
9
10
/**
* Predict where the character will stop based on its current movement properties and parameters from the movement component.
* This uses prediction logic that is heavily tied to the UCharacterMovementComponent.
* Each parameter corresponds to a value from the UCharacterMovementComponent with the same name.
* Because this is a thread safe function, it's	recommended to populate these fields via the Property Access system.
* @return The predicted stop position in local space to the character. The size of this vector will be the distance to the stop location.
*/
UFUNCTION(BlueprintPure, Category = "Animation Character Movement", meta = (BlueprintThreadSafe))
static FVector PredictGroundMovementStopLocation(const FVector& Velocity,
	bool bUseSeparateBrakingFriction, float BrakingFriction, float GroundFriction, float BrakingFrictionFactor, float BrakingDecelerationWalking);

可以看到注释内容为：通过角色移动组件中的属性来预测当角色停止运动时角色移动的位置

  • Velocity：角色的速度
  • bUseSeparateBrakingFriction：是否使用单独的制动摩擦力
  • BrakingFriction：制动摩擦力
  • GroundFriction：地面摩擦力
  • BrakingFrictionFactor：制动摩擦力因数
  • BrakingDecelerationWalking：制动减速度

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
FVector UAnimCharacterMovementLibrary::PredictGroundMovementStopLocation(const FVector& Velocity, 
	bool bUseSeparateBrakingFriction, float BrakingFriction, float GroundFriction, float BrakingFrictionFactor, float BrakingDecelerationWalking)
{
	// 预测的停止位置
	FVector PredictedStopLocation = FVector::ZeroVector;

	// 选择实际摩檫力
	float ActualBrakingFriction = (bUseSeparateBrakingFriction ? BrakingFriction : GroundFriction);
	// 计算摩檫力
	const float FrictionFactor = FMath::Max(0.f, BrakingFrictionFactor);
	ActualBrakingFriction = FMath::Max(0.f, ActualBrakingFriction * FrictionFactor);
	float BrakingDeceleration = FMath::Max(0.f, BrakingDecelerationWalking);

	// 计算角色的地面速度
	const FVector Velocity2D = Velocity * FVector(1.f, 1.f, 0.f);
	FVector VelocityDir2D;
	float Speed2D;
	Velocity2D.ToDirectionAndLength(VelocityDir2D, Speed2D);

	// 高中数学：x = v * t + 0.5 * a * t^2
	// 这里先计算加速度
	const float Divisor = ActualBrakingFriction * Speed2D + BrakingDeceleration;
	if (Divisor > 0.f)
	{
		// 根据v = a * t计算停止时间
		const float TimeToStop = Speed2D / Divisor;
		// 将时间带入公式计算位置
		PredictedStopLocation = Velocity2D * TimeToStop + 0.5f * ((-ActualBrakingFriction) * Velocity2D - BrakingDeceleration * VelocityDir2D) * TimeToStop * TimeToStop;
	}

	// 将计算结果返回
	return PredictedStopLocation;
}

DistanceMatchToTarget

定义：

1
2
3
4
5
6
7
8
9
10
11
/**
* Set the time of the sequence evaluator to the point in the animation where the distance curve matches the DistanceToTarget input.
* A common use case is to achieve stops without foot sliding by, each frame, selecting the point in the animation that matches the distance the character has remaining until it stops.
* Note that because this technique sets the time of the animation by distance remaining, it doesn't respect phase of any previous animation (e.g. from a jog cycle).
* @param SequenceEvaluator - The sequence evaluator node to operate on.
* @param DistanceToTarget - The distance remaining to a target (e.g. a stop or pivot point).
* @param DistanceCurveName - Name of the curve we want to match 
*/
UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
static FSequenceEvaluatorReference DistanceMatchToTarget(const FSequenceEvaluatorReference& SequenceEvaluator,
	float DistanceToTarget, FName DistanceCurveName);

注释为：通过距离来设置序列求值器的播放时间，通过每帧选择动画中与角色剩余距离匹配的点来实现

  • SequenceEvaluator：序列求值器
  • DistanceToTarget：目标距离，即预测的行进距离
  • DistanceCurveName：距离曲线

实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
FSequenceEvaluatorReference UAnimDistanceMatchingLibrary::DistanceMatchToTarget(const FSequenceEvaluatorReference& SequenceEvaluator,
	float DistanceToTarget, FName DistanceCurveName)
{
	// 同样将一个lambda函数作为参数传递给CallAnimNodeFunction函数
	SequenceEvaluator.CallAnimNodeFunction<FAnimNode_SequenceEvaluator>(
		TEXT("DistanceMatchToTarget"),
		[DistanceToTarget, DistanceCurveName](FAnimNode_SequenceEvaluator& InSequenceEvaluator)
		{
			// 获取当前的动画序列
			if (const UAnimSequenceBase* AnimSequence = Cast<UAnimSequence>(InSequenceEvaluator.GetSequence()))
			{
				// 根据距离获取动画播放到的位置(播放时间)并将这个位置设置给当前播放的动画
				const float NewTime = UE::Anim::DistanceMatchingUtility::GetAnimPositionFromDistance(AnimSequence, -DistanceToTarget, DistanceCurveName);
				if (!InSequenceEvaluator.SetExplicitTime(NewTime))
				{
					UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set explicit time on sequence evaluator, value is not dynamic. Set it as Always Dynamic."));
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence evaluator does not have an anim sequence to play."));
			}
			
		});

	return SequenceEvaluator;
}

// 根据位置和距离曲线查找这个动画的时间节点
float GetAnimPositionFromDistance(const UAnimSequenceBase* InAnimSequence, const float& InDistance, FName InCurveName)
{	
	// 获取曲线数据
	FAnimCurveBufferAccess BufferCurveAccess(InAnimSequence, InCurveName);
	if (BufferCurveAccess.IsValid())
	{
		// 获取曲线的key，即在UDistanceCurveModifier中添加的位置
		const int32 NumKeys = BufferCurveAccess.GetNumSamples();
		if (NumKeys < 2)
		{
			return 0.f;
		}

		int32 First = 1;
		int32 Last = NumKeys - 1;
		int32 Count = Last - First;

		// 通过二分法查找符合的距离位置
		while (Count > 0)
		{
			int32 Step = Count / 2;
			int32 Middle = First + Step;

			if (InDistance > BufferCurveAccess.GetValue(Middle))
			{
				First = Middle + 1;
				Count -= Step + 1;
			}
			else
			{
				Count = Step;
			}
		}

		// 将位置转为时间并进行差值获取符合的时间节点
		const float KeyAValue = BufferCurveAccess.GetValue(First - 1);
		const float KeyBValue = BufferCurveAccess.GetValue(First);
		const float Diff = KeyBValue - KeyAValue;
		const float Alpha = !FMath::IsNearlyZero(Diff) ? ((InDistance - KeyAValue) / Diff) : 0.f;

		const float KeyATime = BufferCurveAccess.GetTime(First - 1);
		const float KeyBTime = BufferCurveAccess.GetTime(First);
		return FMath::Lerp(KeyATime, KeyBTime, Alpha);
	}

	return 0.f;
}

流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
flowchart TD
    A[开始距离匹配] --> B{匹配场景选择}
    
    B --> C[起步匹配]
    B --> D[停步匹配]
    
    %% 起步匹配分支
    subgraph C [起步匹配流程]
        direction LR
        C1[起步动画] --> C2[提取根运动距离曲线]
        C2 --> C3[采样生成Distance曲线<br/>采样率:30Hz]
        C3 --> C4[根据本帧移动距离<br/>查找对应动画时间]
        C4 --> C5[设置动画播放时间<br/>播放速率限制:0.75-1.25]
        C5 --> C6[起步匹配完成]
    end
    
    %% 停步匹配分支
    subgraph D [停步匹配流程]
        direction LR
        D1[停步动画] --> D2[预测停止位置<br/>基于速度/摩擦力/减速度]
        D2 --> D3[计算剩余距离]
        D3 --> D4[反向查找距离曲线<br/>对应时间点]
        D4 --> D5[设置停步动画时间]
        D5 --> D6[停步匹配完成]
    end
    
    C6 --> E[应用匹配动画]
    D6 --> E
    
    E --> F[消除滑步]

注意事项

  • 使用UE版本为5.5.4
  • 确保动画已开启根运动
  • 距离曲线名称需与代码中一致
  • 采样率过高可能导致性能问题

展开全文 >>

步幅匹配

步幅匹配

主要用于角色的循环移动动画，当角色完成起步后回进入循环移动动画，但角色的移动速度与动画的速度不匹配时依然会出现滑步的情况，所以我们通常会拿到角色的移动速度与动画的移动速度做比值来调整动画的播放速度从而使动画的移动与角色的速度相匹配。

除了动态调整循环动画的播放速度外，还需要调整角色的脚步步幅，一般来讲，当人的奔跑速度增加时，出了步频会增加外，步幅同样也会增加，所以为了防止角色的高速或低速情况下出现脚步鬼畜的情况，还需要对角色进行footik来调整步幅。

综上步幅匹配主要包括两部分：速度匹配和脚步ik

速度匹配

SpeedMatch

主要通过SetPlayrateToMatchSpeed来实现

1
2
3
4
5
6
7
8
9
10
11
12
/**
* Set the play rate of the sequence player so that the speed of the animation matches in-game movement speed.
* While distance matching is commonly used for transition animations, cycle animations (walk, jog, etc) typically just adjust their play rate to match
* the in-game movement speed.
* This function assumes that the animation has a constant speed.
* @param SequencePlayer - The sequence player node to operate on.
* @param SpeedToMatch - The in-game movement speed to match. This is usually the current speed of the movement component.
* @param PlayRateClamp - A clamp on how much the animation's play rate can change to match the in-game movement speed. Set to (0,0) for no clamping.
*/
UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
static FSequencePlayerReference SetPlayrateToMatchSpeed(const FSequencePlayerReference& SequencePlayer, 
    float SpeedToMatch, FVector2D PlayRateClamp = FVector2D(0.75f, 1.25f));

注释为：根据角色在游戏中的移动速度来设置动画的播放速度

  • SequencePlayer：序列播放器，包含需要播放的动画序列
  • SpeedToMatch：需要匹配的移动速度，通常为角色的地面移动速度
  • PlayRateClamp：播放速度的上下限，默认为0.75到1.25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
FSequencePlayerReference UAnimDistanceMatchingLibrary::SetPlayrateToMatchSpeed(const FSequencePlayerReference& SequencePlayer, float SpeedToMatch, FVector2D PlayRateClamp)
{
    // 绑定了一个lambda函数作为参数一并传入CallAnimNodeFunction中被调用
	SequencePlayer.CallAnimNodeFunction<FAnimNode_SequencePlayer>(
		TEXT("SetPlayrateToMatchSpeed"),
		[SpeedToMatch, PlayRateClamp](FAnimNode_SequencePlayer& InSequencePlayer)
		{
            // 获取当前播放的动画序列
			if (const UAnimSequence* AnimSequence = Cast<UAnimSequence>(InSequencePlayer.GetSequence()))
			{
                // 获取序列的长度，如果长度大于0则进行调整
				const float AnimLength = AnimSequence->GetPlayLength();
				if (!FMath::IsNearlyZero(AnimLength))
				{
					// Calculate the speed as: (distance traveled by the animation) / (length of the animation)
                    // 获取动画从开始到结束的根运动距离并计算平面的移动距离
					const FVector RootMotionTranslation = AnimSequence->ExtractRootMotionFromRange(0.0f, AnimLength).GetTranslation();
					const float RootMotionDistance = RootMotionTranslation.Size2D();
                    // 当角色的移动距离大于0时则进行调整
					if (!FMath::IsNearlyZero(RootMotionDistance))
					{
                        // 获取动画速度
						const float AnimationSpeed = RootMotionDistance / AnimLength;
                        // 获取速度当前的移动速度与动画的速度的比值
						float DesiredPlayRate = SpeedToMatch / AnimationSpeed;
						if (PlayRateClamp.X >= 0.0f && PlayRateClamp.X < PlayRateClamp.Y)
						{
							DesiredPlayRate = FMath::Clamp(DesiredPlayRate, PlayRateClamp.X, PlayRateClamp.Y);
						}

						// 根据比值来动态调整动画的播放速度
						if (!InSequencePlayer.SetPlayRate(DesiredPlayRate))
						{
							UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set play rate on sequence player, value is not dynamic. Set it as Always Dynamic."));
						}
					}
					else
					{
						UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Unable to adjust playrate for animation with no root motion delta (%s)."), *GetNameSafe(AnimSequence));
					}
				}
				else
				{
					UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Unable to adjust playrate for zero length animation (%s)."), *GetNameSafe(AnimSequence));
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence player does not have an anim sequence to play."));
			}
		});

	return SequencePlayer;
}

脚步IK

主要是通过跨步扭曲(StrideWarping)来实现。

StrideWarping

在细节面板中展示了需要调整的选项，主要为添加需要进行匹配的脚步骨骼，StrideWarping节点本身需要传入开始混入的alpha值(skeleton control的强度)以及角色地面的移动速度（MatchSpeed）。

该节点定义在UAnimGraphNode_StrideWarping中，其中最主要的内容为声明的一个FAnimNode_StrideWarping类型的成员变量Node，在这个Node中定义了大多在细节面板中使用到的属性，同时还包括一些节点使用的初始化和更新方法。

初始化

其中初始化方法为:Initialize_AnyThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void FAnimNode_StrideWarping::Initialize_AnyThread(const FAnimationInitializeContext& Context)
{
	FAnimNode_SkeletalControlBase::Initialize_AnyThread(Context);
	
    // 初始化代理
	AnimInstanceProxy = Context.AnimInstanceProxy;
	// 用于夹值和插值
    StrideScaleModifierState.Reinitialize();
	// 初始化朝向
    ActualStrideDirection = FVector::ForwardVector;
	// 初始化步幅
    ActualStrideScale = 1.f;
#if WITH_EDITORONLY_DATA
    // 调试模式下使用，获取根骨骼的位移和速度
	CachedRootMotionDeltaTranslation = FVector::ZeroVector;
	CachedRootMotionDeltaSpeed = 0.f;
#endif
}

其中还有另一个初始化方法:InitializeBoneReferences，这个方法用于初始化我们在节点中写入的骨骼引用

更新

其中更新的方法为:EvaluateSkeletalControl_AnyThread，这是更新的主要方法，也是进行跨步扭曲的核心方法，接下来将对这个方法进行解析。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
void FAnimNode_StrideWarping::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms)
{
	SCOPE_CYCLE_COUNTER(STAT_StrideWarping_Eval);
	check(OutBoneTransforms.IsEmpty());

	// 获取当前帧的跨步朝向以及上一帧的朝向
	const FVector PreviousStrideDirection = ActualStrideDirection;
	ActualStrideDirection = StrideDirection;
	// 跨步缩放值->步幅的大小
	ActualStrideScale = StrideScale;

	// 是否使用图表模式
	bool bGraphDrivenWarping = false;
	// 获取根运动提取器,如果改提取器是有效的则使用图表模式
	const UE::Anim::IAnimRootMotionProvider* RootMotionProvider = UE::Anim::IAnimRootMotionProvider::Get();

	// 判断是否为图表模式,在节点的细节面板中可以选择
	if (Mode == EWarpingEvaluationMode::Graph)
	{
		bGraphDrivenWarping = !!RootMotionProvider;
		ensureMsgf(bGraphDrivenWarping, TEXT("Graph driven Stride Warping expected a valid root motion delta provider interface."));
	}

	// 初始化运动距离
	FTransform RootMotionTransformDelta = FTransform::Identity;
#if WITH_EDITORONLY_DATA
	// 编辑器下的调试设置
	bFoundRootMotionAttribute = false;
#else
	FVector CachedRootMotionDeltaTranslation = FVector::ZeroVector;
#endif
	if (bGraphDrivenWarping)
	{
		// 如果根运动是有效的话则提取根运动
		// Output的含义:在AnimInstance更新时会从Root开始递归更新骨骼的pose,这个output就是动画节点左边的连线所计算的pose
		// Graph driven stride warping will override the manual stride direction with the intent of the current animation sub-graph's accumulated root motion
		bGraphDrivenWarping = RootMotionProvider->ExtractRootMotion(Output.CustomAttributes, RootMotionTransformDelta);
		if (bGraphDrivenWarping)
		{
			// 缓存根运动的位移数据
			CachedRootMotionDeltaTranslation = RootMotionTransformDelta.GetTranslation();
			// If there's no root motion delta, keep the previous stride direction
			// 根据两帧之间的位移差值拿到运动的朝向
			ActualStrideDirection = CachedRootMotionDeltaTranslation.GetSafeNormal(UE_SMALL_NUMBER, PreviousStrideDirection);
#if WITH_EDITORONLY_DATA
			// Graph driven Stride Warping expects a root motion delta to be present in the attribute stream.
			// 编辑器下的调试设置
			bFoundRootMotionAttribute = true;
#endif
		}
		// Early exit on missing root motion delta attribute
		// 否则说明在图表模式下没有开启根运动,提前返回
		else if (bDisableIfMissingRootMotion)
		{
			return;
		}
	}

	// 拿到output中的骨骼数据
	const FBoneContainer& RequiredBones = Output.Pose.GetPose().GetBoneContainer();
	// 从output的骨骼数据中拿到脚步ik骨骼的空间网格体数据
	const FTransform IKFootRootTransform = Output.Pose.GetComponentSpaceTransform(IKFootRootBone.GetCompactPoseIndex(RequiredBones));
	// 获取地面的法线向量,一般为(0, 0, 1)
	const FVector ResolvedFloorNormal = FloorNormalDirection.AsComponentSpaceDirection(AnimInstanceProxy, IKFootRootTransform);
	// 获取重力方向,一般默认向下(0 ,0, -1)
	const FVector ResolvedGravityDirection = GravityDirection.AsComponentSpaceDirection(AnimInstanceProxy, IKFootRootTransform);

	// 是否使用地面方向来旋转跨步朝向
	// 根据下面的计算可以得到:
	// 首先将实际跨步方向和地面法线方向进行叉乘,可以得到横向的轴向向量
	// 再将轴向向量和地面法向向量进行叉乘得到实际方向
	// 主要用来处理一些上下坡等非水平面的运动方向
	if (bOrientStrideDirectionUsingFloorNormal)
	{
		const FVector StrideWarpingAxis = ResolvedFloorNormal ^ ActualStrideDirection;
		ActualStrideDirection = StrideWarpingAxis ^ ResolvedFloorNormal;
	}

#if ENABLE_ANIM_DEBUG
	bool bDebugging = false;
#if WITH_EDITORONLY_DATA
	bDebugging = bDebugging || bEnableDebugDraw;
#else
	constexpr float DebugDrawScale = 1.f;
#endif
	bDebugging = bDebugging || CVarAnimNodeStrideWarpingDebug.GetValueOnAnyThread() == 1;
	if (bDebugging)
	{
		// 绘制骨骼信息用于调试
		// Draw Floor Normal
		AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
			AnimInstanceProxy->GetComponentTransform().TransformPosition(IKFootRootTransform.GetLocation()),
			AnimInstanceProxy->GetComponentTransform().TransformPosition(IKFootRootTransform.GetLocation() + ResolvedFloorNormal * 25.f * DebugDrawScale),
			40.f * DebugDrawScale, FColor::Blue, false, 0.f, 2.f * DebugDrawScale);
	}
#endif

	// Get all foot IK Transforms
	// FootData在InitializeBoneReferences中初始化,数据来源与output一致,从节点左边输出的骨骼数据中获取
	for (auto& Foot : FootData)
	{
		Foot.IKFootBoneTransform = Output.Pose.GetComponentSpaceTransform(Foot.IKFootBoneIndex);
#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootOrigin
#endif
		)
		{
			const FVector FootWorldLocation = AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation());
			AnimInstanceProxy->AnimDrawDebugSphere(FootWorldLocation, 8.f * DebugDrawScale, 16, FColor::Red);
		}
#endif
	}

	// 如果开启根运动则对实际步幅进行调整
	if (bGraphDrivenWarping)
	{
		// CachedRootMotionDeltaSpeed,存储根运动的速度
#if WITH_EDITORONLY_DATA
		CachedRootMotionDeltaSpeed = CachedRootMotionDeltaTranslation.Size() / CachedDeltaTime;
#else
		const float CachedRootMotionDeltaSpeed = CachedRootMotionDeltaTranslation.Size() / CachedDeltaTime;
#endif

		// 如果速度小于根运动的最小移动速度则不调整步幅
		// 否则根据实际速度对步幅进行等比缩放
		if (CachedRootMotionDeltaSpeed <= MinRootMotionSpeedThreshold)
		{
			// If root motion speed is under the threshold, snap back to no stride adjustment.
			// If interpolation is on, it will blend the result
			ActualStrideScale = 1.0f;
		}
		else
		{
			// Graph driven stride scale factor will be determined by the ratio of the
			// locomotion (capsule/physics) speed against the animation root motion speed
			ActualStrideScale = LocomotionSpeed / CachedRootMotionDeltaSpeed;
		}
	}

	// Allow the opportunity for stride scale clamping and interpolation regardless of evaluation mode
	// 翻译无论采用哪种模式(EWarpingEvaluationMode中的定义),都对步幅进行夹值和插值(可能是用于平滑过渡)
	ActualStrideScale = StrideScaleModifierState.ApplyTo(StrideScaleModifier, ActualStrideScale, CachedDeltaTime);

	// 如果开启了根运动则根据实际的步幅大小对运动位移进行缩放
	// 同时尝试对输入的骨骼数据使用缩放后的位移数据进行覆盖
	if (bGraphDrivenWarping)
	{
		// Forward the side effects of stride warping on the root motion contribution for this sub-graph
		RootMotionTransformDelta.ScaleTranslation(ActualStrideScale);
		const bool bRootMotionOverridden = RootMotionProvider->OverrideRootMotion(RootMotionTransformDelta, Output.CustomAttributes);
		ensureMsgf(bRootMotionOverridden, TEXT("Graph driven Stride Warping expected a root motion delta to be present in the attribute stream prior to warping/overriding it."));
	}

	// 处理脚步ik
	// Scale IK feet bones along Stride Warping Axis, from the Thigh bone location.
	// 翻译:从大腿骨开始沿着跨步扭曲的轴向对脚步ik数据进行缩放
	for (auto& Foot : FootData)
	{
		// Stride Warping along Stride Warping Axis
		// 获取脚步ik骨骼的位置以及大腿骨的位置
		const FVector IKFootLocation = Foot.IKFootBoneTransform.GetLocation();
		const FVector ThighBoneLocation = Output.Pose.GetComponentSpaceTransform(Foot.ThighBoneIndex).GetLocation();

		// Project Thigh Bone Location on plane made of FootIKLocation and FloorPlaneNormal, along Gravity Dir.
		// 翻译:沿着重力方向将大腿骨的位置投影在由脚步ik骨的位置和地面法线所组成的平面上
		// LinePlaneIntersection:线平面交点
		// This will be the StrideWarpingPlaneOrigin
		// 首先判断重力和地面法线是否平行,如果平行,则直接使用脚步ik骨骼的位置
		// 否则进行投影:以脚步ik骨的位置作为平面的原点,以地面的法线作为平面的法线得到一个片面,将大腿骨的位置沿着重力的方向投影在这个平面上
		// 实际得到的就是大腿骨在脚步ik骨位置的运动平面上的投影位置
		const FVector StrideWarpingPlaneOrigin = (FMath::Abs(ResolvedGravityDirection | ResolvedFloorNormal) > DELTA) ? FMath::LinePlaneIntersection(ThighBoneLocation, ThighBoneLocation + ResolvedGravityDirection, IKFootLocation, ResolvedFloorNormal) : IKFootLocation;

		// Project FK Foot along StrideWarping Plane, this will be our Scale Origin
		// 翻译:将脚步ik骨的位置投影在跨步平面上(运动平面)
		// 以上一步得到的投影位置作为平面的原点,实际的运动方向作为该平面的法线构造平面
		// 计算脚步ik骨在这个平面上的投影
		const FVector ScaleOrigin = FVector::PointPlaneProject(IKFootLocation, StrideWarpingPlaneOrigin, ActualStrideDirection);

		// 由IKFootLocation和ScaleOrigin可以计算出脚步ik骨的运动方向,再乘以实际的步幅加上投影位置就是新的脚步骨骼应该在的位置
		// Now the ScaleOrigin and IKFootLocation are forming a line parallel to the floor, and we can scale the IK foot.
		const FVector WarpedLocation = ScaleOrigin + (IKFootLocation - ScaleOrigin) * ActualStrideScale;
		Foot.IKFootBoneTransform.SetLocation(WarpedLocation);

#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootAdjustment
#endif
		)
		{
			const FVector FootWorldLocation = AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation());
			AnimInstanceProxy->AnimDrawDebugSphere(FootWorldLocation, 8.f * DebugDrawScale, 16, FColor::Green);

			const FVector ScaleOriginWorldLoc = AnimInstanceProxy->GetComponentTransform().TransformPosition(ScaleOrigin);
			AnimInstanceProxy->AnimDrawDebugSphere(ScaleOriginWorldLoc, 8.f * DebugDrawScale, 16, FColor::Yellow);
		}
#endif
	}

	// 开始计算盆骨偏移,首先进行初始化
	FVector PelvisOffset = FVector::ZeroVector;
	const FCompactPoseBoneIndex PelvisBoneIndex = PelvisBone.GetCompactPoseIndex(RequiredBones);

	// 获取盆骨的位置信息并初始化盆骨的位置
	FTransform PelvisTransform = Output.Pose.GetComponentSpaceTransform(PelvisBoneIndex);
	const FVector InitialPelvisLocation = PelvisTransform.GetLocation();

	// 声明一个容器用于存储所有FK骨骼到盆骨的距离
	TArray<float, TInlineAllocator<10>> FKFootDistancesToPelvis;
	FKFootDistancesToPelvis.Reserve(FootData.Num());

	// 声明一个容器储存所有IK骨骼的位置
	TArray<FVector, TInlineAllocator<10>> IKFootLocations;
	IKFootLocations.Reserve(FootData.Num());

	// 遍历脚步ik骨骼的数据并获取距离和位置信息
	for (auto& Foot : FootData)
	{
		const FVector FKFootLocation = Output.Pose.GetComponentSpaceTransform(Foot.FKFootBoneIndex).GetLocation();
		FKFootDistancesToPelvis.Add(FVector::Dist(FKFootLocation, InitialPelvisLocation));

		const FVector IKFootLocation = Foot.IKFootBoneTransform.GetLocation();
		IKFootLocations.Add(IKFootLocation);
	}

	// Adjust Pelvis down if needed to keep foot contact with the ground and prevent over-extension
	// 翻译:将盆骨的位置向下进行调整以保证脚步解除地面同时防止过度拉伸
	PelvisTransform = PelvisIKFootSolver.Solve(PelvisTransform, FKFootDistancesToPelvis, IKFootLocations, CachedDeltaTime);

#if ENABLE_ANIM_DEBUG
	if (bDebugging
#if WITH_EDITORONLY_DATA
		&& bDebugDrawPelvisAdjustment
#endif
	)
	{
		// Draw Adjustments in Pelvis location
		AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation), 8.f * DebugDrawScale, 16, FColor::Red);
		AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(PelvisTransform.GetLocation()), 8.f * DebugDrawScale, 16, FColor::Blue);
	}

	if (bDebugging)
	{
		// Draw Stride Direction
		AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
			AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation),
			AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation + ActualStrideDirection * ActualStrideScale * 100.f * DebugDrawScale),
			40.f * DebugDrawScale, FColor::Red, false, 0.f, 2.f * DebugDrawScale);

		// Draw text on mesh in world space
		{
			TStringBuilder<1024> DebugLine;

			DebugLine.Appendf(TEXT("\n - Stride Scale: (%.3fd)"), ActualStrideScale);
			DebugLine.Appendf(TEXT("\n - Stride Direction: (%s)"), *(ActualStrideDirection.ToCompactString()));
			
			if (Mode == EWarpingEvaluationMode::Graph)
			{
				DebugLine.Appendf(TEXT("\n - Locomotion Speed: (%.3fd)"), LocomotionSpeed);

#if WITH_EDITORONLY_DATA
				if (bFoundRootMotionAttribute)
				{
					DebugLine.Appendf(TEXT("\n - Root Motion: Direction(%s), Speed(%.3fd)"), *(CachedRootMotionDeltaTranslation.GetSafeNormal().ToCompactString()), CachedRootMotionDeltaSpeed);
				}
				else
				{
					DebugLine.Appendf(TEXT("\n - Root Motion: NO ATTRIBUTE FOUND"), *(ActualStrideDirection.ToCompactString()));
				}
#endif

				DebugLine.Appendf(TEXT("\n - Min Root Motion Speed Threshold: (%.3fd)"), MinRootMotionSpeedThreshold);
			}

			AnimInstanceProxy->AnimDrawDebugInWorldMessage(DebugLine.ToString(), FVector::UpVector * 50.0f, FColor::Yellow, 1.f /*TextScale*/);
		}
	}
#endif
	// Add adjusted pelvis transform
	check(!PelvisTransform.ContainsNaN());
	// 将盆骨偏移后的位置数据添加到输出骨骼中
	OutBoneTransforms.Add(FBoneTransform(PelvisBoneIndex, PelvisTransform));

	// Compute final offset to use below
	// 获取盆骨调整后的差值
	PelvisOffset = (PelvisTransform.GetLocation() - InitialPelvisLocation);

	// Rotate Thigh bones to help IK, and maintain leg shape.
	// 翻译:旋转大腿骨骼以适配脚步ik,同时保证腿部的形状(应该是为了防止位移过大导致变形)
	if (bCompensateIKUsingFKThighRotation)
	{
		for (auto& Foot : FootData)
		{
			// 获取大腿骨位置和脚步位置
			const FTransform ThighTransform = Output.Pose.GetComponentSpaceTransform(Foot.ThighBoneIndex);
			const FTransform FKFootTransform = Output.Pose.GetComponentSpaceTransform(Foot.FKFootBoneIndex);

			// 将盆骨偏移应用的大腿骨的位置中
			FTransform AdjustedThighTransform = ThighTransform;
			AdjustedThighTransform.AddToTranslation(PelvisOffset);

			// 获取当前的脚步-大腿朝向以及目标的脚步-大腿朝向
			const FVector InitialDir = (FKFootTransform.GetLocation() - ThighTransform.GetLocation()).GetSafeNormal();
			const FVector TargetDir = (Foot.IKFootBoneTransform.GetLocation() - AdjustedThighTransform.GetLocation()).GetSafeNormal();
			
#if ENABLE_ANIM_DEBUG
			if (bDebugging
#if WITH_EDITORONLY_DATA
				&& bDebugDrawThighAdjustment
#endif
			)
			{
				AnimInstanceProxy->AnimDrawDebugLine(
					AnimInstanceProxy->GetComponentTransform().TransformPosition(ThighTransform.GetLocation()),
					AnimInstanceProxy->GetComponentTransform().TransformPosition(FKFootTransform.GetLocation()),
					FColor::Red, false, 0.f, 2.f * DebugDrawScale);

				AnimInstanceProxy->AnimDrawDebugLine(
					AnimInstanceProxy->GetComponentTransform().TransformPosition(AdjustedThighTransform.GetLocation()),
					AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation()),
					FColor::Green, false, 0.f, 2.f * DebugDrawScale);
			}
#endif
			// Find Delta Rotation take takes us from Old to New dir
			// 获取两个方向之间的旋转值
			const FQuat DeltaRotation = FQuat::FindBetweenNormals(InitialDir, TargetDir);

			// Rotate our Joint quaternion by this delta rotation
			// 将旋转值应用值大腿骨
			AdjustedThighTransform.SetRotation(DeltaRotation * AdjustedThighTransform.GetRotation());

			// Add adjusted thigh transform
			check(!AdjustedThighTransform.ContainsNaN());
			// 将调整后的骨骼添加到输出中
			OutBoneTransforms.Add(FBoneTransform(Foot.ThighBoneIndex, AdjustedThighTransform));

			// Clamp IK Feet bone based on FK leg. To prevent over-extension and preserve animated motion.
			// 通过大腿的FK限制脚步IK防止腿部过度拉伸
			// 如果调整后的脚步IK骨与调整后的大腿骨的距离大于FK的距离则使用FK的距离重新调整这个脚步IK的位置
			if (bClampIKUsingFKLimits)
			{
				const float FKLength = FVector::Dist(FKFootTransform.GetLocation(), ThighTransform.GetLocation());
				const float IKLength = FVector::Dist(Foot.IKFootBoneTransform.GetLocation(), AdjustedThighTransform.GetLocation());
				if (IKLength > FKLength)
				{
					const FVector ClampedFootLocation = AdjustedThighTransform.GetLocation() + TargetDir * FKLength;
					Foot.IKFootBoneTransform.SetLocation(ClampedFootLocation);
				}
			}
		}
	}

	// Add final IK feet transforms
	// 将调整后的脚步数据应用到输出数据中
	for (auto& Foot : FootData)
	{
#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootFinal
#endif
		)
		{
			AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation()), 8.f * DebugDrawScale, 16, FColor::Blue);
		}
#endif
		check(!Foot.IKFootBoneTransform.ContainsNaN());
		OutBoneTransforms.Add(FBoneTransform(Foot.IKFootBoneIndex, Foot.IKFootBoneTransform));
	}

	// Sort OutBoneTransforms so indices are in increasing order.
	// 按照骨骼树的位置对骨骼进行排序让其对应骨骼树中的索引
	OutBoneTransforms.Sort(FCompareBoneTransformIndex());
}

更新流程:

  1. 获取实际的运动方向和运动速度
  2. 根据速度和方向调整脚步的位置
  3. 调整盆骨位置
  4. 根据盆骨的偏移和大腿的旋转限制脚步的位置
  5. 将调整后的骨骼数据添加到输出中并按照骨骼树进行排序

流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
flowchart TD
    A[开始步幅匹配] --> B{匹配模式选择}
    
    B --> C[速度匹配模式]
    B --> D[脚步IK模式]
    
    %% 速度匹配分支
    subgraph C [速度匹配流程]
        direction LR
        C1[循环移动动画] --> C2[计算动画固有速度<br/>根运动距离/动画时长]
        C2 --> C3[计算速度比值<br/>角色速度/动画速度]
        C3 --> C4[应用播放速率<br/>限制范围:0.75-1.25]
        C4 --> C5[速度匹配完成]
    end
    
    %% 脚步IK分支
    subgraph D [脚步IK流程]
        direction LR
        D1[获取运动参数<br/>方向与速度] --> D2[计算步幅缩放比例<br/>角色速度/根运动速度]
        D2 --> D3[脚步骨骼空间投影<br/>基于运动平面]
        D3 --> D4[应用步幅缩放<br/>调整骨骼位置]
        D4 --> D5[盆骨偏移计算<br/>保持腿部形态]
        D5 --> D6[大腿旋转补偿<br/>防止过度拉伸]
        D6 --> D7[应用所有骨骼调整]
        D7 --> D8[脚步IK完成]
    end
    
    C5 --> E[动态调整步频<br/>保持动画节奏]
    D8 --> F[调整步幅大小<br/>防止鬼畜现象]
    
    E --> G[自然流畅的循环移动]
    F --> G

展开全文 >>

服务器倒带

服务器倒带(Server Rewind)主要用于解决多人在线游戏中，由于网络延迟导致的客户端与服务器表现不一致问题。该技术特别适用于第一人称射击(FPS)和动作类游戏，能够在不牺牲响应性的前提下保证游戏的公平性。

服务器倒带算法的实现思路

在服务器上保存玩家一段时间内的历史状态信息（位置、旋转等），当收到客户端的命中请求时，根据客户端上报的时间戳将目标玩家的状态回滚到对应时刻，重新进行碰撞检测以验证命中有效性。

所以我们需要如下结构体：

1
2
3
4
5
6
7
8
9
struct FHistoryCache
{
public:
    float Time; // 运行时间
    FVector Loction; // 位置
    FRotator Rotation; // 旋转

    static void Create(...); // 创建方法
};

保存的时间

在这个结构体中我们保存了游戏的运行时间，UE给我们提供了游戏自开始一共运行了多少时间，我们可以很容易的获取并将其保存到缓存中，但需要注意的是：这个时间会因为客户端服务端的差异而存在不同，所以我们需要对时间进行校准。

时间校准的方法

我们可以向服务器请求一次当前服务器的运行时间并将客户端时间一并上报，当服务器收到客户端的请求后便将服务器运行时间于客户端上报的时间一并下发给客户端，这样便可以计算出服务器的运行时间。

具体过程：

  1. 在需要校准时间时将客户端的时间上报给服务器
  2. 服务器收到客户端上报的时间后将服务器的时间于客户端的时间一并发送给客户端
  3. 客户端收到后可以根据上报时的客户端时间计算出RTT，这里假设客户端服务端进行一次通信所花费的时间相同，即服务端收到客户端上报的时间于客户端收到服务器下发的数据所花费的时间相同，就可以计算出客户端在收到服务器下发数据时的运行时间

具体实现

我们将实现放在玩家的控制器中，继承APlayerController类。

ASGPlayerController的头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class ASGPlayerController : public APlayerController
{
public:
    ASGPlayerController();

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaSeconds) override;

    /** 客户端上报服务器 */
    UFUNCTION(Server, Reliable)
    void Server_ReqServerTime(float ClientTime);

    /** 服务器响应客户端 */
    UFUNCTION(Client, Reliable)
    void Client_RspServerTime(float ServerTime, float ClientTime);

    UFUNCTION(BlueprintPure)
    float GetServerTime();
protected:
    /** 客户端服务端运行时间的差值 */
    float DeltaTimeInCS = 0.0f;

    /** 检查时间 */
    float CheckTime = 0.0f;

    /** RTT */
    float RTT = 0.0f;

    /** 检查间隔 */
    UPROPERTY(EditAnywhere)
    float CheckInterval = 4.0f;
};

ASGPlayerController的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
ASGPlayerController::ASGPlayerController()
{
    // 在Tick中决定校准运行时间的时机
    PrimaryActorTick.bCanEverTick = true;
};

ASGPlayerController::BeginPlay()
{
    Super::BeginPlay();

    // 客户端玩家进入游戏时校准一次时间
    if(!HasAuthority())
    {
        Server_ReqServerTime(GetWorld()->GetTimeSeconds());
    }
}

ASGPlayerController::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);

    // 只在客户端校准
    if(!HasAuthority())
    {
        if(CheckTime > CheckInterval)
        {
            CheckTime = 0.0f;
            Server_ReqServerTime(GetWorld()->GetTimeSeconds());
        }
        CheckTime += DeltaSeconds;
    }
}

ASGPlayerController::Server_ReqServerTime_Implementation(float ClientTime)
{
    // 服务器收到后将服务器运行时间于客户端上报的时间一并下发给客户端
    Client_RspServerTime(GetWorld()->GetTimeSeconds(), ClientTime);
}

ASGPlayerController::Client_RspServerTime_Implementation(float ServerTime, float ClientTime)
{
    RTT = GetWorld()->GetTimeSeconds() - ClientTime;
    // 当前时刻服务器的实际运行时间
    ServerTime += RTT * 0.5;
    // 客户端与服务器运行时间的差值
    DeltaTimeInCS = GetWorld()->GetTimeSeconds() - ServerTime;
}

float ASGPlayerController::GetServerTime()
{
    // 如果是服务器直接返回世界时间
    if (HasAuthority())
    {
        return GetWorld()->GetTimeSeconds();
    }
    // 否则返回客户端时间减去差值
    return GetWorld()->GetTimeSeconds() - DeltaTimeInCS;
}

位置与旋转

为了便于实现，我们只在玩家身上挂载一个UBoxComponent, 将这个BoxComponent用作玩家回滚后的击中判定：

1
2
3
4
5
6
7
8
class ASGCharacter : public ACharacter
{
    // ...

public:
    UPROPERTY(EditAnywhere)
    TObjectPtr<UBoxComponent> BoxComponent;
};

倒带过程

我们使用一个组件来承担倒带的主要逻辑，主要实现功能为：

  1. 记录一段时间内玩家的历史位置信息
  2. 根据上报的信息回滚玩家位置并确认击中
  3. 使用循环数组保存信息以减少开销
  4. 需要提供可视化调试

USGLagComponent的头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/** 历史缓存的结构体，存储每帧玩家的位置以及时间信息 */
USTRUCT(BlueprintType)
struct FSGHistoryFrameCache
{
	GENERATED_BODY()
public:
	/** 缓存的时间 */
	float Time;

	/** 位置信息 */
	FVector BoxLocation;

	/** 旋转信息 */
	FRotator BoxRotation;
	
    /** 创建方法 */
	static void CreateHistoryFrame(ASGCharacter* Character, FSGHistoryFrameCache& CurrentFrame)
	{
		if (IsValid(Character))
		{
			CurrentFrame.Time = Character->GetWorld()->GetTimeSeconds();
			CurrentFrame.BoxLocation = Character->GetHitBoxComponent()->GetComponentLocation();
			CurrentFrame.Rotation = Character->GetHitBoxComponent()->GetComponentRotation();
		}
	}
};

class USGLagComponent : public UActorComponent
{
public:	
	
	USGLagComponent();

	virtual void BeginPlay() override;

	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

    /** 检查是否被击中 */
	UFUNCTION(BlueprintCallable)
	bool CheckHit(FVector& StartLocation, FVector& EndLocation, float HittedTime);

protected:
    /** 尝试保存每帧的回滚信息 */
	void TrySaveFrame();

    /**
    * 根据目标时间查找历史帧并进行线性插值
    * @param TargetTime 目标时间（服务器时间）
    * @param bFind 输出参数，是否找到合适帧
    * @param FrameCache 输出参数，插值后的帧数据
    */
	void FindFrame_Liner(float TargetTime, bool& bFind, FSGHistoryFrameCache& FrameCache);
	
    /** 玩家 */
	TWeakObjectPtr<ASGCharacter> OwnerCharacter;

    /** 历史帧缓存列表 */
	TArray<FSGHistoryFrameCache> HistoryFrameCache;
	
    /** 保存的有效帧数 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly)
	int32 ValidTickNum = 64;
    
    /** 用于记录保存的帧号，为了与数组下标对应，从-1开始记录 */
	int32 CurrentTickNum = -1;
	
    /** 是否开启调试 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bDebug = false;
};

USGLagComponent的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
USGLagComponent::USGLagComponent()
{
	PrimaryComponentTick.bCanEverTick = true;
}

USGLagComponent::BeginPlay()
{
	Super::BeginPlay();
}

USGLagComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

    // 尝试保存每帧的回滚信息
	TrySaveFrame();
}

bool USGLagComponent::CheckHit(FVector& StartLocation, FVector& EndLocation, float HittedTime)
{
    // 前置检查
	if (!OwnerCharacter.IsValid() || !GetWorld())
	{
		return false;
	}

    UBoxComponent* HittedBox = OwnerCharacter->GetHitBoxComponent();
    if (!IsValid(HittedBox))
    {
        return false;
    }
	
	bool bFind = false;
	FSGHistoryFrameCache FrameCache;
	FindFrame_Liner(HittedTime, bFind, FrameCache);
	if (bFind == false)
	{
		return false;
	}

	// 获取原先的位置并记录

	FVector OriginLocation = HittedBox->GetComponentLocation();
	FRotator OriginRotation = HittedBox->GetComponentRotation();
	
	// 将碰撞体移动到被击中的位置
	HittedBox->SetWorldLocation(FrameCache.BoxLocation);
	HittedBox->SetWorldRotation(FrameCache.BoxRotation);
	HittedBox->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
	
	// 专门用来进行回滚检测的碰撞预设
	FHitResult HitResult;
	bool bHit = GetWorld()->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_GameTraceChannel1);

	// 关闭碰撞并且恢复原先的位置
	HittedBox->SetCollisionEnabled(ECollisionEnabled::NoCollision);
	HittedBox->SetWorldLocation(OriginLocation);
	HittedBox->SetWorldRotation(OriginRotation);

    // 在调试模式下绘制检测过程
#if WITH_EDITOR
    if (bDebug == true && !OwnerCharacter->HasAuthority())
    {
    // 绘制射线
    DrawDebugLine(GetWorld(), StartLocation, EndLocation, 
                    bHit ? FColor::Green : FColor::Green, false, 5.0f);

    // 绘制碰撞体在回滚时刻的位置
    DrawDebugBox(GetWorld(), FrameCache.BoxLocation,
                    HitBox->GetScaledBoxExtent(),
                    FQuat(FrameCache.BoxRotation), 
                    bHit ? FColor::Green : FColor::Red, false, 5.0f);
    }
#endif

	return bHit;
}

void USGLagComponent::TrySaveFrame()
{
    if(!OwnerCharacter.IsValid())
    {
        OwnerCharacter = Cast<ASGCharacter>(GetOwner());
        return;
    }

	int32 CurrentFrameSize = HistoryFrameCache.Num();
    // 计算要保存的帧索引
	int32 SavedFrameIndex = (CurrentTickNum + 1) % ValidTickNum;
	// 如果当前数量小于最大数量则直接添加
	if (CurrentFrameSize < ValidTickNum)
	{
		FSGHistoryFrameCache CurrentFrameCache;
		FSGHistoryFrameCache::CreateHistoryFrame(OwnerCharacter.Get(), CurrentFrameCache);
		HistoryFrameCache.Add(CurrentFrameCache);
	}
	else
	{
		// 否则循环更新
		FSGHistoryFrameCache::CreateHistoryFrame(OwnerCharacter.Get(), HistoryFrameCache[SavedFrameIndex]);
	}
	CurrentTickNum = SavedFrameIndex;

    // 调试功能
#if WITH_EDITOR
    if(bDebug == true && !OwnerCharacter->HasAuthority())
    {
        // 将调试Box绘制出来
        DrawDebugBox(GetWorld(), HistoryFrameCache[CurrentTickNum].BoxLocation,
		             OwnerCharacter->GetHitBoxComponent()->GetScaledBoxExtent(),
		             FQuat(HistoryFrameCache[CurrentTickNum].BoxRotation), FColor::Red, false, ValidTickNum * GetWorld()->GetDeltaSeconds());
    }
#endif
}

void USGLagComponent::FindFrame_Liner(float TargetTime, bool& bFind, FSGHistoryFrameCache& FrameCache)
{
bFind = false;
	
	// 获取有效帧的数量和范围
	int32 TotalValidFrames = HistoryFrameCache.Num();
	int32 StartIndex = 0;
	int32 EndIndex = TotalValidFrames - 1;

	// 如果已满，调整起始和结束索引
	if (TotalValidFrames >= ValidTickNum)
	{
		StartIndex = (CurrentTickNum + 1) % ValidTickNum;
		EndIndex = CurrentTickNum;
	}
	
	// 检查目标时间是否在有效范围内
	float FirstTime = HistoryFrameCache[StartIndex].Time;
	float LastTime = HistoryFrameCache[EndIndex].Time;

	if (TargetTime < FirstTime || LastTime < TargetTime)
	{
		bFind = false;
		return;
	}

	// 查找目标时间所在的时间段
	int32 PreIndex = -1;
	int32 NextIndex = -1;

	// 遍历查找合适的时间段
	for (int32 i = 0; i < TotalValidFrames; i++)
	{
		int32 CurrentIndex = (StartIndex + i) % ValidTickNum;
		float CurrentTime = HistoryFrameCache[CurrentIndex].Time;
        
		if (CurrentTime <= TargetTime)
		{
			PreIndex = CurrentIndex;
		}
		else
		{
			NextIndex = CurrentIndex;
			break;
		}
	}

	// 如果Pre没更新过，则说明是第一帧
	if (PreIndex == -1)
	{
		FrameCache = HistoryFrameCache[StartIndex];
		bFind = true;
		return;
	}

	// 如果Next没更新过，则说明是最后一帧
	if (NextIndex == -1)
	{
		FrameCache = HistoryFrameCache[EndIndex];
		bFind = true;
		return;
	}

	float PreTime = HistoryFrameCache[PreIndex].Time;
	float NextTime = HistoryFrameCache[NextIndex].Time;

	if (FMath::IsNearlyEqual(PreTime, NextTime))
	{
        bFind = false;
		return;
	}
	
	// 长度大于2，进行插值
	FVector PreLocation = HistoryFrameCache[PreIndex].BoxLocation;
	FVector NextLocation = HistoryFrameCache[NextIndex].BoxLocation;
	FRotator PreRotation = HistoryFrameCache[PreIndex].BoxRotation;
	FRotator NextRotation = HistoryFrameCache[NextIndex].BoxRotation;
	
	// 进行线性插值
	float Distance = NextTime - PreTime;
	float InterpSpeed = (TargetTime - PreTime) / Distance;
	FrameCache.BoxLocation = FMath::VInterpTo(PreLocation, NextLocation, 1.0f, InterpSpeed);
	FrameCache.BoxRotation = FMath::RInterpTo(PreRotation, NextRotation, 1.0f, InterpSpeed);
	bFind = true;
}

总结

工作流程

以下mermaid展示了整个服务器倒带的工作流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
graph LR
    A[客户端开始射击] --> B[本地碰撞检测]
    B --> C[检测到命中]
    C --> D[上报服务器<br>包含命中时间]
    
    E[服务器接收命中请求] --> F[获取目标玩家LagComponent]
    F --> G[调用CheckHit函数]
    G --> H[FindFrame_Liner查找历史帧]
    H --> I{是否找到合适帧?}
    I -->|是| J[回滚碰撞体位置]
    I -->|否| K[返回命中失败]
    J --> L[执行碰撞检测]
    L --> M[恢复碰撞体位置]
    M --> N[返回检测结果]
    
    O[服务器Tick更新] --> P[TrySaveFrame保存帧]
    P --> Q{缓存是否已满?}
    Q -->|否| R[添加新帧]
    Q -->|是| S[循环覆盖旧帧]
    R --> T[更新CurrentTickNum]
    S --> T
    
    U[时间校准流程] --> V[客户端请求校准]
    V --> W[服务器响应时间]
    W --> X[客户端计算DeltaTimeInCS]
    
    subgraph 数据存储
        Y[HistoryFrameCache<br>历史帧缓存]
        Z[CurrentTickNum<br>当前帧索引]
    end
    
    H --> Y
    P --> Y
    T --> Z

mermaid网站链接：https://mermaid-live.nodejs.cn/edit#pako:eNptlOtOGkEUx1-FzGc0IEKVNDYV661oVahWB9OsMApRdsm629SiidrWO2iLt1ZrxXprrYiNiimiL8PM4lt0mFm7mDgfNjtzfufMOf85M1HglwIIOMGALESCJneHTzTR8RTi1A6ZyWhHJ_hqHB_M4_QHPJ3tNZWV1ZhqIdn8jTfT2k6afN4iP8bJ-Xwv96tlgAvyRTyTxp9y-ctj3epi1jqYv5wjc3tkM4bnkvjL4eM-uQYvfMRLR5wmaxe3a2e6D_8-g_9pEt8jyxecLJxkyOkkz6oeFuIZvLiqbaTI9rQW_4lTF25hwCWFI5KIREWPV8_gBlhIv9eWD11B5B9sDCl4OkdW0jrSwJBGWB8SA_WyEEav3SERyeT7Hpm9xvEpvPgHXx7ocCODm6Jk_QQv7RcBWvTSzO34JGWejHGoqQiNUmTU1AzxxhbJfuXi5XOJfC6m5VK9pSANNGp6Dgs3y5TlleLd08LZnk41sz3dkMweFJILDxyDmwEtkEzs4N3Yw1u1MKZV34W7a9kE2dq8p_wLQ3lvyD9INs7Iapor3ga98ohHeIOYSPmbb_h43RCmjTHtUe0qQde5PDjzh2STd6q0G8V2QJLJ4rltGtuI0G6o5oH4-pcWPynsT2kbq2TtwKA62D5eyDNzqbJMD7uYaqsa1hEPR0rLegl5l5HtJJ6eIucT2uE8r6rTaH3eXhzRQ3UypssQBSdi-O_yvZbtYsyrkjippJZaq0NDiuANhVGT6PLc03hY7ePXj_YgiaWKMk4eclNxdMPG0LAiySNMZ5fgDyJ2Ze46kSvcazj0wPsyMDqXwLOxIn22g69WdBqJgdJEeDN3lx6gPvGySQ8wgzCSw0IoQJ-MaNHkA0oQhZEPOOlvAPUL6pDiAz5xjKKCqkieEdEPnIqsIjOQJXUgCJz9wtAwnamRgKCgupBAaw_fIRFB7JGk0ilwRsFb4CxzVNrK7RXWKpvtUaW1oqraDEaA02qrLrdbHBWOaovVYqmwVTnGzOAdC2Att9urLRaHjQ671Wqz28z0kSsmridDa0eyS1JFBTjtY_8AjNc7_w

调试与优化

如果要模拟高延迟的情况，可以选择在DefaultEngine.ini中添加:

1
2
[PacketSimulationSettings]
PktLag = 500

可修改PktLag这个值来改变测试的延迟

依然可优化的方案：

  1. 如果保存的历史帧非常长的话使用遍历会影响性能，可以使用二分查找来优化
  2. 在进行回滚检测时，可以使用更细致的检测方案

参考

https://zhuanlan.zhihu.com/p/690661788
https://zhuanlan.zhihu.com/p/1929071131677143054

展开全文 >>

消息系统(上)

前言

这是对上一篇消息系统的重置和补充，之前的消息系统在使用上并不灵活，使用起来过于死板，于是参考了Lyra的消息系统并对原有的项目进行改进。

在新的消息系统中，将使用充分使用C++模板函数和UScriptStruct的特性，使得消息统统能够支持更灵活的定义和数据传递。

项目使用UE版本为5.2。

消息系统概述

消息系统的一个重要特性就是可以降低代码的耦合度，使代码更加简洁。
在UE中，如果当一个对象需要向另一个对象想要对另一个对象的某些变化做出响应，一般而言可以使用使用虚幻的委托来实现这个功能，但美中不足的是我们依然需要先在两个对象间建立联系随后绑定一方的委托，这依然带来了代码耦合度的提升。所以为了进一步优化我们的代码，我们便可以使用消息系统，当一个对象需要对一些变化做出响应时，就只需要监听一条特定的消息，等待消息的发起者将消息广播给所有监听者即可，这样一来我们便不用关系消息的发起者是谁，只需要处理消息发送过来的数据即可。

为了实现上述描述的消息系统，我们需要实现以下功能：

  1. 提供消息的监听功能
  2. 消息的发起者能够将消息发送给所有监听者
  3. 消息系统能够将消息发起者发送的数据传递给所有监听者
  4. 在监听者不需要时能够及时对消息进行解绑

为了方便管理我们的消息，所以我们可以先创建一个消息子系统用于管理所有的消息，之后所有的功能都将在这个类里实现。

注册消息

注册消息的目的是能够监听消息的变化并处理一些数据，所以我们需要一个注册的消息通道和一个接收到的数据类型，在UE中，我们使用FGameplayTag来作为消息通道，使用UStruct来作为绑定的数据类型。

因为我们可以知道这个监听者的回调函数应该长这样：

1
2
3
4
void Callback(FGameplayTag Channel, const FSomeStruct& SomeStruct)
{
    //...
}

为了能匹配通道类型和数据类型，我们将这个回调函数作为观察者注册进消息系统，当进行广播时由消息系统来调用这个回调函数。
这样我们的注册函数的样子大致如下：

1
void Register(FGameplayTag Channel, class SomeClass* Owner, void(SomeClass::*Callback)(FGameplayTag, const FSomeStruct&));

为了能够对类型进行匹配，我们将其改为模板函数，并在这个函数中对传进来的参数进行一些处理，在这一步对消息数据的类型进行解析同时将回调函数进行注册：

1
2
3
// 这个的Owner不一定会是UObject类型，只是UE中大多数的类都是使用UObject的，所以这里使用UObject作为默认类型
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*Callback)(FGameplayTag, const FMessageStructType&));

对回调函数进行注册

先看代码：

1
2
3
4
5
6
7
8
9
10
11
12
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*Callback)(FGameplayTag, const FMessageStructType&))
{
    TWeakObjectPtr<Owner> WeakOwner(Owner);
    auto ReceivedCallback = [WeakOwner, Callback](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
    {
        if(WeakOwner.Get())
        {
            (WeakOwner.Get()->*Callback)(Channel_, MessagePayload);
        }
    };
}

这一步我们先创建了一个Owner的弱引用并在lambda表达式中捕获，并且在函数体中执行Owner的回调函数，在这一步需要确保回调函数的参数和数据类型能够匹配。

对数据的类型进行解析

这一步我们需要对回调函数进一步封装，使之能够获取正确的数据类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*CallbackFunction)(FGameplayTag, const FMessageStructType&))
{
    TWeakObjectPtr<Owner> WeakOwner(Owner);
    auto ReceivedCallback = [WeakOwner, CallbackFunction](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
    {
        if(WeakOwner.Get())
        {
            (WeakOwner.Get()->*Callback)(Channel_, MessagePayload);
        }
    };

    auto Thunk = [Callback = MoveTemp(ReceivedCallback)](FGameplayTag Channel_, const void* MessagePayloadData)
    {
        // 先将数据进行一次类型转换随后解引用，便能得到我们想要的类型
        Callback(Channel_, *reinterpret_cast<const FMessageStructType*>(MessagePayloadData));	
    };
}

在这一步我们定义了一个Thunk函数，这个函数的主要作用是将发送过来的数据转化为与回调函数类型匹配的数据

在这一步完成后我们便完成了对注册内容的初步解析，随后我们需要将解析的内容保存在消息系统中，所以我们使用一个结构体来对消息进行保存：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
USTRUCT()
struct FGameplayMessageListenerData
{
	GENERATED_BODY()
public:
	/** 回调函数 */
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)> ReceivedCallback;

	/** 消息的结构体类型 */
	TWeakObjectPtr<const UScriptStruct> StructType = nullptr;

	/** 是否是合法的消息结构体 */
	bool bValidStructType = false;
};

有了存储的结构以后还需要让消息系统持有这个结构体，已知一个通道可以存储多个监听，又有多个消息通道，所以选择使用TMap的key来存储所有的消息通道，用一个数组来存储所有该消息通道下的监听者。为了便于使用，需要将数组进行一层包装：

1
2
3
4
5
6
7
/**
 * Wrapper，主要保存消息通道监听者的列表
 */
struct FChannelListenerList
{
	TArray<FGameplayMessageListenerData> ListenerDatas;
};
1
2
3
4
5
6
7
8
UCLASS()
class PROJECT_API UGameplayMessageSubsystem:UGameInstanceSubsystem
{
    GENERATED_BODY()

protected:
    TMap<FGameplayTag, FChannelListenerList> Listeners;
}

随后我们将解析的内容保存进这个结构体并由消息系统持有：

1
2
3
4
5
6
7
8
9
10
11
12
13
void RegisterListener_Internal(FGameplayTag Channel, TFunction<void(FGameplayTag, const void*)>&& Callback, const UScriptStruct* StructType)
{
    // 查找改通道的监听者列表，没有者创建
	FChannelListenerList& List = Listeners.FindOrAdd(Channel);

	// 在数组尾部创建一个默认的对象并获取
	FGameplayMessageListenerData& Data = List.ListenerDatas.AddDefaulted_GetRef();

	// 设置数据
	Data.ReceivedCallback = MoveTemp(Callback);
	Data.StructType = StructType;
	Data.bValidStructType = StructType != nullptr;
}

直到这一步我们便完成了消息的注册功能，接下来将消息进行广播。

广播消息

这一步就比较简单，广播消息时只需要设置消息的通道和发送的数据即可，在消息系统内部会对数据进行处理，对外提供如下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
template<typename FMessageStructType>
void BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload)
{
    // 获取消息的结构体类型
	const UScriptStruct* StructType = FMessageStructType::StaticStruct();
	// 调用消息广播
	BroadcastMessage_Internal(Channel, StructType, &MessagePayload);
}

void BoradcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType, const void* MessagePayloadData)
{
    // 先查找该通道的所有消息
	if (const FChannelListenerList* List = Listeners.Find(Channel))
	{
		// 安全处理，防止在调用时某一个消息被解绑（移除）
		TArray<FGameplayMessageListenerData> CopyedData(List->ListenerDatas);
		for (const FGameplayMessageListenerData& ListenerData:CopyedData)
		{
			// 判断数据类型不合法或类型不匹配则进行解绑
			if (ListenerData.bValidStructType == false || !StructType->IsChildOf(ListenerData.StructType.Get()))
			{
				// 不合法则对该消息进行解绑
				UE_LOG(LogGameplayMessage, Warning, TEXT("消息的结构体类型不匹配"))
				continue;
			}
			
			// 调用回调函数
			ListenerData.ReceivedCallback(Channel, StructType, MessagePayload);
		}
	}
}

从消息的注册到广播可以发现对回调的处理是由内及外和由外及内的，在注册时，我们对回调函数进行封装处理使之变成广播时易于调用的类型，在广播时又逐层解析调用真正的回调函数。这一切都发生在Thunk函数中，这个函数便是消息系统能够支持任意类型数据结构的基石之一。

对消息的解绑

当一个对象不在需要监听消息时便需要对消息进行解绑。

当下的问题时，我们只在消息注册时保存了这份消息，而注册者却什么都不知道，所以在注册成功后我们需要返回一个句柄，当注册者不再需要监听时便通过这个句柄来解除绑定，所以我们需要一个句柄结构体同时对现有的一些结构体进行一些小小的修改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
USTRUCT(BlueprintType)
struct FGameplayMessageHandle
{
	GENERATED_BODY()

	friend UGameplayMessageSubsystem;
public:
	FGameplayMessageHandle(){}

	FGameplayMessageHandle(UGameplayMessageSubsystem* InSubsystem, FGameplayTag InChannel, uint64 InHandleID):
	GameplayMessageSubsystem(InSubsystem), Channel(InChannel), HandleId(InHandleID){}

	bool IsValid() const { return HandleId != 0; }

	// 解绑方法，主要用于提供蓝图支持
	void Unregister();
protected:
	/** 持有的消息系统，蓝图支持 */
	UPROPERTY(Transient)
	TWeakObjectPtr<UGameplayMessageSubsystem> GameplayMessageSubsystem;

	/** 消息通道 */
	UPROPERTY(Transient)
	FGameplayTag Channel;
	
	/** 唯一的表示id */
	uint64 HandleId;
};

// 对FGameplayMessageListenerData进行修改，同样增加一个handleid
USTRUCT(BlueprintType)
struct FGameplayMessageListenerData
{
    //...

    // 新增的字段
    uint64 HandleId;
};

UCLASS()
class PROJECT_API UGameplayMessageSubsystem:UGameInstanceSubsystem
{
    //...
protected:
    // 新增的字段
    uint64 HandleCounter = 0;
};

// 修改Register方法，返回一个结构体即可，具体代码会在最后提供

在Handle和Data这两个结构体中都包含一个HandleId，这个id由消息系统分配并由Handle和Data各自持有一份，在解绑时通过对比HandleId来确认是否为同一个注册的消息。

我们对外提供解绑方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void Unregister(FGameplayMessageHandle& Handle)
{
    // 检查句柄的合法性
    if (!Handle.IsValid())
	{
		return;
	}

    // 找到消息通道的监听者列表
	if (FChannelListenerList* List = Listeners.Find(Handle.Channel))
	{
		// 找到下标
		int32 Index = List->ListenerDatas.IndexOfByPredicate([&Handle](const FGameplayMessageListenerData& CheckedData){ return CheckedData.HandleId == Handle.HandleId; });
		// 根据下标移除，在之前我们在广播时对数组进行拷贝避免了线程安全问题
		if (Index != -1)
		{
			List->ListenerDatas.RemoveAtSwap(Index);
		}

		// 如果该通道没有使用者则清除该通道
		if (List->ListenerDatas.IsEmpty() == true)
		{
			Listeners.Remove(Handle.Channel);
		}
	}
}

在Handle中我们同样提供了解绑的方法，该方法对消息系统提供的解绑方法进行了一次封装，这样在解绑时我们可以直接调用这个Handle中的Unregister方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void Unregister()
{
    if(HandleId == 0)
    {
        return;
    }

  	if (UGameplayMessageSubsystem* MessageSubsystem = GameplayMessageSubsystem.Get())
	{
		MessageSubsystem->Unregister(*this);
		GameplayMessageSubsystem.Reset();
		Channel = FGameplayTag::EmptyTag;
		HandleId = 0;
	}
}

至此我们便完成了消息系统的三个基本功能，接下来我们可以在一个类中进行测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
USTRUCT(BlueprintType)
struct FTestMessageStruct
{
    GENERATED_BODY()
public:
    UPROPERTY(BlueprintReadOnly)
    int32 TestData;
}

// 声明一个Tag，在头文件中
UE_DECLARE_GAMEPLAY_TAG_EXTERN(PlayerTestTag);

// 在头文件中定义这个Tag
UE_DEFINE_GAMEPLAY_TAG_COMMENT(PlayerTestTag, "PlayerTestTag.Tag", "this is a test tag");

UCLASS()
class PROJECT_API ATestPlayer:public ACharacter
{
    //...

    FGameplayMessageHandle TestHandle;

    UFUNCTION(BlueprintCallable)
    void TestRegister()
    {
        // 获取消息系统
        if(UWorld* World = this->GetWorld())
        {
            if(UGameplayMessageSubsystem* MessageSubsystem = UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance()))
            {
                TestHandle = MessageSubsystem->Register(PlayerTestTag, this, &ATestPlayer::TestMessageCallback);
            }
        }
    }

    UFUNCTION(BlueprintCallable)
    void TestUnregister()
    {
        TestHandle.Unregister();
    }

    UFUNCTION(BlueprintCallable)
    void TestBroadcast()
    {
        // 获取消息系统
        if(UWorld* World = this->GetWorld())
        {
            if(UGameplayMessageSubsystem* MessageSubsystem = UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance()))
            {
                FTestMessageStruct TestMessage;
                TestMessage.TestData = 114514;
                MessageSubsystem->Broadcast(PlayerTestTag, TestMessage);
            }
        }
    }
}

我们在蓝图中分别调用这几个函数进行测试，可以看到消息正常发送和接受。

总结

这里我们实现了在C++中使用消息系统，但UE并不只有C++，消息系统需要同样支持蓝图调用才算完整，后面我们会对消息系统进行蓝图支持。

暂时完整的代码

代码中对获取方法提供了封装，使之更易于调用。
此外我们还可以使用宏对注册和广播进行封装，使之更加简洁易用，不过这里并未提供。
提供的代码与上文中的代码略有不同，主要在于参数传递时有一个UScriptStruct*类型的参数，这个是用于提供蓝图支持的，暂时可以忽略。

头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameplayTagContainer.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "GameplayMessageSubsystem.generated.h"

class UAsyncAction_ListenForGameplayMessage;
class UGameplayMessageSubsystem;

/*
 * 创建消息监听时返回的句柄
 */
USTRUCT(BlueprintType)
struct FGameplayMessageHandle
{
	GENERATED_BODY()

	friend UGameplayMessageSubsystem;
public:
	FGameplayMessageHandle(){}

	FGameplayMessageHandle(UGameplayMessageSubsystem* InSubsystem, FGameplayTag InChannel, uint64 InHandleID):
	GameplayMessageSubsystem(InSubsystem), Channel(InChannel), HandleId(InHandleID){}

	bool IsValid() const { return HandleId != 0; }

	// 解绑方法，主要用于提供蓝图支持
	void Unregister();
protected:
	/** 持有的消息系统，蓝图支持 */
	UPROPERTY(Transient)
	TWeakObjectPtr<UGameplayMessageSubsystem> GameplayMessageSubsystem;

	/** 消息通道 */
	UPROPERTY(Transient)
	FGameplayTag Channel;
	
	/** 唯一的表示id */
	uint64 HandleId;
};

/**
 * 保存消息监听者持有的数据
 */
USTRUCT()
struct FGameplayMessageListenerData
{
	GENERATED_BODY()
public:
	/** 回调函数 */
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)> ReceivedCallback;

	/** 消息的结构体类型 */
	TWeakObjectPtr<const UScriptStruct> StructType = nullptr;

	/** 是否是合法的消息结构体 */
	bool bValidStructType = false;

	/** 唯一的表示id，由Handle和Data各自保存一份用于查找 */
	uint64 HandleId;
};

/**
 * Wrapper，主要保存消息通道监听者的列表
 */
struct FChannelListenerList
{
	TArray<FGameplayMessageListenerData> ListenerDatas;
};

DECLARE_LOG_CATEGORY_EXTERN(LogGameplayMessage, Log, All);

UCLASS()
class PROJECT_CTF_API UGameplayMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	// 提供蓝图支持
	friend UAsyncAction_ListenForGameplayMessage;
public:
	virtual bool ShouldCreateSubsystem(UObject* Outer) const override;

	virtual void Initialize(FSubsystemCollectionBase& Collection) override;

	virtual void Deinitialize() override;

	static UGameplayMessageSubsystem* Get(const UObject* WorldContext);
	
	/// 对外提供的注册方法
	/// @tparam FMessageStructType 消息的数据类型
	/// @tparam Owner 消息的注册者
	/// @param Channel 消息的通道
	/// @param OwnerObject 注册者
	/// @param CallbackFunction 接收到消息的回调
	/// @return 监听的handle
	template<typename FMessageStructType, typename Owner = UObject>
	FGameplayMessageHandle RegisterListener(FGameplayTag Channel, Owner* OwnerObject, void(Owner::*CallbackFunction)(FGameplayTag, const FMessageStructType&));

	/// 清理绑定
	/// @param Handle 创建监听时返回的唯一句柄
	void Unregister(FGameplayMessageHandle& Handle);

	/// 广播一条消息
	/// @tparam FMessageStructType 消息结构体类型
	/// @param Channel 消息通道
	/// @param MessagePayload 消息数据
	template<typename FMessageStructType>
	void BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload);
protected:
	/// 实际完成注册的函数
	/// @param Channel 消息通道
	/// @param Callback 回调函数
	/// @param StructType 消息数据类型
	/// @return 监听的handle
	FGameplayMessageHandle RegisterListener_Internal(FGameplayTag Channel, TFunction<void(FGameplayTag, const UScriptStruct*, const void*)>&& Callback, const UScriptStruct* StructType);

	/// 广播消息的内部实现，便于蓝图支持
	/// @param Channel 消息通道
	/// @param StructType 具体的消息类型
	/// @param MessagePayload 消息数据
	void BroadcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType, const void* MessagePayload);
	
	/** 持有所有 通道-监听者 */
	TMap<FGameplayTag, FChannelListenerList> Listeners;

	/** 标识Handle计数器，用于分配唯一id */
	uint64 HandleCounter = 0;
};

template <typename FMessageStructType, typename Owner>
FGameplayMessageHandle UGameplayMessageSubsystem::RegisterListener(FGameplayTag Channel, Owner* OwnerObject,
	void(Owner::* CallbackFunction)(FGameplayTag, const FMessageStructType&))
{
	TWeakObjectPtr<Owner> WeakOwner(OwnerObject);
	auto ReceivedCallback = [WeakOwner, CallbackFunction](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
	{
		// 检查注册者是否有效
		if (WeakOwner.Get())
		{
			(WeakOwner.Get()->*CallbackFunction)(Channel_, MessagePayload);
		}
	};

	/**
	 * 转换函数，将消息的发起者传入的参数转为符合条件类型并回调
	 * 其中StructType用于提供蓝图支持，便于在蓝图中使用监听回调
	 */
	auto ThunkCallback = [Callback = MoveTemp(ReceivedCallback)](FGameplayTag Channel_, const UScriptStruct* MessageStructType, const void* MessagePayloadData)
	{
		Callback(Channel_, *reinterpret_cast<const FMessageStructType*>(MessagePayloadData));	
	};

	// 获取消息数据的类型
	const UScriptStruct* MessageStructType = FMessageStructType::StaticStruct();

	// 返回内部实现
	return RegisterListener_Internal(Channel, ThunkCallback, MessageStructType);
}

template <typename FMessageStructType>
void UGameplayMessageSubsystem::BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload)
{
	// 获取消息的结构体类型
	const UScriptStruct* StructType = FMessageStructType::StaticStruct();
	// 调用消息广播
	BroadcastMessage_Internal(Channel, StructType, &MessagePayload);
}

源文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// Fill out your copyright notice in the Description page of Project Settings.

#include "GameplayMessageSubsystem.h"

DEFINE_LOG_CATEGORY(LogGameplayMessage);

void FGameplayMessageHandle::Unregister()
{
	if (UGameplayMessageSubsystem* MessageSubsystem = GameplayMessageSubsystem.Get())
	{
		MessageSubsystem->Unregister(*this);
		GameplayMessageSubsystem.Reset();
		Channel = FGameplayTag::EmptyTag;
		HandleId = 0;
	}
}

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

void UGameplayMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Listeners.Reset();
	Super::Initialize(Collection);
}

void UGameplayMessageSubsystem::Deinitialize()
{
	Listeners.Reset();
	Super::Deinitialize();
}

UGameplayMessageSubsystem* UGameplayMessageSubsystem::Get(const UObject* WorldContext)
{
	if (IsValid(WorldContext);UWorld* World = WorldContext->GetWorld())
	{
		return UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance());
	}
	return nullptr;
}

FGameplayMessageHandle UGameplayMessageSubsystem::RegisterListener_Internal(
	FGameplayTag Channel,
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)>&& Callback,
	const UScriptStruct* StructType)
{
	// 查找改通道的监听者列表，没有者创建
	FChannelListenerList& List = Listeners.FindOrAdd(Channel);

	// 创建一个默认的对象并获取
	FGameplayMessageListenerData& Data = List.ListenerDatas.AddDefaulted_GetRef();

	// 设置数据
	Data.ReceivedCallback = MoveTemp(Callback);
	Data.StructType = StructType;
	Data.bValidStructType = StructType != nullptr;
	Data.HandleId = ++HandleCounter;
	
	// 创建handle并返回
	return FGameplayMessageHandle(this, Channel, Data.HandleId);
}

void UGameplayMessageSubsystem::Unregister(FGameplayMessageHandle& Handle)
{
	if (!Handle.IsValid())
	{
		return;
	}

	if (FChannelListenerList* List = Listeners.Find(Handle.Channel))
	{
		// 找到下标
		int32 Index = List->ListenerDatas.IndexOfByPredicate([&Handle](const FGameplayMessageListenerData& CheckedData){ return CheckedData.HandleId == Handle.HandleId; });
		// 根据下标移除
		if (Index != -1)
		{
			List->ListenerDatas.RemoveAtSwap(Index);
		}

		// 如果该通道没有使用者则清除该通道
		if (List->ListenerDatas.IsEmpty() == true)
		{
			Listeners.Remove(Handle.Channel);
		}
	}
}

void UGameplayMessageSubsystem::BroadcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType,
	const void* MessagePayload)
{
	// 先查找该通道的所有消息
	if (const FChannelListenerList* List = Listeners.Find(Channel))
	{
		// 安全处理，防止在调用时某一个消息被解绑（移除）
		TArray<FGameplayMessageListenerData> CopyedData(List->ListenerDatas);
		for (const FGameplayMessageListenerData& ListenerData:CopyedData)
		{
			// 判断数据类型不合法或类型不匹配则进行解绑
			if (ListenerData.bValidStructType == false || !StructType->IsChildOf(ListenerData.StructType.Get()))
			{
				// 不合法则对该消息进行解绑
				UE_LOG(LogGameplayMessage, Warning, TEXT("消息的结构体类型不匹配"))
				continue;
			}
			
			// 调用回调函数
			ListenerData.ReceivedCallback(Channel, StructType, MessagePayload);
		}
	}
}


展开全文 >>

UE消息系统（上）：无参消息广播

前言

消息系统允许对象之间进行通信而不需要知道对象的具体类型，只需要接受消息的对象完成注册即可接收从各个地方发送来的消息从而执行相关的逻辑。

与UE中的委托类似，但是使用委托在绑定时仍需要知道具体的对象，而消息则不需要，所以使用消息能更进一步完成解耦。

基本的实现方式

可以采取与委托类似的方式，不同的是可以将绑定的信息存储在一个容器中，当消息被发送时就从容器中查找相应的委托并执行逻辑。

定义最基本的结构体

首先在这个容器中存储了一个委托，其次需要一个唯一的标识符，所以相应的应该还有一个ID。

消息的最基本结构体定义完成后，还需要知道消息的具体类型，采用FGameplayTag作为消息类型的标识符。

定义委托：

1
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

所以消息结构体的基本构成为：

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageListenerHandle
{
public:
    FGameplayMessageListenerHandle()
    {

    }

    FMessageDelegate MessageDelegate;
    int64 HandleID;
    FGameplayTag Channel;
};

消息的存储容器

有了消息的基本结构体后，就需要一个容器来存放这些消息。之前定义了FGameplayTag作为消息类型，一个消息同时有一组接收者，因而采取map的形式维护消息类型与接收者之间的映射关系。

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageHandleWarpper
{
public:
    FGameplayMessageHandleWarpper()
    {

    }

    TArray<FGameplayMessageListenerHandle> Events;
};

TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

每个消息的唯一标识ID

使用一个静态成员变量作为标识ID，没当调用注册函数时就为其注册的Handle分配一个HandleID。

消息本身应提供的方法

同时消息本身应该具有合法性判断、解绑、委托执行的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct FGameplayMessageListenerHandle
{
public:
    bool IsValid() const { return HandleID > 0; }
    // 稍后实现
    void Unregister();
protected:
    void Broadcast()
    {
        if(HandleID > 0)
        {
            MessageDelegate.ExecuteIfBound();
        }
    }
};

消息系统的实现

消息系统在整个游戏中明显应该只存在一份，所以采用UE的子系统来实现，同时让消息结构体中持有一份该系统的弱引用：

1
2
3
4
5
6
7
8
9
class UMessageSubsystem:public UGameInstanceSubsystem
{
public:
    bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

    TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

    static TAtomic<int64> HandleID;
};

对于C++的实现

消息的注册

我们提供一个模板方法来完成对消息的注册，为了完成消息的注册，我们需要一些注册的基本信息：注册的消息类型、注册者以及注册的委托函数，所以需要三个基本参数：FGameplayTag、UserObject、Function。

最终提供一个静态方法完成注册：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
template<typename UserClass>
FGameplayMessageHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* UserObject, FName FunctionName)
{
    if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
                    // 为其分配ID
					MessageHandler.HandleID = ++MessageHanderAlloc;
					// 完成委托的绑定
                    MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					// 确定消息类型
                    MessageHandler.Channel = Channel;
                    // 让该消息持有消息系统
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

消息的执行

在消息执行时只需要传入一个消息类型即可完成消息的发送，同样将其定义为静态方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

消息的解绑

直接对对象持有的消息本身进行解绑，之前我们对消息结构体中定义了Unregister方法，现在只需要实现该方法即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void FGameplayMessageListenerHandle::Unregister()
{
    if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
                // 提供线程安全的移除方法
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	} 
}

对于蓝图实现

蓝图与C++实现最大的区别在于无法直接使用FGameplayMessageHandle这个结构体，在蓝图与C++的交互中，结构体会以值传递的方式传递，即使定义了以引用的方式传递，在蓝图中的结构体进入C++时仍然会拷贝出一个副本，此时无法保证操作的一致性；而类类型在蓝图与C++的交互中是以引用的方式传递，此时可以保证操作的一致性，所以需要对消息结构在做一层类封装。

1
2
3
4
5
6
7
8
9
class UGameplayMessageAction: public UObject
{
public:
    FGameplayMessageListenerHandle ListenerHandler;

    // 用于给蓝图提供注册消息的方法，这也是不选用结构体的另一个原因：蓝图无法调用结构体中的方法
	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

蓝图消息的注册

同样提供静态方法进行注册，不同的是这次不传入函数名而是直接传入一个事件引脚，当发送消息时直接通过蓝图事件来执行，此时便不再需要传入UserObject：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
UFUNCTION(BlueprintCallable, Category = "Message")
UGameplayMessageAction* K2_RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

蓝图消息的执行与C++消息的执行方式相同，直接调用BroadcastMessage即可。

蓝图消息的解绑

在注册消息时我们使用一个MessageAction接收返回值，并使用它的完成消息解绑：

1
2
3
4
void UGameplayMessageAction::Unregister()
{
    ListenerHandler.Unregister();
}

完整的代码

头文件部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

USTRUCT(BlueprintType)
struct FGameplayMessageListenerHandle
{
public:
	friend UMessageSubsystem;

	FGameplayMessageListenerHandle():HandleID(-1)
	{

	}

	FGameplayMessageListenerHandle(UMessageSubsystem* _Subsystem, FGameplayTag _Channel, int64 _HandleID) :Subsystem(_Subsystem), Channel(_Channel), HandleID(_HandleID)
	{

	}

	void Unregister();
	bool IsValid() { return HandleID > 0; }

	FMessageDelegate MessageDelegate;
	TWeakObjectPtr<UMessageSubsystem> Subsystem;
	FGameplayTag Channel;
	int64 HandleID; 
protected:
	void Boardcast();
};

USTRUCT()
struct FMessageHandleWarpper
{
public:
    // 用于结束游戏时清理消息
	void Clear()
	{
		for (FGameplayMessageListenerHandle& Handler : Events)
		{
			Handler.Unregister();
		}
	}

	TArray<FGameplayMessageListenerHandle> Events;
};

UCLASS(BlueprintType)
class UGameplayMessageAction :public UObject
{
public:
	FGameplayMessageListenerHandle ListenerHandler;

	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

/**
 * 
 */
UCLASS()
class UMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	
public:
	bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

	virtual void Initialize(FSubsystemCollectionBase& Collection);

	virtual void Deinitialize();

	template<class UserClass>
	static FGameplayMessageListenerHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static UGameplayMessageAction* K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel);

	static TAtomic<int64> MessageHanderAlloc;

	UPROPERTY()
	TMap<FGameplayTag, FMessageHandleWarpper> Messages;
};

template<class UserClass>
inline FGameplayMessageListenerHandle UMessageSubsystem::RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
					MessageHandler.HandleID = ++MessageHanderAlloc;
					MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					MessageHandler.Channel = Channel;
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

源文件部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

TAtomic<int64> UMessageSubsystem::MessageHanderAlloc = -1;

void UMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);
	MessageHanderAlloc = 0;
}

void UMessageSubsystem::Deinitialize()
{
	for (auto& Pair : Messages)
	{
		Pair.Value.Clear();
	}

	Messages.Empty();
	MessageHanderAlloc = -1;
}

UGameplayMessageAction* UMessageSubsystem::K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

void UMessageSubsystem::BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Unregister()
{
	if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Boardcast()
{
	if (HandleID > 0)
	{
		MessageDelegate.ExecuteIfBound();
	}
}

void UGameplayMessageAction::Unregister()
{
	ListenerHandler.Unregister();
}

测试

使用默认的主角类进行测试，在C++中提供以下函数并绑定一些按键进行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
   FGameplayMessageListenerHandle TestListenerHandler;

UFUNCTION(BlueprintCallable)
void TestAddListener()
   {
       TestListenerHandler = UETMessageSubsystem::RegisterGameplayMessageListener<AMainCharacter>(this, YourTestTag, this, "TestMessageFunc");
   }

UFUNCTION(BlueprintCallable)
void TestBroadcastListener()
   {      
    UETMessageSubsystem::BroadcastMessage(this, YourTestTag);
   }

UFUNCTION(BlueprintCallable)
void TestUnregisterListener()
   {
       TestListenerHandler.Unregister();
   }

UFUNCTION()
void TestMessageFunc()
   {
   	UE_LOG(LogTemp,Warning,TEXT("TestMessageFunc"));    
   }

在蓝图中则直接可以搜索K2_RegisterGameplayMessageListerner和BroadcastMessage进行绑定和广播，直接调用Action的Unregister()函数即可取消监听。

后续

后续会增加消息的参数传递功能，使其能够携带任意数量的参数进行传递。

展开全文 >>

增强输入与GAS

前言

前文介绍了GAS与增强输入的基本使用，本文将介绍如何将输入与GA进行绑定来完成解耦和扩展。

前置准备

绑定方法

技能与输入的绑定方法，查看BindAction的函数声明，可以看到在后面有一次额外的参数包，在绑定时可以将Tag做为参数在绑定时传入：

1
BindAction(IA, TriggerEvent, UserObject, BindFunc, Tag);

在触发影响的IA时就可以获取到对应的Tag:

1
2
3
4
void BindFunc(FGameplayTag Tag)
{
    //...
}

在初始化时可以通过将Tag和GA进行绑定，在触发输入时通过Tag来查找对应的GA。

技能的初始化

初始化时需要将GA和Tag进行绑定，所以考虑将对应关系放入一张数据表中，在玩家进行初始化时读入这张表完成绑定。

其基本的数据结构应包含一个GA和一个TagContainer，一个技能可能会有几种触发方式，所以提供Container来存储多个Tag。

1
2
3
4
5
6
7
8
9
10
11
12
USTRUCT(BlueprintType)
struct FAbilityAction
{
    GENERATED_BODY()

    // 使用Ability的CDO进行初始化
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSubclassOf<FGameplayAbility> Ability;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    FGameplayTagContainer Tags;
};

同时提供基本的表结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
UCLASS()
class PROJECTE_API UAbilityAsset : public UDataAsset
{
    GENERATED_BODY()

public:
    UAbilityAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TArray<FAbilityAction> Abilities;
};

输入的初始化

同样使用数据表来存储输入关系，基本应该包含一个Tag和一个IA，其中Tag用于查找对应的GA。

所以输入的基本数据结构为：

1
2
3
4
5
6
7
8
9
10
11
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;
};

输入的表结构，其中提供查找方法和一个映射上下文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
UCLASS()
class PROJECTE_API UInputAsset : public UDataAsset
{
    GENERATED_BODY()
public:
    UInputAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    const UInputAction* FindInputActionByTag(FGameplayTag Tag) const
    {
        UInputAction* InputAction = nullptr;
        if(Tag.IsValid())
        {
            for(const FInputAction& IA: Actions)
            {
                if(IA.Action.Get() && IA.Tag == Tag)
                {
                    InputAction = IA.Action;
                    break;
                }
            }
        }

        return InputAction;
    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TArray<FInputAction> Actions;

    UPROPERTY(EdtiAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputMappingContext> InputMappingContext;
};

实现输入与GA的绑定

准备好两张表后就可以准备完成初始化与绑定了！

GA的初始化

在GameplayAbility的实例GameplayAbilitySpec中包含一个DynamicAbilityTag的TagContainer，使用其来查找对应的GA。

绑定函数：

1
2
3
4
5
6
7
8
9
10
void InitializeAbility()
{
    // 假设已经读取到了UAbilityAsset--->AbilityAsset
    for(FAbilityAction& GameplayAbilityAction: AbilityAsset->Abilities)
    {
        FGameplayAbilitySpec GameplayAbilitySpec = FGameplayAbilitySpec(GameplayAbilityAction.Ability);
        GameplayAbilitySpec.DynamicAbilityTags = GameplayAbilityAction.Tags;
        GiveAbility(GameplayAbilitySpec);
    }
}

输入的初始化

在绑定中，将输入分为两种，一种为GA输入；另一种为本地输入，包括玩家的基本移动等，所以在绑定时要对其进行区分，所以输入表中需要对结构进行改进，增加一个用于区分是否为技能的bool值；此外技能同样有长按与单次触发的类型，所以再增加一个bool值进行区分。

改进后的结构应为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bAbilityInput;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bTriggerEvent;
};

为了确保绑定可以通用，考虑将其作为增强输入组件的模板成员函数。对于本地输入的初始化只要从输入表中拿到对应的IA完成绑定即可；对于技能输入则需要增加一个扩展参数包。

所以玩家的本地输入绑定函数应为：

1
2
3
4
5
6
7
8
9
template<class UserClass, typename FuncType>
void BindNativeAction(const UInputAsset* InputAsset, const FGameplayTag& InputTag, ETriggerEvent TriggerEvent, UserClass* UserObject, FuncType InputFunc)
{
    check(InputAsset);
    if(const UInputAction* IA = InputAsset->FindInputActionByTag(InputTag))
    {
        BindAction(IA, TriggerEvent, UserObject, InputFunc);
    }
}

绑定技能的输入为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
template<class UserClass, typename Press, typename Release>
void BindAbilityAction(const UInputAsset* InputAsset, UserClass* UserObject, Press PressFunc, Relase ReleaseFunc, TArray<uint32>& BindHandles)
{
    check(InputAsset);
    for(const FInputAction& IA: InputAsset->Actions)
    {
        if(IA.Action.Get() && IA.bAbilityInput)
        {
            if(PressFunc)
            {
                if(IA.bTriggerEvent)
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Triggered, PressFunc, PressFunc, IA.Tag).GetHandle());
                }
                else
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Started, PressFunc, ReleaseFunc, IA.Tag).GetHandle());
                }
            }
            
            if(ReleaseFunc)
            {
                BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Completed, ReleaseFUnc, IA.Tag).GetHandle());
            }
        }
    }
}

触发IA与GA

对于玩家的本地输入，可以直接调用BindNativeAction进行绑定，有多少绑定多少，对于GA的绑定则只需要一次。

当IA触发以后则需要根据对应的Tag去寻找对应的GA，提供两个函数用来处理技能输入的按下与抬起：

在GAS中的处理

首先在ASC中提供两个函数用来处理技能输入的按下与抬起：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void ProcessAbilityPressInput(FGameplayTag InputTag)
{
    if(FGameplayAbilitySpec& AbilitySpec:GetActivatableAbilities())
    {
        if(AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpec.Ability->ActivateAbility(AbilitySpec);
        }
    }
}

void ProcessAbilityReleaseInput(FGameplayTag InputTag)
{
    for (FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
    {
        if (AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpecInputRelease(AbilitySpec);
        }
    }
}

在输入组件中的处理

随后可以在玩家的输入组件中调用这两个函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void OnAbilityPressd(FGameplayTag InputTag)
{
    // 认为已经提供了相应的获取ASC的方法
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityPressInput(InputTag);
    }
}

void OnAbilityReleased(FGameplayTag InputTag)
{
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityReleaseInput(InputTag);
    }
}

最终绑定

最终在增强输入中提供初始化函数SetPlayerInput:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void SetPlayerInput()
{
    ACharacter* OwnerCharacter = Cast<ACharacter>(GetOwner());
    if(!IsValid(OwnerCharacter))
    {
        return;
    }

    if (APlayerController* LocalPC = Cast<APlayerController>(OwnerCharacter->Controller))
    {
        if (UEnhancedInputLocalPlayerSubsystem* LPSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(LocalPC->GetLocalPlayer()))
        {
            if (InputAsset->InputMappingContext.Get())
            {
                LPSubsystem->ClearAllMappings();
                LPSubsystem->AddMappingContext(InputAsset->InputMappingContext,0);
            }
        }

        //BindNativeAction完成本地输入绑定

        BindAbilityAction(InputAsset, this, &ThisClass::OnAbilityPressd, &ThisClass::OnAbilityReleased, AbilityInputHandles);
    }
}

最终完成了IA与GA的绑定

管理GameplayTag

参考lyra工程使用namespace作为Tag管理，同样我们也提供一个名为GameplayTags的namespace：

1
2
3
4
5
6
7
8
namespace GameplayTags
{
    // 在头文件中这样声明
	PROJECTET_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(CharacterInputTag_Move);

    // 在cpp文件中这样定义，可以编辑器中外部使用
	UE_DEFINE_GAMEPLAY_TAG_COMMENT(CharacterInputTag_Move, "CharacterInput.Move", "Character Movement Input Tag");
}

使用ini管理资产文件

以上是直接将资产挂载在玩家身上，并不方便管理，所以可以考虑使用全局配置项来进行管理。

用UDeveloperSettings作为父类创建名为ProjectAssetSettings的子类，注意需要在uproject文件中新加一条”DeveloperSettings”的配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
UCLASS(config = Game, defaultconfig, meta = (DisplayName = "Game Asset Config"))
class PROJECTET_API UProjectAssetSettings : public UDeveloperSettings
{
	GENERATED_BODY()
public:
	virtual FName GetCategoryName() const
    {
        return FName{ TEXT("Game Asset Config") };
    }

	virtual FName GetContainerName() const
    {
        return FName{ TEXT("Project") };
    }

    // 用于获取读取配置的方法，一般在游戏运行时不修改游戏配置，所以返回const
	UFUNCTION(BlueprintPure)
	static const UProjectAssetSettings* GetProjectAssetSettings()
    {
        const UProjectAssetSettings* Settings = GetDefault<UProjectAssetSettings>();
        return Settings;
    }

    //如果想要修改的话可以使用GetMutableDefault<UProjectAssetSettings>()来返回一个可修改的配置文件

    // 将输入资产与技能资产迁至这里，这里一般不会使用硬引用，ini文件加载时机很早，使用硬引用会导致读入的类为空
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TSoftObjectPtr<UInputAsset> InputAsset;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSoftObjectPtr<UAbilitAsset> AbilityAsset;
};

总结

通过以上步骤，我们将输入与技能进行了绑定，并且通过namespace管理Tag和ini文件管理了输入与技能的资产。

展开全文 >>

常用的排序算法

总结常用的排序算法

主要包括冒泡排序、堆排序、归并排序、快速排序四个。

冒泡排序

冒泡排序是一种很简单的原地排序算法，在每一轮遍历都将最大的元素（或者最小）放在数组的末尾
过程为：

  1. 比较相邻的元素，如果第一个比第二个大，就交换它们两个
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
  3. 针对所有的元素重复以上的步骤，除了最后一个
  4. 重复步骤1~3，直到排序完成
    平均时间复杂度：O(n^2)
1
2
3
4
5
6
7
8
9
10
11
void BubbleSort(vector<int>& nums)
{
    int n = nums.size();
    for(int i = 0; i < n ;i++){
        for(int j = 0; j < n - i - 1; j++){
            if(nums[j] > nums[j + 1]){
                swap(nums[j], nums[j + 1]);
            }
        }
    }
}

堆排序

堆排序是一种原地排序算法，依赖于堆实现
过程为：

  1. 将原数组调整为大顶堆（或小顶堆）
  2. 交换堆顶与数组末尾元素，再将剩余元素调整为大顶堆
  3. 不断重复步骤2直到数组有序
    每次调整堆的时间复杂度位O(logn)，一共需要调整n次，总时间复杂度位O(nlogn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
void Heapfiy(vector<int>& nums,int n,int i)
{
    int largest=i;
    int left=2*i+1;
    int right=2*i+2;
    while (true) {
        if (left < n && nums[left] > nums[largest]) {
            largest = left;
        }

        if (right < n && nums[right] > nums[largest]) {
            largest = right;
        }

        if (largest == i) {
            break;
        }

        swap(nums[i], nums[largest]);
        i = largest;
        left = 2 * i + 1;
        right = 2 * i + 2;
    }
}

void HeapSort(vector<int>& nums)
{
    int n=nums.size();
    // 构造大顶堆
    // 从最后一个非叶子节点开始
    for(int i=n/2-1;i>=0;i--){
        Heapfiy(nums,n,i);
    }

    // 交换堆顶元素并调整堆
    for(int i=n-1;i>=0;i--){
        swap(nums[0],nums[i]);
        Heapfiy(nums,i,0);
    }   
}

归并排序

归并依赖于递归操作
过程为：

  1. 将原数组分为左右两个子数组
  2. 将数组递归分为左右两个子数组
  3. 将左右两个子数组合并有有序数组
    评价时间复杂度为O(nlogn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
void Merge(vector<int>& nums,int left,int mid,int right)
{
    vector<int> temp(right-left+1);
    int i=left;
    int j=right;
    int k=0;
    while(i<=left && j<=right){
        // 将两个数组合并为一个有序数组
        if(nums[i]<=nums[j]){
            temp[k]=nums[i];
            i++;
        }else{
            temp[k]=nums[j];
            j++;
        }
        k++;
    }

    while(i<=left){
        temp[k++]=nums[i++];
    }

    while(j<=right){
        temp[k++]=nums[j++];
    }

    for(int t=0;t<k;t++){
        nums[left+t]=temp[t];
    }
}

void MergeSort(vector<int>& nums,int left,int right)
{
    if(left>=right){
        return;
    }
    int mid=left+(right-left)/2;
    MergeSort(nums,left,mid);
    MergeSort(nums,mid+1,right);
    Merge(nums,left,mid,right);
}

快速排序

快排是最常用的排序算法之一
过程为：

  1. 选择一个基准值（一般为第一个或最后一个），将原数组分为两个数组
  2. 比基准值小的元素放在基准值左边，比基准值大的元素放在右边
  3. 递归调用左右两个子数组，重复上述步骤
    平均时间复杂度为O(nlogn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int partition(vector<int>& nums,int left,int right)
{
    int base=nums[left];
    while(left<right){
        while(left<right && nums[right]>=base){
            right--;
        }
        nums[left]=nums[right];
        while(left<right && nums[left]<=base){
            left++;
        }
        nums[right]=nums[left];
    }
    nums[left]=base;
    return left;    
}


void QuickSort(vector<int>& nums,int left,int right)
{
    if(left<right){
        int pos=partition(nums,left,right);
        QuickSort(nums,left,pos-1);
        QuickSort(nums,pos+1,right);       
    }
}

展开全文 >>

C++多线程入门：完善线程池

上一章我们制作了一个简单的线程池，本次将使用智能指针来管理创建的对象：各种任务和创建的线程

使用shared_ptr来管理任务和线程

首先对线程池中进行修改：

  1. 将BaseTask*替换为std::shared_ptr< BaseTask >
  2. 将线程池中的std::thread*替换为std::shared_ptr< std::thread >
  3. 对AddTask的逻辑稍加修改

具体改动：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//void AddTask(BaseTask* Task);
void AddTask(std::shared_ptr<BaseTask> Task);

//BaseTask* GetTask();
std::shared_ptr<BaseTask> GetTask();

//std::vector<std::thread*> ThreadPool;
std::vector<std::shared_ptr<std::thread>> ThreadPool;

//std::list<BaseTask*> TaskList;
std::list<std::shared_ptr<BaseTask>> TaskList;

void Start()
{
    //...
    //auto th = new std::thread(&BaseThreadPool::Run,this);	
    auto th = std::make_shared<std::thread>(&BaseThreadPool::Run,this);
    //...
}

void Exit()
{
    //...
    //智能指针可以帮助我们自动释放资源，所以这里就不在需要我们手动释放
    //std::unique_lock<std::mutex> Lock(mtx);
	//for (auto& th : ThreadPool) {
	//	delete th;
	//	th=nullptr;
	//}
}

在其它地方因为我们使用了auto自动类型推导，所以并不需要有太大变化。

希望异步获取任务的运行结果

对BaseTask类做出修改，增加promise变量以及Set和Get函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <future>
class BaseTask
{
public:
    //...

    void SetValue(int val)
    {
        p.set_value(val);
    }

    auto GetValue()->int
    {
        return p.get_future().get();
    }

private:
    std::promise<int> p;
};

在main中进行测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
int main()
{
    BaseThreadPool pool;
	pool.Init(4);
	pool.Start();

	// 使用智能指针管理对象
	auto t = make_shared<TestTask>();
	t->name="Name01";
	pool.AddTask(t);
	auto t2 = make_shared<TestTask>();
	t2->name = "Name02";
	pool.AddTask(t2);
	auto t3 = make_shared<TestTask>();
	t3->name = "Name03";
	pool.AddTask(t3);
	auto t4 = make_shared<TestTask>();
	t4->name = "Name04";
	pool.AddTask(t4);
	std::this_thread::sleep_for(3000ms);
	cout << "Task1 ret = " << t.get()->GetValue() << endl;
	cout << "Task2 ret = " << t2.get()->GetValue() << endl;
	
	pool.Exit();

	cout << "Task3 ret = " << t3.get()->GetValue() << endl;
	cout << "Task4 ret = " << t4.get()->GetValue() << endl;
	auto t5 = make_shared<TestTask>();
	pool.AddTask(t2);
	getchar();
	return 0;
}

总结

至此就完成了一个功能相对完善的线程池并尽可能的减少了内存泄漏的问题。

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true


个人简介:
大学生一枚，想要从事游戏开发,
希望能做出自己的游戏

主要涉及技术：
UE4、Unity2D、C++