Update

Source/AnalyticsBlueprintLibrary/AnalyticsBlueprintLibrary.Build.cs

@@ -0,0 +1,15 @@
+using UnrealBuildTool;
+
+public class AnalyticsBlueprintLibrary : ModuleRules {
+    public AnalyticsBlueprintLibrary(ReadOnlyTargetRules Target) : base(Target) {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        bLegacyPublicIncludePaths = false;
+        ShadowVariableWarningLevel = WarningLevel.Warning;
+        
+        PublicDependencyModuleNames.AddRange(new string[] {
+            "Core",
+            "CoreUObject",
+            "Engine",
+        });
+    }
+}

Source/AnalyticsBlueprintLibrary/Private/AnalyticsBlueprintLibrary.cpp

@@ -0,0 +1,97 @@
+#include "AnalyticsBlueprintLibrary.h"
+
+bool UAnalyticsBlueprintLibrary::StartSessionWithAttributes(const TArray<FAnalyticsEventAttr>& Attributes) {
+    return false;
+}
+
+bool UAnalyticsBlueprintLibrary::StartSession() {
+    return false;
+}
+
+void UAnalyticsBlueprintLibrary::SetUserId(const FString& UserId) {
+}
+
+void UAnalyticsBlueprintLibrary::SetSessionId(const FString& SessionId) {
+}
+
+void UAnalyticsBlueprintLibrary::SetLocation(const FString& Location) {
+}
+
+void UAnalyticsBlueprintLibrary::SetGender(const FString& Gender) {
+}
+
+void UAnalyticsBlueprintLibrary::SetBuildInfo(const FString& BuildInfo) {
+}
+
+void UAnalyticsBlueprintLibrary::SetAge(int32 Age) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordSimpleItemPurchaseWithAttributes(const FString& ItemId, int32 ItemQuantity, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordSimpleItemPurchase(const FString& ItemId, int32 ItemQuantity) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordSimpleCurrencyPurchaseWithAttributes(const FString& GameCurrencyType, int32 GameCurrencyAmount, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordSimpleCurrencyPurchase(const FString& GameCurrencyType, int32 GameCurrencyAmount) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordProgressWithFullHierarchyAndAttributes(const FString& ProgressType, const TArray<FString>& ProgressNames, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordProgressWithAttributes(const FString& ProgressType, const FString& ProgressName, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordProgress(const FString& ProgressType, const FString& ProgressName) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordItemPurchase(const FString& ItemId, const FString& Currency, int32 PerItemCost, int32 ItemQuantity) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordEventWithAttributes(const FString& EventName, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordEventWithAttribute(const FString& EventName, const FString& AttributeName, const FString& AttributeValue) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordEvent(const FString& EventName) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordErrorWithAttributes(const FString& Error, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordError(const FString& Error) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordCurrencyPurchase(const FString& GameCurrencyType, int32 GameCurrencyAmount, const FString& RealCurrencyType, float RealMoneyCost, const FString& PaymentProvider) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordCurrencyGivenWithAttributes(const FString& GameCurrencyType, int32 GameCurrencyAmount, const TArray<FAnalyticsEventAttr>& Attributes) {
+}
+
+void UAnalyticsBlueprintLibrary::RecordCurrencyGiven(const FString& GameCurrencyType, int32 GameCurrencyAmount) {
+}
+
+FAnalyticsEventAttr UAnalyticsBlueprintLibrary::MakeEventAttribute(const FString& AttributeName, const FString& AttributeValue) {
+    return FAnalyticsEventAttr{};
+}
+
+FString UAnalyticsBlueprintLibrary::GetUserId() {
+    return TEXT("");
+}
+
+FString UAnalyticsBlueprintLibrary::GetSessionId() {
+    return TEXT("");
+}
+
+void UAnalyticsBlueprintLibrary::FlushEvents() {
+}
+
+void UAnalyticsBlueprintLibrary::EndSession() {
+}
+
+UAnalyticsBlueprintLibrary::UAnalyticsBlueprintLibrary() {
+}
+

Source/AnalyticsBlueprintLibrary/Private/AnalyticsBlueprintLibraryModule.cpp

@@ -0,0 +1,3 @@
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultGameModuleImpl, AnalyticsBlueprintLibrary);

Source/AnalyticsBlueprintLibrary/Private/AnalyticsEventAttr.cpp

@@ -0,0 +1,5 @@
+#include "AnalyticsEventAttr.h"
+
+FAnalyticsEventAttr::FAnalyticsEventAttr() {
+}
+

Source/AnalyticsBlueprintLibrary/Public/AnalyticsBlueprintLibrary.h

@@ -0,0 +1,100 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "AnalyticsEventAttr.h"
+#include "AnalyticsBlueprintLibrary.generated.h"
+
+UCLASS(Blueprintable)
+class UAnalyticsBlueprintLibrary : public UBlueprintFunctionLibrary {
+    GENERATED_BODY()
+public:
+    UAnalyticsBlueprintLibrary();
+    UFUNCTION(BlueprintCallable)
+    static bool StartSessionWithAttributes(const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static bool StartSession();
+    
+    UFUNCTION(BlueprintCallable)
+    static void SetUserId(const FString& UserId);
+    
+    UFUNCTION(BlueprintCallable)
+    static void SetSessionId(const FString& SessionId);
+    
+    UFUNCTION(BlueprintCallable)
+    static void SetLocation(const FString& Location);
+    
+    UFUNCTION(BlueprintCallable)
+    static void SetGender(const FString& Gender);
+    
+    UFUNCTION(BlueprintCallable)
+    static void SetBuildInfo(const FString& BuildInfo);
+    
+    UFUNCTION(BlueprintCallable)
+    static void SetAge(int32 Age);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordSimpleItemPurchaseWithAttributes(const FString& ItemId, int32 ItemQuantity, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordSimpleItemPurchase(const FString& ItemId, int32 ItemQuantity);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordSimpleCurrencyPurchaseWithAttributes(const FString& GameCurrencyType, int32 GameCurrencyAmount, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordSimpleCurrencyPurchase(const FString& GameCurrencyType, int32 GameCurrencyAmount);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordProgressWithFullHierarchyAndAttributes(const FString& ProgressType, const TArray<FString>& ProgressNames, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordProgressWithAttributes(const FString& ProgressType, const FString& ProgressName, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordProgress(const FString& ProgressType, const FString& ProgressName);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordItemPurchase(const FString& ItemId, const FString& Currency, int32 PerItemCost, int32 ItemQuantity);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordEventWithAttributes(const FString& EventName, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordEventWithAttribute(const FString& EventName, const FString& AttributeName, const FString& AttributeValue);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordEvent(const FString& EventName);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordErrorWithAttributes(const FString& Error, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordError(const FString& Error);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordCurrencyPurchase(const FString& GameCurrencyType, int32 GameCurrencyAmount, const FString& RealCurrencyType, float RealMoneyCost, const FString& PaymentProvider);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordCurrencyGivenWithAttributes(const FString& GameCurrencyType, int32 GameCurrencyAmount, const TArray<FAnalyticsEventAttr>& Attributes);
+    
+    UFUNCTION(BlueprintCallable)
+    static void RecordCurrencyGiven(const FString& GameCurrencyType, int32 GameCurrencyAmount);
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    static FAnalyticsEventAttr MakeEventAttribute(const FString& AttributeName, const FString& AttributeValue);
+    
+    UFUNCTION(BlueprintCallable)
+    static FString GetUserId();
+    
+    UFUNCTION(BlueprintCallable)
+    static FString GetSessionId();
+    
+    UFUNCTION(BlueprintCallable)
+    static void FlushEvents();
+    
+    UFUNCTION(BlueprintCallable)
+    static void EndSession();
+    
+};
+

Source/AnalyticsBlueprintLibrary/Public/AnalyticsEventAttr.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "AnalyticsEventAttr.generated.h"
+
+USTRUCT(BlueprintType)
+struct FAnalyticsEventAttr {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FString Name;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FString Value;
+    
+    ANALYTICSBLUEPRINTLIBRARY_API FAnalyticsEventAttr();
+};
+

Source/ArsenicCoreRuntime/ArsenicCoreRuntime.Build.cs

@@ -0,0 +1,83 @@
+using UnrealBuildTool;
+
+public class ArsenicCoreRuntime : ModuleRules {
+    public ArsenicCoreRuntime(ReadOnlyTargetRules Target) : base(Target) {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        bLegacyPublicIncludePaths = false;
+        ShadowVariableWarningLevel = WarningLevel.Warning;
+        
+        PublicDependencyModuleNames.AddRange(new string[] {
+            "AIModule",
+            "Account",
+            "AmbientAudio",
+            "AnimGraphRuntime",
+            "AnimationBudgetAllocator",
+            "AnimationCore",
+            "AnimationSharing",
+            "AssetRegistry",
+            "AudioMixer",
+            "BlueprintContext",
+            "Chaos",
+            "CinematicCamera",
+            "ClientPilot",
+            "ClothingSystemRuntimeInterface",
+            "CommonDialogueRuntime",
+            "CommonInput",
+            "CommonUI",
+            "Core",
+            "CoreUObject",
+            "Curie",
+            "DataAssetDirectory",
+            "DeveloperSettings",
+            "Engine",
+            "EpicGameplayStatsRuntime",
+            "FoleySound",
+            "Foliage",
+            "FortniteGame",
+            "GameSubCatalog",
+            "GameplayAbilities",
+            "GameplayTags",
+            "GameplayTasks",
+            "Gauntlet",
+            "HeadMountedDisplay",
+            "Hotfix",
+            "InputCore",
+            "JsonUtilities",
+            "Landscape",
+            "LevelSequence",
+            "LiveLinkInterface",
+            "Lobby",
+            "McpProfileSys",
+            "MediaAssets",
+            "MediaUtils",
+            "MeshNetwork",
+            "ModularGameplay",
+            "MovieScene",
+            "MovieSceneTracks",
+            "NavigationSystem",
+            "Niagara",
+            "NiagaraAnimNotifies",
+            "NiagaraCore",
+            "NiagaraShader",
+            "OnlineSubsystem",
+            "OnlineSubsystemUtils",
+            "Overlay",
+            "Paper2D",
+            "Party",
+            "PhysXVehicles",
+            "PhysicsCore",
+            "PlayspaceSystem",
+            "PropertyPath",
+            "Rejoin",
+            "ReplicationGraph",
+            "SidecarSys",
+            "SignificanceManager",
+            "Slate",
+            "SlateCore",
+            "SubtitlesWidgets",
+            "UMG",
+            "Water",
+            "WebBrowser",
+        });
+    }
+}

Source/ArsenicCoreRuntime/Private/ArsenicCoreGCNGhostAudioHelperComponent.cpp

@@ -0,0 +1,19 @@
+#include "ArsenicCoreGCNGhostAudioHelperComponent.h"
+
+void UArsenicCoreGCNGhostAudioHelperComponent::SetTargetPawn(APawn* InTargetPawn) {
+}
+
+void UArsenicCoreGCNGhostAudioHelperComponent::SetLoopingAudioComponent(UAudioComponent* InLoopingAudioComponent) {
+}
+
+void UArsenicCoreGCNGhostAudioHelperComponent::PopVelocitySoundMix() {
+}
+
+UArsenicCoreGCNGhostAudioHelperComponent::UArsenicCoreGCNGhostAudioHelperComponent() {
+    this->VelocityAudioInputRange_Min = 1;
+    this->VelocityAudioInputRange_Max = 1;
+    this->AudioInterpSpeed = 1;
+    this->VelocitySoundMix = NULL;
+    this->VelocityThresholdForMixModActivation = 1;
+}
+

Source/ArsenicCoreRuntime/Private/ArsenicCoreHumanPawnData.cpp

@@ -0,0 +1,7 @@
+#include "ArsenicCoreHumanPawnData.h"
+
+FArsenicCoreHumanPawnData::FArsenicCoreHumanPawnData() {
+    this->Pawn = NULL;
+    this->PlayerState = NULL;
+}
+

Source/ArsenicCoreRuntime/Private/ArsenicCorePlayerComponent.cpp

@@ -0,0 +1,46 @@
+#include "ArsenicCorePlayerComponent.h"
+#include "Net/UnrealNetwork.h"
+
+void UArsenicCorePlayerComponent::UpdateGhostVisibilityChange(const bool bIsVisibile) {
+}
+
+void UArsenicCorePlayerComponent::SetSquadMemberArsenicCorePlayerStatus(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewPlayerStatus) {
+}
+
+void UArsenicCorePlayerComponent::ServerClientIsReadyToSpawnAsGhost_Implementation() {
+}
+bool UArsenicCorePlayerComponent::ServerClientIsReadyToSpawnAsGhost_Validate() {
+    return true;
+}
+
+void UArsenicCorePlayerComponent::OnRep_SquadMemberPlayerStatuses(const TArray<FArsenicCoreSquadMemberPlayerStatus>& OldValue) {
+}
+
+void UArsenicCorePlayerComponent::OnRep_ScreamFoundNoSurvivors() {
+}
+
+void UArsenicCorePlayerComponent::OnRep_ManagingMutator() {
+}
+
+void UArsenicCorePlayerComponent::OnRep_CurrentPlayerStatus() {
+}
+
+void UArsenicCorePlayerComponent::GhostScreamFoundNoSurvivors() {
+}
+
+void UArsenicCorePlayerComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UArsenicCorePlayerComponent, ManagingMutator);
+    DOREPLIFETIME(UArsenicCorePlayerComponent, CurrentPlayerStatus);
+    DOREPLIFETIME(UArsenicCorePlayerComponent, ScreamFoundNoSurvivors);
+    DOREPLIFETIME(UArsenicCorePlayerComponent, SquadMemberPlayerStatuses);
+}
+
+UArsenicCorePlayerComponent::UArsenicCorePlayerComponent() {
+    this->ManagingMutator = NULL;
+    this->LocalRespawnDrone = NULL;
+    this->CurrentPlayerStatus = EArsenicCorePlayerStatus::None;
+    this->ScreamFoundNoSurvivors = 0;
+}
+

Source/ArsenicCoreRuntime/Private/ArsenicCorePopulationGridCellData.cpp

@@ -0,0 +1,9 @@
+#include "ArsenicCorePopulationGridCellData.h"
+
+FArsenicCorePopulationGridCellData::FArsenicCorePopulationGridCellData() {
+    this->NumGhostPlayers = 0;
+    this->NumGhostBots = 0;
+    this->NumHumanPlayers = 0;
+    this->NumHumanBots = 0;
+}
+

Source/ArsenicCoreRuntime/Private/ArsenicCorePopulationTracker.cpp

@@ -0,0 +1,17 @@
+#include "ArsenicCorePopulationTracker.h"
+#include "Net/UnrealNetwork.h"
+
+void AArsenicCorePopulationTracker::OnGameMemberRemoved(uint8 InSquadId, uint8 InTeamIndex, AFortPlayerStateAthena* ChangedPS) {
+}
+
+void AArsenicCorePopulationTracker::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(AArsenicCorePopulationTracker, PopulationGridInfo);
+    DOREPLIFETIME(AArsenicCorePopulationTracker, PopulationGrid);
+}
+
+AArsenicCorePopulationTracker::AArsenicCorePopulationTracker() {
+    this->ArsenicCoreMutator = NULL;
+}
+

Source/ArsenicCoreRuntime/Private/ArsenicCoreRespawnDrone.cpp

@@ -0,0 +1,7 @@
+#include "ArsenicCoreRespawnDrone.h"
+
+
+
+AArsenicCoreRespawnDrone::AArsenicCoreRespawnDrone() {
+}
+

Source/ArsenicCoreRuntime/Private/ArsenicCoreRuntimeModule.cpp

@@ -0,0 +1,3 @@
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultGameModuleImpl, ArsenicCoreRuntime);

Source/ArsenicCoreRuntime/Private/ArsenicCoreSquadMemberPlayerStatus.cpp

@@ -0,0 +1,7 @@
+#include "ArsenicCoreSquadMemberPlayerStatus.h"
+
+FArsenicCoreSquadMemberPlayerStatus::FArsenicCoreSquadMemberPlayerStatus() {
+    this->SquadMemberPlayerState = NULL;
+    this->SquadMemberPlayerStatus = EArsenicCorePlayerStatus::None;
+}
+

Source/ArsenicCoreRuntime/Private/FortAthenaAIBotEvaluator_Dash_ArsenicCore.cpp

@@ -0,0 +1,3 @@
+#include "FortAthenaAIBotEvaluator_Dash_ArsenicCore.h"
+
+

Source/ArsenicCoreRuntime/Private/FortAthenaAIBotEvaluator_Loot_ArsenicCore.cpp

@@ -0,0 +1 @@
+#include "FortAthenaAIBotEvaluator_Loot_ArsenicCore.h"

Source/ArsenicCoreRuntime/Private/FortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore.cpp

@@ -0,0 +1,7 @@
+#include "FortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore.h"
+
+UFortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore::UFortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore() {
+    this->MaxDistanceToEngageMeleeDefensive = 1;
+    this->DashExecutionStatusName = TEXT("AIEvaluator_GhostDash_ExecutionStatus");
+}
+

Source/ArsenicCoreRuntime/Private/FortAthenaBTService_Dash_ArsenicCore.cpp

@@ -0,0 +1,2 @@
+#include "FortAthenaBTService_Dash_ArsenicCore.h"
+

Source/ArsenicCoreRuntime/Private/FortAthenaBTService_PickUpLoot_ArsenicCore.cpp

@@ -0,0 +1,2 @@
+#include "FortAthenaBTService_PickUpLoot_ArsenicCore.h"
+

Source/ArsenicCoreRuntime/Private/FortAthenaMutator_ArsenicCore.cpp

@@ -0,0 +1,69 @@
+#include "FortAthenaMutator_ArsenicCore.h"
+#include "Net/UnrealNetwork.h"
+
+void AFortAthenaMutator_ArsenicCore::UpdateAnalyticsDataOnPawnDied(AActor* DamagedActor, float Damage, AController* InstigatedBy, AActor* DamageCauser, FVector HitLocation, UPrimitiveComponent* FHitComponent, FName BoneName, FVector Momentum) {
+}
+
+void AFortAthenaMutator_ArsenicCore::OnRep_bTheGhostTeamHasWon() {
+}
+
+bool AFortAthenaMutator_ArsenicCore::IsGhostThatPermaDiedTeam(uint8 TeamId) const {
+    return false;
+}
+
+bool AFortAthenaMutator_ArsenicCore::IsGhostTeam(uint8 TeamId) const {
+    return false;
+}
+
+bool AFortAthenaMutator_ArsenicCore::IsALivingTeam(uint8 TeamId) const {
+    return false;
+}
+
+bool AFortAthenaMutator_ArsenicCore::HasTheGhostTeamWon() const {
+    return false;
+}
+
+float AFortAthenaMutator_ArsenicCore::GetPopulationInRadius(FVector CenterLocation, float Radius) {
+    return 0.0f;
+}
+
+void AFortAthenaMutator_ArsenicCore::GetPopulationAndGhostHumanRatioInRadius(FVector CenterLocation, float Radius, float& OutPopulation, float& OutGhostHumanRatio) {
+}
+
+uint8 AFortAthenaMutator_ArsenicCore::GetGhostTeam(uint8 TeamId) const {
+    return 0;
+}
+
+float AFortAthenaMutator_ArsenicCore::GetGhostHumanRatioInRadius(FVector CenterLocation, float Radius) {
+    return 0.0f;
+}
+
+uint8 AFortAthenaMutator_ArsenicCore::GetEliminatedPlayersTeamId() const {
+    return 0;
+}
+
+void AFortAthenaMutator_ArsenicCore::CreateGhostBotStimuliFromScream(AFortPlayerPawnAthena* ScreamerPawn, TArray<AFortPlayerPawnAthena*> RevealedHumans) {
+}
+
+void AFortAthenaMutator_ArsenicCore::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(AFortAthenaMutator_ArsenicCore, bTheGhostTeamHasWon);
+    DOREPLIFETIME(AFortAthenaMutator_ArsenicCore, GhostPlayerStates);
+    DOREPLIFETIME(AFortAthenaMutator_ArsenicCore, HumanPlayerPawnDataList);
+    DOREPLIFETIME(AFortAthenaMutator_ArsenicCore, PopulationTracker);
+}
+
+AFortAthenaMutator_ArsenicCore::AFortAthenaMutator_ArsenicCore() {
+    this->ArsenicCorePlayerComponentClass = NULL;
+    this->ConsumePickupsMutator = NULL;
+    this->ArsenicCoreRespawnDroneClass = NULL;
+    this->GhostContrails = NULL;
+    this->GhostPortrait = NULL;
+    this->GhostWeaponItemDefinition = NULL;
+    this->AmbientAudioBank = NULL;
+    this->AmbientAudioBankPriority = 0;
+    this->bTheGhostTeamHasWon = false;
+    this->PopulationTracker = NULL;
+}
+

Source/ArsenicCoreRuntime/Private/FortAthenaMutator_ArsenicInventoryOverride.cpp

@@ -0,0 +1,8 @@
+#include "FortAthenaMutator_ArsenicInventoryOverride.h"
+
+void AFortAthenaMutator_ArsenicInventoryOverride::OnGamePhaseChanged(EAthenaGamePhase NewPhase) {
+}
+
+AFortAthenaMutator_ArsenicInventoryOverride::AFortAthenaMutator_ArsenicInventoryOverride() {
+}
+

Source/ArsenicCoreRuntime/Private/FortAthenaMutator_ConsumePickups.cpp

@@ -0,0 +1,16 @@
+#include "FortAthenaMutator_ConsumePickups.h"
+#include "FortControllerComponent_ConsumePickups.h"
+#include "Net/UnrealNetwork.h"
+
+void AFortAthenaMutator_ConsumePickups::OnRep_ManagerObject() {
+}
+
+void AFortAthenaMutator_ConsumePickups::OnAllGameplayModifiersRegistered() {
+}
+
+void AFortAthenaMutator_ConsumePickups::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(AFortAthenaMutator_ConsumePickups, ManagerObject);
+}
+

Source/ArsenicCoreRuntime/Private/FortAthenaMutator_ConsumePickups_ArsenicCore.cpp

@@ -0,0 +1,8 @@
+#include "FortAthenaMutator_ConsumePickups_ArsenicCore.h"
+
+void AFortAthenaMutator_ConsumePickups_ArsenicCore::OnPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus PlayerStatus) {
+}
+
+AFortAthenaMutator_ConsumePickups_ArsenicCore::AFortAthenaMutator_ConsumePickups_ArsenicCore() {
+}
+

Source/ArsenicCoreRuntime/Private/FortChargingSet_ArsenicCore_Dash.cpp

@@ -0,0 +1,18 @@
+#include "FortChargingSet_ArsenicCore_Dash.h"
+#include "Net/UnrealNetwork.h"
+
+void UFortChargingSet_ArsenicCore_Dash::OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue) {
+}
+
+void UFortChargingSet_ArsenicCore_Dash::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Dash, CurrentCharge);
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Dash, MaxCharge);
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Dash, ChargeTime);
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Dash, ServerTimeChargeIncrements);
+}
+
+UFortChargingSet_ArsenicCore_Dash::UFortChargingSet_ArsenicCore_Dash() {
+}
+

