Add stubs that were missed by the header implementer

Plugins/Online/OnlineIntegration/Source/OnlineIntegration/Private/OnlineFriend.cpp

@@ -6,7 +6,9 @@ bool UOnlineFriend::IsPlayingThisGame() const{ return bool(); }
 UCommonUserSubsystem* UOnlineFriend::GetSubsystem() const{ return nullptr; }
 ULocalUserInfo* UOnlineFriend::GetLocalUserInfo() const{ return nullptr; }
 UOnlineUserPresence* UOnlineFriend::GetPresence(UOnlineIntegrationBackend* Backend) const{ return nullptr; }
+USessionInformation* UOnlineFriend::GetGameSession() const { return nullptr; }
 EOnlineRelationship UOnlineFriend::GetRelationshipForBackend(UOnlineIntegrationBackend* Backend) const{ return EOnlineRelationship(); }
+UOnlineUserInfo* UOnlineFriend::GetOnlineUser() const{ return nullptr; }
 EOnlineUserPresenceStatus UOnlineFriend::GetPresenceStatus(UOnlineIntegrationBackend* Backend) const{ return EOnlineUserPresenceStatus(); }
 EOnlineUserPresenceJoinability UOnlineFriend::GetPresenceJoinability(UOnlineIntegrationBackend* Backend) const{ return EOnlineUserPresenceJoinability(); }
 EOnlineUserPresenceGameStatus UOnlineFriend::GetPresenceGameStatus(UOnlineIntegrationBackend* Backend) const{ return EOnlineUserPresenceGameStatus(); }

Plugins/Online/OnlineIntegration/Source/OnlineIntegration/Private/User/OnlineUserBackendLink.cpp

@@ -5,4 +5,9 @@
 #include "GameplayTagContainerViewModel.h"
 
 UOnlineUserBackendLink::UOnlineUserBackendLink(){ }
+const FPlayerAvatar& UOnlineUserBackendLink::GetAvatar() const{ return *(new FPlayerAvatar()); }
+const FString& UOnlineUserBackendLink::GetNickname() const{ return *(new FString()); }
+UE::Online::FAccountId UOnlineUserBackendLink::GetAccountId() const{ return UE::Online::FAccountId(); }
+UOnlineIntegrationBackend* UOnlineUserBackendLink::GetOnlineBackend() const{ return nullptr; }
+UOnlineUserInfo* UOnlineUserBackendLink::GetOnlineUser() const{ return nullptr; }
 const UGameplayTagContainerViewModel& UOnlineUserBackendLink::GetTagContainer() const{ return *NewObject<UGameplayTagContainerViewModel>(); }

Source/FactoryGame/Private/Atmosphere/BiomeHelpers.cpp

@@ -2,5 +2,6 @@
 
 #include "Atmosphere/BiomeHelpers.h"
 
+void FBiomeHelpers::GetExponentialFogSettings(UFGBiome* biome, float atTime, struct FExponentialFogSettings& out_settings){ }
 void FBiomeHelpers::GetSkySphereSettings(UFGBiome *biome, float atTime,  FSkySphereSettings& out_settings){ }
 void FBiomeHelpers::GetAtmosphereSettings(UFGBiome *biome, float atTime,  FSkyAtmosphereSettings& out_settings){ }

Source/FactoryGame/Private/Buildables/FGBuildableConveyorBase.cpp

