Update headers to CL368883

Source/FactoryGame/Private/Buildables/FGBuildableGeneratorFuel.cpp

@@ -52,4 +52,4 @@ bool AFGBuildableGeneratorFuel::CanLoadFuel() const{ return bool(); }
 bool AFGBuildableGeneratorFuel::CanLoadSupplemental() const{ return bool(); }
 bool AFGBuildableGeneratorFuel::FilterFuelClasses(TSubclassOf< UObject > object, int32 idx) const{ return bool(); }
 void AFGBuildableGeneratorFuel::UpdateInInventoryFuelTypes(const UFGInventoryComponent* instigatorInventory){ }
-void AFGBuildableGeneratorFuel::UpdateUnlockedFuelTypes(){ }
+TArray< TSubclassOf< UFGItemDescriptor > > AFGBuildableGeneratorFuel::UpdateUnlockedFuelTypes(){ return TArray< TSubclassOf< UFGItemDescriptor > >(); }

Source/FactoryGame/Private/Equipment/FGObjectScanner.cpp

@@ -12,7 +12,6 @@ AFGObjectScanner::AFGObjectScanner() : Super() {
 	this->mBeepDelayMin = 0.2;
 	this->mDetectionRange = 500.0;
 	this->mUpdateClosestObjectTime = 2.0;
-	this->mClosestObject = nullptr;
 	this->mClosestObjectInScanRange = false;
 	this->mNormalizedDistanceToClosestObject = 0.0;
 	this->mAngleToClosestObject = 0.0;
@@ -51,6 +50,8 @@ void AFGObjectScanner::OpenScannerInteractUI(){ }
 void AFGObjectScanner::ForceCloseScannerInteractUI(){ }
 void AFGObjectScanner::Input_OpenMenu(const FInputActionValue& actionValue){ }
 void AFGObjectScanner::Input_Cycle(const FInputActionValue& actionValue){ }
+AActor* AFGObjectScanner::GetClosestObjectIfLoaded() const { return nullptr; }
+FVector AFGObjectScanner::GetClosestObjectLocation() const { return FVector(); }
 void AFGObjectScanner::Server_SetScannableDescriptor_Implementation(TSubclassOf<UFGItemDescriptor> newScannableDescriptor, EFGScannerCycleDirection cycleDirection, bool shouldPlayAnimation){ }
 void AFGObjectScanner::Multicast_PlayCycleAnimation_Implementation(EFGScannerCycleDirection cycleDirection){ }
 void AFGObjectScanner::Multicast_PlayBeepAnimation_Implementation(){ }

Source/FactoryGame/Private/FGCircuitSubsystem.cpp

@@ -61,5 +61,5 @@ void AFGCircuitSubsystem::RebuildCircuitGroups(){ }
 void AFGCircuitSubsystem::RebuildCircuit(int32 circuitID){ }
 void AFGCircuitSubsystem::AddComponentToCircuit( UFGCircuitConnectionComponent* component, int32 circuitID, bool rebuildTrivialCircuits){ }
 void AFGCircuitSubsystem::RemoveComponentFromCircuit( UFGCircuitConnectionComponent* component){ }
-void AFGCircuitSubsystem::OnPowerCircuitStable( UFGPowerCircuit* circuit,  AFGPlayerController* fuseResetInstigator){ }
+void AFGCircuitSubsystem::OnPowerCircuitStable( AFGPlayerController* fuseResetInstigator ) const{ }
 void AFGCircuitSubsystem::RemovePowerCircuitStabilityData(int32 circuitID){ }

Source/FactoryGame/Private/FGConveyorItemSubSystem.cpp

@@ -22,9 +22,13 @@ AFGConveyorItemSubsystem::AFGConveyorItemSubsystem() : Super() {
 }
 AFGConveyorItemSubsystem* AFGConveyorItemSubsystem::Get(UWorld* world){ return nullptr; }
 void AFGConveyorItemSubsystem::LazyAddConveyorItemOfClass(UClass* Descriptor){ }
+void AFGConveyorItemSubsystem::AddLookupTable(AFGConveyorChainActor* Actor, const TArray<FVector3f>& Position, const TArray<FQuat4f>& Quats){ }
+void AFGConveyorItemSubsystem::RemoveChainActorFromLookupTable(AFGConveyorChainActor* ChainActor){ }
 void AFGConveyorItemSubsystem::Tick(float DeltaSeconds){ }
 void AFGConveyorItemSubsystem::BeginPlay(){ }
 void AFGConveyorItemSubsystem::EndPlay(const EEndPlayReason::Type EndPlayReason){ }
 void AFGConveyorItemSubsystem::InitializeConveyorItems(){ }
 void AFGConveyorItemSubsystem::Update(){ }
+void AFGConveyorItemSubsystem::CleanupLookupTables(){ }
+void AFGConveyorItemSubsystem::AddNewLookupTables(){ }
 bool AFGConveyorItemSubsystem::mIsConveyorRendererActive = bool();

Source/FactoryGame/Private/FGDroneVehicle.cpp

@@ -145,13 +145,15 @@ void FDroneAction_TraversePath::Begin(){ }
 void FDroneAction_TraversePath::End(){ }
 void FDroneAction_TraversePath::ReceiveActionEvent(EDroneActionEvent ActionEvent, void* EventData){ }
 bool FDroneAction_TraversePath::IsDone() const{ return bool(); }
+void FDroneAction_TraversePath::PostLoadGame(int32 saveVersion){ }
 void FDroneAction_TraversePath::OnDestinationReached(){ }
 FDroneAction_MoveToLocation::FDroneAction_MoveToLocation(){ }
 FDroneAction_MoveToLocation::FDroneAction_MoveToLocation(AFGDroneVehicle* drone, const FVector& location, EDroneFlyingMode flyingMode, const FVector& directionToFace , EDroneDirectionFacingIstruction directionFacingInstruction){ }
 void FDroneAction_MoveToLocation::Begin(){ }
 void FDroneAction_MoveToLocation::End(){ }
 void FDroneAction_MoveToLocation::ReceiveActionEvent(EDroneActionEvent ActionEvent, void* EventData){ }
 bool FDroneAction_MoveToLocation::IsDone() const{ return bool(); }
+void FDroneAction_MoveToLocation::PostLoadGame(int32 saveVersion){ }
 void FDroneAction_MoveToLocation::OnDestinationReached(){ }
 #if !UE_BUILD_SHIPPING
 void FDroneAction_RequestDocking::ShowDebug(FString& out_concatDebugString){ }
@@ -186,3 +188,4 @@ FDroneAction_TravelStartSequence::FDroneAction_TravelStartSequence(AFGDroneVehic
 void FDroneAction_TravelStartSequence::Begin(){ }
 void FDroneAction_TravelStartSequence::End(){ }
 float FDroneAction_TravelStartSequence::GetActionDuration() const{ return float(); }
+void FDroneAction_TravelStartSequence::PostLoadGame(int32 saveVersion){ }

Source/FactoryGame/Private/FGDropPod.cpp

@@ -6,6 +6,7 @@
 #include "FGPowerConnectionComponent.h"
 #include "FGPowerInfoComponent.h"
 #include "Net/UnrealNetwork.h"
+#include "UObject/ObjectSaveContext.h"
 
 #if WITH_EDITOR
 void AFGDropPod::PostLoad(){ Super::PostLoad(); }
@@ -47,6 +48,7 @@ void AFGDropPod::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifeti
 }
 void AFGDropPod::BeginPlay(){ }
 void AFGDropPod::EndPlay(const EEndPlayReason::Type endPlayReason){ }
+void AFGDropPod::PreSave(FObjectPreSaveContext SaveContext){ Super::PreSave(SaveContext); }
 void AFGDropPod::GainedSignificance_Implementation(){ }
 void AFGDropPod::LostSignificance_Implementation(){ }
 void AFGDropPod::GetConditionalReplicatedProps(TArray<FFGCondReplicatedProperty>& outProps) const{ }

Source/FactoryGame/Private/FGItemPickup.cpp

@@ -2,6 +2,7 @@
 
 #include "FGItemPickup.h"
 #include "Net/UnrealNetwork.h"
+#include "UObject/ObjectSaveContext.h"
 
 AFGItemPickup::AFGItemPickup() : Super() {
 	this->mSignificanceRange = 5000.0;
@@ -29,6 +30,7 @@ void AFGItemPickup::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLif
 void AFGItemPickup::Serialize(FArchive& ar){ Super::Serialize(ar); }
 void AFGItemPickup::BeginPlay(){ }
 void AFGItemPickup::EndPlay(const EEndPlayReason::Type EndPlayReason){ }
+void AFGItemPickup::PreSave(FObjectPreSaveContext SaveContext){ Super::PreSave(SaveContext); }
 void AFGItemPickup::PreSaveGame_Implementation(int32 saveVersion, int32 gameVersion){ }
 void AFGItemPickup::PostSaveGame_Implementation(int32 saveVersion, int32 gameVersion){ }
 void AFGItemPickup::PreLoadGame_Implementation(int32 saveVersion, int32 gameVersion){ }

Source/FactoryGame/Private/FGLightweightBuildableSubsystem.cpp

@@ -24,13 +24,15 @@ void UFGLightweightBuildableRemovalBundle::GetLifetimeReplicatedProps(TArray<FLi
 	DOREPLIFETIME(UFGLightweightBuildableRemovalBundle, mFullSize);
 }
 void UFGLightweightBuildableRemovalBundle::PostInitProperties(){ Super::PostInitProperties(); }
+void UFGLightweightBuildableRemovalBundle::OnRep_BuildableClass() { }
 void UFGLightweightCustomizationBundle::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
 	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 	DOREPLIFETIME(UFGLightweightCustomizationBundle, mLightweightCustomizationArray);
 	DOREPLIFETIME(UFGLightweightCustomizationBundle, mBuildableClass);
 	DOREPLIFETIME(UFGLightweightCustomizationBundle, mFullSize);
 }
 void UFGLightweightCustomizationBundle::PostInitProperties(){ Super::PostInitProperties(); }
+void UFGLightweightCustomizationBundle::OnRep_BuildableClass(){ }
 AFGLightweightBuildableRepProxy::AFGLightweightBuildableRepProxy() : Super() {
 	this->PrimaryActorTick.TickGroup = ETickingGroup::TG_PrePhysics;
 	this->PrimaryActorTick.EndTickGroup = ETickingGroup::TG_PrePhysics;
@@ -63,8 +65,8 @@ void AFGLightweightBuildableRepProxy::Server_NotifyBundleBunchReceived_Implement
 void AFGLightweightBuildableRepProxy::Server_NotifyBundleInitialRepReceived_Implementation(UFGLightweightBuildableConstructionBundle* bundle){ }
 void AFGLightweightBuildableRepProxy::NotifyConstructBundleInitialRepReceived(UFGLightweightBuildableConstructionBundle* bundle){ }
 void AFGLightweightBuildableRepProxy::Client_SendConstructionBundle_Implementation(UFGLightweightBuildableConstructionBundle* bundle, const TArray< FLightweightBuildableReplicationItem >& Items){ }
-void AFGLightweightBuildableRepProxy::Server_NotifyRemovalBundleReplicated_Implementation(UFGLightweightBuildableRemovalBundle* removalBundle){ }
-void AFGLightweightBuildableRepProxy::Server_NotifyCustomizationBundleReplicated_Implementation(UFGLightweightCustomizationBundle* customizationBundle){ }
+void AFGLightweightBuildableRepProxy::Server_NotifyRemovalBundleReplicated_Implementation(int32 clientCount, UFGLightweightBuildableRemovalBundle* removalBundle){ }
+void AFGLightweightBuildableRepProxy::Server_NotifyCustomizationBundleReplicated_Implementation(int32 clientCount, UFGLightweightCustomizationBundle* customizationBundle){ }
 AFGLightweightBuildableSubsystem::AFGLightweightBuildableSubsystem() : Super() {
 	this->mCachedLocalRepProxy = nullptr;
 	this->mBuildEffectComponentActor = nullptr;

Source/FactoryGame/Private/FGPlayerController.cpp

@@ -29,7 +29,6 @@ AFGPlayerController::AFGPlayerController() : Super() {
 	this->mSpeedToReachForAchievement = 4166.67;
 	this->mIsRespawning = false;
 	this->mCachedMapAreaTexture = nullptr;
-	this->mInTutorialMode = false;
 	this->mRespawnFromDeath = false;
 	this->mRespawnFromJoin = false;
 	this->mMinPhotoModeFOV = 5;
@@ -45,7 +44,6 @@ void AFGPlayerController::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>&
 	DOREPLIFETIME(AFGPlayerController, mLightweightBuildableRepProxy);
 	DOREPLIFETIME(AFGPlayerController, mRemoteCallObjects);
 	DOREPLIFETIME(AFGPlayerController, mIsRespawning);
-	DOREPLIFETIME(AFGPlayerController, mInTutorialMode);
 	DOREPLIFETIME(AFGPlayerController, mDedicatedServerPrivilegeLevel);
 }
 void AFGPlayerController::PostInitializeComponents(){ Super::PostInitializeComponents(); }
@@ -117,6 +115,7 @@ void AFGPlayerController::ClientPlayCameraAnimationSequence_Implementation( UCam
 float AFGPlayerController::GetObjectScreenRadius(AActor* actor, float boundingRadius){ return float(); }
 float AFGPlayerController::GetScreenBasedObjectRadius(AActor* actor, float screenRadius){ return float(); }
 void AFGPlayerController::SetDisabledInputGate(FDisabledInputGate newDisabledInputGate){ }
+bool AFGPlayerController::IsInTutorialMode(){ return bool() ;}
 void AFGPlayerController::Client_NotifyHitFeedback_Implementation(EHitFeedbackType feedbackType, AActor* damageCauser, AFGCharacterBase* hitCharacter){ }
 void AFGPlayerController::Client_SendChatMessage_Implementation(const FChatMessageStruct& chatMessage){ }
 FString AFGPlayerController::GetScreenshotPath(bool isHighRes){ return FString(); }

Source/FactoryGame/Private/FGPlayerState.cpp

@@ -128,6 +128,8 @@ void AFGPlayerState::PostLoadGame_Implementation(int32 saveVersion, int32 gameVe
 void AFGPlayerState::GatherDependencies_Implementation(TArray< UObject* >& out_dependentObjects){ }
 bool AFGPlayerState::NeedTransform_Implementation(){ return bool(); }
 bool AFGPlayerState::ShouldSave_Implementation() const{ return bool(); }
+void AFGPlayerState::RegisterPlayerWithSessionRemote(bool bWasFromInvite){ }
+void AFGPlayerState::RegisterPlayerWithSessionAuthoritative(bool bWasFromInvite){ }
 void AFGPlayerState::SetPlayerColorData(FPlayerColorData slotData){ }
 void AFGPlayerState::SetCreatureHostility(EPlayerHostilityMode hostility){ }
 void AFGPlayerState::Server_SetCreatureHostility_Implementation(EPlayerHostilityMode hostility){ }

Source/FactoryGame/Private/FGScannableDetails.cpp

@@ -5,8 +5,11 @@
 bool FScannableObjectData::operator ==(const FScannableObjectData& other) const{ return bool(); }
 bool FScannableObjectData::operator !=(const FScannableObjectData& other) const{ return bool(); }
 bool FScannableDetails::HasRequiredSchematic() const{ return bool(); }
+FScannableActorDetails::FScannableActorDetails(AActor* actor){ }
+FScannableActorDetails::FScannableActorDetails(const struct FWorldScannableData& scannableData) { }
+FVector FScannableActorDetails::GetActorLocation() const { return FVector(); }
 TSubclassOf< class UFGSchematic > FScannableDetails::GetRequiredSchematic() const{ return TSubclassOf<class UFGSchematic>(); }
-AActor* UFGScannableDetails::FindClosestRelevantActor( UWorld* world, const FVector& scanLocation, const float maxRangeSquare, TSubclassOf<AActor> actorClassToScanFor) const{ return nullptr; }
-AActor* UFGScannableDetailsHostileCreature::FindClosestRelevantActor(UWorld* world, const FVector& scanLocation, const float maxRangeSquared, TSubclassOf<AActor> actorClassToScanFor) const{ return nullptr; }
-AActor* UFGScannableDetailsRegrowingPickups::FindClosestRelevantActor(UWorld* world, const FVector& scanLocation, const float maxRangeSquared, TSubclassOf<AActor> actorClassToScanFor) const{ return nullptr; }
-AActor* UFGScannableDetailsHarddrive::FindClosestRelevantActor(UWorld* world, const FVector& scanLocation, const float maxRangeSquared, TSubclassOf<AActor> actorClassToScanFor) const{ return nullptr; }
+FScannableActorDetails UFGScannableDetails::FindClosestRelevantActor( UWorld* world, const FVector& scanLocation, const float maxRangeSquare, TSubclassOf<AActor> actorClassToScanFor) const{ return FScannableActorDetails(); }
+FScannableActorDetails UFGScannableDetailsHostileCreature::FindClosestRelevantActor(UWorld* world, const FVector& scanLocation, const float maxRangeSquared, TSubclassOf<AActor> actorClassToScanFor) const{ return FScannableActorDetails(); }
+FScannableActorDetails UFGScannableDetailsRegrowingPickups::FindClosestRelevantActor(UWorld* world, const FVector& scanLocation, const float maxRangeSquared, TSubclassOf<AActor> actorClassToScanFor) const{ return FScannableActorDetails(); }
+FScannableActorDetails UFGScannableDetailsHarddrive::FindClosestRelevantActor(UWorld* world, const FVector& scanLocation, const float maxRangeSquared, TSubclassOf<AActor> actorClassToScanFor) const{ return FScannableActorDetails(); }

Source/FactoryGame/Private/FGScannableSubsystem.cpp

@@ -9,7 +9,6 @@ AFGScannableSubsystem* AFGScannableSubsystem::Get(UWorld* world){ return nullptr
 AFGScannableSubsystem* AFGScannableSubsystem::Get(UObject* worldContext){ return nullptr; }
 void AFGScannableSubsystem::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
 	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
-	DOREPLIFETIME(AFGScannableSubsystem, mUnlootedDropPods);
 }
 void AFGScannableSubsystem::BeginPlay(){ }
 void AFGScannableSubsystem::EndPlay(const EEndPlayReason::Type EndPlayReason){ }
@@ -21,5 +20,5 @@ void AFGScannableSubsystem::OnCreatureSpawnerUpdated( AFGCreatureSpawner* creatu
 void AFGScannableSubsystem::OnCreatureSpawnerAdded( AFGCreatureSpawner* creatureSpawner){ }
 void AFGScannableSubsystem::OnCreatureSpawnerRemoved( AFGCreatureSpawner* creatureSpawner){ }
 bool AFGScannableSubsystem::DoesPickupExist(const FGuid& PickupGuid) const{ return bool(); }
-void AFGScannableSubsystem::CacheDropPods(){ }
-void AFGScannableSubsystem::AssignAvailableItemPickups(const TArray< FWorldScannableData >& ItemPickups){ }
+bool AFGScannableSubsystem::HasDropPodBeenLooted(const FGuid& dropPodGuid) const { return bool(); }
+void AFGScannableSubsystem::AssignScannableData(const TArray<FWorldScannableData>& itemPickups,	const TArray<FWorldScannableData>& dropPods){ }

Source/FactoryGame/Private/FGWorldScannableData.cpp

@@ -1,15 +1,18 @@
 // This file has been automatically generated by the Unreal Header Implementation tool
 
 #include "FGWorldScannableData.h"
+#include "UObject/ObjectSaveContext.h"
 
-FWorldScannableData::FWorldScannableData(AActor* actor){ }
+FWorldScannableData::FWorldScannableData() { }
 #if WITH_EDITOR
-void UFGWorldScannableData::GenerateWorldScannableData(UWorld* world){ }
-#endif 
-#if WITH_EDITOR
-void AFGWorldScannableDataGenerator::GenerateWorldScannableData(){ }
-#endif 
+FWorldScannableData::FWorldScannableData(const AActor* actor) { }
+FWorldScannableData::FWorldScannableData(const class FWorldPartitionActorDesc* ActorDesc, int32 PIEInstanceIndex) { }
+#endif
 AFGWorldScannableDataGenerator::AFGWorldScannableDataGenerator() : Super() {
 
 }
 void AFGWorldScannableDataGenerator::BeginPlay(){ }
+void AFGWorldScannableDataGenerator::PreSave(FObjectPreSaveContext SaveContext){ Super::PreSave(SaveContext); }
+#if WITH_EDITOR
+void AFGWorldScannableDataGenerator::CacheWorldScannableData(){ }
+#endif

Source/FactoryGame/Private/Hologram/FGWallAttachmentHologram.cpp

@@ -8,4 +8,5 @@ AFGWallAttachmentHologram::AFGWallAttachmentHologram() : Super() {
 	this->mSnapAxis = EAxis::X;
 	this->mNeedsValidFloor = false;
 }
+void AFGWallAttachmentHologram::SetHologramLocationAndRotation(const FHitResult& hitResult){ }
 void AFGWallAttachmentHologram::CheckValidPlacement(){ }

Source/FactoryGame/Private/Representation/FGResourceNodeRepresentation.cpp

@@ -19,6 +19,7 @@ UMaterialInterface* UFGResourceNodeRepresentation::GetRepresentationCompassEffec
 FVector2f UFGResourceNodeRepresentation::GetRepresentationCompassEffectSize() const{ return FVector2f(); }
 bool UFGResourceNodeRepresentation::UpdateRepresentationCompassEffectMaterial(UMaterialInstanceDynamic* compassMaterialInstance, APlayerController* ownerPlayerController, float distanceToPlayer, float totalTime){ return bool(); }
 bool UFGResourceNodeRepresentation::IsImportantCompassRepresentation() const{ return bool(); }
+bool UFGResourceNodeRepresentation::GetShouldShowOnMap() const{ return bool(); }
 void UFGResourceNodeRepresentation::SetupResourceNodeRepresentation( AFGResourceNodeBase* resourceNode){ }
 bool UFGResourceNodeRepresentation::IsCluster() const{ return bool(); }
 bool UFGResourceNodeRepresentation::IsOccupied() const{ return bool(); }

Source/FactoryGame/Public/Buildables/FGBuildableGeneratorFuel.h

@@ -146,7 +146,7 @@ class FACTORYGAME_API AFGBuildableGeneratorFuel : public AFGBuildableGenerator
 	bool FilterFuelClasses( TSubclassOf< UObject > object, int32 idx ) const;
 
 	void UpdateInInventoryFuelTypes( const UFGInventoryComponent* instigatorInventory );
-	void UpdateUnlockedFuelTypes();
+	TArray< TSubclassOf< UFGItemDescriptor > > UpdateUnlockedFuelTypes();
 
 protected:
 	/** Kept for save game compatibility. @see mDefaultFuelClasses */

Source/FactoryGame/Public/Equipment/FGObjectScanner.h

@@ -104,6 +104,14 @@ class FACTORYGAME_API AFGObjectScanner : public AFGEquipment
 	UFUNCTION( NetMulticast, Reliable )
 	void Multicast_PlayBeepAnimation();
 
+	/** Returns the location of the object closest to the scanner if it is loaded, otherwise returns null */
+	UFUNCTION( BlueprintPure, Category = "Scanner" )
+	AActor* GetClosestObjectIfLoaded() const;
+
+	/** Returns the location of the object closest to the scanner. If the object is not loaded, returns the estimated location */
+	UFUNCTION( BlueprintPure, Category = "Scanner" )
+	FVector GetClosestObjectLocation() const;
+
 	/** Called when the scanner should play the "Beep" VFX when the object is in range */
 	UFUNCTION( BlueprintImplementableEvent, Category = "Scanner", DisplayName = "PlayScannerBeepVFX" )
 	void K2_PlayScannerBeepVFX();
@@ -172,8 +180,8 @@ class FACTORYGAME_API AFGObjectScanner : public AFGEquipment
 	float mUpdateClosestObjectTime;
 
 	/** The current closest Object */
-	UPROPERTY( BlueprintReadOnly, ReplicatedUsing = OnRep_ClosestObject, Category = "Scanner" )
-	class AActor* mClosestObject;
+	UPROPERTY( ReplicatedUsing = OnRep_ClosestObject )
+	FScannableActorDetails mClosestObject;
 
 	UPROPERTY( BlueprintReadOnly, Category = "Scanner" )
 	bool mClosestObjectInScanRange;

Source/FactoryGame/Public/FGCharacterMovementComponent.h

@@ -546,6 +546,9 @@ class FACTORYGAME_API UFGCharacterMovementComponent final : public UCharacterMov
 	/** Keeps is the player sprinting this update or not? */
 	bool mIsSliding;
 
+	/** Keep track of what status was for mIsSliding */
+	bool mLastIsSliding; 
+
 	/** True if the player is pressing jump */
 	bool mIsPressingJump;
 
@@ -765,10 +768,6 @@ class FSavedMove_FGMovement final : public FSavedMove_Character
 	uint8 mSavedIsPressingJump : 1;
 
 	uint8 mSavedWantsToSprintOnZipline : 1;
-
-	float mSavedSlideTime;
-
-	float mSavedLastSlideTime;
 
 	FVector mSavedHookLocation;
 

Source/FactoryGame/Public/FGCircuitSubsystem.h

@@ -200,7 +200,7 @@ class FACTORYGAME_API AFGCircuitSubsystem : public AFGSubsystem, public IFGSaveI
 	void RemoveComponentFromCircuit( class UFGCircuitConnectionComponent* component );
 
 	/** Called when a power circuit is considered stable. */
-	void OnPowerCircuitStable( class UFGPowerCircuit* circuit, class AFGPlayerController* fuseResetInstigator );
+	void OnPowerCircuitStable( AFGPlayerController* fuseResetInstigator ) const;
 
 	void RemovePowerCircuitStabilityData( int32 circuitID );