Source/ArsenicCoreRuntime/Private/FortChargingSet_ArsenicCore_Scream.cpp

@@ -0,0 +1,18 @@
+#include "FortChargingSet_ArsenicCore_Scream.h"
+#include "Net/UnrealNetwork.h"
+
+void UFortChargingSet_ArsenicCore_Scream::OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue) {
+}
+
+void UFortChargingSet_ArsenicCore_Scream::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Scream, CurrentCharge);
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Scream, MaxCharge);
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Scream, ChargeTime);
+    DOREPLIFETIME(UFortChargingSet_ArsenicCore_Scream, ServerTimeChargeIncrements);
+}
+
+UFortChargingSet_ArsenicCore_Scream::UFortChargingSet_ArsenicCore_Scream() {
+}
+

Source/ArsenicCoreRuntime/Private/FortCheatManager_ArsenicInterface.cpp

@@ -0,0 +1,41 @@
+#include "FortCheatManager_ArsenicInterface.h"
+
+void UFortCheatManager_ArsenicInterface::TickHightlightAllBots() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreToggleHighlightAllBots() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreToggleDrawPopulationGridOnMap() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreSpawnScriptedPawn(const FString& ProfileName) {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreSetPopulationGridRedValue(int32 RedValue) {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreLogPopulationGridData() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreKillAllNonGhosts() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreKillAllGhosts() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreConvertToHuman() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreConvertToGhost() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreConvertLookAtPawnToHuman() {
+}
+
+void UFortCheatManager_ArsenicInterface::ArsenicCoreConvertLookAtPawnToGhost() {
+}
+
+UFortCheatManager_ArsenicInterface::UFortCheatManager_ArsenicInterface() {
+}
+

Source/ArsenicCoreRuntime/Private/FortCheatManager_ConsumePickups.cpp

@@ -0,0 +1,8 @@
+#include "FortCheatManager_ConsumePickups.h"
+
+void UFortCheatManager_ConsumePickups::ConsumePickupsToggleEnabled() {
+}
+
+UFortCheatManager_ConsumePickups::UFortCheatManager_ConsumePickups() {
+}
+

Source/ArsenicCoreRuntime/Private/FortControllerComponent_ConsumePickups.cpp

@@ -0,0 +1,39 @@
+#include "FortControllerComponent_ConsumePickups.h"
+#include "Net/UnrealNetwork.h"
+
+void UFortControllerComponent_ConsumePickups::SetPickupBeingConsumed(AActor* InPickupActorBeingConsumed) {
+}
+
+void UFortControllerComponent_ConsumePickups::ServerSetPickupBeingConsumed_Implementation(AActor* InPickupActorBeingConsumed) {
+}
+
+void UFortControllerComponent_ConsumePickups::OnRep_ConsumePickups() {
+}
+
+void UFortControllerComponent_ConsumePickups::OnPlayerInteractLongUseChanged(bool bPlayerHasStartedALongUseInteraction, bool bLongUseInteractionCompleted) {
+}
+
+
+AActor* UFortControllerComponent_ConsumePickups::GetPickupThatWasLastConsumed() {
+    return NULL;
+}
+
+AActor* UFortControllerComponent_ConsumePickups::GetPickupBeingConsumed() {
+    return NULL;
+}
+
+void UFortControllerComponent_ConsumePickups::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UFortControllerComponent_ConsumePickups, bConsumePickups);
+    DOREPLIFETIME(UFortControllerComponent_ConsumePickups, ConsumePickupsMutator);
+}
+
+UFortControllerComponent_ConsumePickups::UFortControllerComponent_ConsumePickups() {
+    this->bConsumePickups = false;
+    this->ClassOfCosmeticActorToSpawnOnPickupBeingConsumed = NULL;
+    this->ActorSpawnedOnPickupThatIsBeingConsumed = NULL;
+    this->PickupActorBeingConsumed = NULL;
+    this->PickupActorThatWasLastConsumed = NULL;
+}
+