@@ -14,6 +14,9 @@ void UFGConveyorRemoteCallObject::GetLifetimeReplicatedProps(TArray< FLifetimePr
 void UFGConveyorRemoteCallObject::Server_OnUse_Implementation( AFGBuildableConveyorBase* target,  AFGCharacterPlayer* byCharacter, float itemOffset, uint16 desiredItemClassIdx){ }
 #if !UE_BUILD_SHIPPING
 void AFGBuildableConveyorBase::DebugDrawStalled() const{ }
+#if !UE_BUILD_SHIPPING
+void AFGBuildableConveyorBase::SetStalled(bool stall) const{ }
+#endif
 #endif 
 #if UE_BUILD_SHIPPING
 #endif 

Source/FactoryGame/Private/Buildables/FGBuildablePoleBase.cpp

@@ -13,5 +13,6 @@ void AFGBuildablePoleBase::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>&
 }
 bool AFGBuildablePoleBase::ShouldBeConsideredForBase_Implementation(){ return bool(); }
 bool AFGBuildablePoleBase::ShouldShowCenterGuidelinesForHologram(const AFGHologram* hologram) const{ return bool(); }
+struct FPoleHeightMesh AFGBuildablePoleBase::FindBestHeightMesh(float inHeight) const{ return FPoleHeightMesh(); }
 void AFGBuildablePoleBase::PostLoad(){ Super::PostLoad(); }
 void AFGBuildablePoleBase::EndPlay(const EEndPlayReason::Type EndPlayReason){ }

Source/FactoryGame/Private/Buildables/FGBuildableTrainPlatformCargo.cpp

@@ -101,6 +101,7 @@ bool AFGBuildableTrainPlatformCargo::CanCompleteDocking(){ return bool(); }
 bool AFGBuildableTrainPlatformCargo::IsLoadUnloadBlockedByNoneFilter(){ return bool(); }
 void AFGBuildableTrainPlatformCargo::UpdateItemTransferRate(int32 numItemsTransfered){ }
 float AFGBuildableTrainPlatformCargo::GetCurrentItemTransferRate(){ return float(); }
+bool AFGBuildableTrainPlatformCargo::ShouldLockIncomingOutgoing() const{ return bool(); }
 void AFGBuildableTrainPlatformCargo::OnRep_SmoothedLoadRate(){ }
 void AFGBuildableTrainPlatformCargo::OnRep_SmoothedUnloadRate(){ }
 FName AFGBuildableTrainPlatformCargo::mMagicBoxComponentName = FName();

Source/FactoryGame/Private/FGAtmosphereUpdater.cpp

@@ -9,6 +9,7 @@ UFGAtmosphereUpdater::UFGAtmosphereUpdater() : Super() {
 }
 void UFGAtmosphereUpdater::Tick(float dt){ }
 void UFGAtmosphereUpdater::FinishDestroy(){ Super::FinishDestroy(); }
+const TArray<FAtmosphereVolumeBlend>& UFGAtmosphereUpdater::GetEffectiveAtmosphereVolumes() const{ return *(new TArray<FAtmosphereVolumeBlend>()); }
 void UFGAtmosphereUpdater::ApplyFogSettings(const FExponentialFogSettings& fogSettings,  UWorld* world) const{ }
 void UFGAtmosphereUpdater::ApplySkyAtmosphereSettings(const  FSkyAtmosphereSettings& settings,  UWorld* world) const{ }
 void UFGAtmosphereUpdater::InterpolateFogSettings(FExponentialFogSettings& dest, const FExponentialFogSettings& src, float alpha) const{ }

Source/FactoryGame/Private/FGAttachmentPointComponent.cpp

@@ -1,8 +1,10 @@
 // This file has been automatically generated by the Unreal Header Implementation tool
 
 #include "FGAttachmentPointComponent.h"
+#include "FGAttachmentPoint.h"
 
 UFGAttachmentPointComponent::UFGAttachmentPointComponent() : Super() {
 	this->mUsage = EAttachmentPointUsage::EAPU_Default;
 	this->mType = nullptr;
 }
+struct FFGAttachmentPoint UFGAttachmentPointComponent::CreateAttachmentPoint(AActor* owner) const{ return FFGAttachmentPoint(); }

Source/FactoryGame/Private/FGBackgroundThread.cpp

@@ -3,7 +3,7 @@
 #include "FGBackgroundThread.h"
 
 DEFINE_LOG_CATEGORY(LogPoolSystem);
