Update headers to CL377620

Plugins/AbstractInstance/Source/AbstractInstance/Private/AbstractInstanceManager.cpp

@@ -187,7 +187,7 @@ void AAbstractInstanceManager::Tick( float DeltaSeconds )
 #endif
 }
 
-void AAbstractInstanceManager::SetInstancedStatic( AActor* OwnerActor, const FTransform& ActorTransform, const UAbstractInstanceDataObject* InstanceDataArray, TArray<FInstanceHandle*>& OutHandles, bool bInitializeHidden,TSubclassOf< class AActor > buildableClass )
+void AAbstractInstanceManager::SetInstancedStatic( AActor* OwnerActor, const FTransform& ActorTransform, const UAbstractInstanceDataObject* InstanceDataArray, TArray<FInstanceHandle*>& OutHandles, bool bInitializeHidden)
 {
 	QUICK_SCOPE_CYCLE_COUNTER( AAbstractInstanceManager_SetInstancedStatic )
 
@@ -201,7 +201,7 @@ void AAbstractInstanceManager::SetInstancedStatic( AActor* OwnerActor, const FTr
 				FInstanceHandle* Handle = new FInstanceHandle();
 
 				// Assign buildable class if its used (LightWeightBuildableSubsystem)
-				Handle->BuildableClass = buildableClass;
+				//Handle->BuildableClass = buildableClass;
 
 				if( InstanceDataEntry.bAllowLazyInstance && Manager->CanLazyLoad() )
 				{

Plugins/AbstractInstance/Source/AbstractInstance/Public/AbstractInstanceManager.h

@@ -96,7 +96,7 @@ class ABSTRACTINSTANCE_API AAbstractInstanceManager : public AActor
 
 	virtual void Tick(float DeltaSeconds) override;
 
-	static void SetInstancedStatic( AActor* OwnerActor, const FTransform& ActorTransform, const UAbstractInstanceDataObject* InstanceData, TArray<FInstanceHandle*>& OutHandle, bool bInitializeHidden = false, TSubclassOf< class AActor > buildableClass = nullptr );
+	static void SetInstancedStatic( AActor* OwnerActor, const FTransform& ActorTransform, const UAbstractInstanceDataObject* InstanceData, TArray<FInstanceHandle*>& OutHandle, bool bInitializeHidden = false );
 	static void SetInstanceFromDataStatic( AActor* OwnerActor, const FTransform& ActorTransform, const FInstanceData& InstanceData, FInstanceHandle* &OutHandle, bool bInitializeHidden = false );
 	void SetInstanced( AActor* OwnerActor, const FTransform& ActorTransform, const FInstanceData& InstanceData, FInstanceHandle* &OutHandle, bool bInitializeHidden = false );
 
@@ -126,7 +126,7 @@ class ABSTRACTINSTANCE_API AAbstractInstanceManager : public AActor
 	void StartDrawDebug(bool bEnabled);
 	void HideAllInstance(bool bIsHidden);
 
-	FORCEINLINE bool CanLazyLoad() const { return bAllowLazySpawn; }
+	FORCEINLINE bool CanLazyLoad() const { return false; }
 
 protected:	
 	// Called when the game starts or when spawned

Plugins/AbstractInstance/Source/AbstractInstance/Public/InstanceData.h

@@ -87,6 +87,12 @@ struct ABSTRACTINSTANCE_API FInstanceData
 	UStaticMeshComponent* CreateStaticMeshComponent( UObject* Outer ) const;
 };
 
+/** Base class that can be used to store metadata on instance handles */
+struct FInstanceHandleMetadata
+{
+	virtual ~FInstanceHandleMetadata() = default;
+};
+
 USTRUCT( BlueprintType )
 struct ABSTRACTINSTANCE_API FInstanceHandle
 {
@@ -135,8 +141,6 @@ struct ABSTRACTINSTANCE_API FInstanceHandle
 			HideInstance(bMarkRenderStateDirty);
 		}
 	}
-
-	FORCEINLINE TSubclassOf< AActor > GetInstancedBasedOnClass() { return BuildableClass; }
 
 	void HideInstance( bool bMarkRenderStateDirty = true );
 	void HideInstance( UHierarchicalInstancedStaticMeshComponent* Hism, int32 Id, bool bMarkRenderStateDirty = true );
@@ -195,12 +199,11 @@ struct ABSTRACTINSTANCE_API FInstanceHandle
 
 	int32 NumPrimitiveFloatData;
 
-	UPROPERTY()
-	TSubclassOf< class AActor > BuildableClass;
-
 	/* Used for hiding */
 	mutable FVector Scale;
-
+public:
+	/** Metadata set on the instance. Can be used to store additional data associated with the instance handle */
+	TSharedPtr<FInstanceHandleMetadata> Metadata;
 public:
 
 	FInstanceHandle( uint32 inIndex, uint32 inCollisionID, AActor* inOwner, UHierarchicalInstancedStaticMeshComponent* inInstancedStaticMeshComponent, UInstancedStaticMeshComponent* inBatchCollision )

Plugins/Online/OnlineIntegration/OnlineIntegration.uplugin

@@ -44,7 +44,9 @@
 			"Enabled": true,
 			"WhitelistPlatforms": [
 				"Win64",
-				"Linux"
+				"Linux",
+				"PS5",
+				"XSX"
 			],
 			"BlacklistTargets": [
 				"Server"
@@ -79,6 +81,17 @@
 				"Server"
 			]
 		},