Source/ArsenicCoreRuntime/Public/ArsenicCoreGCNGhostAudioHelperComponent.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "ArsenicCoreGCNGhostAudioHelperComponent.generated.h"
+
+class APawn;
+class UAudioComponent;
+class USoundMix;
+
+UCLASS(Blueprintable, ClassGroup=Custom, meta=(BlueprintSpawnableComponent))
+class UArsenicCoreGCNGhostAudioHelperComponent : public UActorComponent {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float VelocityAudioInputRange_Min;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float VelocityAudioInputRange_Max;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float AudioInterpSpeed;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    USoundMix* VelocitySoundMix;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float VelocityThresholdForMixModActivation;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName AudioScalarParameterName;
+    
+public:
+    UArsenicCoreGCNGhostAudioHelperComponent();
+    UFUNCTION(BlueprintCallable)
+    void SetTargetPawn(APawn* InTargetPawn);
+    
+    UFUNCTION(BlueprintCallable)
+    void SetLoopingAudioComponent(UAudioComponent* InLoopingAudioComponent);
+    
+    UFUNCTION(BlueprintCallable)
+    void PopVelocitySoundMix();
+    
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicCoreHumanPawnData.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicCoreHumanPawnData.generated.h"
+
+class AFortPlayerPawnAthena;
+class AFortPlayerStateAthena;
+
+USTRUCT(BlueprintType)
+struct FArsenicCoreHumanPawnData {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortPlayerPawnAthena* Pawn;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortPlayerStateAthena* PlayerState;
+    
+    ARSENICCORERUNTIME_API FArsenicCoreHumanPawnData();
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicCorePlayerComponent.h

@@ -0,0 +1,87 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortControllerComponent.h"
+#include "GameplayTagContainer.h"
+#include "ArsenicCoreSquadMemberPlayerStatus.h"
+#include "ArsenicOnGhostScreamFoundNoSurvivorsDelegate.h"
+#include "ArsenicOnGhostVisibilityChangeDelegate.h"
+#include "ArsenicOnLocalGhostPlayerEnteredOrExitedVehicleDelegate.h"
+#include "ArsenicOnPlayerStatusChangeDelegate.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicCorePlayerComponent.generated.h"
+
+class AArsenicCoreRespawnDrone;
+class AFortAthenaMutator_ArsenicCore;
+class AFortPlayerStateAthena;
+
+UCLASS(Blueprintable, ClassGroup=Custom, meta=(BlueprintSpawnableComponent))
+class UArsenicCorePlayerComponent : public UFortControllerComponent {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnGhostVisibilityChange OnGhostVisibilityChange;
+    
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnGhostScreamFoundNoSurvivors OnGhostScreamFoundNoSurvivors;
+    
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnLocalGhostPlayerEnteredOrExitedVehicle OnLocalGhostPlayerEnteredOrExitedVehicle;
+    
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnPlayerStatusChange ArsenicOnPlayerStatusChange;
+    
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnPlayerStatusChange ArsenicOnPlayerSquadMemberStatusChanged;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_ManagingMutator, meta=(AllowPrivateAccess=true))
+    AFortAthenaMutator_ArsenicCore* ManagingMutator;
+    
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer HideWhileLoadingGameplayTagContainer;
+    
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AArsenicCoreRespawnDrone* LocalRespawnDrone;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_CurrentPlayerStatus, meta=(AllowPrivateAccess=true))
+    EArsenicCorePlayerStatus CurrentPlayerStatus;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_ScreamFoundNoSurvivors, meta=(AllowPrivateAccess=true))
+    uint8 ScreamFoundNoSurvivors;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Transient, ReplicatedUsing=OnRep_SquadMemberPlayerStatuses, meta=(AllowPrivateAccess=true))
+    TArray<FArsenicCoreSquadMemberPlayerStatus> SquadMemberPlayerStatuses;
+    
+public:
+    UArsenicCorePlayerComponent();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+    UFUNCTION(BlueprintCallable)
+    void UpdateGhostVisibilityChange(const bool bIsVisibile);
+    
+    UFUNCTION(BlueprintCallable)
+    void SetSquadMemberArsenicCorePlayerStatus(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewPlayerStatus);
+    
+    UFUNCTION(BlueprintCallable, Reliable, Server, WithValidation)
+    void ServerClientIsReadyToSpawnAsGhost();
+    
+private:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_SquadMemberPlayerStatuses(const TArray<FArsenicCoreSquadMemberPlayerStatus>& OldValue);
+    
+    UFUNCTION(BlueprintCallable)
+    void OnRep_ScreamFoundNoSurvivors();
+    
+    UFUNCTION(BlueprintCallable)
+    void OnRep_ManagingMutator();
+    
+    UFUNCTION(BlueprintCallable)
+    void OnRep_CurrentPlayerStatus();
+    
+public:
+    UFUNCTION(BlueprintCallable)
+    void GhostScreamFoundNoSurvivors();
+    
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicCorePopulationGridCellData.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicCorePopulationGridCellData.generated.h"
+
+USTRUCT(BlueprintType)
+struct FArsenicCorePopulationGridCellData {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    uint8 NumGhostPlayers;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    uint8 NumGhostBots;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    uint8 NumHumanPlayers;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    uint8 NumHumanBots;
+    
+    ARSENICCORERUNTIME_API FArsenicCorePopulationGridCellData();
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicCorePopulationTracker.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "FortPoiGridInfo.h"
+#include "ArsenicCorePopulationGridCellData.h"
+#include "ArsenicCorePopulationTracker.generated.h"
+
+class AFortAthenaMutator_ArsenicCore;
+class AFortPlayerStateAthena;
+
+UCLASS(Blueprintable)
+class ARSENICCORERUNTIME_API AArsenicCorePopulationTracker : public AActor {
+    GENERATED_BODY()
+public:
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortAthenaMutator_ArsenicCore* ArsenicCoreMutator;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortPoiGridInfo PopulationGridInfo;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    TArray<FArsenicCorePopulationGridCellData> PopulationGrid;
+    
+public:
+    AArsenicCorePopulationTracker();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+private:
+    UFUNCTION(BlueprintCallable)
+    void OnGameMemberRemoved(uint8 InSquadId, uint8 InTeamIndex, AFortPlayerStateAthena* ChangedPS);
+    
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicCoreRespawnDrone.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "UObject/NoExportTypes.h"
+#include "GameFramework/Actor.h"
+#include "ArsenicCoreRespawnDrone.generated.h"
+
+class ACameraActor;
+class AFortPlayerPawnAthena;
+class UArsenicCorePlayerComponent;
+
+UCLASS(Blueprintable)
+class AArsenicCoreRespawnDrone : public AActor {
+    GENERATED_BODY()
+public:
+    AArsenicCoreRespawnDrone();
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    ACameraActor* GetCamera() const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void BeginGhostTransitionSequence(AFortPlayerPawnAthena* PlayerPawn, UArsenicCorePlayerComponent* ArsenicCorePlayerComponent, FVector RespawnLocation);
+    
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicCoreSquadMemberPlayerStatus.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicCoreSquadMemberPlayerStatus.generated.h"
+
+class AFortPlayerStateAthena;
+
+USTRUCT(BlueprintType)
+struct FArsenicCoreSquadMemberPlayerStatus {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortPlayerStateAthena* SquadMemberPlayerState;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    EArsenicCorePlayerStatus SquadMemberPlayerStatus;
+    
+    ARSENICCORERUNTIME_API FArsenicCoreSquadMemberPlayerStatus();
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicGameModeMutatorInterface.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicGameModeMutatorInterface.generated.h"
+
+class AFortPlayerStateAthena;
+
+UINTERFACE()
+class ARSENICCORERUNTIME_API UArsenicGameModeMutatorInterface : public UInterface {
+    GENERATED_BODY()
+};
+
+class ARSENICCORERUNTIME_API IArsenicGameModeMutatorInterface : public IInterface {
+    GENERATED_BODY()
+public:
+protected:
+    UFUNCTION()
+    virtual void BroadcastArsenicOnPlayerStatusChange(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus PlayerStatus) PURE_VIRTUAL(BroadcastArsenicOnPlayerStatusChange,);
+    
+};
+

Source/ArsenicCoreRuntime/Public/ArsenicOnArsenicPlayerComponentReadyDelegate.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicOnArsenicPlayerComponentReadyDelegate.generated.h"
+
+class AFortPlayerControllerAthena;
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FArsenicOnArsenicPlayerComponentReady, const AFortPlayerControllerAthena*, PlayerController);
+

Source/ArsenicCoreRuntime/Public/ArsenicOnGhostScreamFoundNoSurvivorsDelegate.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicOnGhostScreamFoundNoSurvivorsDelegate.generated.h"
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE(FArsenicOnGhostScreamFoundNoSurvivors);
+

Source/ArsenicCoreRuntime/Public/ArsenicOnGhostTeamWonDelegate.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicOnGhostTeamWonDelegate.generated.h"
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE(FArsenicOnGhostTeamWon);
+

Source/ArsenicCoreRuntime/Public/ArsenicOnGhostVisibilityChangeDelegate.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicOnGhostVisibilityChangeDelegate.generated.h"
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FArsenicOnGhostVisibilityChange, const bool, bIsVisible);
+

Source/ArsenicCoreRuntime/Public/ArsenicOnLocalGhostPlayerEnteredOrExitedVehicleDelegate.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicOnLocalGhostPlayerEnteredOrExitedVehicleDelegate.generated.h"
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FArsenicOnLocalGhostPlayerEnteredOrExitedVehicle, const bool, bIsInVehicle);
+

Source/ArsenicCoreRuntime/Public/ArsenicOnLocalPlayerDiedAsHumanDelegate.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortPlayerDeathReport.h"
+#include "ArsenicOnLocalPlayerDiedAsHumanDelegate.generated.h"
+
+class AFortPlayerStateAthena;
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FArsenicOnLocalPlayerDiedAsHuman, const AFortPlayerStateAthena*, VictimPlayerState, const FFortPlayerDeathReport&, DeathReport);
+

