Update headers to CL382498

Source/DummyHeaders/Public/Audio/AudioMeter/IAudioMeterImpl.h

@@ -0,0 +1,3 @@
+#pragma once
+
+class DUMMYHEADERS_API IAudioMeterImpl {};

Source/FactoryGame/Private/Audio/FGVoiceChatAudioMeterSubsystem.cpp

@@ -0,0 +1,8 @@
+#include "Audio/FGVoiceChatAudioMeterSubsystem.h"
+
+AFGVoiceChatAudioMeterSubsystem::AFGVoiceChatAudioMeterSubsystem(){ }
+void AFGVoiceChatAudioMeterSubsystem::BeginPlay(){ Super::BeginPlay(); }
+void AFGVoiceChatAudioMeterSubsystem::EndPlay(const EEndPlayReason::Type EndPlayReason){ Super::EndPlay(EndPlayReason); }
+void AFGVoiceChatAudioMeterSubsystem::Tick(float DeltaTime){ Super::Tick(DeltaTime); }
+void AFGVoiceChatAudioMeterSubsystem::ConvertPeakToRTPC(float peak, float DeltaTime){ }
+void AFGVoiceChatAudioMeterSubsystem::SetRTPC(float AudioMeterValue){ }

Source/FactoryGame/Private/AvailabilityDependencies/FGCalendarOpenedDependency.cpp

@@ -0,0 +1,7 @@
+#include "AvailabilityDependencies/FGCalendarOpenedDependency.h"
+
+bool UFGCalendarOpenedDependency::AreDependenciesMet( UObject* worldContext ) const{ return bool(); }
+#if WITH_EDITOR
+FString UFGCalendarOpenedDependency::ToString() const{ return FString(); }
+void UFGCalendarOpenedDependency::FromString( const FString& inString ){ }
+#endif

Source/FactoryGame/Private/AvailabilityDependencies/FGCalendarSlotUnlockedDependency.cpp

@@ -0,0 +1,8 @@
+#include "AvailabilityDependencies/FGCalendarSlotUnlockedDependency.h"
+
+UFGCalendarSlotUnlockedDependency::UFGCalendarSlotUnlockedDependency(){ }
+bool UFGCalendarSlotUnlockedDependency::AreDependenciesMet( UObject* worldContext ) const{ return bool(); }
+#if WITH_EDITOR
+FString UFGCalendarSlotUnlockedDependency::ToString() const{ return FString(); }
+void UFGCalendarSlotUnlockedDependency::FromString( const FString& inString ){ }
+#endif

Source/FactoryGame/Private/AvailabilityDependencies/FGEventDisabledDependency.cpp

@@ -0,0 +1,7 @@
+#include "AvailabilityDependencies/FGEventDisabledDependency.h"
+
+bool UFGEventDisabledDependency::AreDependenciesMet( UObject* worldContext ) const{ return bool(); }
+#if WITH_EDITOR
+FString UFGEventDisabledDependency::ToString() const{ return FString(); }
+void UFGEventDisabledDependency::FromString( const FString& inString ){ }
+#endif

Source/FactoryGame/Private/Buildables/FGBuildableCalendar.cpp

@@ -8,7 +8,6 @@ AFGBuildableCalendar::AFGBuildableCalendar() : Super() {
 	this->mInventory = CreateDefaultSubobject<UFGInventoryComponent>(TEXT("CalendarInventory"));
 	this->mPopulatedInitialInventory = false;
 	this->mNumberOfSlotsInCalendar = 25;
-	this->mCalendarRewardsClass = nullptr;
 	this->mSlotFillerItemClass = nullptr;
 	this->NetDormancy = ENetDormancy::DORM_Awake;
 }
@@ -20,6 +19,7 @@ void AFGBuildableCalendar::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>&
 	DOREPLIFETIME(AFGBuildableCalendar, mOpenedSlotsInCalendar);
 }
 void AFGBuildableCalendar::GetDismantleRefund_Implementation(TArray< FInventoryStack >& out_refund, bool noBuildCostEnabled) const{ }
+void AFGBuildableCalendar::OnUse_Implementation(class AFGCharacterPlayer* byCharacter, const FUseState& state) { }
 void AFGBuildableCalendar::OpenSlot(int32 dayNumber){ }
 bool AFGBuildableCalendar::GetContentOnSlot(int32 dayNumber, FInventoryStack& out_slotContent){ return bool(); }
 UFGUnlock* AFGBuildableCalendar::GetUnlockOnSlot(int32 dayNumber){ return nullptr; }