+		{
+			"Name": "OnlineServicesSteamLimited",
+			"Enabled": false,
+			"WhitelistPlatforms": [
+				"Win64",
+				"Linux"
+			],
+			"BlacklistTargets": [
+				"Server"
+			]
+		},
 		{
 			"Name": "ModelViewViewModel",
 			"Enabled": true

Plugins/Online/OnlineIntegration/Source/OnlineIntegration/Public/CommonSessionSubsystem.h

@@ -76,7 +76,8 @@ class ONLINEINTEGRATION_API UCommonSessionSubsystem : public UGameInstanceSubsys
 	//////////////////////////////////////////////////////////////////////
 	/// Native API - should be preferred when used from native code
 	UE::Online::TOnlineResult<UE::Online::FGetSessionByName> GetSessionByName(UE::Online::FGetSessionByName::Params&& Params, UOnlineIntegrationBackend* Backend);
-
+
+	static bool IsProviderNameSupported(const FString& ProviderName);
 	static UE::Online::FOnlineSessionId MakeOnlineSessionId(const FString& SessionIdString);
 	static FString OnlineSessionIdToString(UE::Online::FOnlineSessionId SessionId);
 

Plugins/Online/OnlineIntegration/Source/OnlineIntegration/Public/CommonUserSubsystem.h

@@ -270,6 +270,11 @@ class ONLINEINTEGRATION_API UCommonUserSubsystem : public UGameInstanceSubsystem
 
 	UOnlineUserInfo* CreateOnlineUserForLink(UOnlineUserBackendLink* BackendLink);
 
+	const TMap<FGameplayTag, FString>& GetTrackedStats() const { return TrackedStatMap; }
+	const TArray<FAggregatedOnlineStat>& GetTrackedAggregatedStats() const { return TrackedAggregatedStats; }
+
+	void UpdateAllAggregatedStats(const UE::Online::FAccountId& AccountId, UOnlineIntegrationBackend* Backend);
+
 protected:
 	/**
 	 * Handles Gameplay events. Most likely that means a backend stat update

Plugins/Online/OnlineIntegration/Source/OnlineIntegrationEditor/Private/AddOnEntitlementFactory.cpp

@@ -0,0 +1,10 @@
+#include "AddOnEntitlementFactory.h"
+
+UAddOnEntitlementFactory::UAddOnEntitlementFactory()
+{
+}
+
+UObject* UAddOnEntitlementFactory::FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn)
+{
+	return nullptr;
+}

Plugins/Online/OnlineIntegration/Source/OnlineIntegrationEditor/Private/AddOnEntitlementFactory.h

@@ -0,0 +1,34 @@
+// Copyright Coffee Stain Studios. All Rights Reserved.
+
+#pragma once
+
+#include "AssetTypeActions_Base.h"
+#include "CoreMinimal.h"
+#include "Factories/Factory.h"
+
+#include "AddOnEntitlementFactory.generated.h"
+
+class FAssetTypeActions_AddOnEntitlement: public FAssetTypeActions_Base
+{
+public:
+	// Begin IAssetTypeActions interface
+	virtual FText GetName() const override;
+	virtual FColor GetTypeColor() const override;
+	virtual UClass* GetSupportedClass() const override;
+	virtual uint32 GetCategories() override;
+	// End IAssetTypeActions interface
+};
+class UAddOnEntitlement;
+/**
+ * 
+ */
+UCLASS()
+class UAddOnEntitlementFactory : public UFactory
+{
+	GENERATED_BODY()
+public:
+	UAddOnEntitlementFactory();
+
+protected:
+	virtual UObject* FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn) override;
+};