Source/ArsenicCoreRuntime/Public/ArsenicOnPlayerStatusChangeDelegate.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicOnPlayerStatusChangeDelegate.generated.h"
+
+class AFortPlayerStateAthena;
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FArsenicOnPlayerStatusChange, const AFortPlayerStateAthena*, PlayerState, EArsenicCorePlayerStatus, PlayerStatus);
+

Source/ArsenicCoreRuntime/Public/ConsumePickupsManager.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "ConsumePickupsManager.generated.h"
+
+UINTERFACE()
+class UConsumePickupsManager : public UInterface {
+    GENERATED_BODY()
+};
+
+class IConsumePickupsManager : public IInterface {
+    GENERATED_BODY()
+public:
+};
+

Source/ArsenicCoreRuntime/Public/EArsenicCorePlayerStatus.h

@@ -0,0 +1,14 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.generated.h"
+
+UENUM(BlueprintType)
+enum class EArsenicCorePlayerStatus : uint8 {
+    None,
+    Human,
+    Transforming_HumanToGhost,
+    Ghost,
+    EliminatedGhost,
+    MAX,
+};
+

Source/ArsenicCoreRuntime/Public/EConsumePickupsDropOnDeathFilterRule.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EConsumePickupsDropOnDeathFilterRule.generated.h"
+
+UENUM(BlueprintType)
+enum class EConsumePickupsDropOnDeathFilterRule : uint8 {
+    DiscardLowestRarityItem,
+    DiscardHighestRarityItem,
+};
+

