111. UE5 GAS RPG 实现角色技能和场景状态保存到存档

实现角色的技能存档保存和加载

首先，我们在LoadScreenSaveGame.h文件里，增加一个结构体，用于存储技能相关的所有信息

//存储技能的相关信息结构体
USTRUCT(BlueprintType)
struct FSavedAbility
{
	GENERATED_BODY()

	//需要存储的技能
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="ClassDefaults")
	TSubclassOf<UGameplayAbility> GameplayAbility;

	//当前技能的等级
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
	int32 AbilityLevel = 0;

	//当前技能的标签
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
	FGameplayTag AbilityTag = FGameplayTag();

	//当前技能的状态标签
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
	FGameplayTag AbilityStatus = FGameplayTag();

	//当前技能装配到的插槽，如果技能未装配则为空
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
	FGameplayTag AbilityInputTag = FGameplayTag();

	//当前技能的类型（主动技能还是被动技能）
	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
	FGameplayTag AbilityType = FGameplayTag();
};

然后重新设置==运算符的方法，如果我们在判断FSavedAbility是否相等时，会通过此函数运算返回布尔结果。

//自定义运算符==，如果左右都是FSavedAbility类型的值，将通过函数内的值判断是否相等。
inline bool operator==(const FSavedAbility& Left, const FSavedAbility& Right)
{
	return Left.AbilityTag.MatchesTagExact(Right.AbilityTag);
}

然后我们在SaveGame类里添加一个属性，用于保存所有技能属性。

	/************************** 技能 **************************/

	UPROPERTY()
	TArray<FSavedAbility> SavedAbilities;

有了相关数据可以存储到存档后，我们可以在角色保存时，实现保存技能相关数据。
在保存数据的时候，我们先将存档里的技能数组清空，然后使用RPGASC->ForEachAbility技能委托遍历所有应用到角色身上的技能，通过结构体设置技能数据，并通过AddUnique添加到数组（前面我们添加了operator==覆写了获取相等的设置）

void ARPGHero::SaveProgress_Implementation(const FName& CheckpointTag)
{
	if(const ARPGGameMode* GameMode = Cast<ARPGGameMode>(UGameplayStatics::GetGameMode(this)))
	{
		...

		SaveGameData->bFirstTimeLoadIn = false; //保存完成将第一次加载属性设置为false

		if(!HasAuthority()) return;

		URPGAbilitySystemComponent* RPGASC = Cast<URPGAbilitySystemComponent>(AbilitySystemComponent);
		SaveGameData->SavedAbilities.Empty(); //清空数组

		//使用ASC里创建的ForEach函数循环获取角色的技能，并生成技能结构体保存
		FForEachAbility SaveAbilityDelegate;
		SaveAbilityDelegate.BindLambda([this, RPGASC, SaveGameData](const FGameplayAbilitySpec& AbilitySpec)
		{
			//获取技能标签和
			const FGameplayTag AbilityTag = URPGAbilitySystemComponent::GetAbilityTagFromSpec(AbilitySpec);
			UAbilityInfo* AbilityInfo = URPGAbilitySystemLibrary::GetAbilityInfo(this);
			FRPGAbilityInfo Info = AbilityInfo->FindAbilityInfoForTag(AbilityTag);

			//创建技能结构体
			FSavedAbility SavedAbility;
			SavedAbility.GameplayAbility = Info.Ability;
			SavedAbility.AbilityLevel = AbilitySpec.Level;
			SavedAbility.AbilityTag = AbilityTag;
			SavedAbility.AbilityStatus = RPGASC->GetStatusTagFromAbilityTag(AbilityTag);
			SavedAbility.AbilityInputTag = RPGASC->GetInputTagFromAbilityTag(AbilityTag);
			SavedAbility.AbilityType = Info.AbilityType;

			SaveGameData->SavedAbilities.AddUnique(SavedAbility);
		});
		//调用ForEach技能来执行存储到存档
		RPGASC->ForEachAbility(SaveAbilityDelegate);

		//保存存档
		GameMode->SaveInGameProgressData(SaveGameData);
	}
}