Plugins/Online/OnlineIntegration/Source/OnlineIntegrationEditor/Private/SessionDefinitionFactory.cpp

@@ -0,0 +1,10 @@
+#include "SessionDefinitionFactory.h"
+
+USessionDefinitionFactory::USessionDefinitionFactory()
+{
+}
+
+UObject* USessionDefinitionFactory::FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn)
+{
+	return nullptr;
+}

Plugins/Online/OnlineIntegration/Source/OnlineIntegrationEditor/Private/SessionDefinitionFactory.h

@@ -0,0 +1,34 @@
+// Copyright Coffee Stain Studios. All Rights Reserved.
+
+#pragma once
+
+#include "AssetTypeActions_Base.h"
+#include "CoreMinimal.h"
+#include "Factories/Factory.h"
+
+#include "SessionDefinitionFactory.generated.h"
+
+class USessionDefinition;
+class FAssetTypeActions_SessionDefinition: public FAssetTypeActions_Base
+{
+public:
+	// Begin IAssetTypeActions interface
+	virtual FText GetName() const override;
+	virtual FColor GetTypeColor() const override;
+	virtual UClass* GetSupportedClass() const override;
+	virtual uint32 GetCategories() override;
+	// End IAssetTypeActions interface
+};
+/**
+ * 
+ */
+UCLASS()
+class USessionDefinitionFactory : public UFactory
+{
+	GENERATED_BODY()
+public:
+	USessionDefinitionFactory();
+
+protected:
+	virtual UObject* FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn) override;
+};

Source/FactoryGame/Private/FGCircuitSubsystem.cpp

@@ -16,6 +16,7 @@ AFGCircuitSubsystem::AFGCircuitSubsystem() : Super() {
 	this->PrimaryActorTick.TickInterval = 0.0;
 	this->bReplicateUsingRegisteredSubObjectList = true;
 }