Source/ArsenicCoreRuntime/Public/EConsumePickupsDropOnDeathFilterRule_Definitive.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EConsumePickupsDropOnDeathFilterRule_Definitive.generated.h"
+
+UENUM(BlueprintType)
+enum class EConsumePickupsDropOnDeathFilterRule_Definitive : uint8 {
+    DiscardNewestItem,
+    DiscardOldestItem,
+    EConsumePickupsDropOnDeathFilterRule_MAX UMETA(Hidden),
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaAIBotEvaluator_Dash_ArsenicCore.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EFortBuildingType.h"
+#include "FortAthenaAIBotEvaluator.h"
+#include "AttributeSet.h"
+#include "GameplayTagContainer.h"
+#include "FortAthenaAIBotEvaluator_Dash_ArsenicCore.generated.h"
+
+UCLASS(Blueprintable, MinimalAPI)
+class UFortAthenaAIBotEvaluator_Dash_ArsenicCore : public UFortAthenaAIBotEvaluator {
+    GENERATED_BODY()
+public:
+private:
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName DashExecutionStatusName;
+    
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName TargetActorName;
+    
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName WeaponTriggerMeleeName;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MinimumTimeAfterPreviousDashToAttemptNewDash;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaximumTimeAfterPreviousDashToAttemptNewDash;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<TEnumAsByte<EFortBuildingType::Type>> DashableBuildingTypes;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTag DashAbilityCooldownTag;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat DashDistanceMagnitude;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float MinAcceptableMoveDirFacingDotProductValue;
+    
+public:
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaAIBotEvaluator_Loot_ArsenicCore.h

@@ -0,0 +1,51 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EFortRarity.h"
+#include "FortAthenaAIBotEvaluator_Loot.h"
+#include "AttributeSet.h"
+#include "GameplayTagContainer.h"
+#include "FortAthenaAIBotEvaluator_Loot_ArsenicCore.generated.h"
+
+UCLASS(Blueprintable)
+class UFortAthenaAIBotEvaluator_Loot_ArsenicCore : public UFortAthenaAIBotEvaluator_Loot {
+    GENERATED_BODY()
+public:
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat CommonRarityLootScore;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat UncommonRarityLootScore;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat RareRarityLootScore;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat LegendaryRarityLootScore;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MythicRarityLootScore;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat TranscendentRarityLootScore;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    EFortRarity MinRarityToLootWhenAboveLootConsumeHealth;
+    
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BatchLootBlacklistDuration;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BatchLootBlacklistRadius;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat LootConsumeHealthPercentThreshold;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer BlacklistedLootTags;
+    
+public:
+
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortAthenaAIBotEvaluator_MeleeAttack.h"
+#include "FortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore.generated.h"
+
+UCLASS(Blueprintable)
+class UFortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore : public UFortAthenaAIBotEvaluator_MeleeAttack {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float MaxDistanceToEngageMeleeDefensive;
+    
+private:
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName DashExecutionStatusName;
+    
+public:
+    UFortAthenaAIBotEvaluator_MeleeAttack_ArsenicCore();
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaBTService_Dash_ArsenicCore.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "BehaviorTree/BTService.h"
+#include "GameplayTagContainer.h"
+#include "FortAthenaBTService_Dash_ArsenicCore.generated.h"
+
+UCLASS(Blueprintable)
+class UFortAthenaBTService_Dash_ArsenicCore : public UBTService {
+    GENERATED_BODY()
+public:
+private:
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName DashExecutionStatusName;
+    
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer DashAbilityTagContainer;
+    
+public:
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaBTService_PickUpLoot_ArsenicCore.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortAthenaBTService_PickUpLoot.h"
+#include "GameplayTagContainer.h"
+#include "FortAthenaBTService_PickUpLoot_ArsenicCore.generated.h"
+
+UCLASS(Blueprintable, MinimalAPI)
+class UFortAthenaBTService_PickUpLoot_ArsenicCore : public UFortAthenaBTService_PickUpLoot {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer AttackInsteadOfInteractContainerTags;
+    
+private:
+    UPROPERTY(AdvancedDisplay, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FName TargetActorName;
+    
+public:
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaMutator_ArsenicCore.h

@@ -0,0 +1,240 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "UObject/NoExportTypes.h"
+#include "UObject/NoExportTypes.h"
+#include "FortAthenaMutator_GameModeBase.h"
+#include "ItemAndCount.h"
+#include "AttributeSet.h"
+#include "GameplayTagContainer.h"
+#include "GameplayTagContainer.h"
+#include "ArsenicCoreHumanPawnData.h"
+#include "ArsenicGameModeMutatorInterface.h"
+#include "ArsenicOnGhostTeamWonDelegate.h"
+#include "ArsenicOnLocalPlayerDiedAsHumanDelegate.h"
+#include "ConsumePickupsManager.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "Templates/SubclassOf.h"
+#include "FortAthenaMutator_ArsenicCore.generated.h"
+
+class AActor;
+class AArsenicCorePopulationTracker;
+class AArsenicCoreRespawnDrone;
+class AController;
+class AFortAthenaMutator_ConsumePickups;
+class AFortPlayerPawnAthena;
+class AFortPlayerStateAthena;
+class UAmbientAudioDataAsset;
+class UArsenicCorePlayerComponent;
+class UAthenaSkyDiveContrailItemDefinition;
+class UFortWeaponItemDefinition;
+class UGameplayEffect;
+class UPrimitiveComponent;
+class UTexture2D;
+
+UCLASS(Blueprintable, MinimalAPI)
+class AFortAthenaMutator_ArsenicCore : public AFortAthenaMutator_GameModeBase, public IConsumePickupsManager, public IArsenicGameModeMutatorInterface {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bEnablePopulationTracker;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat PopulationTrackerGridSpacing;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat PopulationTrackerMaxGridUpdatesPerFrame;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bBotsUseOwnScreamData;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bBotsUsePlayerScreamData;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bBotsUseOtherBotsScreamData;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotScreamDataShareRadius;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaxBotScreamStimDistance;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotChanceToIgnoreScreamStimFromPlayerScream;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotChanceToIgnoreScreamStimFromOtherBotScream;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotChanceToIgnoreScreamStimFromOwnScream;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaxNearbyGhostHumanRatioForBotScreamStim;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaxNearbyPopulationForBotScreamStim;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotScreamStimNearbyRadius;
+    
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TSubclassOf<UArsenicCorePlayerComponent> ArsenicCorePlayerComponentClass;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortAthenaMutator_ConsumePickups* ConsumePickupsMutator;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bAllowBotRespawnAsGhost;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TSubclassOf<AArsenicCoreRespawnDrone> ArsenicCoreRespawnDroneClass;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat GhostRespawnHeight;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MinimumGhostRespawnDistanceFromStormShieldBorder;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat DroneViewTargetBlendDuration;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat PlayerRespawnCountdownTimerStartValue;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotRespawnTimerValue;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<FItemAndCount> GhostItemList;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    UAthenaSkyDiveContrailItemDefinition* GhostContrails;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FLinearColor GhostHealthBarColorA;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FLinearColor GhostHealthBarColorB;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FLinearColor HumanHealthBarColorA;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FLinearColor HumanHealthBarColorB;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bShouldHideGhostShieldBar;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    UTexture2D* GhostPortrait;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    UFortWeaponItemDefinition* GhostWeaponItemDefinition;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTag BotGhostPawnTag;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FText VehiclePossessionContextText;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<TSubclassOf<UGameplayEffect>> PossessionGameplayEffectsForVehicle;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTag PossessionGameplayCueTagForVehicle;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<TSubclassOf<AActor>> GhostInteractAllowedClasses;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer GhostInteractDisallowedTags;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    UAmbientAudioDataAsset* AmbientAudioBank;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    int32 AmbientAudioBankPriority;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bEnableBotRespawnControlSystem;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bBotRespawnControlSystem_UsePopulationTracker;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotRespawnControlSystem_PopulationTrackerHumanGhostCountRadius;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat BotRespawnControlSystem_DesiredRatioOfHumanToGhostThreshold;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_bTheGhostTeamHasWon, meta=(AllowPrivateAccess=true))
+    bool bTheGhostTeamHasWon;
+    
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnGhostTeamWon ArsenicOnGhostTeamWon;
+    
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FArsenicOnLocalPlayerDiedAsHuman ArsenicOnLocalPlayerDiedAsHuman;
+    
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    TArray<AFortPlayerStateAthena*> GhostPlayerStates;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    TArray<FArsenicCoreHumanPawnData> HumanPlayerPawnDataList;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    AArsenicCorePopulationTracker* PopulationTracker;
+    
+public:
+    AFortAthenaMutator_ArsenicCore();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+private:
+    UFUNCTION(BlueprintCallable)
+    void UpdateAnalyticsDataOnPawnDied(AActor* DamagedActor, float Damage, AController* InstigatedBy, AActor* DamageCauser, FVector HitLocation, UPrimitiveComponent* FHitComponent, FName BoneName, FVector Momentum);
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_bTheGhostTeamHasWon();
+    
+public:
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsGhostThatPermaDiedTeam(uint8 TeamId) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsGhostTeam(uint8 TeamId) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsALivingTeam(uint8 TeamId) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool HasTheGhostTeamWon() const;
+    
+    UFUNCTION(BlueprintCallable)
+    float GetPopulationInRadius(FVector CenterLocation, float Radius);
+    
+    UFUNCTION(BlueprintCallable)
+    void GetPopulationAndGhostHumanRatioInRadius(FVector CenterLocation, float Radius, float& OutPopulation, float& OutGhostHumanRatio);
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    uint8 GetGhostTeam(uint8 TeamId) const;
+    
+    UFUNCTION(BlueprintCallable)
+    float GetGhostHumanRatioInRadius(FVector CenterLocation, float Radius);
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    uint8 GetEliminatedPlayersTeamId() const;
+    
+    UFUNCTION(BlueprintCallable)
+    void CreateGhostBotStimuliFromScream(AFortPlayerPawnAthena* ScreamerPawn, TArray<AFortPlayerPawnAthena*> RevealedHumans);
+    
+    
+    // Fix for true pure virtual functions not being implemented
+protected:
+    UFUNCTION()
+    void BroadcastArsenicOnPlayerStatusChange(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus PlayerStatus) override PURE_VIRTUAL(BroadcastArsenicOnPlayerStatusChange,);
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaMutator_ArsenicInventoryOverride.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EAthenaGamePhase.h"
+#include "FortAthenaMutator_InventoryOverride.h"
+#include "ItemLoadoutContainer.h"
+#include "FortAthenaMutator_ArsenicInventoryOverride.generated.h"
+
+UCLASS(Blueprintable, MinimalAPI)
+class AFortAthenaMutator_ArsenicInventoryOverride : public AFortAthenaMutator_InventoryOverride {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<FItemLoadoutContainer> PostSkyDiveInventoryLoadouts;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<FItemLoadoutContainer> ParachuteDisabledInventoryLoadout;
+    
+public:
+    AFortAthenaMutator_ArsenicInventoryOverride();
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnGamePhaseChanged(EAthenaGamePhase NewPhase);
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaMutator_ConsumePickups.h

@@ -0,0 +1,57 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortAthenaMutator.h"
+#include "AttributeSet.h"
+#include "EConsumePickupsDropOnDeathFilterRule.h"
+#include "EConsumePickupsDropOnDeathFilterRule_Definitive.h"
+#include "Templates/SubclassOf.h"
+#include "FortAthenaMutator_ConsumePickups.generated.h"
+
+class UFortControllerComponent_ConsumePickups;
+class UGameplayEffect;
+class UObject;
+
+UCLASS(Blueprintable)
+class ARSENICCORERUNTIME_API AFortAthenaMutator_ConsumePickups : public AFortAthenaMutator {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bCanConsumeWhenHealthIsFull;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat ConsumePickupInteractionTime;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaxConsumedItemsToDropOnDeath;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<EConsumePickupsDropOnDeathFilterRule> DropOnDeathFilterRules;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    EConsumePickupsDropOnDeathFilterRule_Definitive DefinitiveDropOnDeathFilterRule;
+    
+    UPROPERTY(EditAnywhere, meta=(AllowPrivateAccess=true))
+    TSubclassOf<UGameplayEffect> GameplayEffectClassesToApplyByRarity[8];
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TSubclassOf<UFortControllerComponent_ConsumePickups> ConsumePickupsControllerComponentClass;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    bool bFindAndSetManagerMutatorAutomatically;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_ManagerObject, meta=(AllowPrivateAccess=true))
+    UObject* ManagerObject;
+    
+public:
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_ManagerObject();
+    
+    UFUNCTION(BlueprintCallable)
+    void OnAllGameplayModifiersRegistered();
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortAthenaMutator_ConsumePickups_ArsenicCore.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "FortAthenaMutator_ConsumePickups.h"
+#include "FortAthenaMutator_ConsumePickups_ArsenicCore.generated.h"
+
+class AFortPlayerStateAthena;
+
+UCLASS(Blueprintable)
+class ARSENICCORERUNTIME_API AFortAthenaMutator_ConsumePickups_ArsenicCore : public AFortAthenaMutator_ConsumePickups {
+    GENERATED_BODY()
+public:
+    AFortAthenaMutator_ConsumePickups_ArsenicCore();
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus PlayerStatus);
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortChargingSet_ArsenicCore_Dash.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortChargingSet_Base.h"
+#include "FortGameplayAttributeData.h"
+#include "FortChargingSet_ArsenicCore_Dash.generated.h"
+
+UCLASS(Blueprintable)
+class UFortChargingSet_ArsenicCore_Dash : public UFortChargingSet_Base {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_CurrentCharge, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData CurrentCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData MaxCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ChargeTime;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ServerTimeChargeIncrements;
+    
+public:
+    UFortChargingSet_ArsenicCore_Dash();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue);
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortChargingSet_ArsenicCore_Scream.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortChargingSet_Base.h"
+#include "FortGameplayAttributeData.h"
+#include "FortChargingSet_ArsenicCore_Scream.generated.h"
+
+UCLASS(Blueprintable)
+class UFortChargingSet_ArsenicCore_Scream : public UFortChargingSet_Base {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_CurrentCharge, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData CurrentCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData MaxCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ChargeTime;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ServerTimeChargeIncrements;
+    
+public:
+    UFortChargingSet_ArsenicCore_Scream();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue);
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortCheatManager_ArsenicInterface.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortCheatManager_Coupled.h"
+#include "FortCheatManager_ArsenicInterface.generated.h"
+
+UCLASS(Blueprintable)
+class UFortCheatManager_ArsenicInterface : public UFortCheatManager_Coupled {
+    GENERATED_BODY()
+public:
+    UFortCheatManager_ArsenicInterface();
+protected:
+    UFUNCTION(BlueprintCallable)
+    void TickHightlightAllBots();
+    
+public:
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreToggleHighlightAllBots();
+    
+    UFUNCTION(BlueprintCallable, Exec)
+    void ArsenicCoreToggleDrawPopulationGridOnMap();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreSpawnScriptedPawn(const FString& ProfileName);
+    
+    UFUNCTION(BlueprintCallable, Exec)
+    void ArsenicCoreSetPopulationGridRedValue(int32 RedValue);
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreLogPopulationGridData();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreKillAllNonGhosts();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreKillAllGhosts();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreConvertToHuman();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreConvertToGhost();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreConvertLookAtPawnToHuman();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ArsenicCoreConvertLookAtPawnToGhost();
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortCheatManager_ConsumePickups.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortCheatManager_Coupled.h"
+#include "FortCheatManager_ConsumePickups.generated.h"
+
+UCLASS(Blueprintable)
+class UFortCheatManager_ConsumePickups : public UFortCheatManager_Coupled {
+    GENERATED_BODY()
+public:
+    UFortCheatManager_ConsumePickups();
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ConsumePickupsToggleEnabled();
+    
+};
+

Source/ArsenicCoreRuntime/Public/FortControllerComponent_ConsumePickups.h

@@ -0,0 +1,73 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortControllerComponent.h"
+#include "FortInterface_OverrideCanInteract.h"
+#include "AttributeSet.h"
+#include "Templates/SubclassOf.h"
+#include "FortControllerComponent_ConsumePickups.generated.h"
+
+class AActor;
+class AFortAthenaMutator_ConsumePickups;
+class UFortWorldItem;
+
+UCLASS(Blueprintable, ClassGroup=Custom, meta=(BlueprintSpawnableComponent))
+class UFortControllerComponent_ConsumePickups : public UFortControllerComponent, public IFortInterface_OverrideCanInteract {
+    GENERATED_BODY()
+public:
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_ConsumePickups, meta=(AllowPrivateAccess=true))
+    uint8 bConsumePickups: 1;
+    
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TSubclassOf<AActor> ClassOfCosmeticActorToSpawnOnPickupBeingConsumed;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaxDistanceToPickupBeingConsumed;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<UFortWorldItem*> ItemsToDropOnDeath;
+    
+    UPROPERTY(EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    TWeakObjectPtr<AFortAthenaMutator_ConsumePickups> ConsumePickupsMutator;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Transient, meta=(AllowPrivateAccess=true))
+    AActor* ActorSpawnedOnPickupThatIsBeingConsumed;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AActor* PickupActorBeingConsumed;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AActor* PickupActorThatWasLastConsumed;
+    
+public:
+    UFortControllerComponent_ConsumePickups();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+    UFUNCTION(BlueprintCallable)
+    void SetPickupBeingConsumed(AActor* InPickupActorBeingConsumed);
+    
+    UFUNCTION(BlueprintCallable, Server, Unreliable)
+    void ServerSetPickupBeingConsumed(AActor* InPickupActorBeingConsumed);
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_ConsumePickups();
+    
+    UFUNCTION(BlueprintCallable)
+    void OnPlayerInteractLongUseChanged(bool bPlayerHasStartedALongUseInteraction, bool bLongUseInteractionCompleted);
+    
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void OnItemConsumed(const UFortWorldItem* ConsumedItem);
+    
+public:
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    AActor* GetPickupThatWasLastConsumed();
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    AActor* GetPickupBeingConsumed();
+    
+    
+    // Fix for true pure virtual functions not being implemented
+};
+

Source/ArsenicCoreUI/ArsenicCoreUI.Build.cs

@@ -0,0 +1,90 @@
+using UnrealBuildTool;
+
+public class ArsenicCoreUI : ModuleRules {
+    public ArsenicCoreUI(ReadOnlyTargetRules Target) : base(Target) {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        bLegacyPublicIncludePaths = false;
+        ShadowVariableWarningLevel = WarningLevel.Warning;
+        
+        PublicDependencyModuleNames.AddRange(new string[] {
+            "AIModule",
+            "Account",
+            "AmbientAudio",
+            "AnimGraphRuntime",
+            "AnimationBudgetAllocator",
+            "AnimationCore",
+            "AnimationSharing",
+            "ArsenicCoreRuntime",
+            "AssetRegistry",
+            "AudioMixer",
+            "BlueprintContext",
+            "Chaos",
+            "CinematicCamera",
+            "ClientPilot",
+            "ClothingSystemRuntimeInterface",
+            "CommonDialogueRuntime",
+            "CommonInput",
+            "CommonUI",
+            "Core",
+            "CoreUObject",
+            "Curie",
+            "DataAssetDirectory",
+            "DeveloperSettings",
+            "Engine",
+            "EpicCMSUIFramework",
+            "EpicGameplayStatsRuntime",
+            "FoleySound",
+            "Foliage",
+            "FortniteGame",
+            "FortniteUI",
+            "GameSubCatalog",
+            "GameplayAbilities",
+            "GameplayTags",
+            "GameplayTasks",
+            "Gauntlet",
+            "HeadMountedDisplay",
+            "Hotfix",
+            "InputCore",
+            "JsonUtilities",
+            "Landscape",
+            "LauncherSocialDefaults",
+            "LauncherSocialTypes",
+            "LevelSequence",
+            "LiveLinkInterface",
+            "Lobby",
+            "McpProfileSys",
+            "MediaAssets",
+            "MediaUtils",
+            "MeshNetwork",
+            "ModularGameplay",
+            "MovieScene",
+            "MovieSceneTracks",
+            "NavigationSystem",
+            "Niagara",
+            "NiagaraAnimNotifies",
+            "NiagaraCore",
+            "NiagaraShader",
+            "OnlineSubsystem",
+            "OnlineSubsystemUtils",
+            "Overlay",
+            "Paper2D",
+            "Party",
+            "PhysXVehicles",
+            "PhysicsCore",
+            "PlayspaceSystem",
+            "PropertyPath",
+            "Rejoin",
+            "ReplicationGraph",
+            "SidecarSys",
+            "SignificanceManager",
+            "Slate",
+            "SlateCore",
+            "SocialUMG",
+            "SolarisUi",
+            "SubtitlesWidgets",
+            "UMG",
+            "Water",
+            "WebBrowser",
+        });
+    }
+}

Source/ArsenicCoreUI/Private/ArsenicCoreActivatablePanelBase.cpp

@@ -0,0 +1,8 @@
+#include "ArsenicCoreActivatablePanelBase.h"
+
+void UArsenicCoreActivatablePanelBase::OnPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus) {
+}
+
+UArsenicCoreActivatablePanelBase::UArsenicCoreActivatablePanelBase() {
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreHUD.cpp

@@ -0,0 +1,12 @@
+#include "ArsenicCoreHUD.h"
+
+
+
+
+
+void UArsenicCoreHUD::GhostMessagingFinished() {
+}
+
+UArsenicCoreHUD::UArsenicCoreHUD() {
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreHumansAndGhostsLeftBase.cpp

@@ -0,0 +1,7 @@
+#include "ArsenicCoreHumansAndGhostsLeftBase.h"
+
+
+
+UArsenicCoreHumansAndGhostsLeftBase::UArsenicCoreHumansAndGhostsLeftBase() {
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreInventoryReplacementScreen.cpp

@@ -0,0 +1,6 @@
+#include "ArsenicCoreInventoryReplacementScreen.h"
+
+
+UArsenicCoreInventoryReplacementScreen::UArsenicCoreInventoryReplacementScreen() {
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreKillerInfoScreen.cpp

@@ -0,0 +1,10 @@
+#include "ArsenicCoreKillerInfoScreen.h"
+
+
+void UArsenicCoreKillerInfoScreen::OnLocalPlayerDiedAsHuman(const AFortPlayerStateAthena* VictimPlayerState, const FFortPlayerDeathReport& DeathReport) {
+}
+
+UArsenicCoreKillerInfoScreen::UArsenicCoreKillerInfoScreen() {
+    this->Widget_KillerInfo = NULL;
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreSquadMemberGameplayMessageWidget.cpp

@@ -0,0 +1,6 @@
+#include "ArsenicCoreSquadMemberGameplayMessageWidget.h"
+
+
+UArsenicCoreSquadMemberGameplayMessageWidget::UArsenicCoreSquadMemberGameplayMessageWidget() {
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreSquadMemberStatusTrackingWidget.cpp

@@ -0,0 +1,8 @@
+#include "ArsenicCoreSquadMemberStatusTrackingWidget.h"
+
+void UArsenicCoreSquadMemberStatusTrackingWidget::OnSquadMemberPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus) {
+}
+
+UArsenicCoreSquadMemberStatusTrackingWidget::UArsenicCoreSquadMemberStatusTrackingWidget() {
+}
+

Source/ArsenicCoreUI/Private/ArsenicCoreUIModule.cpp

@@ -0,0 +1,3 @@
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultGameModuleImpl, ArsenicCoreUI);

Source/ArsenicCoreUI/Private/ArsenicCoreWidgetBase.cpp

@@ -0,0 +1,14 @@
+#include "ArsenicCoreWidgetBase.h"
+
+void UArsenicCoreWidgetBase::OnPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus) {
+}
+
+void UArsenicCoreWidgetBase::OnLocalPlayerGhostVisibilityChanged(const bool bIsVisibile) {
+}
+
+void UArsenicCoreWidgetBase::OnLocalGhostPlayerEnteredOrExitedVehicle(const bool bIsInVehicle) {
+}
+
+UArsenicCoreWidgetBase::UArsenicCoreWidgetBase() {
+}
+

Source/ArsenicCoreUI/Public/ArsenicCoreActivatablePanelBase.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "FortActivatablePanelLTM.h"
+#include "ArsenicCoreActivatablePanelBase.generated.h"
+
+class AFortPlayerStateAthena;
+
+UCLASS(Blueprintable, EditInlineNew, MinimalAPI)
+class UArsenicCoreActivatablePanelBase : public UFortActivatablePanelLTM {
+    GENERATED_BODY()
+public:
+    UArsenicCoreActivatablePanelBase();
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus);
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreHUD.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "GameplayTagContainer.h"
+#include "ArsenicCoreWidgetBase.h"
+#include "ArsenicCoreHUD.generated.h"
+
+UCLASS(Blueprintable, EditInlineNew)
+class ARSENICCOREUI_API UArsenicCoreHUD : public UArsenicCoreWidgetBase {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer AthenaHUDElementsToHideForGhost;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FGameplayTagContainer AthenaHUDElementsToHideForGhostMessagingAnimation;
+    
+public:
+    UArsenicCoreHUD();
+protected:
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void HandleSpectatingGhost_BP();
+    
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void HandlePlayerHasBecomeAGhost_BP();
+    
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void HandleNoSurvivorsFoundInScream_BP();
+    
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void HandleGhostVisibilityChange_BP(const bool bIsVisible);
+    
+    UFUNCTION(BlueprintCallable)
+    void GhostMessagingFinished();
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreHumansAndGhostsLeftBase.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ArsenicCoreWidgetBase.h"
+#include "ArsenicCoreHumansAndGhostsLeftBase.generated.h"
+
+UCLASS(Abstract, Blueprintable, EditInlineNew)
+class UArsenicCoreHumansAndGhostsLeftBase : public UArsenicCoreWidgetBase {
+    GENERATED_BODY()
+public:
+    UArsenicCoreHumansAndGhostsLeftBase();
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void SetHumansLeftText(const FText& HumansText);
+    
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void SetGhostsLeftText(const FText& GhostsText);
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreInventoryReplacementScreen.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicCoreActivatablePanelBase.h"
+#include "ArsenicCoreInventoryReplacementScreen.generated.h"
+
+UCLASS(Abstract, Blueprintable, EditInlineNew)
+class ARSENICCOREUI_API UArsenicCoreInventoryReplacementScreen : public UArsenicCoreActivatablePanelBase {
+    GENERATED_BODY()
+public:
+    UArsenicCoreInventoryReplacementScreen();
+protected:
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void OnOwningPlayerStatusChanged(EArsenicCorePlayerStatus NewStatus);
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreKillerInfoScreen.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortPlayerDeathReport.h"
+#include "ArsenicCoreActivatablePanelBase.h"
+#include "ArsenicCoreKillerInfoScreen.generated.h"
+
+class AFortPlayerStateAthena;
+class UAthenaLastKillerInfoWidget;
+
+UCLASS(Abstract, Blueprintable, EditInlineNew)
+class ARSENICCOREUI_API UArsenicCoreKillerInfoScreen : public UArsenicCoreActivatablePanelBase {
+    GENERATED_BODY()
+public:
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Instanced, meta=(AllowPrivateAccess=true))
+    UAthenaLastKillerInfoWidget* Widget_KillerInfo;
+    
+public:
+    UArsenicCoreKillerInfoScreen();
+protected:
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void PlayIntroAnimation();
+    
+    UFUNCTION(BlueprintCallable)
+    void OnLocalPlayerDiedAsHuman(const AFortPlayerStateAthena* VictimPlayerState, const FFortPlayerDeathReport& DeathReport);
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreSquadMemberGameplayMessageWidget.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicCoreSquadMemberStatusTrackingWidget.h"
+#include "ArsenicCoreSquadMemberGameplayMessageWidget.generated.h"
+
+class AFortPlayerStateAthena;
+
+UCLASS(Abstract, Blueprintable, EditInlineNew)
+class ARSENICCOREUI_API UArsenicCoreSquadMemberGameplayMessageWidget : public UArsenicCoreSquadMemberStatusTrackingWidget {
+    GENERATED_BODY()
+public:
+    UArsenicCoreSquadMemberGameplayMessageWidget();
+protected:
+    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
+    void OnSquadMemberPlayerStatusChanged_BP(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus);
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreSquadMemberStatusTrackingWidget.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "ArsenicCoreWidgetBase.h"
+#include "ArsenicCoreSquadMemberStatusTrackingWidget.generated.h"
+
+class AFortPlayerStateAthena;
+
+UCLASS(Abstract, Blueprintable, EditInlineNew)
+class ARSENICCOREUI_API UArsenicCoreSquadMemberStatusTrackingWidget : public UArsenicCoreWidgetBase {
+    GENERATED_BODY()
+public:
+    UArsenicCoreSquadMemberStatusTrackingWidget();
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnSquadMemberPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus);
+    
+};
+

Source/ArsenicCoreUI/Public/ArsenicCoreWidgetBase.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicCorePlayerStatus.h"
+#include "LTMWidgetBase.h"
+#include "ArsenicCoreWidgetBase.generated.h"
+
+class AFortPlayerStateAthena;
+
+UCLASS(Blueprintable, EditInlineNew, MinimalAPI)
+class UArsenicCoreWidgetBase : public ULTMWidgetBase {
+    GENERATED_BODY()
+public:
+    UArsenicCoreWidgetBase();
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnPlayerStatusChanged(const AFortPlayerStateAthena* PlayerState, EArsenicCorePlayerStatus NewStatus);
+    
+    UFUNCTION(BlueprintCallable)
+    void OnLocalPlayerGhostVisibilityChanged(const bool bIsVisibile);
+    
+    UFUNCTION(BlueprintCallable)
+    void OnLocalGhostPlayerEnteredOrExitedVehicle(const bool bIsInVehicle);
+    
+};
+

Source/ArsenicRuntime/ArsenicRuntime.Build.cs

@@ -0,0 +1,84 @@
+using UnrealBuildTool;
+
+public class ArsenicRuntime : ModuleRules {
+    public ArsenicRuntime(ReadOnlyTargetRules Target) : base(Target) {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        bLegacyPublicIncludePaths = false;
+        ShadowVariableWarningLevel = WarningLevel.Warning;
+        
+        PublicDependencyModuleNames.AddRange(new string[] {
+            "AIModule",
+            "Account",
+            "AmbientAudio",
+            "AnimGraphRuntime",
+            "AnimationBudgetAllocator",
+            "AnimationCore",
+            "AnimationSharing",
+            "ArsenicCoreRuntime",
+            "AssetRegistry",
+            "AudioMixer",
+            "BlueprintContext",
+            "Chaos",
+            "CinematicCamera",
+            "ClientPilot",
+            "ClothingSystemRuntimeInterface",
+            "CommonDialogueRuntime",
+            "CommonInput",
+            "CommonUI",
+            "Core",
+            "CoreUObject",
+            "Curie",
+            "DataAssetDirectory",
+            "DeveloperSettings",
+            "Engine",
+            "EpicGameplayStatsRuntime",
+            "FoleySound",
+            "Foliage",
+            "FortniteGame",
+            "GameSubCatalog",
+            "GameplayAbilities",
+            "GameplayTags",
+            "GameplayTasks",
+            "Gauntlet",
+            "HeadMountedDisplay",
+            "Hotfix",
+            "InputCore",
+            "JsonUtilities",
+            "Landscape",
+            "LevelSequence",
+            "LiveLinkInterface",
+            "Lobby",
+            "McpProfileSys",
+            "MediaAssets",
+            "MediaUtils",
+            "MeshNetwork",
+            "ModularGameplay",
+            "MovieScene",
+            "MovieSceneTracks",
+            "NavigationSystem",
+            "Niagara",
+            "NiagaraAnimNotifies",
+            "NiagaraCore",
+            "NiagaraShader",
+            "OnlineSubsystem",
+            "OnlineSubsystemUtils",
+            "Overlay",
+            "Paper2D",
+            "Party",
+            "PhysXVehicles",
+            "PhysicsCore",
+            "PlayspaceSystem",
+            "PropertyPath",
+            "Rejoin",
+            "ReplicationGraph",
+            "SidecarSys",
+            "SignificanceManager",
+            "Slate",
+            "SlateCore",
+            "SubtitlesWidgets",
+            "UMG",
+            "Water",
+            "WebBrowser",
+        });
+    }
+}

Source/ArsenicRuntime/Private/ArsenicPlayerDataArray.cpp

@@ -0,0 +1,5 @@
+#include "ArsenicPlayerDataArray.h"
+
+FArsenicPlayerDataArray::FArsenicPlayerDataArray() {
+}
+

Source/ArsenicRuntime/Private/ArsenicPlayerDataEntry.cpp

@@ -0,0 +1,7 @@
+#include "ArsenicPlayerDataEntry.h"
+
+FArsenicPlayerDataEntry::FArsenicPlayerDataEntry() {
+    this->PlayerState = NULL;
+    this->bHasRevealedTeam = false;
+}
+

Source/ArsenicRuntime/Private/ArsenicRuntimeModule.cpp

@@ -0,0 +1,3 @@
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultGameModuleImpl, ArsenicRuntime);

Source/ArsenicRuntime/Private/FortAthenaMutator_Arsenic.cpp

@@ -0,0 +1,78 @@
+#include "FortAthenaMutator_Arsenic.h"
+#include "Net/UnrealNetwork.h"
+
+void AFortAthenaMutator_Arsenic::RequestGameMessageOnServer(EArsenicGameMsgId MsgId) const {
+}
+
+void AFortAthenaMutator_Arsenic::RequestGameMessageOnClient(EArsenicGameMsgId MsgId) const {
+}
+
+void AFortAthenaMutator_Arsenic::RefreshPlayerIndicators(AFortPlayerStateAthena* PlayerState) {
+}
+
+void AFortAthenaMutator_Arsenic::OnCurrentPlaylistLoaded(FName PlaylistName, const FGameplayTagContainer& PlaylistContainerTags) {
+}
+
+bool AFortAthenaMutator_Arsenic::IsPlaylistDBNOEnabled() const {
+    return false;
+}
+
+bool AFortAthenaMutator_Arsenic::IsPlayerTeamRevealed(const AFortPlayerStateAthena* PlayerState) const {
+    return false;
+}
+
+bool AFortAthenaMutator_Arsenic::IsPlayerARevealedInfected(const AFortPlayerController* PC) const {
+    return false;
+}
+
+bool AFortAthenaMutator_Arsenic::IsPawnAnInfected(const AFortPawn* Pawn) const {
+    return false;
+}
+
+bool AFortAthenaMutator_Arsenic::IsHeartbeatEnabled() const {
+    return false;
+}
+
+bool AFortAthenaMutator_Arsenic::IsHealOverTimeEnabled() const {
+    return false;
+}
+
+bool AFortAthenaMutator_Arsenic::IsGrowlEnabled() const {
+    return false;
+}
+
+FString AFortAthenaMutator_Arsenic::GetWinner() const {
+    return TEXT("");
+}
+
+float AFortAthenaMutator_Arsenic::GetTimeRemaining() const {
+    return 0.0f;
+}
+
+int32 AFortAthenaMutator_Arsenic::GetTeamPlayerCount(uint8 Team) {
+    return 0;
+}
+
+void AFortAthenaMutator_Arsenic::EndGame(uint8 WinningTeam) {
+}
+
+void AFortAthenaMutator_Arsenic::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(AFortAthenaMutator_Arsenic, Winner);
+    DOREPLIFETIME(AFortAthenaMutator_Arsenic, TagTeamInfo);
+    DOREPLIFETIME(AFortAthenaMutator_Arsenic, PlayerDataArray);
+    DOREPLIFETIME(AFortAthenaMutator_Arsenic, bCheatHeartbeatEnabled);
+}
+
+AFortAthenaMutator_Arsenic::AFortAthenaMutator_Arsenic() {
+    this->Winner = TEXT("WinnerNotSet");
+    this->bGameTimeExpired = false;
+    this->HumanDeathSound = NULL;
+    this->HumanTeam = 4;
+    this->InfectedTeam = 3;
+    this->ConsumePickupsMutator = NULL;
+    this->CachedInventoryOverrideMutator = NULL;
+    this->bCheatHeartbeatEnabled = true;
+}
+

Source/ArsenicRuntime/Private/FortAthenaMutator_ArsenicRespawn.cpp

@@ -0,0 +1,3 @@
+#include "FortAthenaMutator_ArsenicRespawn.h"
+
+

Source/ArsenicRuntime/Private/FortChargingSet_Arsenic_Hurl.cpp

@@ -0,0 +1,18 @@
+#include "FortChargingSet_Arsenic_Hurl.h"
+#include "Net/UnrealNetwork.h"
+
+void UFortChargingSet_Arsenic_Hurl::OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue) {
+}
+
+void UFortChargingSet_Arsenic_Hurl::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Hurl, CurrentCharge);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Hurl, MaxCharge);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Hurl, ChargeTime);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Hurl, ServerTimeChargeIncrements);
+}
+
+UFortChargingSet_Arsenic_Hurl::UFortChargingSet_Arsenic_Hurl() {
+}
+

Source/ArsenicRuntime/Private/FortChargingSet_Arsenic_Scream.cpp

@@ -0,0 +1,18 @@
+#include "FortChargingSet_Arsenic_Scream.h"
+#include "Net/UnrealNetwork.h"
+
+void UFortChargingSet_Arsenic_Scream::OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue) {
+}
+
+void UFortChargingSet_Arsenic_Scream::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Scream, CurrentCharge);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Scream, MaxCharge);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Scream, ChargeTime);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Scream, ServerTimeChargeIncrements);
+}
+
+UFortChargingSet_Arsenic_Scream::UFortChargingSet_Arsenic_Scream() {
+}
+