ForEach技能就是传入一个委托，然后遍历所有的应用技能。
在这里插入图片描述
接着，在ASC里增加一个通过存档数据设置角色技能的函数。
我们遍历存储的技能，根据技能是主动技能还是被动技能，应用给角色。

void URPGAbilitySystemComponent::AddCharacterAbilitiesFormSaveData(ULoadScreenSaveGame* SaveGameData)
{
	for(const FSavedAbility& Data : SaveGameData->SavedAbilities)
	{
		const TSubclassOf<UGameplayAbility> LoadedAbilityClass = Data.GameplayAbility;

		FGameplayAbilitySpec LoadedAbilitySpec = FGameplayAbilitySpec(LoadedAbilityClass, Data.AbilityLevel);
		LoadedAbilitySpec.DynamicAbilityTags.AddTag(Data.AbilityInputTag); //设置技能激活输入标签
		LoadedAbilitySpec.DynamicAbilityTags.AddTag(Data.AbilityStatus); //设置技能状态标签

		//主动技能的处理
		if(Data.AbilityType == FRPGGameplayTags::Get().Abilities_Type_Offensive)
		{
			GiveAbility(LoadedAbilitySpec); //只应用不激活
		}
		//被动技能的处理
		else if(Data.AbilityType == FRPGGameplayTags::Get().Abilities_Type_Passive)
		{
			//确保技能已经装配
			if(Data.AbilityStatus.MatchesTagExact(FRPGGameplayTags::Get().Abilities_Status_Equipped))
			{
				GiveAbilityAndActivateOnce(LoadedAbilitySpec); //应用技能并激活
			}
			else
			{
				GiveAbility(LoadedAbilitySpec); //只应用不激活
			}
		}
	}

	bStartupAbilitiesGiven = true;
	AbilityGivenDelegate.Broadcast();
}

接下来，我们编译打开UE，查看现在角色身上装配的技能，这些技能我们保存需要技能对应的资产数据
在这里插入图片描述
接着，我们给一些不需要操作的被动技能添加标签，这个被动技能主要是监听属性加点，我们通过加点是，会发送事件，此技能会接受事件通过GE给角色增加属性值。

我们在技能的数据资产里增加对应的配置，由于不需要显示，我们不需要设置Icon
在这里插入图片描述
还有之前制作的眩晕技能也需要配置数据

删除多余的测试技能，就可以去测试。

处理加载时的一些bug

首先，第一个bug是我这边通过存档进入时，激活的技能不显示，这个问题的原因是初始化时，对应的面板控制器没有初始化，不使用存档时没这个问题是因为我们打开对应面板时进行的初始化。
解决方案是，在HUD初始化面板时，我们将对应的控制器都初始化一下即可
在这里插入图片描述
第二个问题，被动技能特效无法显示，出现这个问题的原因是因为在ASC通过存档初始化技能时，对应的被动技能效果组件还没有执行绑定监听，解决这个问题的方式是，我们在绑定监听时，调用一次即可。
在这里插入图片描述

实现保存场景状态

我们实现了对技能的保存，接下来，我们实现可以在存档里，将角色进入过的场景的状态也保存。
我们要在存档里保存场景的数据，首先在场景里创建对应的数据类型，对于场景的Actor，我们考虑使用结构体保存，并通过UE内置的序列器，进行对Actor的数据进行序列化存储到存档，并在使用的时候，通过反序列化，应用会角色身上。
这里，我们增加两个结构体，一个用于保存关卡场景里的Actor，另一个是保存所在的关卡，这样，我们可以通过进入的关卡，获取到对应关卡的Actor数据，并应用回去。

//保存场景中的Actor结构体
USTRUCT()
struct FSavedActor
{
	GENERATED_BODY()

	UPROPERTY()
	FName ActorName = FName();

	UPROPERTY()
	FTransform Transform = FTransform();