Source/FactoryGame/Private/Buildables/FGBuildableConveyorBelt.cpp

@@ -34,9 +34,12 @@ void AFGBuildableConveyorBelt::UpdateMeshLodLevels(int32 newLodLevel){ }
 TArray<FInstanceData> AFGBuildableConveyorBelt::GetActorLightweightInstanceData_Implementation(){ return TArray<FInstanceData>(); }
 int32 AFGBuildableConveyorBelt::GetDismantleRefundReturnsMultiplier() const{ return int32(); }
 void AFGBuildableConveyorBelt::OnBuildEffectFinished(){ }
+void AFGBuildableConveyorBelt::OnSkinCustomizationApplied_Implementation(TSubclassOf<class UFGFactoryCustomizationDescriptor_Skin> skin){ }
 float AFGBuildableConveyorBelt::FindOffsetClosestToLocation(const FVector& location) const{ return float(); }
 void AFGBuildableConveyorBelt::GetLocationAndDirectionAtOffset(float offset, FVector& out_location, FVector& out_direction) const{ }
 FVector AFGBuildableConveyorBelt::GetVelocityForBase( AActor* basedActor,  UPrimitiveComponent* baseComponent) const{ return FVector(); }
+TArray<FInstanceData> AFGBuildableConveyorBelt::SetupAbstractInstances(const FFactoryCustomizationData& CustomizationData) { return TArray<FInstanceData>(); }
+void AFGBuildableConveyorBelt::ApplyCustomizationData_Native(const FFactoryCustomizationData& customizationData){ }
 FVector AFGBuildableConveyorBelt::GetRefundSpawnLocationAndArea_Implementation(const FVector& aimHitLocation, float& out_radius) const{ return FVector(); }
 void AFGBuildableConveyorBelt::Upgrade_Implementation(AActor* newActor){ }
 void AFGBuildableConveyorBelt::CreateClearanceData( USplineComponent* splineComponent, const TArray< FSplinePointData >& splineData, const FTransform& conveyorTransform, TArray< FFGClearanceData >& out_clearanceData, float maxDistance){ }

Source/FactoryGame/Private/Buildables/FGBuildableGenerator.cpp

@@ -2,6 +2,10 @@
 
 #include "Buildables/FGBuildableGenerator.h"
 