Source/ArsenicRuntime/Private/FortChargingSet_Arsenic_Sniff.cpp

@@ -0,0 +1,18 @@
+#include "FortChargingSet_Arsenic_Sniff.h"
+#include "Net/UnrealNetwork.h"
+
+void UFortChargingSet_Arsenic_Sniff::OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue) {
+}
+
+void UFortChargingSet_Arsenic_Sniff::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+    
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Sniff, CurrentCharge);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Sniff, MaxCharge);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Sniff, ChargeTime);
+    DOREPLIFETIME(UFortChargingSet_Arsenic_Sniff, ServerTimeChargeIncrements);
+}
+
+UFortChargingSet_Arsenic_Sniff::UFortChargingSet_Arsenic_Sniff() {
+}
+

Source/ArsenicRuntime/Private/FortCheatManager_Arsenic.cpp

@@ -0,0 +1,32 @@
+#include "FortCheatManager_Arsenic.h"
+
+void UFortCheatManager_Arsenic::ToggleWinConditionEnabled() {
+}
+
+void UFortCheatManager_Arsenic::ToggleInfectedModifiedDamageEnabled() {
+}
+
+void UFortCheatManager_Arsenic::ToggleHeartbeatEnabled() {
+}
+
+void UFortCheatManager_Arsenic::ToggleHealOverTimeEnabled() {
+}
+
+void UFortCheatManager_Arsenic::ToggleGrowlEnabled() {
+}
+
+void UFortCheatManager_Arsenic::ToggleDBNOEnabled() {
+}
+
+void UFortCheatManager_Arsenic::SetMatchTime(float NewTime) {
+}
+
+void UFortCheatManager_Arsenic::SetInfectedDamageToStructuralBuildingPercent(float DamagePercent) {
+}
+
+void UFortCheatManager_Arsenic::SetInfectedDamageToBuildingPercent(float DamagePercent) {
+}
+
+UFortCheatManager_Arsenic::UFortCheatManager_Arsenic() {
+}
+