	//Actor身上序列号的数据，必须通过UPROPERTY定义过，只在保存存档时使用。
	UPROPERTY()
	TArray<uint8> Bytes;
};

//自定义运算符==，如果结构体内的ActorName相同，这代表这两个结构体为相同结构体
inline bool operator==(const FSavedActor& Left, const FSavedActor& Right)
{
	return Left.ActorName == Right.ActorName;
}

//地图相关数据保存
USTRUCT()
struct FSavedMap
{
	GENERATED_BODY()

	UPROPERTY()
	FString MapAssetName = FString();

	UPROPERTY()
	TArray<FSavedActor> SavedActors;
};

接着，我们在存档类里，添加一个属性，可以通过此属性可以获取到所有保存的关卡数据，并增加两个函数，用于获取对应的关卡数据和判断存档里是否有对应关卡的数据。

	UPROPERTY()
	TArray<FSavedMap> SavedMaps;

	//通过地图名称获取地图数据
	FSavedMap GetSavedMapWithMapName(const FString& InMapName);

	//判断存档是否含有对于地图数据
	bool HasMap(const FString& InMapName);

实现对应的函数，通过遍历判断名称来实现。

FSavedMap ULoadScreenSaveGame::GetSavedMapWithMapName(const FString& InMapName)
{
	for(const FSavedMap& Map : SavedMaps)
	{
		if(Map.MapAssetName == InMapName)
		{
			return Map;
		}
	}
	return FSavedMap();
}

bool ULoadScreenSaveGame::HasMap(const FString& InMapName)
{
	for(const FSavedMap& Map : SavedMaps)
	{
		if(Map.MapAssetName == InMapName)
		{
			return true;
		}
	}
	return false;
}

接着，我们增加一个新的接口，新的接口可以用于判断当前场景中的哪些Actor需要保存到存档里
在这里插入图片描述
我们命名新接口

需要保存的场景的Actor都需要继承此接口。

我们在接口里增加两个函数，一个是用于判断是否需要修改位置变换，这个功能可以在解密游戏里，解开机关后，开启了某扇密门后，将其保存起来，防止下次还需要继续重新开启。另一个是在从存档里读取数据后，更新Actor。

// 版权归暮志未晚所有。

#pragma once

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "SaveInterface.generated.h"

// This class does not need to be modified.
UINTERFACE(MinimalAPI)
class USaveInterface : public UInterface
{
	GENERATED_BODY()
};

/**
 * 
 */
class RPG_API ISaveInterface
{
	GENERATED_BODY()

	// Add interface functions to this class. This is the class that will be inherited to implement this interface.
public:

	//设置Actor是否需要修改位置变换
	UFUNCTION(BlueprintCallable, BlueprintNativeEvent)
	bool ShouldLoadTransform();

	//在存档读取完数据后，调用更新Actor
	UFUNCTION(BlueprintCallable, BlueprintNativeEvent)
	void LoadActor();
};

接着，我们修改检查点的类，我们需要将检查点的数据存储到存档里，这里增加了一个变量，用于判断当前检查点是否被激活，并且覆写继承接口的函数。我们不需要修改存档点的位置变换，这里直接返回false，如果像机关密门那种，则需要保存，我们可以设置为true。
将bReached，设置SaveGame时，如果我们将实例序列化存档数据时，它的值将会被存入到存档中，在反序列化时，将存档数据重新设置回来。

	/*   Save Interface   */
	virtual bool ShouldLoadTransform_Implementation() override { return false; } //是否需要修改变换，检查点不需要
	virtual void LoadActor_Implementation() override; //通过存档二进制修改Actor数据后，更新Actor
	/*   End Save Interface   */

	//当前检查点是否已经被激活，设置SaveGame表示该值将会被存储到存档文件中
	UPROPERTY(BlueprintReadOnly, SaveGame)
	bool bReached = false;

我们实现一下LoadActor函数，在从存档读取数据设置完Actor，调用它实现一些处理。

void ACheckPoint::LoadActor_Implementation()
{
	if(bReached)
	{
		HandleGlowEffects();
	}
}