-
+class FFGBackgroundThread* FPoolInstanceBase::GetRunnable(const AActor* owner) const{ return nullptr; }
 bool FPoolInstanceBase::ResolveHitResults(const TArray<FHitResult>& inHits, const TArray<UClass*>& classesToCheckAgainst, FVector& outHitLocation, float& inNearestDistance){ return bool(); }
 void FPoolInstanceComponent::Claim(int32 EntryId){ }
 bool FPoolInstanceComponent::Update(const TArray<FPoolItem*>& entries){ return bool(); }

Source/FactoryGame/Private/FGCharacterPlayer.cpp

@@ -429,6 +429,7 @@ void AFGCharacterPlayer::OnDisabledInputGateChanged_Implementation(const FDisabl
 void AFGCharacterPlayer::StartPortal(AFGBuildablePortalBase* sourcePortal, AFGBuildablePortalBase* destPortal){ }
 void AFGCharacterPlayer::OnPortalStateChanged_Implementation(const FFGPlayerPortalData& newValue){ }
 void AFGCharacterPlayer::SnapPlayerToPortalExitLocation(){ }
+struct FInventoryToRespawnWith AFGCharacterPlayer::SpawnDeathCrate(const EPlayerKeepInventoryMode& keepInventoryMode, UFGInventoryComponent* inventory){ return FInventoryToRespawnWith(); }
 void AFGCharacterPlayer::OnItemAddedToInventory(TSubclassOf< UFGItemDescriptor > itemClass, const int32 numAdded, UFGInventoryComponent* targetInventory){ }
 void AFGCharacterPlayer::OnInventorySlotUpdated(const int32 Index){ }
 void AFGCharacterPlayer::OnCentralStorageItemAmountUpdated(const TSubclassOf<UFGItemDescriptor> itemClass, int32 newAmount){ }

Source/FactoryGame/Private/FGConveyorChainActor.cpp

@@ -74,6 +74,7 @@ float AFGConveyorChainActor::FindOffsetClosestToLocation(const FVector& location
 FConveyorChainSplineSegment* AFGConveyorChainActor::GetSegmentForConveyorBase(AFGBuildableConveyorBase* conveyorBase){ return nullptr; }
 FConveyorChainSplineSegment* AFGConveyorChainActor::GetSegmentForItemIndex(int32 itemIndex){ return nullptr; }
 FConveyorChainSplineSegment* AFGConveyorChainActor::GetSegmentForOffset(float offset){ return nullptr; }
+bool AFGConveyorChainActor::HasRoomOnChain(float& out_availableSpace){ return bool(); }
 float AFGConveyorChainActor::GetAvailableSpace(){ return float(); }
 void AFGConveyorChainActor::InitializeConveyorItemArray(){ }
 void AFGConveyorChainActor::AddClientAvailableConveyor( AFGBuildableConveyorBase* conveyorBase){ }

Source/FactoryGame/Private/FGDroneVehicle.cpp

@@ -123,6 +123,7 @@ FDroneAction* AFGDroneVehicle::MigrateLegacyAction( UFGDroneAction* action){ ret
 void AFGDroneVehicle::OnMovementFlyingModeChanged(EDroneFlyingMode NewFlyingMode){ }
 void AFGDroneVehicle::OnMovementBrakingStateChanged(bool IsBraking){ }
 FGDroneActionFactory::FGDroneActionFactory(AFGDroneVehicle* drone){ }
+struct FDroneAction* FGDroneActionFactory::CreateDroneActionFromName(const FName& name) const{ return nullptr; }
 #if !UE_BUILD_SHIPPING
 void FDroneAction::ShowDebug(FString& out_concatDebugString){ }
 #endif 

Source/FactoryGame/Private/FGFactoryConnectionComponent.cpp

@@ -43,11 +43,15 @@ UFGFactoryConnectionComponent* UFGFactoryConnectionComponent::FindCompatibleOver
 		const FVector& location,
 		const AActor* priorityActor,
 		float radius){ return nullptr; }
+
+UFGFactoryConnectionComponent* UFGFactoryConnectionComponent::FindOverlappingConnections(UWorld* world,
+	const FVector& location, const AActor* priorityActor, float radius, EFactoryConnectionConnector connector,
+	EFactoryConnectionDirection direction, const TArray<TSubclassOf<class AFGBuildable>>& buildableClassFilter){ return nullptr; }
 int32 UFGFactoryConnectionComponent::FindAllOverlappingConnections(TArray< UFGFactoryConnectionComponent* > out_Connection,
-		UWorld* world,
-		const FVector& location,
-		float radius,
-		EFactoryConnectionConnector connector,
-		EFactoryConnectionDirection direction){ return int32(); }
+                                                                   UWorld* world,
+                                                                   const FVector& location,
+                                                                   float radius,
+                                                                   EFactoryConnectionConnector connector,
+                                                                   EFactoryConnectionDirection direction){ return int32(); }
 UFGFactoryConnectionComponent* UFGFactoryConnectionComponent::CheckIfSnapOnlyIsBlockedByOtherConnection(UFGFactoryConnectionComponent* connectionToCheck,
 		const TArray< FOverlapResult >& potentialBlockers){ return nullptr; }

Source/FactoryGame/Private/FGInventoryComponentEquipment.cpp

@@ -18,6 +18,7 @@ AFGEquipment* UFGInventoryComponentEquipment::GetStackEquipmentActorAtIdx(const
 int32 UFGInventoryComponentEquipment::FindSlotForSlottedInEquipment(const AFGEquipment* equipment) const{ return int32(); }
 void UFGInventoryComponentEquipment::CycleEquipment(int32 dir){ }
 void UFGInventoryComponentEquipment::SetActiveIndexWithDefaultItem(int32 index){ }
+void UFGInventoryComponentEquipment::SetActiveIndex(int32 index, TOptional<FInventoryItem> itemAtCurrentIndex){ }
 bool UFGInventoryComponentEquipment::ContainsItemTypeAndHasEnoughSpaceForItem(FInventoryItem item){ return bool(); }
 FDelegateHandle UFGInventoryComponentEquipment::BindOnActiveEquipmentChanged(const FOnActiveEquipmentChanged::FDelegate &Delegate){ return FDelegateHandle(); }
 void UFGInventoryComponentEquipment::SetActiveEquipment(AFGEquipment* equipment){ }

Source/FactoryGame/Private/FGLightweightBuildableSubsystem.cpp

@@ -8,6 +8,7 @@ void FLightweightBuildablePool::PreallocPool(AActor* owner, TArray<TSubclassOf<A
 AFGBuildable* FLightweightBuildablePool::GetBuildableFromPool(AActor* owner, FRuntimeBuildableInstanceData* runtimeData, int32 indexOfRuntimeData, TSubclassOf<AFGBuildable> buildableClass){ return nullptr; }
 void FLightweightBuildablePool::ReturnBuildableToPool(AFGBuildable* buildable){ }
 AFGBuildable* FLightweightBuildablePool::SpawnBuildableForPool(AActor* owner, TSubclassOf<AFGBuildable> buildableClass){ return nullptr; }
+bool FInstanceConverterInstigator::TryAddInstigatedBuildable(FInstanceToTemporaryBuildable* instanceToTemp){ return bool(); }
 void FLightweightBuildableRemovalArray::PostReplicatedAdd(const TArrayView<int32>& AddedIndices, int32 FinalSize){ }
 void FLightweightBuildableCustomizationArray::PostReplicatedAdd(const TArrayView<int32>& AddedIndices, int32 FinalSize){ }
 void UFGLightweightBuildableConstructionBundle::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {

Source/FactoryGame/Private/FGMaterialFlowAnalysisFunctionLibrary.cpp

@@ -3,7 +3,9 @@
 #include "FGMaterialFlowAnalysisFunctionLibrary.h"
 
 int32 FMaterialFlowGraph::GetDepth() const{ return int32(); }
+struct FMaterialFlowNode* FMaterialFlowGraph::CreateNodeFromRecipe(TSubclassOf<UFGRecipe> recipe, int32 depth){ return nullptr; }
 TArray< struct FMaterialFlowNode* > FMaterialFlowGraph::GetNodes(int32 depth) const{ return TArray<struct FMaterialFlowNode*>(); }
+struct FMaterialFlowNode* FMaterialFlowGraph::CreateNodeFromOutput(TSubclassOf<class UFGItemDescriptor> descriptor, int32 depth){ return nullptr; }
 void FMaterialFlowGraph::SortNodes(){ }
 void FMaterialFlowGraph::UpdateTotals(){ }
 FMaterialFlowConnection::FMaterialFlowConnection(){ }

Source/FactoryGame/Private/FGPlayerState.cpp

@@ -149,6 +149,7 @@ int32 AFGPlayerState::FindHotbarIndex(UFGPlayerHotbar* hotbar) const{ return int
 void AFGPlayerState::GetAllHotbars(TArray<UFGPlayerHotbar*>& out_hotbars) const{ }
 bool AFGPlayerState::GetAndSetFirstTimeEquipped( AFGEquipment* equipment){ return bool(); }
 AFGPlayerController* AFGPlayerState::GetOwningController() const{ return nullptr; }
+class AFGHUD* AFGPlayerState::GetHUD() const{ return nullptr; }
 UFGGameUI* AFGPlayerState::GetGameUI() const{ return nullptr; }
 void AFGPlayerState::AddNewRecipe(TSubclassOf< UFGRecipe > recipe){ }
 void AFGPlayerState::GetNewRecipes(TArray<TSubclassOf<class UFGRecipe>>& out_newRecipes) const{ }
@@ -177,6 +178,7 @@ void AFGPlayerState::Server_SetMapCategoryCollapsed_Implementation(ERepresentati
 void AFGPlayerState::SetCustomMapCategoryCollapsed(const FString& customMapCategory, bool collapsed){ }
 void AFGPlayerState::Server_SetCustomMapCategoryCollapsed_Implementation(const FString& customMapCategory, bool collapsed){ }
 void AFGPlayerState::UpdateOwningPawnActorRepresentation() const{ }
+void AFGPlayerState::SetIsServerAdmin(const bool isAdmin){ }
 void AFGPlayerState::DumpHotbars(){ }
 void AFGPlayerState::UpdateNumObservedInventorySlots(){ }
 bool AFGPlayerState::IsShopFavorite(TSubclassOf<class UFGSchematic> schematic) const{ return bool(); }

Source/FactoryGame/Private/FGResearchManager.cpp

@@ -3,6 +3,8 @@
 #include "FGResearchManager.h"
 #include "Net/UnrealNetwork.h"
 
+bool IsValidForLoad(const FResearchData& element){ return bool(); }
+bool IsValidForLoad(const FResearchTime& element){ return bool(); }
 bool FHardDriveData::operator==(const FHardDriveData& other) const{ return bool(); }
 void UFGResearchManagerRemoteCallObject::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const {
 	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

Source/FactoryGame/Private/FGTutorialIntroManager.cpp

@@ -1,6 +1,7 @@
 // This file has been automatically generated by the Unreal Header Implementation tool
 
 #include "FGTutorialIntroManager.h"
+#include "FGCharacterPlayer.h"
 #include "Net/UnrealNetwork.h"
 
 AFGTutorialIntroManager* AFGTutorialIntroManager::Get(UWorld* world){ return nullptr; }
@@ -69,6 +70,7 @@ void AFGTutorialIntroManager::CompleteOnboardingStepByTag(FGameplayTag completed
 UFGOnboardingStep* AFGTutorialIntroManager::GetOnboardingStepFromTag(FGameplayTag OnboardingStepTag) const{ return nullptr; }
 void AFGTutorialIntroManager::SetTradingPostLevel(int32 newLevel){ }
 void AFGTutorialIntroManager::SetInputGatesFromTutorialLevel( AFGPlayerController* playerController){ }
+struct FDisabledInputGate AFGTutorialIntroManager::GetInputGatesFromTutorialLevel(){ return FDisabledInputGate(); }
 void AFGTutorialIntroManager::SetupDropPod( AFGCharacterPlayer* forPlayer){ }
 void AFGTutorialIntroManager::TradingPostWasBuilt(){ }
 void AFGTutorialIntroManager::StartSkipIntroSequence(){ }

Source/FactoryGame/Private/FGWorldGridSubsystem.cpp

@@ -26,8 +26,17 @@ void AFGWorldGridSubsystem::CreateRuntimeWorldGrid(const TArray< FFGWorldGridCel
 bool AFGWorldGridSubsystem::HasValidGrid() const{ return bool(); }
 void AFGWorldGridSubsystem::UpdateCellContainingBuildable( AFGBuildable* pBuildable){ }
 void AFGWorldGridSubsystem::UpdateCellContainingLocation(const FVector& location){ }
+FIntPoint AFGWorldGridSubsystem::GetWorldGridCoordinatesForLocation(const FVector& WorldLocation) const{ return FIntPoint(); }
+FFGWorldGridCell* AFGWorldGridSubsystem::GetCellByIndex(int32 Index){ return nullptr; }
+const FFGWorldGridCell* AFGWorldGridSubsystem::GetCellByIndex(int32 Index) const{ return nullptr; }
+FFGWorldGridCell* AFGWorldGridSubsystem::GetCellFromGridCoordinates(const FIntPoint& Coords){ return nullptr; }
+const FFGWorldGridCell* AFGWorldGridSubsystem::GetCellFromGridCoordinates(const FIntPoint& Coords) const{ return nullptr; }
 FFGWorldGridCell* AFGWorldGridSubsystem::GetCellContainingWorldLocation(const FVector& WorldLocation){ return nullptr; }
 FFGWorldGridCell* AFGWorldGridSubsystem::GetClosestCellToWorldLocation(const FVector& WorldLocation){ return nullptr; }
+int32 AFGWorldGridSubsystem::GetCellIndexFromGridCoordinates(const FIntPoint& Coords) const{ return int32(); }
+int32 AFGWorldGridSubsystem::GetCellIndexFromWorldLocation(const FVector& WorldLocation) const{ return int32(); }
+FVector AFGWorldGridSubsystem::GetCellWorldLocationFromGridCoords(const FIntPoint& Coords) const { return FVector(); }
+void AFGWorldGridSubsystem::GetCellWorldLocationFromGridCoords(const FIntPoint& Coords, FVector& OutVector) const{ }
 float AFGWorldGridSubsystem::GetCellElevationFromWorldLocation(const FVector& WorldLocation) const{ return float(); }
 float AFGWorldGridSubsystem::GetCellElevationFromGridCoordinates(const FIntPoint& Coords) const{ return float(); }
 TArray< const FFGWorldGridCell* > AFGWorldGridSubsystem::GetCellNeighbours(const FFGWorldGridCell* Cell) const{ return TArray<const FFGWorldGridCell*>(); }

Source/FactoryGame/Private/Online/FGOnlineHelpers.cpp

@@ -5,6 +5,8 @@
 void RefreshEOSConnectionForPlayer::CallLoginRefresh(IOnlineSubsystem* systemEos){ }
 FEOSAccountHelpers::FEOSAccountHelpers() noexcept(false){ }
 FEOSAccountHelpers::~FEOSAccountHelpers(){ }
+const TCHAR* FEOSAccountHelpers::EpicAccountIDToString(EOS_EpicAccountId InAccountId){ return nullptr; }
+const TCHAR* FEOSAccountHelpers::ProductUserIDToString(EOS_ProductUserId InAccountId){ return nullptr; }
 void FEOSAccountHelpers::ConnectAccount(UObject* worldContext, int32 LocalUserNum, TSharedRef<const FUniqueNetId> userId, FString token, const FOnEOSAccountConnectionCompleteDelegate& onComplete){ }
 void FEOSAccountHelpers::ConnectLinkAccountToExistingEOSAccount(UObject* worldContext, int32 LocalUserNum, EOS_ContinuanceToken token, const FOnEOSAccountConnectionCompleteDelegate& onComplete){ }
 void FEOSAccountHelpers::CreateNewAccountConnection(UObject* worldContext, int32 LocalUserNum, TSharedRef<const FUniqueNetId> userId, EOS_ContinuanceToken token, const FOnEOSAccountConnectionCompleteDelegate& onComplete){ }

Source/FactoryGame/Private/Resources/FGItemDescriptor.cpp

@@ -203,6 +203,8 @@ TSubclassOf<UFGSchematic> UFGItemDescriptor::GetRequiredSchematicToScan(TSubclas
 FText UFGItemDescriptor::GetScannerDisplayText(TSubclassOf< UFGItemDescriptor > inClass){ return FText(); }
 FColor UFGItemDescriptor::GetScannerLightColor(TSubclassOf< UFGItemDescriptor > inClass){ return FColor(); }
 bool UFGItemDescriptor::NeedsPickupMapMarker(TSubclassOf<UFGItemDescriptor> inClass){ return bool(); }
+void UFGItemDescriptor::SetItemEncountered(TSubclassOf<UFGItemDescriptor> Class, int32 Index){ }
+int32 UFGItemDescriptor::IsItemEncountered(TSubclassOf<UFGItemDescriptor> Class){ return int32(); }
 bool UFGItemDescriptor::CanItemBePickedup(TSubclassOf< UFGItemDescriptor > inClass){ return bool(); }
 bool UFGItemDescriptor::CanItemBePickedup(UFGItemDescriptor* inClass){ return bool(); }
 FText UFGItemDescriptor::GetItemNameInternal() const{ return FText(); }

Source/FactoryGame/Private/SCompassWidget.cpp

@@ -22,6 +22,8 @@ UFGCompassWidget::UFGCompassWidget() : Super() {
 TSharedRef<SWidget> UFGCompassWidget::RebuildWidget(){ return Super::RebuildWidget(); }
 TArray<FCompassEntry>& UFGCompassWidget::GetCompassEntries(){ return *(new TArray<FCompassEntry>); }
 bool UFGCompassWidget::ShouldHideCompass() const{ return bool(); }
+AFGHUD* UFGCompassWidget::GetOwningHUD() const{ return nullptr; }
+void SCompassWidget::Construct(const FArguments& InArgs, const TWeakObjectPtr<UFGCompassWidget>& OwnerCompassWidget){ }
 int32 SCompassWidget::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const{ return int32(); }
 FVector2D SCompassWidget::ComputeDesiredSize(float LayoutScaleMultiplier) const{ return FVector2D(); }
 FChildren* SCompassWidget::GetChildren(){ return nullptr; }

Source/FactoryGame/Private/Server/HTTPSharedDataTypes.cpp

@@ -21,3 +21,4 @@ void FFGRequestBodyPart::AppendBodyHeaders(const TMap<FString, TArray<FString>>&
 FString FFGRequestBodyPart::GetContentDisposition() const{ return FString(); }
 FFGRequestBodyPart* FFGMultipartDataWrapper::operator->() const{ return nullptr; }
 FFGRequestBodyPart& FFGMultipartDataWrapper::operator*() const{ return *MultipartData; }
+FFGMultipartDataWrapper::operator FFGRequestBodyPart*() const { return nullptr; }