Fix building with new headers

SML builds and launches fine. No further tests done yet.

Signed-off-by: Angel Pons <[email protected]>

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/Online/OnlineIntegration/OnlineIntegration.uplugin

@@ -83,7 +83,7 @@
 		},
 		{
 			"Name": "OnlineServicesSteamLimited",
-			"Enabled": true,
+			"Enabled": false,
 			"WhitelistPlatforms": [
 				"Win64",
 				"Linux"

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/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;
+}

Source/FactoryEditor.Target.cs

@@ -14,8 +14,8 @@ public FactoryEditorTarget( TargetInfo Target ) : base(Target)
 		ExtraModuleNames.AddRange(new string[] {
 			"FactoryPreEarlyLoadingScreen",
             "FactoryGame",
-            "FactoryEditor",
-			"FactoryUncookedOnly",
+            //"FactoryEditor",
+			//"FactoryUncookedOnly",
 			"FactoryDedicatedServer",
 			"FactoryDedicatedClient"
 		});

Source/FactoryGame/FactoryGame.Build.cs

@@ -90,11 +90,11 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 		else
 		{
 			// If the target is not a server we add upscaler modules to the PublicDependencyModuleNames
-			PublicDependencyModuleNames.AddRange( new string[] { 
-				"XeSSBlueprint",
-				"DLSSBlueprint",
-				"StreamlineBlueprint",
-			} );
+			// PublicDependencyModuleNames.AddRange( new string[] { 
+			// 	"XeSSBlueprint",
+			// 	"DLSSBlueprint",
+			// 	"StreamlineBlueprint",
+			// } );
 		}
 
 		// <FL> [PfaffN] EOS does not compile on PS5 or XSX, they are not compatible
@@ -103,8 +103,8 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 		// [ZolotukhinN:24/01/2024] Exclude EOSShared on dedicated server, it's not enabled as a plugin for the dedicated server so we cannot depend on it
 		if (Target.Type != TargetType.Server)
 		{
-			if (Target.Platform != UnrealTargetPlatform.PS5 &&
-			    Target.Platform != UnrealTargetPlatform.XSX)
+			if (/*Target.Platform != UnrealTargetPlatform.PS5 &&
+			    Target.Platform != UnrealTargetPlatform.XSX*/ true)
 			{
 				PublicDependencyModuleNames.AddRange(new string[] {
 					"OnlineSubsystemSteam",
@@ -118,7 +118,7 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 			}
 		}
 		// <FL> [WuttkeP] Additional dependencies that are required to run the game on XSX.
-		if (Target.Platform == UnrealTargetPlatform.XSX)
+		if (/*Target.Platform == UnrealTargetPlatform.XSX*/ false)
 		{
 			PublicDependencyModuleNames.AddRange(new string[]
 			{
@@ -134,14 +134,14 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 		if (Target.Configuration != UnrealTargetConfiguration.Shipping &&
 			Target.Type != TargetType.Server)
 		{
-			PrivateDependencyModuleNames.AddRange(new string[] {
-				"DebugUI",
-			});
+			// PrivateDependencyModuleNames.AddRange(new string[] {
+			// 	"DebugUI",
+			// });
 		}
 		// </FL>
 		// <FL> [PfaffN] TODO: PS5 does not compile with WITH_SHOWVAR, we disable it until
 		// we know if it is necessary for the build.
-		if (Target.Platform == UnrealTargetPlatform.PS5)
+		if (/*Target.Platform == UnrealTargetPlatform.PS5*/ false)
 		{
 			PrivateDefinitions.Add("WITH_SHOWVAR=0");
 		}
@@ -166,15 +166,15 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 		// Only depend on XESS and DLSS blueprint module for non-dedicated servers
 		if (Target.Type != TargetType.Server)
 		{
-			PrivateDependencyModuleNames.AddRange( new string[]
-			{
-				"XeSSBlueprint",
-				"DLSSBlueprint",
-				"StreamlineBlueprint",
-			} );
+			// PrivateDependencyModuleNames.AddRange( new string[]
+			// {
+			// 	"XeSSBlueprint",
+			// 	"DLSSBlueprint",
+			// 	"StreamlineBlueprint",
+			// } );
 		}
 
-		const bool withTelemetry = true;
+		const bool withTelemetry = false;
 		if ( withTelemetry )
 		{
 			PublicDependencyModuleNames.Add( "DSTelemetry" );
@@ -185,7 +185,7 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 			PrivateDefinitions.Add("WITH_TELEMETRY=0");
 		}
 
-		bool isPublicBuild = false;
+		bool isPublicBuild = true;
 		string isPublicBuildVersion = System.Environment.GetEnvironmentVariable("IS_PUBLIC_BUILD");
 		if( isPublicBuildVersion != null && isPublicBuildVersion.Length > 0 )
 		{
@@ -215,5 +215,9 @@ public FactoryGame( ReadOnlyTargetRules Target ) : base(Target)
 				"SourceControl", // <FL>
             } );
         }
+
+		PublicDependencyModuleNames.AddRange(new[] {
+			"DummyHeaders",
+		});
 	}
 }

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/FGAudioMeteringSubsystem.h

@@ -6,6 +6,7 @@
 #include "CoreMinimal.h"
 #include "Subsystems/GameInstanceSubsystem.h"
 #include "UObject/NoExportTypes.h"
+#include "AkMetering.h" // MODDING EDIT: Wwise changes
 #include "FGAudioMeteringSubsystem.generated.h"
 
 

Source/FactoryGame/Public/FGPlayerState.h

@@ -16,6 +16,8 @@
 #include "UI/Message/FGMessageBase.h"
 #include "FGPlayerState.generated.h"
 
+#undef GetUserName // MODDING EDIT: Wwise includes Windows.h which defines GetUserName as a macro
+
 class UFGPlayerHotbar;
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( FOnBuildableConstructedNew, TSubclassOf< class UFGItemDescriptor >, itemDesc );

Source/FactoryGame/Public/FGSoundSplineComponent.h

@@ -27,7 +27,7 @@ class FACTORYGAME_API UFGSoundSplineComponent : public UAkComponent
 	FORCEINLINE float GetEmitterInterval( float newEmitterInterval ) const { return mEmitterInterval; }
 
 	// Begin UAkComponent interface
-	virtual void UpdateGameObjectPosition() override;
+	virtual void UpdateGameObjectPosition(); // MODDING EDIT Wwise... override;
 	// End UAkComponent interface
 protected:
 	/** Distance between each emitter on our parent spline, this might be scaled slightly so that we get a point on both start and end */

Source/FactoryGameEGS.Target.cs

@@ -7,7 +7,7 @@ public class FactoryGameEGSTarget : FactoryGameTarget
 {
     public FactoryGameEGSTarget(TargetInfo Target) : base(Target)
     {
-	    CustomConfig = "EGS";
+	    // CustomConfig = "EGS"; // MODDING EDIT: Cannot deploy targets with conflicting CustomConfig values 
 	    GlobalDefinitions.Add("STOREFRONT_ID=epic");
 
 	    // Enable launcher checks for the game targets built for EGS

Source/FactoryGameSteam.Target.cs

@@ -7,7 +7,7 @@ public class FactoryGameSteamTarget : FactoryGameTarget
 {
     public FactoryGameSteamTarget(TargetInfo Target) : base(Target)
     {
-	    CustomConfig = "Steam";
+	    // CustomConfig = "Steam"; // MODDING EDIT: Cannot deploy targets with conflicting CustomConfig values
 	    GlobalDefinitions.Add("STOREFRONT_ID=steam");
     }
 }

Source/FactoryShared.Target.cs

@@ -9,7 +9,7 @@ public class FactorySharedTarget : TargetRules
 {
 	/** Allows overriding whenever the checks in the shipping builds should be used from the commandline */
 	[CommandLine("-UseChecksInShipping")]
-	public bool UseChecksInShippingOverride = false;
+	public bool UseChecksInShippingOverride = true; /* MODDING EDIT */
 
 	/** Allows overriding the build type from the command line */
 	[CommandLine("-Monolithic", Value = "Monolithic")]