+void AFGCircuitSubsystem::EndPlay(const EEndPlayReason::Type EndPlayReason){ Super::EndPlay(EndPlayReason); }
 void AFGCircuitSubsystem::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const {
 	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 	DOREPLIFETIME(AFGCircuitSubsystem, mReplicatedCircuits);

Source/FactoryGame/Private/FGCrashSiteDebris.cpp

@@ -3,6 +3,7 @@
 #include "FGCrashSiteDebris.h"
 #include "Components/BoxComponent.h"
 #include "Components/SceneComponent.h"
+#include "UObject/ObjectSaveContext.h"
 
 #if WITH_EDITOR
 void AFGCrashSiteDebris::PreSave(FObjectPreSaveContext SaveContext){ }

Source/FactoryGame/Private/FGCreatureSubsystem.cpp

@@ -25,6 +25,7 @@ void AFGCreatureSubsystem::RegisterFlyingBabyCrab( AFGFlyingBabyCrab* babyCrab){
 void AFGCreatureSubsystem::UnregisterFlyingBabyCrab( AFGFlyingBabyCrab* babyCrab){ }
 void AFGCreatureSubsystem::ForceTriggerSpawnersInRange(){ }
 bool AFGCreatureSubsystem::IsProtectedCreature(TSubclassOf<  AFGCreature > creatureClass) const{ return bool(); }
+int32 AFGCreatureSubsystem::GetNumActiveCreatures(bool includePersistent) const{ return int32(); }
 void AFGCreatureSubsystem::SetCreatureStressEnabled(bool enabled){ }
 AFGCreatureSubsystem* AFGCreatureSubsystem::Get(UWorld* world){ return nullptr; }
 AFGCreatureSubsystem* AFGCreatureSubsystem::Get(UObject* worldContext){ return nullptr; }

Source/FactoryGame/Private/FGLightweightBuildableBlueprintLibrary.cpp

@@ -0,0 +1,47 @@
+// This file has been manually implemented by Th3Fanbus
+
+#include "FGLightweightBuildableBlueprintLibrary.h"
+
+bool UFGLightweightBuildableBlueprintLibrary::IsLightweightValid(const FLightweightBuildableInstanceRef& instance)
+{
+    return instance.IsValid();
+}
+
+TSubclassOf<AFGBuildable> UFGLightweightBuildableBlueprintLibrary::GetLightweightClass(const FLightweightBuildableInstanceRef& instance)
+{
+    return instance.GetBuildableClass();
+}
+
+FTransform UFGLightweightBuildableBlueprintLibrary::GetLightweightTransform(const FLightweightBuildableInstanceRef& instance)
+{
+    return instance.GetBuildableTransform();
+}
+
+TSubclassOf<UFGRecipe> UFGLightweightBuildableBlueprintLibrary::GetLightweightBuiltWithRecipe(const FLightweightBuildableInstanceRef& instance)
+{
+    return instance.GetBuiltWithRecipe();
+}
+
+bool UFGLightweightBuildableBlueprintLibrary::ResolveLightweightCustomizationData(const FLightweightBuildableInstanceRef& instance, FFactoryCustomizationData& out_customizationData)
+{
+    if (const FRuntimeBuildableInstanceData* InstanceData = instance.ResolveBuildableInstanceData()) {
+        out_customizationData = InstanceData->CustomizationData;
+        return true;
+    }
+    return false;
+}
+
+void UFGLightweightBuildableBlueprintLibrary::UpdateLightweightCustomizationData(const FLightweightBuildableInstanceRef& instance, const FFactoryCustomizationData& customizationData)
+{
+    instance.SetCustomizationData(customizationData);
+}
+
+void UFGLightweightBuildableBlueprintLibrary::RemoveLightweight(UPARAM(Ref)FLightweightBuildableInstanceRef& instance)
+{
+    instance.Remove();
+}
+
+AFGBuildable* UFGLightweightBuildableBlueprintLibrary::SpawnTemporaryFromLightweight(const FLightweightBuildableInstanceRef& instance)
+{
+    return instance.SpawnTemporaryBuildable();
+}

Source/FactoryGame/Private/FGLightweightBuildableSubsystem.cpp

@@ -102,7 +102,7 @@ int32 AFGLightweightBuildableSubsystem::AddFromBuildable( AFGBuildable* buildabl
 void AFGLightweightBuildableSubsystem::RemoveByBuildable( AFGBuildable* buildable){ }
 void AFGLightweightBuildableSubsystem::RemoveByInstanceIndex(TSubclassOf<  AFGBuildable > buildableClass, int32 instanceIndex){ }
 void AFGLightweightBuildableSubsystem::InvalidateRuntimeInstanceDataForIndex(TSubclassOf<AFGBuildable> buildableClass, int32 index){ }
-int32 AFGLightweightBuildableSubsystem::AddFromBuildableInstanceData(TSubclassOf<  AFGBuildable > buildableClass, FRuntimeBuildableInstanceData& buildableInstanceData, bool fromSaveData , uint16 constructId , AActor* buildEffectInstigator , int32 blueprintBuildEffectIndex){ return int32(); }
+int32 AFGLightweightBuildableSubsystem::AddFromBuildableInstanceData(TSubclassOf<class AFGBuildable> buildableClass, FRuntimeBuildableInstanceData& buildableInstanceData, bool fromSaveData, int32 saveDataBuildableIndex, uint16 constructId, AActor* buildEffectInstigator, int32 blueprintBuildEffectIndex){ return int32(); }
 void AFGLightweightBuildableSubsystem::AddFromReplicatedData(TSubclassOf< AFGBuildable > buildableClass, TSubclassOf<  UFGRecipe > builtWithRecipe, const FLightweightBuildableReplicationItem& replicationData, int32 maxSize, AActor* buildEffectInstigator, int32 blueprintBuildIndex){ }
 void AFGLightweightBuildableSubsystem::RemoveStaleTemporaryBuildables(){ }
 void AFGLightweightBuildableSubsystem::RemoveTemporaryBuildableForInstanceIndex(TSubclassOf<AFGBuildable> buildableClass, int32 instanceIndex){ }
@@ -119,13 +119,17 @@ void AFGLightweightBuildableSubsystem::BlueprintProxyHoveredForDismantle( AFGBlu
 void AFGLightweightBuildableSubsystem::BlueprintProxyStopHoveredForDismantle( AFGBlueprintProxy* blueprintProxy){ }
 void AFGLightweightBuildableSubsystem::NotifyInstancesOfBlueprintProxy(const TArray< FBuildableClassLightweightIndices >& lightweightInstancesAndIndices, AFGBlueprintProxy* blueprintProxy){ }
 FRuntimeBuildableInstanceData* AFGLightweightBuildableSubsystem::GetRuntimeDataForBuildableClassAndIndex(TSubclassOf<  AFGBuildable > buildableClass, int32 index){ return nullptr; }
-FRuntimeBuildableInstanceData* AFGLightweightBuildableSubsystem::GetRuntimeDataForBuildableClassAndHandleNearLocation(TSubclassOf<  AFGBuildable > buildableClass, const FInstanceHandle& handle, const FVector& location){ return nullptr; }
 void AFGLightweightBuildableSubsystem::AddBuildEffectForRuntimeData(AFGBuildEffectActor* buildEffectActor, TSubclassOf< AFGBuildable > buildableClass, int32 index){ }
 void AFGLightweightBuildableSubsystem::RemoveBuildEffectForRuntimeData(AFGBuildEffectActor* buildEffectActor){ }
+bool AFGLightweightBuildableSubsystem::ResolveLightweightInstance(const FInstanceHandle& instanceHandle, FLightweightBuildableInstanceRef& out_buildableDescriptor){ return false; }
 TSoftClassPtr< class UFGMaterialEffect_Build > AFGLightweightBuildableSubsystem::GetBuildEffectTemplate() const{ return TSoftClassPtr<class UFGMaterialEffect_Build>(); }
 TSoftClassPtr< class UFGMaterialEffect_Build > AFGLightweightBuildableSubsystem::GetDismantleEffectTemplate() const{ return TSoftClassPtr<class UFGMaterialEffect_Build>(); }
 void AFGLightweightBuildableSubsystem::CreateBuildEffectForRuntimeData(TSubclassOf<AFGBuildable> buildableClass, FRuntimeBuildableInstanceData& runtimeData, AActor* instigator, UAbstractInstanceDataObject* instanceData, int32 Index){ }
 void AFGLightweightBuildableSubsystem::OnBuildEffectFinished( UFGMaterialEffectComponent* materialEffect){ }
 void AFGLightweightBuildableSubsystem::CreateDismantleEffectForRuntimeData(FRuntimeBuildableInstanceData& runtimeData, AActor* instigator,  UAbstractInstanceDataObject* instanceData){ }
 void AFGLightweightBuildableSubsystem::OnDismantleEffectFinished( UFGMaterialEffectComponent* materialEffect){ }
 FRuntimeBuildableInstanceData AFGLightweightBuildableSubsystem::mStaticRuntimeInstanceDataStorage = FRuntimeBuildableInstanceData();
+const FRuntimeBuildableInstanceData* FLightweightBuildableInstanceRef::ResolveBuildableInstanceData() const{ return nullptr; }
+bool FLightweightBuildableInstanceRef::Remove(){ return false; }
+bool FLightweightBuildableInstanceRef::SetCustomizationData(const FFactoryCustomizationData& customizationData) const{ return false; }
+AFGBuildable* FLightweightBuildableInstanceRef::SpawnTemporaryBuildable() const{ return nullptr; }

Source/FactoryGame/Private/FGPlayerController.cpp

@@ -55,6 +55,9 @@ void AFGPlayerController::OnRep_PlayerState(){ }
 void AFGPlayerController::SetPawn(APawn* inPawn){ }
 void AFGPlayerController::OnPossess(APawn* aPawn){ }
 void AFGPlayerController::OnUnPossess(){ }
+void AFGPlayerController::SetIgnoreMoveInput(bool bNewMoveInput){ }
+void AFGPlayerController::ResetIgnoreMoveInput(){ }
+void AFGPlayerController::ResetIgnoreInputFlags(){ }
 void AFGPlayerController::PawnLeavingGame(){ }
 void AFGPlayerController::PlayerTick(float DeltaTime){ }
 void AFGPlayerController::PreClientTravel(const FString& pendingURL, ETravelType travelType, bool isSeamlessTravel){ }

Source/FactoryGame/Private/FGWorldScannableData.cpp

@@ -3,7 +3,6 @@
 #include "FGWorldScannableData.h"
 #include "UObject/ObjectSaveContext.h"
 
-FWorldScannableData::FWorldScannableData() { }
 #if WITH_EDITOR
 FWorldScannableData::FWorldScannableData(const AActor* actor) { }
 FWorldScannableData::FWorldScannableData(const class FWorldPartitionActorDesc* ActorDesc, int32 PIEInstanceIndex) { }

Source/FactoryGame/Private/Hologram/FGHologram.cpp

@@ -107,7 +107,7 @@ void AFGHologram::UpdateRotationValuesFromTransform(){ }
 void AFGHologram::SetBuildClass(TSubclassOf<  AActor > buildClass){ }
 TSubclassOf< AActor > AFGHologram::GetActorClass() const{ return TSubclassOf<AActor>(); }
 void AFGHologram::SetInsideBlueprintDesigner( AFGBuildableBlueprintDesigner* designer){ }
-AFGBuildableBlueprintDesigner* AFGHologram::GetBlueprintDesigner(){ return nullptr; }
+AFGBuildableBlueprintDesigner* AFGHologram::GetBlueprintDesigner() const{ return nullptr; }
 bool AFGHologram::CanNudgeHologram() const{ return bool(); }
 void AFGHologram::LockHologramPosition(bool lock){ }
 void AFGHologram::SetNudgeOffset(const FVector& NewNudgeOffset){ }

Source/FactoryGame/Private/Resources/FGItemDescriptor.cpp

@@ -4,6 +4,7 @@
 #include "FGCategory.h"
 #include "FGItemCategory.h"
 #include "FGResourceSettings.h"
+#include "FactoryGame.h"
 
 EResourceForm UFGItemDescriptor::GetForm(TSubclassOf<UFGItemDescriptor> inClass) {
 	if (inClass)

Source/FactoryGame/Private/Settings/FGUserSettingApplyType.cpp

@@ -14,7 +14,7 @@ void UFGUserSettingApplyType::SetValue(FVariant newValue){ }
 void UFGUserSettingApplyType::ForceSetValue(FVariant newValue, bool bClearPendingValue){ }
 bool UFGUserSettingApplyType::ForceSetPendingAppliedValue(FVariant newValue){ return bool(); }
 void UFGUserSettingApplyType::OverrideDefaultValue(FVariant newDefaultValue){ }
-void UFGUserSettingApplyType::ResetToDefaultValue(){ }
+void UFGUserSettingApplyType::ResetToDefaultValue(bool bForce){ }
 void UFGUserSettingApplyType::ClearPendingChanges(){ }
 void UFGUserSettingApplyType::NotifySubscribers(){ }
 void UFGUserSettingApplyType::PurgeDeadSubscribers(){ }
@@ -39,7 +39,7 @@ bool UFGUserSettingApplyType_RequireGameRestart::OnApply(bool markDirty){ return
 void UFGUserSettingApplyType_RequireGameRestart::OnPreRestartGame(){ }
 void UFGUserSettingApplyType_RequireGameRestart::ForceSetValue(FVariant newValue, bool bClearPendingValue){ }
 bool UFGUserSettingApplyType_RequireGameRestart::ForceSetPendingAppliedValue(FVariant newValue){ return bool(); }
-void UFGUserSettingApplyType_RequireGameRestart::ResetToDefaultValue(){ }
+void UFGUserSettingApplyType_RequireGameRestart::ResetToDefaultValue(bool bForce){ }
 FVariant UFGUserSettingApplyType_RequireGameRestart::GetDisplayValue() const{ return FVariant(); }
 bool UFGUserSettingApplyType_RequireGameRestart::HasGameRestartRequiredChanges() const{ return bool(); }
 FVariant UFGUserSettingApplyType_RequireGameRestart::GetValueToSave() const{ return FVariant(); }
@@ -49,7 +49,7 @@ bool UFGUserSettingApplyType_RequireSessionRestart::OnApply(bool markDirty){ ret
 void UFGUserSettingApplyType_RequireSessionRestart::OnPreSessionRestart(){ }
 void UFGUserSettingApplyType_RequireSessionRestart::ForceSetValue(FVariant newValue, bool bClearPendingValue){ }
 bool UFGUserSettingApplyType_RequireSessionRestart::ForceSetPendingAppliedValue(FVariant newValue){ return bool(); }
-void UFGUserSettingApplyType_RequireSessionRestart::ResetToDefaultValue(){ }
+void UFGUserSettingApplyType_RequireSessionRestart::ResetToDefaultValue(bool bForce){ }
 FVariant UFGUserSettingApplyType_RequireSessionRestart::GetDisplayValue() const{ return FVariant(); }
 bool UFGUserSettingApplyType_RequireSessionRestart::HasSessionRestartRequiredChanges() const{ return bool(); }
 FVariant UFGUserSettingApplyType_RequireSessionRestart::GetValueToSave() const{ return FVariant(); }

Source/FactoryGame/Private/Tests/TestCases/FGGameplayTest_OnlineStats.cpp

@@ -0,0 +1,5 @@
+// This file has been manually implemented by Th3Fanbus
+
+#include "Tests/TestCases/FGGameplayTest_OnlineStats.h"
+
+void UFGGameplayTest_OnlineStats::OnTestStarted(){ Super::OnTestStarted(); }

Source/FactoryGame/Public/AI/FGAIPerceptionComponent.h

@@ -2,7 +2,6 @@
 
 #pragma once
 
-#include "FactoryGame.h"
 #include "CoreMinimal.h"
 #include "Perception/AIPerceptionComponent.h"
 #include "FGAIPerceptionComponent.generated.h"