+void UFGGeneratorClipboardRCO::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const{
+	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+}
+void UFGGeneratorClipboardRCO::Server_PasteSettings_Implementation(class AFGBuildableGenerator* generator, AFGCharacterPlayer* player, float overclock, float productionBoost, TSubclassOf<UFGPowerShardDescriptor> overclockingShard, TSubclassOf<UFGPowerShardDescriptor> productionBoostShard){ }
 AFGBuildableGenerator::AFGBuildableGenerator() : Super() {
 	this->mPowerProduction = 0.0;
 	this->mLoadPercentage = 0.0;
@@ -12,6 +16,9 @@ void AFGBuildableGenerator::GetConditionalReplicatedProps(TArray<FFGCondReplicat
 bool AFGBuildableGenerator::CanProduce_Implementation() const{ return bool(); }
 bool AFGBuildableGenerator::Factory_HasPower() const{ return bool(); }
 EProductionStatus AFGBuildableGenerator::GetProductionIndicatorStatus() const{ return EProductionStatus(); }
+bool AFGBuildableGenerator::CanUseFactoryClipboard_Implementation() { return bool(); }
+UFGFactoryClipboardSettings* AFGBuildableGenerator::CopySettings_Implementation(){ return nullptr; }
+bool AFGBuildableGenerator::PasteSettings_Implementation(UFGFactoryClipboardSettings* settings){ return bool(); }
 float AFGBuildableGenerator::GetPowerProductionCapacity() const{ return float(); }
 float AFGBuildableGenerator::GetDefaultPowerProductionCapacity() const{ return float(); }
 float AFGBuildableGenerator::CalcPowerProductionCapacityForPotential(float potential) const{ return float(); }

Source/FactoryGame/Private/Buildables/FGBuildablePipeBase.cpp

@@ -32,6 +32,8 @@ int32 AFGBuildablePipeBase::GetDismantleRefundReturnsMultiplier() const{ return
 bool AFGBuildablePipeBase::ShouldBeConsideredForBase_Implementation(){ return bool(); }
 void AFGBuildablePipeBase::GetClearanceData_Implementation(TArray< FFGClearanceData >& out_data) const{ }
 bool AFGBuildablePipeBase::ShouldBlockGuidelinePathForHologram(const  AFGHologram* hologram) const{ return bool(); }
+void AFGBuildablePipeBase::OnSkinCustomizationApplied_Implementation(TSubclassOf<UFGFactoryCustomizationDescriptor_Skin> skin){ }
+void AFGBuildablePipeBase::ApplyCustomizationData_Native(const FFactoryCustomizationData& customizationData){ }
 void AFGBuildablePipeBase::Upgrade_Implementation(AActor* newActor){ }
 void AFGBuildablePipeBase::Dismantle_Implementation(){ }
 TArray<FInstanceData> AFGBuildablePipeBase::GetActorLightweightInstanceData_Implementation(){ return TArray<FInstanceData>(); }
@@ -43,6 +45,7 @@ void AFGBuildablePipeBase::SetupForSignificance(){ }
 float AFGBuildablePipeBase::GetSignificanceRange(){ return float(); }
 float AFGBuildablePipeBase::FindOffsetClosestToLocation(const FVector& location) const{ return float(); }
 void AFGBuildablePipeBase::GetLocationAndDirectionAtOffset(float offset, FVector& out_location, FVector& out_direction) const{ }
+TArray<FInstanceData> AFGBuildablePipeBase::SetupAbstractInstances(const FFactoryCustomizationData& CustomizationData){ return TArray<FInstanceData>(); }
 UFGConnectionComponent* AFGBuildablePipeBase::GetSplineConnection0() const{ return nullptr; }
 UFGConnectionComponent* AFGBuildablePipeBase::GetSplineConnection1() const{ return nullptr; }
 void AFGBuildablePipeBase::CreateClearanceData( USplineComponent* splineComponent, const TArray< FSplinePointData >& splineData, const FTransform& pipeTransform, TArray< FFGClearanceData >& out_clearanceData, float maxDistance){ }

Source/FactoryGame/Private/Buildables/FGBuildablePipeline.cpp

@@ -52,6 +52,7 @@ void AFGBuildablePipeline::GetLifetimeReplicatedProps(TArray< FLifetimeProperty
 void AFGBuildablePipeline::BeginPlay(){ Super::BeginPlay(); }
 void AFGBuildablePipeline::EndPlay(const EEndPlayReason::Type endPlayReason){ Super::EndPlay(endPlayReason); }
 void AFGBuildablePipeline::Factory_Tick(float dt){ }
+bool AFGBuildablePipeline::ShouldRegisterToFactoryTickGroup() const { return bool(); }
 void AFGBuildablePipeline::PreUpgrade_Implementation(){ }
 void AFGBuildablePipeline::Upgrade_Implementation(AActor* newActor){ }
 void AFGBuildablePipeline::GainedSignificance_Implementation(){ }

Source/FactoryGame/Private/Buildables/FGBuildableResourceExtractorBase.cpp

@@ -5,6 +5,10 @@
 #include "Hologram/FGResourceExtractorHologram.h"
 #include "Net/UnrealNetwork.h"
 
+void UFGResourceExtractorClipboardRCO::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+}
+void UFGResourceExtractorClipboardRCO::Server_PasteSettings_Implementation(class AFGBuildableResourceExtractorBase* extractor, AFGCharacterPlayer* player, float overclock, float productionBoost, TSubclassOf<UFGPowerShardDescriptor> overclockingShard, TSubclassOf<UFGPowerShardDescriptor> productionBoostShard){ }
 int AFGBuildableResourceExtractorBase::GetDebugLevel(){ return int(); }
 void AFGBuildableResourceExtractorBase::SetDebugLevel(int level){ }
 void AFGBuildableResourceExtractorBase::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const {
@@ -27,6 +31,8 @@ void AFGBuildableResourceExtractorBase::BeginPlay(){ Super::BeginPlay(); }
 void AFGBuildableResourceExtractorBase::Destroyed(){ Super::Destroyed(); }
 bool AFGBuildableResourceExtractorBase::DisconnectExtractableResource(){ return bool(); }
 void AFGBuildableResourceExtractorBase::PostLoadGame_Implementation(int32 saveVersion, int32 gameVersion){ }
+UFGFactoryClipboardSettings* AFGBuildableResourceExtractorBase::CopySettings_Implementation(){ return nullptr; }
+bool AFGBuildableResourceExtractorBase::PasteSettings_Implementation(UFGFactoryClipboardSettings* settings) { return bool(); }
 void AFGBuildableResourceExtractorBase::SetExtractableResource(TScriptInterface< IFGExtractableResourceInterface > extractableInterface){ }
 void AFGBuildableResourceExtractorBase::SetResourceNode( AFGResourceNode* resourceNode){ }
 UFXSystemAsset* AFGBuildableResourceExtractorBase::GetMiningParticle(){ return nullptr; }

Source/FactoryGame/Private/Buildables/FGBuildableSnowCannon.cpp

@@ -0,0 +1,9 @@
+#include "Buildables/FGBuildableSnowCannon.h"
+
+AFGBuildableSnowCannon::AFGBuildableSnowCannon(){ }
+void AFGBuildableSnowCannon::BeginPlay(){ Super::BeginPlay(); }
+void AFGBuildableSnowCannon::EndPlay(const EEndPlayReason::Type EndPlayReason){ Super::EndPlay(EndPlayReason); }
+void AFGBuildableSnowCannon::GainedSignificance_Implementation(){ }
+void AFGBuildableSnowCannon::LostSignificance_Implementation(){ }
+void AFGBuildableSnowCannon::SetCannonAngle(int32 angle){ }
+void AFGBuildableSnowCannon::UpdateCannonMesh(){ }

Source/FactoryGame/Private/Creature/FGCreatureSpawner.cpp

@@ -40,6 +40,9 @@ AFGCreatureSpawner::AFGCreatureSpawner() : Super() {
 void AFGCreatureSpawner::BeginPlay(){ Super::BeginPlay(); }
 void AFGCreatureSpawner::EndPlay(const EEndPlayReason::Type endPlayReason){ Super::EndPlay(endPlayReason); }
 void AFGCreatureSpawner::Tick(float DeltaSeconds){ Super::Tick(DeltaSeconds); }
+#if WITH_EDITOR
+void AFGCreatureSpawner::GetActorDescProperties(FPropertyPairsMap& PropertyPairsMap) const{ }
+#endif
 void AFGCreatureSpawner::PreSaveGame_Implementation(int32 saveVersion, int32 gameVersion){ }
 void AFGCreatureSpawner::PostSaveGame_Implementation(int32 saveVersion, int32 gameVersion){ }
 void AFGCreatureSpawner::PreLoadGame_Implementation(int32 saveVersion, int32 gameVersion){ }
@@ -64,7 +67,8 @@ bool AFGCreatureSpawner::IsTimeForCreature() const{ return bool(); }
 void AFGCreatureSpawner::CreatureDied(AActor* thisActor){ }
 bool AFGCreatureSpawner::PopulateSpawnData(){ return bool(); }
 float AFGCreatureSpawner::GetSpawnDistance() const{ return float(); }
-void AFGCreatureSpawner::UpdateScannableState(){ }
 void AFGCreatureSpawner::TryRecoupleCreatureAndSpawner(){ }
 void AFGCreatureSpawner::RegisterAsNavigationInvoker(bool shouldRegister){ }
 void AFGCreatureSpawner::TraceForNearbyBase(){ }
+
+const FName AFGCreatureSpawner::CreatureClassPropertyName = FName();

Source/FactoryGame/Private/Equipment/FGBuildGunPaint.cpp

@@ -36,6 +36,8 @@ void UFGBuildGunStatePaint::CreateStencilProxy(AActor* selected){ }
 void UFGBuildGunStatePaint::DestroyStencilProxies(bool destroyComponents){ }
 void UFGBuildGunStatePaint::Server_ExecutePrimaryFire_Implementation(){ }
 void UFGBuildGunStatePaint::Server_ExecutePaint_Implementation(uint8 mode, FFactoryCustomizationData customizationData, AActor* hitActor){ }
+void UFGBuildGunStatePaint::Server_SetActiveRecipe_Implementation(TSubclassOf<UFGCustomizationRecipe> customizationRecipe){ }
+void UFGBuildGunStatePaint::Server_SetCustomizeClassFilter_Implementation(TSubclassOf<AActor> actorToFilter){ }
 void UFGBuildGunStatePaint::SetActiveCustomization(TSubclassOf< UFGFactoryCustomizationDescriptor > customizationDesc){ }
 void UFGBuildGunStatePaint::SetActiveSwatchDesc(TSubclassOf< UFGFactoryCustomizationDescriptor_Swatch > swatchDesc){ }
 void UFGBuildGunStatePaint::SetActivePatternDesc(TSubclassOf< UFGFactoryCustomizationDescriptor_Pattern > patternDesc){ }
@@ -45,6 +47,7 @@ void UFGBuildGunStatePaint::RemoveCustomization(TSubclassOf< UFGFactoryCustomiza
 void UFGBuildGunStatePaint::ClearAllCustomizations(){ }
 void UFGBuildGunStatePaint::SetActiveRecipe(TSubclassOf< UFGCustomizationRecipe > customizationRecipe){ }
 void UFGBuildGunStatePaint::SetCustomizeClassFilter(AActor* actorToFilter){ }
+void UFGBuildGunStatePaint::SetCustomizeClassFilter_Internal(TSubclassOf<AActor> actorClass, TSubclassOf<UFGItemDescriptor> itemDesc){ }
 bool UFGBuildGunStatePaint::IsCustomizationActive(TSubclassOf< UFGFactoryCustomizationDescriptor > customization){ return bool(); }
 bool UFGBuildGunStatePaint::IsRecipeActive(TSubclassOf<  UFGCustomizationRecipe > inClass){ return bool(); }
 TArray< FItemAmount > UFGBuildGunStatePaint::GetCustomizationCost() const{ return TArray<FItemAmount>(); }

Source/FactoryGame/Private/Equipment/FGWeapon.cpp

@@ -56,6 +56,7 @@ bool AFGWeapon::CanReload() const{ return bool(); }
 float AFGWeapon::GetReloadTimeLeft() const{ return float(); }
 FVector AFGWeapon::GetWeaponMeshSocketLocation_Implementation(FName socketName) const{ return FVector(); }
 void AFGWeapon::Server_CycleDesiredAmmunitionType_Implementation(){ }
+class UAnimSequence* AFGWeapon::GetNobeliskWeaponIdleAnimationOverride() const{ return nullptr; }
 void AFGWeapon::CycleDesiredAmmunitionType(){ }
 void AFGWeapon::Server_SetDesiredAmmoClass_Implementation(TSubclassOf< UFGAmmoType > newDesiredAmmoClass){ }
 void AFGWeapon::SetDesiredAmmoClass(TSubclassOf< UFGAmmoType > newDesiredAmmoClass){ }

Source/FactoryGame/Private/FGBuildableSubsystem.cpp

@@ -106,6 +106,7 @@ bool AFGBuildableSubsystem::RemoveConveyorFromBucket(AFGBuildableConveyorBase* c
 void AFGBuildableSubsystem::RearrangeConveyorBuckets(int32 emptiedBucketID){ }
 void AFGBuildableSubsystem::RemoveAndSplitConveyorBucket(AFGBuildableConveyorBase* conveyorToRemove){ }
 bool AFGBuildableSubsystem::IsServerSubSystem() const{ return bool(); }
+int32 AFGBuildableSubsystem::GetBuildableCount(TSubclassOf<AFGBuildable> buildableClass) const{ return int32(); }
 void AFGBuildableSubsystem::GetTypedBuildable(TSubclassOf<  AFGBuildable > inClass, TArray<  AFGBuildable* >& out_buildables) const{ }
 void AFGBuildableSubsystem::GetOcclusionAffectingBuildebles(TArray<AFGBuildable*>& Out, const FVector& RequestLocation, float Range, bool bParallel) const{ }
 void AFGBuildableSubsystem::GetNearestBuildables(TArray<AFGBuildable*>& Out, const FVector& RequestLocation, float Range) const{ }

Source/FactoryGame/Private/FGCharacterPlayer.cpp

@@ -544,6 +544,8 @@ void AFGCharacterPlayer::FadeDamageIndicator(float deltaTime){ }
 void AFGCharacterPlayer::TickFlashlight(){ }
 void AFGCharacterPlayer::RadiationIntensityUpdated(){ }
 bool AFGCharacterPlayer::IsPlayerInOrAboveWater(const FVector& hitPosition) const{ return bool(); }
+void AFGCharacterPlayer::ActivateCameraComponents(){ }
+void AFGCharacterPlayer::DeactivateCameraComponents(){ }
 void AFGCharacterPlayer::OnActiveEquipmentChangedInSlot(EEquipmentSlot slot){ }
 FOnPersistentEquipmentActivated AFGCharacterPlayer::OnPersistentEquipmentActivated = FOnPersistentEquipmentActivated();
 FOnEquipmentEquipped AFGCharacterPlayer::OnEquipmentEquipped = FOnEquipmentEquipped();

Source/FactoryGame/Private/FGCheatManager.cpp

@@ -80,6 +80,8 @@ void UFGCheatManager::RunGameplayTest(TSubclassOf<class UFGGameplayTest> gamepla
 void UFGCheatManager::Server_RunGameplayTest_Implementation(TSubclassOf<class UFGGameplayTest> gameplayTest){ }
 void UFGCheatManager::Server_SetSAMIntensity_Implementation(int32 newSAMIntensity){ }
 void UFGCheatManager::SetSAMIntensity(int32 newSAMIntensity){ }
+void UFGCheatManager::SpawnFallingGiftBundle(){ }
+void UFGCheatManager::Server_SpawnFallingGiftBundle_Implementation(){ }
 void UFGCheatManager::Server_Creature_CanAttackEachother_Implementation(bool canAttack){ }
 void UFGCheatManager::Creature_CanAttackEachother(bool canAttack){ }
 void UFGCheatManager::Creature_SetStressEnabled(bool enable){ }

Source/FactoryGame/Private/FGConveyorChainSubsystem.cpp

@@ -49,3 +49,5 @@ void AFGConveyorChainSubsystem::OnRep_ServerFactoryTickTime(float oldValue){ }
 float AFGConveyorChainSubsystem::GetAndConsumeClientTimeDebt(float updateDelta){ return float(); }
 float AFGConveyorChainSubsystem::GetAverageServerTickDeltaTime(){ return float(); }
 bool AFGConveyorChainSubsystem::IsUnusuallyLargeTickDelta(){ return bool(); }
+
+FGetAdditionalConveyorItemDescriptors AFGConveyorChainSubsystem::GetAdditionalItemDescriptors;

Source/FactoryGame/Private/FGCreatureSubsystem.cpp

@@ -33,7 +33,7 @@ TSubclassOf< class UFGNoise > AFGCreatureSubsystem::GetNoiseClassFromFName(const
 TSubclassOf< class UFGNoise > AFGCreatureSubsystem::GetNoiseClassFromStimulus(const  FAIStimulus& stimulus) const{ return TSubclassOf<class UFGNoise>(); }
 void AFGCreatureSubsystem::AddCreatureClassOverride(TSubclassOf< AFGCreature > classToReplace, TSubclassOf< AFGCreature > overrideClass, ECreatureReplaceAction replaceAction){ }
 void AFGCreatureSubsystem::AddCreatureClassOverride(const FCreatureClassOverride& creatureOverride, ECreatureReplaceAction replaceAction){ }
-void AFGCreatureSubsystem::RemoveCreatureClassOverride(TSubclassOf< AFGCreature > creatureClass, bool updateScannableState){ }
+void AFGCreatureSubsystem::RemoveCreatureClassOverride(TSubclassOf< AFGCreature > creatureClass){ }
 AFGCreature* AFGCreatureSubsystem::BeginSpawningCreature(TSubclassOf< AFGCreature > creatureClass, const FTransform& spawnTransform){ return nullptr; }
 void AFGCreatureSubsystem::SetArachnidCreaturesDisabled(bool disabled, ECreatureReplaceAction replaceAction){ }
 TSubclassOf< AFGCreature > AFGCreatureSubsystem::GetOverriddenCreatureClass(TSubclassOf< AFGCreature > creatureClass) const{ return TSubclassOf<AFGCreature>(); }

Source/FactoryGame/Private/FGDynamicStruct.cpp

@@ -75,6 +75,7 @@ bool FFGDynamicStruct::Serialize( FArchive& Ar )
     }
     return true;
 }
+bool FFGDynamicStruct::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess){ return bool(); }
 
 FFGDynamicStruct::FFGDynamicStruct(){ }
 FFGDynamicStruct::FFGDynamicStruct(const FFGDynamicStruct& other){ }