实现场景状态的存储和读取

要实现场景状态的存储和读取，我们在GameMode里增加两个函数，分别处理存储和读取。

	//保存关卡中的状态到当前存档中
	void SaveWorldState(UWorld* World) const;
	//从存档中加载当前关卡的状态
	void LoadWorldState(UWorld* World) const;

首先我们实现对关卡的状态存储，这里说一下逻辑，首先获取到关卡名称，和游戏实例，游戏实例有存档的相关信息，获取到存档对象，判断对应关卡在存档内是否有对应的数据存储，如果没有，新创建一个。
然后获取到对应的关卡数据，将数据内存储的Actor数据清除，遍历关卡内的所有Actor，找到继承保存接口的Actor，创建一个对应Actor的存储数据结构体，通过FMemoryWriter将Actor身上需要保存到存档的数据设置到存档结构体内。
最后，将地图的数据存储到存档对象里。

void ARPGGameMode::SaveWorldState(UWorld* World) const
{
	//获取关卡名称
	FString WorldName = World->GetMapName();
	WorldName.RemoveFromStart(World->StreamingLevelsPrefix); //从关卡名称这里移除指定前缀，当前为移除通常用于标识流式加载的关卡文件前缀

	//获取到游戏实例
	URPGGameInstance* RPGGI = Cast<URPGGameInstance>(GetGameInstance());
	check(RPGGI);

	//获取存档
	if(ULoadScreenSaveGame* SaveGame = GetSaveSlotData(RPGGI->LoadSlotName, RPGGI->LoadSlotIndex))
	{
		if(!SaveGame->HasMap(WorldName))
		{
			//如果存档不包含对应关卡内容，将创建一个对应的数据结构体存储
			FSavedMap NewSavedMap;
			NewSavedMap.MapAssetName = WorldName;
			SaveGame->SavedMaps.Add(NewSavedMap);
		}

		//获取对应的存档关卡数据结构体
		FSavedMap SavedMap = SaveGame->GetSavedMapWithMapName(WorldName);
		SavedMap.SavedActors.Empty(); //存储的内容

		//使用迭代起，便利场景里的每一个Actor，将需要保存Actor数据保存到结构体内
		for(FActorIterator It(World); It; ++It)
		{
			AActor* Actor = *It;

			//判断Actor是否存在，并判断Actor是否需要存储
			if(!IsValid(Actor) || !Actor->Implements<USaveInterface>()) continue;

			//创建存储结构体
			FSavedActor SavedActor;
			SavedActor.ActorName = Actor->GetFName();
			SavedActor.Transform = Actor->GetTransform();

			//创建一个 FMemoryWriter，用于将数据写入SavedActor.Bytes
			FMemoryWriter MemoryWriter(SavedActor.Bytes);

			//创建一个序列化器，将对象的成员以名称和值的形式保存到 MemoryWriter。
			FObjectAndNameAsStringProxyArchive Archive(MemoryWriter, true);
			Archive.ArIsSaveGame = true; //设置序列化方式为保存到存档的模式

			//将Actor所需要保存的数据写入到Archive，Archive将把数据存储到SavedActor.Bytes
			Actor->Serialize(Archive);

			SavedMap.SavedActors.AddUnique(SavedActor);
		}

		//找到对应的名称的结构体，将数据存储到存档对象内
		for(FSavedMap& MapToReplace : SaveGame->SavedMaps)
		{
			if(MapToReplace.MapAssetName == WorldName)
			{
				MapToReplace = SavedMap;
			}
		}

		//保存存档
		UGameplayStatics::SaveGameToSlot(SaveGame, RPGGI->LoadSlotName, RPGGI->LoadSlotIndex);
	}
}

接着是加载关卡状态，我们通过关卡名称和游戏实例获取到存档实例，判断存档实例是否存在此关卡的存档数据。
如果存在此关卡数据，我们将遍历此关卡的所有Actor，如果Actor包含存储接口，我们将判断存档里是否存储了此Actor对应的数据，然后通过MemoryReader读取存档数据，进行反序列化，将数据应用回Actor。
最后通过接口函数，调用Actor更新自身状态。