Source/ArsenicRuntime/Public/ArsenicPlayerDataArray.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/NetSerialization.h"
+#include "ArsenicPlayerDataEntry.h"
+#include "ArsenicPlayerDataArray.generated.h"
+
+USTRUCT(BlueprintType)
+struct FArsenicPlayerDataArray : public FFastArraySerializer {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TArray<FArsenicPlayerDataEntry> Entries;
+    
+    ARSENICRUNTIME_API FArsenicPlayerDataArray();
+};
+

Source/ArsenicRuntime/Public/ArsenicPlayerDataEntry.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/NetSerialization.h"
+#include "ArsenicPlayerDataEntry.generated.h"
+
+class AFortPlayerStateAthena;
+
+USTRUCT(BlueprintType)
+struct FArsenicPlayerDataEntry : public FFastArraySerializerItem {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Transient, meta=(AllowPrivateAccess=true))
+    AFortPlayerStateAthena* PlayerState;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Transient, meta=(AllowPrivateAccess=true))
+    bool bHasRevealedTeam;
+    
+    ARSENICRUNTIME_API FArsenicPlayerDataEntry();
+};
+

Source/ArsenicRuntime/Public/EArsenicGameMsgId.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "EArsenicGameMsgId.generated.h"
+
+UENUM(BlueprintType)
+enum class EArsenicGameMsgId : uint8 {
+    None,
+    InitialTeamRevealed,
+    BecameInfected,
+    OneHumanRemaining,
+};
+