void ARPGGameMode::LoadWorldState(UWorld* World) const
{
	//获取关卡名称
	FString WorldName = World->GetMapName();
	WorldName.RemoveFromStart(World->StreamingLevelsPrefix); //从关卡名称这里移除指定前缀，当前为移除通常用于标识流式加载的关卡文件前缀
	
	//获取到游戏实例
	URPGGameInstance* RPGGI = Cast<URPGGameInstance>(GetGameInstance());
	check(RPGGI);

	//判断获取的存档是否存在
	if(UGameplayStatics::DoesSaveGameExist(RPGGI->LoadSlotName, RPGGI->LoadSlotIndex))
	{
		//获取存档
		ULoadScreenSaveGame* SaveGame = Cast<ULoadScreenSaveGame>(UGameplayStatics::LoadGameFromSlot(RPGGI->LoadSlotName, RPGGI->LoadSlotIndex));
		if(SaveGame == nullptr)
		{
			UE_LOG(LogRPG, Error, TEXT("加载对应存档失败"));
		}

		//判断存档是否含有对应关卡的数据
		if(SaveGame->HasMap(WorldName))
		{
			//遍历场景内的所有Actor，寻找存档内对应的数据并应用到场景
			for(FActorIterator It(World); It; ++It)
			{
				AActor* Actor = *It;

				if(!Actor->Implements<USaveInterface>()) continue;

				//遍历存档里对应关卡的所有actor数据
				for(FSavedActor SavedActor : SaveGame->GetSavedMapWithMapName(WorldName).SavedActors)
				{
					//查找到对应的actor的存档数据
					if(SavedActor.ActorName == Actor->GetFName())
					{
						//判断当前Actor是否需要设置位置变换
						if(ISaveInterface::Execute_ShouldLoadTransform(Actor))
						{
							Actor->SetActorTransform(SavedActor.Transform);
						}

						//反序列化，创建一个FMemoryReader实例用于从二进制数据中读取内容
						FMemoryReader MemoryReader(SavedActor.Bytes);

						//FObjectAndNameAsStringProxyArchive 代理类，用于序列化和反序列化对象的属性 true：表示允许使用字符串形式的对象和属性名称（便于调试和可读性）。
						FObjectAndNameAsStringProxyArchive Archive(MemoryReader, true);
						Archive.ArIsSaveGame = true; //指定反序列化是用于加载存档数据。
						Actor->Serialize(Archive); //执行反序列化，将二进制数据设置到actor属性上

						//修改Actor上的属性后，调用函数更新Actor的显示
						ISaveInterface::Execute_LoadActor(Actor);
					}
				}
			}			
		}
	}
}

实现场景存储和读取

对应的函数实现了，最后一步，我们需要知道在什么时候存储和什么时候去读取。
存储我们选择在玩家角色激活检查点时，我们将bReached设置为true，并调用保存状态函数，将数据保存到关卡内。

void ACheckPoint::OnSphereOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
	//if(OtherActor->ActorHasTag("Player")) //如果只需要判断是不是玩家角色通过标签判断即可
	if(OtherActor->Implements<UPlayerInterface>())
	{
		//设置当前检查点已被玩家激活
		bReached = true;

		if(ARPGGameMode* RPGGameMode = Cast<ARPGGameMode>(UGameplayStatics::GetGameMode(this)))
		{
			//保存场景状态
			RPGGameMode->SaveWorldState(GetWorld());
		}
		
		//修改存档当的检测点
		IPlayerInterface::Execute_SaveProgress(OtherActor, PlayerStartTag);
		
		//如果与碰撞体重叠的是
		HandleGlowEffects();
	}
}

在读取时，我们选择在玩家PossessedBy里，它将调用加载存档函数，我们将读取写在读取完技能之后，实现场景的加载。
在这里插入图片描述
最后，测试即可。