Source/ArsenicRuntime/Public/FortAthenaMutator_Arsenic.h

@@ -0,0 +1,141 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "ConsumePickupsManager.h"
+#include "AthenaGameMessageData.h"
+#include "FortAthenaMutator_GameModeBase.h"
+#include "TagTeamInfoArray.h"
+#include "AttributeSet.h"
+#include "GameplayTagContainer.h"
+#include "ArsenicPlayerDataArray.h"
+#include "EArsenicGameMsgId.h"
+#include "OnPlayerTeamRevealedDelegate.h"
+#include "FortAthenaMutator_Arsenic.generated.h"
+
+class AFortAthenaMutator_ArsenicInventoryOverride;
+class AFortAthenaMutator_ConsumePickups;
+class AFortPawn;
+class AFortPlayerController;
+class AFortPlayerStateAthena;
+class USoundBase;
+
+UCLASS(Blueprintable)
+class ARSENICRUNTIME_API AFortAthenaMutator_Arsenic : public AFortAthenaMutator_GameModeBase, public IConsumePickupsManager {
+    GENERATED_BODY()
+public:
+    UPROPERTY(BlueprintAssignable, BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FOnPlayerTeamRevealed OnPlayerTeamRevealedDelegate;
+    
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat InitialInfectedPct;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat InfectedDamageToBuildingPercent;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat InfectedDamageToStructuralBuildingPercent;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, Transient, meta=(AllowPrivateAccess=true))
+    FString Winner;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Transient, meta=(AllowPrivateAccess=true))
+    bool bGameTimeExpired;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    USoundBase* HumanDeathSound;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TMap<EArsenicGameMsgId, FAthenaGameMessageData> GameMsgs_Infected;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    TMap<EArsenicGameMsgId, FAthenaGameMessageData> GameMsgs_Human;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MinInitialVehicleFuelPercent;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat MaxInitialVehicleFuelPercent;
+    
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    uint8 HumanTeam;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    uint8 InfectedTeam;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, Transient, meta=(AllowPrivateAccess=true))
+    FTagTeamInfoArray TagTeamInfo;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, Transient, meta=(AllowPrivateAccess=true))
+    FArsenicPlayerDataArray PlayerDataArray;
+    
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FScalableFloat bInfectedConsumePickups;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortAthenaMutator_ConsumePickups* ConsumePickupsMutator;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    AFortAthenaMutator_ArsenicInventoryOverride* CachedInventoryOverrideMutator;
+    
+private:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, Transient, meta=(AllowPrivateAccess=true))
+    bool bCheatHeartbeatEnabled;
+    
+public:
+    AFortAthenaMutator_Arsenic();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, BlueprintPure=false)
+    void RequestGameMessageOnServer(EArsenicGameMsgId MsgId) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintCosmetic, BlueprintPure=false)
+    void RequestGameMessageOnClient(EArsenicGameMsgId MsgId) const;
+    
+    UFUNCTION(BlueprintCallable)
+    void RefreshPlayerIndicators(AFortPlayerStateAthena* PlayerState);
+    
+private:
+    UFUNCTION(BlueprintCallable)
+    void OnCurrentPlaylistLoaded(FName PlaylistName, const FGameplayTagContainer& PlaylistContainerTags);
+    
+public:
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsPlaylistDBNOEnabled() const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsPlayerTeamRevealed(const AFortPlayerStateAthena* PlayerState) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsPlayerARevealedInfected(const AFortPlayerController* PC) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsPawnAnInfected(const AFortPawn* Pawn) const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    bool IsHeartbeatEnabled() const;
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, BlueprintPure)
+    bool IsHealOverTimeEnabled() const;
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, BlueprintPure)
+    bool IsGrowlEnabled() const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    FString GetWinner() const;
+    
+    UFUNCTION(BlueprintCallable, BlueprintPure)
+    float GetTimeRemaining() const;
+    
+    UFUNCTION(BlueprintCallable)
+    int32 GetTeamPlayerCount(uint8 Team);
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void EndGame(uint8 WinningTeam);
+    
+    
+    // Fix for true pure virtual functions not being implemented
+};
+

Source/ArsenicRuntime/Public/FortAthenaMutator_ArsenicRespawn.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortAthenaMutator.h"
+#include "FortRespawnLogicData_Teams.h"
+#include "FortAthenaMutator_ArsenicRespawn.generated.h"
+
+UCLASS(Blueprintable)
+class AFortAthenaMutator_ArsenicRespawn : public AFortAthenaMutator {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    bool bRespawnAwayFromDeathLocation;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float MinimumDistanceFromDeath;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    float MaximumDistanceFromDeath;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(AllowPrivateAccess=true))
+    FFortRespawnLogicData_Teams RespawnSettings;
+    
+public:
+};
+

Source/ArsenicRuntime/Public/FortChargingSet_Arsenic_Hurl.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortChargingSet_Base.h"
+#include "FortGameplayAttributeData.h"
+#include "FortChargingSet_Arsenic_Hurl.generated.h"
+
+UCLASS(Blueprintable)
+class UFortChargingSet_Arsenic_Hurl : public UFortChargingSet_Base {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_CurrentCharge, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData CurrentCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData MaxCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ChargeTime;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ServerTimeChargeIncrements;
+    
+public:
+    UFortChargingSet_Arsenic_Hurl();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue);
+    
+};
+

Source/ArsenicRuntime/Public/FortChargingSet_Arsenic_Scream.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortChargingSet_Base.h"
+#include "FortGameplayAttributeData.h"
+#include "FortChargingSet_Arsenic_Scream.generated.h"
+
+UCLASS(Blueprintable)
+class UFortChargingSet_Arsenic_Scream : public UFortChargingSet_Base {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_CurrentCharge, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData CurrentCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData MaxCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ChargeTime;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ServerTimeChargeIncrements;
+    
+public:
+    UFortChargingSet_Arsenic_Scream();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue);
+    
+};
+

Source/ArsenicRuntime/Public/FortChargingSet_Arsenic_Sniff.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortChargingSet_Base.h"
+#include "FortGameplayAttributeData.h"
+#include "FortChargingSet_Arsenic_Sniff.generated.h"
+
+UCLASS(Blueprintable)
+class UFortChargingSet_Arsenic_Sniff : public UFortChargingSet_Base {
+    GENERATED_BODY()
+public:
+protected:
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, ReplicatedUsing=OnRep_CurrentCharge, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData CurrentCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData MaxCharge;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ChargeTime;
+    
+    UPROPERTY(BlueprintReadWrite, EditAnywhere, Replicated, meta=(AllowPrivateAccess=true))
+    FFortGameplayAttributeData ServerTimeChargeIncrements;
+    
+public:
+    UFortChargingSet_Arsenic_Sniff();
+    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+    
+protected:
+    UFUNCTION(BlueprintCallable)
+    void OnRep_CurrentCharge(const FFortGameplayAttributeData& OldValue);
+    
+};
+

Source/ArsenicRuntime/Public/FortCheatManager_Arsenic.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "FortCheatManager_Coupled.h"
+#include "FortCheatManager_Arsenic.generated.h"
+
+UCLASS(Blueprintable)
+class UFortCheatManager_Arsenic : public UFortCheatManager_Coupled {
+    GENERATED_BODY()
+public:
+    UFortCheatManager_Arsenic();
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ToggleWinConditionEnabled();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ToggleInfectedModifiedDamageEnabled();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ToggleHeartbeatEnabled();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ToggleHealOverTimeEnabled();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ToggleGrowlEnabled();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void ToggleDBNOEnabled();
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void SetMatchTime(float NewTime);
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void SetInfectedDamageToStructuralBuildingPercent(float DamagePercent);
+    
+    UFUNCTION(BlueprintAuthorityOnly, BlueprintCallable, Exec)
+    void SetInfectedDamageToBuildingPercent(float DamagePercent);
+    
+};
+

Source/ArsenicRuntime/Public/OnPlayerTeamRevealedDelegate.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "OnPlayerTeamRevealedDelegate.generated.h"
+
+class AFortPlayerStateAthena;
+
+UDELEGATE(BlueprintCallable) DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPlayerTeamRevealed, AFortPlayerStateAthena*, PlayerState);
+