asa/_actor_8h_source.html

#pragma once

#include "UE.h"

#include "Math/Transform.h"


struct FPrimalChatMessage {

    FString SenderName;

    FString SenderSteamName;

    FString SenderTribeName;

    unsigned int SenderId;

    FString Message;

    FString Receiver;

    int SenderTeamIndex;

    long double ReceivedTime;

    TEnumAsByte<enum EChatSendMode::Type> SendMode;

    unsigned int RadioFrequency;

    TEnumAsByte<enum EChatType::Type> ChatType;

    UTexture2D* SenderIcon;

    unsigned __int8 senderPlatform;

    FString UserId;

    unsigned __int8 SenderIsAdmin : 1;

    FPrimalChatMessage()

        : SenderName(""),

        SenderSteamName(""),

        SenderTribeName(""),

        SenderId(0),

        Message(""),

        Receiver(""),

        SenderTeamIndex(0),

        ReceivedTime(0),

        SendMode(EChatSendMode::GlobalChat),

        RadioFrequency(0),

        ChatType(EChatType::GlobalChat),

        SenderIcon(nullptr),

        UserId(""),

        senderPlatform((unsigned char)1)

    {

    }

    FPrimalChatMessage* operator=(FPrimalChatMessage* __that) { return NativeCall<FPrimalChatMessage*, FPrimalChatMessage*>(this, "FPrimalChatMessage.operator=(FPrimalChatMessage&)", __that); }

};


struct FPrimalPlayerCharacterConfigStructReplicated

{

    unsigned __int8 bIsFemale : 1;

    FLinearColor BodyColors[4];

    FString PlayerCharacterName;

    unsigned __int8 FacialHairIndex;

    unsigned __int8 HeadHairIndex;

    unsigned __int8 EyebrowIndex;

    float PercentOfFullHeadHairGrowth;

    float PercentOfFullFacialHairGrowth;

    float RawBoneModifiers[26];

    int PlayerSpawnRegionIndex;

    unsigned __int8 OverrideHeadHairColor[2];

    unsigned __int8 OverrideFacialHairColor[2];

    unsigned __int8 DynamicMaterialBytes[50];

    int PlayerVoiceCollectionIndex;

    unsigned __int8 bUsingCustomPlayerVoiceCollection : 1;


    // Fields


    FieldArray<FLinearColor, 4> BodyColorsField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.BodyColors" }; }

    FString& PlayerCharacterNameField() { return *GetNativePointerField<FString*>(this, "FPrimalPlayerCharacterConfigStructReplicated.PlayerCharacterName"); }

    unsigned __int8& HeadHairIndexField() { return *GetNativePointerField<unsigned __int8*>(this, "FPrimalPlayerCharacterConfigStructReplicated.HeadHairIndex"); }

    float& PercentOfFullHeadHairGrowthField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerCharacterConfigStructReplicated.PercentOfFullHeadHairGrowth"); }

    float& PercentOfFullFacialHairGrowthField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerCharacterConfigStructReplicated.PercentOfFullFacialHairGrowth"); }

    FieldArray<float, 26> RawBoneModifiersField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.RawBoneModifiers" }; }

    int& PlayerSpawnRegionIndexField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerCharacterConfigStructReplicated.PlayerSpawnRegionIndex"); }

    FieldArray<unsigned __int8, 2> OverrideHeadHairColorField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.OverrideHeadHairColor" }; }

    FieldArray<unsigned __int8, 2> OverrideFacialHairColorField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.OverrideFacialHairColor" }; }

    FieldArray<unsigned __int8, 50> DynamicMaterialBytesField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.DynamicMaterialBytes" }; }

    int& PlayerVoiceCollectionIndexField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerCharacterConfigStructReplicated.PlayerVoiceCollectionIndex"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bIsFemaleField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.bIsFemale" }; }

    BitFieldValue<bool, unsigned __int32> bUsingCustomPlayerVoiceCollectionField() { return { this, "FPrimalPlayerCharacterConfigStructReplicated.bUsingCustomPlayerVoiceCollection" }; }


    // Functions


    //void FPrimalPlayerCharacterConfigStructReplicated(const FPrimalPlayerCharacterConfigStructReplicated* __that) { NativeCall<void, const FPrimalPlayerCharacterConfigStructReplicated*>(this, "FPrimalPlayerCharacterConfigStructReplicated.FPrimalPlayerCharacterConfigStructReplicated(FPrimalPlayerCharacterConfigStructReplicated&)", __that); }

    static UScriptStruct* StaticStruct() { return NativeCall<UScriptStruct*>(nullptr, "FPrimalPlayerCharacterConfigStructReplicated.StaticStruct()"); }

    FPrimalPlayerCharacterConfigStructReplicated* operator=(const FPrimalPlayerCharacterConfigStructReplicated* __that) { return NativeCall<FPrimalPlayerCharacterConfigStructReplicated*, const FPrimalPlayerCharacterConfigStructReplicated*>(this, "FPrimalPlayerCharacterConfigStructReplicated.operator=(FPrimalPlayerCharacterConfigStructReplicated&)", __that); }

    //void FPrimalPlayerCharacterConfigStructReplicated() { NativeCall<void>(this, "FPrimalPlayerCharacterConfigStructReplicated.FPrimalPlayerCharacterConfigStructReplicated()"); }

    FPrimalPlayerCharacterConfigStructReplicated* operator=(FPrimalPlayerCharacterConfigStructReplicated* __that) { return NativeCall<FPrimalPlayerCharacterConfigStructReplicated*, FPrimalPlayerCharacterConfigStructReplicated*>(this, "FPrimalPlayerCharacterConfigStructReplicated.operator=(FPrimalPlayerCharacterConfigStructReplicated&)", __that); }

    //void FPrimalPlayerCharacterConfigStructReplicated(FPrimalPlayerCharacterConfigStructReplicated* __that) { NativeCall<void, FPrimalPlayerCharacterConfigStructReplicated*>(this, "FPrimalPlayerCharacterConfigStructReplicated.FPrimalPlayerCharacterConfigStructReplicated(FPrimalPlayerCharacterConfigStructReplicated&)", __that); }

    FPrimalPlayerCharacterConfigStruct* GetPlayerCharacterConfig(FPrimalPlayerCharacterConfigStruct* result) { return NativeCall<FPrimalPlayerCharacterConfigStruct*, FPrimalPlayerCharacterConfigStruct*>(this, "FPrimalPlayerCharacterConfigStructReplicated.GetPlayerCharacterConfig()", result); }

    //void FPrimalPlayerCharacterConfigStructReplicated(const FPrimalPlayerCharacterConfigStruct* fromConfig) { NativeCall<void, const FPrimalPlayerCharacterConfigStruct*>(this, "FPrimalPlayerCharacterConfigStructReplicated.FPrimalPlayerCharacterConfigStructReplicated(FPrimalPlayerCharacterConfigStruct&)", fromConfig); }

};


struct UDamageType : UObject

{

    // Fields


    float& DamageImpulseField() { return *GetNativePointerField<float*>(this, "UDamageType.DamageImpulse"); }

    float& DestructibleImpulseField() { return *GetNativePointerField<float*>(this, "UDamageType.DestructibleImpulse"); }

    float& DestructibleDamageSpreadScaleField() { return *GetNativePointerField<float*>(this, "UDamageType.DestructibleDamageSpreadScale"); }

    float& DamageFalloffField() { return *GetNativePointerField<float*>(this, "UDamageType.DamageFalloff"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bIsPassiveDamage() { return { this, "UDamageType.bIsPassiveDamage" }; }

    BitFieldValue<bool, unsigned __int32> bCausedByWorld() { return { this, "UDamageType.bCausedByWorld" }; }

    BitFieldValue<bool, unsigned __int32> bScaleMomentumByMass() { return { this, "UDamageType.bScaleMomentumByMass" }; }

    BitFieldValue<bool, unsigned __int32> bRadialDamageVelChange() { return { this, "UDamageType.bRadialDamageVelChange" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UDamageType.StaticClass()"); }

    //void UDamageType(const FObjectInitializer* ObjectInitializer) { NativeCall<void, const FObjectInitializer*>(this, "UDamageType.UDamageType(FObjectInitializer&)", ObjectInitializer); }

};


struct UPrimalActor : UObject

{

    // Fields


    FTargetingTeamChanged& OnTargetingTeamChangedField() { return *GetNativePointerField<FTargetingTeamChanged*>(this, "UPrimalActor.OnTargetingTeamChanged"); }

    TMulticastDelegate<void __cdecl(UPrimalActor*, int, int), FDefaultDelegateUserPolicy>& OnTeamChangedForActorField() { return *GetNativePointerField<TMulticastDelegate<void __cdecl(UPrimalActor*, int, int), FDefaultDelegateUserPolicy>*>(this, "UPrimalActor.OnTeamChangedForActor"); }

    int& TargetingTeamField() { return *GetNativePointerField<int*>(this, "UPrimalActor.TargetingTeam"); }

    int& CustomActorFlagsField() { return *GetNativePointerField<int*>(this, "UPrimalActor.CustomActorFlags"); }

    TObjectPtr<AActor>& ActorUsingQuickActionField() { return *GetNativePointerField<TObjectPtr<AActor>*>(this, "UPrimalActor.ActorUsingQuickAction"); }

    FName& CustomTagField() { return *GetNativePointerField<FName*>(this, "UPrimalActor.CustomTag"); }

    int& CustomDataField() { return *GetNativePointerField<int*>(this, "UPrimalActor.CustomData"); }

    FActorCustomEventSignature& OnActorCustomEventField() { return *GetNativePointerField<FActorCustomEventSignature*>(this, "UPrimalActor.OnActorCustomEvent"); }

    long double& LastThrottledTickTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.LastThrottledTickTime"); }

    FActorMatineeUpdated& OnMatineeUpdatedField() { return *GetNativePointerField<FActorMatineeUpdated*>(this, "UPrimalActor.OnMatineeUpdated"); }

    TMulticastDelegate<void __cdecl(void), FDefaultDelegateUserPolicy>& OnMatineeUpdatedRawField() { return *GetNativePointerField<TMulticastDelegate<void __cdecl(void), FDefaultDelegateUserPolicy>*>(this, "UPrimalActor.OnMatineeUpdatedRaw"); }

    TEnumAsByte<enum EReplicationGraphBehavior>& DesiredRepGraphBehaviorField() { return *GetNativePointerField<TEnumAsByte<enum EReplicationGraphBehavior>*>(this, "UPrimalActor.DesiredRepGraphBehavior"); }

    long double& ForceMaximumReplicationRateUntilTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.ForceMaximumReplicationRateUntilTime"); }

    long double& LastActorForceReplicationTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.LastActorForceReplicationTime"); }

    int& LastActorForceReplicationFrameField() { return *GetNativePointerField<int*>(this, "UPrimalActor.LastActorForceReplicationFrame"); }

    float& NetworkAndStasisRangeMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalActor.NetworkAndStasisRangeMultiplier"); }

    float& NetworkRangeMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalActor.NetworkRangeMultiplier"); }

    float& NetCullDistanceSquaredDormantField() { return *GetNativePointerField<float*>(this, "UPrimalActor.NetCullDistanceSquaredDormant"); }

    int& NetworkDormantChildrenOpIdxField() { return *GetNativePointerField<int*>(this, "UPrimalActor.NetworkDormantChildrenOpIdx"); }

    int& LastFrameCalculatedNetworkRangeMultiplierField() { return *GetNativePointerField<int*>(this, "UPrimalActor.LastFrameCalculatedNetworkRangeMultiplier"); }

    TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >& NetworkSpatializationChildrenField() { return *GetNativePointerField<TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.NetworkSpatializationChildren"); }

    TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >& NetworkSpatializationChildrenDormantField() { return *GetNativePointerField<TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.NetworkSpatializationChildrenDormant"); }

    TObjectPtr<AActor>& NetworkSpatializationParentField() { return *GetNativePointerField<TObjectPtr<AActor>*>(this, "UPrimalActor.NetworkSpatializationParent"); }

    int& DefaultStasisComponentOctreeFlagsField() { return *GetNativePointerField<int*>(this, "UPrimalActor.DefaultStasisComponentOctreeFlags"); }

    int& DefaultStasisedOctreeFlagsField() { return *GetNativePointerField<int*>(this, "UPrimalActor.DefaultStasisedOctreeFlags"); }

    int& DefaultUnstasisedOctreeFlagsField() { return *GetNativePointerField<int*>(this, "UPrimalActor.DefaultUnstasisedOctreeFlags"); }

    float& OverrideStasisComponentRadiusField() { return *GetNativePointerField<float*>(this, "UPrimalActor.OverrideStasisComponentRadius"); }

    TObjectPtr<UPrimitiveComponent>& StasisCheckComponentField() { return *GetNativePointerField<TObjectPtr<UPrimitiveComponent>*>(this, "UPrimalActor.StasisCheckComponent"); }

    long double& UnstasisLastInRangeTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.UnstasisLastInRangeTime"); }

    long double& LastPreReplicationTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.LastPreReplicationTime"); }

    long double& LastEnterStasisTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.LastEnterStasisTime"); }

    long double& LastExitStasisTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.LastExitStasisTime"); }

    FString& LastSelectedWindSourceComponentNameField() { return *GetNativePointerField<FString*>(this, "UPrimalActor.LastSelectedWindSourceComponentName"); }

    unsigned __int8& RandomStartByteField() { return *GetNativePointerField<unsigned __int8*>(this, "UPrimalActor.RandomStartByte"); }

    unsigned __int64& LastFrameUnStasisField() { return *GetNativePointerField<unsigned __int64*>(this, "UPrimalActor.LastFrameUnStasis"); }

    volatile int& LastUnstasisFrameCounterField() { return *GetNativePointerField<volatile int*>(this, "UPrimalActor.LastUnstasisFrameCounter"); }

    TArray<TWeakObjectPtr<UActorComponent>, TSizedDefaultAllocator<32> >& StasisUnRegisteredComponentsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UActorComponent>, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.StasisUnRegisteredComponents"); }

    float& ReplicationIntervalMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalActor.ReplicationIntervalMultiplier"); }

    float& ClientReplicationSendNowThresholdField() { return *GetNativePointerField<float*>(this, "UPrimalActor.ClientReplicationSendNowThreshold"); }

    int& ForceImmediateReplicationFrameField() { return *GetNativePointerField<int*>(this, "UPrimalActor.ForceImmediateReplicationFrame"); }

    TWeakObjectPtr<USoundBase>& LastPostProcessVolumeSoundField() { return *GetNativePointerField<TWeakObjectPtr<USoundBase>*>(this, "UPrimalActor.LastPostProcessVolumeSound"); }

    FActorSemaphoreTaken& OnSemaphoreTakenField() { return *GetNativePointerField<FActorSemaphoreTaken*>(this, "UPrimalActor.OnSemaphoreTaken"); }

    long double& OriginalCreationTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalActor.OriginalCreationTime"); }

    __int64& LastActorUnstasisedCycleField() { return *GetNativePointerField<__int64*>(this, "UPrimalActor.LastActorUnstasisedCycle"); }

    unsigned int& LastOnlyInitialReplicationPreReplicationFrameField() { return *GetNativePointerField<unsigned int*>(this, "UPrimalActor.LastOnlyInitialReplicationPreReplicationFrame"); }

    TArray<FTimerHandle, TSizedDefaultAllocator<32> >& TimerStasisStoreField() { return *GetNativePointerField<TArray<FTimerHandle, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.TimerStasisStore"); }

    TArray<TObjectPtr<AMatineeActor>, TSizedDefaultAllocator<32> >& ControllingMatineeActorsField() { return *GetNativePointerField<TArray<TObjectPtr<AMatineeActor>, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.ControllingMatineeActors"); }

    int& NetCriticalPriorityAdjustmentField() { return *GetNativePointerField<int*>(this, "UPrimalActor.NetCriticalPriorityAdjustment"); }

    UMovementComponent*& DeferredMovementComponentField() { return *GetNativePointerField<UMovementComponent**>(this, "UPrimalActor.DeferredMovementComponent"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bIsShooterPlayerController() { return { this, "UPrimalActor.bIsShooterPlayerController" }; }

    BitFieldValue<bool, unsigned __int32> bIsPrimalDino() { return { this, "UPrimalActor.bIsPrimalDino" }; }

    BitFieldValue<bool, unsigned __int32> bIsShooterCharacter() { return { this, "UPrimalActor.bIsShooterCharacter" }; }

    BitFieldValue<bool, unsigned __int32> bIsPrimalCharacter() { return { this, "UPrimalActor.bIsPrimalCharacter" }; }

    BitFieldValue<bool, unsigned __int32> bIsPrimalStructure() { return { this, "UPrimalActor.bIsPrimalStructure" }; }

    BitFieldValue<bool, unsigned __int32> bIsPrimalStructureExplosive() { return { this, "UPrimalActor.bIsPrimalStructureExplosive" }; }

    BitFieldValue<bool, unsigned __int32> bIsInstancedFoliage() { return { this, "UPrimalActor.bIsInstancedFoliage" }; }

    BitFieldValue<bool, unsigned __int32> bPreventSaving() { return { this, "UPrimalActor.bPreventSaving" }; }

    BitFieldValue<bool, unsigned __int32> bEnableMultiUse() { return { this, "UPrimalActor.bEnableMultiUse" }; }

    BitFieldValue<bool, unsigned __int32> bBlueprintMultiUseEntries() { return { this, "UPrimalActor.bBlueprintMultiUseEntries" }; }

    BitFieldValue<bool, unsigned __int32> bUseCanMoveThroughActor() { return { this, "UPrimalActor.bUseCanMoveThroughActor" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPFilterMultiUseEntries() { return { this, "UPrimalActor.bUseBPFilterMultiUseEntries" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetMultiUseCenterText() { return { this, "UPrimalActor.bUseBPGetMultiUseCenterText" }; }

    BitFieldValue<bool, unsigned __int32> bMultiUseCenterHUD() { return { this, "UPrimalActor.bMultiUseCenterHUD" }; }

    BitFieldValue<bool, unsigned __int32> bUseNetworkSpatialization() { return { this, "UPrimalActor.bUseNetworkSpatialization" }; }

    BitFieldValue<bool, unsigned __int32> bNetworkSpatializationForceRelevancyCheck() { return { this, "UPrimalActor.bNetworkSpatializationForceRelevancyCheck" }; }

    BitFieldValue<bool, unsigned __int32> bNetUseClientRelevancy() { return { this, "UPrimalActor.bNetUseClientRelevancy" }; }

    BitFieldValue<bool, unsigned __int32> bAttachmentReplicationUseNetworkParent() { return { this, "UPrimalActor.bAttachmentReplicationUseNetworkParent" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPChangedActorTeam() { return { this, "UPrimalActor.bUseBPChangedActorTeam" }; }

    BitFieldValue<bool, unsigned __int32> bForceNetworkSpatialization() { return { this, "UPrimalActor.bForceNetworkSpatialization" }; }

    BitFieldValue<bool, unsigned __int32> bForcedHudDrawingRequiresSameTeam() { return { this, "UPrimalActor.bForcedHudDrawingRequiresSameTeam" }; }

    BitFieldValue<bool, unsigned __int32> bIsMapActor() { return { this, "UPrimalActor.bIsMapActor" }; }

    BitFieldValue<bool, unsigned __int32> bUseOnlyPointForLevelBounds() { return { this, "UPrimalActor.bUseOnlyPointForLevelBounds" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCheckForErrors() { return { this, "UPrimalActor.bUseBPCheckForErrors" }; }

    BitFieldValue<bool, unsigned __int32> bHasHighVolumeRPCs() { return { this, "UPrimalActor.bHasHighVolumeRPCs" }; }

    BitFieldValue<bool, unsigned __int32> bAutoStasis() { return { this, "UPrimalActor.bAutoStasis" }; }

    BitFieldValue<bool, unsigned __int32> bClimbable() { return { this, "UPrimalActor.bClimbable" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPDrawEntry() { return { this, "UPrimalActor.bUseBPDrawEntry" }; }

    BitFieldValue<bool, unsigned __int32> bPreventCliffPlatforms() { return { this, "UPrimalActor.bPreventCliffPlatforms" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideUILocation() { return { this, "UPrimalActor.bUseBPOverrideUILocation" }; }

    BitFieldValue<bool, unsigned __int32> bStasised() { return { this, "UPrimalActor.bStasised" }; }

    BitFieldValue<bool, unsigned __int32> bPreventActorStasis() { return { this, "UPrimalActor.bPreventActorStasis" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetBonesToHideOnAllocation() { return { this, "UPrimalActor.bUseBPGetBonesToHideOnAllocation" }; }

    BitFieldValue<bool, unsigned __int32> bReplicateHidden() { return { this, "UPrimalActor.bReplicateHidden" }; }

    BitFieldValue<bool, unsigned __int32> bPendingUnstasis() { return { this, "UPrimalActor.bPendingUnstasis" }; }

    BitFieldValue<bool, unsigned __int32> bHibernateChange() { return { this, "UPrimalActor.bHibernateChange" }; }

    BitFieldValue<bool, unsigned __int32> bSavedWhenStasised() { return { this, "UPrimalActor.bSavedWhenStasised" }; }

    BitFieldValue<bool, unsigned __int32> bLoadedFromSaveGame() { return { this, "UPrimalActor.bLoadedFromSaveGame" }; }

    BitFieldValue<bool, unsigned __int32> bPreventCharacterBasing() { return { this, "UPrimalActor.bPreventCharacterBasing" }; }

    BitFieldValue<bool, unsigned __int32> bPreventCharacterBasingAllowSteppingUp() { return { this, "UPrimalActor.bPreventCharacterBasingAllowSteppingUp" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreNetworkRangeScaling() { return { this, "UPrimalActor.bIgnoreNetworkRangeScaling" }; }

    BitFieldValue<bool, unsigned __int32> bForceReplicateDormantChildrenWithoutSpatialRelevancy() { return { this, "UPrimalActor.bForceReplicateDormantChildrenWithoutSpatialRelevancy" }; }

    BitFieldValue<bool, unsigned __int32> bForcePreventSeamlessTravel() { return { this, "UPrimalActor.bForcePreventSeamlessTravel" }; }

    BitFieldValue<bool, unsigned __int32> bPreventLevelBoundsRelevant() { return { this, "UPrimalActor.bPreventLevelBoundsRelevant" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPInventoryItemUsed() { return { this, "UPrimalActor.bUseBPInventoryItemUsed" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPInventoryItemDropped() { return { this, "UPrimalActor.bUseBPInventoryItemDropped" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideTargetingLocation() { return { this, "UPrimalActor.bUseBPOverrideTargetingLocation" }; }

    BitFieldValue<bool, unsigned __int32> bForceAllowNetMulticast() { return { this, "UPrimalActor.bForceAllowNetMulticast" }; }

    BitFieldValue<bool, unsigned __int32> bBPInventoryItemUsedHandlesDurability() { return { this, "UPrimalActor.bBPInventoryItemUsedHandlesDurability" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPForceAllowsInventoryUse() { return { this, "UPrimalActor.bUseBPForceAllowsInventoryUse" }; }

    BitFieldValue<bool, unsigned __int32> bAlwaysRelevantPrimalStructure() { return { this, "UPrimalActor.bAlwaysRelevantPrimalStructure" }; }

    BitFieldValue<bool, unsigned __int32> bPreventNPCSpawnFloor() { return { this, "UPrimalActor.bPreventNPCSpawnFloor" }; }

    BitFieldValue<bool, unsigned __int32> bForceHiddenReplication() { return { this, "UPrimalActor.bForceHiddenReplication" }; }

    BitFieldValue<bool, unsigned __int32> bNetCritical() { return { this, "UPrimalActor.bNetCritical" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyReplicateOnNetForcedUpdate() { return { this, "UPrimalActor.bOnlyReplicateOnNetForcedUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bPreventRegularForceNetUpdate() { return { this, "UPrimalActor.bPreventRegularForceNetUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyInitialReplication() { return { this, "UPrimalActor.bOnlyInitialReplication" }; }

    BitFieldValue<bool, unsigned __int32> bPreventOnDedicatedServer() { return { this, "UPrimalActor.bPreventOnDedicatedServer" }; }

    BitFieldValue<bool, unsigned __int32> bUseAttachmentReplication() { return { this, "UPrimalActor.bUseAttachmentReplication" }; }

    BitFieldValue<bool, unsigned __int32> bStasisComponentRadiusForceDistanceCheck() { return { this, "UPrimalActor.bStasisComponentRadiusForceDistanceCheck" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoredByCharacterEncroachment() { return { this, "UPrimalActor.bIgnoredByCharacterEncroachment" }; }

    BitFieldValue<bool, unsigned __int32> bNetMulticasting() { return { this, "UPrimalActor.bNetMulticasting" }; }

    BitFieldValue<bool, unsigned __int32> bDormantNetMulticastForceFullReplication() { return { this, "UPrimalActor.bDormantNetMulticastForceFullReplication" }; }

    BitFieldValue<bool, unsigned __int32> bForceIgnoreSpatialComponent() { return { this, "UPrimalActor.bForceIgnoreSpatialComponent" }; }

    BitFieldValue<bool, unsigned __int32> bWasForceIgnoreSpatialComponent() { return { this, "UPrimalActor.bWasForceIgnoreSpatialComponent" }; }

    BitFieldValue<bool, unsigned __int32> bWillStasisAfterSpawn() { return { this, "UPrimalActor.bWillStasisAfterSpawn" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetHUDDrawLocationOffset() { return { this, "UPrimalActor.bUseBPGetHUDDrawLocationOffset" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPPreventAttachments() { return { this, "UPrimalActor.bUseBPPreventAttachments" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetShowDebugAnimationComponents() { return { this, "UPrimalActor.bUseBPGetShowDebugAnimationComponents" }; }

    BitFieldValue<bool, unsigned __int32> bUnstreamComponentsUseEndOverlap() { return { this, "UPrimalActor.bUnstreamComponentsUseEndOverlap" }; }

    BitFieldValue<bool, unsigned __int32> bWantsPerformanceThrottledTick() { return { this, "UPrimalActor.bWantsPerformanceThrottledTick" }; }

    BitFieldValue<bool, unsigned __int32> bAddedPerformanceThrottledTick() { return { this, "UPrimalActor.bAddedPerformanceThrottledTick" }; }

    BitFieldValue<bool, unsigned __int32> bAddedTagsList() { return { this, "UPrimalActor.bAddedTagsList" }; }

    BitFieldValue<bool, unsigned __int32> bWantsServerThrottledTick() { return { this, "UPrimalActor.bWantsServerThrottledTick" }; }

    BitFieldValue<bool, unsigned __int32> bAddedServerThrottledTick() { return { this, "UPrimalActor.bAddedServerThrottledTick" }; }

    BitFieldValue<bool, unsigned __int32> bBPPreInitializeComponents() { return { this, "UPrimalActor.bBPPreInitializeComponents" }; }

    BitFieldValue<bool, unsigned __int32> bBPPostInitializeComponents() { return { this, "UPrimalActor.bBPPostInitializeComponents" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCustomIsRelevantForClient() { return { this, "UPrimalActor.bUseBPCustomIsRelevantForClient" }; }

    BitFieldValue<bool, unsigned __int32> bUseStasisGrid() { return { this, "UPrimalActor.bUseStasisGrid" }; }

    BitFieldValue<bool, unsigned __int32> bAlwaysCreatePhysicsState() { return { this, "UPrimalActor.bAlwaysCreatePhysicsState" }; }

    BitFieldValue<bool, unsigned __int32> bForceInfiniteDrawDistance() { return { this, "UPrimalActor.bForceInfiniteDrawDistance" }; }

    BitFieldValue<bool, unsigned __int32> bIsFromChildActorComponent() { return { this, "UPrimalActor.bIsFromChildActorComponent" }; }

    BitFieldValue<bool, unsigned __int32> bIsDestroyedFromChildActorComponent() { return { this, "UPrimalActor.bIsDestroyedFromChildActorComponent" }; }

    BitFieldValue<bool, unsigned __int32> bIsValidUnstasisCaster() { return { this, "UPrimalActor.bIsValidUnstasisCaster" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAllowActorSpawn() { return { this, "UPrimalActor.bUseBPAllowActorSpawn" }; }

    BitFieldValue<bool, unsigned __int32> bWantsRealtimeThrottledTick() { return { this, "UPrimalActor.bWantsRealtimeThrottledTick" }; }

    BitFieldValue<bool, unsigned __int32> bAddedRealtimeThrottledTick() { return { this, "UPrimalActor.bAddedRealtimeThrottledTick" }; }

    BitFieldValue<bool, unsigned __int32> bRealtimeThrottledTickUseNativeTick() { return { this, "UPrimalActor.bRealtimeThrottledTickUseNativeTick" }; }


    // Functions


    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "UPrimalActor.IsValidUnStasisCaster()"); }

    bool AllowSeamlessTravel() { return NativeCall<bool>(this, "UPrimalActor.AllowSeamlessTravel()"); }

    float GetNetworkRangeMultiplier() { return NativeCall<float>(this, "UPrimalActor.GetNetworkRangeMultiplier()"); }

    bool GetIsMapActor() { return NativeCall<bool>(this, "UPrimalActor.GetIsMapActor()"); }

    bool AllowSaving() { return NativeCall<bool>(this, "UPrimalActor.AllowSaving()"); }

    void ControlRigNotify(FName NotifyName, FName NotifyCustomTag, const FHitResult* WorldSpaceHitResult, const UE::Math::TVector<double>* Velocity) { NativeCall<void, FName, FName, const FHitResult*, const UE::Math::TVector<double>*>(this, "UPrimalActor.ControlRigNotify(FName,FName,FHitResult&,UE::Math::TVector<double>&)", NotifyName, NotifyCustomTag, WorldSpaceHitResult, Velocity); }

    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "UPrimalActor.ChangeActorTeam(int)", NewTeam); }

    bool ForceInfiniteDrawDistanceOnComponent(const UPrimitiveComponent* OnComponent) { return NativeCall<bool, const UPrimitiveComponent*>(this, "UPrimalActor.ForceInfiniteDrawDistanceOnComponent(UPrimitiveComponent*)", OnComponent); }

    void TargetingTeamChanged() { NativeCall<void>(this, "UPrimalActor.TargetingTeamChanged()"); }

    float OffsetHUDFromCenterScreenY_Implementation() { return NativeCall<float>(this, "UPrimalActor.OffsetHUDFromCenterScreenY_Implementation(AHUD*)"); }

    bool IsShooterCharacter() { return NativeCall<bool>(this, "UPrimalActor.IsShooterCharacter()"); }

    bool IsPrimalDino() { return NativeCall<bool>(this, "UPrimalActor.IsPrimalDino()"); }

    bool IsPrimalCharacter() { return NativeCall<bool>(this, "UPrimalActor.IsPrimalCharacter()"); }

    bool IsPrimalStructure() { return NativeCall<bool>(this, "UPrimalActor.IsPrimalStructure()"); }

    bool IsPrimalCharacterOrStructure() { return NativeCall<bool>(this, "UPrimalActor.IsPrimalCharacterOrStructure()"); }

    bool IsInstancedFoliage() { return NativeCall<bool>(this, "UPrimalActor.IsInstancedFoliage()"); }

    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "UPrimalActor.GetPrivateStaticClass()"); }

    bool AllowIgnoreCharacterEncroachment(UPrimitiveComponent* HitComponent, AActor* EncroachingCharacter) { return NativeCall<bool, UPrimitiveComponent*, AActor*>(this, "UPrimalActor.AllowIgnoreCharacterEncroachment(UPrimitiveComponent*,AActor*)", HitComponent, EncroachingCharacter); }

    bool AllowManualMultiUseActivation(APlayerController* ForPC) { return NativeCall<bool, APlayerController*>(this, "UPrimalActor.AllowManualMultiUseActivation(APlayerController*)", ForPC); }

    void BPAttachedRootComponent() { NativeCall<void>(this, "UPrimalActor.BPAttachedRootComponent()"); }

    void DrawBasicFloatingHUD(AHUD* ForHUD) { NativeCall<void, AHUD*>(this, "UPrimalActor.DrawBasicFloatingHUD(AHUD*)", ForHUD); }

    float GetUsablePriority() { return NativeCall<float>(this, "UPrimalActor.GetUsablePriority()"); }

    FMultiUseWheelOption* GetWheelOptionInfoBP(FMultiUseWheelOption* result, APlayerController* ForPC, int WheelCategory) { return NativeCall<FMultiUseWheelOption*, FMultiUseWheelOption*, APlayerController*, int>(this, "UPrimalActor.GetWheelOptionInfoBP(APlayerController*,int)", result, ForPC, WheelCategory); }

    void ModifyHudMultiUseLoc(UE::Math::TVector2<double>* theVec, APlayerController* PC, int index) { NativeCall<void, UE::Math::TVector2<double>*, APlayerController*, int>(this, "UPrimalActor.ModifyHudMultiUseLoc(UE::Math::TVector2<double>&,APlayerController*,int)", theVec, PC, index); }

    static void StaticRegisterNativesUPrimalActor() { NativeCall<void>(nullptr, "UPrimalActor.StaticRegisterNativesUPrimalActor()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    bool CheckBPAllowActorSpawn(UWorld* World, const UE::Math::TVector<double>* AtLocation, const UE::Math::TRotator<double>* AtRotation, AActor* ForOwner, APawn* ForInstigator) { return NativeCall<bool, UWorld*, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*, AActor*, APawn*>(this, "UPrimalActor.CheckBPAllowActorSpawn(UWorld*,UE::Math::TVector<double>&,UE::Math::TRotator<double>&,AActor*,APawn*)", World, AtLocation, AtRotation, ForOwner, ForInstigator); }

    void MatineeUpdated() { NativeCall<void>(this, "UPrimalActor.MatineeUpdated()"); }

    bool PreventCharacterBasing(AActor* OtherActor, UPrimitiveComponent* BasedOnComponent) { return NativeCall<bool, AActor*, UPrimitiveComponent*>(this, "UPrimalActor.PreventCharacterBasing(AActor*,UPrimitiveComponent*)", OtherActor, BasedOnComponent); }

    float GetApproachRadius() { return NativeCall<float>(this, "UPrimalActor.GetApproachRadius()"); }

    bool UseNetworkRangeScaling() { return NativeCall<bool>(this, "UPrimalActor.UseNetworkRangeScaling()"); }

    float GetNetStasisAndRangeMultiplier(bool bIsForNetworking) { return NativeCall<float, bool>(this, "UPrimalActor.GetNetStasisAndRangeMultiplier(bool)", bIsForNetworking); }

    void InventoryItemUsed(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "UPrimalActor.InventoryItemUsed(UObject*)", InventoryItemObject); }

    void InventoryItemDropped(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "UPrimalActor.InventoryItemDropped(UObject*)", InventoryItemObject); }

    bool ForceAllowsInventoryUse(const UObject* InventoryItemObject) { return NativeCall<bool, const UObject*>(this, "UPrimalActor.ForceAllowsInventoryUse(UObject*)", InventoryItemObject); }

    void PlaySoundOnActor(USoundCue* InSoundCue, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundCue*, float, float>(this, "UPrimalActor.PlaySoundOnActor(USoundCue*,float,float)", InSoundCue, VolumeMultiplier, PitchMultiplier); }

    void ClientMultiUse(APlayerController* ForPC, int UseIndex, int hitBodyInstance) { NativeCall<void, APlayerController*, int, int>(this, "UPrimalActor.ClientMultiUse(APlayerController*,int,int)", ForPC, UseIndex, hitBodyInstance); }

    bool TryMultiUse(APlayerController* ForPC, int UseIndex, int hitBodyInstance) { return NativeCall<bool, APlayerController*, int, int>(this, "UPrimalActor.TryMultiUse(APlayerController*,int,int)", ForPC, UseIndex, hitBodyInstance); }

    void InputDismissPOI(APlayerController* ForPC, int Index) { NativeCall<void, APlayerController*, int>(this, "UPrimalActor.InputDismissPOI(APlayerController*,int)", ForPC, Index); }

    void GetMultiUseEntries(APlayerController* ForPC, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* MultiUseEntries, int hitBodyInstance) { NativeCall<void, APlayerController*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*, int>(this, "UPrimalActor.GetMultiUseEntries(APlayerController*,TArray<FMultiUseEntry,TSizedDefaultAllocator<32>>&,int)", ForPC, MultiUseEntries, hitBodyInstance); }

    UTexture2D* GetMultiUseIcon(APlayerController* ForPC, FMultiUseEntry* MultiUseEntry) { return NativeCall<UTexture2D*, APlayerController*, FMultiUseEntry*>(this, "UPrimalActor.GetMultiUseIcon(APlayerController*,FMultiUseEntry)", ForPC, MultiUseEntry); }

    void SetDesiredRepGraphBehavior(EReplicationGraphBehavior NewBehavior) { NativeCall<void, EReplicationGraphBehavior>(this, "UPrimalActor.SetDesiredRepGraphBehavior(EReplicationGraphBehavior)", NewBehavior); }

    void FilterMultiUseEntries(APlayerController* ForPC, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* MultiUseEntries) { NativeCall<void, APlayerController*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.FilterMultiUseEntries(APlayerController*,TArray<FMultiUseEntry,TSizedDefaultAllocator<32>>&)", ForPC, MultiUseEntries); }

    bool GetMultiUseCenterText(APlayerController* ForPC, int UseIndex, FString* OutCenterText, FLinearColor* OutCenterTextColor) { return NativeCall<bool, APlayerController*, int, FString*, FLinearColor*>(this, "UPrimalActor.GetMultiUseCenterText(APlayerController*,int,FString&,FLinearColor&)", ForPC, UseIndex, OutCenterText, OutCenterTextColor); }

    FMultiUseWheelOption* GetWheelOptionInfo(FMultiUseWheelOption* result, APlayerController* ForPC, int WheelCategory) { return NativeCall<FMultiUseWheelOption*, FMultiUseWheelOption*, APlayerController*, int>(this, "UPrimalActor.GetWheelOptionInfo(APlayerController*,int)", result, ForPC, WheelCategory); }

    FMultiUseWheelOption* GetWheelOptionByUseIndex(FMultiUseWheelOption* result, APlayerController* ForPC, int Index) { return NativeCall<FMultiUseWheelOption*, FMultiUseWheelOption*, APlayerController*, int>(this, "UPrimalActor.GetWheelOptionByUseIndex(APlayerController*,int)", result, ForPC, Index); }

    float BPOverrideServerMultiUseAcceptRange_Implementation() { return NativeCall<float>(this, "UPrimalActor.BPOverrideServerMultiUseAcceptRange_Implementation()"); }

    void GetAllSceneComponents(TArray<USceneComponent*, TSizedDefaultAllocator<32> >* OutComponents) { NativeCall<void, TArray<USceneComponent*, TSizedDefaultAllocator<32> >*>(this, "UPrimalActor.GetAllSceneComponents(TArray<USceneComponent*,TSizedDefaultAllocator<32>>&)", OutComponents); }

    void AddControllingMatineeActor(AMatineeActor* InMatineeActor) { NativeCall<void, AMatineeActor*>(this, "UPrimalActor.AddControllingMatineeActor(AMatineeActor&)", InMatineeActor); }

    void RemoveControllingMatineeActor(AMatineeActor* InMatineeActor) { NativeCall<void, AMatineeActor*>(this, "UPrimalActor.RemoveControllingMatineeActor(AMatineeActor&)", InMatineeActor); }

    bool IsMatineeControlled() { return NativeCall<bool>(this, "UPrimalActor.IsMatineeControlled()"); }

    void OnUROPostInterpolation_AnyThread(float Delta, USkeletalMeshComponent* Mesh, FAnimationEvaluationContext* InOutContext) { NativeCall<void, float, USkeletalMeshComponent*, FAnimationEvaluationContext*>(this, "UPrimalActor.OnUROPostInterpolation_AnyThread(float,USkeletalMeshComponent*,FAnimationEvaluationContext&)", Delta, Mesh, InOutContext); }

    void MulticastProperty(FName PropertyName, bool bUnreliable) { NativeCall<void, FName, bool>(this, "UPrimalActor.MulticastProperty(FName,bool)", PropertyName, bUnreliable); }

    void ForceReplicateNow(bool bForceCreateChannel, bool bForceCreateChannelIfRelevant, bool bOnlyIfNoChannel) { NativeCall<void, bool, bool, bool>(this, "UPrimalActor.ForceReplicateNow(bool,bool,bool)", bForceCreateChannel, bForceCreateChannelIfRelevant, bOnlyIfNoChannel); }

};


struct UActorComponent : UObject

{

    // Fields


    FActorComponentTickFunction& PrimaryComponentTickField() { return *GetNativePointerField<FActorComponentTickFunction*>(this, "UActorComponent.PrimaryComponentTick"); }

    TArray<FName, TSizedDefaultAllocator<32> >& ComponentTagsField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "UActorComponent.ComponentTags"); }

    TArray<TObjectPtr<UAssetUserData>, TSizedDefaultAllocator<32> >& AssetUserDataField() { return *GetNativePointerField<TArray<TObjectPtr<UAssetUserData>, TSizedDefaultAllocator<32> >*>(this, "UActorComponent.AssetUserData"); }

    int& MarkedForEndOfFrameUpdateArrayIndexField() { return *GetNativePointerField<int*>(this, "UActorComponent.MarkedForEndOfFrameUpdateArrayIndex"); }

    int& UCSSerializationIndexField() { return *GetNativePointerField<int*>(this, "UActorComponent.UCSSerializationIndex"); }

    EComponentCreationMethod& CreationMethodField() { return *GetNativePointerField<EComponentCreationMethod*>(this, "UActorComponent.CreationMethod"); }

    FActorComponentDeactivateSignature& OnComponentDeactivatedField() { return *GetNativePointerField<FActorComponentDeactivateSignature*>(this, "UActorComponent.OnComponentDeactivated"); }

    AActor*& OwnerPrivateField() { return *GetNativePointerField<AActor**>(this, "UActorComponent.OwnerPrivate"); }

    UWorld*& WorldPrivateField() { return *GetNativePointerField<UWorld**>(this, "UActorComponent.WorldPrivate"); }

    FName& CustomTagField() { return *GetNativePointerField<FName*>(this, "UActorComponent.CustomTag"); }

    int& CustomDataField() { return *GetNativePointerField<int*>(this, "UActorComponent.CustomData"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bRegistered() { return { this, "UActorComponent.bRegistered" }; }

    BitFieldValue<bool, unsigned __int32> bRenderStateCreated() { return { this, "UActorComponent.bRenderStateCreated" }; }

    BitFieldValue<bool, unsigned __int32> bPhysicsStateCreated() { return { this, "UActorComponent.bPhysicsStateCreated" }; }

    BitFieldValue<bool, unsigned __int32> bNetAddressable() { return { this, "UActorComponent.bNetAddressable" }; }

    BitFieldValue<bool, unsigned __int32> bReplicateUsingRegisteredSubObjectList() { return { this, "UActorComponent.bReplicateUsingRegisteredSubObjectList" }; }

    BitFieldValue<bool, unsigned __int32> bReplicates() { return { this, "UActorComponent.bReplicates" }; }

    BitFieldValue<bool, unsigned __int32> bRenderStateDirty() { return { this, "UActorComponent.bRenderStateDirty" }; }

    BitFieldValue<bool, unsigned __int32> bRenderTransformDirty() { return { this, "UActorComponent.bRenderTransformDirty" }; }

    BitFieldValue<bool, unsigned __int32> bRenderDynamicDataDirty() { return { this, "UActorComponent.bRenderDynamicDataDirty" }; }

    BitFieldValue<bool, unsigned __int32> bRenderInstancesDirty() { return { this, "UActorComponent.bRenderInstancesDirty" }; }

    BitFieldValue<bool, unsigned __int32> bRoutedPostRename() { return { this, "UActorComponent.bRoutedPostRename" }; }

    BitFieldValue<bool, unsigned __int32> bAutoRegister() { return { this, "UActorComponent.bAutoRegister" }; }

    BitFieldValue<bool, unsigned __int32> bAllowReregistration() { return { this, "UActorComponent.bAllowReregistration" }; }

    BitFieldValue<bool, unsigned __int32> bTickInEditor() { return { this, "UActorComponent.bTickInEditor" }; }

    BitFieldValue<bool, unsigned __int32> bNeverNeedsRenderUpdate() { return { this, "UActorComponent.bNeverNeedsRenderUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bAllowConcurrentTick() { return { this, "UActorComponent.bAllowConcurrentTick" }; }

    BitFieldValue<bool, unsigned __int32> bAllowAnyoneToDestroyMe() { return { this, "UActorComponent.bAllowAnyoneToDestroyMe" }; }

    BitFieldValue<bool, unsigned __int32> bAutoActivate() { return { this, "UActorComponent.bAutoActivate" }; }

    BitFieldValue<bool, unsigned __int32> bIsActive() { return { this, "UActorComponent.bIsActive" }; }

    BitFieldValue<bool, unsigned __int32> bEditableWhenInherited() { return { this, "UActorComponent.bEditableWhenInherited" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyRelevantToOwner() { return { this, "UActorComponent.bOnlyRelevantToOwner" }; }

    BitFieldValue<bool, unsigned __int32> bNavigationRelevant() { return { this, "UActorComponent.bNavigationRelevant" }; }

    BitFieldValue<bool, unsigned __int32> bCanEverAffectNavigation() { return { this, "UActorComponent.bCanEverAffectNavigation" }; }

    BitFieldValue<bool, unsigned __int32> bWantsInitializeComponent() { return { this, "UActorComponent.bWantsInitializeComponent" }; }

    BitFieldValue<bool, unsigned __int32> bIsEditorOnly() { return { this, "UActorComponent.bIsEditorOnly" }; }

    BitFieldValue<bool, unsigned __int32> bHasBeenCreated() { return { this, "UActorComponent.bHasBeenCreated" }; }

    BitFieldValue<bool, unsigned __int32> bHasBeenInitialized() { return { this, "UActorComponent.bHasBeenInitialized" }; }

    BitFieldValue<bool, unsigned __int32> bIsReadyForReplication() { return { this, "UActorComponent.bIsReadyForReplication" }; }

    BitFieldValue<bool, unsigned __int32> bHasBegunPlay() { return { this, "UActorComponent.bHasBegunPlay" }; }

    BitFieldValue<bool, unsigned __int32> bIsBeingDestroyed() { return { this, "UActorComponent.bIsBeingDestroyed" }; }

    BitFieldValue<bool, unsigned __int32> bTickFunctionsRegistered() { return { this, "UActorComponent.bTickFunctionsRegistered" }; }

    BitFieldValue<bool, unsigned __int32> bIsNetStartupComponent() { return { this, "UActorComponent.bIsNetStartupComponent" }; }

    BitFieldValue<bool, unsigned __int32> MarkedForEndOfFrameUpdateState() { return { this, "UActorComponent.MarkedForEndOfFrameUpdateState" }; }

    BitFieldValue<bool, unsigned __int32> bMarkedForPreEndOfFrameSync() { return { this, "UActorComponent.bMarkedForPreEndOfFrameSync" }; }

    BitFieldValue<bool, unsigned __int32> bAsyncPhysicsTickEnabled() { return { this, "UActorComponent.bAsyncPhysicsTickEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bStasisPreventUnregister() { return { this, "UActorComponent.bStasisPreventUnregister" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyInitialReplication() { return { this, "UActorComponent.bOnlyInitialReplication" }; }

    BitFieldValue<bool, unsigned __int32> bPreventOnDedicatedServer() { return { this, "UActorComponent.bPreventOnDedicatedServer" }; }

    BitFieldValue<bool, unsigned __int32> bPreventOnConsoles() { return { this, "UActorComponent.bPreventOnConsoles" }; }

    BitFieldValue<bool, unsigned __int32> bPreventOnClient() { return { this, "UActorComponent.bPreventOnClient" }; }

    BitFieldValue<bool, unsigned __int32> bPreventOnNonDedicatedHost() { return { this, "UActorComponent.bPreventOnNonDedicatedHost" }; }

    BitFieldValue<bool, unsigned __int32> bDedicatedForceTickingEveryFrame() { return { this, "UActorComponent.bDedicatedForceTickingEveryFrame" }; }

    BitFieldValue<bool, unsigned __int32> bAlwaysReplicatePropertyConditional() { return { this, "UActorComponent.bAlwaysReplicatePropertyConditional" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnComponentTick() { return { this, "UActorComponent.bUseBPOnComponentTick" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnComponentDestroyed() { return { this, "UActorComponent.bUseBPOnComponentDestroyed" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnComponentCreated() { return { this, "UActorComponent.bUseBPOnComponentCreated" }; }


    // Functions


    UWorld* GetWorld() { return NativeCall<UWorld*>(this, "UActorComponent.GetWorld()"); }

    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "UActorComponent.GetPrivateStaticClass()"); }

    void AsyncPhysicsTickComponent(float DeltaTime, float SimTime) { NativeCall<void, float, float>(this, "UActorComponent.AsyncPhysicsTickComponent(float,float)", DeltaTime, SimTime); }

    ELifetimeCondition GetReplicationCondition() { return NativeCall<ELifetimeCondition>(this, "UActorComponent.GetReplicationCondition()"); }

    void PostInitProperties() { NativeCall<void>(this, "UActorComponent.PostInitProperties()"); }

    void OnCreatePhysicsState() { NativeCall<void>(this, "UActorComponent.OnCreatePhysicsState()"); }

    static void StaticRegisterNativesUActorComponent() { NativeCall<void>(nullptr, "UActorComponent.StaticRegisterNativesUActorComponent()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "UActorComponent.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    bool Rename(const wchar_t* InName, UObject* NewOuter, unsigned int Flags) { return NativeCall<bool, const wchar_t*, UObject*, unsigned int>(this, "UActorComponent.Rename(wchar_t*,UObject*,unsignedint)", InName, NewOuter, Flags); }

    void PostRename(UObject* OldOuter, const FName OldName) { NativeCall<void, UObject*, const FName>(this, "UActorComponent.PostRename(UObject*,FName)", OldOuter, OldName); }

    bool AllowRegisterWithWorld(UWorld* InWorld) { return NativeCall<bool, UWorld*>(this, "UActorComponent.AllowRegisterWithWorld(UWorld*)", InWorld); }

    void FailedToRegisterWithWorld(UWorld* InWorld) { NativeCall<void, UWorld*>(this, "UActorComponent.FailedToRegisterWithWorld(UWorld*)", InWorld); }

    UWorld* GetWorld_Uncached() { return NativeCall<UWorld*>(this, "UActorComponent.GetWorld_Uncached()"); }

    bool ComponentHasTag(FName Tag) { return NativeCall<bool, FName>(this, "UActorComponent.ComponentHasTag(FName)", Tag); }

    ENetMode InternalGetNetMode() { return NativeCall<ENetMode>(this, "UActorComponent.InternalGetNetMode()"); }

    FString* GetReadableName(FString* result) { return NativeCall<FString*, FString*>(this, "UActorComponent.GetReadableName()", result); }

    void BeginDestroy() { NativeCall<void>(this, "UActorComponent.BeginDestroy()"); }

    bool NeedsLoadForClient() { return NativeCall<bool>(this, "UActorComponent.NeedsLoadForClient()"); }

    bool NeedsLoadForServer() { return NativeCall<bool>(this, "UActorComponent.NeedsLoadForServer()"); }

    bool NeedsLoadForEditorGame() { return NativeCall<bool>(this, "UActorComponent.NeedsLoadForEditorGame()"); }

    int GetFunctionCallspace(UFunction* Function, FFrame* Stack) { return NativeCall<int, UFunction*, FFrame*>(this, "UActorComponent.GetFunctionCallspace(UFunction*,FFrame*)", Function, Stack); }

    bool CallRemoteFunction(UFunction* Function, void* Parameters, FOutParmRec* OutParms, FFrame* Stack) { return NativeCall<bool, UFunction*, void*, FOutParmRec*, FFrame*>(this, "UActorComponent.CallRemoteFunction(UFunction*,void*,FOutParmRec*,FFrame*)", Function, Parameters, OutParms, Stack); }

    void OnRegister() { NativeCall<void>(this, "UActorComponent.OnRegister()"); }

    void InitializeComponent() { NativeCall<void>(this, "UActorComponent.InitializeComponent()"); }

    void UninitializeComponent() { NativeCall<void>(this, "UActorComponent.UninitializeComponent()"); }

    void ReadyForReplication() { NativeCall<void>(this, "UActorComponent.ReadyForReplication()"); }

    void BeginPlay() { NativeCall<void>(this, "UActorComponent.BeginPlay()"); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "UActorComponent.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    //TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* GetComponentInstanceData(TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* result) { return NativeCall<TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*, TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*>(this, "UActorComponent.GetComponentInstanceData()", result); }

    bool SetupActorComponentTickFunction(FTickFunction* TickFunction) { return NativeCall<bool, FTickFunction*>(this, "UActorComponent.SetupActorComponentTickFunction(FTickFunction*)", TickFunction); }

    void SetComponentTickEnabled(bool bEnabled) { NativeCall<void, bool>(this, "UActorComponent.SetComponentTickEnabled(bool)", bEnabled); }

    void SetComponentTickEnabledAsync(bool bEnabled) { NativeCall<void, bool>(this, "UActorComponent.SetComponentTickEnabledAsync(bool)", bEnabled); }

    bool IsComponentTickEnabled() { return NativeCall<bool>(this, "UActorComponent.IsComponentTickEnabled()"); }

    void SetComponentTickIntervalAndCooldown(float TickInterval) { NativeCall<void, float>(this, "UActorComponent.SetComponentTickIntervalAndCooldown(float)", TickInterval); }

    void RegisterComponentTickFunctions(bool bRegister, bool bSaveAndRestoreComponentTickState) { NativeCall<void, bool, bool>(this, "UActorComponent.RegisterComponentTickFunctions(bool,bool)", bRegister, bSaveAndRestoreComponentTickState); }

    void RegisterAllComponentTickFunctions(bool bRegister, bool bSaveAndRestoreComponentTickState) { NativeCall<void, bool, bool>(this, "UActorComponent.RegisterAllComponentTickFunctions(bool,bool)", bRegister, bSaveAndRestoreComponentTickState); }

    void RegisterAsyncPhysicsTickEnabled(bool bRegister) { NativeCall<void, bool>(this, "UActorComponent.RegisterAsyncPhysicsTickEnabled(bool)", bRegister); }

    void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) { NativeCall<void, float, ELevelTick, FActorComponentTickFunction*>(this, "UActorComponent.TickComponent(float,ELevelTick,FActorComponentTickFunction*)", DeltaTime, TickType, ThisTickFunction); }

    void RegisterComponentWithWorld(UWorld* InWorld, FRegisterComponentContext* Context) { NativeCall<void, UWorld*, FRegisterComponentContext*>(this, "UActorComponent.RegisterComponentWithWorld(UWorld*,FRegisterComponentContext*)", InWorld, Context); }

    void RegisterComponent() { NativeCall<void>(this, "UActorComponent.RegisterComponent()"); }

    void UnregisterComponent() { NativeCall<void>(this, "UActorComponent.UnregisterComponent()"); }

    void DestroyComponent(bool bPromoteChildren) { NativeCall<void, bool>(this, "UActorComponent.DestroyComponent(bool)", bPromoteChildren); }

    void OnComponentDestroyed(bool bDestroyingHierarchy) { NativeCall<void, bool>(this, "UActorComponent.OnComponentDestroyed(bool)", bDestroyingHierarchy); }

    void CreateRenderState_Concurrent(FRegisterComponentContext* Context) { NativeCall<void, FRegisterComponentContext*>(this, "UActorComponent.CreateRenderState_Concurrent(FRegisterComponentContext*)", Context); }

    void SendRenderTransform_Concurrent() { NativeCall<void>(this, "UActorComponent.SendRenderTransform_Concurrent()"); }

    void SendRenderInstanceData_Concurrent() { NativeCall<void>(this, "UActorComponent.SendRenderInstanceData_Concurrent()"); }

    void DestroyRenderState_Concurrent() { NativeCall<void>(this, "UActorComponent.DestroyRenderState_Concurrent()"); }

    void OnDestroyPhysicsState() { NativeCall<void>(this, "UActorComponent.OnDestroyPhysicsState()"); }

    void CreatePhysicsState(bool bAllowDeferral) { NativeCall<void, bool>(this, "UActorComponent.CreatePhysicsState(bool)", bAllowDeferral); }

    void DestroyPhysicsState() { NativeCall<void>(this, "UActorComponent.DestroyPhysicsState()"); }

    void ExecuteUnregisterEvents() { NativeCall<void>(this, "UActorComponent.ExecuteUnregisterEvents()"); }

    void ReregisterComponent() { NativeCall<void>(this, "UActorComponent.ReregisterComponent()"); }

    void RecreateRenderState_Concurrent() { NativeCall<void>(this, "UActorComponent.RecreateRenderState_Concurrent()"); }

    void RecreatePhysicsState() { NativeCall<void>(this, "UActorComponent.RecreatePhysicsState()"); }

    void AddTickPrerequisiteActor(AActor* PrerequisiteActor) { NativeCall<void, AActor*>(this, "UActorComponent.AddTickPrerequisiteActor(AActor*)", PrerequisiteActor); }

    void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent) { NativeCall<void, UActorComponent*>(this, "UActorComponent.AddTickPrerequisiteComponent(UActorComponent*)", PrerequisiteComponent); }

    void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor) { NativeCall<void, AActor*>(this, "UActorComponent.RemoveTickPrerequisiteActor(AActor*)", PrerequisiteActor); }

    void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent) { NativeCall<void, UActorComponent*>(this, "UActorComponent.RemoveTickPrerequisiteComponent(UActorComponent*)", PrerequisiteComponent); }

    void DoDeferredRenderUpdates_Concurrent() { NativeCall<void>(this, "UActorComponent.DoDeferredRenderUpdates_Concurrent()"); }

    void MarkRenderStateDirty() { NativeCall<void>(this, "UActorComponent.MarkRenderStateDirty()"); }

    void MarkForNeededEndOfFrameUpdate() { NativeCall<void>(this, "UActorComponent.MarkForNeededEndOfFrameUpdate()"); }

    void ClearNeedEndOfFrameUpdate_Internal() { NativeCall<void>(this, "UActorComponent.ClearNeedEndOfFrameUpdate_Internal()"); }

    void Activate(bool bReset) { NativeCall<void, bool>(this, "UActorComponent.Activate(bool)", bReset); }

    void Deactivate() { NativeCall<void>(this, "UActorComponent.Deactivate()"); }

    void SetActive(bool bNewActive, bool bReset) { NativeCall<void, bool, bool>(this, "UActorComponent.SetActive(bool,bool)", bNewActive, bReset); }

    void SetAutoActivate(bool bNewAutoActivate) { NativeCall<void, bool>(this, "UActorComponent.SetAutoActivate(bool)", bNewAutoActivate); }

    void ToggleActive() { NativeCall<void>(this, "UActorComponent.ToggleActive()"); }

    void AddAssetUserData(UAssetUserData* InUserData) { NativeCall<void, UAssetUserData*>(this, "UActorComponent.AddAssetUserData(UAssetUserData*)", InUserData); }

    UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) { return NativeCall<UAssetUserData*, TSubclassOf<UAssetUserData>>(this, "UActorComponent.GetAssetUserDataOfClass(TSubclassOf<UAssetUserData>)", InUserDataClass); }

    void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) { NativeCall<void, TSubclassOf<UAssetUserData>>(this, "UActorComponent.RemoveUserDataOfClass(TSubclassOf<UAssetUserData>)", InUserDataClass); }

    bool IsNameStableForNetworking() { return NativeCall<bool>(this, "UActorComponent.IsNameStableForNetworking()"); }

    bool IsSupportedForNetworking() { return NativeCall<bool>(this, "UActorComponent.IsSupportedForNetworking()"); }

    void SetIsReplicated(bool bShouldReplicate) { NativeCall<void, bool>(this, "UActorComponent.SetIsReplicated(bool)", bShouldReplicate); }

    void AddReplicatedSubObject(UObject* SubObject, ELifetimeCondition NetCondition) { NativeCall<void, UObject*, ELifetimeCondition>(this, "UActorComponent.AddReplicatedSubObject(UObject*,ELifetimeCondition)", SubObject, NetCondition); }

    bool ReplicateSubobjects(UActorChannel* Channel, FOutBunch* Bunch, FReplicationFlags* RepFlags) { return NativeCall<bool, UActorChannel*, FOutBunch*, FReplicationFlags*>(this, "UActorComponent.ReplicateSubobjects(UActorChannel*,FOutBunch*,FReplicationFlags*)", Channel, Bunch, RepFlags); }

    void PreReplication(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "UActorComponent.PreReplication(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "UActorComponent.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void OnRep_IsActive() { NativeCall<void>(this, "UActorComponent.OnRep_IsActive()"); }

    void DetermineUCSModifiedProperties() { NativeCall<void>(this, "UActorComponent.DetermineUCSModifiedProperties()"); }

    void GetUCSModifiedProperties(TSet<FProperty const*, DefaultKeyFuncs<FProperty const*, 0>, FDefaultSetAllocator>* ModifiedProperties) { NativeCall<void, TSet<FProperty const*, DefaultKeyFuncs<FProperty const*, 0>, FDefaultSetAllocator>*>(this, "UActorComponent.GetUCSModifiedProperties(TSet<FProperty*,DefaultKeyFuncs<FProperty*,0>,FDefaultSetAllocator>&)", ModifiedProperties); }

    void RemoveUCSModifiedProperties(const TArray<FProperty*, TSizedDefaultAllocator<32> >* Properties) { NativeCall<void, const TArray<FProperty*, TSizedDefaultAllocator<32> >*>(this, "UActorComponent.RemoveUCSModifiedProperties(TArray<FProperty*,TSizedDefaultAllocator<32>>&)", Properties); }

    static void AddReferencedObjects(UObject* InThis, FReferenceCollector* Collector) { NativeCall<void, UObject*, FReferenceCollector*>(nullptr, "UActorComponent.AddReferencedObjects(UObject*,FReferenceCollector&)", InThis, Collector); }

    void SetCanEverAffectNavigation(bool bRelevant) { NativeCall<void, bool>(this, "UActorComponent.SetCanEverAffectNavigation(bool)", bRelevant); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UActorComponent.Serialize(FArchive&)", Ar); }

    void SetIsReplicatedByDefault(const bool bNewReplicates) { NativeCall<void, const bool>(this, "UActorComponent.SetIsReplicatedByDefault(bool)", bNewReplicates); }

};


struct USceneComponent : UActorComponent

{

    // Fields


    //const FLevelCollection*& CachedLevelCollectionField() { return *GetNativePointerField<const FLevelCollection**>(this, "USceneComponent.CachedLevelCollection"); }

    TWeakObjectPtr<APhysicsVolume>& PhysicsVolumeField() { return *GetNativePointerField<TWeakObjectPtr<APhysicsVolume>*>(this, "USceneComponent.PhysicsVolume"); }

    TObjectPtr<USceneComponent>& AttachParentField() { return *GetNativePointerField<TObjectPtr<USceneComponent>*>(this, "USceneComponent.AttachParent"); }

    FName& AttachSocketNameField() { return *GetNativePointerField<FName*>(this, "USceneComponent.AttachSocketName"); }

    TArray<TObjectPtr<USceneComponent>, TSizedDefaultAllocator<32> >& AttachChildrenField() { return *GetNativePointerField<TArray<TObjectPtr<USceneComponent>, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.AttachChildren"); }

    TArray<TObjectPtr<USceneComponent>, TSizedDefaultAllocator<32> >& ClientAttachedChildrenField() { return *GetNativePointerField<TArray<TObjectPtr<USceneComponent>, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.ClientAttachedChildren"); }

    FName& NetOldAttachSocketNameField() { return *GetNativePointerField<FName*>(this, "USceneComponent.NetOldAttachSocketName"); }

    USceneComponent*& NetOldAttachParentField() { return *GetNativePointerField<USceneComponent**>(this, "USceneComponent.NetOldAttachParent"); }

    UE::Math::TBoxSphereBounds<double, double>& BoundsField() { return *GetNativePointerField<UE::Math::TBoxSphereBounds<double, double>*>(this, "USceneComponent.Bounds"); }

    UE::Math::TVector<double>& RelativeLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "USceneComponent.RelativeLocation"); }

    UE::Math::TRotator<double>& RelativeRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "USceneComponent.RelativeRotation"); }

    UE::Math::TVector<double>& RelativeScale3DField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "USceneComponent.RelativeScale3D"); }

    UE::Math::TVector<double>& ComponentVelocityField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "USceneComponent.ComponentVelocity"); }

    TEnumAsByte<enum EDetailMode>& DetailModeField() { return *GetNativePointerField<TEnumAsByte<enum EDetailMode>*>(this, "USceneComponent.DetailMode"); }

    //FIsRootComponentChanged& IsRootComponentChangedField() { return *GetNativePointerField<FIsRootComponentChanged*>(this, "USceneComponent.IsRootComponentChanged"); }

    //FTransformUpdated& TransformUpdatedField() { return *GetNativePointerField<FTransformUpdated*>(this, "USceneComponent.TransformUpdated"); }

    //TArray<FScopedMovementUpdate*, TSizedDefaultAllocator<32> >& ScopedMovementStackField() { return *GetNativePointerField<TArray<FScopedMovementUpdate*, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.ScopedMovementStack"); }

    FRotationConversionCache& WorldRotationCacheField() { return *GetNativePointerField<FRotationConversionCache*>(this, "USceneComponent.WorldRotationCache"); }

    FRotationConversionCache& RelativeRotationCacheField() { return *GetNativePointerField<FRotationConversionCache*>(this, "USceneComponent.RelativeRotationCache"); }

    UE::Math::TTransform<double>& ComponentToWorldField() { return *GetNativePointerField<UE::Math::TTransform<double>*>(this, "USceneComponent.ComponentToWorld"); }

    int& AttachmentChangedIncrementerField() { return *GetNativePointerField<int*>(this, "USceneComponent.AttachmentChangedIncrementer"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bClientSyncAlwaysUpdatePhysicsCollision() { return { this, "USceneComponent.bClientSyncAlwaysUpdatePhysicsCollision" }; }

    BitFieldValue<bool, unsigned __int32> bComponentToWorldUpdated() { return { this, "USceneComponent.bComponentToWorldUpdated" }; }

    BitFieldValue<bool, unsigned __int32> bSkipUpdateOverlaps() { return { this, "USceneComponent.bSkipUpdateOverlaps" }; }

    BitFieldValue<bool, unsigned __int32> bAbsoluteLocation() { return { this, "USceneComponent.bAbsoluteLocation" }; }

    BitFieldValue<bool, unsigned __int32> bAbsoluteRotation() { return { this, "USceneComponent.bAbsoluteRotation" }; }

    BitFieldValue<bool, unsigned __int32> bAbsoluteScale() { return { this, "USceneComponent.bAbsoluteScale" }; }

    BitFieldValue<bool, unsigned __int32> bVisible() { return { this, "USceneComponent.bVisible" }; }

    BitFieldValue<bool, unsigned __int32> bShouldBeAttached() { return { this, "USceneComponent.bShouldBeAttached" }; }

    BitFieldValue<bool, unsigned __int32> bShouldSnapLocationWhenAttached() { return { this, "USceneComponent.bShouldSnapLocationWhenAttached" }; }

    BitFieldValue<bool, unsigned __int32> bShouldSnapRotationWhenAttached() { return { this, "USceneComponent.bShouldSnapRotationWhenAttached" }; }

    BitFieldValue<bool, unsigned __int32> bShouldSnapScaleWhenAttached() { return { this, "USceneComponent.bShouldSnapScaleWhenAttached" }; }

    BitFieldValue<bool, unsigned __int32> bShouldUpdatePhysicsVolume() { return { this, "USceneComponent.bShouldUpdatePhysicsVolume" }; }

    BitFieldValue<bool, unsigned __int32> bHiddenInGame() { return { this, "USceneComponent.bHiddenInGame" }; }

    BitFieldValue<bool, unsigned __int32> bAttachedSoundsForceHighPriority() { return { this, "USceneComponent.bAttachedSoundsForceHighPriority" }; }

    BitFieldValue<bool, unsigned __int32> bBoundsChangeTriggersStreamingDataRebuild() { return { this, "USceneComponent.bBoundsChangeTriggersStreamingDataRebuild" }; }

    BitFieldValue<bool, unsigned __int32> bUseAttachParentBound() { return { this, "USceneComponent.bUseAttachParentBound" }; }

    BitFieldValue<bool, unsigned __int32> bComputeFastLocalBounds() { return { this, "USceneComponent.bComputeFastLocalBounds" }; }

    BitFieldValue<bool, unsigned __int32> bComputeBoundsOnceForGame() { return { this, "USceneComponent.bComputeBoundsOnceForGame" }; }

    BitFieldValue<bool, unsigned __int32> bComputedBoundsOnceForGame() { return { this, "USceneComponent.bComputedBoundsOnceForGame" }; }

    BitFieldValue<bool, unsigned __int32> bIsNotRenderAttachmentRoot() { return { this, "USceneComponent.bIsNotRenderAttachmentRoot" }; }

    BitFieldValue<bool, unsigned __int32> bDisableDetachmentUpdateOverlaps() { return { this, "USceneComponent.bDisableDetachmentUpdateOverlaps" }; }

    BitFieldValue<bool, unsigned __int32> bWantsOnUpdateTransform() { return { this, "USceneComponent.bWantsOnUpdateTransform" }; }

    BitFieldValue<bool, unsigned __int32> bNetUpdateTransform() { return { this, "USceneComponent.bNetUpdateTransform" }; }

    BitFieldValue<bool, unsigned __int32> bNetUpdateAttachment() { return { this, "USceneComponent.bNetUpdateAttachment" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreParentTransformUpdate() { return { this, "USceneComponent.bIgnoreParentTransformUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bUpdateChildOverlaps() { return { this, "USceneComponent.bUpdateChildOverlaps" }; }


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "USceneComponent.GetPrivateStaticClass()"); }

    void OnChildAttached(USceneComponent* ChildComponent) { NativeCall<void, USceneComponent*>(this, "USceneComponent.OnChildAttached(USceneComponent*)", ChildComponent); }

    //void UpdateComponentToWorld(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) { NativeCall<void, EUpdateTransformFlags, ETeleportType>(this, "USceneComponent.UpdateComponentToWorld(EUpdateTransformFlags,ETeleportType)", UpdateTransformFlags, Teleport); }

    void SetHiddenInGame(bool NewHidden, bool bPropagateToChildren, bool bSetChildrenRenderState) { NativeCall<void, bool, bool, bool>(this, "USceneComponent.SetHiddenInGame(bool,bool,bool)", NewHidden, bPropagateToChildren, bSetChildrenRenderState); }

    void OnUnregister() { NativeCall<void>(this, "USceneComponent.OnUnregister()"); }

    static void StaticRegisterNativesUSceneComponent() { NativeCall<void>(nullptr, "USceneComponent.StaticRegisterNativesUSceneComponent()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void NotifyIsRootComponentChanged(bool bIsRootComponent) { NativeCall<void, bool>(this, "USceneComponent.NotifyIsRootComponentChanged(bool)", bIsRootComponent); }

    static const FName* GetRelativeScale3DPropertyName(const FName* result) { return NativeCall<const FName*, const FName*>(nullptr, "USceneComponent.GetRelativeScale3DPropertyName()", result); }

    void UpdateComponentToWorldWithParent(USceneComponent* Parent, FName SocketName, EUpdateTransformFlags UpdateTransformFlags, const UE::Math::TQuat<double>* RelativeRotationQuat, ETeleportType Teleport) { NativeCall<void, USceneComponent*, FName, EUpdateTransformFlags, const UE::Math::TQuat<double>*, ETeleportType>(this, "USceneComponent.UpdateComponentToWorldWithParent(USceneComponent*,FName,EUpdateTransformFlags,UE::Math::TQuat<double>&,ETeleportType)", Parent, SocketName, UpdateTransformFlags, RelativeRotationQuat, Teleport); }

    void OnRegister() { NativeCall<void>(this, "USceneComponent.OnRegister()"); }

    void EndPlay(EEndPlayReason::Type Reason) { NativeCall<void, EEndPlayReason::Type>(this, "USceneComponent.EndPlay(EEndPlayReason::Type)", Reason); }

    void PropagateTransformUpdate(bool bTransformChanged, EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) { NativeCall<void, bool, EUpdateTransformFlags, ETeleportType>(this, "USceneComponent.PropagateTransformUpdate(bool,EUpdateTransformFlags,ETeleportType)", bTransformChanged, UpdateTransformFlags, Teleport); }

    bool UpdateOverlaps(const TArrayView<FOverlapInfo const, int>* PendingOverlaps, bool bDoNotifies, const TArrayView<FOverlapInfo const, int>* OverlapsAtEndLocation) { return NativeCall<bool, const TArrayView<FOverlapInfo const, int>*, bool, const TArrayView<FOverlapInfo const, int>*>(this, "USceneComponent.UpdateOverlaps(TArrayView<FOverlapInfo,int>*,bool,TArrayView<FOverlapInfo,int>*)", PendingOverlaps, bDoNotifies, OverlapsAtEndLocation); }

    //void ProcessScopedMovementUpdate(FScopedMovementUpdate* CurrentScopedUpdate) { NativeCall<void, FScopedMovementUpdate*>(this, "USceneComponent.ProcessScopedMovementUpdate(FScopedMovementUpdate*)", CurrentScopedUpdate); }

    void DestroyComponent(bool bPromoteChildren) { NativeCall<void, bool>(this, "USceneComponent.DestroyComponent(bool)", bPromoteChildren); }

    void OnComponentDestroyed(bool bDestroyingHierarchy) { NativeCall<void, bool>(this, "USceneComponent.OnComponentDestroyed(bool)", bDestroyingHierarchy); }

    void CalcBoundingCylinder(float* CylinderRadius, float* CylinderHalfHeight) { NativeCall<void, float*, float*>(this, "USceneComponent.CalcBoundingCylinder(float&,float&)", CylinderRadius, CylinderHalfHeight); }

    void UpdateBounds() { NativeCall<void>(this, "USceneComponent.UpdateBounds()"); }

    void SetRelativeLocationAndRotation(UE::Math::TVector<double>* NewLocation, const UE::Math::TQuat<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetRelativeLocationAndRotation(UE::Math::TVector<double>,UE::Math::TQuat<double>&,bool,FHitResult*,ETeleportType)", NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); }

    void SetRelativeLocationAndRotation(UE::Math::TVector<double>* NewLocation, UE::Math::TRotator<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetRelativeLocationAndRotation(UE::Math::TVector<double>,UE::Math::TRotator<double>,bool,FHitResult*,ETeleportType)", NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); }

    void SetRelativeRotationExact(UE::Math::TRotator<double>* NewRotation, __int64 bSweep, FHitResult* OutSweepHitResult) { NativeCall<void, UE::Math::TRotator<double>*, __int64, FHitResult*>(this, "USceneComponent.SetRelativeRotationExact(UE::Math::TRotator<double>,bool,FHitResult*,ETeleportType)", NewRotation, bSweep, OutSweepHitResult); }

    void SetRelativeRotation(UE::Math::TRotator<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetRelativeRotation(UE::Math::TRotator<double>,bool,FHitResult*,ETeleportType)", NewRotation, bSweep, OutSweepHitResult, Teleport); }

    void AddLocalOffset(UE::Math::TVector<double>* DeltaLocation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddLocalOffset(UE::Math::TVector<double>,bool,FHitResult*,ETeleportType)", DeltaLocation, bSweep, OutSweepHitResult, Teleport); }

    // TODO: Might need manual analysis

    void AddLocalRotation(UE::Math::TRotator<double>* DeltaRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddLocalRotation(UE::Math::TRotator<double>&,bool,FHitResult*,ETeleportType)", DeltaRotation, bSweep, OutSweepHitResult, Teleport); }

    void AddLocalRotation(const UE::Math::TQuat<double>* DeltaRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TQuat<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddLocalRotation(UE::Math::TQuat<double>&,bool,FHitResult*,ETeleportType)", DeltaRotation, bSweep, OutSweepHitResult, Teleport); }

    void AddLocalTransform(const UE::Math::TTransform<double>* DeltaTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddLocalTransform(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", DeltaTransform, bSweep, OutSweepHitResult, Teleport); }

    void AddWorldRotation(UE::Math::TRotator<double>* DeltaRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddWorldRotation(UE::Math::TRotator<double>,bool,FHitResult*,ETeleportType)", DeltaRotation, bSweep, OutSweepHitResult, Teleport); }

    void AddWorldTransform(const UE::Math::TTransform<double>* DeltaTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddWorldTransform(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", DeltaTransform, bSweep, OutSweepHitResult, Teleport); }

    void AddWorldTransformKeepScale(const UE::Math::TTransform<double>* DeltaTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.AddWorldTransformKeepScale(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", DeltaTransform, bSweep, OutSweepHitResult, Teleport); }

    void SetRelativeScale3D(UE::Math::TVector<double>* NewScale3D) { NativeCall<void, UE::Math::TVector<double>*>(this, "USceneComponent.SetRelativeScale3D(UE::Math::TVector<double>)", NewScale3D); }

    void ResetRelativeTransform() { NativeCall<void>(this, "USceneComponent.ResetRelativeTransform()"); }

    void SetRelativeTransform(const UE::Math::TTransform<double>* NewTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetRelativeTransform(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", NewTransform, bSweep, OutSweepHitResult, Teleport); }

    void SetWorldLocation(UE::Math::TVector<double>* NewLocation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetWorldLocation(UE::Math::TVector<double>,bool,FHitResult*,ETeleportType)", NewLocation, bSweep, OutSweepHitResult, Teleport); }

    void SetWorldRotation(const UE::Math::TQuat<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TQuat<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetWorldRotation(UE::Math::TQuat<double>&,bool,FHitResult*,ETeleportType)", NewRotation, bSweep, OutSweepHitResult, Teleport); }

    // TODO: Might need manual analysis

    void SetWorldRotation(UE::Math::TRotator<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetWorldRotation(UE::Math::TRotator<double>&,bool,FHitResult*,ETeleportType)", NewRotation, bSweep, OutSweepHitResult, Teleport); }

    void SetWorldScale3D(UE::Math::TVector<double>* NewScale) { NativeCall<void, UE::Math::TVector<double>*>(this, "USceneComponent.SetWorldScale3D(UE::Math::TVector<double>)", NewScale); }

    void SetWorldTransform(const UE::Math::TTransform<double>* NewTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetWorldTransform(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", NewTransform, bSweep, OutSweepHitResult, Teleport); }

    // TODO: Might need manual analysis

    void SetWorldLocationAndRotation(UE::Math::TVector<double>* NewLocation, UE::Math::TRotator<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetWorldLocationAndRotation(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool,FHitResult*,ETeleportType)", NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); }

    void SetWorldLocationAndRotation(UE::Math::TVector<double>* NewLocation, const UE::Math::TQuat<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, bool, FHitResult*, ETeleportType>(this, "USceneComponent.SetWorldLocationAndRotation(UE::Math::TVector<double>,UE::Math::TQuat<double>&,bool,FHitResult*,ETeleportType)", NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); }

    void SetWorldLocationAndRotationNoPhysics(const UE::Math::TVector<double>* NewLocation, const UE::Math::TRotator<double>* NewRotation) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*>(this, "USceneComponent.SetWorldLocationAndRotationNoPhysics(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", NewLocation, NewRotation); }

    void GetChildrenComponents(bool bIncludeAllDescendants, TArray<USceneComponent*, TSizedDefaultAllocator<32> >* Children) { NativeCall<void, bool, TArray<USceneComponent*, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.GetChildrenComponents(bool,TArray<USceneComponent*,TSizedDefaultAllocator<32>>&)", bIncludeAllDescendants, Children); }

    void AppendDescendants(TArray<USceneComponent*, TSizedDefaultAllocator<32> >* Children) { NativeCall<void, TArray<USceneComponent*, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.AppendDescendants(TArray<USceneComponent*,TSizedDefaultAllocator<32>>&)", Children); }

    void SetupAttachment(USceneComponent* InParent, FName InSocketName) { NativeCall<void, USceneComponent*, FName>(this, "USceneComponent.SetupAttachment(USceneComponent*,FName)", InParent, InSocketName); }

    bool AttachTo(USceneComponent* Parent, FName InSocketName, EAttachLocation::Type AttachType, bool bWeldSimulatedBodies) { return NativeCall<bool, USceneComponent*, FName, EAttachLocation::Type, bool>(this, "USceneComponent.AttachTo(USceneComponent*,FName,EAttachLocation::Type,bool)", Parent, InSocketName, AttachType, bWeldSimulatedBodies); }

    bool AttachToComponent(USceneComponent* Parent, const FAttachmentTransformRules* AttachmentRules, FName SocketName) { return NativeCall<bool, USceneComponent*, const FAttachmentTransformRules*, FName>(this, "USceneComponent.AttachToComponent(USceneComponent*,FAttachmentTransformRules&,FName)", Parent, AttachmentRules, SocketName); }

    void DetachFromParent(bool bMaintainWorldPosition, bool bCallModify) { NativeCall<void, bool, bool>(this, "USceneComponent.DetachFromParent(bool,bool)", bMaintainWorldPosition, bCallModify); }

    //void DetachFromComponent(const FDetachmentTransformRules* DetachmentRules) { NativeCall<void, const FDetachmentTransformRules*>(this, "USceneComponent.DetachFromComponent(FDetachmentTransformRules&)", DetachmentRules); }

    //TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* GetComponentInstanceData(TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* result) { return NativeCall<TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*, TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*>(this, "USceneComponent.GetComponentInstanceData()", result); }

    void UpdateChildTransforms(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) { NativeCall<void, EUpdateTransformFlags, ETeleportType>(this, "USceneComponent.UpdateChildTransforms(EUpdateTransformFlags,ETeleportType)", UpdateTransformFlags, Teleport); }

    void GetSocketWorldLocationAndRotation(FName InSocketName, UE::Math::TVector<double>* OutLocation, UE::Math::TRotator<double>* OutRotation) { NativeCall<void, FName, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "USceneComponent.GetSocketWorldLocationAndRotation(FName,UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", InSocketName, OutLocation, OutRotation); }

    //const FCollisionResponseContainer* GetCollisionResponseToChannels() { return NativeCall<const FCollisionResponseContainer*>(this, "USceneComponent.GetCollisionResponseToChannels()"); }

    ECollisionResponse GetCollisionResponseToComponent(USceneComponent* OtherComponent) { return NativeCall<ECollisionResponse, USceneComponent*>(this, "USceneComponent.GetCollisionResponseToComponent(USceneComponent*)", OtherComponent); }

    void SetMobility(EComponentMobility::Type NewMobility) { NativeCall<void, EComponentMobility::Type>(this, "USceneComponent.SetMobility(EComponentMobility::Type)", NewMobility); }

    bool IsAnySimulatingPhysics() { return NativeCall<bool>(this, "USceneComponent.IsAnySimulatingPhysics()"); }

    APhysicsVolume* GetPhysicsVolume() { return NativeCall<APhysicsVolume*>(this, "USceneComponent.GetPhysicsVolume()"); }

    void UpdatePhysicsVolume(bool bTriggerNotifiers) { NativeCall<void, bool>(this, "USceneComponent.UpdatePhysicsVolume(bool)", bTriggerNotifiers); }

    void SetPhysicsVolume(APhysicsVolume* NewVolume, bool bTriggerNotifiers) { NativeCall<void, APhysicsVolume*, bool>(this, "USceneComponent.SetPhysicsVolume(APhysicsVolume*,bool)", NewVolume, bTriggerNotifiers); }

    bool IsPostLoadThreadSafe() { return NativeCall<bool>(this, "USceneComponent.IsPostLoadThreadSafe()"); }

    char InternalSetWorldLocationAndRotation(UE::Math::TVector<double>* NewLocation, const UE::Math::TQuat<double>* RotationQuat, __int64 bNoPhysics, ETeleportType Teleport) { return NativeCall<char, UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, __int64, ETeleportType>(this, "USceneComponent.InternalSetWorldLocationAndRotation(UE::Math::TVector<double>,UE::Math::TQuat<double>&,bool,ETeleportType)", NewLocation, RotationQuat, bNoPhysics, Teleport); }

    bool UpdateOverlapsImpl(const TArrayView<FOverlapInfo const, int>* PendingOverlaps, TTypeCompatibleBytes<FOctreeElementSimple*>* bDoNotifies, const TArrayView<FOverlapInfo const, int>* OverlapsAtEndLocation) { return NativeCall<bool, const TArrayView<FOverlapInfo const, int>*, TTypeCompatibleBytes<FOctreeElementSimple*>*, const TArrayView<FOverlapInfo const, int>*>(this, "USceneComponent.UpdateOverlapsImpl(TArrayView<FOverlapInfo,int>*,bool,TArrayView<FOverlapInfo,int>*)", PendingOverlaps, bDoNotifies, OverlapsAtEndLocation); }

    bool MoveComponent(const UE::Math::TVector<double>* Delta, const UE::Math::TRotator<double>* NewRotation, bool bSweep, FHitResult* Hit, EMoveComponentFlags MoveFlags, ETeleportType Teleport) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*, bool, FHitResult*, EMoveComponentFlags, ETeleportType>(this, "USceneComponent.MoveComponent(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool,FHitResult*,EMoveComponentFlags,ETeleportType)", Delta, NewRotation, bSweep, Hit, MoveFlags, Teleport); }

    bool MoveComponentImpl(const UE::Math::TVector<double>* Delta, const UE::Math::TQuat<double>* NewRotation, bool bSweep, FHitResult* OutHit, EMoveComponentFlags MoveFlags, ETeleportType Teleport) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, bool, FHitResult*, EMoveComponentFlags, ETeleportType>(this, "USceneComponent.MoveComponentImpl(UE::Math::TVector<double>&,UE::Math::TQuat<double>&,bool,FHitResult*,EMoveComponentFlags,ETeleportType)", Delta, NewRotation, bSweep, OutHit, MoveFlags, Teleport); }

    bool IsVisibleInEditor() { return NativeCall<bool>(this, "USceneComponent.IsVisibleInEditor()"); }

    bool ShouldRender() { return NativeCall<bool>(this, "USceneComponent.ShouldRender()"); }

    bool CanEverRender() { return NativeCall<bool>(this, "USceneComponent.CanEverRender()"); }

    bool IsVisible() { return NativeCall<bool>(this, "USceneComponent.IsVisible()"); }

    void OnHiddenInGameChanged() { NativeCall<void>(this, "USceneComponent.OnHiddenInGameChanged()"); }

    //void InternalSetVisibility(bool bNewVisibility, USceneComponent::EVisibilityPropagation PropagateToChildren, bool bSetChildrenRenderState) { NativeCall<void, bool, USceneComponent::EVisibilityPropagation, bool>(this, "USceneComponent.InternalSetVisibility(bool,USceneComponent::EVisibilityPropagation,bool)", bNewVisibility, PropagateToChildren, bSetChildrenRenderState); }

    //void SetHiddenInGame(bool bNewHiddenGame, USceneComponent::EVisibilityPropagation PropagateToChildren, bool bSetChildrenRenderState) { NativeCall<void, bool, USceneComponent::EVisibilityPropagation, bool>(this, "USceneComponent.SetHiddenInGame(bool,USceneComponent::EVisibilityPropagation,bool)", bNewHiddenGame, PropagateToChildren, bSetChildrenRenderState); }

    void ApplyWorldOffset(const UE::Math::TVector<double>* InOffset, bool bWorldShift) { NativeCall<void, const UE::Math::TVector<double>*, bool>(this, "USceneComponent.ApplyWorldOffset(UE::Math::TVector<double>&,bool)", InOffset, bWorldShift); }

    void OnRep_AttachChildren() { NativeCall<void>(this, "USceneComponent.OnRep_AttachChildren()"); }

    void PreNetReceive() { NativeCall<void>(this, "USceneComponent.PreNetReceive()"); }

    void PostNetReceive() { NativeCall<void>(this, "USceneComponent.PostNetReceive()"); }

    void PostRepNotifies() { NativeCall<void>(this, "USceneComponent.PostRepNotifies()"); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "USceneComponent.Serialize(FArchive&)", Ar); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "USceneComponent.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void ClearSkipUpdateOverlaps() { NativeCall<void>(this, "USceneComponent.ClearSkipUpdateOverlaps()"); }

    void SetShouldUpdatePhysicsVolume(bool bInShouldUpdatePhysicsVolume) { NativeCall<void, bool>(this, "USceneComponent.SetShouldUpdatePhysicsVolume(bool)", bInShouldUpdatePhysicsVolume); }

    void UpdateNavigationData() { NativeCall<void>(this, "USceneComponent.UpdateNavigationData()"); }

    void K2_SetRelativeLocation(UE::Math::TVector<double>* NewLocation, bool bSweep, FHitResult* SweepHitResult, bool bTeleport) { NativeCall<void, UE::Math::TVector<double>*, bool, FHitResult*, bool>(this, "USceneComponent.K2_SetRelativeLocation(UE::Math::TVector<double>,bool,FHitResult&,bool)", NewLocation, bSweep, SweepHitResult, bTeleport); }

    void K2_AddRelativeLocation(UE::Math::TVector<double>* DeltaLocation, bool bSweep, FHitResult* SweepHitResult, bool bTeleport) { NativeCall<void, UE::Math::TVector<double>*, bool, FHitResult*, bool>(this, "USceneComponent.K2_AddRelativeLocation(UE::Math::TVector<double>,bool,FHitResult&,bool)", DeltaLocation, bSweep, SweepHitResult, bTeleport); }

    void StopSound(USoundBase* SoundToStop, float FadeOutTime) { NativeCall<void, USoundBase*, float>(this, "USceneComponent.StopSound(USoundBase*,float)", SoundToStop, FadeOutTime); }

};


struct UPrimitiveComponent : USceneComponent

{

    // Fields


    float& MinDrawDistanceField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.MinDrawDistance"); }

    float& LDMaxDrawDistanceField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LDMaxDrawDistance"); }

    float& CachedMaxDrawDistanceField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.CachedMaxDrawDistance"); }

    TEnumAsByte<enum ESceneDepthPriorityGroup>& ViewOwnerDepthPriorityGroupField() { return *GetNativePointerField<TEnumAsByte<enum ESceneDepthPriorityGroup>*>(this, "UPrimitiveComponent.ViewOwnerDepthPriorityGroup"); }

    FieldArray<char, 1> LightmapTypeField() { return { this, "UPrimitiveComponent.LightmapType" }; }

    TArray<unsigned int, TSizedDefaultAllocator<32> >& MaterialPSOPrecacheRequestIDsField() { return *GetNativePointerField<TArray<unsigned int, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.MaterialPSOPrecacheRequestIDs"); }

    //TRefCountPtr<FGraphEvent>& PSOPrecacheCompileEventField() { return *GetNativePointerField<TRefCountPtr<FGraphEvent>*>(this, "UPrimitiveComponent.PSOPrecacheCompileEvent"); }

    unsigned __int8& MoveIgnoreMaskField() { return *GetNativePointerField<unsigned __int8*>(this, "UPrimitiveComponent.MoveIgnoreMask"); }

    //FLightingChannels& LightingChannelsField() { return *GetNativePointerField<FLightingChannels*>(this, "UPrimitiveComponent.LightingChannels"); }

    int& RayTracingGroupIdField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.RayTracingGroupId"); }

    int& VisibilityIdField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.VisibilityId"); }

    int& CustomDepthStencilValueField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.CustomDepthStencilValue"); }

    //FCustomPrimitiveData& CustomPrimitiveDataField() { return *GetNativePointerField<FCustomPrimitiveData*>(this, "UPrimitiveComponent.CustomPrimitiveData"); }

    //FCustomPrimitiveData& CustomPrimitiveDataInternalField() { return *GetNativePointerField<FCustomPrimitiveData*>(this, "UPrimitiveComponent.CustomPrimitiveDataInternal"); }

    //FPhysScene_Chaos*& DeferredCreatePhysicsStateSceneField() { return *GetNativePointerField<FPhysScene_Chaos**>(this, "UPrimitiveComponent.DeferredCreatePhysicsStateScene"); }

    int& TranslucencySortPriorityField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.TranslucencySortPriority"); }

    float& TranslucencySortDistanceOffsetField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.TranslucencySortDistanceOffset"); }

    //TArray<TObjectPtr<URuntimeVirtualTexture>, TSizedDefaultAllocator<32> >& RuntimeVirtualTexturesField() { return *GetNativePointerField<TArray<TObjectPtr<URuntimeVirtualTexture>, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.RuntimeVirtualTextures"); }

    char& VirtualTextureCullMipsField() { return *GetNativePointerField<char*>(this, "UPrimitiveComponent.VirtualTextureCullMips"); }

    FieldArray<char, 1> VirtualTextureRenderPassTypeField() { return { this, "UPrimitiveComponent.VirtualTextureRenderPassType" }; }

    //FPrimitiveComponentId& ComponentIdField() { return *GetNativePointerField<FPrimitiveComponentId*>(this, "UPrimitiveComponent.ComponentId"); }

    int& RegistrationSerialNumberField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.RegistrationSerialNumber"); }

    FThreadSafeCounter& AttachmentCounterField() { return *GetNativePointerField<FThreadSafeCounter*>(this, "UPrimitiveComponent.AttachmentCounter"); }

    float& LastCheckedAllCollideableDescendantsTimeField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LastCheckedAllCollideableDescendantsTime"); }

    float& BoundsScaleField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.BoundsScale"); }

    float& LastSubmitTimeField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LastSubmitTime"); }

    long double& LastRenderTimeField() { return *GetNativePointerField<long double*>(this, "UPrimitiveComponent.LastRenderTime"); }

    long double& LastRenderTimeOnScreenField() { return *GetNativePointerField<long double*>(this, "UPrimitiveComponent.LastRenderTimeOnScreen"); }

    float& OcclusionBoundsSlackField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.OcclusionBoundsSlack"); }

    TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >& MoveIgnoreActorsField() { return *GetNativePointerField<TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.MoveIgnoreActors"); }

    TArray<TObjectPtr<UPrimitiveComponent>, TSizedDefaultAllocator<32> >& MoveIgnoreComponentsField() { return *GetNativePointerField<TArray<TObjectPtr<UPrimitiveComponent>, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.MoveIgnoreComponents"); }

    TArray<FOverlapInfo, TSizedDefaultAllocator<32> >& OverlappingComponentsField() { return *GetNativePointerField<TArray<FOverlapInfo, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.OverlappingComponents"); }

    TMap<TWeakObjectPtr<UPrimitiveComponent>, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<TWeakObjectPtr<UPrimitiveComponent>, int, 0> >& OverlappingPrimitiveComponentsField() { return *GetNativePointerField<TMap<TWeakObjectPtr<UPrimitiveComponent>, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<TWeakObjectPtr<UPrimitiveComponent>, int, 0> >*>(this, "UPrimitiveComponent.OverlappingPrimitiveComponents"); }

    FBodyInstance& BodyInstanceField() { return *GetNativePointerField<FBodyInstance*>(this, "UPrimitiveComponent.BodyInstance"); }

    FComponentBeginOverlapSignature& OnComponentBeginOverlapField() { return *GetNativePointerField<FComponentBeginOverlapSignature*>(this, "UPrimitiveComponent.OnComponentBeginOverlap"); }

    //FComponentWakeSignature& OnComponentWakeField() { return *GetNativePointerField<FComponentWakeSignature*>(this, "UPrimitiveComponent.OnComponentWake"); }

    //FComponentCollisionSettingsChangedSignature& OnComponentCollisionSettingsChangedEventField() { return *GetNativePointerField<FComponentCollisionSettingsChangedSignature*>(this, "UPrimitiveComponent.OnComponentCollisionSettingsChangedEvent"); }

    FComponentBeginCursorOverSignature& OnBeginCursorOverField() { return *GetNativePointerField<FComponentBeginCursorOverSignature*>(this, "UPrimitiveComponent.OnBeginCursorOver"); }

    FComponentOnClickedSignature& OnClickedField() { return *GetNativePointerField<FComponentOnClickedSignature*>(this, "UPrimitiveComponent.OnClicked"); }

    FComponentOnInputTouchBeginSignature& OnInputTouchBeginField() { return *GetNativePointerField<FComponentOnInputTouchBeginSignature*>(this, "UPrimitiveComponent.OnInputTouchBegin"); }

    FComponentBeginTouchOverSignature& OnInputTouchEnterField() { return *GetNativePointerField<FComponentBeginTouchOverSignature*>(this, "UPrimitiveComponent.OnInputTouchEnter"); }

    ERayTracingGroupCullingPriority& RayTracingGroupCullingPriorityField() { return *GetNativePointerField<ERayTracingGroupCullingPriority*>(this, "UPrimitiveComponent.RayTracingGroupCullingPriority"); }

    //FPrimitiveSceneProxy*& SceneProxyField() { return *GetNativePointerField<FPrimitiveSceneProxy**>(this, "UPrimitiveComponent.SceneProxy"); }

    FRenderCommandFence& DetachFenceField() { return *GetNativePointerField<FRenderCommandFence*>(this, "UPrimitiveComponent.DetachFence"); }

    TObjectPtr<UPrimitiveComponent>& LODParentPrimitiveField() { return *GetNativePointerField<TObjectPtr<UPrimitiveComponent>*>(this, "UPrimitiveComponent.LODParentPrimitive"); }

    int& ObjectLayerField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.ObjectLayer"); }

    float& OverrideStepHeightField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.OverrideStepHeight"); }

    //FOctreeElementId2& InternalOctreeIdField() { return *GetNativePointerField<FOctreeElementId2*>(this, "UPrimitiveComponent.InternalOctreeId"); }

    //FieldArray<FOctreeElementId2, 18> SpecializedInternalOctreeIdField() { return { this, "UPrimitiveComponent.SpecializedInternalOctreeId" }; }

    int& InternalOctreeMaskField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.InternalOctreeMask"); }

    //TLazyObjectPtr<UPrimitiveComponent>& ReplacementPrimitiveField() { return *GetNativePointerField<TLazyObjectPtr<UPrimitiveComponent>*>(this, "UPrimitiveComponent.ReplacementPrimitive"); }

    unsigned int& ProxyMeshIDField() { return *GetNativePointerField<unsigned int*>(this, "UPrimitiveComponent.ProxyMeshID"); }

    bool& bHasActiveProxyMeshChildrenField() { return *GetNativePointerField<bool*>(this, "UPrimitiveComponent.bHasActiveProxyMeshChildren"); }

    //TLinkedList<UPrimitiveComponent*>& ProxyMeshLinkField() { return *GetNativePointerField<TLinkedList<UPrimitiveComponent*>*>(this, "UPrimitiveComponent.ProxyMeshLink"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bEnableAutoLODGeneration() { return { this, "UPrimitiveComponent.bEnableAutoLODGeneration" }; }

    BitFieldValue<bool, unsigned __int32> bIsActorTextureStreamingBuiltData() { return { this, "UPrimitiveComponent.bIsActorTextureStreamingBuiltData" }; }

    BitFieldValue<bool, unsigned __int32> bIsValidTextureStreamingBuiltData() { return { this, "UPrimitiveComponent.bIsValidTextureStreamingBuiltData" }; }

    BitFieldValue<bool, unsigned __int32> bNeverDistanceCull() { return { this, "UPrimitiveComponent.bNeverDistanceCull" }; }

    BitFieldValue<bool, unsigned __int32> bAttachedToStreamingManagerAsStatic() { return { this, "UPrimitiveComponent.bAttachedToStreamingManagerAsStatic" }; }

    BitFieldValue<bool, unsigned __int32> bAttachedToStreamingManagerAsDynamic() { return { this, "UPrimitiveComponent.bAttachedToStreamingManagerAsDynamic" }; }

    BitFieldValue<bool, unsigned __int32> bHandledByStreamingManagerAsDynamic() { return { this, "UPrimitiveComponent.bHandledByStreamingManagerAsDynamic" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreStreamingManagerUpdate() { return { this, "UPrimitiveComponent.bIgnoreStreamingManagerUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bAttachedToCoarseMeshStreamingManager() { return { this, "UPrimitiveComponent.bAttachedToCoarseMeshStreamingManager" }; }

    BitFieldValue<bool, unsigned __int32> bAlwaysCreatePhysicsState() { return { this, "UPrimitiveComponent.bAlwaysCreatePhysicsState" }; }

    BitFieldValue<bool, unsigned __int32> bGenerateOverlapEvents() { return { this, "UPrimitiveComponent.bGenerateOverlapEvents" }; }

    BitFieldValue<bool, unsigned __int32> bMultiBodyOverlap() { return { this, "UPrimitiveComponent.bMultiBodyOverlap" }; }

    BitFieldValue<bool, unsigned __int32> bTraceComplexOnMove() { return { this, "UPrimitiveComponent.bTraceComplexOnMove" }; }

    BitFieldValue<bool, unsigned __int32> bReturnMaterialOnMove() { return { this, "UPrimitiveComponent.bReturnMaterialOnMove" }; }

    BitFieldValue<bool, unsigned __int32> bUseViewOwnerDepthPriorityGroup() { return { this, "UPrimitiveComponent.bUseViewOwnerDepthPriorityGroup" }; }

    BitFieldValue<bool, unsigned __int32> bAllowCullDistanceVolume() { return { this, "UPrimitiveComponent.bAllowCullDistanceVolume" }; }

    BitFieldValue<bool, unsigned __int32> bVisibleInReflectionCaptures() { return { this, "UPrimitiveComponent.bVisibleInReflectionCaptures" }; }

    BitFieldValue<bool, unsigned __int32> bVisibleInRealTimeSkyCaptures() { return { this, "UPrimitiveComponent.bVisibleInRealTimeSkyCaptures" }; }

    BitFieldValue<bool, unsigned __int32> bVisibleInRayTracing() { return { this, "UPrimitiveComponent.bVisibleInRayTracing" }; }

    BitFieldValue<bool, unsigned __int32> bRenderInMainPass() { return { this, "UPrimitiveComponent.bRenderInMainPass" }; }

    BitFieldValue<bool, unsigned __int32> bRenderInDepthPass() { return { this, "UPrimitiveComponent.bRenderInDepthPass" }; }

    BitFieldValue<bool, unsigned __int32> bReceivesDecals() { return { this, "UPrimitiveComponent.bReceivesDecals" }; }

    BitFieldValue<bool, unsigned __int32> bHoldout() { return { this, "UPrimitiveComponent.bHoldout" }; }

    BitFieldValue<bool, unsigned __int32> bOwnerNoSee() { return { this, "UPrimitiveComponent.bOwnerNoSee" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyOwnerSee() { return { this, "UPrimitiveComponent.bOnlyOwnerSee" }; }

    BitFieldValue<bool, unsigned __int32> bTreatAsBackgroundForOcclusion() { return { this, "UPrimitiveComponent.bTreatAsBackgroundForOcclusion" }; }

    BitFieldValue<bool, unsigned __int32> bUseAsOccluder() { return { this, "UPrimitiveComponent.bUseAsOccluder" }; }

    BitFieldValue<bool, unsigned __int32> bSelectable() { return { this, "UPrimitiveComponent.bSelectable" }; }

    BitFieldValue<bool, unsigned __int32> bForceMipStreaming() { return { this, "UPrimitiveComponent.bForceMipStreaming" }; }

    BitFieldValue<bool, unsigned __int32> bHasPerInstanceHitProxies() { return { this, "UPrimitiveComponent.bHasPerInstanceHitProxies" }; }

    BitFieldValue<bool, unsigned __int32> CastShadow() { return { this, "UPrimitiveComponent.CastShadow" }; }

    BitFieldValue<bool, unsigned __int32> bEmissiveLightSource() { return { this, "UPrimitiveComponent.bEmissiveLightSource" }; }

    BitFieldValue<bool, unsigned __int32> bAffectDynamicIndirectLighting() { return { this, "UPrimitiveComponent.bAffectDynamicIndirectLighting" }; }

    BitFieldValue<bool, unsigned __int32> bAffectIndirectLightingWhileHidden() { return { this, "UPrimitiveComponent.bAffectIndirectLightingWhileHidden" }; }

    BitFieldValue<bool, unsigned __int32> bAffectDistanceFieldLighting() { return { this, "UPrimitiveComponent.bAffectDistanceFieldLighting" }; }

    BitFieldValue<bool, unsigned __int32> bCastDynamicShadow() { return { this, "UPrimitiveComponent.bCastDynamicShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastStaticShadow() { return { this, "UPrimitiveComponent.bCastStaticShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastVolumetricTranslucentShadow() { return { this, "UPrimitiveComponent.bCastVolumetricTranslucentShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastContactShadow() { return { this, "UPrimitiveComponent.bCastContactShadow" }; }

    BitFieldValue<bool, unsigned __int32> bSelfShadowOnly() { return { this, "UPrimitiveComponent.bSelfShadowOnly" }; }

    BitFieldValue<bool, unsigned __int32> bCastFarShadow() { return { this, "UPrimitiveComponent.bCastFarShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastInsetShadow() { return { this, "UPrimitiveComponent.bCastInsetShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastCinematicShadow() { return { this, "UPrimitiveComponent.bCastCinematicShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastHiddenShadow() { return { this, "UPrimitiveComponent.bCastHiddenShadow" }; }

    BitFieldValue<bool, unsigned __int32> bCastShadowAsTwoSided() { return { this, "UPrimitiveComponent.bCastShadowAsTwoSided" }; }

    BitFieldValue<bool, unsigned __int32> bLightAsIfStatic_DEPRECATED() { return { this, "UPrimitiveComponent.bLightAsIfStatic_DEPRECATED" }; }

    BitFieldValue<bool, unsigned __int32> bLightAttachmentsAsGroup() { return { this, "UPrimitiveComponent.bLightAttachmentsAsGroup" }; }

    BitFieldValue<bool, unsigned __int32> bExcludeFromLightAttachmentGroup() { return { this, "UPrimitiveComponent.bExcludeFromLightAttachmentGroup" }; }

    BitFieldValue<bool, unsigned __int32> bReceiveMobileCSMShadows() { return { this, "UPrimitiveComponent.bReceiveMobileCSMShadows" }; }

    BitFieldValue<bool, unsigned __int32> bSingleSampleShadowFromStationaryLights() { return { this, "UPrimitiveComponent.bSingleSampleShadowFromStationaryLights" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreRadialImpulse() { return { this, "UPrimitiveComponent.bIgnoreRadialImpulse" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreRadialForce() { return { this, "UPrimitiveComponent.bIgnoreRadialForce" }; }

    BitFieldValue<bool, unsigned __int32> bApplyImpulseOnDamage() { return { this, "UPrimitiveComponent.bApplyImpulseOnDamage" }; }

    BitFieldValue<bool, unsigned __int32> bReplicatePhysicsToAutonomousProxy() { return { this, "UPrimitiveComponent.bReplicatePhysicsToAutonomousProxy" }; }

    BitFieldValue<bool, unsigned __int32> bFillCollisionUnderneathForNavmesh() { return { this, "UPrimitiveComponent.bFillCollisionUnderneathForNavmesh" }; }

    BitFieldValue<bool, unsigned __int32> AlwaysLoadOnClient() { return { this, "UPrimitiveComponent.AlwaysLoadOnClient" }; }

    BitFieldValue<bool, unsigned __int32> AlwaysLoadOnServer() { return { this, "UPrimitiveComponent.AlwaysLoadOnServer" }; }

    BitFieldValue<bool, unsigned __int32> bUseEditorCompositing() { return { this, "UPrimitiveComponent.bUseEditorCompositing" }; }

    BitFieldValue<bool, unsigned __int32> bIsBeingMovedByEditor() { return { this, "UPrimitiveComponent.bIsBeingMovedByEditor" }; }

    BitFieldValue<bool, unsigned __int32> bRenderCustomDepth() { return { this, "UPrimitiveComponent.bRenderCustomDepth" }; }

    BitFieldValue<bool, unsigned __int32> bVisibleInSceneCaptureOnly() { return { this, "UPrimitiveComponent.bVisibleInSceneCaptureOnly" }; }

    BitFieldValue<bool, unsigned __int32> bHiddenInSceneCapture() { return { this, "UPrimitiveComponent.bHiddenInSceneCapture" }; }

    BitFieldValue<bool, unsigned __int32> bRayTracingFarField() { return { this, "UPrimitiveComponent.bRayTracingFarField" }; }

    BitFieldValue<bool, unsigned __int32> bCachedAllCollideableDescendantsRelative() { return { this, "UPrimitiveComponent.bCachedAllCollideableDescendantsRelative" }; }

    BitFieldValue<bool, unsigned __int32> bHasNoStreamableTextures() { return { this, "UPrimitiveComponent.bHasNoStreamableTextures" }; }

    BitFieldValue<bool, unsigned __int32> bStaticWhenNotMoveable() { return { this, "UPrimitiveComponent.bStaticWhenNotMoveable" }; }

    BitFieldValue<bool, unsigned __int32> bPSOPrecacheCalled() { return { this, "UPrimitiveComponent.bPSOPrecacheCalled" }; }

    BitFieldValue<bool, unsigned __int32> bPSOPrecacheRequestBoosted() { return { this, "UPrimitiveComponent.bPSOPrecacheRequestBoosted" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreUpdatingOwnersLastRenderTime() { return { this, "UPrimitiveComponent.bIgnoreUpdatingOwnersLastRenderTime" }; }

    BitFieldValue<bool, unsigned __int32> bForcePreventBlockingProjectiles() { return { this, "UPrimitiveComponent.bForcePreventBlockingProjectiles" }; }

    BitFieldValue<bool, unsigned __int32> bForceOverlapEvents() { return { this, "UPrimitiveComponent.bForceOverlapEvents" }; }

    BitFieldValue<bool, unsigned __int32> bIsInForeground() { return { this, "UPrimitiveComponent.bIsInForeground" }; }

    BitFieldValue<bool, unsigned __int32> bUseInternalOctree() { return { this, "UPrimitiveComponent.bUseInternalOctree" }; }

    BitFieldValue<bool, unsigned __int32> bUseInternalOctreeOnClient() { return { this, "UPrimitiveComponent.bUseInternalOctreeOnClient" }; }

    BitFieldValue<bool, unsigned __int32> bRegisteredInternalOctree() { return { this, "UPrimitiveComponent.bRegisteredInternalOctree" }; }

    BitFieldValue<bool, unsigned __int32> bForceDynamicPhysics() { return { this, "UPrimitiveComponent.bForceDynamicPhysics" }; }

    BitFieldValue<bool, unsigned __int32> bPreventCharacterBasing() { return { this, "UPrimitiveComponent.bPreventCharacterBasing" }; }

    BitFieldValue<bool, unsigned __int32> bAllowBasedCharacters() { return { this, "UPrimitiveComponent.bAllowBasedCharacters" }; }

    BitFieldValue<bool, unsigned __int32> bIsAbstractBasingComponent() { return { this, "UPrimitiveComponent.bIsAbstractBasingComponent" }; }

    BitFieldValue<bool, unsigned __int32> bClimbable() { return { this, "UPrimitiveComponent.bClimbable" }; }

    BitFieldValue<bool, unsigned __int32> bUseAbsoluteMaxDrawDisatance() { return { this, "UPrimitiveComponent.bUseAbsoluteMaxDrawDisatance" }; }

    BitFieldValue<bool, unsigned __int32> bMovableUseDynamicDrawDistance() { return { this, "UPrimitiveComponent.bMovableUseDynamicDrawDistance" }; }

    BitFieldValue<bool, unsigned __int32> bIncludeBoundsRadiusInDrawDistances() { return { this, "UPrimitiveComponent.bIncludeBoundsRadiusInDrawDistances" }; }

    BitFieldValue<bool, unsigned __int32> bExcludeFromLevelBounds() { return { this, "UPrimitiveComponent.bExcludeFromLevelBounds" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoredByCharacterEncroachment() { return { this, "UPrimitiveComponent.bIgnoredByCharacterEncroachment" }; }

    BitFieldValue<bool, unsigned __int32> bPreventDamage() { return { this, "UPrimitiveComponent.bPreventDamage" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UPrimitiveComponent.StaticClass()"); }

    void Serialize(FStructuredArchiveRecord Record) { NativeCall<void, FStructuredArchiveRecord>(this, "UPrimitiveComponent.Serialize(FStructuredArchiveRecord)", Record); }

    bool OverlapComponent(const UE::Math::TVector<double>* Pos, const UE::Math::TQuat<double>* Rot, const struct FCollisionShape* CollisionShape) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, const FCollisionShape*>(this, "UPrimitiveComponent.OverlapComponent(UE::Math::TVector<double>&,UE::Math::TQuat<double>&,FCollisionShape&)", Pos, Rot, CollisionShape); }

    bool AreSymmetricRotations(const UE::Math::TQuat<double>* A, const UE::Math::TQuat<double>* B, const UE::Math::TVector<double>* Scale3D) { return NativeCall<bool, const UE::Math::TQuat<double>*, const UE::Math::TQuat<double>*, const UE::Math::TVector<double>*>(this, "UPrimitiveComponent.AreSymmetricRotations(UE::Math::TQuat<double>&,UE::Math::TQuat<double>&,UE::Math::TVector<double>&)", A, B, Scale3D); }

    ESceneDepthPriorityGroup GetStaticDepthPriorityGroup() { return NativeCall<ESceneDepthPriorityGroup>(this, "UPrimitiveComponent.GetStaticDepthPriorityGroup()"); }

    bool HasValidSettingsForStaticLighting(bool bOverlookInvalidComponents) { return NativeCall<bool, bool>(this, "UPrimitiveComponent.HasValidSettingsForStaticLighting(bool)", bOverlookInvalidComponents); }

    UMaterialInterface* GetEditorMaterial(int ElementIndex) { return NativeCall<UMaterialInterface*, int>(this, "UPrimitiveComponent.GetEditorMaterial(int)", ElementIndex); }

    //const FReferenceSkeleton* GetRuntimeVirtualTextures() { return NativeCall<const FReferenceSkeleton*>(this, "UPrimitiveComponent.GetRuntimeVirtualTextures()"); }

    void ResizeGrow(int OldNum) { NativeCall<void, int>(this, "UPrimitiveComponent.ResizeGrow(int)", OldNum); }

    void SetPhysicsAngularVelocityInDegrees(UE::Math::TVector<double>* NewAngVel, __int64 bAddToCurrent, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, __int64, FName>(this, "UPrimitiveComponent.SetPhysicsAngularVelocityInDegrees(UE::Math::TVector<double>,bool,FName)", NewAngVel, bAddToCurrent, BoneName); }

    void GetLightAndShadowMapMemoryUsage(int* OutNum, int* OutMax) { NativeCall<void, int*, int*>(this, "UPrimitiveComponent.GetLightAndShadowMapMemoryUsage(int&,int&)", OutNum, OutMax); }

    static void StaticRegisterNativesUPrimitiveComponent() { NativeCall<void>(nullptr, "UPrimitiveComponent.StaticRegisterNativesUPrimitiveComponent()"); }

    void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) { NativeCall<void, bool, bool>(this, "UPrimitiveComponent.InvalidateLightingCacheDetailed(bool,bool)", bInvalidateBuildEnqueuedLighting, bTranslationOnly); }

    bool IsEditorOnly() { return NativeCall<bool>(this, "UPrimitiveComponent.IsEditorOnly()"); }

    //void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext* LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >* OutStreamingRenderAssets) { NativeCall<void, FStreamingTextureLevelContext*, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.GetStreamingRenderAssetInfo(FStreamingTextureLevelContext&,TArray<FStreamingRenderAssetPrimitiveInfo,TSizedDefaultAllocator<32>>&)", LevelContext, OutStreamingRenderAssets); }

    //void GetStreamingRenderAssetInfoWithNULLRemoval(FStreamingTextureLevelContext* LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >* OutStreamingRenderAssets) { NativeCall<void, FStreamingTextureLevelContext*, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.GetStreamingRenderAssetInfoWithNULLRemoval(FStreamingTextureLevelContext&,TArray<FStreamingRenderAssetPrimitiveInfo,TSizedDefaultAllocator<32>>&)", LevelContext, OutStreamingRenderAssets); }

    void GetUsedTextures(TArray<UTexture*, TSizedDefaultAllocator<32> >* OutTextures, EMaterialQualityLevel::Type QualityLevel) { NativeCall<void, TArray<UTexture*, TSizedDefaultAllocator<32> >*, EMaterialQualityLevel::Type>(this, "UPrimitiveComponent.GetUsedTextures(TArray<UTexture*,TSizedDefaultAllocator<32>>&,EMaterialQualityLevel::Type)", OutTextures, QualityLevel); }

    void CreateRenderState_Concurrent(FRegisterComponentContext* Context) { NativeCall<void, FRegisterComponentContext*>(this, "UPrimitiveComponent.CreateRenderState_Concurrent(FRegisterComponentContext*)", Context); }

    void SendRenderTransform_Concurrent() { NativeCall<void>(this, "UPrimitiveComponent.SendRenderTransform_Concurrent()"); }

    void OnRegister() { NativeCall<void>(this, "UPrimitiveComponent.OnRegister()"); }

    void OnUnregister() { NativeCall<void>(this, "UPrimitiveComponent.OnUnregister()"); }

    //TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* GetComponentInstanceData(TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* result) { return NativeCall<TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*, TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*>(this, "UPrimitiveComponent.GetComponentInstanceData()", result); }

    void OnAttachmentChanged() { NativeCall<void>(this, "UPrimitiveComponent.OnAttachmentChanged()"); }

    void DestroyRenderState_Concurrent() { NativeCall<void>(this, "UPrimitiveComponent.DestroyRenderState_Concurrent()"); }

    void OnCreatePhysicsState() { NativeCall<void>(this, "UPrimitiveComponent.OnCreatePhysicsState()"); }

    void EnsurePhysicsStateCreated() { NativeCall<void>(this, "UPrimitiveComponent.EnsurePhysicsStateCreated()"); }

    void MarkChildPrimitiveComponentRenderStateDirty() { NativeCall<void>(this, "UPrimitiveComponent.MarkChildPrimitiveComponentRenderStateDirty()"); }

    //void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) { NativeCall<void, EUpdateTransformFlags, ETeleportType>(this, "UPrimitiveComponent.OnUpdateTransform(EUpdateTransformFlags,ETeleportType)", UpdateTransformFlags, Teleport); }

    void OnDestroyPhysicsState() { NativeCall<void>(this, "UPrimitiveComponent.OnDestroyPhysicsState()"); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UPrimitiveComponent.Serialize(FArchive&)", Ar); }

    void ReceiveComponentDamage(float DamageAmount, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, AController*, AActor*>(this, "UPrimitiveComponent.ReceiveComponentDamage(float,FDamageEvent&,AController*,AActor*)", DamageAmount, DamageEvent, EventInstigator, DamageCauser); }

    void PostInitProperties() { NativeCall<void>(this, "UPrimitiveComponent.PostInitProperties()"); }

    void PostLoad() { NativeCall<void>(this, "UPrimitiveComponent.PostLoad()"); }

    void PostDuplicate(bool bDuplicateForPIE) { NativeCall<void, bool>(this, "UPrimitiveComponent.PostDuplicate(bool)", bDuplicateForPIE); }

    void BeginDestroy() { NativeCall<void>(this, "UPrimitiveComponent.BeginDestroy()"); }

    void OnComponentDestroyed(bool bDestroyingHierarchy) { NativeCall<void, bool>(this, "UPrimitiveComponent.OnComponentDestroyed(bool)", bDestroyingHierarchy); }

    bool IsReadyForFinishDestroy() { return NativeCall<bool>(this, "UPrimitiveComponent.IsReadyForFinishDestroy()"); }

    bool NeedsLoadForClient() { return NativeCall<bool>(this, "UPrimitiveComponent.NeedsLoadForClient()"); }

    bool NeedsLoadForServer() { return NativeCall<bool>(this, "UPrimitiveComponent.NeedsLoadForServer()"); }

    void SetOwnerNoSee(bool bNewOwnerNoSee) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetOwnerNoSee(bool)", bNewOwnerNoSee); }

    void SetOnlyOwnerSee(bool bNewOnlyOwnerSee) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetOnlyOwnerSee(bool)", bNewOnlyOwnerSee); }

    bool ShouldComponentAddToScene() { return NativeCall<bool>(this, "UPrimitiveComponent.ShouldComponentAddToScene()"); }

    bool ShouldCreatePhysicsState() { return NativeCall<bool>(this, "UPrimitiveComponent.ShouldCreatePhysicsState()"); }

    bool HasValidPhysicsState() { return NativeCall<bool>(this, "UPrimitiveComponent.HasValidPhysicsState()"); }

    bool ShouldRenderSelected() { return NativeCall<bool>(this, "UPrimitiveComponent.ShouldRenderSelected()"); }

    void SetCastHiddenShadow(bool NewCastHiddenShadow) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetCastHiddenShadow(bool)", NewCastHiddenShadow); }

    void PushSelectionToProxy() { NativeCall<void>(this, "UPrimitiveComponent.PushSelectionToProxy()"); }

    void SetCullDistance(float NewCullDistance) { NativeCall<void, float>(this, "UPrimitiveComponent.SetCullDistance(float)", NewCullDistance); }

    bool IsWorldGeometry() { return NativeCall<bool>(this, "UPrimitiveComponent.IsWorldGeometry()"); }

    ECollisionChannel GetCollisionObjectType() { return NativeCall<ECollisionChannel>(this, "UPrimitiveComponent.GetCollisionObjectType()"); }

    UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamic(int ElementIndex) { return NativeCall<UMaterialInstanceDynamic*, int>(this, "UPrimitiveComponent.CreateAndSetMaterialInstanceDynamic(int)", ElementIndex); }

    UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamicFromMaterial(int ElementIndex, UMaterialInterface* Parent) { return NativeCall<UMaterialInstanceDynamic*, int, UMaterialInterface*>(this, "UPrimitiveComponent.CreateAndSetMaterialInstanceDynamicFromMaterial(int,UMaterialInterface*)", ElementIndex, Parent); }

    UMaterialInstanceDynamic* CreateDynamicMaterialInstance(int ElementIndex, UMaterialInterface* SourceMaterial, FName OptionalName) { return NativeCall<UMaterialInstanceDynamic*, int, UMaterialInterface*, FName>(this, "UPrimitiveComponent.CreateDynamicMaterialInstance(int,UMaterialInterface*,FName)", ElementIndex, SourceMaterial, OptionalName); }

    int GetCustomPrimitiveDataIndexForScalarParameter(FName ParameterName) { return NativeCall<int, FName>(this, "UPrimitiveComponent.GetCustomPrimitiveDataIndexForScalarParameter(FName)", ParameterName); }

    int GetCustomPrimitiveDataIndexForVectorParameter(FName ParameterName) { return NativeCall<int, FName>(this, "UPrimitiveComponent.GetCustomPrimitiveDataIndexForVectorParameter(FName)", ParameterName); }

    void SetCustomPrimitiveDataFloat(int DataIndex, float Value) { NativeCall<void, int, float>(this, "UPrimitiveComponent.SetCustomPrimitiveDataFloat(int,float)", DataIndex, Value); }

    UMaterialInterface* GetMaterialFromCollisionFaceIndex(int FaceIndex, int* SectionIndex) { return NativeCall<UMaterialInterface*, int, int*>(this, "UPrimitiveComponent.GetMaterialFromCollisionFaceIndex(int,int&)", FaceIndex, SectionIndex); }

    void InitSweepCollisionParams(FCollisionQueryParams* OutParams, FCollisionResponseParams* OutResponseParam) { NativeCall<void, FCollisionQueryParams*, FCollisionResponseParams*>(this, "UPrimitiveComponent.InitSweepCollisionParams(FCollisionQueryParams&,FCollisionResponseParams&)", OutParams, OutResponseParam); }

    //FCollisionShape* GetCollisionShape(FCollisionShape* result, float Inflation) { return NativeCall<FCollisionShape*, FCollisionShape*, float>(this, "UPrimitiveComponent.GetCollisionShape(float)", result, Inflation); }

    //bool MoveComponentImpl(const UE::Math::TVector<double>* Delta, const UE::Math::TQuat<double>* NewRotationQuat, bool bSweep, FHitResult* OutHit, EMoveComponentFlags MoveFlags, ETeleportType Teleport) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, bool, FHitResult*, EMoveComponentFlags, ETeleportType>(this, "UPrimitiveComponent.MoveComponentImpl(UE::Math::TVector<double>&,UE::Math::TQuat<double>&,bool,FHitResult*,EMoveComponentFlags,ETeleportType)", Delta, NewRotationQuat, bSweep, OutHit, MoveFlags, Teleport); }

    void DispatchBlockingHit(AActor* Owner, const FHitResult* BlockingHit) { NativeCall<void, AActor*, const FHitResult*>(this, "UPrimitiveComponent.DispatchBlockingHit(AActor&,FHitResult&)", Owner, BlockingHit); }

    void DispatchWakeEvents(ESleepEvent WakeEvent, FName BoneName) { NativeCall<void, ESleepEvent, FName>(this, "UPrimitiveComponent.DispatchWakeEvents(ESleepEvent,FName)", WakeEvent, BoneName); }

    //void GetNavigationData(FNavigationRelevantData* OutData) { NativeCall<void, FNavigationRelevantData*>(this, "UPrimitiveComponent.GetNavigationData(FNavigationRelevantData&)", OutData); }

    bool IsNavigationRelevant() { return NativeCall<bool>(this, "UPrimitiveComponent.IsNavigationRelevant()"); }

    bool LineTraceComponent(FHitResult* OutHit, const UE::Math::TVector<double>* Start, const UE::Math::TVector<double>* End, const FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, const FCollisionQueryParams*>(this, "UPrimitiveComponent.LineTraceComponent(FHitResult&,UE::Math::TVector<double>,UE::Math::TVector<double>,FCollisionQueryParams&)", OutHit, Start, End, Params); }

    bool SweepComponent(FHitResult* OutHit, const UE::Math::TVector<double>* Start, const UE::Math::TVector<double>* End, const UE::Math::TQuat<double>* ShapeWorldRotation, const FCollisionShape* CollisionShape, bool bTraceComplex) { return NativeCall<bool, FHitResult*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, const FCollisionShape*, bool>(this, "UPrimitiveComponent.SweepComponent(FHitResult&,UE::Math::TVector<double>,UE::Math::TVector<double>,UE::Math::TQuat<double>&,FCollisionShape&,bool)", OutHit, Start, End, ShapeWorldRotation, CollisionShape, bTraceComplex); }

    char ComponentOverlapComponentImpl(UPrimitiveComponent* PrimComp, const UE::Math::TVector<double>* Pos, const UE::Math::TQuat<double>* Quat) { return NativeCall<char, UPrimitiveComponent*, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*>(this, "UPrimitiveComponent.ComponentOverlapComponentImpl(UPrimitiveComponent*,UE::Math::TVector<double>,UE::Math::TQuat<double>&,FCollisionQueryParams&)", PrimComp, Pos, Quat); }

    //bool OverlapComponent(const UE::Math::TVector<double>* Pos, const UE::Math::TQuat<double>* Rot, const FCollisionShape* CollisionShape) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, const FCollisionShape*>(this, "UPrimitiveComponent.OverlapComponent(UE::Math::TVector<double>&,UE::Math::TQuat<double>&,FCollisionShape&)", Pos, Rot, CollisionShape); }

    //bool ComputePenetration(FMTDResult* OutMTD, const FCollisionShape* CollisionShape, const UE::Math::TVector<double>* Pos, const UE::Math::TQuat<double>* Rot) { return NativeCall<bool, FMTDResult*, const FCollisionShape*, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*>(this, "UPrimitiveComponent.ComputePenetration(FMTDResult&,FCollisionShape&,UE::Math::TVector<double>&,UE::Math::TQuat<double>&)", OutMTD, CollisionShape, Pos, Rot); }

    bool IsOverlappingActor(const AActor* Other) { return NativeCall<bool, const AActor*>(this, "UPrimitiveComponent.IsOverlappingActor(AActor*)", Other); }

    void BeginComponentOverlap(const FOverlapInfo* OtherOverlap, bool bDoNotifies) { NativeCall<void, const FOverlapInfo*, bool>(this, "UPrimitiveComponent.BeginComponentOverlap(FOverlapInfo&,bool)", OtherOverlap, bDoNotifies); }

    void EndComponentOverlap(const FOverlapInfo* OtherOverlap, bool bDoNotifies, bool bSkipNotifySelf) { NativeCall<void, const FOverlapInfo*, bool, bool>(this, "UPrimitiveComponent.EndComponentOverlap(FOverlapInfo&,bool,bool)", OtherOverlap, bDoNotifies, bSkipNotifySelf); }

    void GetOverlappingActors(TArray<AActor*, TSizedDefaultAllocator<32> >* OutOverlappingActors, TSubclassOf<AActor> ClassFilter) { NativeCall<void, TArray<AActor*, TSizedDefaultAllocator<32> >*, TSubclassOf<AActor>>(this, "UPrimitiveComponent.GetOverlappingActors(TArray<AActor*,TSizedDefaultAllocator<32>>&,TSubclassOf<AActor>)", OutOverlappingActors, ClassFilter); }

    void GetOverlappingActors(TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>* OutOverlappingActors, TSubclassOf<AActor> ClassFilter) { NativeCall<void, TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>*, TSubclassOf<AActor>>(this, "UPrimitiveComponent.GetOverlappingActors(TSet<AActor*,DefaultKeyFuncs<AActor*,0>,FDefaultSetAllocator>&,TSubclassOf<AActor>)", OutOverlappingActors, ClassFilter); }

    void GetOverlappingComponents(TArray<UPrimitiveComponent*, TSizedDefaultAllocator<32> >* OutOverlappingComponents) { NativeCall<void, TArray<UPrimitiveComponent*, TSizedDefaultAllocator<32> >*>(this, "UPrimitiveComponent.GetOverlappingComponents(TArray<UPrimitiveComponent*,TSizedDefaultAllocator<32>>&)", OutOverlappingComponents); }

    void GetOverlappingComponents(TSet<UPrimitiveComponent*, DefaultKeyFuncs<UPrimitiveComponent*, 0>, FDefaultSetAllocator>* OutOverlappingComponents) { NativeCall<void, TSet<UPrimitiveComponent*, DefaultKeyFuncs<UPrimitiveComponent*, 0>, FDefaultSetAllocator>*>(this, "UPrimitiveComponent.GetOverlappingComponents(TSet<UPrimitiveComponent*,DefaultKeyFuncs<UPrimitiveComponent*,0>,FDefaultSetAllocator>&)", OutOverlappingComponents); }

    bool AreAllCollideableDescendantsRelative(bool bAllowCachedValue) { return NativeCall<bool, bool>(this, "UPrimitiveComponent.AreAllCollideableDescendantsRelative(bool)", bAllowCachedValue); }

    void BeginPlay() { NativeCall<void>(this, "UPrimitiveComponent.BeginPlay()"); }

    void IgnoreActorWhenMoving(AActor* Actor, bool bShouldIgnore) { NativeCall<void, AActor*, bool>(this, "UPrimitiveComponent.IgnoreActorWhenMoving(AActor*,bool)", Actor, bShouldIgnore); }

    bool UpdateOverlapsImpl(const TArrayView<FOverlapInfo const, int>* NewPendingOverlaps, bool bDoNotifies, const TArrayView<FOverlapInfo const, int>* OverlapsAtEndLocation) { return NativeCall<bool, const TArrayView<FOverlapInfo const, int>*, bool, const TArrayView<FOverlapInfo const, int>*>(this, "UPrimitiveComponent.UpdateOverlapsImpl(TArrayView<FOverlapInfo,int>*,bool,TArrayView<FOverlapInfo,int>*)", NewPendingOverlaps, bDoNotifies, OverlapsAtEndLocation); }

    void SetGenerateOverlapEvents(bool bInGenerateOverlapEvents) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetGenerateOverlapEvents(bool)", bInGenerateOverlapEvents); }

    void OnGenerateOverlapEventsChanged() { NativeCall<void>(this, "UPrimitiveComponent.OnGenerateOverlapEventsChanged()"); }

    void ClearComponentOverlaps(bool bDoNotifies, bool bSkipNotifySelf) { NativeCall<void, bool, bool>(this, "UPrimitiveComponent.ClearComponentOverlaps(bool,bool)", bDoNotifies, bSkipNotifySelf); }

    //bool ComponentOverlapMultiImpl(TArray<FOverlapResult, TSizedDefaultAllocator<32> >* OutOverlaps, const UWorld* World, const UE::Math::TVector<double>* Pos, const UE::Math::TQuat<double>* Quat, ECollisionChannel TestChannel, const FComponentQueryParams* Params, const FCollisionObjectQueryParams* ObjectQueryParams) { return NativeCall<bool, TArray<FOverlapResult, TSizedDefaultAllocator<32> >*, const UWorld*, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, ECollisionChannel, const FComponentQueryParams*, const FCollisionObjectQueryParams*>(this, "UPrimitiveComponent.ComponentOverlapMultiImpl(TArray<FOverlapResult,TSizedDefaultAllocator<32>>&,UWorld*,UE::Math::TVector<double>&,UE::Math::TQuat<double>&,ECollisionChannel,FComponentQueryParams&,FCollisionObjectQueryParams&)", OutOverlaps, World, Pos, Quat, TestChannel, Params, ObjectQueryParams); }

    void UpdatePhysicsVolume(bool bTriggerNotifiers) { NativeCall<void, bool>(this, "UPrimitiveComponent.UpdatePhysicsVolume(bool)", bTriggerNotifiers); }

    static void DispatchMouseOverEvents(UPrimitiveComponent* CurrentComponent, UPrimitiveComponent* NewComponent) { NativeCall<void, UPrimitiveComponent*, UPrimitiveComponent*>(nullptr, "UPrimitiveComponent.DispatchMouseOverEvents(UPrimitiveComponent*,UPrimitiveComponent*)", CurrentComponent, NewComponent); }

    static void DispatchTouchOverEvents(ETouchIndex::Type FingerIndex, UPrimitiveComponent* CurrentComponent, UPrimitiveComponent* NewComponent) { NativeCall<void, ETouchIndex::Type, UPrimitiveComponent*, UPrimitiveComponent*>(nullptr, "UPrimitiveComponent.DispatchTouchOverEvents(ETouchIndex::Type,UPrimitiveComponent*,UPrimitiveComponent*)", FingerIndex, CurrentComponent, NewComponent); }

    void DispatchOnClicked(FKey* ButtonPressed) { NativeCall<void, FKey*>(this, "UPrimitiveComponent.DispatchOnClicked(FKey)", ButtonPressed); }

    void DispatchOnReleased(FKey* ButtonReleased) { NativeCall<void, FKey*>(this, "UPrimitiveComponent.DispatchOnReleased(FKey)", ButtonReleased); }

    void GetResourceSizeEx(FResourceSizeEx* CumulativeResourceSize) { NativeCall<void, FResourceSizeEx*>(this, "UPrimitiveComponent.GetResourceSizeEx(FResourceSizeEx&)", CumulativeResourceSize); }

    void SetCustomDepthStencilValue(int Value) { NativeCall<void, int>(this, "UPrimitiveComponent.SetCustomDepthStencilValue(int)", Value); }

    bool CanCharacterStepUp(APawn* Pawn) { return NativeCall<bool, APawn*>(this, "UPrimitiveComponent.CanCharacterStepUp(APawn*)", Pawn); }

    bool CanEditSimulatePhysics() { return NativeCall<bool>(this, "UPrimitiveComponent.CanEditSimulatePhysics()"); }

    bool WasRecentlyRendered(float Tolerance) { return NativeCall<bool, float>(this, "UPrimitiveComponent.WasRecentlyRendered(float)", Tolerance); }

    //void SetupPrecachePSOParams(FPSOPrecacheParams* Params) { NativeCall<void, FPSOPrecacheParams*>(this, "UPrimitiveComponent.SetupPrecachePSOParams(FPSOPrecacheParams&)", Params); }

    bool IsPSOPrecaching() { return NativeCall<bool>(this, "UPrimitiveComponent.IsPSOPrecaching()"); }

    void GetCollisionResponseSet(FCollisionResponseSet* OutCollision) { NativeCall<void, FCollisionResponseSet*>(this, "UPrimitiveComponent.GetCollisionResponseSet(FCollisionResponseSet&)", OutCollision); }

    //bool ConvertRotationOverlapsToCurrentOverlaps<class TSizedInlineAllocator<3, 32, class TSizedDefaultAllocator<32>>>(TArray<FOverlapInfo, TSizedInlineAllocator<3, 32, TSizedDefaultAllocator<32> > >* OutOverlapsAtEndLocation, const TArrayView<FOverlapInfo const, int>* CurrentOverlaps) { return NativeCall<bool, TArray<FOverlapInfo, TSizedInlineAllocator<3, 32, TSizedDefaultAllocator<32> > >*, const TArrayView<FOverlapInfo const, int>*>(this, "UPrimitiveComponent.ConvertRotationOverlapsToCurrentOverlaps<class TSizedInlineAllocator<3,32,class TSizedDefaultAllocator<32>>>(TArray<FOverlapInfo,TSizedInlineAllocator<3,32,TSizedDefaultAllocator<32>>>&,TArrayView<FOverlapInfo,int>&)", OutOverlapsAtEndLocation, CurrentOverlaps); }

    //bool ConvertSweptOverlapsToCurrentOverlaps<class TSizedInlineAllocator<3, 32, class TSizedDefaultAllocator<32>>>(TArray<FOverlapInfo, TSizedInlineAllocator<3, 32, TSizedDefaultAllocator<32> > >* OverlapsAtEndLocation, const TArrayView<FOverlapInfo const, int>* SweptOverlaps, int SweptOverlapsIndex, const UE::Math::TVector<double>* EndLocation, const UE::Math::TQuat<double>* EndRotationQuat) { return NativeCall<bool, TArray<FOverlapInfo, TSizedInlineAllocator<3, 32, TSizedDefaultAllocator<32> > >*, const TArrayView<FOverlapInfo const, int>*, int, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*>(this, "UPrimitiveComponent.ConvertSweptOverlapsToCurrentOverlaps<class TSizedInlineAllocator<3,32,class TSizedDefaultAllocator<32>>>(TArray<FOverlapInfo,TSizedInlineAllocator<3,32,TSizedDefaultAllocator<32>>>&,TArrayView<FOverlapInfo,int>&,int,UE::Math::TVector<double>&,UE::Math::TQuat<double>&)", OverlapsAtEndLocation, SweptOverlaps, SweptOverlapsIndex, EndLocation, EndRotationQuat); }

    void SetWalkableSlopeOverride(const FWalkableSlopeOverride* NewOverride) { NativeCall<void, const FWalkableSlopeOverride*>(this, "UPrimitiveComponent.SetWalkableSlopeOverride(FWalkableSlopeOverride&)", NewOverride); }

    void SetSimulatePhysics(bool bSimulate) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetSimulatePhysics(bool)", bSimulate); }

    void SetConstraintMode(EDOFMode::Type ConstraintMode) { NativeCall<void, EDOFMode::Type>(this, "UPrimitiveComponent.SetConstraintMode(EDOFMode::Type)", ConstraintMode); }

    void AddImpulse(UE::Math::TVector<double>* Impulse, FName BoneName, bool bVelChange) { NativeCall<void, UE::Math::TVector<double>*, FName, bool>(this, "UPrimitiveComponent.AddImpulse(UE::Math::TVector<double>,FName,bool)", Impulse, BoneName, bVelChange); }

    void AddAngularImpulseInRadians(UE::Math::TVector<double>* Impulse, FName BoneName, bool bVelChange) { NativeCall<void, UE::Math::TVector<double>*, FName, bool>(this, "UPrimitiveComponent.AddAngularImpulseInRadians(UE::Math::TVector<double>,FName,bool)", Impulse, BoneName, bVelChange); }

    void AddImpulseAtLocation(UE::Math::TVector<double>* Impulse, UE::Math::TVector<double>* Location, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, FName>(this, "UPrimitiveComponent.AddImpulseAtLocation(UE::Math::TVector<double>,UE::Math::TVector<double>,FName)", Impulse, Location, BoneName); }

    void AddVelocityChangeImpulseAtLocation(UE::Math::TVector<double>* Impulse, UE::Math::TVector<double>* Location, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, FName>(this, "UPrimitiveComponent.AddVelocityChangeImpulseAtLocation(UE::Math::TVector<double>,UE::Math::TVector<double>,FName)", Impulse, Location, BoneName); }

    void AddRadialImpulse(UE::Math::TVector<double>* Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange) { NativeCall<void, UE::Math::TVector<double>*, float, float, ERadialImpulseFalloff, bool>(this, "UPrimitiveComponent.AddRadialImpulse(UE::Math::TVector<double>,float,float,ERadialImpulseFalloff,bool)", Origin, Radius, Strength, Falloff, bVelChange); }

    void AddForce(UE::Math::TVector<double>* Force, FName BoneName, bool bAccelChange) { NativeCall<void, UE::Math::TVector<double>*, FName, bool>(this, "UPrimitiveComponent.AddForce(UE::Math::TVector<double>,FName,bool)", Force, BoneName, bAccelChange); }

    void AddForceAtLocation(UE::Math::TVector<double>* Force, UE::Math::TVector<double>* Location, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, FName>(this, "UPrimitiveComponent.AddForceAtLocation(UE::Math::TVector<double>,UE::Math::TVector<double>,FName)", Force, Location, BoneName); }

    void AddForceAtLocationLocal(UE::Math::TVector<double>* Force, UE::Math::TVector<double>* Location, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, FName>(this, "UPrimitiveComponent.AddForceAtLocationLocal(UE::Math::TVector<double>,UE::Math::TVector<double>,FName)", Force, Location, BoneName); }

    void AddRadialForce(UE::Math::TVector<double>* Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bAccelChange) { NativeCall<void, UE::Math::TVector<double>*, float, float, ERadialImpulseFalloff, bool>(this, "UPrimitiveComponent.AddRadialForce(UE::Math::TVector<double>,float,float,ERadialImpulseFalloff,bool)", Origin, Radius, Strength, Falloff, bAccelChange); }

    void AddTorqueInRadians(UE::Math::TVector<double>* Torque, FName BoneName, bool bAccelChange) { NativeCall<void, UE::Math::TVector<double>*, FName, bool>(this, "UPrimitiveComponent.AddTorqueInRadians(UE::Math::TVector<double>,FName,bool)", Torque, BoneName, bAccelChange); }

    void SetPhysicsLinearVelocity(UE::Math::TVector<double>* NewVel, __int64 bAddToCurrent, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, __int64, FName>(this, "UPrimitiveComponent.SetPhysicsLinearVelocity(UE::Math::TVector<double>,bool,FName)", NewVel, bAddToCurrent, BoneName); }

    void SetAllPhysicsLinearVelocity(UE::Math::TVector<double>* NewVel, __int64 bAddToCurrent) { NativeCall<void, UE::Math::TVector<double>*, __int64>(this, "UPrimitiveComponent.SetAllPhysicsLinearVelocity(UE::Math::TVector<double>,bool)", NewVel, bAddToCurrent); }

    void SetPhysicsAngularVelocityInRadians(UE::Math::TVector<double>* NewAngVel, __int64 bAddToCurrent, FName BoneName) { NativeCall<void, UE::Math::TVector<double>*, __int64, FName>(this, "UPrimitiveComponent.SetPhysicsAngularVelocityInRadians(UE::Math::TVector<double>,bool,FName)", NewAngVel, bAddToCurrent, BoneName); }

    void SetPhysicsMaxAngularVelocityInRadians(float NewMaxAngVel, bool bAddToCurrent, FName BoneName) { NativeCall<void, float, bool, FName>(this, "UPrimitiveComponent.SetPhysicsMaxAngularVelocityInRadians(float,bool,FName)", NewMaxAngVel, bAddToCurrent, BoneName); }

    void SetAllPhysicsAngularVelocityInRadians(const UE::Math::TVector<double>* NewAngVel, bool bAddToCurrent) { NativeCall<void, const UE::Math::TVector<double>*, bool>(this, "UPrimitiveComponent.SetAllPhysicsAngularVelocityInRadians(UE::Math::TVector<double>&,bool)", NewAngVel, bAddToCurrent); }

    void SetAllPhysicsPosition(UE::Math::TVector<double>* NewPos) { NativeCall<void, UE::Math::TVector<double>*>(this, "UPrimitiveComponent.SetAllPhysicsPosition(UE::Math::TVector<double>)", NewPos); }

    void SetAllPhysicsRotation(UE::Math::TRotator<double>* NewRot) { NativeCall<void, UE::Math::TRotator<double>*>(this, "UPrimitiveComponent.SetAllPhysicsRotation(UE::Math::TRotator<double>)", NewRot); }

    void SetAllPhysicsRotation(const UE::Math::TQuat<double>* NewRot) { NativeCall<void, const UE::Math::TQuat<double>*>(this, "UPrimitiveComponent.SetAllPhysicsRotation(UE::Math::TQuat<double>&)", NewRot); }

    void WakeRigidBody(FName BoneName) { NativeCall<void, FName>(this, "UPrimitiveComponent.WakeRigidBody(FName)", BoneName); }

    void WakeAllRigidBodies() { NativeCall<void>(this, "UPrimitiveComponent.WakeAllRigidBodies()"); }

    void SetEnableGravity(bool bGravityEnabled) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetEnableGravity(bool)", bGravityEnabled); }

    bool IsGravityEnabled() { return NativeCall<bool>(this, "UPrimitiveComponent.IsGravityEnabled()"); }

    void SetLinearDamping(float InDamping) { NativeCall<void, float>(this, "UPrimitiveComponent.SetLinearDamping(float)", InDamping); }

    float GetLinearDamping() { return NativeCall<float>(this, "UPrimitiveComponent.GetLinearDamping()"); }

    void SetAngularDamping(float InDamping) { NativeCall<void, float>(this, "UPrimitiveComponent.SetAngularDamping(float)", InDamping); }

    float GetAngularDamping() { return NativeCall<float>(this, "UPrimitiveComponent.GetAngularDamping()"); }

    void SetMassScale(FName BoneName, float InMassScale) { NativeCall<void, FName, float>(this, "UPrimitiveComponent.SetMassScale(FName,float)", BoneName, InMassScale); }

    float GetMassScale(FName BoneName) { return NativeCall<float, FName>(this, "UPrimitiveComponent.GetMassScale(FName)", BoneName); }

    void SetMassOverrideInKg(FName BoneName, float MassInKg, bool bOverrideMass) { NativeCall<void, FName, float, bool>(this, "UPrimitiveComponent.SetMassOverrideInKg(FName,float,bool)", BoneName, MassInKg, bOverrideMass); }

    float GetMass() { return NativeCall<float>(this, "UPrimitiveComponent.GetMass()"); }

    float CalculateMass(FName __formal) { return NativeCall<float, FName>(this, "UPrimitiveComponent.CalculateMass(FName)", __formal); }

    void SetUseCCD(bool bInUseCCD, FName BoneName) { NativeCall<void, bool, FName>(this, "UPrimitiveComponent.SetUseCCD(bool,FName)", bInUseCCD, BoneName); }

    void SetAllUseCCD(bool bInUseCCD) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetAllUseCCD(bool)", bInUseCCD); }

    void PutRigidBodyToSleep(FName BoneName) { NativeCall<void, FName>(this, "UPrimitiveComponent.PutRigidBodyToSleep(FName)", BoneName); }

    void PutAllRigidBodiesToSleep() { NativeCall<void>(this, "UPrimitiveComponent.PutAllRigidBodiesToSleep()"); }

    bool RigidBodyIsAwake(FName BoneName) { return NativeCall<bool, FName>(this, "UPrimitiveComponent.RigidBodyIsAwake(FName)", BoneName); }

    bool IsAnyRigidBodyAwake() { return NativeCall<bool>(this, "UPrimitiveComponent.IsAnyRigidBodyAwake()"); }

    void SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetNotifyRigidBodyCollision(bool)", bNewNotifyRigidBodyCollision); }

    void SetPhysMaterialOverride(UPhysicalMaterial* NewPhysMaterial) { NativeCall<void, UPhysicalMaterial*>(this, "UPrimitiveComponent.SetPhysMaterialOverride(UPhysicalMaterial*)", NewPhysMaterial); }

    void SyncComponentToRBPhysics() { NativeCall<void>(this, "UPrimitiveComponent.SyncComponentToRBPhysics()"); }

    void GetWeldedBodies(TArray<FBodyInstance*, TSizedDefaultAllocator<32> >* OutWeldedBodies, TArray<FName, TSizedDefaultAllocator<32> >* OutLabels, bool bIncludingAutoWeld) { NativeCall<void, TArray<FBodyInstance*, TSizedDefaultAllocator<32> >*, TArray<FName, TSizedDefaultAllocator<32> >*, bool>(this, "UPrimitiveComponent.GetWeldedBodies(TArray<FBodyInstance*,TSizedDefaultAllocator<32>>&,TArray<FName,TSizedDefaultAllocator<32>>&,bool)", OutWeldedBodies, OutLabels, bIncludingAutoWeld); }

    bool WeldToImplementation(USceneComponent* InParent, FName ParentSocketName, bool bWeldSimulatedChild) { return NativeCall<bool, USceneComponent*, FName, bool>(this, "UPrimitiveComponent.WeldToImplementation(USceneComponent*,FName,bool)", InParent, ParentSocketName, bWeldSimulatedChild); }

    void WeldTo(USceneComponent* InParent, FName InSocketName) { NativeCall<void, USceneComponent*, FName>(this, "UPrimitiveComponent.WeldTo(USceneComponent*,FName)", InParent, InSocketName); }

    void UnWeldFromParent() { NativeCall<void>(this, "UPrimitiveComponent.UnWeldFromParent()"); }

    void UnWeldChildren() { NativeCall<void>(this, "UPrimitiveComponent.UnWeldChildren()"); }

    FBodyInstance* GetBodyInstance(FName BoneName, bool bGetWelded, int Index) { return NativeCall<FBodyInstance*, FName, bool, int>(this, "UPrimitiveComponent.GetBodyInstance(FName,bool,int)", BoneName, bGetWelded, Index); }

    bool GetSquaredDistanceToCollision(const UE::Math::TVector<double>* Point, float* OutSquaredDistance, UE::Math::TVector<double>* OutClosestPointOnCollision) { return NativeCall<bool, const UE::Math::TVector<double>*, float*, UE::Math::TVector<double>*>(this, "UPrimitiveComponent.GetSquaredDistanceToCollision(UE::Math::TVector<double>&,float&,UE::Math::TVector<double>&)", Point, OutSquaredDistance, OutClosestPointOnCollision); }

    float GetClosestPointOnCollision(const UE::Math::TVector<double>* Point, UE::Math::TVector<double>* OutPointOnBody, FName BoneName) { return NativeCall<float, const UE::Math::TVector<double>*, UE::Math::TVector<double>*, FName>(this, "UPrimitiveComponent.GetClosestPointOnCollision(UE::Math::TVector<double>&,UE::Math::TVector<double>&,FName)", Point, OutPointOnBody, BoneName); }

    bool IsSimulatingPhysics(FName BoneName) { return NativeCall<bool, FName>(this, "UPrimitiveComponent.IsSimulatingPhysics(FName)", BoneName); }

    void SetCollisionObjectType(ECollisionChannel Channel) { NativeCall<void, ECollisionChannel>(this, "UPrimitiveComponent.SetCollisionObjectType(ECollisionChannel)", Channel); }

    void SetCollisionResponseToChannel(ECollisionChannel Channel, ECollisionResponse NewResponse) { NativeCall<void, ECollisionChannel, ECollisionResponse>(this, "UPrimitiveComponent.SetCollisionResponseToChannel(ECollisionChannel,ECollisionResponse)", Channel, NewResponse); }

    void SetCollisionResponseToAllChannels(ECollisionResponse NewResponse) { NativeCall<void, ECollisionResponse>(this, "UPrimitiveComponent.SetCollisionResponseToAllChannels(ECollisionResponse)", NewResponse); }

    //void SetCollisionResponseToChannels(const FCollisionResponseContainer* NewReponses) { NativeCall<void, const FCollisionResponseContainer*>(this, "UPrimitiveComponent.SetCollisionResponseToChannels(FCollisionResponseContainer&)", NewReponses); }

    void SetCollisionEnabled(ECollisionEnabled::Type NewType) { NativeCall<void, ECollisionEnabled::Type>(this, "UPrimitiveComponent.SetCollisionEnabled(ECollisionEnabled::Type)", NewType); }

    void SetCollisionProfileName(FName InCollisionProfileName, bool bUpdateOverlaps) { NativeCall<void, FName, bool>(this, "UPrimitiveComponent.SetCollisionProfileName(FName,bool)", InCollisionProfileName, bUpdateOverlaps); }

    void OnActorEnableCollisionChanged() { NativeCall<void>(this, "UPrimitiveComponent.OnActorEnableCollisionChanged()"); }

    void OnComponentCollisionSettingsChanged(bool bUpdateOverlaps) { NativeCall<void, bool>(this, "UPrimitiveComponent.OnComponentCollisionSettingsChanged(bool)", bUpdateOverlaps); }

    __int64 K2_LineTraceComponent(UE::Math::TVector<double>* TraceStart, UE::Math::TVector<double>* TraceEnd, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, UE::Math::TVector<double>* HitLocation, UE::Math::TVector<double>* HitNormal, FName* BoneName, FHitResult* OutHit) { return NativeCall<__int64, UE::Math::TVector<double>*, UE::Math::TVector<double>*, bool, bool, bool, UE::Math::TVector<double>*, UE::Math::TVector<double>*, FName*, FHitResult*>(this, "UPrimitiveComponent.K2_LineTraceComponent(UE::Math::TVector<double>,UE::Math::TVector<double>,bool,bool,bool,UE::Math::TVector<double>&,UE::Math::TVector<double>&,FName&,FHitResult&)", TraceStart, TraceEnd, bTraceComplex, bShowTrace, bPersistentShowTrace, HitLocation, HitNormal, BoneName, OutHit); }

    ECollisionResponse GetCollisionResponseToChannel(ECollisionChannel Channel) { return NativeCall<ECollisionResponse, ECollisionChannel>(this, "UPrimitiveComponent.GetCollisionResponseToChannel(ECollisionChannel)", Channel); }

    //const FCollisionResponseContainer* GetCollisionResponseToChannels() { return NativeCall<const FCollisionResponseContainer*>(this, "UPrimitiveComponent.GetCollisionResponseToChannels()"); }

    void UpdatePhysicsToRBChannels() { NativeCall<void>(this, "UPrimitiveComponent.UpdatePhysicsToRBChannels()"); }

    void SetInternalOctreeMask(int InOctreeMask, bool bReregisterWithTree) { NativeCall<void, int, bool>(this, "UPrimitiveComponent.SetInternalOctreeMask(int,bool)", InOctreeMask, bReregisterWithTree); }

};


struct UMeshComponent : UPrimitiveComponent

{

    // Fields


    TArray<TObjectPtr<UMaterialInterface>, TSizedDefaultAllocator<32> >& OverrideMaterialsField() { return *GetNativePointerField<TArray<TObjectPtr<UMaterialInterface>, TSizedDefaultAllocator<32> >*>(this, "UMeshComponent.OverrideMaterials"); }

    TObjectPtr<UMaterialInterface>& OverlayMaterialField() { return *GetNativePointerField<TObjectPtr<UMaterialInterface>*>(this, "UMeshComponent.OverlayMaterial"); }

    float& OverlayMaterialMaxDrawDistanceField() { return *GetNativePointerField<float*>(this, "UMeshComponent.OverlayMaterialMaxDrawDistance"); }

    //TSortedMap<FName, UMeshComponent::FMaterialParameterCache, TSizedDefaultAllocator<32>, FNameFastLess>& MaterialParameterCacheField() { return *GetNativePointerField<TSortedMap<FName, UMeshComponent::FMaterialParameterCache, TSizedDefaultAllocator<32>, FNameFastLess>*>(this, "UMeshComponent.MaterialParameterCache"); }

    TSubclassOf<AActor>& DamageFXActorToSpawnField() { return *GetNativePointerField<TSubclassOf<AActor>*>(this, "UMeshComponent.DamageFXActorToSpawn"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bEnableMaterialParameterCaching() { return { this, "UMeshComponent.bEnableMaterialParameterCaching" }; }

    BitFieldValue<bool, unsigned __int32> bCachedMaterialParameterIndicesAreDirty() { return { this, "UMeshComponent.bCachedMaterialParameterIndicesAreDirty" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UMeshComponent.StaticClass()"); }

    void MulticastHideInstance(int originalIndex, UE::Math::TVector<double>* HitDirection, float Damage, float TotalHealth, bool bCheckHideAttachedDecals) { NativeCall<void, int, UE::Math::TVector<double>*, float, float, bool>(this, "UMeshComponent.MulticastHideInstance(int,UE::Math::TVector<double>,float,float,bool)", originalIndex, HitDirection, Damage, TotalHealth, bCheckHideAttachedDecals); }

    void MulticastShowInstance(int originalIndex) { NativeCall<void, int>(this, "UMeshComponent.MulticastShowInstance(int)", originalIndex); }

    static void StaticRegisterNativesUMeshComponent() { NativeCall<void>(nullptr, "UMeshComponent.StaticRegisterNativesUMeshComponent()"); }

    UMaterialInterface* GetMaterial(int ElementIndex) { return NativeCall<UMaterialInterface*, int>(this, "UMeshComponent.GetMaterial(int)", ElementIndex); }

    void SetMaterial(int ElementIndex, UMaterialInterface* Material) { NativeCall<void, int, UMaterialInterface*>(this, "UMeshComponent.SetMaterial(int,UMaterialInterface*)", ElementIndex, Material); }

    void SetMaterialByName(FName MaterialSlotName, UMaterialInterface* Material) { NativeCall<void, FName, UMaterialInterface*>(this, "UMeshComponent.SetMaterialByName(FName,UMaterialInterface*)", MaterialSlotName, Material); }

    //FMaterialRelevance* GetMaterialRelevance(FMaterialRelevance* result, ERHIFeatureLevel::Type InFeatureLevel) { return NativeCall<FMaterialRelevance*, FMaterialRelevance*, ERHIFeatureLevel::Type>(this, "UMeshComponent.GetMaterialRelevance(ERHIFeatureLevel::Type)", result, InFeatureLevel); }

    int GetNumOverrideMaterials() { return NativeCall<int>(this, "UMeshComponent.GetNumOverrideMaterials()"); }

    void EmptyOverrideMaterials() { NativeCall<void>(this, "UMeshComponent.EmptyOverrideMaterials()"); }

    void GetUsedMaterials(TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >* OutMaterials, __int64 bGetDebugMaterials) { NativeCall<void, TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*, __int64>(this, "UMeshComponent.GetUsedMaterials(TArray<UMaterialInterface*,TSizedDefaultAllocator<32>>&,bool)", OutMaterials, bGetDebugMaterials); }

    void PrestreamTextures(float Seconds, bool bPrioritizeCharacterTextures, int CinematicTextureGroups) { NativeCall<void, float, bool, int>(this, "UMeshComponent.PrestreamTextures(float,bool,int)", Seconds, bPrioritizeCharacterTextures, CinematicTextureGroups); }

    void RegisterLODStreamingCallback(TFunction<void __cdecl(UPrimitiveComponent*, UStreamableRenderAsset*, ELODStreamingCallbackResult)>* Callback, __int64 LODIdx, float TimeoutSecs) { NativeCall<void, TFunction<void __cdecl(UPrimitiveComponent*, UStreamableRenderAsset*, ELODStreamingCallbackResult)>*, __int64, float>(this, "UMeshComponent.RegisterLODStreamingCallback(TFunction<void__cdecl(UPrimitiveComponent*,UStreamableRenderAsset*,ELODStreamingCallbackResult)", Callback, LODIdx, TimeoutSecs); }

    void SetTextureForceResidentFlag(bool bForceMiplevelsToBeResident) { NativeCall<void, bool>(this, "UMeshComponent.SetTextureForceResidentFlag(bool)", bForceMiplevelsToBeResident); }

    TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >* GetMaterials(TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*, TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*>(this, "UMeshComponent.GetMaterials()", result); }

    void SetScalarParameterValueOnMaterials(const FName ParameterName, const float ParameterValue) { NativeCall<void, const FName, const float>(this, "UMeshComponent.SetScalarParameterValueOnMaterials(FName,float)", ParameterName, ParameterValue); }

    void SetVectorParameterValueOnMaterials(const FName ParameterName, const UE::Math::TVector<double>* ParameterValue) { NativeCall<void, const FName, const UE::Math::TVector<double>*>(this, "UMeshComponent.SetVectorParameterValueOnMaterials(FName,UE::Math::TVector<double>)", ParameterName, ParameterValue); }

    void CacheMaterialParameterNameIndices(int a2) { NativeCall<void, int>(this, "UMeshComponent.CacheMaterialParameterNameIndices()", a2); }

    //void GetStreamingTextureInfoInner(FStreamingTextureLevelContext* LevelContext, const TArray<FStreamingTextureBuildInfo, TSizedDefaultAllocator<32> >* PreBuiltData, float ComponentScaling, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >* OutStreamingTextures) { NativeCall<void, FStreamingTextureLevelContext*, const TArray<FStreamingTextureBuildInfo, TSizedDefaultAllocator<32> >*, float, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >*>(this, "UMeshComponent.GetStreamingTextureInfoInner(FStreamingTextureLevelContext&,TArray<FStreamingTextureBuildInfo,TSizedDefaultAllocator<32>>*,float,TArray<FStreamingRenderAssetPrimitiveInfo,TSizedDefaultAllocator<32>>&)", LevelContext, PreBuiltData, ComponentScaling, OutStreamingTextures); }

    //void FMaterialParameterCache > , class TSizedDefaultAllocator<32 >> () { NativeCall<void>(this, "UMeshComponent.FMaterialParameterCache>,class TSizedDefaultAllocator<32>>()"); }

    void Reset(int NewSize) { NativeCall<void, int>(this, "UMeshComponent.Reset(int)", NewSize); }

    //UMeshComponent::FMaterialParameterCache* Emplace<class FName const&>(const FName* InKey) { return NativeCall<UMeshComponent::FMaterialParameterCache*, const FName*>(this, "UMeshComponent.Emplace<class FName const &>(FName*)", InKey); }

};


struct UStaticMeshComponent : UMeshComponent

{

    // Fields


    int& ForcedLodModelField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.ForcedLodModel"); }

    int& PreviousLODLevel_DEPRECATEDField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.PreviousLODLevel_DEPRECATED"); }

    int& MinLODField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.MinLOD"); }

    int& SubDivisionStepSizeField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.SubDivisionStepSize"); }

    TObjectPtr<UStaticMesh>& StaticMeshField() { return *GetNativePointerField<TObjectPtr<UStaticMesh>*>(this, "UStaticMeshComponent.StaticMesh"); }

    FColor& WireframeColorOverrideField() { return *GetNativePointerField<FColor*>(this, "UStaticMeshComponent.WireframeColorOverride"); }

    int& WorldPositionOffsetDisableDistanceField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.WorldPositionOffsetDisableDistance"); }

    int& CustomDataOutDisableDistanceField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.CustomDataOutDisableDistance"); }

    int& OverriddenLightMapResField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.OverriddenLightMapRes"); }

    float& DistanceFieldIndirectShadowMinVisibilityField() { return *GetNativePointerField<float*>(this, "UStaticMeshComponent.DistanceFieldIndirectShadowMinVisibility"); }

    float& DistanceFieldSelfShadowBiasField() { return *GetNativePointerField<float*>(this, "UStaticMeshComponent.DistanceFieldSelfShadowBias"); }

    float& StreamingDistanceMultiplierField() { return *GetNativePointerField<float*>(this, "UStaticMeshComponent.StreamingDistanceMultiplier"); }

    //TArray<FStaticMeshComponentLODInfo, TSizedDefaultAllocator<32> >& LODDataField() { return *GetNativePointerField<TArray<FStaticMeshComponentLODInfo, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.LODData"); }

    //TArray<FStreamingTextureBuildInfo, TSizedDefaultAllocator<32> >& StreamingTextureDataField() { return *GetNativePointerField<TArray<FStreamingTextureBuildInfo, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.StreamingTextureData"); }

    //FLightmassPrimitiveSettings& LightmassSettingsField() { return *GetNativePointerField<FLightmassPrimitiveSettings*>(this, "UStaticMeshComponent.LightmassSettings"); }

    //TDelegate<Nanite::FResources const* __cdecl(void), FDefaultDelegateUserPolicy>& OnGetNaniteResourcesEventField() { return *GetNativePointerField<TDelegate<Nanite::FResources const* __cdecl(void), FDefaultDelegateUserPolicy>*>(this, "UStaticMeshComponent.OnGetNaniteResourcesEvent"); }

    float& DirectionalShadowDistanceLimitField() { return *GetNativePointerField<float*>(this, "UStaticMeshComponent.DirectionalShadowDistanceLimit"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bDisallowNanite() { return { this, "UStaticMeshComponent.bDisallowNanite" }; }

    BitFieldValue<bool, unsigned __int32> bForceDisableNanite() { return { this, "UStaticMeshComponent.bForceDisableNanite" }; }

    BitFieldValue<bool, unsigned __int32> bEvaluateWorldPositionOffset() { return { this, "UStaticMeshComponent.bEvaluateWorldPositionOffset" }; }

    BitFieldValue<bool, unsigned __int32> bEvaluateWorldPositionOffsetInRayTracing() { return { this, "UStaticMeshComponent.bEvaluateWorldPositionOffsetInRayTracing" }; }

    BitFieldValue<bool, unsigned __int32> bInitialEvaluateWorldPositionOffset() { return { this, "UStaticMeshComponent.bInitialEvaluateWorldPositionOffset" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideWireframeColor() { return { this, "UStaticMeshComponent.bOverrideWireframeColor" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideMinLOD() { return { this, "UStaticMeshComponent.bOverrideMinLOD" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideNavigationExport() { return { this, "UStaticMeshComponent.bOverrideNavigationExport" }; }

    BitFieldValue<bool, unsigned __int32> bForceNavigationObstacle() { return { this, "UStaticMeshComponent.bForceNavigationObstacle" }; }

    BitFieldValue<bool, unsigned __int32> bDisallowMeshPaintPerInstance() { return { this, "UStaticMeshComponent.bDisallowMeshPaintPerInstance" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreInstanceForTextureStreaming() { return { this, "UStaticMeshComponent.bIgnoreInstanceForTextureStreaming" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideLightMapRes() { return { this, "UStaticMeshComponent.bOverrideLightMapRes" }; }

    BitFieldValue<bool, unsigned __int32> bCastDistanceFieldIndirectShadow() { return { this, "UStaticMeshComponent.bCastDistanceFieldIndirectShadow" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideDistanceFieldSelfShadowBias() { return { this, "UStaticMeshComponent.bOverrideDistanceFieldSelfShadowBias" }; }

    BitFieldValue<bool, unsigned __int32> bUseSubDivisions() { return { this, "UStaticMeshComponent.bUseSubDivisions" }; }

    BitFieldValue<bool, unsigned __int32> bUseDefaultCollision() { return { this, "UStaticMeshComponent.bUseDefaultCollision" }; }

    BitFieldValue<bool, unsigned __int32> bSortTriangles() { return { this, "UStaticMeshComponent.bSortTriangles" }; }

    BitFieldValue<bool, unsigned __int32> bReverseCulling() { return { this, "UStaticMeshComponent.bReverseCulling" }; }

    BitFieldValue<bool, unsigned __int32> bUseDirectionalShadowDistanceLimit() { return { this, "UStaticMeshComponent.bUseDirectionalShadowDistanceLimit" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UStaticMeshComponent.StaticClass()"); }

    bool GetShadowIndirectOnly() { return NativeCall<bool>(this, "UStaticMeshComponent.GetShadowIndirectOnly()"); }

    void PropagateLightingScenarioChange() { NativeCall<void>(this, "UStaticMeshComponent.PropagateLightingScenarioChange()"); }

    bool BuildTextureStreamingDataImpl(ETextureStreamingBuildType BuildType, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, TSet<FGuid, DefaultKeyFuncs<FGuid, 0>, FDefaultSetAllocator>* DependentResources, bool* bOutSupportsBuildTextureStreamingData) { return NativeCall<bool, ETextureStreamingBuildType, EMaterialQualityLevel::Type, ERHIFeatureLevel::Type, TSet<FGuid, DefaultKeyFuncs<FGuid, 0>, FDefaultSetAllocator>*, bool*>(this, "UStaticMeshComponent.BuildTextureStreamingDataImpl(ETextureStreamingBuildType,EMaterialQualityLevel::Type,ERHIFeatureLevel::Type,TSet<FGuid,DefaultKeyFuncs<FGuid,0>,FDefaultSetAllocator>&,bool&)", BuildType, QualityLevel, FeatureLevel, DependentResources, bOutSupportsBuildTextureStreamingData); }

    static void StaticRegisterNativesUStaticMeshComponent() { NativeCall<void>(nullptr, "UStaticMeshComponent.StaticRegisterNativesUStaticMeshComponent()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void Serialize(FStructuredArchiveRecord Record) { NativeCall<void, FStructuredArchiveRecord>(this, "UStaticMeshComponent.Serialize(FStructuredArchiveRecord)", Record); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    bool HasAnySockets() { return NativeCall<bool>(this, "UStaticMeshComponent.HasAnySockets()"); }

    //void QuerySupportedSockets(TArray<FComponentSocketDescription, TSizedDefaultAllocator<32> >* OutSockets) { NativeCall<void, TArray<FComponentSocketDescription, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.QuerySupportedSockets(TArray<FComponentSocketDescription,TSizedDefaultAllocator<32>>&)", OutSockets); }

    FString* GetDetailedInfoInternal(FString* result) { return NativeCall<FString*, FString*>(this, "UStaticMeshComponent.GetDetailedInfoInternal()", result); }

    static void AddReferencedObjects(UObject* InThis, FReferenceCollector* Collector) { NativeCall<void, UObject*, FReferenceCollector*>(nullptr, "UStaticMeshComponent.AddReferencedObjects(UObject*,FReferenceCollector&)", InThis, Collector); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UStaticMeshComponent.Serialize(FArchive&)", Ar); }

    void PostInitProperties() { NativeCall<void>(this, "UStaticMeshComponent.PostInitProperties()"); }

    bool AreNativePropertiesIdenticalTo(UObject* Other) { return NativeCall<bool, UObject*>(this, "UStaticMeshComponent.AreNativePropertiesIdenticalTo(UObject*)", Other); }

    //const FMeshMapBuildData* GetMeshMapBuildData(const FStaticMeshComponentLODInfo* LODInfo, bool bCheckForResourceCluster) { return NativeCall<const FMeshMapBuildData*, const FStaticMeshComponentLODInfo*, bool>(this, "UStaticMeshComponent.GetMeshMapBuildData(FStaticMeshComponentLODInfo&,bool)", LODInfo, bCheckForResourceCluster); }

    void BeginPlay() { NativeCall<void>(this, "UStaticMeshComponent.BeginPlay()"); }

    void OnCreatePhysicsState() { NativeCall<void>(this, "UStaticMeshComponent.OnCreatePhysicsState()"); }

    void OnDestroyPhysicsState() { NativeCall<void>(this, "UStaticMeshComponent.OnDestroyPhysicsState()"); }

    //bool GetMaterialStreamingData(int MaterialIndex, FPrimitiveMaterialInfo* MaterialData) { return NativeCall<bool, int, FPrimitiveMaterialInfo*>(this, "UStaticMeshComponent.GetMaterialStreamingData(int,FPrimitiveMaterialInfo&)", MaterialIndex, MaterialData); }

    //void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext* LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >* OutStreamingRenderAssets) { NativeCall<void, FStreamingTextureLevelContext*, TArray<FStreamingRenderAssetPrimitiveInfo, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.GetStreamingRenderAssetInfo(FStreamingTextureLevelContext&,TArray<FStreamingRenderAssetPrimitiveInfo,TSizedDefaultAllocator<32>>&)", LevelContext, OutStreamingRenderAssets); }

    //UBodySetup* GetBodySetup() { return NativeCall<UBodySetup*>(this, "UStaticMeshComponent.GetBodySetup()"); }

    bool CanEditSimulatePhysics() { return NativeCall<bool>(this, "UStaticMeshComponent.CanEditSimulatePhysics()"); }

    bool DoesSocketExist(FName InSocketName) { return NativeCall<bool, FName>(this, "UStaticMeshComponent.DoesSocketExist(FName)", InSocketName); }

    const UStaticMeshSocket* GetSocketByName(FName InSocketName) { return NativeCall<const UStaticMeshSocket*, FName>(this, "UStaticMeshComponent.GetSocketByName(FName)", InSocketName); }

    void RemoveInstanceVertexColorsFromLOD(int LODToRemoveColorsFrom) { NativeCall<void, int>(this, "UStaticMeshComponent.RemoveInstanceVertexColorsFromLOD(int)", LODToRemoveColorsFrom); }

   // void CollectPSOPrecacheData(const FPSOPrecacheParams* BasePrecachePSOParams, TArray<UPrimitiveComponent::FComponentPSOPrecacheParams, TSizedInlineAllocator<2, 32, TSizedDefaultAllocator<32> > >* OutParams) { NativeCall<void, const FPSOPrecacheParams*, TArray<UPrimitiveComponent::FComponentPSOPrecacheParams, TSizedInlineAllocator<2, 32, TSizedDefaultAllocator<32> > >*>(this, "UStaticMeshComponent.CollectPSOPrecacheData(FPSOPrecacheParams&,TArray<UPrimitiveComponent::FComponentPSOPrecacheParams,TSizedInlineAllocator<2,32,TSizedDefaultAllocator<32>>>&)", BasePrecachePSOParams, OutParams); }

    bool ShouldCreateNaniteProxy() { return NativeCall<bool>(this, "UStaticMeshComponent.ShouldCreateNaniteProxy()"); }

    void BeginDestroy() { NativeCall<void>(this, "UStaticMeshComponent.BeginDestroy()"); }

    void ExportCustomProperties(FOutputDevice* Out, unsigned int Indent) { NativeCall<void, FOutputDevice*, unsigned int>(this, "UStaticMeshComponent.ExportCustomProperties(FOutputDevice&,unsignedint)", Out, Indent); }

    void ImportCustomProperties(const wchar_t* SourceText, FFeedbackContext* Warn) { NativeCall<void, const wchar_t*, FFeedbackContext*>(this, "UStaticMeshComponent.ImportCustomProperties(wchar_t*,FFeedbackContext*)", SourceText, Warn); }

    bool SupportsDefaultCollision() { return NativeCall<bool>(this, "UStaticMeshComponent.SupportsDefaultCollision()"); }

    bool SupportsDitheredLODTransitions(ERHIFeatureLevel::Type FeatureLevel) { return NativeCall<bool, ERHIFeatureLevel::Type>(this, "UStaticMeshComponent.SupportsDitheredLODTransitions(ERHIFeatureLevel::Type)", FeatureLevel); }

    void UpdateCollisionFromStaticMesh() { NativeCall<void>(this, "UStaticMeshComponent.UpdateCollisionFromStaticMesh()"); }

    void PostLoad() { NativeCall<void>(this, "UStaticMeshComponent.PostLoad()"); }

    bool ShouldCreateRenderState() { return NativeCall<bool>(this, "UStaticMeshComponent.ShouldCreateRenderState()"); }

    bool ShouldCreatePhysicsState() { return NativeCall<bool>(this, "UStaticMeshComponent.ShouldCreatePhysicsState()"); }

    bool SetStaticMesh(UStaticMesh* NewMesh) { return NativeCall<bool, UStaticMesh*>(this, "UStaticMeshComponent.SetStaticMesh(UStaticMesh*)", NewMesh); }

    bool HasValidNaniteData() { return NativeCall<bool>(this, "UStaticMeshComponent.HasValidNaniteData()"); }

    bool UseNaniteOverrideMaterials() { return NativeCall<bool>(this, "UStaticMeshComponent.UseNaniteOverrideMaterials()"); }

    float GetWorldPositionOffsetDisableDistance() { return NativeCall<float>(this, "UStaticMeshComponent.GetWorldPositionOffsetDisableDistance()"); }

    float GetCustomDataOutDisableDistance() { return NativeCall<float>(this, "UStaticMeshComponent.GetCustomDataOutDisableDistance()"); }

    void GetLocalBounds(UE::Math::TVector<double>* Min, UE::Math::TVector<double>* Max) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "UStaticMeshComponent.GetLocalBounds(UE::Math::TVector<double>&,UE::Math::TVector<double>&)", Min, Max); }

    void SetCollisionProfileName(FName InCollisionProfileName, bool bUpdateOverlaps) { NativeCall<void, FName, bool>(this, "UStaticMeshComponent.SetCollisionProfileName(FName,bool)", InCollisionProfileName, bUpdateOverlaps); }

    bool UsesOnlyUnlitMaterials() { return NativeCall<bool>(this, "UStaticMeshComponent.UsesOnlyUnlitMaterials()"); }

    bool GetLightMapResolution(int* Width, int* Height) { return NativeCall<bool, int*, int*>(this, "UStaticMeshComponent.GetLightMapResolution(int&,int&)", Width, Height); }

    void GetEstimatedLightMapResolution(int* Width, int* Height) { NativeCall<void, int*, int*>(this, "UStaticMeshComponent.GetEstimatedLightMapResolution(int&,int&)", Width, Height); }

    bool HasValidSettingsForStaticLighting(bool bOverlookInvalidComponents) { return NativeCall<bool, bool>(this, "UStaticMeshComponent.HasValidSettingsForStaticLighting(bool)", bOverlookInvalidComponents); }

    bool UsesTextureLightmaps(int InWidth, int InHeight) { return NativeCall<bool, int, int>(this, "UStaticMeshComponent.UsesTextureLightmaps(int,int)", InWidth, InHeight); }

    bool HasLightmapTextureCoordinates() { return NativeCall<bool>(this, "UStaticMeshComponent.HasLightmapTextureCoordinates()"); }

    void GetTextureLightAndShadowMapMemoryUsage(int InWidth, int InHeight, int* OutLightMapMemoryUsage, int* OutShadowMapMemoryUsage) { NativeCall<void, int, int, int*, int*>(this, "UStaticMeshComponent.GetTextureLightAndShadowMapMemoryUsage(int,int,int&,int&)", InWidth, InHeight, OutLightMapMemoryUsage, OutShadowMapMemoryUsage); }

    void GetLightAndShadowMapMemoryUsage(int* LightMapMemoryUsage, int* ShadowMapMemoryUsage) { NativeCall<void, int*, int*>(this, "UStaticMeshComponent.GetLightAndShadowMapMemoryUsage(int&,int&)", LightMapMemoryUsage, ShadowMapMemoryUsage); }

    bool GetEstimatedLightAndShadowMapMemoryUsage(int* TextureLightMapMemoryUsage, int* TextureShadowMapMemoryUsage, int* VertexLightMapMemoryUsage, int* VertexShadowMapMemoryUsage, int* StaticLightingResolution, bool* bIsUsingTextureMapping, bool* bHasLightmapTexCoords) { return NativeCall<bool, int*, int*, int*, int*, int*, bool*, bool*>(this, "UStaticMeshComponent.GetEstimatedLightAndShadowMapMemoryUsage(int&,int&,int&,int&,int&,bool&,bool&)", TextureLightMapMemoryUsage, TextureShadowMapMemoryUsage, VertexLightMapMemoryUsage, VertexShadowMapMemoryUsage, StaticLightingResolution, bIsUsingTextureMapping, bHasLightmapTexCoords); }

    int GetNumMaterials() { return NativeCall<int>(this, "UStaticMeshComponent.GetNumMaterials()"); }

    int GetMaterialIndex(FName MaterialSlotName) { return NativeCall<int, FName>(this, "UStaticMeshComponent.GetMaterialIndex(FName)", MaterialSlotName); }

    TArray<FName, TSizedDefaultAllocator<32> >* GetMaterialSlotNames(TArray<FName, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<FName, TSizedDefaultAllocator<32> >*, TArray<FName, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.GetMaterialSlotNames()", result); }

    UMaterialInterface* GetMaterial(int MaterialIndex) { return NativeCall<UMaterialInterface*, int>(this, "UStaticMeshComponent.GetMaterial(int)", MaterialIndex); }

    UMaterialInterface* GetEditorMaterial(int MaterialIndex) { return NativeCall<UMaterialInterface*, int>(this, "UStaticMeshComponent.GetEditorMaterial(int)", MaterialIndex); }

    void GetUsedMaterials(TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >* OutMaterials, bool bGetDebugMaterials) { NativeCall<void, TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*, bool>(this, "UStaticMeshComponent.GetUsedMaterials(TArray<UMaterialInterface*,TSizedDefaultAllocator<32>>&,bool)", OutMaterials, bGetDebugMaterials); }

    //TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* GetComponentInstanceData(TStructOnScope<FActorComponentInstanceData, UScriptStruct*>* result) { return NativeCall<TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*, TStructOnScope<FActorComponentInstanceData, UScriptStruct*>*>(this, "UStaticMeshComponent.GetComponentInstanceData()", result); }

    //void ApplyComponentInstanceData(FStaticMeshComponentInstanceData* StaticMeshInstanceData) { NativeCall<void, FStaticMeshComponentInstanceData*>(this, "UStaticMeshComponent.ApplyComponentInstanceData(FStaticMeshComponentInstanceData*)", StaticMeshInstanceData); }

    bool IsHLODRelevant() { return NativeCall<bool>(this, "UStaticMeshComponent.IsHLODRelevant()"); }

    //bool DoCustomNavigableGeometryExport(FNavigableGeometryExport* GeomExport) { return NativeCall<bool, FNavigableGeometryExport*>(this, "UStaticMeshComponent.DoCustomNavigableGeometryExport(FNavigableGeometryExport&)", GeomExport); }

    UMaterialInterface* GetMaterialFromCollisionFaceIndex(int FaceIndex, int* SectionIndex) { return NativeCall<UMaterialInterface*, int, int*>(this, "UStaticMeshComponent.GetMaterialFromCollisionFaceIndex(int,int&)", FaceIndex, SectionIndex); }

    bool IsNavigationRelevant() { return NativeCall<bool>(this, "UStaticMeshComponent.IsNavigationRelevant()"); }

    //void GetNavigationData(FNavigationRelevantData* Data) { NativeCall<void, FNavigationRelevantData*>(this, "UStaticMeshComponent.GetNavigationData(FNavigationRelevantData&)", Data); }

    //bool IsShown(const FEngineShowFlags* ShowFlags) { return NativeCall<bool, const FEngineShowFlags*>(this, "UStaticMeshComponent.IsShown(FEngineShowFlags&)", ShowFlags); }

    bool CopyPerInstanceDynamicCustomData(const UStaticMeshComponent* SrcComponent, int SrcInstanceIndex, int DstInstanceIndex, int NumInstances) { return NativeCall<bool, const UStaticMeshComponent*, int, int, int>(this, "UStaticMeshComponent.CopyPerInstanceDynamicCustomData(UStaticMeshComponent*,int,int,int)", SrcComponent, SrcInstanceIndex, DstInstanceIndex, NumInstances); }

    ELightMapInteractionType GetStaticLightingType() { return NativeCall<ELightMapInteractionType>(this, "UStaticMeshComponent.GetStaticLightingType()"); }

    bool IsPrecomputedLightingValid() { return NativeCall<bool>(this, "UStaticMeshComponent.IsPrecomputedLightingValid()"); }

    float GetEmissiveBoost(int ElementIndex) { return NativeCall<float, int>(this, "UStaticMeshComponent.GetEmissiveBoost(int)", ElementIndex); }

    float GetDiffuseBoost(int ElementIndex) { return NativeCall<float, int>(this, "UStaticMeshComponent.GetDiffuseBoost(int)", ElementIndex); }

    //FStaticMeshStaticLightingMesh* AllocateStaticLightingMesh(int LODIndex, const TArray<ULightComponent*, TSizedDefaultAllocator<32> >* InRelevantLights) { return NativeCall<FStaticMeshStaticLightingMesh*, int, const TArray<ULightComponent*, TSizedDefaultAllocator<32> >*>(this, "UStaticMeshComponent.AllocateStaticLightingMesh(int,TArray<ULightComponent*,TSizedDefaultAllocator<32>>&)", LODIndex, InRelevantLights); }

    void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) { NativeCall<void, bool, bool>(this, "UStaticMeshComponent.InvalidateLightingCacheDetailed(bool,bool)", bInvalidateBuildEnqueuedLighting, bTranslationOnly); }

    const UObject* AdditionalStatObject() { return NativeCall<const UObject*>(this, "UStaticMeshComponent.AdditionalStatObject()"); }

    bool SetStaticLightingMapping(bool bTextureMapping, int ResolutionToUse) { return NativeCall<bool, bool, int>(this, "UStaticMeshComponent.SetStaticLightingMapping(bool,int)", bTextureMapping, ResolutionToUse); }

    bool SetLODDataCount(const unsigned int MinSize, const unsigned int MaxSize) { return NativeCall<bool, const unsigned int, const unsigned int>(this, "UStaticMeshComponent.SetLODDataCount(unsignedint,unsignedint)", MinSize, MaxSize); }

    //FPrimitiveSceneProxy* CreateSceneProxy() { return NativeCall<FPrimitiveSceneProxy*>(this, "UStaticMeshComponent.CreateSceneProxy()"); }

    bool ShouldRecreateProxyOnUpdateTransform() { return NativeCall<bool>(this, "UStaticMeshComponent.ShouldRecreateProxyOnUpdateTransform()"); }

};


struct AActor : UPrimalActor, ActorExtensions

{

    // Fields


    FActorTickFunction& PrimaryActorTickField() { return *GetNativePointerField<FActorTickFunction*>(this, "AActor.PrimaryActorTick"); }

    EActorUpdateOverlapsMethod& UpdateOverlapsMethodDuringLevelStreamingField() { return *GetNativePointerField<EActorUpdateOverlapsMethod*>(this, "AActor.UpdateOverlapsMethodDuringLevelStreaming"); }

    int& LastForceNetUpdateFrameField() { return *GetNativePointerField<int*>(this, "AActor.LastForceNetUpdateFrame"); }

    float& InitialLifeSpanField() { return *GetNativePointerField<float*>(this, "AActor.InitialLifeSpan"); }

    float& CustomTimeDilationField() { return *GetNativePointerField<float*>(this, "AActor.CustomTimeDilation"); }

    int& RayTracingGroupIdField() { return *GetNativePointerField<int*>(this, "AActor.RayTracingGroupId"); }

    FRepAttachment& AttachmentReplicationField() { return *GetNativePointerField<FRepAttachment*>(this, "AActor.AttachmentReplication"); }

    FRepMovement& ReplicatedMovementField() { return *GetNativePointerField<FRepMovement*>(this, "AActor.ReplicatedMovement"); }

    TObjectPtr<AActor>& OwnerField() { return *GetNativePointerField<TObjectPtr<AActor>*>(this, "AActor.Owner"); }

    FName& NetDriverNameField() { return *GetNativePointerField<FName*>(this, "AActor.NetDriverName"); }

    TEnumAsByte<enum ENetDormancy>& NetDormancyField() { return *GetNativePointerField<TEnumAsByte<enum ENetDormancy>*>(this, "AActor.NetDormancy"); }

    TEnumAsByte<enum EAutoReceiveInput::Type>& AutoReceiveInputField() { return *GetNativePointerField<TEnumAsByte<enum EAutoReceiveInput::Type>*>(this, "AActor.AutoReceiveInput"); }

    int& InputPriorityField() { return *GetNativePointerField<int*>(this, "AActor.InputPriority"); }

    long double& CreationTimeField() { return *GetNativePointerField<long double*>(this, "AActor.CreationTime"); }

    TObjectPtr<UInputComponent>& InputComponentField() { return *GetNativePointerField<TObjectPtr<UInputComponent>*>(this, "AActor.InputComponent"); }

    float& NetCullDistanceSquaredField() { return *GetNativePointerField<float*>(this, "AActor.NetCullDistanceSquared"); }

    int& NetTagField() { return *GetNativePointerField<int*>(this, "AActor.NetTag"); }

    float& NetUpdateFrequencyField() { return *GetNativePointerField<float*>(this, "AActor.NetUpdateFrequency"); }

    float& MinNetUpdateFrequencyField() { return *GetNativePointerField<float*>(this, "AActor.MinNetUpdateFrequency"); }

    float& NetPriorityField() { return *GetNativePointerField<float*>(this, "AActor.NetPriority"); }

    long double& LastRenderTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastRenderTime"); }

    long double& LastRenderTimeOnScreenField() { return *GetNativePointerField<long double*>(this, "AActor.LastRenderTimeOnScreen"); }

    long double& LastRenderTimeIgnoreShadowField() { return *GetNativePointerField<long double*>(this, "AActor.LastRenderTimeIgnoreShadow"); }

    TObjectPtr<APawn>& InstigatorField() { return *GetNativePointerField<TObjectPtr<APawn>*>(this, "AActor.Instigator"); }

    TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >& ChildrenField() { return *GetNativePointerField<TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "AActor.Children"); }

    TObjectPtr<USceneComponent>& RootComponentField() { return *GetNativePointerField<TObjectPtr<USceneComponent>*>(this, "AActor.RootComponent"); }

    FTimerHandle& TimerHandle_LifeSpanExpiredField() { return *GetNativePointerField<FTimerHandle*>(this, "AActor.TimerHandle_LifeSpanExpired"); }

    TArray<FName, TSizedDefaultAllocator<32> >& LayersField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "AActor.Layers"); }

    TWeakObjectPtr<UChildActorComponent>& ParentComponentField() { return *GetNativePointerField<TWeakObjectPtr<UChildActorComponent>*>(this, "AActor.ParentComponent"); }

    TArray<FName, TSizedDefaultAllocator<32> >& TagsField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "AActor.Tags"); }

    int& CachedStasisGridIndexField() { return *GetNativePointerField<int*>(this, "AActor.CachedStasisGridIndex"); }

    FTakePointDamageSignature& OnTakePointDamageField() { return *GetNativePointerField<FTakePointDamageSignature*>(this, "AActor.OnTakePointDamage"); }

    FActorBeginOverlapSignature& OnActorBeginOverlapField() { return *GetNativePointerField<FActorBeginOverlapSignature*>(this, "AActor.OnActorBeginOverlap"); }

    FActorBeginCursorOverSignature& OnBeginCursorOverField() { return *GetNativePointerField<FActorBeginCursorOverSignature*>(this, "AActor.OnBeginCursorOver"); }

    FActorOnClickedSignature& OnClickedField() { return *GetNativePointerField<FActorOnClickedSignature*>(this, "AActor.OnClicked"); }

    FActorOnInputTouchBeginSignature& OnInputTouchBeginField() { return *GetNativePointerField<FActorOnInputTouchBeginSignature*>(this, "AActor.OnInputTouchBegin"); }

    FActorBeginTouchOverSignature& OnInputTouchEnterField() { return *GetNativePointerField<FActorBeginTouchOverSignature*>(this, "AActor.OnInputTouchEnter"); }

    FActorHitSignature& OnActorHitField() { return *GetNativePointerField<FActorHitSignature*>(this, "AActor.OnActorHit"); }

    FActorEndPlaySignature& OnEndPlayField() { return *GetNativePointerField<FActorEndPlaySignature*>(this, "AActor.OnEndPlay"); }

    //UE::Net::FSubObjectRegistry& ReplicatedSubObjectsField() { return *GetNativePointerField<UE::Net::FSubObjectRegistry*>(this, "AActor.ReplicatedSubObjects"); }

    //TArray<UE::Net::FReplicatedComponentInfo, TSizedDefaultAllocator<32> >& ReplicatedComponentsInfoField() { return *GetNativePointerField<TArray<UE::Net::FReplicatedComponentInfo, TSizedDefaultAllocator<32> >*>(this, "AActor.ReplicatedComponentsInfo"); }

    TArray<UActorComponent*, TSizedDefaultAllocator<32> >& ReplicatedComponentsField() { return *GetNativePointerField<TArray<UActorComponent*, TSizedDefaultAllocator<32> >*>(this, "AActor.ReplicatedComponents"); }

    TSet<UActorComponent*, DefaultKeyFuncs<UActorComponent*, 0>, FDefaultSetAllocator>& OwnedComponentsField() { return *GetNativePointerField<TSet<UActorComponent*, DefaultKeyFuncs<UActorComponent*, 0>, FDefaultSetAllocator>*>(this, "AActor.OwnedComponents"); }

    TArray<TObjectPtr<UActorComponent>, TSizedDefaultAllocator<32> >& InstanceComponentsField() { return *GetNativePointerField<TArray<TObjectPtr<UActorComponent>, TSizedDefaultAllocator<32> >*>(this, "AActor.InstanceComponents"); }

    TArray<TObjectPtr<UActorComponent>, TSizedDefaultAllocator<32> >& BlueprintCreatedComponentsField() { return *GetNativePointerField<TArray<TObjectPtr<UActorComponent>, TSizedDefaultAllocator<32> >*>(this, "AActor.BlueprintCreatedComponents"); }

    FRenderCommandFence& DetachFenceField() { return *GetNativePointerField<FRenderCommandFence*>(this, "AActor.DetachFence"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bNetTemporary() { return { this, "AActor.bNetTemporary" }; }

    BitFieldValue<bool, unsigned __int32> bNetStartup() { return { this, "AActor.bNetStartup" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyRelevantToOwner() { return { this, "AActor.bOnlyRelevantToOwner" }; }

    BitFieldValue<bool, unsigned __int32> bAlwaysRelevant() { return { this, "AActor.bAlwaysRelevant" }; }

    BitFieldValue<bool, unsigned __int32> bReplicateMovement() { return { this, "AActor.bReplicateMovement" }; }

    BitFieldValue<bool, unsigned __int32> bCallPreReplication() { return { this, "AActor.bCallPreReplication" }; }

    BitFieldValue<bool, unsigned __int32> bCallPreReplicationForReplay() { return { this, "AActor.bCallPreReplicationForReplay" }; }

    BitFieldValue<bool, unsigned __int32> bHidden() { return { this, "AActor.bHidden" }; }

    BitFieldValue<bool, unsigned __int32> bTearOff() { return { this, "AActor.bTearOff" }; }

    BitFieldValue<bool, unsigned __int32> bForceNetAddressable() { return { this, "AActor.bForceNetAddressable" }; }

    BitFieldValue<bool, unsigned __int32> bExchangedRoles() { return { this, "AActor.bExchangedRoles" }; }

    BitFieldValue<bool, unsigned __int32> bNetLoadOnClient() { return { this, "AActor.bNetLoadOnClient" }; }

    BitFieldValue<bool, unsigned __int32> bNetUseOwnerRelevancy() { return { this, "AActor.bNetUseOwnerRelevancy" }; }

    BitFieldValue<bool, unsigned __int32> bRelevantForNetworkReplays() { return { this, "AActor.bRelevantForNetworkReplays" }; }

    BitFieldValue<bool, unsigned __int32> bRelevantForLevelBounds() { return { this, "AActor.bRelevantForLevelBounds" }; }

    BitFieldValue<bool, unsigned __int32> bReplayRewindable() { return { this, "AActor.bReplayRewindable" }; }

    BitFieldValue<bool, unsigned __int32> bAllowTickBeforeBeginPlay() { return { this, "AActor.bAllowTickBeforeBeginPlay" }; }

    BitFieldValue<bool, unsigned __int32> bForceHighQualityViewerReplication() { return { this, "AActor.bForceHighQualityViewerReplication" }; }

    BitFieldValue<bool, unsigned __int32> bActorPreventPhysicsSceneRegistration() { return { this, "AActor.bActorPreventPhysicsSceneRegistration" }; }

    BitFieldValue<bool, unsigned __int32> bAutoDestroyWhenFinished() { return { this, "AActor.bAutoDestroyWhenFinished" }; }

    BitFieldValue<bool, unsigned __int32> bCanBeDamaged() { return { this, "AActor.bCanBeDamaged" }; }

    BitFieldValue<bool, unsigned __int32> bBlockInput() { return { this, "AActor.bBlockInput" }; }

    BitFieldValue<bool, unsigned __int32> bCollideWhenPlacing() { return { this, "AActor.bCollideWhenPlacing" }; }

    BitFieldValue<bool, unsigned __int32> bFindCameraComponentWhenViewTarget() { return { this, "AActor.bFindCameraComponentWhenViewTarget" }; }

    BitFieldValue<bool, unsigned __int32> bGenerateOverlapEventsDuringLevelStreaming() { return { this, "AActor.bGenerateOverlapEventsDuringLevelStreaming" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoresOriginShifting() { return { this, "AActor.bIgnoresOriginShifting" }; }

    BitFieldValue<bool, unsigned __int32> bEnableAutoLODGeneration() { return { this, "AActor.bEnableAutoLODGeneration" }; }

    BitFieldValue<bool, unsigned __int32> bIsEditorOnlyActor() { return { this, "AActor.bIsEditorOnlyActor" }; }

    BitFieldValue<bool, unsigned __int32> bActorSeamlessTraveled() { return { this, "AActor.bActorSeamlessTraveled" }; }

    BitFieldValue<bool, unsigned __int32> bDisableRigidBodyAnimNodes() { return { this, "AActor.bDisableRigidBodyAnimNodes" }; }

    BitFieldValue<bool, unsigned __int32> bReplicates() { return { this, "AActor.bReplicates" }; }

    BitFieldValue<bool, unsigned __int32> bCanBeInCluster() { return { this, "AActor.bCanBeInCluster" }; }

    BitFieldValue<bool, unsigned __int32> bAllowReceiveTickEventOnDedicatedServer() { return { this, "AActor.bAllowReceiveTickEventOnDedicatedServer" }; }

    BitFieldValue<bool, unsigned __int32> bNetCheckedInitialPhysicsState() { return { this, "AActor.bNetCheckedInitialPhysicsState" }; }

    BitFieldValue<bool, unsigned __int32> bReplicateUsingRegisteredSubObjectList() { return { this, "AActor.bReplicateUsingRegisteredSubObjectList" }; }

    BitFieldValue<bool, unsigned __int32> bHasFinishedSpawning() { return { this, "AActor.bHasFinishedSpawning" }; }

    BitFieldValue<bool, unsigned __int32> bActorInitialized() { return { this, "AActor.bActorInitialized" }; }

    BitFieldValue<bool, unsigned __int32> bActorBeginningPlayFromLevelStreaming() { return { this, "AActor.bActorBeginningPlayFromLevelStreaming" }; }

    BitFieldValue<bool, unsigned __int32> bTickFunctionsRegistered() { return { this, "AActor.bTickFunctionsRegistered" }; }

    BitFieldValue<bool, unsigned __int32> bHasDeferredComponentRegistration() { return { this, "AActor.bHasDeferredComponentRegistration" }; }

    BitFieldValue<bool, unsigned __int32> bRunningUserConstructionScript() { return { this, "AActor.bRunningUserConstructionScript" }; }

    BitFieldValue<bool, unsigned __int32> bHasRegisteredAllComponents() { return { this, "AActor.bHasRegisteredAllComponents" }; }

    BitFieldValue<bool, unsigned __int32> bDeferredBeginPlay() { return { this, "AActor.bDeferredBeginPlay" }; }

    BitFieldValue<bool, unsigned __int32> bPrimalDeferredConstruction() { return { this, "AActor.bPrimalDeferredConstruction" }; }

    BitFieldValue<bool, unsigned __int32> bActorEnableCollision() { return { this, "AActor.bActorEnableCollision" }; }

    BitFieldValue<bool, unsigned __int32> bActorIsBeingDestroyed() { return { this, "AActor.bActorIsBeingDestroyed" }; }

    BitFieldValue<bool, unsigned __int32> bActorWantsDestroyDuringBeginPlay() { return { this, "AActor.bActorWantsDestroyDuringBeginPlay" }; }

    BitFieldValue<bool, unsigned __int32> ActorHasBegunPlay() { return { this, "AActor.ActorHasBegunPlay" }; }

    BitFieldValue<bool, unsigned __int32> bActorIsBeingConstructed() { return { this, "AActor.bActorIsBeingConstructed" }; }

    BitFieldValue<bool, unsigned __int32> bAsyncPhysicsTickEnabled() { return { this, "AActor.bAsyncPhysicsTickEnabled" }; }


    // Functions


    FString* GetActorNameOrLabel(FString* result) { return NativeCall<FString*, FString*>(this, "AActor.GetActorNameOrLabel()", result); }

    bool ServerHandleNetExecCommand(APlayerController* FromPC, FName CommandName, const FBPNetExecParams* ExecParams) { return NativeCall<bool, APlayerController*, FName, const FBPNetExecParams*>(this, "AActor.ServerHandleNetExecCommand(APlayerController*,FName,FBPNetExecParams&)", FromPC, CommandName, ExecParams); }

    float GetRepGraphRelevantDistanceSq() { return NativeCall<float>(this, "AActor.GetRepGraphRelevantDistanceSq()"); }

    long double GetLastGameplayRelevantTime() { return NativeCall<long double>(this, "AActor.GetLastGameplayRelevantTime()"); }

    bool IncrementalUnregisterComponents() { return NativeCall<bool>(this, "AActor.IncrementalUnregisterComponents()"); }

    void AsyncPhysicsTickActor(float DeltaTime, float SimTime) { NativeCall<void, float, float>(this, "AActor.AsyncPhysicsTickActor(float,float)", DeltaTime, SimTime); }

    bool IsLevelBoundsRelevant() { return NativeCall<bool>(this, "AActor.IsLevelBoundsRelevant()"); }

    __int64 GetDefaultAttachComponent() { return NativeCall<__int64>(this, "AActor.GetDefaultAttachComponent()"); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AActor.StaticClass()"); }

    //USkeletalMeshComponent* FindComponentByClass<class USkeletalMeshComponent>() { return NativeCall<USkeletalMeshComponent*>(this, "AActor.FindComponentByClass<class USkeletalMeshComponent>()"); }

    //USplineComponent* FindComponentByClass<class USplineComponent>() { return NativeCall<USplineComponent*>(this, "AActor.FindComponentByClass<class USplineComponent>()"); }

    bool IsHidden() { return NativeCall<bool>(this, "AActor.IsHidden()"); }

    //void GetComponents<class USkeletalMeshComponent, class TSizedDefaultAllocator<32>>(TArray<USkeletalMeshComponent*, TSizedDefaultAllocator<32> >* OutComponents, bool bIncludeFromChildActors) { NativeCall<void, TArray<USkeletalMeshComponent*, TSizedDefaultAllocator<32> >*, bool>(this, "AActor.GetComponents<class USkeletalMeshComponent,class TSizedDefaultAllocator<32>>(TArray<USkeletalMeshComponent*,TSizedDefaultAllocator<32>>&,bool)", OutComponents, bIncludeFromChildActors); }

    //void GetComponents<class UPCGComponent, class TSizedInlineAllocator<1, 32, class TSizedDefaultAllocator<32>>>(TArray<UPCGComponent*, TSizedInlineAllocator<1, 32, TSizedDefaultAllocator<32> > >* OutComponents, bool bIncludeFromChildActors) { NativeCall<void, TArray<UPCGComponent*, TSizedInlineAllocator<1, 32, TSizedDefaultAllocator<32> > >*, bool>(this, "AActor.GetComponents<class UPCGComponent,class TSizedInlineAllocator<1,32,class TSizedDefaultAllocator<32>>>(TArray<UPCGComponent*,TSizedInlineAllocator<1,32,TSizedDefaultAllocator<32>>>&,bool)", OutComponents, bIncludeFromChildActors); }

    void PostRegisterAllComponents() { NativeCall<void>(this, "AActor.PostRegisterAllComponents()"); }

    void OutsideWorldBounds() { NativeCall<void>(this, "AActor.OutsideWorldBounds()"); }

    bool CanBeDamaged() { return NativeCall<bool>(this, "AActor.CanBeDamaged()"); }

    void ForceDestroy() { NativeCall<void>(this, "AActor.ForceDestroy()"); }

    //void GetComponents<class UPrimitiveComponent, class TSizedDefaultAllocator<32>>(TArray<UPrimitiveComponent*, TSizedDefaultAllocator<32> >* OutComponents, bool bIncludeFromChildActors) { NativeCall<void, TArray<UPrimitiveComponent*, TSizedDefaultAllocator<32> >*, bool>(this, "AActor.GetComponents<class UPrimitiveComponent,class TSizedDefaultAllocator<32>>(TArray<UPrimitiveComponent*,TSizedDefaultAllocator<32>>&,bool)", OutComponents, bIncludeFromChildActors); }

    //UStaticMeshComponent* FindComponentByClass<class UStaticMeshComponent>() { return NativeCall<UStaticMeshComponent*>(this, "AActor.FindComponentByClass<class UStaticMeshComponent>()"); }

    void InitializeDefaults() { NativeCall<void>(this, "AActor.InitializeDefaults()"); }

    bool CheckDefaultSubobjectsInternal() { return NativeCall<bool>(this, "AActor.CheckDefaultSubobjectsInternal()"); }

    bool CheckActorComponents() { return NativeCall<bool>(this, "AActor.CheckActorComponents()"); }

    void ResetOwnedComponents() { NativeCall<void>(this, "AActor.ResetOwnedComponents()"); }

    void PostInitProperties() { NativeCall<void>(this, "AActor.PostInitProperties()"); }

    bool CanBeInCluster() { return NativeCall<bool>(this, "AActor.CanBeInCluster()"); }

    bool IsEditorOnly() { return NativeCall<bool>(this, "AActor.IsEditorOnly()"); }

    bool IsAsset() { return NativeCall<bool>(this, "AActor.IsAsset()"); }

    UWorld* GetWorld() { return NativeCall<UWorld*>(this, "AActor.GetWorld()"); }

    FTimerManager* GetWorldTimerManager() { return NativeCall<FTimerManager*>(this, "AActor.GetWorldTimerManager()"); }

    UGameInstance* GetGameInstance() { return NativeCall<UGameInstance*>(this, "AActor.GetGameInstance()"); }

    bool IsNetStartupActor() { return NativeCall<bool>(this, "AActor.IsNetStartupActor()"); }

    void ClearCrossLevelReferences() { NativeCall<void>(this, "AActor.ClearCrossLevelReferences()"); }

    bool TeleportTo(const UE::Math::TVector<double>* DestLocation, const UE::Math::TRotator<double>* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*, bool, bool>(this, "AActor.TeleportTo(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool,bool)", DestLocation, DestRotation, bIsATest, bNoCheck); }

    bool K2_TeleportTo(UE::Math::TVector<double>* DestLocation, UE::Math::TRotator<double>* DestRotation, bool bSimpleTeleport) { return NativeCall<bool, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool>(this, "AActor.K2_TeleportTo(UE::Math::TVector<double>,UE::Math::TRotator<double>,bool)", DestLocation, DestRotation, bSimpleTeleport); }

    void AddTickPrerequisiteActor(AActor* PrerequisiteActor) { NativeCall<void, AActor*>(this, "AActor.AddTickPrerequisiteActor(AActor*)", PrerequisiteActor); }

    void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent) { NativeCall<void, UActorComponent*>(this, "AActor.AddTickPrerequisiteComponent(UActorComponent*)", PrerequisiteComponent); }

    void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor) { NativeCall<void, AActor*>(this, "AActor.RemoveTickPrerequisiteActor(AActor*)", PrerequisiteActor); }

    void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent) { NativeCall<void, UActorComponent*>(this, "AActor.RemoveTickPrerequisiteComponent(UActorComponent*)", PrerequisiteComponent); }

    void BeginDestroy() { NativeCall<void>(this, "AActor.BeginDestroy()"); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "AActor.Serialize(FArchive&)", Ar); }

    void PostLoad() { NativeCall<void>(this, "AActor.PostLoad()"); }

    void PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph) { NativeCall<void, FObjectInstancingGraph*>(this, "AActor.PostLoadSubobjects(FObjectInstancingGraph*)", OuterInstanceGraph); }

    void ProcessEvent(UFunction* Function, void* Parameters) { NativeCall<void, UFunction*, void*>(this, "AActor.ProcessEvent(UFunction*,void*)", Function, Parameters); }

    void ApplyWorldOffset(const UE::Math::TVector<double>* InOffset, bool bWorldShift) { NativeCall<void, const UE::Math::TVector<double>*, bool>(this, "AActor.ApplyWorldOffset(UE::Math::TVector<double>&,bool)", InOffset, bWorldShift); }

    void RegisterActorTickFunctions(bool bRegister, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool>(this, "AActor.RegisterActorTickFunctions(bool,bool)", bRegister, bSaveAndRestoreTickState); }

    void RegisterAllActorTickFunctions(bool bRegister, bool bDoComponents, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool, bool>(this, "AActor.RegisterAllActorTickFunctions(bool,bool,bool)", bRegister, bDoComponents, bSaveAndRestoreTickState); }

    bool Rename(const wchar_t* InName, UObject* NewOuter, unsigned int Flags) { return NativeCall<bool, const wchar_t*, UObject*, unsigned int>(this, "AActor.Rename(wchar_t*,UObject*,unsignedint)", InName, NewOuter, Flags); }

    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "AActor.GetNetConnection()"); }

    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "AActor.GetNetOwningPlayer()"); }

    void TickActor(float DeltaSeconds, ELevelTick TickType, FActorTickFunction* ThisTickFunction) { NativeCall<void, float, ELevelTick, FActorTickFunction*>(this, "AActor.TickActor(float,ELevelTick,FActorTickFunction&)", DeltaSeconds, TickType, ThisTickFunction); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "AActor.Tick(float)", DeltaSeconds); }

    void PreReplication(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "AActor.PreReplication(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void CallPreReplication(UNetDriver* NetDriver) { NativeCall<void, UNetDriver*>(this, "AActor.CallPreReplication(UNetDriver*)", NetDriver); }

    void PreReplicationForReplay(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "AActor.PreReplicationForReplay(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void GetComponentsBoundingCylinder(float* OutCollisionRadius, float* OutCollisionHalfHeight, bool bNonColliding, bool bIncludeFromChildActors) { NativeCall<void, float*, float*, bool, bool>(this, "AActor.GetComponentsBoundingCylinder(float&,float&,bool,bool)", OutCollisionRadius, OutCollisionHalfHeight, bNonColliding, bIncludeFromChildActors); }

    void GetSimpleCollisionCylinder(float* CollisionRadius, float* CollisionHalfHeight) { NativeCall<void, float*, float*>(this, "AActor.GetSimpleCollisionCylinder(float&,float&)", CollisionRadius, CollisionHalfHeight); }

    bool IsRootComponentCollisionRegistered() { return NativeCall<bool>(this, "AActor.IsRootComponentCollisionRegistered()"); }

    bool IsAttachedTo(const AActor* Other) { return NativeCall<bool, const AActor*>(this, "AActor.IsAttachedTo(AActor*)", Other); }

    bool IsBasedOnActor(const AActor* Other) { return NativeCall<bool, const AActor*>(this, "AActor.IsBasedOnActor(AActor*)", Other); }

    bool CheckStillInWorld() { return NativeCall<bool>(this, "AActor.CheckStillInWorld()"); }

    void ClearComponentOverlaps() { NativeCall<void>(this, "AActor.ClearComponentOverlaps()"); }

    void UpdateOverlaps(bool bDoNotifies) { NativeCall<void, bool>(this, "AActor.UpdateOverlaps(bool)", bDoNotifies); }

    bool IsOverlappingActor(const AActor* Other) { return NativeCall<bool, const AActor*>(this, "AActor.IsOverlappingActor(AActor*)", Other); }

    void GetOverlappingActors(TArray<AActor*, TSizedDefaultAllocator<32> >* OutOverlappingActors, TSubclassOf<AActor> ClassFilter) { NativeCall<void, TArray<AActor*, TSizedDefaultAllocator<32> >*, TSubclassOf<AActor>>(this, "AActor.GetOverlappingActors(TArray<AActor*,TSizedDefaultAllocator<32>>&,TSubclassOf<AActor>)", OutOverlappingActors, ClassFilter); }

    void GetOverlappingActors(TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>* OutOverlappingActors, TSubclassOf<AActor> ClassFilter) { NativeCall<void, TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>*, TSubclassOf<AActor>>(this, "AActor.GetOverlappingActors(TSet<AActor*,DefaultKeyFuncs<AActor*,0>,FDefaultSetAllocator>&,TSubclassOf<AActor>)", OutOverlappingActors, ClassFilter); }

    void GetOverlappingComponents(TArray<UPrimitiveComponent*, TSizedDefaultAllocator<32> >* OutOverlappingComponents) { NativeCall<void, TArray<UPrimitiveComponent*, TSizedDefaultAllocator<32> >*>(this, "AActor.GetOverlappingComponents(TArray<UPrimitiveComponent*,TSizedDefaultAllocator<32>>&)", OutOverlappingComponents); }

    void GetOverlappingComponents(TSet<UPrimitiveComponent*, DefaultKeyFuncs<UPrimitiveComponent*, 0>, FDefaultSetAllocator>* OutOverlappingComponents) { NativeCall<void, TSet<UPrimitiveComponent*, DefaultKeyFuncs<UPrimitiveComponent*, 0>, FDefaultSetAllocator>*>(this, "AActor.GetOverlappingComponents(TSet<UPrimitiveComponent*,DefaultKeyFuncs<UPrimitiveComponent*,0>,FDefaultSetAllocator>&)", OutOverlappingComponents); }

    void NotifyActorBeginOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "AActor.NotifyActorBeginOverlap(AActor*)", OtherActor); }

    void NotifyActorEndOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "AActor.NotifyActorEndOverlap(AActor*)", OtherActor); }

    void NotifyActorBeginCursorOver() { NativeCall<void>(this, "AActor.NotifyActorBeginCursorOver()"); }

    void NotifyActorEndCursorOver() { NativeCall<void>(this, "AActor.NotifyActorEndCursorOver()"); }

    void NotifyActorOnClicked(FKey* ButtonPressed) { NativeCall<void, FKey*>(this, "AActor.NotifyActorOnClicked(FKey)", ButtonPressed); }

    void NotifyActorOnReleased(FKey* ButtonReleased) { NativeCall<void, FKey*>(this, "AActor.NotifyActorOnReleased(FKey)", ButtonReleased); }

    void NotifyActorOnInputTouchBegin(const ETouchIndex::Type FingerIndex) { NativeCall<void, const ETouchIndex::Type>(this, "AActor.NotifyActorOnInputTouchBegin(ETouchIndex::Type)", FingerIndex); }

    void NotifyActorOnInputTouchEnd(const ETouchIndex::Type FingerIndex) { NativeCall<void, const ETouchIndex::Type>(this, "AActor.NotifyActorOnInputTouchEnd(ETouchIndex::Type)", FingerIndex); }

    void NotifyActorOnInputTouchEnter(const ETouchIndex::Type FingerIndex) { NativeCall<void, const ETouchIndex::Type>(this, "AActor.NotifyActorOnInputTouchEnter(ETouchIndex::Type)", FingerIndex); }

    void NotifyActorOnInputTouchLeave(const ETouchIndex::Type FingerIndex) { NativeCall<void, const ETouchIndex::Type>(this, "AActor.NotifyActorOnInputTouchLeave(ETouchIndex::Type)", FingerIndex); }

    void NotifyHit(UPrimitiveComponent* MyComp, AActor* Other, UPrimitiveComponent* OtherComp, bool bSelfMoved, UE::Math::TVector<double>* HitLocation, UE::Math::TVector<double>* HitNormal, UE::Math::TVector<double>* NormalImpulse, const FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, AActor*, UPrimitiveComponent*, bool, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*, const FHitResult*>(this, "AActor.NotifyHit(UPrimitiveComponent*,AActor*,UPrimitiveComponent*,bool,UE::Math::TVector<double>,UE::Math::TVector<double>,UE::Math::TVector<double>,FHitResult&)", MyComp, Other, OtherComp, bSelfMoved, HitLocation, HitNormal, NormalImpulse, Hit); }

    bool WasRecentlyRendered(float Tolerance) { return NativeCall<bool, float>(this, "AActor.WasRecentlyRendered(float)", Tolerance); }

    long double GetLastRenderTime(bool IgnoreShadow) { return NativeCall<long double, bool>(this, "AActor.GetLastRenderTime(bool)", IgnoreShadow); }

    void SetOwner(AActor* NewOwner) { NativeCall<void, AActor*>(this, "AActor.SetOwner(AActor*)", NewOwner); }

    bool HasLocalNetOwner() { return NativeCall<bool>(this, "AActor.HasLocalNetOwner()"); }

    bool HasNetOwner() { return NativeCall<bool>(this, "AActor.HasNetOwner()"); }

    void SetAutoDestroyWhenFinished(bool bVal) { NativeCall<void, bool>(this, "AActor.SetAutoDestroyWhenFinished(bool)", bVal); }

    bool AttachToComponent(USceneComponent* Parent, const FAttachmentTransformRules* AttachmentRules, FName SocketName) { return NativeCall<bool, USceneComponent*, const FAttachmentTransformRules*, FName>(this, "AActor.AttachToComponent(USceneComponent*,FAttachmentTransformRules&,FName)", Parent, AttachmentRules, SocketName); }

    void OnRep_AttachmentReplication() { NativeCall<void>(this, "AActor.OnRep_AttachmentReplication()"); }

    bool AttachToActor(AActor* ParentActor, const FAttachmentTransformRules* AttachmentRules, FName SocketName) { return NativeCall<bool, AActor*, const FAttachmentTransformRules*, FName>(this, "AActor.AttachToActor(AActor*,FAttachmentTransformRules&,FName)", ParentActor, AttachmentRules, SocketName); }

    void DetachRootComponentFromParent(bool bMaintainWorldPosition) { NativeCall<void, bool>(this, "AActor.DetachRootComponentFromParent(bool)", bMaintainWorldPosition); }

    AActor* GetAttachParentActor() { return NativeCall<AActor*>(this, "AActor.GetAttachParentActor()"); }

    void ForEachAttachedActors(TFunctionRef<bool __cdecl(AActor*)>* Functor) { NativeCall<void, TFunctionRef<bool __cdecl(AActor*)>*>(this, "AActor.ForEachAttachedActors(TFunctionRef<bool__cdecl(AActor*)", Functor); }

    void GetAttachedActors(TArray<AActor*, TSizedDefaultAllocator<32> >* OutActors, bool bResetArray, bool bRecursivelyIncludeAttachedActors) { NativeCall<void, TArray<AActor*, TSizedDefaultAllocator<32> >*, bool, bool>(this, "AActor.GetAttachedActors(TArray<AActor*,TSizedDefaultAllocator<32>>&,bool,bool)", OutActors, bResetArray, bRecursivelyIncludeAttachedActors); }

    bool ActorHasTag(FName Tag) { return NativeCall<bool, FName>(this, "AActor.ActorHasTag(FName)", Tag); }

    APhysicsVolume* GetPhysicsVolume() { return NativeCall<APhysicsVolume*>(this, "AActor.GetPhysicsVolume()"); }

    bool IsRelevancyOwnerFor(const AActor* ReplicatedActor, const AActor* ActorOwner, const AActor* ConnectionActor) { return NativeCall<bool, const AActor*, const AActor*, const AActor*>(this, "AActor.IsRelevancyOwnerFor(AActor*,AActor*,AActor*)", ReplicatedActor, ActorOwner, ConnectionActor); }

    void ForceNetUpdate(bool bDormantDontReplicateProperties, bool bAbsoluteForceNetUpdate, bool bDontUpdateChannel) { NativeCall<void, bool, bool, bool>(this, "AActor.ForceNetUpdate(bool,bool,bool)", bDormantDontReplicateProperties, bAbsoluteForceNetUpdate, bDontUpdateChannel); }

    void SetNetDormancy(ENetDormancy NewDormancy) { NativeCall<void, ENetDormancy>(this, "AActor.SetNetDormancy(ENetDormancy)", NewDormancy); }

    void FlushNetDormancy() { NativeCall<void>(this, "AActor.FlushNetDormancy()"); }

    void ForcePropertyCompare() { NativeCall<void>(this, "AActor.ForcePropertyCompare()"); }

    void PrestreamTextures(float Seconds, bool bEnableStreaming, int CinematicTextureGroups) { NativeCall<void, float, bool, int>(this, "AActor.PrestreamTextures(float,bool,int)", Seconds, bEnableStreaming, CinematicTextureGroups); }

    void RouteEndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "AActor.RouteEndPlay(EEndPlayReason::Type)", EndPlayReason); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "AActor.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    void Destroyed() { NativeCall<void>(this, "AActor.Destroyed()"); }

    void TearOff() { NativeCall<void>(this, "AActor.TearOff()"); }

    void Reset() { NativeCall<void>(this, "AActor.Reset()"); }

    void FellOutOfWorld(const UDamageType* dmgType) { NativeCall<void, const UDamageType*>(this, "AActor.FellOutOfWorld(UDamageType&)", dmgType); }

    void MakeNoise(float Loudness, APawn* NoiseInstigator, UE::Math::TVector<double>* NoiseLocation, float MaxRange, FName Tag) { NativeCall<void, float, APawn*, UE::Math::TVector<double>*, float, FName>(this, "AActor.MakeNoise(float,APawn*,UE::Math::TVector<double>,float,FName)", Loudness, NoiseInstigator, NoiseLocation, MaxRange, Tag); }

    static void MakeNoiseImpl(AActor* NoiseMaker, float Loudness, APawn* NoiseInstigator, const UE::Math::TVector<double>* NoiseLocation, float MaxRange, FName Tag) { NativeCall<void, AActor*, float, APawn*, const UE::Math::TVector<double>*, float, FName>(nullptr, "AActor.MakeNoiseImpl(AActor*,float,APawn*,UE::Math::TVector<double>&,float,FName)", NoiseMaker, Loudness, NoiseInstigator, NoiseLocation, MaxRange, Tag); }

    float TakeDamage(float DamageAmount, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, const FDamageEvent*, AController*, AActor*>(this, "AActor.TakeDamage(float,FDamageEvent&,AController*,AActor*)", DamageAmount, DamageEvent, EventInstigator, DamageCauser); }

    float InternalTakeRadialDamage(float Damage, const FRadialDamageEvent* RadialDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, const FRadialDamageEvent*, AController*, AActor*>(this, "AActor.InternalTakeRadialDamage(float,FRadialDamageEvent&,AController*,AActor*)", Damage, RadialDamageEvent, EventInstigator, DamageCauser); }

    void DispatchBlockingHit(UPrimitiveComponent* MyComp, UPrimitiveComponent* OtherComp, bool bSelfMoved, const FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, UPrimitiveComponent*, bool, const FHitResult*>(this, "AActor.DispatchBlockingHit(UPrimitiveComponent*,UPrimitiveComponent*,bool,FHitResult&)", MyComp, OtherComp, bSelfMoved, Hit); }

    void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo* DebugDisplay, float* YL, float* YPos) { NativeCall<void, UCanvas*, const FDebugDisplayInfo*, float*, float*>(this, "AActor.DisplayDebug(UCanvas*,FDebugDisplayInfo&,float&,float&)", Canvas, DebugDisplay, YL, YPos); }

    void BecomeViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.BecomeViewTarget(APlayerController*)", PC); }

    void EndViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.EndViewTarget(APlayerController*)", PC); }

    void CalcCamera(float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<void, float, FMinimalViewInfo*>(this, "AActor.CalcCamera(float,FMinimalViewInfo&)", DeltaTime, OutResult); }

    bool HasActiveCameraComponent() { return NativeCall<bool>(this, "AActor.HasActiveCameraComponent()"); }

    bool HasActivePawnControlCameraComponent() { return NativeCall<bool>(this, "AActor.HasActivePawnControlCameraComponent()"); }

    void ForceNetRelevant() { NativeCall<void>(this, "AActor.ForceNetRelevant()"); }

    ECollisionResponse GetComponentsCollisionResponseToChannel(ECollisionChannel Channel) { return NativeCall<ECollisionResponse, ECollisionChannel>(this, "AActor.GetComponentsCollisionResponseToChannel(ECollisionChannel)", Channel); }

    void AddOwnedComponent(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.AddOwnedComponent(UActorComponent*)", Component); }

    void RemoveOwnedComponent(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.RemoveOwnedComponent(UActorComponent*)", Component); }

    void UpdateReplicatedComponent(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.UpdateReplicatedComponent(UActorComponent*)", Component); }

    void UpdateAllReplicatedComponents() { NativeCall<void>(this, "AActor.UpdateAllReplicatedComponents()"); }

    void AddInstanceComponent(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.AddInstanceComponent(UActorComponent*)", Component); }

    UActorComponent* FindComponentByClass(const TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, const TSubclassOf<UActorComponent>>(this, "AActor.FindComponentByClass(TSubclassOf<UActorComponent>)", ComponentClass); }

    UActorComponent* GetComponentByClass(TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, TSubclassOf<UActorComponent>>(this, "AActor.GetComponentByClass(TSubclassOf<UActorComponent>)", ComponentClass); }

    TArray<UActorComponent*, TSizedDefaultAllocator<32> >* K2_GetComponentsByClass(TArray<UActorComponent*, TSizedDefaultAllocator<32> >* result, TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TSubclassOf<UActorComponent>>(this, "AActor.K2_GetComponentsByClass(TSubclassOf<UActorComponent>)", result, ComponentClass); }

    TArray<UActorComponent*, TSizedDefaultAllocator<32> >* GetComponentsByTag(TArray<UActorComponent*, TSizedDefaultAllocator<32> >* result, TSubclassOf<UActorComponent> ComponentClass, FName Tag) { return NativeCall<TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TSubclassOf<UActorComponent>, FName>(this, "AActor.GetComponentsByTag(TSubclassOf<UActorComponent>,FName)", result, ComponentClass, Tag); }

    UActorComponent* FindComponentByInterface(const TSubclassOf<UInterface> Interface) { return NativeCall<UActorComponent*, const TSubclassOf<UInterface>>(this, "AActor.FindComponentByInterface(TSubclassOf<UInterface>)", Interface); }

    TArray<UActorComponent*, TSizedDefaultAllocator<32> >* GetComponentsByInterface(TArray<UActorComponent*, TSizedDefaultAllocator<32> >* result, TSubclassOf<UInterface> Interface) { return NativeCall<TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TSubclassOf<UInterface>>(this, "AActor.GetComponentsByInterface(TSubclassOf<UInterface>)", result, Interface); }

    void DisableComponentsSimulatePhysics() { NativeCall<void>(this, "AActor.DisableComponentsSimulatePhysics()"); }

    void PostSpawnInitialize(const UE::Math::TTransform<double>* UserSpawnTransform, AActor* InOwner, APawn* InInstigator, bool bRemoteOwned, bool bNoFail, bool bDeferConstruction, bool bDeferBeginPlay, bool bPrimalDeferConstruction, ESpawnActorScaleMethod TransformScaleMethod) { NativeCall<void, const UE::Math::TTransform<double>*, AActor*, APawn*, bool, bool, bool, bool, bool, ESpawnActorScaleMethod>(this, "AActor.PostSpawnInitialize(UE::Math::TTransform<double>&,AActor*,APawn*,bool,bool,bool,bool,bool,ESpawnActorScaleMethod)", UserSpawnTransform, InOwner, InInstigator, bRemoteOwned, bNoFail, bDeferConstruction, bDeferBeginPlay, bPrimalDeferConstruction, TransformScaleMethod); }

    bool BPClientHandleNetExecCommand(FName CommandName, const FBPNetExecParams* ExecParams, APlayerController* ForPC) { return NativeCall<bool, FName, const FBPNetExecParams*, APlayerController*>(this, "AActor.BPClientHandleNetExecCommand(FName,FBPNetExecParams&,APlayerController*)", CommandName, ExecParams, ForPC); }

    void MulticastDrawDebugLine(const UE::Math::TVector<double>* LineStart, const UE::Math::TVector<double>* LineEnd, FLinearColor* LineColor, float Duration, float Thickness, bool enableInShipping) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, FLinearColor*, float, float, bool>(this, "AActor.MulticastDrawDebugLine(UE::Math::TVector<double>,UE::Math::TVector<double>,FLinearColor,float,float,bool)", LineStart, LineEnd, LineColor, Duration, Thickness, enableInShipping); }

    void MulticastDrawDebugPoint(const UE::Math::TVector<double>* Position, float Size, FLinearColor* PointColor, float Duration, bool enableInShipping) { NativeCall<void, const UE::Math::TVector<double>*, float, FLinearColor*, float, bool>(this, "AActor.MulticastDrawDebugPoint(UE::Math::TVector<double>,float,FLinearColor,float,bool)", Position, Size, PointColor, Duration, enableInShipping); }

    void MulticastDrawDebugSphere(const UE::Math::TVector<double>* Center, float Radius, int Segments, FLinearColor* LineColor, float Duration, bool enableInShipping) { NativeCall<void, const UE::Math::TVector<double>*, float, int, FLinearColor*, float, bool>(this, "AActor.MulticastDrawDebugSphere(UE::Math::TVector<double>,float,int,FLinearColor,float,bool)", Center, Radius, Segments, LineColor, Duration, enableInShipping); }

    void ReceiveHit(UPrimitiveComponent* MyComp, AActor* Other, UPrimitiveComponent* OtherComp, bool bSelfMoved, UE::Math::TVector<double>* HitLocation, UE::Math::TVector<double>* HitNormal, UE::Math::TVector<double>* NormalImpulse, const FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, AActor*, UPrimitiveComponent*, bool, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*, const FHitResult*>(this, "AActor.ReceiveHit(UPrimitiveComponent*,AActor*,UPrimitiveComponent*,bool,UE::Math::TVector<double>,UE::Math::TVector<double>,UE::Math::TVector<double>,FHitResult&)", MyComp, Other, OtherComp, bSelfMoved, HitLocation, HitNormal, NormalImpulse, Hit); }

    static void StaticRegisterNativesAActor() { NativeCall<void>(nullptr, "AActor.StaticRegisterNativesAActor()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "AActor.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void FinishSpawning(const UE::Math::TTransform<double>* UserTransform, bool bIsDefaultTransform, const FComponentInstanceDataCache* InstanceDataCache, ESpawnActorScaleMethod TransformScaleMethod) { NativeCall<void, const UE::Math::TTransform<double>*, bool, const FComponentInstanceDataCache*, ESpawnActorScaleMethod>(this, "AActor.FinishSpawning(UE::Math::TTransform<double>&,bool,FComponentInstanceDataCache*,ESpawnActorScaleMethod)", UserTransform, bIsDefaultTransform, InstanceDataCache, TransformScaleMethod); }

    void PostActorConstruction() { NativeCall<void>(this, "AActor.PostActorConstruction()"); }

    void SetReplicates(bool bInReplicates) { NativeCall<void, bool>(this, "AActor.SetReplicates(bool)", bInReplicates); }

    void SetReplicateMovement(bool bInReplicateMovement) { NativeCall<void, bool>(this, "AActor.SetReplicateMovement(bool)", bInReplicateMovement); }

    void CopyRemoteRoleFrom(const AActor* CopyFromActor) { NativeCall<void, const AActor*>(this, "AActor.CopyRemoteRoleFrom(AActor*)", CopyFromActor); }

    void PostNetInit() { NativeCall<void>(this, "AActor.PostNetInit()"); }

    void SwapRoles() { NativeCall<void>(this, "AActor.SwapRoles()"); }

    void DispatchBeginPlay(bool bFromLevelStreaming) { NativeCall<void, bool>(this, "AActor.DispatchBeginPlay(bool)", bFromLevelStreaming); }

    void BeginPlay() { NativeCall<void>(this, "AActor.BeginPlay()"); }

    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.EnableInput(APlayerController*)", PlayerController); }

    void CreateInputComponent(TSubclassOf<UInputComponent> InputComponentToCreate) { NativeCall<void, TSubclassOf<UInputComponent>>(this, "AActor.CreateInputComponent(TSubclassOf<UInputComponent>)", InputComponentToCreate); }

    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.DisableInput(APlayerController*)", PlayerController); }

    float GetInputAxisValue(const FName InputAxisName) { return NativeCall<float, const FName>(this, "AActor.GetInputAxisValue(FName)", InputAxisName); }

    bool SetActorLocation(const UE::Math::TVector<double>* NewLocation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { return NativeCall<bool, const UE::Math::TVector<double>*, bool, FHitResult*, ETeleportType>(this, "AActor.SetActorLocation(UE::Math::TVector<double>&,bool,FHitResult*,ETeleportType)", NewLocation, bSweep, OutSweepHitResult, Teleport); }

    bool SetActorRotation(UE::Math::TRotator<double>* NewRotation, ETeleportType Teleport) { return NativeCall<bool, UE::Math::TRotator<double>*, ETeleportType>(this, "AActor.SetActorRotation(UE::Math::TRotator<double>,ETeleportType)", NewRotation, Teleport); }

    bool SetActorLocationAndRotation(UE::Math::TVector<double>* NewLocation, UE::Math::TRotator<double>* NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { return NativeCall<bool, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "AActor.SetActorLocationAndRotation(UE::Math::TVector<double>,UE::Math::TRotator<double>,bool,FHitResult*,ETeleportType)", NewLocation, NewRotation, bSweep, OutSweepHitResult, Teleport); }

    // TODO: Might need manual analysis

    bool SetActorLocationAndRotation(UE::Math::TVector<double>* NewLocation, const UE::Math::TQuat<double>* NewRotation, __int64 bSweep) { return NativeCall<bool, UE::Math::TVector<double>*, const UE::Math::TQuat<double>*, __int64>(this, "AActor.SetActorLocationAndRotation(UE::Math::TVector<double>&,UE::Math::TQuat<double>&,__int64)", NewLocation, NewRotation, bSweep); }

    bool SetActorTransform(const UE::Math::TTransform<double>* NewTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { return NativeCall<bool, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "AActor.SetActorTransform(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", NewTransform, bSweep, OutSweepHitResult, Teleport); }

    void SetActorRelativeLocation(UE::Math::TVector<double>* NewRelativeLocation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TVector<double>*, bool, FHitResult*, ETeleportType>(this, "AActor.SetActorRelativeLocation(UE::Math::TVector<double>,bool,FHitResult*,ETeleportType)", NewRelativeLocation, bSweep, OutSweepHitResult, Teleport); }

    void SetActorRelativeRotation(UE::Math::TRotator<double>* NewRelativeRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, UE::Math::TRotator<double>*, bool, FHitResult*, ETeleportType>(this, "AActor.SetActorRelativeRotation(UE::Math::TRotator<double>,bool,FHitResult*,ETeleportType)", NewRelativeRotation, bSweep, OutSweepHitResult, Teleport); }

    void SetActorRelativeTransform(const UE::Math::TTransform<double>* NewRelativeTransform, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport) { NativeCall<void, const UE::Math::TTransform<double>*, bool, FHitResult*, ETeleportType>(this, "AActor.SetActorRelativeTransform(UE::Math::TTransform<double>&,bool,FHitResult*,ETeleportType)", NewRelativeTransform, bSweep, OutSweepHitResult, Teleport); }

    void SetActorRelativeScale3D(UE::Math::TVector<double>* NewRelativeScale) { NativeCall<void, UE::Math::TVector<double>*>(this, "AActor.SetActorRelativeScale3D(UE::Math::TVector<double>)", NewRelativeScale); }

    void SetActorHiddenInGame(bool bNewHidden) { NativeCall<void, bool>(this, "AActor.SetActorHiddenInGame(bool)", bNewHidden); }

    void SetActorEnableCollision(bool bNewActorEnableCollision) { NativeCall<void, bool>(this, "AActor.SetActorEnableCollision(bool)", bNewActorEnableCollision); }

    bool Destroy(bool bNetForce, bool bShouldModifyLevel) { return NativeCall<bool, bool, bool>(this, "AActor.Destroy(bool,bool)", bNetForce, bShouldModifyLevel); }

    bool SetRootComponent(USceneComponent* NewRootComponent) { return NativeCall<bool, USceneComponent*>(this, "AActor.SetRootComponent(USceneComponent*)", NewRootComponent); }

    void GetActorBounds(bool bOnlyCollidingComponents, UE::Math::TVector<double>* Origin, UE::Math::TVector<double>* BoxExtent, bool bIncludeFromChildActors) { NativeCall<void, bool, UE::Math::TVector<double>*, UE::Math::TVector<double>*, bool>(this, "AActor.GetActorBounds(bool,UE::Math::TVector<double>&,UE::Math::TVector<double>&,bool)", bOnlyCollidingComponents, Origin, BoxExtent, bIncludeFromChildActors); }

    AWorldSettings* GetWorldSettings() { return NativeCall<AWorldSettings*>(this, "AActor.GetWorldSettings()"); }

    ENetMode InternalGetNetMode() { return NativeCall<ENetMode>(this, "AActor.InternalGetNetMode()"); }

    UNetDriver* GetNetDriver() { return NativeCall<UNetDriver*>(this, "AActor.GetNetDriver()"); }

    void SetNetDriverName(FName NewNetDriverName) { NativeCall<void, FName>(this, "AActor.SetNetDriverName(FName)", NewNetDriverName); }

    int GetFunctionCallspace(UFunction* Function, FFrame* Stack) { return NativeCall<int, UFunction*, FFrame*>(this, "AActor.GetFunctionCallspace(UFunction*,FFrame*)", Function, Stack); }

    bool CallRemoteFunction(UFunction* Function, void* Parameters, FOutParmRec* OutParms, FFrame* Stack) { return NativeCall<bool, UFunction*, void*, FOutParmRec*, FFrame*>(this, "AActor.CallRemoteFunction(UFunction*,void*,FOutParmRec*,FFrame*)", Function, Parameters, OutParms, Stack); }

    void DispatchPhysicsCollisionHit(const FRigidBodyCollisionInfo* MyInfo, const FRigidBodyCollisionInfo* OtherInfo, const FCollisionImpactData* RigidCollisionData) { NativeCall<void, const FRigidBodyCollisionInfo*, const FRigidBodyCollisionInfo*, const FCollisionImpactData*>(this, "AActor.DispatchPhysicsCollisionHit(FRigidBodyCollisionInfo&,FRigidBodyCollisionInfo&,FCollisionImpactData&)", MyInfo, OtherInfo, RigidCollisionData); }

    bool IsSelectionChild() { return NativeCall<bool>(this, "AActor.IsSelectionChild()"); }

    AActor* GetSelectionParent() { return NativeCall<AActor*>(this, "AActor.GetSelectionParent()"); }

    AActor* GetRootSelectionParent() { return NativeCall<AActor*>(this, "AActor.GetRootSelectionParent()"); }

    bool IsActorOrSelectionParentSelected() { return NativeCall<bool>(this, "AActor.IsActorOrSelectionParentSelected()"); }

    void PushSelectionToProxies() { NativeCall<void>(this, "AActor.PushSelectionToProxies()"); }

    bool IsChildActor() { return NativeCall<bool>(this, "AActor.IsChildActor()"); }

    UChildActorComponent* GetParentComponent() { return NativeCall<UChildActorComponent*>(this, "AActor.GetParentComponent()"); }

    void GetAllChildActors(TArray<AActor*, TSizedDefaultAllocator<32> >* ChildActors, bool bIncludeDescendants) { NativeCall<void, TArray<AActor*, TSizedDefaultAllocator<32> >*, bool>(this, "AActor.GetAllChildActors(TArray<AActor*,TSizedDefaultAllocator<32>>&,bool)", ChildActors, bIncludeDescendants); }

    void UnregisterAllComponents(bool bForReregister) { NativeCall<void, bool>(this, "AActor.UnregisterAllComponents(bool)", bForReregister); }

    void RegisterAllComponents() { NativeCall<void>(this, "AActor.RegisterAllComponents()"); }

    bool IncrementalRegisterComponents(int NumComponentsToRegister, FRegisterComponentContext* Context) { return NativeCall<bool, int, FRegisterComponentContext*>(this, "AActor.IncrementalRegisterComponents(int,FRegisterComponentContext*)", NumComponentsToRegister, Context); }

    void MarkComponentsAsPendingKill(__int64 a2) { NativeCall<void, __int64>(this, "AActor.MarkComponentsAsPendingKill()", a2); }

    void ReregisterAllComponents(bool a2) { NativeCall<void, bool>(this, "AActor.ReregisterAllComponents()", a2); }

    void UpdateComponentTransforms() { NativeCall<void>(this, "AActor.UpdateComponentTransforms()"); }

    void MarkComponentsRenderStateDirty() { NativeCall<void>(this, "AActor.MarkComponentsRenderStateDirty()"); }

    void InitializeComponents() { NativeCall<void>(this, "AActor.InitializeComponents()"); }

    void UninitializeComponents(const EEndPlayReason::Type* EndPlayReason) { NativeCall<void, const EEndPlayReason::Type*>(this, "AActor.UninitializeComponents(EEndPlayReason::Type&)", EndPlayReason); }

    bool ActorLineTraceSingle(FHitResult* OutHit, const UE::Math::TVector<double>* Start, const UE::Math::TVector<double>* End, ECollisionChannel TraceChannel, const FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, ECollisionChannel, const FCollisionQueryParams*>(this, "AActor.ActorLineTraceSingle(FHitResult&,UE::Math::TVector<double>&,UE::Math::TVector<double>&,ECollisionChannel,FCollisionQueryParams&)", OutHit, Start, End, TraceChannel, Params); }

    void SetLifeSpan(float InLifespan) { NativeCall<void, float>(this, "AActor.SetLifeSpan(float)", InLifespan); }

    float GetLifeSpan() { return NativeCall<float>(this, "AActor.GetLifeSpan()"); }

    void PreInitializeComponents() { NativeCall<void>(this, "AActor.PreInitializeComponents()"); }

    float GetActorTimeDilation() { return NativeCall<float>(this, "AActor.GetActorTimeDilation()"); }

    float GetDistanceTo(const AActor* OtherActor) { return NativeCall<float, const AActor*>(this, "AActor.GetDistanceTo(AActor*)", OtherActor); }

    bool IsHLODRelevant() { return NativeCall<bool>(this, "AActor.IsHLODRelevant()"); }

    void SetLODParent(UPrimitiveComponent* InLODParent, float InParentDrawDistance) { NativeCall<void, UPrimitiveComponent*, float>(this, "AActor.SetLODParent(UPrimitiveComponent*,float)", InLODParent, InParentDrawDistance); }

    int GetRayTracingGroupId() { return NativeCall<int>(this, "AActor.GetRayTracingGroupId()"); }

    void SetCanBeDamaged(bool bInCanBeDamaged) { NativeCall<void, bool>(this, "AActor.SetCanBeDamaged(bool)", bInCanBeDamaged); }

    void RealtimeThrottledTick_Implementation(long double DeltaTime) { NativeCall<void, long double>(this, "AActor.RealtimeThrottledTick_Implementation(double)", DeltaTime); }

    void DestroyConstructedComponents() { NativeCall<void>(this, "AActor.DestroyConstructedComponents()"); }

    bool ExecuteConstruction(const UE::Math::TTransform<double>* Transform, const FRotationConversionCache* TransformRotationCache, const FComponentInstanceDataCache* InstanceDataCache, bool bIsDefaultTransform, ESpawnActorScaleMethod TransformScaleMethod) { return NativeCall<bool, const UE::Math::TTransform<double>*, const FRotationConversionCache*, const FComponentInstanceDataCache*, bool, ESpawnActorScaleMethod>(this, "AActor.ExecuteConstruction(UE::Math::TTransform<double>&,FRotationConversionCache*,FComponentInstanceDataCache*,bool,ESpawnActorScaleMethod)", Transform, TransformRotationCache, InstanceDataCache, bIsDefaultTransform, TransformScaleMethod); }

    void ProcessUserConstructionScript() { NativeCall<void>(this, "AActor.ProcessUserConstructionScript()"); }

    UActorComponent* CreateComponentFromTemplate(UActorComponent* Template, const FName InName) { return NativeCall<UActorComponent*, UActorComponent*, const FName>(this, "AActor.CreateComponentFromTemplate(UActorComponent*,FName)", Template, InName); }

    UActorComponent* CreateComponentFromTemplateData(const FBlueprintCookedComponentInstancingData* TemplateData, const FName InName) { return NativeCall<UActorComponent*, const FBlueprintCookedComponentInstancingData*, const FName>(this, "AActor.CreateComponentFromTemplateData(FBlueprintCookedComponentInstancingData*,FName)", TemplateData, InName); }

    UActorComponent* AddComponent(FName TemplateName, bool bManualAttachment, const UE::Math::TTransform<double>* RelativeTransform, const UObject* ComponentTemplateContext, bool bDeferredFinish) { return NativeCall<UActorComponent*, FName, bool, const UE::Math::TTransform<double>*, const UObject*, bool>(this, "AActor.AddComponent(FName,bool,UE::Math::TTransform<double>&,UObject*,bool)", TemplateName, bManualAttachment, RelativeTransform, ComponentTemplateContext, bDeferredFinish); }

    void FinishAddComponent(UActorComponent* NewActorComp, bool bManualAttachment, const UE::Math::TTransform<double>* RelativeTransform) { NativeCall<void, UActorComponent*, bool, const UE::Math::TTransform<double>*>(this, "AActor.FinishAddComponent(UActorComponent*,bool,UE::Math::TTransform<double>&)", NewActorComp, bManualAttachment, RelativeTransform); }

    void CheckComponentInstanceName(const FName InName) { NativeCall<void, const FName>(this, "AActor.CheckComponentInstanceName(FName)", InName); }

    void PostCreateBlueprintComponent(UActorComponent* NewActorComp) { NativeCall<void, UActorComponent*>(this, "AActor.PostCreateBlueprintComponent(UActorComponent*)", NewActorComp); }

    float GetNetPriority(const UE::Math::TVector<double>* ViewPos, const UE::Math::TVector<double>* ViewDir, AActor* Viewer, AActor* ViewTarget, UActorChannel* InChannel, float Time, bool bLowBandwidth) { return NativeCall<float, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, AActor*, AActor*, UActorChannel*, float, bool>(this, "AActor.GetNetPriority(UE::Math::TVector<double>&,UE::Math::TVector<double>&,AActor*,AActor*,UActorChannel*,float,bool)", ViewPos, ViewDir, Viewer, ViewTarget, InChannel, Time, bLowBandwidth); }

    float GetReplayPriority(const UE::Math::TVector<double>* ViewPos, const UE::Math::TVector<double>* ViewDir, AActor* Viewer, AActor* ViewTarget, UActorChannel* const InChannel, float Time) { return NativeCall<float, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, AActor*, AActor*, UActorChannel* const, float>(this, "AActor.GetReplayPriority(UE::Math::TVector<double>&,UE::Math::TVector<double>&,AActor*,AActor*,UActorChannel*const,float)", ViewPos, ViewDir, Viewer, ViewTarget, InChannel, Time); }

    void PreNetReceive() { NativeCall<void>(this, "AActor.PreNetReceive()"); }

    void PostNetReceive() { NativeCall<void>(this, "AActor.PostNetReceive()"); }

    void OnRep_ReplicatedMovement() { NativeCall<void>(this, "AActor.OnRep_ReplicatedMovement()"); }

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "AActor.PostNetReceiveLocationAndRotation()"); }

    void PostNetReceivePhysicState() { NativeCall<void>(this, "AActor.PostNetReceivePhysicState()"); }

    void SyncReplicatedPhysicsSimulation() { NativeCall<void>(this, "AActor.SyncReplicatedPhysicsSimulation()"); }

    bool IsWithinNetRelevancyDistance(const UE::Math::TVector<double>* SrcLocation) { return NativeCall<bool, const UE::Math::TVector<double>*>(this, "AActor.IsWithinNetRelevancyDistance(UE::Math::TVector<double>&)", SrcLocation); }

    bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const UE::Math::TVector<double>* SrcLocation) { return NativeCall<bool, const AActor*, const AActor*, const UE::Math::TVector<double>*>(this, "AActor.IsNetRelevantFor(AActor*,AActor*,UE::Math::TVector<double>&)", RealViewer, ViewTarget, SrcLocation); }

    bool IsReplayRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const UE::Math::TVector<double>* SrcLocation, const float CullDistanceOverrideSq) { return NativeCall<bool, const AActor*, const AActor*, const UE::Math::TVector<double>*, const float>(this, "AActor.IsReplayRelevantFor(AActor*,AActor*,UE::Math::TVector<double>&,float)", RealViewer, ViewTarget, SrcLocation, CullDistanceOverrideSq); }

    void GatherCurrentMovement() { NativeCall<void>(this, "AActor.GatherCurrentMovement()"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "AActor.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void GetReplicatedCustomConditionState(FCustomPropertyConditionState* OutActiveState) { NativeCall<void, FCustomPropertyConditionState*>(this, "AActor.GetReplicatedCustomConditionState(FCustomPropertyConditionState&)", OutActiveState); }

    bool ReplicateSubobjects(UActorChannel* Channel, FOutBunch* Bunch, FReplicationFlags* RepFlags) { return NativeCall<bool, UActorChannel*, FOutBunch*, FReplicationFlags*>(this, "AActor.ReplicateSubobjects(UActorChannel*,FOutBunch*,FReplicationFlags*)", Channel, Bunch, RepFlags); }

    ELifetimeCondition AllowActorComponentToReplicate(const UActorComponent* ComponentToReplicate) { return NativeCall<ELifetimeCondition, const UActorComponent*>(this, "AActor.AllowActorComponentToReplicate(UActorComponent*)", ComponentToReplicate); }

    void AddComponentForReplication(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.AddComponentForReplication(UActorComponent*)", Component); }

    void BuildReplicatedComponentsInfo() { NativeCall<void>(this, "AActor.BuildReplicatedComponentsInfo()"); }

    void GetSubobjectsWithStableNamesForNetworking(TArray<UObject*, TSizedDefaultAllocator<32> >* ObjList) { NativeCall<void, TArray<UObject*, TSizedDefaultAllocator<32> >*>(this, "AActor.GetSubobjectsWithStableNamesForNetworking(TArray<UObject*,TSizedDefaultAllocator<32>>&)", ObjList); }

    void OnSubobjectCreatedFromReplication(UObject* NewSubobject) { NativeCall<void, UObject*>(this, "AActor.OnSubobjectCreatedFromReplication(UObject*)", NewSubobject); }

    void OnSubobjectDestroyFromReplication(UObject* Subobject) { NativeCall<void, UObject*>(this, "AActor.OnSubobjectDestroyFromReplication(UObject*)", Subobject); }

    bool IsNameStableForNetworking() { return NativeCall<bool>(this, "AActor.IsNameStableForNetworking()"); }

    void Stasis() { NativeCall<void>(this, "AActor.Stasis()"); }

    void ResetSpatialComponent() { NativeCall<void>(this, "AActor.ResetSpatialComponent()"); }

    void Unstasis() { NativeCall<void>(this, "AActor.Unstasis()"); }

    void ClearNetworkSpatializationParent() { NativeCall<void>(this, "AActor.ClearNetworkSpatializationParent()"); }

    void SetNetworkSpatializationParent(AActor* NewParent) { NativeCall<void, AActor*>(this, "AActor.SetNetworkSpatializationParent(AActor*)", NewParent); }

    void PostInitializeComponents() { NativeCall<void>(this, "AActor.PostInitializeComponents()"); }

    //UMovementComponent* FindComponentByClass<class UMovementComponent>() { return NativeCall<UMovementComponent*>(this, "AActor.FindComponentByClass<class UMovementComponent>()"); }

    bool IsInOrOwnedBy(const UObject* SomeOuter) { return NativeCall<bool, const UObject*>(this, "AActor.IsInOrOwnedBy(UObject*)", SomeOuter); }

    UActorComponent* GetComponentByCustomTag(FName TheTag) { return NativeCall<UActorComponent*, FName>(this, "AActor.GetComponentByCustomTag(FName)", TheTag); }

    UPrimitiveComponent* GetVisibleComponentByClass(TSubclassOf<UPrimitiveComponent> ComponentClass) { return NativeCall<UPrimitiveComponent*, TSubclassOf<UPrimitiveComponent>>(this, "AActor.GetVisibleComponentByClass(TSubclassOf<UPrimitiveComponent>)", ComponentClass); }

    UPrimitiveComponent* GetVisibleUnhiddenComponentByClass(TSubclassOf<UPrimitiveComponent> ComponentClass) { return NativeCall<UPrimitiveComponent*, TSubclassOf<UPrimitiveComponent>>(this, "AActor.GetVisibleUnhiddenComponentByClass(TSubclassOf<UPrimitiveComponent>)", ComponentClass); }

    TArray<UActorComponent*, TSizedDefaultAllocator<32> >* GetComponentsByCustomTag(TArray<UActorComponent*, TSizedDefaultAllocator<32> >* result, FName TheTag) { return NativeCall<TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, FName>(this, "AActor.GetComponentsByCustomTag(FName)", result, TheTag); }

    void SendExecCommand(FName CommandName, const FNetExecParams* ExecParams, bool bIsReliable) { NativeCall<void, FName, const FNetExecParams*, bool>(this, "AActor.SendExecCommand(FName,FNetExecParams&,bool)", CommandName, ExecParams, bIsReliable); }

    void ServerSendExecCommandToEveryone(FName CommandName, const FBPNetExecParams* ExecParams, bool bIsReliable, bool bForceSendToLocalPlayer, bool bIgnoreRelevancy) { NativeCall<void, FName, const FBPNetExecParams*, bool, bool, bool>(this, "AActor.ServerSendExecCommandToEveryone(FName,FBPNetExecParams&,bool,bool,bool)", CommandName, ExecParams, bIsReliable, bForceSendToLocalPlayer, bIgnoreRelevancy); }

    void ServerSendSimpleExecCommandToEveryone(FName CommandName, bool bIsReliable, bool bForceSendToLocalPlayer, bool bIgnoreRelevancy) { NativeCall<void, FName, bool, bool, bool>(this, "AActor.ServerSendSimpleExecCommandToEveryone(FName,bool,bool,bool)", CommandName, bIsReliable, bForceSendToLocalPlayer, bIgnoreRelevancy); }

    void ServerSendExecCommandToPlayer(APrimalPlayerController* aPC, FName CommandName, const FBPNetExecParams* ExecParams, bool bIsReliable, bool bForceSendToLocalPlayer, bool bIgnoreRelevancy) { NativeCall<void, APrimalPlayerController*, FName, const FBPNetExecParams*, bool, bool, bool>(this, "AActor.ServerSendExecCommandToPlayer(APrimalPlayerController*,FName,FBPNetExecParams&,bool,bool,bool)", aPC, CommandName, ExecParams, bIsReliable, bForceSendToLocalPlayer, bIgnoreRelevancy); }

    void NetActorSpawnActor_Implementation(TSubclassOf<AActor> ActorClass, UE::Math::TVector<double>* AtLoc, UE::Math::TRotator<double>* AtRot, bool bIgnoreOnDedicatedServer, USceneComponent* AttachToComponent, FName BoneName, AActor* SpawnOwner) { NativeCall<void, TSubclassOf<AActor>, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, USceneComponent*, FName, AActor*>(this, "AActor.NetActorSpawnActor_Implementation(TSubclassOf<AActor>,UE::Math::TVector<double>,UE::Math::TRotator<double>,bool,USceneComponent*,FName,AActor*)", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }

    void NetActorSpawnActorUnreliable_Implementation(TSubclassOf<AActor> ActorClass, UE::Math::TVector<double>* AtLoc, UE::Math::TRotator<double>* AtRot, bool bIgnoreOnDedicatedServer, USceneComponent* AttachToComponent, FName BoneName, AActor* SpawnOwner) { NativeCall<void, TSubclassOf<AActor>, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, USceneComponent*, FName, AActor*>(this, "AActor.NetActorSpawnActorUnreliable_Implementation(TSubclassOf<AActor>,UE::Math::TVector<double>,UE::Math::TRotator<double>,bool,USceneComponent*,FName,AActor*)", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }

    void ActorPlaySound_Implementation(USoundBase* SoundAsset, bool bAttach, FName BoneName, UE::Math::TVector<double>* LocOffset) { NativeCall<void, USoundBase*, bool, FName, UE::Math::TVector<double>*>(this, "AActor.ActorPlaySound_Implementation(USoundBase*,bool,FName,UE::Math::TVector<double>)", SoundAsset, bAttach, BoneName, LocOffset); }

    void StopActorSound(USoundBase* SoundAsset, float FadeOutTime) { NativeCall<void, USoundBase*, float>(this, "AActor.StopActorSound(USoundBase*,float)", SoundAsset, FadeOutTime); }

    APlayerController* GetOwnerController() { return NativeCall<APlayerController*>(this, "AActor.GetOwnerController()"); }

    bool IsOwnedOrControlledBy(const AActor* TestOwner) { return NativeCall<bool, const AActor*>(this, "AActor.IsOwnedOrControlledBy(AActor*)", TestOwner); }

    void MulticastDrawDebugLine_Implementation(const UE::Math::TVector<double>* TextLocation, const FString* Text, AActor* TestBaseActor) { NativeCall<void, const UE::Math::TVector<double>*, const FString*, AActor*>(this, "AActor.MulticastDrawDebugLine_Implementation(UE::Math::TVector<double>,UE::Math::TVector<double>,FLinearColor,float,float,bool)", TextLocation, Text, TestBaseActor); }

    void MulticastDrawDebugLineTraceHitResult_Implementation(const FHitResult* Hit, UE::Math::TVector<double>* TraceStart, UE::Math::TVector<double>* TraceEnd) { NativeCall<void, const FHitResult*, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "AActor.MulticastDrawDebugLineTraceHitResult_Implementation(FHitResult,UE::Math::TVector<double>,UE::Math::TVector<double>,FLinearColor,FLinearColor,float,float,bool,FLinearColor,float,float,bool)", Hit, TraceStart, TraceEnd); }

    //UPathFollowingComponent* FindComponentByClass<class UPathFollowingComponent>() { return NativeCall<UPathFollowingComponent*>(this, "AActor.FindComponentByClass<class UPathFollowingComponent>()"); }

};


struct AVolume : AActor // : ABrush

{

    // Fields


    //TArray<FBoxOptimization, TSizedDefaultAllocator<32> >& BoxOptimizationField() { return *GetNativePointerField<TArray<FBoxOptimization, TSizedDefaultAllocator<32> >*>(this, "AVolume.BoxOptimization"); }


    // Bitfields


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AVolume.GetPrivateStaticClass()"); }

    static void StaticRegisterNativesAVolume() { NativeCall<void>(nullptr, "AVolume.StaticRegisterNativesAVolume()"); }

    void PreInitializeComponents() { NativeCall<void>(this, "AVolume.PreInitializeComponents()"); }

    void PreRegisterAllComponents() { NativeCall<void>(this, "AVolume.PreRegisterAllComponents()"); }

    char EncompassesPoint(UE::Math::TVector<double>* Point, float SphereRadius, float* OutDistanceToPoint, float* MaxDistanceLimit) { return NativeCall<char, UE::Math::TVector<double>*, float, float*, float*>(this, "AVolume.EncompassesPoint(UE::Math::TVector<double>,float,float*,float*)", Point, SphereRadius, OutDistanceToPoint, MaxDistanceLimit); }

};


struct ABiomeZoneVolume : AVolume

{

    // Fields


    FString& BiomeZoneNameField() { return *GetNativePointerField<FString*>(this, "ABiomeZoneVolume.BiomeZoneName"); }

    float& FinalTemperatureMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.FinalTemperatureMultiplier"); }

    float& FinalTemperatureExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.FinalTemperatureExponent"); }

    float& FinalTemperatureAdditionField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.FinalTemperatureAddition"); }

    float& PreOffsetTemperatureMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.PreOffsetTemperatureMultiplier"); }

    float& PreOffsetTemperatureExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.PreOffsetTemperatureExponent"); }

    float& PreOffsetTemperatureAdditionField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.PreOffsetTemperatureAddition"); }

    float& AboveTemperatureOffsetThresholdField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AboveTemperatureOffsetThreshold"); }

    float& AboveTemperatureOffsetMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AboveTemperatureOffsetMultiplier"); }

    float& AboveTemperatureOffsetExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AboveTemperatureOffsetExponent"); }

    float& BelowTemperatureOffsetThresholdField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.BelowTemperatureOffsetThreshold"); }

    float& BelowTemperatureOffsetMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.BelowTemperatureOffsetMultiplier"); }

    float& BelowTemperatureOffsetExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.BelowTemperatureOffsetExponent"); }

    float& AbsoluteTemperatureOverrideField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AbsoluteTemperatureOverride"); }

    float& AbsoluteMaxTemperatureField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AbsoluteMaxTemperature"); }

    float& AbsoluteMinTemperatureField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AbsoluteMinTemperature"); }

    float& EggRangeMaximumNumberOverrideField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.EggRangeMaximumNumberOverride"); }

    int& EggMaximumNumberOverrideField() { return *GetNativePointerField<int*>(this, "ABiomeZoneVolume.EggMaximumNumberOverride"); }

    float& EggChanceToSpawnOverrideField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.EggChanceToSpawnOverride"); }

    float& EggIntervalUnstasisChanceToSpawnOverrideField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.EggIntervalUnstasisChanceToSpawnOverride"); }

    TArray<TSubclassOf<APrimalDinoCharacter>, TSizedDefaultAllocator<32> >& OverrideEggLimitsDinoClassesField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalDinoCharacter>, TSizedDefaultAllocator<32> >*>(this, "ABiomeZoneVolume.OverrideEggLimitsDinoClasses"); }

    int& BiomeZonePriorityField() { return *GetNativePointerField<int*>(this, "ABiomeZoneVolume.BiomeZonePriority"); }

    float& MaxMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.MaxMultiplier"); }

    float& AbsoluteWindOverrideField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AbsoluteWindOverride"); }

    float& PreOffsetWindMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.PreOffsetWindMultiplier"); }

    float& PreOffsetWindExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.PreOffsetWindExponent"); }

    float& PreOffsetWindAdditionField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.PreOffsetWindAddition"); }

    float& AboveWindOffsetThresholdField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AboveWindOffsetThreshold"); }

    float& AboveWindOffsetMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AboveWindOffsetMultiplier"); }

    float& AboveWindOffsetExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.AboveWindOffsetExponent"); }

    float& BelowWindOffsetThresholdField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.BelowWindOffsetThreshold"); }

    float& BelowWindOffsetMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.BelowWindOffsetMultiplier"); }

    float& BelowWindOffsetExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.BelowWindOffsetExponent"); }

    float& FinalWindMultiplierField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.FinalWindMultiplier"); }

    float& FinalWindExponentField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.FinalWindExponent"); }

    float& FinalWindAdditionField() { return *GetNativePointerField<float*>(this, "ABiomeZoneVolume.FinalWindAddition"); }

    TArray<float, TSizedDefaultAllocator<32> >& BiomeCustomDatasField() { return *GetNativePointerField<TArray<float, TSizedDefaultAllocator<32> >*>(this, "ABiomeZoneVolume.BiomeCustomDatas"); }

    FieldArray<float, 12> StatusAdjustmentRateMultipliersPositiveField() { return { this, "ABiomeZoneVolume.StatusAdjustmentRateMultipliersPositive" }; }

    FieldArray<float, 12> StatusAdjustmentRateMultipliersNegativeField() { return { this, "ABiomeZoneVolume.StatusAdjustmentRateMultipliersNegative" }; }

    bool& bStatusAdjustRateValuesField() { return *GetNativePointerField<bool*>(this, "ABiomeZoneVolume.bStatusAdjustRateValues"); }

    TSoftClassPtr<APrimalBuff>& BuffToGiveField() { return *GetNativePointerField<TSoftClassPtr<APrimalBuff>*>(this, "ABiomeZoneVolume.BuffToGive"); }

    TSoftClassPtr<APrimalBuff>& BuffToPreventActiveUseField() { return *GetNativePointerField<TSoftClassPtr<APrimalBuff>*>(this, "ABiomeZoneVolume.BuffToPreventActiveUse"); }

    USoundBase*& OverrideCombatMusicDayField() { return *GetNativePointerField<USoundBase**>(this, "ABiomeZoneVolume.OverrideCombatMusicDay"); }

    USoundBase*& OverrideCombatMusicDay_HeavyField() { return *GetNativePointerField<USoundBase**>(this, "ABiomeZoneVolume.OverrideCombatMusicDay_Heavy"); }

    USoundBase*& OverrideCombatMusicNightField() { return *GetNativePointerField<USoundBase**>(this, "ABiomeZoneVolume.OverrideCombatMusicNight"); }

    USoundBase*& OverrideCombatMusicNight_HeavyField() { return *GetNativePointerField<USoundBase**>(this, "ABiomeZoneVolume.OverrideCombatMusicNight_Heavy"); }

    USoundBase*& ForceMusicInBiomeField() { return *GetNativePointerField<USoundBase**>(this, "ABiomeZoneVolume.ForceMusicInBiome"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bPreventCrops() { return { this, "ABiomeZoneVolume.bPreventCrops" }; }

    BitFieldValue<bool, unsigned __int32> bIsOutside() { return { this, "ABiomeZoneVolume.bIsOutside" }; }

    BitFieldValue<bool, unsigned __int32> bRemoveBuffWhenLeavingVolume() { return { this, "ABiomeZoneVolume.bRemoveBuffWhenLeavingVolume" }; }


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "ABiomeZoneVolume.GetPrivateStaticClass()"); }

    static void StaticRegisterNativesABiomeZoneVolume() { NativeCall<void>(nullptr, "ABiomeZoneVolume.StaticRegisterNativesABiomeZoneVolume()"); }

    float GetBiomeTemperature(float GlobalTemperature) { return NativeCall<float, float>(this, "ABiomeZoneVolume.GetBiomeTemperature(float)", GlobalTemperature); }

    float GetBiomeWind(float GlobalWind) { return NativeCall<float, float>(this, "ABiomeZoneVolume.GetBiomeWind(float)", GlobalWind); }

    static ABiomeZoneVolume* GetBiomeZoneVolume(UWorld* World, const UE::Math::TVector<double>* Location) { return NativeCall<ABiomeZoneVolume*, UWorld*, const UE::Math::TVector<double>*>(nullptr, "ABiomeZoneVolume.GetBiomeZoneVolume(UWorld*,UE::Math::TVector<double>&)", World, Location); }

    void PostInitializeComponents() { NativeCall<void>(this, "ABiomeZoneVolume.PostInitializeComponents()"); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "ABiomeZoneVolume.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    float EggGetOverrideIntervalBetweenUnstasisChances(APrimalDinoCharacter* aChar) { return NativeCall<float, APrimalDinoCharacter*>(this, "ABiomeZoneVolume.EggGetOverrideIntervalBetweenUnstasisChances(APrimalDinoCharacter*)", aChar); }

    float EggOverrideChanceToSpawn(APrimalDinoCharacter* aChar) { return NativeCall<float, APrimalDinoCharacter*>(this, "ABiomeZoneVolume.EggOverrideChanceToSpawn(APrimalDinoCharacter*)", aChar); }

    static bool IsPointUnderwater(UWorld* ForWorld, UE::Math::TVector<double>* AtPoint, bool bFastPath, float MinimumWaterHeight, bool bIgnoreVacuumStructures, bool bIgnorePainCausingVolumes) { return NativeCall<bool, UWorld*, UE::Math::TVector<double>*, bool, float, bool, bool>(nullptr, "ABiomeZoneVolume.IsPointUnderwater(UWorld*,UE::Math::TVector<double>,bool,float,bool,bool)", ForWorld, AtPoint, bFastPath, MinimumWaterHeight, bIgnoreVacuumStructures, bIgnorePainCausingVolumes); }

    static APhysicsVolume* GetWaterVolumeAtPoint(UWorld* ForWorld, UE::Math::TVector<double>* AtPoint, bool bFastPath, float MinimumWaterHeight, bool bIgnoreVacuumStructures, bool bIgnorePainCausingVolumes) { return NativeCall<APhysicsVolume*, UWorld*, UE::Math::TVector<double>*, bool, float, bool, bool>(nullptr, "ABiomeZoneVolume.GetWaterVolumeAtPoint(UWorld*,UE::Math::TVector<double>,bool,float,bool,bool)", ForWorld, AtPoint, bFastPath, MinimumWaterHeight, bIgnoreVacuumStructures, bIgnorePainCausingVolumes); }

    static __int64 IsPointInVacuumBase(UWorld* ForWorld, UE::Math::TVector<double>* AtPoint) { return NativeCall<__int64, UWorld*, UE::Math::TVector<double>*>(nullptr, "ABiomeZoneVolume.IsPointInVacuumBase(UWorld*,UE::Math::TVector<double>)", ForWorld, AtPoint); }

    static AActor* GetPhysicsVolumeAtLocation(UWorld* ForWorld, UE::Math::TVector<double>* AtPoint, bool bFastPath) { return NativeCall<AActor*, UWorld*, UE::Math::TVector<double>*, bool>(nullptr, "ABiomeZoneVolume.GetPhysicsVolumeAtLocation(UWorld*,UE::Math::TVector<double>,bool)", ForWorld, AtPoint, bFastPath); }

};


struct APrimalTargetableActor : AActor

{

    // Fields


    UParticleSystem*& HurtFXField() { return *GetNativePointerField<UParticleSystem**>(this, "APrimalTargetableActor.HurtFX"); }

    TArray<FDamageTypeAdjuster, TSizedDefaultAllocator<32> >& DamageTypeAdjustersField() { return *GetNativePointerField<TArray<FDamageTypeAdjuster, TSizedDefaultAllocator<32> >*>(this, "APrimalTargetableActor.DamageTypeAdjusters"); }

    float& LowHealthPercentageField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.LowHealthPercentage"); }

    TSoftClassPtr<AActor>& DestructionActorTemplateField() { return *GetNativePointerField<TSoftClassPtr<AActor>*>(this, "APrimalTargetableActor.DestructionActorTemplate"); }

    float& LifeSpanAfterDeathField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.LifeSpanAfterDeath"); }

    USoundCue*& DeathSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalTargetableActor.DeathSound"); }

    float& PassiveDamageHealthReplicationPercentIntervalField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.PassiveDamageHealthReplicationPercentInterval"); }

    float& DamageNotifyTeamAggroMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.DamageNotifyTeamAggroMultiplier"); }

    float& DamageNotifyTeamAggroRangeField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.DamageNotifyTeamAggroRange"); }

    float& DamageNotifyTeamAggroRangeFalloffField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.DamageNotifyTeamAggroRangeFalloff"); }

    UE::Math::TVector<double>& DestructibleMeshLocationOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalTargetableActor.DestructibleMeshLocationOffset"); }

    UE::Math::TVector<double>& DestructibleMeshScaleOverrideField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalTargetableActor.DestructibleMeshScaleOverride"); }

    UE::Math::TRotator<double>& DestructibleMeshRotationOffsetField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalTargetableActor.DestructibleMeshRotationOffset"); }

    FString& DescriptiveNameField() { return *GetNativePointerField<FString*>(this, "APrimalTargetableActor.DescriptiveName"); }

    //TSubclassOf<APrimalDestructibleActor>& DestroyedMeshActorClassField() { return *GetNativePointerField<TSubclassOf<APrimalDestructibleActor>*>(this, "APrimalTargetableActor.DestroyedMeshActorClass"); }

    //TSoftObjectPtr<UGeometryCollection>& SoftDestructionGeoCollectionAssetField() { return *GetNativePointerField<TSoftObjectPtr<UGeometryCollection>*>(this, "APrimalTargetableActor.SoftDestructionGeoCollectionAsset"); }

    //TArray<FDestructionGeoCollectionInfo, TSizedDefaultAllocator<32> >& MultiSoftDestructionGeoCollectionAssetsField() { return *GetNativePointerField<TArray<FDestructionGeoCollectionInfo, TSizedDefaultAllocator<32> >*>(this, "APrimalTargetableActor.MultiSoftDestructionGeoCollectionAssets"); }

    float& ReplicatedHealthField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.ReplicatedHealth"); }

    float& HealthField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.Health"); }

    float& MaxHealthField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.MaxHealth"); }

    float& DestructibleMeshDeathImpulseScaleField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.DestructibleMeshDeathImpulseScale"); }

    TArray<FBoneDamageAdjuster, TSizedDefaultAllocator<32> >& BoneDamageAdjustersField() { return *GetNativePointerField<TArray<FBoneDamageAdjuster, TSizedDefaultAllocator<32> >*>(this, "APrimalTargetableActor.BoneDamageAdjusters"); }

    float& LastReplicatedHealthValueField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.LastReplicatedHealthValue"); }

    TSubclassOf<UToolTipWidget>& OverlayToolTipWidgetField() { return *GetNativePointerField<TSubclassOf<UToolTipWidget>*>(this, "APrimalTargetableActor.OverlayToolTipWidget"); }

    UE::Math::TVector2<double>& OverlayMultiUseTooltipScaleField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "APrimalTargetableActor.OverlayMultiUseTooltipScale"); }

    UE::Math::TVector2<double>& OverlayMultiUseTooltipPaddingField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "APrimalTargetableActor.OverlayMultiUseTooltipPadding"); }

    UPrimalHarvestingComponent*& MyHarvestingComponentField() { return *GetNativePointerField<UPrimalHarvestingComponent**>(this, "APrimalTargetableActor.MyHarvestingComponent"); }

    TSharedPtr<FAttachedInstancedHarvestingElement>& MyHarvestingElementField() { return *GetNativePointerField<TSharedPtr<FAttachedInstancedHarvestingElement>*>(this, "APrimalTargetableActor.MyHarvestingElement"); }

    TSubclassOf<UPrimalStructureSettings>& StructureSettingsClassField() { return *GetNativePointerField<TSubclassOf<UPrimalStructureSettings>*>(this, "APrimalTargetableActor.StructureSettingsClass"); }

    UPrimalStructureSettings*& MyStructureSettingsCDOField() { return *GetNativePointerField<UPrimalStructureSettings**>(this, "APrimalTargetableActor.MyStructureSettingsCDO"); }

    float& LastHealthBeforeTakeDamageField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.LastHealthBeforeTakeDamage"); }

    long double& NextAllowRepairTimeField() { return *GetNativePointerField<long double*>(this, "APrimalTargetableActor.NextAllowRepairTime"); }

    float& LastPreBlueprintAdjustmentActualDamageField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.LastPreBlueprintAdjustmentActualDamage"); }

    float& LastReplicatedHealthField() { return *GetNativePointerField<float*>(this, "APrimalTargetableActor.LastReplicatedHealth"); }

    AActor*& MyDestructionActorField() { return *GetNativePointerField<AActor**>(this, "APrimalTargetableActor.MyDestructionActor"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bDestructionActorTemplateServerOnly() { return { this, "APrimalTargetableActor.bDestructionActorTemplateServerOnly" }; }

    BitFieldValue<bool, unsigned __int32> bDestroyedMeshUseSkeletalMeshComponent() { return { this, "APrimalTargetableActor.bDestroyedMeshUseSkeletalMeshComponent" }; }

    BitFieldValue<bool, unsigned __int32> bPreventZeroDamageInstigatorSelfDamage() { return { this, "APrimalTargetableActor.bPreventZeroDamageInstigatorSelfDamage" }; }

    BitFieldValue<bool, unsigned __int32> bIsDead() { return { this, "APrimalTargetableActor.bIsDead" }; }

    BitFieldValue<bool, unsigned __int32> bDamageNotifyTeamAggroAI() { return { this, "APrimalTargetableActor.bDamageNotifyTeamAggroAI" }; }

    BitFieldValue<bool, unsigned __int32> bSetWithinPreventionVolume() { return { this, "APrimalTargetableActor.bSetWithinPreventionVolume" }; }

    BitFieldValue<bool, unsigned __int32> bWithinPreventionVolume() { return { this, "APrimalTargetableActor.bWithinPreventionVolume" }; }

    BitFieldValue<bool, unsigned __int32> bAllowDamageByFriendlyDinos() { return { this, "APrimalTargetableActor.bAllowDamageByFriendlyDinos" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustDamage() { return { this, "APrimalTargetableActor.bUseBPAdjustDamage" }; }

    BitFieldValue<bool, unsigned __int32> bForceZeroDamageProcessing() { return { this, "APrimalTargetableActor.bForceZeroDamageProcessing" }; }

    BitFieldValue<bool, unsigned __int32> bForceFloatingDamageNumbers() { return { this, "APrimalTargetableActor.bForceFloatingDamageNumbers" }; }

    BitFieldValue<bool, unsigned __int32> bDoAllowRadialDamageWithoutVisiblityTrace() { return { this, "APrimalTargetableActor.bDoAllowRadialDamageWithoutVisiblityTrace" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreDestructionEffects() { return { this, "APrimalTargetableActor.bIgnoreDestructionEffects" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreDamageRepairCooldown() { return { this, "APrimalTargetableActor.bIgnoreDamageRepairCooldown" }; }

    BitFieldValue<bool, unsigned __int32> bUseHarvestingComponent() { return { this, "APrimalTargetableActor.bUseHarvestingComponent" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPDied() { return { this, "APrimalTargetableActor.bUseBPDied" }; }

    BitFieldValue<bool, unsigned __int32> BPOverrideDestroyedMeshTextures() { return { this, "APrimalTargetableActor.BPOverrideDestroyedMeshTextures" }; }


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "APrimalTargetableActor.GetPrivateStaticClass()"); }

    static void StaticRegisterNativesAPrimalTargetableActor() { NativeCall<void>(nullptr, "APrimalTargetableActor.StaticRegisterNativesAPrimalTargetableActor()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "APrimalTargetableActor.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void PostInitializeComponents() { NativeCall<void>(this, "APrimalTargetableActor.PostInitializeComponents()"); }

    void BeginPlay() { NativeCall<void>(this, "APrimalTargetableActor.BeginPlay()"); }

    void FellOutOfWorld(const UDamageType* dmgType) { NativeCall<void, const UDamageType*>(this, "APrimalTargetableActor.FellOutOfWorld(UDamageType&)", dmgType); }

    bool IsDead() { return NativeCall<bool>(this, "APrimalTargetableActor.IsDead()"); }

    void AdjustDamage(float* Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, const FDamageEvent*, AController*, AActor*>(this, "APrimalTargetableActor.AdjustDamage(float&,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    void TestAdjustDamage(float* Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, const FDamageEvent*, AController*, AActor*>(this, "APrimalTargetableActor.TestAdjustDamage(float&,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    float TakeDamage(float Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, const FDamageEvent*, AController*, AActor*>(this, "APrimalTargetableActor.TakeDamage(float,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    bool Die(float KillingDamage, const FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, const FDamageEvent*, AController*, AActor*>(this, "APrimalTargetableActor.Die(float,FDamageEvent&,AController*,AActor*)", KillingDamage, DamageEvent, Killer, DamageCauser); }

    void PlayDyingGeneric_Implementation(float KillingDamage, FPointDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FPointDamageEvent*, APawn*, AActor*>(this, "APrimalTargetableActor.PlayDyingGeneric_Implementation(float,FDamageEvent,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void PlayDyingRadial_Implementation(float KillingDamage, FRadialDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FRadialDamageEvent*, APawn*, AActor*>(this, "APrimalTargetableActor.PlayDyingRadial_Implementation(float,FRadialDamageEvent,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void GetDestructionEffectTransform(UE::Math::TVector<double>* OutLocation, UE::Math::TRotator<double>* OutRotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APrimalTargetableActor.GetDestructionEffectTransform(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", OutLocation, OutRotation); }

    //TSoftObjectPtr<UGeometryCollection>* GetDestroyedMesh(TSoftObjectPtr<UGeometryCollection>* result) { return NativeCall<TSoftObjectPtr<UGeometryCollection> *, TSoftObjectPtr<UGeometryCollection>*>(this, "APrimalTargetableActor.GetDestroyedMesh()", result); }

    //TArray<FDestructionGeoCollectionInfo, TSizedDefaultAllocator<32> >* GetDestroyedMeshes(TArray<FDestructionGeoCollectionInfo, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<FDestructionGeoCollectionInfo, TSizedDefaultAllocator<32> >*, TArray<FDestructionGeoCollectionInfo, TSizedDefaultAllocator<32> >*>(this, "APrimalTargetableActor.GetDestroyedMeshes()", result); }

    void PlayDying(float KillingDamage, const FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "APrimalTargetableActor.PlayDying(float,FDamageEvent&,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void SpawnDestroyedMesh(float KillingDamage, const FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "APrimalTargetableActor.SpawnDestroyedMesh(float,FDamageEvent&,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    //void CreateSingleDestroyedMesh(float KillingDamage, const FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser, TSoftObjectPtr<UGeometryCollection>* destroyedMeshAssetSoftPtr, UE::Math::TVector<double>* DestructibleMeshLocationOffset_Single, UE::Math::TVector<double>* DestructibleMeshScaleOverride_Single, UE::Math::TRotator<double>* DestructibleMeshRotationOffset_Single) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*, TSoftObjectPtr<UGeometryCollection>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APrimalTargetableActor.CreateSingleDestroyedMesh(float,FDamageEvent&,APawn*,AActor*,TSoftObjectPtr<UGeometryCollection>,UE::Math::TVector<double>,UE::Math::TVector<double>,UE::Math::TRotator<double>)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser, destroyedMeshAssetSoftPtr, DestructibleMeshLocationOffset_Single, DestructibleMeshScaleOverride_Single, DestructibleMeshRotationOffset_Single); }

    void PlayHitEffectPoint_Implementation(float DamageTaken, FPointDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FPointDamageEvent*, APawn*, AActor*>(this, "APrimalTargetableActor.PlayHitEffectPoint_Implementation(float,FPointDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void PlayHitEffectRadial_Implementation(float DamageTaken, FRadialDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FRadialDamageEvent*, APawn*, AActor*>(this, "APrimalTargetableActor.PlayHitEffectRadial_Implementation(float,FRadialDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void PlayHitEffect(float DamageTaken, const FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser, bool bIsLocalPath, bool bSuppressImpactSound) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*, bool, bool>(this, "APrimalTargetableActor.PlayHitEffect(float,FDamageEvent&,APawn*,AActor*,bool,bool)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser, bIsLocalPath, bSuppressImpactSound); }

    void PreReplication(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "APrimalTargetableActor.PreReplication(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "APrimalTargetableActor.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    float GetMaxHealth() { return NativeCall<float>(this, "APrimalTargetableActor.GetMaxHealth()"); }

    bool IsAlive() { return NativeCall<bool>(this, "APrimalTargetableActor.IsAlive()"); }

    FString* GetDescriptiveName(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalTargetableActor.GetDescriptiveName()", result); }

    FString* GetShortName(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalTargetableActor.GetShortName()", result); }

    float GetHealth() { return NativeCall<float>(this, "APrimalTargetableActor.GetHealth()"); }

    float GetHealthPercentage() { return NativeCall<float>(this, "APrimalTargetableActor.GetHealthPercentage()"); }

    float SetHealth(float newHealth) { return NativeCall<float, float>(this, "APrimalTargetableActor.SetHealth(float)", newHealth); }

    void SetMaxHealth(float newMaxHealth) { NativeCall<void, float>(this, "APrimalTargetableActor.SetMaxHealth(float)", newMaxHealth); }

    TSubclassOf<UToolTipWidget>* GetOverlayTooltipTemplate(TSubclassOf<UToolTipWidget>* result) { return NativeCall<TSubclassOf<UToolTipWidget> *, TSubclassOf<UToolTipWidget>*>(this, "APrimalTargetableActor.GetOverlayTooltipTemplate()", result); }

    bool IsOfTribe(int ID) { return NativeCall<bool, int>(this, "APrimalTargetableActor.IsOfTribe(int)", ID); }

    void NetUpdatedHealth_Implementation(int NewHealth) { NativeCall<void, int>(this, "APrimalTargetableActor.NetUpdatedHealth_Implementation(int)", NewHealth); }

    bool IsTargetableDead() { return NativeCall<bool>(this, "APrimalTargetableActor.IsTargetableDead()"); }

    void Suicide() { NativeCall<void>(this, "APrimalTargetableActor.Suicide()"); }

    bool NetExecCommand(FName CommandName, const FNetExecParams* ExecParams) { return NativeCall<bool, FName, const FNetExecParams*>(this, "APrimalTargetableActor.NetExecCommand(FName,FNetExecParams&)", CommandName, ExecParams); }

    void UpdatedHealth(bool bDoReplication) { NativeCall<void, bool>(this, "APrimalTargetableActor.UpdatedHealth(bool)", bDoReplication); }

    bool AllowRadialDamageWithoutVisiblityTrace(const FHitResult* Hit) { return NativeCall<bool, const FHitResult*>(this, "APrimalTargetableActor.AllowRadialDamageWithoutVisiblityTrace(FHitResult&)", Hit); }

    bool IsInvincible() { return NativeCall<bool>(this, "APrimalTargetableActor.IsInvincible()"); }

    void HarvestingDepleted(UPrimalHarvestingComponent* fromComponent) { NativeCall<void, UPrimalHarvestingComponent*>(this, "APrimalTargetableActor.HarvestingDepleted(UPrimalHarvestingComponent*)", fromComponent); }

};


struct AInfo : AActor

{

    // Fields


      // Bitfields


      // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AInfo.StaticClass()"); }

    //void AInfo(const FObjectInitializer* ObjectInitializer) { NativeCall<void, const FObjectInitializer*>(this, "AInfo.AInfo(FObjectInitializer*)", ObjectInitializer); }

};


struct UPlayer : UObject {

    TObjectPtr<APlayerController>& PlayerControllerField() { return *GetNativePointerField<TObjectPtr<APlayerController>*>(this, "UPlayer.PlayerController"); }

    // int CurrentNetSpeed;

    // int ConfiguredInternetSpeed;

    // int ConfiguredLanSpeed;

    // unsigned __int64 TransferringPlayerDataId;


    FString* ConsoleCommand(FString* result, const FString* Cmd, bool bWriteToLog) { return NativeCall<FString*, FString*, const FString*, bool>(this, "UPlayer.ConsoleCommand(FString&,bool)", result, Cmd, bWriteToLog); }

};


struct FUniqueNetIdWrapper

{

    //void* __vftable /*VFT*/;

    //TVariant<TSharedPtr<FUniqueNetId const, 1>, UE::Online::TOnlineId<UE::Online::OnlineIdHandleTags::FAccount> > Variant;


    FUniqueNetIdWrapper* operator=(const FUniqueNetIdWrapper* __that) { return NativeCall<FUniqueNetIdWrapper*, const FUniqueNetIdWrapper*>(this, "FUniqueNetIdWrapper.operator=(FUniqueNetIdWrapper&)", __that); }

    FString* ToString(FString* result) { return NativeCall<FString*, FString*>(this, "FUniqueNetIdWrapper.ToString()", result); }

    FName* GetType(FName* result) { return NativeCall<FName*, FName*>(this, "FUniqueNetIdWrapper.GetType()", result); }

    TSharedPtr<FUniqueNetId const>* GetUniqueNetId(TSharedPtr<FUniqueNetId const>* result) { return NativeCall<TSharedPtr<FUniqueNetId const> *, TSharedPtr<FUniqueNetId const>*>(this, "FUniqueNetIdWrapper.GetUniqueNetId()", result); }

    const FUniqueNetId* operator*() { return NativeCall<const FUniqueNetId*>(this, "FUniqueNetIdWrapper.operator*()"); }

    bool IsValid() { return NativeCall<bool>(this, "FUniqueNetIdWrapper.IsValid()"); }

    TSharedPtr<FUniqueNetId const>* GetV1(TSharedPtr<FUniqueNetId const>* result) { return NativeCall<TSharedPtr<FUniqueNetId const> *, TSharedPtr<FUniqueNetId const>*>(this, "FUniqueNetIdWrapper.GetV1()", result); }

    void SetUniqueNetId(const TSharedPtr<FUniqueNetId const>* InUniqueNetId) { NativeCall<void, const TSharedPtr<FUniqueNetId const>*>(this, "FUniqueNetIdWrapper.SetUniqueNetId(TSharedPtr<FUniqueNetId,1>&)", InUniqueNetId); }

    FString* ToDebugString(FString* result) { return NativeCall<FString*, FString*>(this, "FUniqueNetIdWrapper.ToDebugString()", result); }


};


struct FUniqueNetIdRepl : FUniqueNetIdWrapper

{

    TArray<unsigned char, TSizedDefaultAllocator<32> > ReplicationBytes;

};


/*struct UNetConnection : UPlayer

{

    FUniqueNetIdRepl& UniqueIdField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "UNetConnection.PlayerId"); }

};*/


struct FNetResult

{

    unsigned __int64 Result;

    void* ResultEnumObj;

    const void* RawResultEnumObj;

    FString ErrorContext;

    void* NextResult;

};


struct UNetConnection : UPlayer

{

    // Fields


    //TArray<TObjectPtr<UChildConnection>, TSizedDefaultAllocator<32> >& ChildrenField() { return *GetNativePointerField<TArray<TObjectPtr<UChildConnection>, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.Children"); }

    TObjectPtr<UNetDriver>& DriverField() { return *GetNativePointerField<TObjectPtr<UNetDriver>*>(this, "UNetConnection.Driver"); }

    TSubclassOf<UPackageMap>& PackageMapClassField() { return *GetNativePointerField<TSubclassOf<UPackageMap>*>(this, "UNetConnection.PackageMapClass"); }

    TObjectPtr<UPackageMap>& PackageMapField() { return *GetNativePointerField<TObjectPtr<UPackageMap>*>(this, "UNetConnection.PackageMap"); }

    TArray<TObjectPtr<UChannel>, TSizedDefaultAllocator<32> >& OpenChannelsField() { return *GetNativePointerField<TArray<TObjectPtr<UChannel>, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.OpenChannels"); }

    TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >& SentTemporariesField() { return *GetNativePointerField<TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.SentTemporaries"); }

    TObjectPtr<AActor>& ViewTargetField() { return *GetNativePointerField<TObjectPtr<AActor>*>(this, "UNetConnection.ViewTarget"); }

    TObjectPtr<AActor>& OwningActorField() { return *GetNativePointerField<TObjectPtr<AActor>*>(this, "UNetConnection.OwningActor"); }

    int& MaxPacketField() { return *GetNativePointerField<int*>(this, "UNetConnection.MaxPacket"); }

    //FURL& URLField() { return *GetNativePointerField<FURL*>(this, "UNetConnection.URL"); }

    //TSharedPtr<FInternetAddr>& RemoteAddrField() { return *GetNativePointerField<TSharedPtr<FInternetAddr>*>(this, "UNetConnection.RemoteAddr"); }

    int& NumPacketIdBitsField() { return *GetNativePointerField<int*>(this, "UNetConnection.NumPacketIdBits"); }

    int& NumBunchBitsField() { return *GetNativePointerField<int*>(this, "UNetConnection.NumBunchBits"); }

    int& NumAckBitsField() { return *GetNativePointerField<int*>(this, "UNetConnection.NumAckBits"); }

    int& NumPaddingBitsField() { return *GetNativePointerField<int*>(this, "UNetConnection.NumPaddingBits"); }

    int& MaxPacketHandlerBitsField() { return *GetNativePointerField<int*>(this, "UNetConnection.MaxPacketHandlerBits"); }

    EConnectionState& StateField() { return *GetNativePointerField<EConnectionState*>(this, "UNetConnection.State"); }

    //TUniquePtr<PacketHandler, TDefaultDelete<PacketHandler> >& HandlerField() { return *GetNativePointerField<TUniquePtr<PacketHandler, TDefaultDelete<PacketHandler> >*>(this, "UNetConnection.Handler"); }

    //TWeakPtr<StatelessConnectHandlerComponent, 1>& StatelessConnectComponentField() { return *GetNativePointerField<TWeakPtr<StatelessConnectHandlerComponent, 1>*>(this, "UNetConnection.StatelessConnectComponent"); }

    FUniqueNetIdRepl& PlayerIdField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "UNetConnection.PlayerId"); }

    int& PacketOverheadField() { return *GetNativePointerField<int*>(this, "UNetConnection.PacketOverhead"); }

    FString& ChallengeField() { return *GetNativePointerField<FString*>(this, "UNetConnection.Challenge"); }

    FString& ClientResponseField() { return *GetNativePointerField<FString*>(this, "UNetConnection.ClientResponse"); }

    int& ResponseIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.ResponseId"); }

    FString& RequestURLField() { return *GetNativePointerField<FString*>(this, "UNetConnection.RequestURL"); }

    EClientLoginState::Type& ClientLoginStateField() { return *GetNativePointerField<EClientLoginState::Type*>(this, "UNetConnection.ClientLoginState"); }

    long double& LastReceiveTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastReceiveTime"); }

    long double& LastReceiveRealtimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastReceiveRealtime"); }

    long double& LastGoodPacketRealtimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastGoodPacketRealtime"); }

    long double& LastSendTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastSendTime"); }

    long double& LastTickTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastTickTime"); }

    int& QueuedBitsField() { return *GetNativePointerField<int*>(this, "UNetConnection.QueuedBits"); }

    int& TickCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.TickCount"); }

    unsigned int& LastProcessedFrameField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.LastProcessedFrame"); }

    long double& LastRecvAckTimestampField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastRecvAckTimestamp"); }

    long double& ConnectTimestampField() { return *GetNativePointerField<long double*>(this, "UNetConnection.ConnectTimestamp"); }

    //FPacketTimestamp& LastOSReceiveTimeField() { return *GetNativePointerField<FPacketTimestamp*>(this, "UNetConnection.LastOSReceiveTime"); }

    bool& bSendBufferHasDummyPacketInfoField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bSendBufferHasDummyPacketInfo"); }

    //FBitWriterMark& HeaderMarkForPacketInfoField() { return *GetNativePointerField<FBitWriterMark*>(this, "UNetConnection.HeaderMarkForPacketInfo"); }

    int& PreviousJitterTimeDeltaField() { return *GetNativePointerField<int*>(this, "UNetConnection.PreviousJitterTimeDelta"); }

    long double& PreviousPacketSendTimeInSField() { return *GetNativePointerField<long double*>(this, "UNetConnection.PreviousPacketSendTimeInS"); }

    //FBitWriterMark& LastStartField() { return *GetNativePointerField<FBitWriterMark*>(this, "UNetConnection.LastStart"); }

    //FBitWriterMark& LastEndField() { return *GetNativePointerField<FBitWriterMark*>(this, "UNetConnection.LastEnd"); }

    bool& TimeSensitiveField() { return *GetNativePointerField<bool*>(this, "UNetConnection.TimeSensitive"); }

    FOutBunch*& LastOutBunchField() { return *GetNativePointerField<FOutBunch**>(this, "UNetConnection.LastOutBunch"); }

    FOutBunch& LastOutField() { return *GetNativePointerField<FOutBunch*>(this, "UNetConnection.LastOut"); }

    //FBitWriter& SendBunchHeaderField() { return *GetNativePointerField<FBitWriter*>(this, "UNetConnection.SendBunchHeader"); }

    long double& StatUpdateTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.StatUpdateTime"); }

    float& StatPeriodField() { return *GetNativePointerField<float*>(this, "UNetConnection.StatPeriod"); }

    float& AvgLagField() { return *GetNativePointerField<float*>(this, "UNetConnection.AvgLag"); }

    long double& LagAccField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LagAcc"); }

    int& LagCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.LagCount"); }

    long double& LastTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastTime"); }

    long double& FrameTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.FrameTime"); }

    long double& CumulativeTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.CumulativeTime"); }

    long double& AverageFrameTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.AverageFrameTime"); }

    int& CountedFramesField() { return *GetNativePointerField<int*>(this, "UNetConnection.CountedFrames"); }

    int& InBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.InBytes"); }

    int& OutBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutBytes"); }

    int& InTotalBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.InTotalBytes"); }

    int& OutTotalBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutTotalBytes"); }

    int& InPacketsField() { return *GetNativePointerField<int*>(this, "UNetConnection.InPackets"); }

    int& OutPacketsField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutPackets"); }

    int& InTotalPacketsField() { return *GetNativePointerField<int*>(this, "UNetConnection.InTotalPackets"); }

    int& OutTotalPacketsField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutTotalPackets"); }

    int& InBytesPerSecondField() { return *GetNativePointerField<int*>(this, "UNetConnection.InBytesPerSecond"); }

    int& OutBytesPerSecondField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutBytesPerSecond"); }

    int& InPacketsPerSecondField() { return *GetNativePointerField<int*>(this, "UNetConnection.InPacketsPerSecond"); }

    int& OutPacketsPerSecondField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutPacketsPerSecond"); }

    int& InPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.InPacketsLost"); }

    int& OutPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutPacketsLost"); }

    int& InTotalPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.InTotalPacketsLost"); }

    int& OutTotalPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutTotalPacketsLost"); }

    int& OutTotalAcksField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutTotalAcks"); }

    int& InTotalHandlerPacketsField() { return *GetNativePointerField<int*>(this, "UNetConnection.InTotalHandlerPackets"); }

    //TPacketLossData<3>& InPacketsLossPercentageField() { return *GetNativePointerField<TPacketLossData<3>*>(this, "UNetConnection.InPacketsLossPercentage"); }

    //TPacketLossData<3>& OutPacketsLossPercentageField() { return *GetNativePointerField<TPacketLossData<3>*>(this, "UNetConnection.OutPacketsLossPercentage"); }

    int& StatPeriodCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.StatPeriodCount"); }

    float& AverageJitterInMSField() { return *GetNativePointerField<float*>(this, "UNetConnection.AverageJitterInMS"); }

    //FNetConnAnalyticsVars& AnalyticsVarsField() { return *GetNativePointerField<FNetConnAnalyticsVars*>(this, "UNetConnection.AnalyticsVars"); }

    //TSharedPtr<FNetConnAnalyticsData, 1>& NetAnalyticsDataField() { return *GetNativePointerField<TSharedPtr<FNetConnAnalyticsData, 1>*>(this, "UNetConnection.NetAnalyticsData"); }

    //FBitWriter& SendBufferField() { return *GetNativePointerField<FBitWriter*>(this, "UNetConnection.SendBuffer"); }

    int& InPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.InPacketId"); }

    int& OutPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutPacketId"); }

    int& OutAckPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutAckPacketId"); }

    int& DefaultMaxChannelSizeField() { return *GetNativePointerField<int*>(this, "UNetConnection.DefaultMaxChannelSize"); }

    int& MaxChannelSizeField() { return *GetNativePointerField<int*>(this, "UNetConnection.MaxChannelSize"); }

    TArray<UChannel*, TSizedDefaultAllocator<32> >& ChannelsField() { return *GetNativePointerField<TArray<UChannel*, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.Channels"); }

    TArray<int, TSizedDefaultAllocator<32> >& OutReliableField() { return *GetNativePointerField<TArray<int, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.OutReliable"); }

    TArray<int, TSizedDefaultAllocator<32> >& InReliableField() { return *GetNativePointerField<TArray<int, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.InReliable"); }

    TArray<int, TSizedDefaultAllocator<32> >& PendingOutRecField() { return *GetNativePointerField<TArray<int, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.PendingOutRec"); }

    int& InitOutReliableField() { return *GetNativePointerField<int*>(this, "UNetConnection.InitOutReliable"); }

    int& InitInReliableField() { return *GetNativePointerField<int*>(this, "UNetConnection.InitInReliable"); }

    unsigned int& EngineNetworkProtocolVersionField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.EngineNetworkProtocolVersion"); }

    unsigned int& GameNetworkProtocolVersionField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.GameNetworkProtocolVersion"); }

    FCustomVersionContainer& NetworkCustomVersionsField() { return *GetNativePointerField<FCustomVersionContainer*>(this, "UNetConnection.NetworkCustomVersions"); }

    long double& LogCallLastTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LogCallLastTime"); }

    int& LogCallCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.LogCallCount"); }

    int& LogSustainedCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.LogSustainedCount"); }

    unsigned int& PerPacketTinyTokenToSendField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.PerPacketTinyTokenToSend"); }

    unsigned int& RecentFullTinyTokenACKsField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.RecentFullTinyTokenACKs"); }

    TArray<unsigned char, TSizedDefaultAllocator<32> >& CurrentFullTokenForServerACKField() { return *GetNativePointerField<TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.CurrentFullTokenForServerACK"); }

    //TMap<TWeakObjectPtr<AActor>, UActorChannel*, FDefaultSetAllocator, TWeakObjectPtrMapKeyFuncs<TWeakObjectPtr<AActor>, UActorChannel*, 0> >& ActorChannelsField() { return *GetNativePointerField<TMap<TWeakObjectPtr<AActor>, UActorChannel*, FDefaultSetAllocator, TWeakObjectPtrMapKeyFuncs<TWeakObjectPtr<AActor>, UActorChannel*, 0> >*>(this, "UNetConnection.ActorChannels"); }

    //UReplicationConnectionDriver*& ReplicationConnectionDriverField() { return *GetNativePointerField<UReplicationConnectionDriver**>(this, "UNetConnection.ReplicationConnectionDriver"); }

    FPackageFileVersion& PackageVersionUEField() { return *GetNativePointerField<FPackageFileVersion*>(this, "UNetConnection.PackageVersionUE"); }

    int& PackageVersionLicenseeUEField() { return *GetNativePointerField<int*>(this, "UNetConnection.PackageVersionLicenseeUE"); }

    //FEngineVersion& EngineVersionField() { return *GetNativePointerField<FEngineVersion*>(this, "UNetConnection.EngineVersion"); }

    TSet<FNetworkGUID, DefaultKeyFuncs<FNetworkGUID, 0>, FDefaultSetAllocator>& DestroyedStartupOrDormantActorGUIDsField() { return *GetNativePointerField<TSet<FNetworkGUID, DefaultKeyFuncs<FNetworkGUID, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.DestroyedStartupOrDormantActorGUIDs"); }

    TSet<FName, DefaultKeyFuncs<FName, 0>, FDefaultSetAllocator>& ClientMakingVisibleLevelNamesField() { return *GetNativePointerField<TSet<FName, DefaultKeyFuncs<FName, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.ClientMakingVisibleLevelNames"); }

    TMap<FNetworkGUID, TArray<UActorChannel*, TSizedDefaultAllocator<32> >, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FNetworkGUID, TArray<UActorChannel*, TSizedDefaultAllocator<32> >, 0> >& KeepProcessingActorChannelBunchesMapField() { return *GetNativePointerField<TMap<FNetworkGUID, TArray<UActorChannel*, TSizedDefaultAllocator<32> >, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FNetworkGUID, TArray<UActorChannel*, TSizedDefaultAllocator<32> >, 0> >*>(this, "UNetConnection.KeepProcessingActorChannelBunchesMap"); }

    //TMap<FObjectKey, TSharedRef<FObjectReplicator, 1>, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FObjectKey, TSharedRef<FObjectReplicator, 1>, 0> >& DormantReplicatorMapField() { return *GetNativePointerField<TMap<FObjectKey, TSharedRef<FObjectReplicator, 1>, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FObjectKey, TSharedRef<FObjectReplicator, 1>, 0> >*>(this, "UNetConnection.DormantReplicatorMap"); }

    //UE::Net::Private::FDormantReplicatorHolder& DormantReplicatorSetField() { return *GetNativePointerField<UE::Net::Private::FDormantReplicatorHolder*>(this, "UNetConnection.DormantReplicatorSet"); }

    TSet<FName, DefaultKeyFuncs<FName, 0>, FDefaultSetAllocator>& ClientVisibleLevelNamesField() { return *GetNativePointerField<TSet<FName, DefaultKeyFuncs<FName, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.ClientVisibleLevelNames"); }

    TArray<TObjectPtr<UChannel>, TSizedDefaultAllocator<32> >& ChannelsToTickField() { return *GetNativePointerField<TArray<TObjectPtr<UChannel>, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.ChannelsToTick"); }

    //FHistogram& NetConnectionHistogramField() { return *GetNativePointerField<FHistogram*>(this, "UNetConnection.NetConnectionHistogram"); }

    FName& PlayerOnlinePlatformNameField() { return *GetNativePointerField<FName*>(this, "UNetConnection.PlayerOnlinePlatformName"); }

    TMap<FName, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, bool, 0> >& ClientVisibleActorOutersField() { return *GetNativePointerField<TMap<FName, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, bool, 0> >*>(this, "UNetConnection.ClientVisibleActorOuters"); }

    //TMap<FName, FUpdateLevelVisibilityLevelInfo, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, FUpdateLevelVisibilityLevelInfo, 0> >& PendingUpdateLevelVisibilityField() { return *GetNativePointerField<TMap<FName, FUpdateLevelVisibilityLevelInfo, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, FUpdateLevelVisibilityLevelInfo, 0> >*>(this, "UNetConnection.PendingUpdateLevelVisibility"); }

    //TMap<FName, FNetLevelVisibilityTransactionId, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, FNetLevelVisibilityTransactionId, 0> >& ClientPendingStreamingStatusRequestField() { return *GetNativePointerField<TMap<FName, FNetLevelVisibilityTransactionId, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, FNetLevelVisibilityTransactionId, 0> >*>(this, "UNetConnection.ClientPendingStreamingStatusRequest"); }

    FName& ClientWorldPackageNameField() { return *GetNativePointerField<FName*>(this, "UNetConnection.ClientWorldPackageName"); }

    TMap<FString, TArray<float, TSizedDefaultAllocator<32> >, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, TArray<float, TSizedDefaultAllocator<32> >, 0> >& ActorsStarvedByClassTimeMapField() { return *GetNativePointerField<TMap<FString, TArray<float, TSizedDefaultAllocator<32> >, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, TArray<float, TSizedDefaultAllocator<32> >, 0> >*>(this, "UNetConnection.ActorsStarvedByClassTimeMap"); }

    TMap<int, FNetworkGUID, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FNetworkGUID, 0> >& IgnoringChannelsField() { return *GetNativePointerField<TMap<int, FNetworkGUID, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FNetworkGUID, 0> >*>(this, "UNetConnection.IgnoringChannels"); }

    TMap<int, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, int, 0> >& ChannelIndexMapField() { return *GetNativePointerField<TMap<int, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, int, 0> >*>(this, "UNetConnection.ChannelIndexMap"); }

    TSet<FNetworkGUID, DefaultKeyFuncs<FNetworkGUID, 0>, FDefaultSetAllocator>& IgnoredBunchGuidsField() { return *GetNativePointerField<TSet<FNetworkGUID, DefaultKeyFuncs<FNetworkGUID, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.IgnoredBunchGuids"); }

    TSet<int, DefaultKeyFuncs<int, 0>, FDefaultSetAllocator>& IgnoredBunchChannelsField() { return *GetNativePointerField<TSet<int, DefaultKeyFuncs<int, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.IgnoredBunchChannels"); }

    TSet<int, DefaultKeyFuncs<int, 0>, FDefaultSetAllocator>& ReservedChannelsField() { return *GetNativePointerField<TSet<int, DefaultKeyFuncs<int, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.ReservedChannels"); }

    bool& bIgnoreReservedChannelsField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bIgnoreReservedChannels"); }

    TArray<FOutBunch*, TSizedDefaultAllocator<32> >& OutgoingBunchesField() { return *GetNativePointerField<TArray<FOutBunch*, TSizedDefaultAllocator<32> >*>(this, "UNetConnection.OutgoingBunches"); }

    //FWrittenChannelsRecord& ChannelRecordField() { return *GetNativePointerField<FWrittenChannelsRecord*>(this, "UNetConnection.ChannelRecord"); }

    //FNetPacketNotify& PacketNotifyField() { return *GetNativePointerField<FNetPacketNotify*>(this, "UNetConnection.PacketNotify"); }

    int& LastNotifiedPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.LastNotifiedPacketId"); }

    unsigned int& OutTotalNotifiedPacketsField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.OutTotalNotifiedPackets"); }

    unsigned int& HasDirtyAcksField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.HasDirtyAcks"); }

    bool& bConnectionPendingCloseDueToSocketSendFailureField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bConnectionPendingCloseDueToSocketSendFailure"); }

    int& TotalOutOfOrderPacketsField() { return *GetNativePointerField<int*>(this, "UNetConnection.TotalOutOfOrderPackets"); }

    int& TotalOutOfOrderPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.TotalOutOfOrderPacketsLost"); }

    int& TotalOutOfOrderPacketsRecoveredField() { return *GetNativePointerField<int*>(this, "UNetConnection.TotalOutOfOrderPacketsRecovered"); }

    int& TotalOutOfOrderPacketsDuplicateField() { return *GetNativePointerField<int*>(this, "UNetConnection.TotalOutOfOrderPacketsDuplicate"); }

    //TOptional<TCircularBuffer<TUniquePtr<FBitReader, TDefaultDelete<FBitReader> > > >& PacketOrderCacheField() { return *GetNativePointerField<TOptional<TCircularBuffer<TUniquePtr<FBitReader, TDefaultDelete<FBitReader> > > >*>(this, "UNetConnection.PacketOrderCache"); }

    int& PacketOrderCacheStartIdxField() { return *GetNativePointerField<int*>(this, "UNetConnection.PacketOrderCacheStartIdx"); }

    int& PacketOrderCacheCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.PacketOrderCacheCount"); }

    //FNetConnectionSaturationAnalytics& SaturationAnalyticsField() { return *GetNativePointerField<FNetConnectionSaturationAnalytics*>(this, "UNetConnection.SaturationAnalytics"); }

    //FNetConnectionPacketAnalytics& PacketAnalyticsField() { return *GetNativePointerField<FNetConnectionPacketAnalytics*>(this, "UNetConnection.PacketAnalytics"); }

    unsigned int& ConnectionIdField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.ConnectionId"); }

    AActor*& RepContextActorField() { return *GetNativePointerField<AActor**>(this, "UNetConnection.RepContextActor"); }

    ULevel*& RepContextLevelField() { return *GetNativePointerField<ULevel**>(this, "UNetConnection.RepContextLevel"); }

    bool& bLoggedFlushNetQueuedBitsOverflowField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bLoggedFlushNetQueuedBitsOverflow"); }

    //TUniquePtr<FRPCDoSDetection, TDefaultDelete<FRPCDoSDetection> >& RPCDoSField() { return *GetNativePointerField<TUniquePtr<FRPCDoSDetection, TDefaultDelete<FRPCDoSDetection> >*>(this, "UNetConnection.RPCDoS"); }

    //TUniquePtr<UE::Net::FNetConnectionFaultRecovery, TDefaultDelete<UE::Net::FNetConnectionFaultRecovery> >& FaultRecoveryField() { return *GetNativePointerField<TUniquePtr<UE::Net::FNetConnectionFaultRecovery, TDefaultDelete<UE::Net::FNetConnectionFaultRecovery> >*>(this, "UNetConnection.FaultRecovery"); }

    //TPimplPtr<UE::Net::FNetPing, 0>& NetPingField() { return *GetNativePointerField<TPimplPtr<UE::Net::FNetPing, 0>*>(this, "UNetConnection.NetPing"); }

    //TOptional<FNetworkCongestionControl>& NetworkCongestionControlField() { return *GetNativePointerField<TOptional<FNetworkCongestionControl>*>(this, "UNetConnection.NetworkCongestionControl"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> InternalAck() { return { this, "UNetConnection.InternalAck" }; }

    BitFieldValue<bool, unsigned __int32> bInternalAck() { return { this, "UNetConnection.bInternalAck" }; }

    BitFieldValue<bool, unsigned __int32> bReplay() { return { this, "UNetConnection.bReplay" }; }

    BitFieldValue<bool, unsigned __int32> bForceInitialDirty() { return { this, "UNetConnection.bForceInitialDirty" }; }

    BitFieldValue<bool, unsigned __int32> bUnlimitedBunchSizeAllowed() { return { this, "UNetConnection.bUnlimitedBunchSizeAllowed" }; }

    BitFieldValue<bool, unsigned __int32> bPendingDestroy() { return { this, "UNetConnection.bPendingDestroy" }; }

    BitFieldValue<bool, unsigned __int32> bHasArkLoginLock() { return { this, "UNetConnection.bHasArkLoginLock" }; }


    // Functions


    UActorChannel* FindActorChannelRef(const TWeakObjectPtr<AActor>* Actor) { return NativeCall<UActorChannel*, const TWeakObjectPtr<AActor>*>(this, "UNetConnection.FindActorChannelRef(TWeakObjectPtr<AActor,FWeakObjectPtr>*)", Actor); }

    void Close() { NativeCall<void>(this, "UNetConnection.Close()"); }

    FString* RemoteAddressToString(FString* result) { return NativeCall<FString*, FString*>(this, "UNetConnection.RemoteAddressToString(FString&)", result); }

    int GetAddrPort() { return NativeCall<int>(this, "UNetConnection.GetAddrPort()"); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UNetConnection.StaticClass()"); }

    void StartTickingChannel(UChannel* Channel) { NativeCall<void, UChannel*>(this, "UNetConnection.StartTickingChannel(UChannel*)", Channel); }

    FString* LowLevelGetRemoteAddress(FString* result, bool bAppendPort) { return NativeCall<FString*, FString*, bool>(this, "UNetConnection.LowLevelGetRemoteAddress(FString&,bool)", result, bAppendPort); }

    FString* LowLevelDescribe(FString* result) { return NativeCall<FString*, FString*>(this, "UNetConnection.LowLevelDescribe(FString&)", result); }

    //void LowLevelSend(void* Data, int CountBits, FOutPacketTraits* Traits) { NativeCall<void, void*, int, FOutPacketTraits*>(this, "UNetConnection.LowLevelSend(void*,int,FOutPacketTraits*)", Data, CountBits, Traits); }

    //void InitRemoteConnection(UNetDriver* InDriver, FSocket* InSocket, const struct FURL* InURL, const FInternetAddr* InRemoteAddr, EConnectionState InState, int InMaxPacket, int InPacketOverhead) { NativeCall<void, UNetDriver*, FSocket*, const FURL*, const FInternetAddr*, EConnectionState, int, int>(this, "UNetConnection.InitRemoteConnection(UNetDriver*,FSocket*,FURL*,FInternetAddr*,EConnectionState,int,int)", InDriver, InSocket, InURL, InRemoteAddr, InState, InMaxPacket, InPacketOverhead); }

    //void InitLocalConnection(UNetDriver* InDriver, FSocket* InSocket, const struct FURL* InURL, EConnectionState InState, int InMaxPacket, int InPacketOverhead) { NativeCall<void, UNetDriver*, FSocket*, const FURL*, EConnectionState, int, int>(this, "UNetConnection.InitLocalConnection(UNetDriver*,FSocket*,FURL*,EConnectionState,int,int)", InDriver, InSocket, InURL, InState, InMaxPacket, InPacketOverhead); }

    //void InitChannelData() { NativeCall<void>(this, "UNetConnection.InitChannelData()"); }

    //void InitBase(UNetDriver* InDriver, FSocket* InSocket, const FURL* InURL, EConnectionState InState, int InMaxPacket, int InPacketOverhead) { NativeCall<void, UNetDriver*, FSocket*, const FURL*, EConnectionState, int, int>(this, "UNetConnection.InitBase(UNetDriver*,FSocket*,FURL*,EConnectionState,int,int)", InDriver, InSocket, InURL, InState, InMaxPacket, InPacketOverhead); }

    //void InitConnection(UNetDriver* InDriver, EConnectionState InState, const FURL* InURL, int InConnectionSpeed, int InMaxPacket) { NativeCall<void, UNetDriver*, EConnectionState, const FURL*, int, int>(this, "UNetConnection.InitConnection(UNetDriver*,EConnectionState,FURL*,int,int)", InDriver, InState, InURL, InConnectionSpeed, InMaxPacket); }

    //void InitHandler() { NativeCall<void>(this, "UNetConnection.InitHandler()"); }

    //void InitSequence(int IncomingSequence, int OutgoingSequence) { NativeCall<void, int, int>(this, "UNetConnection.InitSequence(int,int)", IncomingSequence, OutgoingSequence); }

    //void NotifyAnalyticsProvider() { NativeCall<void>(this, "UNetConnection.NotifyAnalyticsProvider()"); }

    //void EnableEncryption(const FEncryptionData* EncryptionData) { NativeCall<void, const FEncryptionData*>(this, "UNetConnection.EnableEncryption(FEncryptionData*)", EncryptionData); }

    //void EnableEncryptionServer(const FEncryptionData* EncryptionData) { NativeCall<void, const FEncryptionData*>(this, "UNetConnection.EnableEncryptionServer(FEncryptionData*)", EncryptionData); }

    //void SetEncryptionData(const FEncryptionData* EncryptionData) { NativeCall<void, const FEncryptionData*>(this, "UNetConnection.SetEncryptionData(FEncryptionData*)", EncryptionData); }

    bool IsEncryptionEnabled() { return NativeCall<bool>(this, "UNetConnection.IsEncryptionEnabled()"); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UNetConnection.Serialize(FArchive*)", Ar); }

    void Close(struct FNetResult* CloseReason) { NativeCall<void, FNetResult*>(this, "UNetConnection.Close(UE::Net::FNetResult&&)", CloseReason); }

    void HandleNetResultOrClose(ENetCloseResult InResult) { NativeCall<void, ENetCloseResult>(this, "UNetConnection.HandleNetResultOrClose(ENetCloseResult)", InResult); }

    void SendCloseReason(FNetResult* CloseReason) { NativeCall<void, FNetResult*>(this, "UNetConnection.SendCloseReason(UE::Net::FNetResult&&)", CloseReason); }

    void HandleReceiveCloseReason(const FString* CloseReasonList) { NativeCall<void, const FString*>(this, "UNetConnection.HandleReceiveCloseReason(FString&)", CloseReasonList); }

    //void HandleReceiveNetUpgrade(unsigned int RemoteNetworkVersion, EEngineNetworkRuntimeFeatures RemoteNetworkFeatures, UE::Net::ENetUpgradeSource NetUpgradeSource) { NativeCall<void, unsigned int, EEngineNetworkRuntimeFeatures, UE::Net::ENetUpgradeSource>(this, "UNetConnection.HandleReceiveNetUpgrade(unsignedint,EEngineNetworkRuntimeFeatures,UE::Net::ENetUpgradeSource)", RemoteNetworkVersion, RemoteNetworkFeatures, NetUpgradeSource); }

    FString* Describe(FString* result) { return NativeCall<FString*, FString*>(this, "UNetConnection.Describe()", result); }

    void CleanUp() { NativeCall<void>(this, "UNetConnection.CleanUp()"); }

    void DestroyOwningActor() { NativeCall<void>(this, "UNetConnection.DestroyOwningActor()"); }

    void FinishDestroy() { NativeCall<void>(this, "UNetConnection.FinishDestroy()"); }

    static void AddReferencedObjects(UObject* InThis, FReferenceCollector* Collector) { NativeCall<void, UObject*, FReferenceCollector*>(nullptr, "UNetConnection.AddReferencedObjects(UObject*,FReferenceCollector*)", InThis, Collector); }

    UWorld* GetWorld() { return NativeCall<UWorld*>(this, "UNetConnection.GetWorld()"); }

    bool Exec(UWorld* InWorld, const wchar_t* Cmd, FOutputDevice* Ar) { return NativeCall<bool, UWorld*, const wchar_t*, FOutputDevice*>(this, "UNetConnection.Exec(UWorld*,wchar_t*,FOutputDevice*)", InWorld, Cmd, Ar); }

    //FNetLevelVisibilityTransactionId* UpdateLevelStreamStatusChangedTransactionId(FNetLevelVisibilityTransactionId* result, const ULevelStreaming* LevelObject, const FName PackageName, bool bShouldBeVisible) { return NativeCall<FNetLevelVisibilityTransactionId*, FNetLevelVisibilityTransactionId*, const ULevelStreaming*, const FName, bool>(this, "UNetConnection.UpdateLevelStreamStatusChangedTransactionId(FNetLevelVisibilityTransactionId*,ULevelStreaming*,FName,bool)", result, LevelObject, PackageName, bShouldBeVisible); }

    bool ClientHasInitializedLevelFor(const AActor* TestActor) { return NativeCall<bool, const AActor*>(this, "UNetConnection.ClientHasInitializedLevelFor(AActor*)", TestActor); }

    bool UpdateCachedLevelVisibility(const FName* PackageName) { return NativeCall<bool, const FName*>(this, "UNetConnection.UpdateCachedLevelVisibility(FName*)", PackageName); }

    void UpdateAllCachedLevelVisibility() { NativeCall<void>(this, "UNetConnection.UpdateAllCachedLevelVisibility()"); }

    //void UpdateLevelVisibility(const FUpdateLevelVisibilityLevelInfo* LevelVisibility) { NativeCall<void, const FUpdateLevelVisibilityLevelInfo*>(this, "UNetConnection.UpdateLevelVisibility(FUpdateLevelVisibilityLevelInfo*)", LevelVisibility); }

    //void UpdateLevelVisibilityInternal(const FUpdateLevelVisibilityLevelInfo* LevelVisibility) { NativeCall<void, const FUpdateLevelVisibilityLevelInfo*>(this, "UNetConnection.UpdateLevelVisibilityInternal(FUpdateLevelVisibilityLevelInfo*)", LevelVisibility); }

    void ValidateSendBuffer() { NativeCall<void>(this, "UNetConnection.ValidateSendBuffer()"); }

    void InitSendBuffer() { NativeCall<void>(this, "UNetConnection.InitSendBuffer()"); }

    void ReceivedRawPacket(void* InData, int Count) { NativeCall<void, void*, int>(this, "UNetConnection.ReceivedRawPacket(void*,int)", InData, Count); }

    void PreTickDispatch() { NativeCall<void>(this, "UNetConnection.PreTickDispatch()"); }

    void PostTickDispatch() { NativeCall<void>(this, "UNetConnection.PostTickDispatch()"); }

    void FlushPacketOrderCache(bool bFlushWholeCache) { NativeCall<void, bool>(this, "UNetConnection.FlushPacketOrderCache(bool)", bFlushWholeCache); }

    void FlushNet(bool bIgnoreSimulation) { NativeCall<void, bool>(this, "UNetConnection.FlushNet(bool)", bIgnoreSimulation); }

    int IsNetReady(bool Saturate) { return NativeCall<int, bool>(this, "UNetConnection.IsNetReady(bool)", Saturate); }

    //void ReceivedAck(int AckPacketId, TArray<FChannelCloseInfo, TSizedInlineAllocator<8, 32, TSizedDefaultAllocator<32> > >* OutChannelsToClose) { NativeCall<void, int, TArray<FChannelCloseInfo, TSizedInlineAllocator<8, 32, TSizedDefaultAllocator<32> > >*>(this, "UNetConnection.ReceivedAck(int,TArray<FChannelCloseInfo,TSizedInlineAllocator<8,32,TSizedDefaultAllocator<32>>>*)", AckPacketId, OutChannelsToClose); }

    void ReceivedNak(int NakPacketId) { NativeCall<void, int>(this, "UNetConnection.ReceivedNak(int)", NakPacketId); }

    //void WritePacketHeader(FBitWriter* Writer) { NativeCall<void, FBitWriter*>(this, "UNetConnection.WritePacketHeader(FBitWriter*)", Writer); }

    //bool ReadPacketInfo(FBitReader* Reader, bool bHasPacketInfoPayload) { return NativeCall<bool, FBitReader*, bool>(this, "UNetConnection.ReadPacketInfo(FBitReader*,bool)", Reader, bHasPacketInfoPayload); }

    //FNetworkGUID* GetActorGUIDFromOpenBunch(FNetworkGUID* result, FInBunch* Bunch) { return NativeCall<FNetworkGUID*, FNetworkGUID*, FInBunch*>(this, "UNetConnection.GetActorGUIDFromOpenBunch(FNetworkGUID*,FInBunch*)", result, Bunch); }

    //void ReceivedPacket(FBitReader* Reader, bool bIsReinjectedPacket) { NativeCall<void, FBitReader*, bool>(this, "UNetConnection.ReceivedPacket(FBitReader*,bool)", Reader, bIsReinjectedPacket); }

    void RestoreRemappedChannel(const int ChIndex) { NativeCall<void, const int>(this, "UNetConnection.RestoreRemappedChannel(int)", ChIndex); }

    void SetAllowExistingChannelIndex(bool bAllow) { NativeCall<void, bool>(this, "UNetConnection.SetAllowExistingChannelIndex(bool)", bAllow); }

    void SetIgnoreReservedChannels(bool bInIgnoreReservedChannels) { NativeCall<void, bool>(this, "UNetConnection.SetIgnoreReservedChannels(bool)", bInIgnoreReservedChannels); }

    void PrepareWriteBitsToSendBuffer(const int SizeInBits, const int ExtraSizeInBits) { NativeCall<void, const int, const int>(this, "UNetConnection.PrepareWriteBitsToSendBuffer(int,int)", SizeInBits, ExtraSizeInBits); }

    //int WriteBitsToSendBufferInternal(const unsigned __int8* Bits, const int SizeInBits, const unsigned __int8* ExtraBits, const int ExtraSizeInBits, UNetConnection::EWriteBitsDataType DataType) { return NativeCall<int, const unsigned __int8*, const int, const unsigned __int8*, const int, UNetConnection::EWriteBitsDataType>(this, "UNetConnection.WriteBitsToSendBufferInternal(unsigned__int8*,int,unsigned__int8*,int,UNetConnection::EWriteBitsDataType)", Bits, SizeInBits, ExtraBits, ExtraSizeInBits, DataType); }

    //TSharedPtr<FObjectReplicator, 1>* CreateReplicatorForNewActorChannel(TSharedPtr<FObjectReplicator, 1>* result, UObject* Object) { return NativeCall<TSharedPtr<FObjectReplicator, 1> *, TSharedPtr<FObjectReplicator, 1>*, UObject*>(this, "UNetConnection.CreateReplicatorForNewActorChannel(TSharedPtr<FObjectReplicator,1>*,UObject*)", result, Object); }

    //int SendRawBunch(FOutBunch* Bunch, bool InAllowMerge, const FNetTraceCollector* BunchCollector) { return NativeCall<int, FOutBunch*, bool, const FNetTraceCollector*>(this, "UNetConnection.SendRawBunch(FOutBunch*,bool,FNetTraceCollector*)", Bunch, InAllowMerge, BunchCollector); }

    int GetFreeChannelIndex(const FName* ChName) { return NativeCall<int, const FName*>(this, "UNetConnection.GetFreeChannelIndex(FName*)", ChName); }

    UChannel* CreateChannelByName(const FName* ChName, EChannelCreateFlags CreateFlags, int ChIndex) { return NativeCall<UChannel*, const FName*, EChannelCreateFlags, int>(this, "UNetConnection.CreateChannelByName(FName*,EChannelCreateFlags,int)", ChName, CreateFlags, ChIndex); }

    //UVoiceChannel* GetVoiceChannel() { return NativeCall<UVoiceChannel*>(this, "UNetConnection.GetVoiceChannel()"); }

    //UBattlEyeChannel* GetBattlEyeChannel() { return NativeCall<UBattlEyeChannel*>(this, "UNetConnection.GetBattlEyeChannel()"); }

    float GetTimeoutValue() { return NativeCall<float>(this, "UNetConnection.GetTimeoutValue()"); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "UNetConnection.Tick(float)", DeltaSeconds); }

    void HandleConnectionTimeout(const FString* Error) { NativeCall<void, const FString*>(this, "UNetConnection.HandleConnectionTimeout(FString&)", Error); }

    void HandleClientPlayer(APlayerController* PC, UNetConnection* NetConnection) { NativeCall<void, APlayerController*, UNetConnection*>(this, "UNetConnection.HandleClientPlayer(APlayerController*,UNetConnection*)", PC, NetConnection); }

    bool ShouldReplicateVoicePacketFrom(const FUniqueNetId* Sender) { return NativeCall<bool, const FUniqueNetId*>(this, "UNetConnection.ShouldReplicateVoicePacketFrom(FUniqueNetId*)", Sender); }

    void ResetGameWorldState() { NativeCall<void>(this, "UNetConnection.ResetGameWorldState()"); }

    void ClearDormantReplicatorsReference() { NativeCall<void>(this, "UNetConnection.ClearDormantReplicatorsReference()"); }

    void FlushDormancy(AActor* Actor) { NativeCall<void, AActor*>(this, "UNetConnection.FlushDormancy(AActor*)", Actor); }

    void FlushDormancyForObject(AActor* DormantActor, UObject* ReplicatedObject) { NativeCall<void, AActor*, UObject*>(this, "UNetConnection.FlushDormancyForObject(AActor*,UObject*)", DormantActor, ReplicatedObject); }

    void DestroyIgnoredActor(AActor* Actor) { NativeCall<void, AActor*>(this, "UNetConnection.DestroyIgnoredActor(AActor*)", Actor); }

    void CleanupDormantReplicatorsForActor(AActor* Actor) { NativeCall<void, AActor*>(this, "UNetConnection.CleanupDormantReplicatorsForActor(AActor*)", Actor); }

    void SendChallengeControlMessage() { NativeCall<void>(this, "UNetConnection.SendChallengeControlMessage()"); }

    //void SendChallengeControlMessage(const FEncryptionKeyResponse* Response) { NativeCall<void, const FEncryptionKeyResponse*>(this, "UNetConnection.SendChallengeControlMessage(FEncryptionKeyResponse*)", Response); }

    void NotifyActorDestroyed(AActor* Actor, bool IsSeamlessTravel) { NativeCall<void, AActor*, bool>(this, "UNetConnection.NotifyActorDestroyed(AActor*,bool)", Actor, IsSeamlessTravel); }

    //void NotifyActorChannelCleanedUp(UActorChannel* Channel, EChannelCloseReason CloseReason) { NativeCall<void, UActorChannel*, EChannelCloseReason>(this, "UNetConnection.NotifyActorChannelCleanedUp(UActorChannel*,EChannelCloseReason)", Channel, CloseReason); }

    void SetNetVersionsOnArchive(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UNetConnection.SetNetVersionsOnArchive(FArchive*)", Ar); }

    void Primal_ReceivedNakRange(int StartingNakPacketId, int RangeLength) { NativeCall<void, int, int>(this, "UNetConnection.Primal_ReceivedNakRange(int,int)", StartingNakPacketId, RangeLength); }

    bool CanMulticast(AActor* toActor, bool bCheckDormancy) { return NativeCall<bool, AActor*, bool>(this, "UNetConnection.CanMulticast(AActor*,bool)", toActor, bCheckDormancy); }

};


struct APlayerState : AInfo

{

    // Fields


    float& ScoreField() { return *GetNativePointerField<float*>(this, "APlayerState.Score"); }

    int& PlayerIdField() { return *GetNativePointerField<int*>(this, "APlayerState.PlayerId"); }

    unsigned __int8& CurPingBucketField() { return *GetNativePointerField<unsigned __int8*>(this, "APlayerState.CurPingBucket"); }

    int& StartTimeField() { return *GetNativePointerField<int*>(this, "APlayerState.StartTime"); }

    TSubclassOf<ULocalMessage>& EngineMessageClassField() { return *GetNativePointerField<TSubclassOf<ULocalMessage>*>(this, "APlayerState.EngineMessageClass"); }

    float& ExactPingField() { return *GetNativePointerField<float*>(this, "APlayerState.ExactPing"); }

    float& ExactPingV2Field() { return *GetNativePointerField<float*>(this, "APlayerState.ExactPingV2"); }

    FString& SavedNetworkAddressField() { return *GetNativePointerField<FString*>(this, "APlayerState.SavedNetworkAddress"); }

    FUniqueNetIdRepl& UniqueIdField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "APlayerState.UniqueId"); }

    FName& SessionNameField() { return *GetNativePointerField<FName*>(this, "APlayerState.SessionName"); }

    FOnPlayerStatePawnSet& OnPawnSetField() { return *GetNativePointerField<FOnPlayerStatePawnSet*>(this, "APlayerState.OnPawnSet"); }

    TObjectPtr<APawn>& PawnPrivateField() { return *GetNativePointerField<TObjectPtr<APawn>*>(this, "APlayerState.PawnPrivate"); }

    FieldArray<PingAvgData, 4> PingBucketField() { return { this, "APlayerState.PingBucket" }; }

    //FieldArray<PingAvgDataV2, 4> PingBucketV2Field() { return { this, "APlayerState.PingBucketV2" }; }

    float& CurPingBucketTimestampField() { return *GetNativePointerField<float*>(this, "APlayerState.CurPingBucketTimestamp"); }

    FString& PlayerNamePrivateField() { return *GetNativePointerField<FString*>(this, "APlayerState.PlayerNamePrivate"); }

    FString& OldNamePrivateField() { return *GetNativePointerField<FString*>(this, "APlayerState.OldNamePrivate"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bShouldUpdateReplicatedPing() { return { this, "APlayerState.bShouldUpdateReplicatedPing" }; }

    BitFieldValue<bool, unsigned __int32> bIsSpectator() { return { this, "APlayerState.bIsSpectator" }; }

    BitFieldValue<bool, unsigned __int32> bOnlySpectator() { return { this, "APlayerState.bOnlySpectator" }; }

    BitFieldValue<bool, unsigned __int32> bIsABot() { return { this, "APlayerState.bIsABot" }; }

    BitFieldValue<bool, unsigned __int32> bHasBeenWelcomed() { return { this, "APlayerState.bHasBeenWelcomed" }; }

    BitFieldValue<bool, unsigned __int32> bIsInactive() { return { this, "APlayerState.bIsInactive" }; }

    BitFieldValue<bool, unsigned __int32> bFromPreviousLevel() { return { this, "APlayerState.bFromPreviousLevel" }; }

    BitFieldValue<bool, unsigned __int32> bUseCustomPlayerNames() { return { this, "APlayerState.bUseCustomPlayerNames" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APlayerState.StaticClass()"); }

    FString* GetPlayerNameCustom(FString* result) { return NativeCall<FString*, FString*>(this, "APlayerState.GetPlayerNameCustom()", result); }

    bool IsSpectator() { return NativeCall<bool>(this, "APlayerState.IsSpectator()"); }

    static void StaticRegisterNativesAPlayerState() { NativeCall<void>(nullptr, "APlayerState.StaticRegisterNativesAPlayerState()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "APlayerState.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void UpdatePing(float InPing) { NativeCall<void, float>(this, "APlayerState.UpdatePing(float)", InPing); }

    void RecalculateAvgPing() { NativeCall<void>(this, "APlayerState.RecalculateAvgPing()"); }

    void OverrideWith(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.OverrideWith(APlayerState*)", PlayerState); }

    void PostInitializeComponents() { NativeCall<void>(this, "APlayerState.PostInitializeComponents()"); }

    void ClientInitialize(AController* C) { NativeCall<void, AController*>(this, "APlayerState.ClientInitialize(AController*)", C); }

    void OnRep_bIsInactive() { NativeCall<void>(this, "APlayerState.OnRep_bIsInactive()"); }

    bool ShouldBroadCastWelcomeMessage(bool bExiting) { return NativeCall<bool, bool>(this, "APlayerState.ShouldBroadCastWelcomeMessage(bool)", bExiting); }

    void Destroyed() { NativeCall<void>(this, "APlayerState.Destroyed()"); }

    FString* GetHumanReadableName(FString* result) { return NativeCall<FString*, FString*>(this, "APlayerState.GetHumanReadableName()", result); }

    void OnRep_PlayerName() { NativeCall<void>(this, "APlayerState.OnRep_PlayerName()"); }

    void SetPlayerNameInternal(const FString* S) { NativeCall<void, const FString*>(this, "APlayerState.SetPlayerNameInternal(FString&)", S); }

    void SetPlayerName(const FString* S) { NativeCall<void, const FString*>(this, "APlayerState.SetPlayerName(FString&)", S); }

    FString* GetPlayerName(FString* result) { return NativeCall<FString*, FString*>(this, "APlayerState.GetPlayerName()", result); }

    FString* GetOldPlayerName(FString* result) { return NativeCall<FString*, FString*>(this, "APlayerState.GetOldPlayerName()", result); }

    void SetOldPlayerName(const FString* S) { NativeCall<void, const FString*>(this, "APlayerState.SetOldPlayerName(FString&)", S); }

    void HandleWelcomeMessage() { NativeCall<void>(this, "APlayerState.HandleWelcomeMessage()"); }

    void OnRep_UniqueId() { NativeCall<void>(this, "APlayerState.OnRep_UniqueId()"); }

    void RegisterPlayerWithSession(bool bWasFromInvite) { NativeCall<void, bool>(this, "APlayerState.RegisterPlayerWithSession(bool)", bWasFromInvite); }

    void UnregisterPlayerWithSession() { NativeCall<void>(this, "APlayerState.UnregisterPlayerWithSession()"); }

    APlayerState* Duplicate() { return NativeCall<APlayerState*>(this, "APlayerState.Duplicate()"); }

    void SeamlessTravelTo(APlayerState* NewPlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.SeamlessTravelTo(APlayerState*)", NewPlayerState); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "APlayerState.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void SetUniqueId(const TSharedPtr<FUniqueNetId const>* InUniqueId) { NativeCall<void, const TSharedPtr<FUniqueNetId const>*>(this, "APlayerState.SetUniqueId(TSharedPtr<FUniqueNetId,1>&)", InUniqueId); }

    void SetUniqueId(FUniqueNetIdRepl* NewUniqueId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerState.SetUniqueId(FUniqueNetIdRepl&&)", NewUniqueId); }

    void SetPawnPrivate(APawn* InPawn) { NativeCall<void, APawn*>(this, "APlayerState.SetPawnPrivate(APawn*)", InPawn); }

};


struct AShooterPlayerState : APlayerState

{

    // Fields


    UPrimalPlayerData*& MyPlayerDataField() { return *GetNativePointerField<UPrimalPlayerData**>(this, "AShooterPlayerState.MyPlayerData"); }

    FPrimalPlayerDataStruct& MyPlayerDataStructField() { return *GetNativePointerField<FPrimalPlayerDataStruct*>(this, "AShooterPlayerState.MyPlayerDataStruct"); }

    FieldArray<TSubclassOf<UPrimalItem>, 10> DefaultItemSlotClassesField() { return { this, "AShooterPlayerState.DefaultItemSlotClasses" }; }

    FieldArray<unsigned __int8, 10> DefaultItemSlotEngramsField() { return { this, "AShooterPlayerState.DefaultItemSlotEngrams" }; }

    FTribeData& MyTribeDataField() { return *GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.MyTribeData"); }

    FTribeData& LastTribeInviteDataField() { return *GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.LastTribeInviteData"); }

    //TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>& OnClientAdminInfoPlayerConnectedRecivedField() { return *GetNativePointerField<TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerState.OnClientAdminInfoPlayerConnectedRecived"); }

    TDelegate<void __cdecl(FServerOptions), FDefaultDelegateUserPolicy>& OnClientServerOptionsInfoRecivedField() { return *GetNativePointerField<TDelegate<void __cdecl(FServerOptions), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerState.OnClientServerOptionsInfoRecived"); }

    //TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>& OnClientAdminInfoPlayerBannedRecivedField() { return *GetNativePointerField<TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerState.OnClientAdminInfoPlayerBannedRecived"); }

    //TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>& OnClientAdminInfoPlayerAdministratorRecivedField() { return *GetNativePointerField<TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerState.OnClientAdminInfoPlayerAdministratorRecived"); }

    //TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>& OnClientAdminInfoPlayerWhiteListedRecivedField() { return *GetNativePointerField<TDelegate<void __cdecl(TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerState.OnClientAdminInfoPlayerWhiteListedRecived"); }

    TArray<FSpawnPointInfo, TSizedDefaultAllocator<32> >& CachedSpawnPointInfosField() { return *GetNativePointerField<TArray<FSpawnPointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.CachedSpawnPointInfos"); }

    int& TotalEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.TotalEngramPoints"); }

    int& FreeEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.FreeEngramPoints"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& EngramItemBlueprintsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.EngramItemBlueprints"); }

    TSet<TSubclassOf<UPrimalItem>, DefaultKeyFuncs<TSubclassOf<UPrimalItem>, 0>, FDefaultSetAllocator>& ServerEngramItemBlueprintsSetField() { return *GetNativePointerField<TSet<TSubclassOf<UPrimalItem>, DefaultKeyFuncs<TSubclassOf<UPrimalItem>, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerState.ServerEngramItemBlueprintsSet"); }

    long double& NextAllowedRespawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.NextAllowedRespawnTime"); }

    float& AllowedRespawnIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerState.AllowedRespawnInterval"); }

    long double& LastTimeDiedToEnemyTeamField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTimeDiedToEnemyTeam"); }

    int& CurrentlySelectedDinoOrderGroupField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.CurrentlySelectedDinoOrderGroup"); }

    FieldArray<FDinoOrderGroup, 10> DinoOrderGroupsField() { return { this, "AShooterPlayerState.DinoOrderGroups" }; }

    long double& GenesisAbilityErrorLastTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.GenesisAbilityErrorLastTime"); }

    long double& NextAllowTurretCopySettingsTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.NextAllowTurretCopySettingsTime"); }

    long double& LastTribeRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTribeRequestTime"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bQuitter() { return { this, "AShooterPlayerState.bQuitter" }; }


    // Functions


    void ClientRefreshDinoOrderGroup(int groupIndex, FDinoOrderGroup* groupData, int UseCurrentlySelectedGroup) { NativeCall<void, int, FDinoOrderGroup*, int>(this, "AShooterPlayerState.ClientRefreshDinoOrderGroup(int,FDinoOrderGroup,int)", groupIndex, groupData, UseCurrentlySelectedGroup); }

    void ServerAcceptTribeWar(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerAcceptTribeWar(int)", EnemyTeamID); }

    void ServerDinoOrderGroup_AddOrRemoveDinoCharacter(int groupIndex, APrimalDinoCharacter* DinoCharacter, bool bAdd) { NativeCall<void, int, APrimalDinoCharacter*, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoCharacter(int,APrimalDinoCharacter*,bool)", groupIndex, DinoCharacter, bAdd); }

    void ServerGetAllPlayerNamesAndLocations() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAllPlayerNamesAndLocations()"); }

    void ServerRequestApplyEngramPoints(TSubclassOf<UPrimalItem> forItemEntry) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints(TSubclassOf<UPrimalItem>)", forItemEntry); }

    void ServerRequestCreateNewTribe(const FString* TribeName, FTribeGovernment* TribeGovernment) { NativeCall<void, const FString*, FTribeGovernment*>(this, "AShooterPlayerState.ServerRequestCreateNewTribe(FString&,FTribeGovernment)", TribeName, TribeGovernment); }

    void ServerRequestLeaveTribe() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestLeaveTribe()"); }

    void ServerRequestRenameTribe(const FString* ServerRequestRenameTribe) { NativeCall<void, const FString*>(this, "AShooterPlayerState.ServerRequestRenameTribe(FString&)", ServerRequestRenameTribe); }

    void ServerRequestSetTribeMemberGroupRank(int PlayerIndexInTribe, int RankGroupIndex) { NativeCall<void, int, int>(this, "AShooterPlayerState.ServerRequestSetTribeMemberGroupRank(int,int)", PlayerIndexInTribe, RankGroupIndex); }

    void ServerRequestSpawnPointsForDownloadedCharacters(unsigned __int64 PlayerDataID, int IgnoreBedID) { NativeCall<void, unsigned __int64, int>(this, "AShooterPlayerState.ServerRequestSpawnPointsForDownloadedCharacters(unsigned__int64,int)", PlayerDataID, IgnoreBedID); }

    void ServerSetDefaultItemSlotClass(int slotNum, TSubclassOf<UPrimalItem> ItemClass, bool bIsEngram) { NativeCall<void, int, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerState.ServerSetDefaultItemSlotClass(int,TSubclassOf<UPrimalItem>,bool)", slotNum, ItemClass, bIsEngram); }

    static void StaticRegisterNativesAShooterPlayerState() { NativeCall<void>(nullptr, "AShooterPlayerState.StaticRegisterNativesAShooterPlayerState()"); }

    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AShooterPlayerState.GetPrivateStaticClass()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void Reset() { NativeCall<void>(this, "AShooterPlayerState.Reset()"); }

    void RegisterPlayerWithSession(bool bWasFromInvite) { NativeCall<void, bool>(this, "AShooterPlayerState.RegisterPlayerWithSession(bool)", bWasFromInvite); }

    void OverrideWith(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "AShooterPlayerState.OverrideWith(APlayerState*)", PlayerState); }

    void UnregisterPlayerWithSession() { NativeCall<void>(this, "AShooterPlayerState.UnregisterPlayerWithSession()"); }

    void ClientInitialize(AController* InController) { NativeCall<void, AController*>(this, "AShooterPlayerState.ClientInitialize(AController*)", InController); }

    void CopyProperties(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "AShooterPlayerState.CopyProperties(APlayerState*)", PlayerState); }

    void ServerGetAllPlayerNamesAndLocations_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAllPlayerNamesAndLocations_Implementation()"); }

    void ServerGetAlivePlayerConnectedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAlivePlayerConnectedData_Implementation()"); }

    void ServerGetPlayerConnectedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerConnectedData_Implementation()"); }

    void ServerGetServerOptions_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetServerOptions_Implementation()"); }

    void ServerGetPlayerBannedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerBannedData_Implementation()"); }

    void ServerGetPlayerAdministratorData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerAdministratorData_Implementation()"); }

    //void ClientGetAlivePlayerConnectedData_Implementation(const TArray<FAlivePlayerDataInfo, TSizedDefaultAllocator<32> >* list) { NativeCall<void, const TArray<FAlivePlayerDataInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientGetAlivePlayerConnectedData_Implementation(TArray<FAlivePlayerDataInfo,TSizedDefaultAllocator<32>>&)", list); }

    //void ClientGetAllPlayerNamesAndLocations_Implementation(const TArray<FAliveNameAndLocation, TSizedDefaultAllocator<32> >* list) { NativeCall<void, const TArray<FAliveNameAndLocation, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientGetAllPlayerNamesAndLocations_Implementation(TArray<FAliveNameAndLocation,TSizedDefaultAllocator<32>>&)", list); }

    //void ClientGetPlayerConnectedData_Implementation(const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >* list) { NativeCall<void, const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientGetPlayerConnectedData_Implementation(TArray<FAdminPlayerDataInfo,TSizedDefaultAllocator<32>>&)", list); }

    //void ClientGetServerOptions_Implementation(FServerOptions* info) { NativeCall<void, FServerOptions*>(this, "AShooterPlayerState.ClientGetServerOptions_Implementation(FServerOptions)", info); }

    //void ClientGetPlayerBannedData_Implementation(const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >* list) { NativeCall<void, const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientGetPlayerBannedData_Implementation(TArray<FAdminPlayerDataInfo,TSizedDefaultAllocator<32>>&)", list); }

    //void ClientGetPlayerAdministratorData_Implementation(const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >* list) { NativeCall<void, const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientGetPlayerAdministratorData_Implementation(TArray<FAdminPlayerDataInfo,TSizedDefaultAllocator<32>>&)", list); }

    //void ClientGetPlayerWhiteListedData_Implementation(const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >* list) { NativeCall<void, const TArray<FAdminPlayerDataInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientGetPlayerWhiteListedData_Implementation(TArray<FAdminPlayerDataInfo,TSizedDefaultAllocator<32>>&)", list); }

    void BroadcastDeath_Implementation(AShooterPlayerState* KillerPlayerState, const UDamageType* KillerDamageType, AShooterPlayerState* KilledPlayerState) { NativeCall<void, AShooterPlayerState*, const UDamageType*, AShooterPlayerState*>(this, "AShooterPlayerState.BroadcastDeath_Implementation(AShooterPlayerState*,UDamageType*,AShooterPlayerState*)", KillerPlayerState, KillerDamageType, KilledPlayerState); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void Destroyed() { NativeCall<void>(this, "AShooterPlayerState.Destroyed()"); }

    void BeginPlay() { NativeCall<void>(this, "AShooterPlayerState.BeginPlay()"); }

    void PromoteToTribeAdmin(APlayerController* PromoterPC) { NativeCall<void, APlayerController*>(this, "AShooterPlayerState.PromoteToTribeAdmin(APlayerController*)", PromoterPC); }

    bool AddToTribe(const FTribeData* MyNewTribe, bool bMergeTribe, bool bForce, bool bIsFromInvite, APlayerController* InviterPC) { return NativeCall<bool, const FTribeData*, bool, bool, bool, APlayerController*>(this, "AShooterPlayerState.AddToTribe(FTribeData&,bool,bool,bool,APlayerController*)", MyNewTribe, bMergeTribe, bForce, bIsFromInvite, InviterPC); }

    void UpdateTribeData(const FTribeData* TribeData) { NativeCall<void, const FTribeData*>(this, "AShooterPlayerState.UpdateTribeData(FTribeData&)", TribeData); }

    void ClearTribe(bool bDontRemoveFromTribe, bool bForce, APlayerController* ForPC) { NativeCall<void, bool, bool, APlayerController*>(this, "AShooterPlayerState.ClearTribe(bool,bool,APlayerController*)", bDontRemoveFromTribe, bForce, ForPC); }

    bool IsInTribe() { return NativeCall<bool>(this, "AShooterPlayerState.IsInTribe()"); }

    void TransferTribalObjects(const FTribeData* TribeData, bool bTransferToTribe, bool bDontIncludePlayers) { NativeCall<void, const FTribeData*, bool, bool>(this, "AShooterPlayerState.TransferTribalObjects(FTribeData&,bool,bool)", TribeData, bTransferToTribe, bDontIncludePlayers); }

    bool IsTribeOwner(unsigned int CheckPlayerDataID) { return NativeCall<bool, unsigned int>(this, "AShooterPlayerState.IsTribeOwner(unsignedint)", CheckPlayerDataID); }

    bool IsExclusivelyTribeOwner(unsigned int CheckPlayerDataID) { return NativeCall<bool, unsigned int>(this, "AShooterPlayerState.IsExclusivelyTribeOwner(unsignedint)", CheckPlayerDataID); }

    bool IsTribeAdmin() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeAdmin()"); }

    bool IsExclusivelyTribeAdmin(unsigned int CheckPlayerDataID) { return NativeCall<bool, unsigned int>(this, "AShooterPlayerState.IsExclusivelyTribeAdmin(unsignedint)", CheckPlayerDataID); }

    void ServerRequestDinoOrderGroups_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestDinoOrderGroups_Implementation()"); }

    void ClientRefreshDinoOrderGroup_Implementation(int groupIndex, FDinoOrderGroup* groupData, int UseCurrentlySelectedGroup) { NativeCall<void, int, FDinoOrderGroup*, int>(this, "AShooterPlayerState.ClientRefreshDinoOrderGroup_Implementation(int,FDinoOrderGroup,int)", groupIndex, groupData, UseCurrentlySelectedGroup); }

    bool AllowDinoOrderByGroup(APrimalDinoCharacter* orderDino) { return NativeCall<bool, APrimalDinoCharacter*>(this, "AShooterPlayerState.AllowDinoOrderByGroup(APrimalDinoCharacter*)", orderDino); }

    void ServerDinoOrderGroup_AddOrRemoveDinoClass_Implementation(int groupIndex, TSubclassOf<APrimalDinoCharacter> DinoClass, bool bAdd) { NativeCall<void, int, TSubclassOf<APrimalDinoCharacter>, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoClass_Implementation(int,TSubclassOf<APrimalDinoCharacter>,bool)", groupIndex, DinoClass, bAdd); }

    void ServerSetDinoGroupName_Implementation(int groupIndex, const FString* GroupName) { NativeCall<void, int, const FString*>(this, "AShooterPlayerState.ServerSetDinoGroupName_Implementation(int,FString&)", groupIndex, GroupName); }

    FString* GetDinoOrderGroupName(FString* result, int groupIndex) { return NativeCall<FString*, FString*, int>(this, "AShooterPlayerState.GetDinoOrderGroupName(int)", result, groupIndex); }

    bool IsDinoInOrderGroup(int groupIndex, APrimalDinoCharacter* dinoChar) { return NativeCall<bool, int, APrimalDinoCharacter*>(this, "AShooterPlayerState.IsDinoInOrderGroup(int,APrimalDinoCharacter*)", groupIndex, dinoChar); }

    bool IsDinoClassInOrderGroup(int groupIndex, TSubclassOf<APrimalDinoCharacter> dinoClass) { return NativeCall<bool, int, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerState.IsDinoClassInOrderGroup(int,TSubclassOf<APrimalDinoCharacter>)", groupIndex, dinoClass); }

    void ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation(int groupIndex, APrimalDinoCharacter* DinoCharacter, bool bAdd) { NativeCall<void, int, APrimalDinoCharacter*, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation(int,APrimalDinoCharacter*,bool)", groupIndex, DinoCharacter, bAdd); }

    void ServerDinoOrderGroup_Clear_Implementation(int groupIndex, bool bClearClasses, bool bClearChars) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_Clear_Implementation(int,bool,bool)", groupIndex, bClearClasses, bClearChars); }

    void ServerDinoOrderGroup_RemoveEntryByIndex_Implementation(int groupIndex, bool bIsClass, int entryIndex) { NativeCall<void, int, bool, int>(this, "AShooterPlayerState.ServerDinoOrderGroup_RemoveEntryByIndex_Implementation(int,bool,int)", groupIndex, bIsClass, entryIndex); }

    void ServerSetSelectedDinoOrderGroup_Implementation(int newGroup) { NativeCall<void, int>(this, "AShooterPlayerState.ServerSetSelectedDinoOrderGroup_Implementation(int)", newGroup); }

    void ServerRequestRenameTribe_Implementation(const FString* TribeName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.ServerRequestRenameTribe_Implementation(FString&)", TribeName); }

    void ServerRequestSetTribeGovernment_Implementation(FTribeGovernment* TribeGovernment) { NativeCall<void, FTribeGovernment*>(this, "AShooterPlayerState.ServerRequestSetTribeGovernment_Implementation(FTribeGovernment)", TribeGovernment); }

    void ServerRequestCreateNewTribe_Implementation(const FString* TribeName, FTribeGovernment* TribeGovernment) { NativeCall<void, const FString*, FTribeGovernment*>(this, "AShooterPlayerState.ServerRequestCreateNewTribe_Implementation(FString&,FTribeGovernment)", TribeName, TribeGovernment); }

    void ServerRequestLeaveTribe_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestLeaveTribe_Implementation()"); }

    void ServerRequestRemovePlayerIndexFromMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestRemovePlayerIndexFromMyTribe_Implementation(int)", PlayerIndexInTribe); }

    void ServerRequestPromotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestPromotePlayerInMyTribe_Implementation(int)", PlayerIndexInTribe); }

    void ServerRequestDemotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestDemotePlayerInMyTribe_Implementation(int)", PlayerIndexInTribe); }

    void InvitedRankGroupPlayerIntoTribe(AShooterPlayerState* OtherPlayer) { NativeCall<void, AShooterPlayerState*>(this, "AShooterPlayerState.InvitedRankGroupPlayerIntoTribe(AShooterPlayerState*)", OtherPlayer); }

    void ServerRequestSetTribeMemberGroupRank_Implementation(int PlayerIndexInTribe, int RankGroupIndex) { NativeCall<void, int, int>(this, "AShooterPlayerState.ServerRequestSetTribeMemberGroupRank_Implementation(int,int)", PlayerIndexInTribe, RankGroupIndex); }

    void ServerTribeRequestAddRankGroup_Implementation(const FString* GroupName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.ServerTribeRequestAddRankGroup_Implementation(FString&)", GroupName); }

    void ServerTribeRequestRemoveRankGroup_Implementation(int RankGroupIndex) { NativeCall<void, int>(this, "AShooterPlayerState.ServerTribeRequestRemoveRankGroup_Implementation(int)", RankGroupIndex); }

    void ServerTribeRequestApplyRankGroupSettings_Implementation(int RankGroupIndex, FTribeRankGroup* newGroupSettings) { NativeCall<void, int, FTribeRankGroup*>(this, "AShooterPlayerState.ServerTribeRequestApplyRankGroupSettings_Implementation(int,FTribeRankGroup)", RankGroupIndex, newGroupSettings); }

    void ServerTribeRequestNewRallyPoint_Implementation(FTeamPingData* RallyPointData) { NativeCall<void, FTeamPingData*>(this, "AShooterPlayerState.ServerTribeRequestNewRallyPoint_Implementation(FTeamPingData)", RallyPointData); }

    void ClientUpdateNewRallyPoint_Implementation(bool DestroyRallyPoint, FTeamPingData* RallyPointData) { NativeCall<void, bool, FTeamPingData*>(this, "AShooterPlayerState.ClientUpdateNewRallyPoint_Implementation(bool,FTeamPingData)", DestroyRallyPoint, RallyPointData); }

    void ServerRequestTransferOwnershipInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestTransferOwnershipInMyTribe_Implementation(int)", PlayerIndexInTribe); }

    FString* GetPlayerName(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerState.GetPlayerName()", result); }

    void ServerRequestMySpawnPoints_Implementation(int IgnoreBedID, TSubclassOf<APrimalStructure> FilterClass) { NativeCall<void, int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerState.ServerRequestMySpawnPoints_Implementation(int,TSubclassOf<APrimalStructure>)", IgnoreBedID, FilterClass); }

    void ClientReceiveSpawnPoints_Implementation(const TArray<FSpawnPointInfo, TSizedDefaultAllocator<32> >* SpawnPointsInfos) { NativeCall<void, const TArray<FSpawnPointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerState.ClientReceiveSpawnPoints_Implementation(TArray<FSpawnPointInfo,TSizedDefaultAllocator<32>>&)", SpawnPointsInfos); }

    void ServerRequestCreateNewPlayer_Implementation(FPrimalPlayerCharacterConfigStructReplicated* PlayerCharacterConfig) { NativeCall<void, FPrimalPlayerCharacterConfigStructReplicated*>(this, "AShooterPlayerState.ServerRequestCreateNewPlayer_Implementation(FPrimalPlayerCharacterConfigStructReplicated)", PlayerCharacterConfig); }

    void ServerRequestApplyEngramPoints_Implementation(TSubclassOf<UPrimalItem> forItemEntry) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints_Implementation(TSubclassOf<UPrimalItem>)", forItemEntry); }

    void ServerUnlockEngram(TSubclassOf<UPrimalItem> forItemEntry, bool bNotifyPlayerHUD, bool bForceUnlock) { NativeCall<void, TSubclassOf<UPrimalItem>, bool, bool>(this, "AShooterPlayerState.ServerUnlockEngram(TSubclassOf<UPrimalItem>,bool,bool)", forItemEntry, bNotifyPlayerHUD, bForceUnlock); }

    void AddEngramBlueprintToPlayerInventory(UPrimalInventoryComponent* invComp, TSubclassOf<UPrimalItem> engramItemBlueprint) { NativeCall<void, UPrimalInventoryComponent*, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.AddEngramBlueprintToPlayerInventory(UPrimalInventoryComponent*,TSubclassOf<UPrimalItem>)", invComp, engramItemBlueprint); }

    AShooterPlayerController* GetShooterController() { return NativeCall<AShooterPlayerController*>(this, "AShooterPlayerState.GetShooterController()"); }

    void GetDataListEntries(TArray<IDataListEntryInterface*, TSizedDefaultAllocator<32> >* OutDataListEntries, int DataListType, bool bCreateFolders, char FolderLevel, TArray<FString, TSizedDefaultAllocator<32> >* FoldersFound, UObject* ForObject, const wchar_t* CustomFolderFilter, char SortType, const wchar_t* NameFilter) { NativeCall<void, TArray<IDataListEntryInterface*, TSizedDefaultAllocator<32> >*, int, bool, char, TArray<FString, TSizedDefaultAllocator<32> >*, UObject*, const wchar_t*, char, const wchar_t*>(this, "AShooterPlayerState.GetDataListEntries(TArray<IDataListEntryInterface*,TSizedDefaultAllocator<32>>&,int,bool,signedchar,TArray<FString,TSizedDefaultAllocator<32>>*,UObject*,wchar_t*,signedchar,wchar_t*,bool,bool,bool)", OutDataListEntries, DataListType, bCreateFolders, FolderLevel, FoldersFound, ForObject, CustomFolderFilter, SortType, NameFilter); }

    UObject* GetObject() { return NativeCall<UObject*>(this, "AShooterPlayerState.GetObject()"); }

    bool GetEntryDefaultEnabled(IDataListEntryInterface* entryInterface) { return NativeCall<bool, IDataListEntryInterface*>(this, "AShooterPlayerState.GetEntryDefaultEnabled(IDataListEntryInterface*)", entryInterface); }

    FString* GetEntryDefaultTextOverride(FString* result, IDataListEntryInterface* entryInterface) { return NativeCall<FString*, FString*, IDataListEntryInterface*>(this, "AShooterPlayerState.GetEntryDefaultTextOverride(IDataListEntryInterface*)", result, entryInterface); }

    void GetEntryCustomColor(IDataListEntryInterface* entryInterface, FLinearColor* CustomColor, FLinearColor* TextColorOverride) { NativeCall<void, IDataListEntryInterface*, FLinearColor*, FLinearColor*>(this, "AShooterPlayerState.GetEntryCustomColor(IDataListEntryInterface*,FLinearColor&,FLinearColor*)", entryInterface, CustomColor, TextColorOverride); }

    FString* GetEngramEntryCostTextOverride(FString* result, IDataListEntryInterface* entryInterface) { return NativeCall<FString*, FString*, IDataListEntryInterface*>(this, "AShooterPlayerState.GetEngramEntryCostTextOverride(IDataListEntryInterface*)", result, entryInterface); }

    bool HasEngram(TSubclassOf<UPrimalItem> ItemClass) { return NativeCall<bool, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.HasEngram(TSubclassOf<UPrimalItem>)", ItemClass); }

    void ReceivedPlayerCharacter(AShooterCharacter* NewPawn) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerState.ReceivedPlayerCharacter(AShooterCharacter*)", NewPawn); }

    void NotifyPlayerJoinedTribe_Implementation(const FString* ThePlayerName, const FString* TribeName, bool Joinee) { NativeCall<void, const FString*, const FString*, bool>(this, "AShooterPlayerState.NotifyPlayerJoinedTribe_Implementation(FString&,FString&,bool)", ThePlayerName, TribeName, Joinee); }

    void NotifyPlayerLeftTribe_Implementation(const FString* ThePlayerName, const FString* TribeName, bool Joinee) { NativeCall<void, const FString*, const FString*, bool>(this, "AShooterPlayerState.NotifyPlayerLeftTribe_Implementation(FString&,FString&,bool)", ThePlayerName, TribeName, Joinee); }

    void NotifyAllianceChanged_Implementation() { NativeCall<void>(this, "AShooterPlayerState.NotifyAllianceChanged_Implementation()"); }

    void NotifyPlayerJoined_Implementation(const FString* ThePlayerName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.NotifyPlayerJoined_Implementation(FString&)", ThePlayerName); }

    void NotifyTribememberJoined_Implementation(const FString* ThePlayerName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.NotifyTribememberJoined_Implementation(FString&)", ThePlayerName); }

    void NotifyPlayerLeft_Implementation(const FString* ThePlayerName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.NotifyPlayerLeft_Implementation(FString&)", ThePlayerName); }

    void NotifyTribememberLeft_Implementation(const FString* ThePlayerName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.NotifyTribememberLeft_Implementation(FString&)", ThePlayerName); }

    void NotifyUniqueDinoDownloaded_Implementation(const FString* TheDinoName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloaded_Implementation(FString&)", TheDinoName); }

    void NotifyUniqueDinoDownloadAllowed_Implementation(const FString* TheDinoName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloadAllowed_Implementation(FString&)", TheDinoName); }

    FString* GetPlayerOrTribeName(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerState.GetPlayerOrTribeName()", result); }

    void ServerSetDefaultItemSlotClass_Implementation(int slotNum, TSubclassOf<UPrimalItem> ItemClass, bool bIsEngram) { NativeCall<void, int, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerState.ServerSetDefaultItemSlotClass_Implementation(int,TSubclassOf<UPrimalItem>,bool)", slotNum, ItemClass, bIsEngram); }

    void ClientNotifyLevelUpAvailable_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ClientNotifyLevelUpAvailable_Implementation()"); }

    int GetCharacterLevel() { return NativeCall<int>(this, "AShooterPlayerState.GetCharacterLevel()"); }

    void SetTribeTamingDinoSettings(APrimalDinoCharacter* aDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerState.SetTribeTamingDinoSettings(APrimalDinoCharacter*)", aDinoChar); }

    void SendTribeInviteData_Implementation(FTribeData* TribeInviteData) { NativeCall<void, FTribeData*>(this, "AShooterPlayerState.SendTribeInviteData_Implementation(FTribeData)", TribeInviteData); }

    int GetHexCostToPurchaseNextEngramPoint() { return NativeCall<int>(this, "AShooterPlayerState.GetHexCostToPurchaseNextEngramPoint()"); }

    void DoRespec(UPrimalPlayerData* ForPlayerData, AShooterCharacter* ForCharacter, bool bSetRespecedAtCharacterLevel) { NativeCall<void, UPrimalPlayerData*, AShooterCharacter*, bool>(this, "AShooterPlayerState.DoRespec(UPrimalPlayerData*,AShooterCharacter*,bool)", ForPlayerData, ForCharacter, bSetRespecedAtCharacterLevel); }

    int GetTribeId() { return NativeCall<int>(this, "AShooterPlayerState.GetTribeId()"); }

    FString* GetUniqueNetIdAsString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerState.GetUniqueNetIdAsString()", result); }

    bool IsInTribeWar(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsInTribeWar(int)", EnemyTeam); }

    void ServerDeclareTribeWar_Implementation(int EnemyTeamID, int StartDayNum, int EndDayNumber, float WarStartTime, float WarEndTime) { NativeCall<void, int, int, int, float, float>(this, "AShooterPlayerState.ServerDeclareTribeWar_Implementation(int,int,int,float,float)", EnemyTeamID, StartDayNum, EndDayNumber, WarStartTime, WarEndTime); }

    void ServerAcceptTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerAcceptTribeWar_Implementation(int)", EnemyTeamID); }

    void ServerRejectTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRejectTribeWar_Implementation(int)", EnemyTeamID); }

    FTribeWar* GetTribeWar(FTribeWar* result, int EnemyTeam) { return NativeCall<FTribeWar*, FTribeWar*, int>(this, "AShooterPlayerState.GetTribeWar(int)", result, EnemyTeam); }

    void ServerRequestRemoveAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestRemoveAllianceMember_Implementation(unsignedint,unsignedint)", AllianceID, MemberID); }

    void ServerRequestPromoteAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestPromoteAllianceMember_Implementation(unsignedint,unsignedint)", AllianceID, MemberID); }

    void ServerTribeRequestNewAlliance_Implementation(const FString* AllianceName) { NativeCall<void, const FString*>(this, "AShooterPlayerState.ServerTribeRequestNewAlliance_Implementation(FString&)", AllianceName); }

    void ServerRequestLeaveAlliance_Implementation(unsigned int AllianceID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestLeaveAlliance_Implementation(unsignedint)", AllianceID); }

    void AcceptJoinAlliance(unsigned int AllianceID, unsigned int NewMemberID, FString* NewMemberName) { NativeCall<void, unsigned int, unsigned int, FString*>(this, "AShooterPlayerState.AcceptJoinAlliance(unsignedint,unsignedint,FString)", AllianceID, NewMemberID, NewMemberName); }

    bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject* OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerState.AllowTribeGroupPermission(ETribeGroupPermission::Type,UObject*)", TribeGroupPermission, OnObject); }

    void ServerRequestSpawnPointsForDownloadedCharacters_Implementation(unsigned __int64 PlayerDataID, int IgnoreBedID) { NativeCall<void, unsigned __int64, int>(this, "AShooterPlayerState.ServerRequestSpawnPointsForDownloadedCharacters_Implementation(unsigned__int64,int)", PlayerDataID, IgnoreBedID); }

    void UpdatedPlayerData() { NativeCall<void>(this, "AShooterPlayerState.UpdatedPlayerData()"); }

};


struct AController : AActor

{

    // Fields


    TObjectPtr<APlayerState>& PlayerStateField() { return *GetNativePointerField<TObjectPtr<APlayerState>*>(this, "AController.PlayerState"); }

    TWeakObjectPtr<AActor>& StartSpotField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AController.StartSpot"); }

    FInstigatedAnyDamageSignature& OnInstigatedAnyDamageField() { return *GetNativePointerField<FInstigatedAnyDamageSignature*>(this, "AController.OnInstigatedAnyDamage"); }

    FOnPossessedPawnChanged& OnPossessedPawnChangedField() { return *GetNativePointerField<FOnPossessedPawnChanged*>(this, "AController.OnPossessedPawnChanged"); }

    FName& StateNameField() { return *GetNativePointerField<FName*>(this, "AController.StateName"); }

    TObjectPtr<APawn>& PawnField() { return *GetNativePointerField<TObjectPtr<APawn>*>(this, "AController.Pawn"); }

    TWeakObjectPtr<APawn>& OldPawnField() { return *GetNativePointerField<TWeakObjectPtr<APawn>*>(this, "AController.OldPawn"); }

    TObjectPtr<ACharacter>& CharacterField() { return *GetNativePointerField<TObjectPtr<ACharacter>*>(this, "AController.Character"); }

    TObjectPtr<USceneComponent>& TransformComponentField() { return *GetNativePointerField<TObjectPtr<USceneComponent>*>(this, "AController.TransformComponent"); }

    TMulticastDelegate<void __cdecl(APawn*), FDefaultDelegateUserPolicy>& OnNewPawnField() { return *GetNativePointerField<TMulticastDelegate<void __cdecl(APawn*), FDefaultDelegateUserPolicy>*>(this, "AController.OnNewPawn"); }

    UE::Math::TRotator<double>& ControlRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "AController.ControlRotation"); }

    unsigned __int8& IgnoreMoveInputField() { return *GetNativePointerField<unsigned __int8*>(this, "AController.IgnoreMoveInput"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bAttachToPawn() { return { this, "AController.bAttachToPawn" }; }

    BitFieldValue<bool, unsigned __int32> bIsPlayerController() { return { this, "AController.bIsPlayerController" }; }

    BitFieldValue<bool, unsigned __int32> bCanPossessWithoutAuthority() { return { this, "AController.bCanPossessWithoutAuthority" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AController.StaticClass()"); }

    void FailedToSpawnPawn() { NativeCall<void>(this, "AController.FailedToSpawnPawn()"); }

    void ClientSetRotation(UE::Math::TRotator<double>* NewRotation, bool bResetCamera) { NativeCall<void, UE::Math::TRotator<double>*, bool>(this, "AController.ClientSetRotation(UE::Math::TRotator<double>,bool)", NewRotation, bResetCamera); }

    static void StaticRegisterNativesAController() { NativeCall<void>(nullptr, "AController.StaticRegisterNativesAController()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "AController.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    bool IsLocalController() { return NativeCall<bool>(this, "AController.IsLocalController()"); }

    void SetInitialLocationAndRotation(const UE::Math::TVector<double>* NewLocation, const UE::Math::TRotator<double>* NewRotation) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*>(this, "AController.SetInitialLocationAndRotation(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", NewLocation, NewRotation); }

    void SetControlRotation(const UE::Math::TRotator<double>* NewRotation) { NativeCall<void, const UE::Math::TRotator<double>*>(this, "AController.SetControlRotation(UE::Math::TRotator<double>&)", NewRotation); }

    void SetIgnoreMoveInput(bool bNewMoveInput) { NativeCall<void, bool>(this, "AController.SetIgnoreMoveInput(bool)", bNewMoveInput); }

    void ResetIgnoreMoveInput() { NativeCall<void>(this, "AController.ResetIgnoreMoveInput()"); }

    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "AController.IsMoveInputIgnored()"); }

    void SetIgnoreLookInput(bool bNewLookInput) { NativeCall<void, bool>(this, "AController.SetIgnoreLookInput(bool)", bNewLookInput); }

    void ResetIgnoreLookInput() { NativeCall<void>(this, "AController.ResetIgnoreLookInput()"); }

    bool IsLookInputIgnored() { return NativeCall<bool>(this, "AController.IsLookInputIgnored()"); }

    void ResetIgnoreInputFlags() { NativeCall<void>(this, "AController.ResetIgnoreInputFlags()"); }

    void AttachToPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.AttachToPawn(APawn*)", InPawn); }

    void DetachFromPawn() { NativeCall<void>(this, "AController.DetachFromPawn()"); }

    AActor* GetViewTarget() { return NativeCall<AActor*>(this, "AController.GetViewTarget()"); }

    void GetPlayerViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AController.GetPlayerViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    bool LineOfSightTo(const AActor* Other, UE::Math::TVector<double>* ViewPoint, __int64 bAlternateChecks) { return NativeCall<bool, const AActor*, UE::Math::TVector<double>*, __int64>(this, "AController.LineOfSightTo(AActor*,UE::Math::TVector<double>,bool)", Other, ViewPoint, bAlternateChecks); }

    void PostInitializeComponents() { NativeCall<void>(this, "AController.PostInitializeComponents()"); }

    void Possess(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.Possess(APawn*)", InPawn); }

    void OnPossess(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.OnPossess(APawn*)", InPawn); }

    void UnPossess() { NativeCall<void>(this, "AController.UnPossess()"); }

    void OnUnPossess() { NativeCall<void>(this, "AController.OnUnPossess()"); }

    void PawnPendingDestroy(APawn* inPawn) { NativeCall<void, APawn*>(this, "AController.PawnPendingDestroy(APawn*)", inPawn); }

    void Reset() { NativeCall<void>(this, "AController.Reset()"); }

    void ClientSetLocation_Implementation(UE::Math::TVector<double>* NewLocation, UE::Math::TRotator<double>* NewRotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AController.ClientSetLocation_Implementation(UE::Math::TVector<double>,UE::Math::TRotator<double>)", NewLocation, NewRotation); }

    void ClientSetRotation_Implementation(UE::Math::TRotator<double>* NewRotation, __int64 bResetCamera) { NativeCall<void, UE::Math::TRotator<double>*, __int64>(this, "AController.ClientSetRotation_Implementation(UE::Math::TRotator<double>,bool)", NewRotation, bResetCamera); }

    void RemovePawnTickDependency(APawn* InOldPawn) { NativeCall<void, APawn*>(this, "AController.RemovePawnTickDependency(APawn*)", InOldPawn); }

    void AddPawnTickDependency(APawn* NewPawn) { NativeCall<void, APawn*>(this, "AController.AddPawnTickDependency(APawn*)", NewPawn); }

    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.SetPawn(APawn*)", InPawn); }

    void OnRep_Pawn() { NativeCall<void>(this, "AController.OnRep_Pawn()"); }

    void OnRep_PlayerState() { NativeCall<void>(this, "AController.OnRep_PlayerState()"); }

    void Destroyed() { NativeCall<void>(this, "AController.Destroyed()"); }

    void CleanupPlayerState() { NativeCall<void>(this, "AController.CleanupPlayerState()"); }

    void InstigatedAnyDamage(float Damage, const UDamageType* DamageType, AActor* DamagedActor, AActor* DamageCauser) { NativeCall<void, float, const UDamageType*, AActor*, AActor*>(this, "AController.InstigatedAnyDamage(float,UDamageType*,AActor*,AActor*)", Damage, DamageType, DamagedActor, DamageCauser); }

    void InitPlayerState() { NativeCall<void>(this, "AController.InitPlayerState()"); }

    void GetActorEyesViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AController.GetActorEyesViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo* DebugDisplay, float* YL, float* YPos) { NativeCall<void, UCanvas*, const FDebugDisplayInfo*, float*, float*>(this, "AController.DisplayDebug(UCanvas*,FDebugDisplayInfo&,float&,float&)", Canvas, DebugDisplay, YL, YPos); }

    FString* GetHumanReadableName(FString* result) { return NativeCall<FString*, FString*>(this, "AController.GetHumanReadableName()", result); }

    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "AController.ChangeState(FName)", NewState); }

    bool IsInState(FName InStateName) { return NativeCall<bool, FName>(this, "AController.IsInState(FName)", InStateName); }

    const FNavAgentProperties* GetNavAgentPropertiesRef() { return NativeCall<const FNavAgentProperties*>(this, "AController.GetNavAgentPropertiesRef()"); }

    void GetMoveGoalReachTest(const AActor* MovingActor, const UE::Math::TVector<double>* MoveOffset, UE::Math::TVector<double>* GoalOffset, float* GoalRadius, float* GoalHalfHeight) { NativeCall<void, const AActor*, const UE::Math::TVector<double>*, UE::Math::TVector<double>*, float*, float*>(this, "AController.GetMoveGoalReachTest(AActor*,UE::Math::TVector<double>&,UE::Math::TVector<double>&,float&,float&)", MovingActor, MoveOffset, GoalOffset, GoalRadius, GoalHalfHeight); }

    bool ShouldPostponePathUpdates() { return NativeCall<bool>(this, "AController.ShouldPostponePathUpdates()"); }

    bool IsFollowingAPath() { return NativeCall<bool>(this, "AController.IsFollowingAPath()"); }

    IPathFollowingAgentInterface* GetPathFollowingAgent() { return NativeCall<IPathFollowingAgentInterface*>(this, "AController.GetPathFollowingAgent()"); }

    void StopMovement() { NativeCall<void>(this, "AController.StopMovement()"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "AController.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    bool ShouldParticipateInSeamlessTravel() { return NativeCall<bool>(this, "AController.ShouldParticipateInSeamlessTravel()"); }

    void TickActor(float DeltaSeconds, ELevelTick TickType, FActorTickFunction* ThisTickFunction) { NativeCall<void, float, ELevelTick, FActorTickFunction*>(this, "AController.TickActor(float,ELevelTick,FActorTickFunction&)", DeltaSeconds, TickType, ThisTickFunction); }

};


struct APrimalController : AController

{

    // Fields


    int& LastValidUnstasisCasterFrameField() { return *GetNativePointerField<int*>(this, "APrimalController.LastValidUnstasisCasterFrame"); }

    long double& ServerLastReceivedSpectatorLocTimeField() { return *GetNativePointerField<long double*>(this, "APrimalController.ServerLastReceivedSpectatorLocTime"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bDebugPathing() { return { this, "APrimalController.bDebugPathing" }; }


    // Functions


    AActor* GetAimedUseActor(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation, bool bForceUpdateAimedActors) { return NativeCall<AActor*, UActorComponent**, int*, bool, bool>(this, "APrimalController.GetAimedUseActor(UActorComponent**,int*,bool,bool)", UseComponent, hitBodyIndex, bForceUseActorLocation, bForceUpdateAimedActors); }

    APawn* GetResponsibleDamager(AActor* DamageCauser) { return NativeCall<APawn*, AActor*>(this, "APrimalController.GetResponsibleDamager(AActor*)", DamageCauser); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalController.StaticClass()"); }

};


struct APlayerController : APrimalController, PlayerControllerExtensions

{

    // Fields


    TObjectPtr<UPlayer>& PlayerField() { return *GetNativePointerField<TObjectPtr<UPlayer>*>(this, "APlayerController.Player"); }

    TObjectPtr<APawn>& AcknowledgedPawnField() { return *GetNativePointerField<TObjectPtr<APawn>*>(this, "APlayerController.AcknowledgedPawn"); }

    TObjectPtr<UInterpTrackInstDirector>& ControllingDirTrackInstField() { return *GetNativePointerField<TObjectPtr<UInterpTrackInstDirector>*>(this, "APlayerController.ControllingDirTrackInst"); }

    TObjectPtr<AHUD>& MyHUDField() { return *GetNativePointerField<TObjectPtr<AHUD>*>(this, "APlayerController.MyHUD"); }

    TObjectPtr<APlayerCameraManager>& PlayerCameraManagerField() { return *GetNativePointerField<TObjectPtr<APlayerCameraManager>*>(this, "APlayerController.PlayerCameraManager"); }

    TSubclassOf<APlayerCameraManager>& PlayerCameraManagerClassField() { return *GetNativePointerField<TSubclassOf<APlayerCameraManager>*>(this, "APlayerController.PlayerCameraManagerClass"); }

    UE::Math::TRotator<double>& TargetViewRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APlayerController.TargetViewRotation"); }

    UE::Math::TRotator<double>& BlendedTargetViewRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APlayerController.BlendedTargetViewRotation"); }

    float& SmoothTargetViewRotationSpeedField() { return *GetNativePointerField<float*>(this, "APlayerController.SmoothTargetViewRotationSpeed"); }

    float& LocalPlayerCachedLODDistanceFactorField() { return *GetNativePointerField<float*>(this, "APlayerController.LocalPlayerCachedLODDistanceFactor"); }

    TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >& HiddenActorsField() { return *GetNativePointerField<TArray<TObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "APlayerController.HiddenActors"); }

    TArray<TWeakObjectPtr<UPrimitiveComponent>, TSizedDefaultAllocator<32> >& HiddenPrimitiveComponentsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UPrimitiveComponent>, TSizedDefaultAllocator<32> >*>(this, "APlayerController.HiddenPrimitiveComponents"); }

    long double& LastSpectatorStateSynchTimeField() { return *GetNativePointerField<long double*>(this, "APlayerController.LastSpectatorStateSynchTime"); }

    UE::Math::TVector<double>& LastSpectatorSyncLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APlayerController.LastSpectatorSyncLocation"); }

    UE::Math::TRotator<double>& LastSpectatorSyncRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APlayerController.LastSpectatorSyncRotation"); }

    int& ClientCapField() { return *GetNativePointerField<int*>(this, "APlayerController.ClientCap"); }

    TObjectPtr<UCheatManager>& CheatManagerField() { return *GetNativePointerField<TObjectPtr<UCheatManager>*>(this, "APlayerController.CheatManager"); }

    TSubclassOf<UCheatManager>& CheatClassField() { return *GetNativePointerField<TSubclassOf<UCheatManager>*>(this, "APlayerController.CheatClass"); }

    TObjectPtr<UPlayerInput>& PlayerInputField() { return *GetNativePointerField<TObjectPtr<UPlayerInput>*>(this, "APlayerController.PlayerInput"); }

    TArray<FActiveForceFeedbackEffect, TSizedDefaultAllocator<32> >& ActiveForceFeedbackEffectsField() { return *GetNativePointerField<TArray<FActiveForceFeedbackEffect, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ActiveForceFeedbackEffects"); }

    TSubclassOf<UAsyncPhysicsData>& AsyncPhysicsDataClassField() { return *GetNativePointerField<TSubclassOf<UAsyncPhysicsData>*>(this, "APlayerController.AsyncPhysicsDataClass"); }

    TObjectPtr<UAsyncPhysicsInputComponent>& AsyncPhysicsDataComponentField() { return *GetNativePointerField<TObjectPtr<UAsyncPhysicsInputComponent>*>(this, "APlayerController.AsyncPhysicsDataComponent"); }

    //TSortedMap<unsigned __int64, APlayerController::FDynamicForceFeedbackAction, TSizedDefaultAllocator<32>, TLess<unsigned __int64 const > >& DynamicForceFeedbacksField() { return *GetNativePointerField<TSortedMap<unsigned __int64, APlayerController::FDynamicForceFeedbackAction, TSizedDefaultAllocator<32>, TLess<unsigned __int64 const > >*>(this, "APlayerController.DynamicForceFeedbacks"); }

    TSortedMap<int, FDynamicForceFeedbackDetails*, TSizedDefaultAllocator<32>, TLess<int const > >& LatentDynamicForceFeedbacksField() { return *GetNativePointerField<TSortedMap<int, FDynamicForceFeedbackDetails*, TSizedDefaultAllocator<32>, TLess<int const > >*>(this, "APlayerController.LatentDynamicForceFeedbacks"); }

    TSharedPtr<FActiveHapticFeedbackEffect>& ActiveHapticEffect_LeftField() { return *GetNativePointerField<TSharedPtr<FActiveHapticFeedbackEffect>*>(this, "APlayerController.ActiveHapticEffect_Left"); }

    TSharedPtr<FActiveHapticFeedbackEffect>& ActiveHapticEffect_RightField() { return *GetNativePointerField<TSharedPtr<FActiveHapticFeedbackEffect>*>(this, "APlayerController.ActiveHapticEffect_Right"); }

    TSharedPtr<FActiveHapticFeedbackEffect>& ActiveHapticEffect_GunField() { return *GetNativePointerField<TSharedPtr<FActiveHapticFeedbackEffect>*>(this, "APlayerController.ActiveHapticEffect_Gun"); }

    TSharedPtr<FActiveHapticFeedbackEffect>& ActiveHapticEffect_HMDField() { return *GetNativePointerField<TSharedPtr<FActiveHapticFeedbackEffect>*>(this, "APlayerController.ActiveHapticEffect_HMD"); }

    FForceFeedbackValues& ForceFeedbackValuesField() { return *GetNativePointerField<FForceFeedbackValues*>(this, "APlayerController.ForceFeedbackValues"); }

    TArray<FName, TSizedDefaultAllocator<32> >& PendingMapChangeLevelNamesField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APlayerController.PendingMapChangeLevelNames"); }

    FPlayerMuteList& MuteListField() { return *GetNativePointerField<FPlayerMuteList*>(this, "APlayerController.MuteList"); }

    TObjectPtr<UNetConnection>& PendingSwapConnectionField() { return *GetNativePointerField<TObjectPtr<UNetConnection>*>(this, "APlayerController.PendingSwapConnection"); }

    TObjectPtr<UNetConnection>& NetConnectionField() { return *GetNativePointerField<TObjectPtr<UNetConnection>*>(this, "APlayerController.NetConnection"); }

    UE::Math::TRotator<double>& RotationInputField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APlayerController.RotationInput"); }

    float& InputYawScale_DEPRECATEDField() { return *GetNativePointerField<float*>(this, "APlayerController.InputYawScale_DEPRECATED"); }

    float& InputPitchScale_DEPRECATEDField() { return *GetNativePointerField<float*>(this, "APlayerController.InputPitchScale_DEPRECATED"); }

    float& InputRollScale_DEPRECATEDField() { return *GetNativePointerField<float*>(this, "APlayerController.InputRollScale_DEPRECATED"); }

    FColor& StreamingSourceDebugColorField() { return *GetNativePointerField<FColor*>(this, "APlayerController.StreamingSourceDebugColor"); }

    //TArray<FStreamingSourceShape, TSizedDefaultAllocator<32> >& StreamingSourceShapesField() { return *GetNativePointerField<TArray<FStreamingSourceShape, TSizedDefaultAllocator<32> >*>(this, "APlayerController.StreamingSourceShapes"); }

    float& ForceFeedbackScaleField() { return *GetNativePointerField<float*>(this, "APlayerController.ForceFeedbackScale"); }

    TArray<FKey, TSizedDefaultAllocator<32> >& ClickEventKeysField() { return *GetNativePointerField<TArray<FKey, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ClickEventKeys"); }

    //TEnumAsByte<enum EMouseCursor::Type>& CurrentMouseCursorField() { return *GetNativePointerField<TEnumAsByte<enum EMouseCursor::Type>*>(this, "APlayerController.CurrentMouseCursor"); }

    TEnumAsByte<enum ECollisionChannel>& CurrentClickTraceChannelField() { return *GetNativePointerField<TEnumAsByte<enum ECollisionChannel>*>(this, "APlayerController.CurrentClickTraceChannel"); }

    float& HitResultTraceDistanceField() { return *GetNativePointerField<float*>(this, "APlayerController.HitResultTraceDistance"); }

    unsigned __int16& SeamlessTravelCountField() { return *GetNativePointerField<unsigned __int16*>(this, "APlayerController.SeamlessTravelCount"); }

    unsigned __int16& LastCompletedSeamlessTravelCountField() { return *GetNativePointerField<unsigned __int16*>(this, "APlayerController.LastCompletedSeamlessTravelCount"); }

    TArray<FName, TSizedDefaultAllocator<32> >& NetConditionGroupsField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APlayerController.NetConditionGroups"); }

    TWeakObjectPtr<UPrimitiveComponent>& CurrentClickablePrimitiveField() { return *GetNativePointerField<TWeakObjectPtr<UPrimitiveComponent>*>(this, "APlayerController.CurrentClickablePrimitive"); }

    FieldArray<TWeakObjectPtr<UPrimitiveComponent>, 11> CurrentTouchablePrimitivesField() { return { this, "APlayerController.CurrentTouchablePrimitives" }; }

    TArray<TWeakObjectPtr<UInputComponent>, TSizedDefaultAllocator<32> >& CurrentInputStackField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UInputComponent>, TSizedDefaultAllocator<32> >*>(this, "APlayerController.CurrentInputStack"); }

    TObjectPtr<UInputComponent>& InactiveStateInputComponentField() { return *GetNativePointerField<TObjectPtr<UInputComponent>*>(this, "APlayerController.InactiveStateInputComponent"); }

    //TSharedPtr<SVirtualJoystick, 1>& VirtualJoystickField() { return *GetNativePointerField<TSharedPtr<SVirtualJoystick, 1>*>(this, "APlayerController.VirtualJoystick"); }

    //TObjectPtr<UTouchInterface>& CurrentTouchInterfaceField() { return *GetNativePointerField<TObjectPtr<UTouchInterface>*>(this, "APlayerController.CurrentTouchInterface"); }

    TSubclassOf<UPlayerInput>& OverridePlayerInputClassField() { return *GetNativePointerField<TSubclassOf<UPlayerInput>*>(this, "APlayerController.OverridePlayerInputClass"); }

    FTimerHandle& TimerHandle_UnFreezeField() { return *GetNativePointerField<FTimerHandle*>(this, "APlayerController.TimerHandle_UnFreeze"); }

    FTimerHandle& TimerHandle_DelayedPrepareMapChangeField() { return *GetNativePointerField<FTimerHandle*>(this, "APlayerController.TimerHandle_DelayedPrepareMapChange"); }

    FTimerHandle& TimerHandle_ClientCommitMapChangeField() { return *GetNativePointerField<FTimerHandle*>(this, "APlayerController.TimerHandle_ClientCommitMapChange"); }

    TWeakObjectPtr<USceneComponent>& AudioListenerComponentField() { return *GetNativePointerField<TWeakObjectPtr<USceneComponent>*>(this, "APlayerController.AudioListenerComponent"); }

    TWeakObjectPtr<USceneComponent>& AudioListenerAttenuationComponentField() { return *GetNativePointerField<TWeakObjectPtr<USceneComponent>*>(this, "APlayerController.AudioListenerAttenuationComponent"); }

    UE::Math::TVector<double>& AudioListenerLocationOverrideField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APlayerController.AudioListenerLocationOverride"); }

    UE::Math::TRotator<double>& AudioListenerRotationOverrideField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APlayerController.AudioListenerRotationOverride"); }

    UE::Math::TVector<double>& AudioListenerAttenuationOverrideField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APlayerController.AudioListenerAttenuationOverride"); }

    TObjectPtr<ASpectatorPawn>& SpectatorPawnField() { return *GetNativePointerField<TObjectPtr<ASpectatorPawn>*>(this, "APlayerController.SpectatorPawn"); }

    long double& LastRetryPlayerTimeField() { return *GetNativePointerField<long double*>(this, "APlayerController.LastRetryPlayerTime"); }

    UE::Math::TVector<double>& SpawnLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APlayerController.SpawnLocation"); }

    float& LastMovementUpdateTimeField() { return *GetNativePointerField<float*>(this, "APlayerController.LastMovementUpdateTime"); }

    float& LastMovementHitchField() { return *GetNativePointerField<float*>(this, "APlayerController.LastMovementHitch"); }

    //APlayerController::FInputCmdBuffer& InputBufferField() { return *GetNativePointerField<APlayerController::FInputCmdBuffer*>(this, "APlayerController.InputBuffer"); }

    //APlayerController::FClientFrameInfo& ClientFrameInfoField() { return *GetNativePointerField<APlayerController::FClientFrameInfo*>(this, "APlayerController.ClientFrameInfo"); }

    //APlayerController::FServerFrameInfo& ServerFrameInfoField() { return *GetNativePointerField<APlayerController::FServerFrameInfo*>(this, "APlayerController.ServerFrameInfo"); }

    int& LocalToServerAsyncPhysicsTickOffsetField() { return *GetNativePointerField<int*>(this, "APlayerController.LocalToServerAsyncPhysicsTickOffset"); }

    int& ClientLatestCorrectedOffsetServerStepField() { return *GetNativePointerField<int*>(this, "APlayerController.ClientLatestCorrectedOffsetServerStep"); }

    int& ClientLatestAsyncPhysicsStepSentField() { return *GetNativePointerField<int*>(this, "APlayerController.ClientLatestAsyncPhysicsStepSent"); }

    int& ClientLatestTimeDilationServerStepField() { return *GetNativePointerField<int*>(this, "APlayerController.ClientLatestTimeDilationServerStep"); }

    float& ServerAsyncPhysicsTimeDilationToSendField() { return *GetNativePointerField<float*>(this, "APlayerController.ServerAsyncPhysicsTimeDilationToSend"); }

    //FAsyncPhysicsTimestamp& ServerLatestTimestampToCorrectField() { return *GetNativePointerField<FAsyncPhysicsTimestamp*>(this, "APlayerController.ServerLatestTimestampToCorrect"); }

    //TArray<FAsyncPhysicsTimestamp, TSizedDefaultAllocator<32> >& ServerPendingTimestampsField() { return *GetNativePointerField<TArray<FAsyncPhysicsTimestamp, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ServerPendingTimestamps"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bShortConnectTimeOut() { return { this, "APlayerController.bShortConnectTimeOut" }; }

    BitFieldValue<bool, unsigned __int32> bCinematicMode() { return { this, "APlayerController.bCinematicMode" }; }

    BitFieldValue<bool, unsigned __int32> bHidePawnInCinematicMode() { return { this, "APlayerController.bHidePawnInCinematicMode" }; }

    BitFieldValue<bool, unsigned __int32> bIsUsingStreamingVolumes() { return { this, "APlayerController.bIsUsingStreamingVolumes" }; }

    BitFieldValue<bool, unsigned __int32> bPlayerIsWaiting() { return { this, "APlayerController.bPlayerIsWaiting" }; }

    BitFieldValue<bool, unsigned __int32> bShowMouseCursor() { return { this, "APlayerController.bShowMouseCursor" }; }

    BitFieldValue<bool, unsigned __int32> bEnableClickEvents() { return { this, "APlayerController.bEnableClickEvents" }; }

    BitFieldValue<bool, unsigned __int32> bEnableTouchEvents() { return { this, "APlayerController.bEnableTouchEvents" }; }

    BitFieldValue<bool, unsigned __int32> bEnableMouseOverEvents() { return { this, "APlayerController.bEnableMouseOverEvents" }; }

    BitFieldValue<bool, unsigned __int32> bEnableTouchOverEvents() { return { this, "APlayerController.bEnableTouchOverEvents" }; }

    BitFieldValue<bool, unsigned __int32> bForceFeedbackEnabled() { return { this, "APlayerController.bForceFeedbackEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bEnableMotionControls() { return { this, "APlayerController.bEnableMotionControls" }; }

    BitFieldValue<bool, unsigned __int32> bEnableStreamingSource() { return { this, "APlayerController.bEnableStreamingSource" }; }

    BitFieldValue<bool, unsigned __int32> bStreamingSourceShouldActivate() { return { this, "APlayerController.bStreamingSourceShouldActivate" }; }

    BitFieldValue<bool, unsigned __int32> bStreamingSourceShouldBlockOnSlowStreaming() { return { this, "APlayerController.bStreamingSourceShouldBlockOnSlowStreaming" }; }

    BitFieldValue<bool, unsigned __int32> bCinemaDisableInputMove() { return { this, "APlayerController.bCinemaDisableInputMove" }; }

    BitFieldValue<bool, unsigned __int32> bCinemaDisableInputLook() { return { this, "APlayerController.bCinemaDisableInputLook" }; }

    BitFieldValue<bool, unsigned __int32> bShouldPerformFullTickWhenPaused() { return { this, "APlayerController.bShouldPerformFullTickWhenPaused" }; }

    BitFieldValue<bool, unsigned __int32> bInputEnabled() { return { this, "APlayerController.bInputEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideAudioListener() { return { this, "APlayerController.bOverrideAudioListener" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideAudioAttenuationListener() { return { this, "APlayerController.bOverrideAudioAttenuationListener" }; }

    BitFieldValue<bool, unsigned __int32> bDisableHaptics() { return { this, "APlayerController.bDisableHaptics" }; }

    BitFieldValue<bool, unsigned __int32> bShouldFlushInputWhenViewportFocusChanges() { return { this, "APlayerController.bShouldFlushInputWhenViewportFocusChanges" }; }


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "APlayerController.GetPrivateStaticClass()"); }

    const UObject* GetStreamingSourceOwner() { return NativeCall<const UObject*>(this, "APlayerController.GetStreamingSourceOwner()"); }

    bool ShouldFlushKeysWhenViewportFocusChanges() { return NativeCall<bool>(this, "APlayerController.ShouldFlushKeysWhenViewportFocusChanges()"); }

    EStreamingSourcePriority GetStreamingSourcePriority() { return NativeCall<EStreamingSourcePriority>(this, "APlayerController.GetStreamingSourcePriority()"); }

    bool StreamingSourceShouldBlockOnSlowStreaming() { return NativeCall<bool>(this, "APlayerController.StreamingSourceShouldBlockOnSlowStreaming()"); }

    bool StreamingSourceShouldActivate() { return NativeCall<bool>(this, "APlayerController.StreamingSourceShouldActivate()"); }

    bool IsStreamingSourceEnabled() { return NativeCall<bool>(this, "APlayerController.IsStreamingSourceEnabled()"); }

    void GameHasEnded(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.GameHasEnded(AActor*,bool)", EndGameFocus, bIsWinner); }

    unsigned __int64 GetSpectatorPawn() { return NativeCall<unsigned __int64>(this, "APlayerController.GetSpectatorPawn()"); }

    void FlushPressedKeys() { NativeCall<void>(this, "APlayerController.FlushPressedKeys()"); }

    void ClientClearCameraLensEffects() { NativeCall<void>(this, "APlayerController.ClientClearCameraLensEffects()"); }

    void ClientCommitMapChange() { NativeCall<void>(this, "APlayerController.ClientCommitMapChange()"); }

    void ClientEnableNetworkVoice(bool bEnable) { NativeCall<void, bool>(this, "APlayerController.ClientEnableNetworkVoice(bool)", bEnable); }

    void ClientGotoState(FName NewState) { NativeCall<void, FName>(this, "APlayerController.ClientGotoState(FName)", NewState); }

    void ClientMessage(const FString* S, FName Type, float MsgLifeTime) { NativeCall<void, const FString*, FName, float>(this, "APlayerController.ClientMessage(FString&,FName,float)", S, Type, MsgLifeTime); }

    void ClientMutePlayer(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ClientMutePlayer(FUniqueNetIdRepl)", PlayerId); }

    void ClientRepObjRef(UObject* Object) { NativeCall<void, UObject*>(this, "APlayerController.ClientRepObjRef(UObject*)", Object); }

    void ClientRetryClientRestart(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRetryClientRestart(APawn*)", NewPawn); }

    void ClientReturnToMainMenu(const FString* ReturnReason) { NativeCall<void, const FString*>(this, "APlayerController.ClientReturnToMainMenu(FString&)", ReturnReason); }

    void ClientReturnToMainMenuWithTextReason(const FText* ReturnReason) { NativeCall<void, const FText*>(this, "APlayerController.ClientReturnToMainMenuWithTextReason(FText&)", ReturnReason); }

    //void ClientStartCameraShake(TSubclassOf<UCameraShakeBase> Shake, float Scale, ECameraShakePlaySpace PlaySpace, UE::Math::TRotator<double>* UserPlaySpaceRot, float Speed) { NativeCall<void, TSubclassOf<UCameraShakeBase>, float, ECameraShakePlaySpace, UE::Math::TRotator<double>*, float>(this, "APlayerController.ClientStartCameraShake(TSubclassOf<UCameraShakeBase>,float,ECameraShakePlaySpace,UE::Math::TRotator<double>,float,bool)", Shake, Scale, PlaySpace, UserPlaySpaceRot, Speed); }

    //void ClientStopCameraShake(TSubclassOf<UCameraShakeBase> Shake, bool bImmediately) { NativeCall<void, TSubclassOf<UCameraShakeBase>, bool>(this, "APlayerController.ClientStopCameraShake(TSubclassOf<UCameraShakeBase>,bool)", Shake, bImmediately); }

    void ClientTeamMessage(APlayerState* SenderPlayerState, const FString* S, FName Type, float MsgLifeTime) { NativeCall<void, APlayerState*, const FString*, FName, float>(this, "APlayerController.ClientTeamMessage(APlayerState*,FString&,FName,float)", SenderPlayerState, S, Type, MsgLifeTime); }

    void ClientUnmutePlayer(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ClientUnmutePlayer(FUniqueNetIdRepl)", PlayerId); }

    void ClientUnmutePlayers(const TArray<FUniqueNetIdRepl, TSizedDefaultAllocator<32> >* PlayerIds) { NativeCall<void, const TArray<FUniqueNetIdRepl, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ClientUnmutePlayers(TArray<FUniqueNetIdRepl,TSizedDefaultAllocator<32>>&)", PlayerIds); }

    //void ClientUpdateMultipleLevelsStreamingStatus(const TArray<FUpdateLevelStreamingLevelStatus, TSizedDefaultAllocator<32> >* LevelStatuses) { NativeCall<void, const TArray<FUpdateLevelStreamingLevelStatus, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ClientUpdateMultipleLevelsStreamingStatus(TArray<FUpdateLevelStreamingLevelStatus,TSizedDefaultAllocator<32>>&)", LevelStatuses); }

    void ClientVoiceHandshakeComplete() { NativeCall<void>(this, "APlayerController.ClientVoiceHandshakeComplete()"); }

    void ClientWasKicked(const FText* KickReason) { NativeCall<void, const FText*>(this, "APlayerController.ClientWasKicked(FText&)", KickReason); }

    void CopyStringToClipboard(const FString* S) { NativeCall<void, const FString*>(this, "APlayerController.CopyStringToClipboard(FString&)", S); }

    void ServerBlockPlayer(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerBlockPlayer(FUniqueNetIdRepl)", PlayerId); }

    void ServerMutePlayer(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerMutePlayer(FUniqueNetIdRepl)", PlayerId); }

    void ServerRestartPlayer() { NativeCall<void>(this, "APlayerController.ServerRestartPlayer()"); }

    void ServerUnblockPlayer(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerUnblockPlayer(FUniqueNetIdRepl)", PlayerId); }

    void ServerUnmutePlayer(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerUnmutePlayer(FUniqueNetIdRepl)", PlayerId); }

    static void StaticRegisterNativesAPlayerController() { NativeCall<void>(nullptr, "APlayerController.StaticRegisterNativesAPlayerController()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    float GetNetPriority(const UE::Math::TVector<double>* ViewPos, const UE::Math::TVector<double>* ViewDir, AActor* Viewer, AActor* ViewTarget, UActorChannel* InChannel, float Time, bool bLowBandwidth) { return NativeCall<float, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, AActor*, AActor*, UActorChannel*, float, bool>(this, "APlayerController.GetNetPriority(UE::Math::TVector<double>&,UE::Math::TVector<double>&,AActor*,AActor*,UActorChannel*,float,bool)", ViewPos, ViewDir, Viewer, ViewTarget, InChannel, Time, bLowBandwidth); }

    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "APlayerController.GetNetOwningPlayer()"); }

    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "APlayerController.GetNetConnection()"); }

    bool DestroyNetworkActorHandled() { return NativeCall<bool>(this, "APlayerController.DestroyNetworkActorHandled()"); }

    void FailedToSpawnPawn() { NativeCall<void>(this, "APlayerController.FailedToSpawnPawn()"); }

    FName* NetworkRemapPath(FName* result, FName InPackageName, bool bReading) { return NativeCall<FName*, FName*, FName, bool>(this, "APlayerController.NetworkRemapPath(FName,bool)", result, InPackageName, bReading); }

    //void ClientUpdateLevelStreamingStatus_Implementation(FName PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int LODIndex, FNetLevelVisibilityTransactionId TransactionId, bool bNewShouldBlockOnUnload) { NativeCall<void, FName, bool, bool, bool, int, FNetLevelVisibilityTransactionId, bool>(this, "APlayerController.ClientUpdateLevelStreamingStatus_Implementation(FName,bool,bool,bool,int,FNetLevelVisibilityTransactionId,bool)", PackageName, bNewShouldBeLoaded, bNewShouldBeVisible, bNewShouldBlockOnLoad, LODIndex, TransactionId, bNewShouldBlockOnUnload); }

    //void ClientUpdateMultipleLevelsStreamingStatus_Implementation(const TArray<FUpdateLevelStreamingLevelStatus, TSizedDefaultAllocator<32> >* LevelStatuses) { NativeCall<void, const TArray<FUpdateLevelStreamingLevelStatus, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ClientUpdateMultipleLevelsStreamingStatus_Implementation(TArray<FUpdateLevelStreamingLevelStatus,TSizedDefaultAllocator<32>>&)", LevelStatuses); }

    //void ClientAckUpdateLevelVisibility_Implementation(FName PackageName, FNetLevelVisibilityTransactionId TransactionId, bool bClientAckCanMakeVisibleResponse) { NativeCall<void, FName, FNetLevelVisibilityTransactionId, bool>(this, "APlayerController.ClientAckUpdateLevelVisibility_Implementation(FName,FNetLevelVisibilityTransactionId,bool)", PackageName, TransactionId, bClientAckCanMakeVisibleResponse); }

    //void ServerUpdateLevelVisibility_Implementation(const FUpdateLevelVisibilityLevelInfo* LevelVisibility) { NativeCall<void, const FUpdateLevelVisibilityLevelInfo*>(this, "APlayerController.ServerUpdateLevelVisibility_Implementation(FUpdateLevelVisibilityLevelInfo&)", LevelVisibility); }

    //bool ServerUpdateLevelVisibility_Validate(const FUpdateLevelVisibilityLevelInfo* LevelVisibility) { return NativeCall<bool, const FUpdateLevelVisibilityLevelInfo*>(this, "APlayerController.ServerUpdateLevelVisibility_Validate(FUpdateLevelVisibilityLevelInfo&)", LevelVisibility); }

    void SetNetSpeed(int NewSpeed) { NativeCall<void, int>(this, "APlayerController.SetNetSpeed(int)", NewSpeed); }

    FString* ConsoleCommand(FString* result, const FString* Cmd, bool bWriteToLog) { return NativeCall<FString*, FString*, const FString*, bool>(this, "APlayerController.ConsoleCommand(FString&,bool)", result, Cmd, bWriteToLog); }

    void CleanUpAudioComponents() { NativeCall<void>(this, "APlayerController.CleanUpAudioComponents()"); }

    AActor* GetViewTarget() { return NativeCall<AActor*>(this, "APlayerController.GetViewTarget()"); }

    //void SetViewTarget(AActor* NewViewTarget, FViewTargetTransitionParams* TransitionParams) { NativeCall<void, AActor*, FViewTargetTransitionParams*>(this, "APlayerController.SetViewTarget(AActor*,FViewTargetTransitionParams)", NewViewTarget, TransitionParams); }

    void AutoManageActiveCameraTarget(AActor* SuggestedTarget) { NativeCall<void, AActor*>(this, "APlayerController.AutoManageActiveCameraTarget(AActor*)", SuggestedTarget); }

    //ACameraActor* GetAutoActivateCameraForPlayer() { return NativeCall<ACameraActor*>(this, "APlayerController.GetAutoActivateCameraForPlayer()"); }

    void ServerNotifyLoadedWorld_Implementation(FName WorldPackageName) { NativeCall<void, FName>(this, "APlayerController.ServerNotifyLoadedWorld_Implementation(FName)", WorldPackageName); }

    bool HasClientLoadedCurrentWorld() { return NativeCall<bool>(this, "APlayerController.HasClientLoadedCurrentWorld()"); }

    void ForceSingleNetUpdateFor(AActor* Target) { NativeCall<void, AActor*>(this, "APlayerController.ForceSingleNetUpdateFor(AActor*)", Target); }

    void SmoothTargetViewRotation(APawn* TargetPawn, float DeltaSeconds) { NativeCall<void, APawn*, float>(this, "APlayerController.SmoothTargetViewRotation(APawn*,float)", TargetPawn, DeltaSeconds); }

    void InitInputSystem() { NativeCall<void>(this, "APlayerController.InitInputSystem()"); }

    void SafeRetryClientRestart() { NativeCall<void>(this, "APlayerController.SafeRetryClientRestart()"); }

    void ClientRetryClientRestart_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRetryClientRestart_Implementation(APawn*)", NewPawn); }

    void ClientRestart_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRestart_Implementation(APawn*)", NewPawn); }

    void OnPossess(APawn* PawnToPossess) { NativeCall<void, APawn*>(this, "APlayerController.OnPossess(APawn*)", PawnToPossess); }

    void AcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "APlayerController.AcknowledgePossession(APawn*)", P); }

    void ReceivedPlayer(TSubclassOf<ASpectatorPawn> SpectatorClass) { NativeCall<void, TSubclassOf<ASpectatorPawn>>(this, "APlayerController.ReceivedPlayer()", SpectatorClass); }

    void PostLoad() { NativeCall<void>(this, "APlayerController.PostLoad()"); }

    void GetActorEyesViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APlayerController.GetActorEyesViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    void CalcCamera(float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<void, float, FMinimalViewInfo*>(this, "APlayerController.CalcCamera(float,FMinimalViewInfo&)", DeltaTime, OutResult); }

    void GetPlayerViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APlayerController.GetPlayerViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    void UpdateRotation(float DeltaTime) { NativeCall<void, float>(this, "APlayerController.UpdateRotation(float)", DeltaTime); }

    void PostInitializeComponents() { NativeCall<void>(this, "APlayerController.PostInitializeComponents()"); }

    void ServerShortTimeout_Implementation() { NativeCall<void>(this, "APlayerController.ServerShortTimeout_Implementation()"); }

    void AddCheats(bool bForce) { NativeCall<void, bool>(this, "APlayerController.AddCheats(bool)", bForce); }

    void EnableCheats(const FString* pass) { NativeCall<void, const FString*>(this, "APlayerController.EnableCheats(FString)", pass); }

    void SpawnDefaultHUD() { NativeCall<void>(this, "APlayerController.SpawnDefaultHUD()"); }

    void CreateTouchInterface() { NativeCall<void>(this, "APlayerController.CreateTouchInterface()"); }

    //TSharedPtr<SVirtualJoystick, 1>* CreateVirtualJoystick(TSharedPtr<SVirtualJoystick, 1>* result) { return NativeCall<TSharedPtr<SVirtualJoystick, 1> *, TSharedPtr<SVirtualJoystick, 1>*>(this, "APlayerController.CreateVirtualJoystick()", result); }

    void CleanupGameViewport() { NativeCall<void>(this, "APlayerController.CleanupGameViewport()"); }

    void GetViewportSize(int* SizeX, int* SizeY) { NativeCall<void, int*, int*>(this, "APlayerController.GetViewportSize(int&,int&)", SizeX, SizeY); }

    void Reset() { NativeCall<void>(this, "APlayerController.Reset()"); }

    void ClientReset_Implementation() { NativeCall<void>(this, "APlayerController.ClientReset_Implementation()"); }

    bool IsFrozen() { return NativeCall<bool>(this, "APlayerController.IsFrozen()"); }

    void ServerAcknowledgePossession_Implementation(APawn* P) { NativeCall<void, APawn*>(this, "APlayerController.ServerAcknowledgePossession_Implementation(APawn*)", P); }

    bool ServerAcknowledgePossession_Validate(APawn* P) { return NativeCall<bool, APawn*>(this, "APlayerController.ServerAcknowledgePossession_Validate(APawn*)", P); }

    void OnUnPossess() { NativeCall<void>(this, "APlayerController.OnUnPossess()"); }

    void ClientSetHUD_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "APlayerController.ClientSetHUD_Implementation(TSubclassOf<AHUD>)", NewHUDClass); }

    void CleanupPlayerState() { NativeCall<void>(this, "APlayerController.CleanupPlayerState()"); }

    //void OnActorChannelOpen(FInBunch* InBunch, UNetConnection* Connection) { NativeCall<void, FInBunch*, UNetConnection*>(this, "APlayerController.OnActorChannelOpen(FInBunch&,UNetConnection*)", InBunch, Connection); }

    bool UseShortConnectTimeout() { return NativeCall<bool>(this, "APlayerController.UseShortConnectTimeout()"); }

    void OnSerializeNewActor(FOutBunch* OutBunch) { NativeCall<void, FOutBunch*>(this, "APlayerController.OnSerializeNewActor(FOutBunch&)", OutBunch); }

    void OnNetCleanup(UNetConnection* Connection) { NativeCall<void, UNetConnection*>(this, "APlayerController.OnNetCleanup(UNetConnection*)", Connection); }

    void ClientReceiveLocalizedMessage_Implementation(TSubclassOf<ULocalMessage> Message, int Switch, APlayerState* RelatedPlayerState_1, APlayerState* RelatedPlayerState_2, UObject* OptionalObject) { NativeCall<void, TSubclassOf<ULocalMessage>, int, APlayerState*, APlayerState*, UObject*>(this, "APlayerController.ClientReceiveLocalizedMessage_Implementation(TSubclassOf<ULocalMessage>,int,APlayerState*,APlayerState*,UObject*)", Message, Switch, RelatedPlayerState_1, RelatedPlayerState_2, OptionalObject); }

    void ClientPlaySound_Implementation(USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundBase*, float, float>(this, "APlayerController.ClientPlaySound_Implementation(USoundBase*,float,float)", Sound, VolumeMultiplier, PitchMultiplier); }

    void ClientMessage_Implementation(const FString* S, FName Type, float MsgLifeTime) { NativeCall<void, const FString*, FName, float>(this, "APlayerController.ClientMessage_Implementation(FString&,FName,float)", S, Type, MsgLifeTime); }

    void CopyStringToClipboard_Implementation(const FString* S) { NativeCall<void, const FString*>(this, "APlayerController.CopyStringToClipboard_Implementation(FString&)", S); }

    void ClientTeamMessage_Implementation(APlayerState* SenderPlayerState, const FString* S, FName Type, float MsgLifeTime) { NativeCall<void, APlayerState*, const FString*, FName, float>(this, "APlayerController.ClientTeamMessage_Implementation(APlayerState*,FString&,FName,float)", SenderPlayerState, S, Type, MsgLifeTime); }

    void ServerToggleAILogging_Implementation() { NativeCall<void>(this, "APlayerController.ServerToggleAILogging_Implementation()"); }

    void PawnLeavingGame() { NativeCall<void>(this, "APlayerController.PawnLeavingGame()"); }

    void BeginPlay() { NativeCall<void>(this, "APlayerController.BeginPlay()"); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "APlayerController.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    void Destroyed() { NativeCall<void>(this, "APlayerController.Destroyed()"); }

    void FOV(float F) { NativeCall<void, float>(this, "APlayerController.FOV(float)", F); }

    //void PreClientTravel(const FString* PendingURL, ETravelType TravelType, bool bIsSeamlessTravel) { NativeCall<void, const FString*, ETravelType, bool>(this, "APlayerController.PreClientTravel(FString&,ETravelType,bool)", PendingURL, TravelType, bIsSeamlessTravel); }

    void Camera(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.Camera(FName)", NewMode); }

    void ServerCamera_Implementation(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.ServerCamera_Implementation(FName)", NewMode); }

    bool ServerCamera_Validate(FName NewMode) { return NativeCall<bool, FName>(this, "APlayerController.ServerCamera_Validate(FName)", NewMode); }

    void ClientSetCameraMode_Implementation(FName NewCamMode) { NativeCall<void, FName>(this, "APlayerController.ClientSetCameraMode_Implementation(FName)", NewCamMode); }

    void SetCameraMode(FName NewCamMode) { NativeCall<void, FName>(this, "APlayerController.SetCameraMode(FName)", NewCamMode); }

    void ResetCameraMode() { NativeCall<void>(this, "APlayerController.ResetCameraMode()"); }

    //void ClientSetCameraFade_Implementation(__int64 bEnableFading, __int64 FadeColor, UE::Math::TVector2<double>* FadeAlpha) { NativeCall<void, bool, UE::Math::TVector2<double>*, float, bool, bool>(this, "APlayerController.ClientSetCameraFade_Implementation(bool,FColor,UE::Math::TVector2<double>,float,bool,bool)", bEnableFading, FadeColor, FadeAlpha); }

    void SendClientAdjustment() { NativeCall<void>(this, "APlayerController.SendClientAdjustment()"); }

    void ServerRecvClientInputFrame_Implementation(int InRecvClientInputFrame, const TArray<unsigned char, TSizedDefaultAllocator<32> >* Data) { NativeCall<void, int, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ServerRecvClientInputFrame_Implementation(int,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", InRecvClientInputFrame, Data); }

    void ClientRecvServerAckFrame_Implementation(int LastProcessedInputFrame, int RecvServerFrameNumber, char TimeDilation) { NativeCall<void, int, int, char>(this, "APlayerController.ClientRecvServerAckFrame_Implementation(int,int,signedchar)", LastProcessedInputFrame, RecvServerFrameNumber, TimeDilation); }

    void ClientRecvServerAckFrameDebug_Implementation(unsigned __int8 NumBuffered, float TargetNumBufferedCmds) { NativeCall<void, unsigned __int8, float>(this, "APlayerController.ClientRecvServerAckFrameDebug_Implementation(unsignedchar,float)", NumBuffered, TargetNumBufferedCmds); }

    void ClientCapBandwidth_Implementation(int Cap) { NativeCall<void, int>(this, "APlayerController.ClientCapBandwidth_Implementation(int)", Cap); }

    void UpdatePing(float InPing) { NativeCall<void, float>(this, "APlayerController.UpdatePing(float)", InPing); }

    void SetSpawnLocation(const UE::Math::TVector<double>* NewLocation) { NativeCall<void, const UE::Math::TVector<double>*>(this, "APlayerController.SetSpawnLocation(UE::Math::TVector<double>&)", NewLocation); }

    void SetInitialLocationAndRotation(const UE::Math::TVector<double>* NewLocation, const UE::Math::TRotator<double>* NewRotation) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*>(this, "APlayerController.SetInitialLocationAndRotation(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", NewLocation, NewRotation); }

    //void ServerUpdateCamera_Implementation(FVector_NetQuantize* CamLoc, int CamPitchAndYaw) { NativeCall<void, FVector_NetQuantize*, int>(this, "APlayerController.ServerUpdateCamera_Implementation(FVector_NetQuantize,int)", CamLoc, CamPitchAndYaw); }

    void RestartLevel() { NativeCall<void>(this, "APlayerController.RestartLevel()"); }

    void LocalTravel(const FString* FURL) { NativeCall<void, const FString*>(this, "APlayerController.LocalTravel(FString&)", FURL); }

    void ClientReturnToMainMenuWithTextReason_Implementation(const FText* ReturnReason) { NativeCall<void, const FText*>(this, "APlayerController.ClientReturnToMainMenuWithTextReason_Implementation(FText&)", ReturnReason); }

    void ClientReturnToMainMenu_Implementation(const FString* ReturnReason) { NativeCall<void, const FString*>(this, "APlayerController.ClientReturnToMainMenu_Implementation(FString&)", ReturnReason); }

    __int64 SetPause(bool bPause, TDelegate<bool __cdecl(void), FDefaultDelegateUserPolicy>* CanUnpauseDelegate) { return NativeCall<__int64, bool, TDelegate<bool __cdecl(void), FDefaultDelegateUserPolicy>*>(this, "APlayerController.SetPause(bool,TDelegate<bool__cdecl(void)", bPause, CanUnpauseDelegate); }

    bool IsPaused() { return NativeCall<bool>(this, "APlayerController.IsPaused()"); }

    void Pause() { NativeCall<void>(this, "APlayerController.Pause()"); }

    bool ServerPause_Validate() { return NativeCall<bool>(this, "APlayerController.ServerPause_Validate()"); }

    void ServerPause_Implementation() { NativeCall<void>(this, "APlayerController.ServerPause_Implementation()"); }

    void SetName(const FString* S) { NativeCall<void, const FString*>(this, "APlayerController.SetName(FString&)", S); }

    void ServerChangeName_Implementation(const FString* S) { NativeCall<void, const FString*>(this, "APlayerController.ServerChangeName_Implementation(FString&)", S); }

    bool ServerChangeName_Validate(const FString* S) { return NativeCall<bool, const FString*>(this, "APlayerController.ServerChangeName_Validate(FString&)", S); }

    void SwitchLevel(const FString* FURL) { NativeCall<void, const FString*>(this, "APlayerController.SwitchLevel(FString&)", FURL); }

    void NotifyLoadedWorld(FName WorldPackageName, bool bFinalDest) { NativeCall<void, FName, bool>(this, "APlayerController.NotifyLoadedWorld(FName,bool)", WorldPackageName, bFinalDest); }

    void ClientGameEnded_Implementation(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.ClientGameEnded_Implementation(AActor*,bool)", EndGameFocus, bIsWinner); }

    bool GetHitResultUnderFinger(ETouchIndex::Type FingerIndex, ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, ETouchIndex::Type, ECollisionChannel, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderFinger(ETouchIndex::Type,ECollisionChannel,bool,FHitResult&)", FingerIndex, TraceChannel, bTraceComplex, HitResult); }

    char ProjectWorldLocationToScreenWithDistance(UE::Math::TVector<double>* WorldLocation, UE::Math::TVector<double>* ScreenLocation, bool bPlayerViewportRelative) { return NativeCall<char, UE::Math::TVector<double>*, UE::Math::TVector<double>*, bool>(this, "APlayerController.ProjectWorldLocationToScreenWithDistance(UE::Math::TVector<double>,UE::Math::TVector<double>&,bool)", WorldLocation, ScreenLocation, bPlayerViewportRelative); }

    bool GetHitResultAtScreenPosition(const UE::Math::TVector2<double>* ScreenPosition, const ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, const UE::Math::TVector2<double>*, const ECollisionChannel, bool, FHitResult*>(this, "APlayerController.GetHitResultAtScreenPosition(UE::Math::TVector2<double>,ECollisionChannel,bool,FHitResult&)", ScreenPosition, TraceChannel, bTraceComplex, HitResult); }

    bool GetHitResultAtScreenPosition(const UE::Math::TVector2<double>* ScreenPosition, const TArray<TEnumAsByte<EObjectTypeQuery>, TSizedDefaultAllocator<32> >* ObjectTypes, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, const UE::Math::TVector2<double>*, const TArray<TEnumAsByte<EObjectTypeQuery>, TSizedDefaultAllocator<32> >*, bool, FHitResult*>(this, "APlayerController.GetHitResultAtScreenPosition(UE::Math::TVector2<double>,TArray<TEnumAsByte<EObjectTypeQuery>,TSizedDefaultAllocator<32>>&,bool,FHitResult&)", ScreenPosition, ObjectTypes, bTraceComplex, HitResult); }

    void PlayerTick(float DeltaTime) { NativeCall<void, float>(this, "APlayerController.PlayerTick(float)", DeltaTime); }

    bool InputKey(FKey* Key, EInputEvent EventType, float AmountDepressed, bool bGamepad) { return NativeCall<bool, FKey*, EInputEvent, float, bool>(this, "APlayerController.InputKey(FKey,EInputEvent,float,bool)", Key, EventType, AmountDepressed, bGamepad); }

    //bool InputKey(const FInputKeyParams* Params) { return NativeCall<bool, const FInputKeyParams*>(this, "APlayerController.InputKey(FInputKeyParams&)", Params); }

    bool InputAxis(FKey* Key, float Delta, float DeltaTime, int NumSamples, bool bGamepad) { return NativeCall<bool, FKey*, float, float, int, bool>(this, "APlayerController.InputAxis(FKey,float,float,int,bool)", Key, Delta, DeltaTime, NumSamples, bGamepad); }

    bool InputMotion(const UE::Math::TVector<double>* Tilt, const UE::Math::TVector<double>* RotationRate, const UE::Math::TVector<double>* Gravity, const UE::Math::TVector<double>* Acceleration) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*>(this, "APlayerController.InputMotion(UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&)", Tilt, RotationRate, Gravity, Acceleration); }

    bool ShouldShowMouseCursor() { return NativeCall<bool>(this, "APlayerController.ShouldShowMouseCursor()"); }

    void SetupInputComponent() { NativeCall<void>(this, "APlayerController.SetupInputComponent()"); }

    void BuildInputStack(TArray<UInputComponent*, TSizedDefaultAllocator<32> >* InputStack) { NativeCall<void, TArray<UInputComponent*, TSizedDefaultAllocator<32> >*>(this, "APlayerController.BuildInputStack(TArray<UInputComponent*,TSizedDefaultAllocator<32>>&)", InputStack); }

    void ProcessPlayerInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.ProcessPlayerInput(float,bool)", DeltaTime, bGamePaused); }

    void PostProcessInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.PostProcessInput(float,bool)", DeltaTime, bGamePaused); }

    void ResetIgnoreInputFlags() { NativeCall<void>(this, "APlayerController.ResetIgnoreInputFlags()"); }

    void SetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning) { NativeCall<void, bool, bool, bool>(this, "APlayerController.SetCinematicMode(bool,bool,bool)", bInCinematicMode, bAffectsMovement, bAffectsTurning); }

    void SetViewTargetWithBlend(AActor* NewViewTarget, float BlendTime, EViewTargetBlendFunction BlendFunc, float BlendExp, bool bLockOutgoing) { NativeCall<void, AActor*, float, EViewTargetBlendFunction, float, bool>(this, "APlayerController.SetViewTargetWithBlend(AActor*,float,EViewTargetBlendFunction,float,bool)", NewViewTarget, BlendTime, BlendFunc, BlendExp, bLockOutgoing); }

    //void ClientSetViewTarget_Implementation(AActor* A, FViewTargetTransitionParams* TransitionParams) { NativeCall<void, AActor*, FViewTargetTransitionParams*>(this, "APlayerController.ClientSetViewTarget_Implementation(AActor*,FViewTargetTransitionParams)", A, TransitionParams); }

    void ServerVerifyViewTarget_Implementation() { NativeCall<void>(this, "APlayerController.ServerVerifyViewTarget_Implementation()"); }

    void SpawnPlayerCameraManager() { NativeCall<void>(this, "APlayerController.SpawnPlayerCameraManager()"); }

    void GetAudioListenerPosition(UE::Math::TVector<double>* OutLocation, UE::Math::TVector<double>* OutFrontDir, UE::Math::TVector<double>* OutRightDir) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "APlayerController.GetAudioListenerPosition(UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&)", OutLocation, OutFrontDir, OutRightDir); }

    bool GetAudioListenerAttenuationOverridePosition(UE::Math::TVector<double>* OutLocation) { return NativeCall<bool, UE::Math::TVector<double>*>(this, "APlayerController.GetAudioListenerAttenuationOverridePosition(UE::Math::TVector<double>&)", OutLocation); }

    void ServerCheckClientPossession_Implementation() { NativeCall<void>(this, "APlayerController.ServerCheckClientPossession_Implementation()"); }

    void ServerCheckClientPossessionReliable_Implementation() { NativeCall<void>(this, "APlayerController.ServerCheckClientPossessionReliable_Implementation()"); }

    void SafeServerCheckClientPossession() { NativeCall<void>(this, "APlayerController.SafeServerCheckClientPossession()"); }

    void ServerSetSpectatorLocation_Implementation(UE::Math::TVector<double>* NewLoc, UE::Math::TRotator<double>* NewRot) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APlayerController.ServerSetSpectatorLocation_Implementation(UE::Math::TVector<double>,UE::Math::TRotator<double>)", NewLoc, NewRot); }

    void ClientSetSpectatorWaiting_Implementation(bool bWaiting) { NativeCall<void, bool>(this, "APlayerController.ClientSetSpectatorWaiting_Implementation(bool)", bWaiting); }

    float GetDeprecatedInputYawScale() { return NativeCall<float>(this, "APlayerController.GetDeprecatedInputYawScale()"); }

    float GetDeprecatedInputPitchScale() { return NativeCall<float>(this, "APlayerController.GetDeprecatedInputPitchScale()"); }

    void ServerViewNextPlayer_Implementation() { NativeCall<void>(this, "APlayerController.ServerViewNextPlayer_Implementation()"); }

    void ServerViewPrevPlayer_Implementation() { NativeCall<void>(this, "APlayerController.ServerViewPrevPlayer_Implementation()"); }

    APlayerState* GetNextViewablePlayer(int dir) { return NativeCall<APlayerState*, int>(this, "APlayerController.GetNextViewablePlayer(int)", dir); }

    void ViewAPlayer(int dir) { NativeCall<void, int>(this, "APlayerController.ViewAPlayer(int)", dir); }

    //void ServerViewSelf_Implementation(FViewTargetTransitionParams* TransitionParams) { NativeCall<void, FViewTargetTransitionParams*>(this, "APlayerController.ServerViewSelf_Implementation(FViewTargetTransitionParams)", TransitionParams); }

    void StartFire(unsigned __int8 FireModeNum) { NativeCall<void, unsigned __int8>(this, "APlayerController.StartFire(unsignedchar)", FireModeNum); }

    bool NotifyServerReceivedClientData(APawn* InPawn, float TimeStamp) { return NativeCall<bool, APawn*, float>(this, "APlayerController.NotifyServerReceivedClientData(APawn*,float)", InPawn, TimeStamp); }

    void ServerRestartPlayer_Implementation() { NativeCall<void>(this, "APlayerController.ServerRestartPlayer_Implementation()"); }

    bool CanRestartPlayer() { return NativeCall<bool>(this, "APlayerController.CanRestartPlayer()"); }

    void ClientIgnoreMoveInput_Implementation(bool bIgnore) { NativeCall<void, bool>(this, "APlayerController.ClientIgnoreMoveInput_Implementation(bool)", bIgnore); }

    void ClientIgnoreLookInput_Implementation(bool bIgnore) { NativeCall<void, bool>(this, "APlayerController.ClientIgnoreLookInput_Implementation(bool)", bIgnore); }

    void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo* DebugDisplay, float* YL, float* YPos) { NativeCall<void, UCanvas*, const FDebugDisplayInfo*, float*, float*>(this, "APlayerController.DisplayDebug(UCanvas*,FDebugDisplayInfo&,float&,float&)", Canvas, DebugDisplay, YL, YPos); }

    void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning) { NativeCall<void, bool, bool, bool, bool, bool>(this, "APlayerController.SetCinematicMode(bool,bool,bool,bool,bool)", bInCinematicMode, bHidePlayer, bAffectsHUD, bAffectsMovement, bAffectsTurning); }

    void ClientSetCinematicMode_Implementation(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning, bool bAffectsHUD) { NativeCall<void, bool, bool, bool, bool>(this, "APlayerController.ClientSetCinematicMode_Implementation(bool,bool,bool,bool)", bInCinematicMode, bAffectsMovement, bAffectsTurning, bAffectsHUD); }

    void ClientForceGarbageCollection_Implementation() { NativeCall<void>(this, "APlayerController.ClientForceGarbageCollection_Implementation()"); }

    //void LevelStreamingStatusChanged(ULevelStreaming* LevelObject, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, bool bNewShouldBlockOnUnload, int LODIndex) { NativeCall<void, ULevelStreaming*, bool, bool, bool, bool, int>(this, "APlayerController.LevelStreamingStatusChanged(ULevelStreaming*,bool,bool,bool,bool,int)", LevelObject, bNewShouldBeLoaded, bNewShouldBeVisible, bNewShouldBlockOnLoad, bNewShouldBlockOnUnload, LODIndex); }

    void ClientPrepareMapChange_Implementation(FName LevelName, bool bFirst, bool bLast) { NativeCall<void, FName, bool, bool>(this, "APlayerController.ClientPrepareMapChange_Implementation(FName,bool,bool)", LevelName, bFirst, bLast); }

    void DelayedPrepareMapChange() { NativeCall<void>(this, "APlayerController.DelayedPrepareMapChange()"); }

    void ClientCommitMapChange_Implementation() { NativeCall<void>(this, "APlayerController.ClientCommitMapChange_Implementation()"); }

    void ClientCancelPendingMapChange_Implementation() { NativeCall<void>(this, "APlayerController.ClientCancelPendingMapChange_Implementation()"); }

    void ClientSetBlockOnAsyncLoading_Implementation() { NativeCall<void>(this, "APlayerController.ClientSetBlockOnAsyncLoading_Implementation()"); }

    void GetSeamlessTravelActorList(bool bToEntry, TArray<AActor*, TSizedDefaultAllocator<32> >* ActorList) { NativeCall<void, bool, TArray<AActor*, TSizedDefaultAllocator<32> >*>(this, "APlayerController.GetSeamlessTravelActorList(bool,TArray<AActor*,TSizedDefaultAllocator<32>>&)", bToEntry, ActorList); }

    void SeamlessTravelTo(APlayerController* NewPC) { NativeCall<void, APlayerController*>(this, "APlayerController.SeamlessTravelTo(APlayerController*)", NewPC); }

    void SeamlessTravelFrom(APlayerController* OldPC) { NativeCall<void, APlayerController*>(this, "APlayerController.SeamlessTravelFrom(APlayerController*)", OldPC); }

    void PostSeamlessTravel() { NativeCall<void>(this, "APlayerController.PostSeamlessTravel()"); }

    void GetStreamingSourceLocationAndRotation(UE::Math::TVector<double>* OutLocation, UE::Math::TRotator<double>* OutRotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APlayerController.GetStreamingSourceLocationAndRotation(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", OutLocation, OutRotation); }

    //void GetStreamingSourceShapes(TArray<FStreamingSourceShape, TSizedDefaultAllocator<32> >* OutShapes) { NativeCall<void, TArray<FStreamingSourceShape, TSizedDefaultAllocator<32> >*>(this, "APlayerController.GetStreamingSourceShapes(TArray<FStreamingSourceShape,TSizedDefaultAllocator<32>>&)", OutShapes); }

    //bool GetStreamingSources(TArray<FWorldPartitionStreamingSource, TSizedDefaultAllocator<32> >* OutStreamingSources) { return NativeCall<bool, TArray<FWorldPartitionStreamingSource, TSizedDefaultAllocator<32> >*>(this, "APlayerController.GetStreamingSources(TArray<FWorldPartitionStreamingSource,TSizedDefaultAllocator<32>>&)", OutStreamingSources); }

    //bool GetStreamingSourcesInternal(TArray<FWorldPartitionStreamingSource, TSizedDefaultAllocator<32> >* OutStreamingSources) { return NativeCall<bool, TArray<FWorldPartitionStreamingSource, TSizedDefaultAllocator<32> >*>(this, "APlayerController.GetStreamingSourcesInternal(TArray<FWorldPartitionStreamingSource,TSizedDefaultAllocator<32>>&)", OutStreamingSources); }

    void ClientEnableNetworkVoice_Implementation(bool bEnable) { NativeCall<void, bool>(this, "APlayerController.ClientEnableNetworkVoice_Implementation(bool)", bEnable); }

    void ToggleSpeaking(bool bSpeaking) { NativeCall<void, bool>(this, "APlayerController.ToggleSpeaking(bool)", bSpeaking); }

    void ServerMutePlayer_Implementation(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerMutePlayer_Implementation(FUniqueNetIdRepl)", PlayerId); }

    bool ServerUnmutePlayer_Validate(FUniqueNetIdRepl* PlayerId) { return NativeCall<bool, FUniqueNetIdRepl*>(this, "APlayerController.ServerUnmutePlayer_Validate(FUniqueNetIdRepl)", PlayerId); }

    void ServerUnmutePlayer_Implementation(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerUnmutePlayer_Implementation(FUniqueNetIdRepl)", PlayerId); }

    void ClientMutePlayer_Implementation(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ClientMutePlayer_Implementation(FUniqueNetIdRepl)", PlayerId); }

    void ClientUnmutePlayer_Implementation(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ClientUnmutePlayer_Implementation(FUniqueNetIdRepl)", PlayerId); }

    void ClientUnmutePlayers_Implementation(const TArray<FUniqueNetIdRepl, TSizedDefaultAllocator<32> >* PlayerIds) { NativeCall<void, const TArray<FUniqueNetIdRepl, TSizedDefaultAllocator<32> >*>(this, "APlayerController.ClientUnmutePlayers_Implementation(TArray<FUniqueNetIdRepl,TSizedDefaultAllocator<32>>&)", PlayerIds); }

    void ServerBlockPlayer_Implementation(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerBlockPlayer_Implementation(FUniqueNetIdRepl)", PlayerId); }

    __int64 ServerUnblockPlayer_Validate(FUniqueNetIdRepl* PlayerId) { return NativeCall<__int64, FUniqueNetIdRepl*>(this, "APlayerController.ServerUnblockPlayer_Validate(FUniqueNetIdRepl)", PlayerId); }

    void ServerUnblockPlayer_Implementation(FUniqueNetIdRepl* PlayerId) { NativeCall<void, FUniqueNetIdRepl*>(this, "APlayerController.ServerUnblockPlayer_Implementation(FUniqueNetIdRepl)", PlayerId); }

    APlayerController* GetPlayerControllerForMuting(const FUniqueNetIdRepl* PlayerNetId) { return NativeCall<APlayerController*, const FUniqueNetIdRepl*>(this, "APlayerController.GetPlayerControllerForMuting(FUniqueNetIdRepl&)", PlayerNetId); }

    bool IsPlayerMuted(const FUniqueNetId* PlayerId) { return NativeCall<bool, const FUniqueNetId*>(this, "APlayerController.IsPlayerMuted(FUniqueNetId&)", PlayerId); }

    void ClientStartOnlineSession_Implementation() { NativeCall<void>(this, "APlayerController.ClientStartOnlineSession_Implementation()"); }

    void ClientEndOnlineSession_Implementation() { NativeCall<void>(this, "APlayerController.ClientEndOnlineSession_Implementation()"); }

    void ConsoleKey(FKey* Key) { NativeCall<void, FKey*>(this, "APlayerController.ConsoleKey(FKey)", Key); }

    void SendToConsole(const FString* Command) { NativeCall<void, const FString*>(this, "APlayerController.SendToConsole(FString&)", Command); }

    bool IsSplitscreenPlayer(int* OutSplitscreenPlayerIndex) { return NativeCall<bool, int*>(this, "APlayerController.IsSplitscreenPlayer(int*)", OutSplitscreenPlayerIndex); }

    int GetSplitscreenPlayerCount() { return NativeCall<int>(this, "APlayerController.GetSplitscreenPlayerCount()"); }

    void ClientSetForceMipLevelsToBeResident_Implementation(UMaterialInterface* Material, float ForceDuration, int CinematicTextureGroups) { NativeCall<void, UMaterialInterface*, float, int>(this, "APlayerController.ClientSetForceMipLevelsToBeResident_Implementation(UMaterialInterface*,float,int)", Material, ForceDuration, CinematicTextureGroups); }

    void ClientPrestreamTextures_Implementation(AActor* ForcedActor, float ForceDuration, bool bEnableStreaming, int CinematicTextureGroups) { NativeCall<void, AActor*, float, bool, int>(this, "APlayerController.ClientPrestreamTextures_Implementation(AActor*,float,bool,int)", ForcedActor, ForceDuration, bEnableStreaming, CinematicTextureGroups); }

    //void ClientPlayForceFeedback_Internal_Implementation(UForceFeedbackEffect* ForceFeedbackEffect, FForceFeedbackParameters* Params, float intensityMult) { NativeCall<void, UForceFeedbackEffect*, FForceFeedbackParameters*, float>(this, "APlayerController.ClientPlayForceFeedback_Internal_Implementation(UForceFeedbackEffect*,FForceFeedbackParameters,float)", ForceFeedbackEffect, Params, intensityMult); }

    //void ClientStopForceFeedback_Implementation(UForceFeedbackEffect* ForceFeedbackEffect, FName Tag) { NativeCall<void, UForceFeedbackEffect*, FName>(this, "APlayerController.ClientStopForceFeedback_Implementation(UForceFeedbackEffect*,FName)", ForceFeedbackEffect, Tag); }

    void PlayDynamicForceFeedback(float Intensity, float Duration, bool bAffectsLeftLarge, bool bAffectsLeftSmall, bool bAffectsRightLarge, bool bAffectsRightSmall, TEnumAsByte<EDynamicForceFeedbackAction::Type> Action, FLatentActionInfo* LatentInfo) { NativeCall<void, float, float, bool, bool, bool, bool, TEnumAsByte<EDynamicForceFeedbackAction::Type>, FLatentActionInfo*>(this, "APlayerController.PlayDynamicForceFeedback(float,float,bool,bool,bool,bool,TEnumAsByte<EDynamicForceFeedbackAction::Type>,FLatentActionInfo)", Intensity, Duration, bAffectsLeftLarge, bAffectsLeftSmall, bAffectsRightLarge, bAffectsRightSmall, Action, LatentInfo); }

    //void PlayHapticEffect(UHapticFeedbackEffect_Base* HapticEffect, EControllerHand Hand, float Scale, bool bLoop) { NativeCall<void, UHapticFeedbackEffect_Base*, EControllerHand, float, bool>(this, "APlayerController.PlayHapticEffect(UHapticFeedbackEffect_Base*,EControllerHand,float,bool)", HapticEffect, Hand, Scale, bLoop); }

    void SetDisableHaptics(bool bNewDisabled) { NativeCall<void, bool>(this, "APlayerController.SetDisableHaptics(bool)", bNewDisabled); }

    void SetHapticsByValue(const float Frequency, const float Amplitude, EControllerHand Hand) { NativeCall<void, const float, const float, EControllerHand>(this, "APlayerController.SetHapticsByValue(float,float,EControllerHand)", Frequency, Amplitude, Hand); }

    void SetControllerLightColor(FColor Color) { NativeCall<void, FColor>(this, "APlayerController.SetControllerLightColor(FColor)", Color); }

    void ProcessForceFeedbackAndHaptics(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.ProcessForceFeedbackAndHaptics(float,bool)", DeltaTime, bGamePaused); }

    //void UpdateForceFeedback(IInputInterface* InputInterface, const int ControllerId) { NativeCall<void, IInputInterface*, const int>(this, "APlayerController.UpdateForceFeedback(IInputInterface*,int)", InputInterface, ControllerId); }

    //void ClientStartCameraShake_Implementation(TSubclassOf<UCameraShakeBase> Shake, float Scale, __int64 PlaySpace, UE::Math::TRotator<double>* UserPlaySpaceRot, float Speed) { NativeCall<void, TSubclassOf<UCameraShakeBase>, float, __int64, UE::Math::TRotator<double>*, float>(this, "APlayerController.ClientStartCameraShake_Implementation(TSubclassOf<UCameraShakeBase>,float,ECameraShakePlaySpace,UE::Math::TRotator<double>,float,bool)", Shake, Scale, PlaySpace, UserPlaySpaceRot, Speed); }

    //void ClientStopCameraShake_Implementation(TSubclassOf<UCameraShakeBase> Shake, bool bImmediately) { NativeCall<void, TSubclassOf<UCameraShakeBase>, bool>(this, "APlayerController.ClientStopCameraShake_Implementation(TSubclassOf<UCameraShakeBase>,bool)", Shake, bImmediately); }

    //void ClientPlayCameraAnim_Implementation(UCameraAnim* AnimToPlay, float Scale, float Rate) { NativeCall<void, UCameraAnim*, float, float>(this, "APlayerController.ClientPlayCameraAnim_Implementation(UCameraAnim*,float,float,float,float,bool,bool,ECameraShakePlaySpace,UE::Math::TRotator<double>)", AnimToPlay, Scale, Rate); }

    //void ClientStopCameraAnim_Implementation(UCameraAnim* AnimToStop) { NativeCall<void, UCameraAnim*>(this, "APlayerController.ClientStopCameraAnim_Implementation(UCameraAnim*)", AnimToStop); }

    void ClientSpawnGenericCameraLensEffect_Implementation(TSubclassOf<AActor> LensEffectEmitterClass) { NativeCall<void, TSubclassOf<AActor>>(this, "APlayerController.ClientSpawnGenericCameraLensEffect_Implementation(TSubclassOf<AActor>)", LensEffectEmitterClass); }

    //void ClientSpawnCameraLensEffect_Implementation(TSubclassOf<AEmitterCameraLensEffectBase> LensEffectEmitterClass) { NativeCall<void, TSubclassOf<AEmitterCameraLensEffectBase>>(this, "APlayerController.ClientSpawnCameraLensEffect_Implementation(TSubclassOf<AEmitterCameraLensEffectBase>)", LensEffectEmitterClass); }

    void ClientClearCameraLensEffects_Implementation() { NativeCall<void>(this, "APlayerController.ClientClearCameraLensEffects_Implementation()"); }

    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "APlayerController.SetPawn(APawn*)", InPawn); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "APlayerController.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void SetPlayer(UPlayer* InPlayer) { NativeCall<void, UPlayer*>(this, "APlayerController.SetPlayer(UPlayer*)", InPlayer); }

    ULocalPlayer* GetLocalPlayer() { return NativeCall<ULocalPlayer*>(this, "APlayerController.GetLocalPlayer()"); }

    //bool IsInViewportClient(UGameViewportClient* ViewportClient) { return NativeCall<bool, UGameViewportClient*>(this, "APlayerController.IsInViewportClient(UGameViewportClient*)", ViewportClient); }

    int GetInputIndex() { return NativeCall<int>(this, "APlayerController.GetInputIndex()"); }

    void TickPlayerInput(const float DeltaSeconds, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.TickPlayerInput(float,bool)", DeltaSeconds, bGamePaused); }

    void TickActor(float DeltaSeconds, ELevelTick TickType, FActorTickFunction* ThisTickFunction) { NativeCall<void, float, ELevelTick, FActorTickFunction*>(this, "APlayerController.TickActor(float,ELevelTick,FActorTickFunction&)", DeltaSeconds, TickType, ThisTickFunction); }

    bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const UE::Math::TVector<double>* SrcLocation) { return NativeCall<bool, const AActor*, const AActor*, const UE::Math::TVector<double>*>(this, "APlayerController.IsNetRelevantFor(AActor*,AActor*,UE::Math::TVector<double>&)", RealViewer, ViewTarget, SrcLocation); }

    //void ClientTravel(const FString* URL, ETravelType TravelType, bool bSeamless, FGuid* MapPackageGuid) { NativeCall<void, const FString*, ETravelType, bool, FGuid*>(this, "APlayerController.ClientTravel(FString&,ETravelType,bool,FGuid)", URL, TravelType, bSeamless, MapPackageGuid); }

    //void ClientTravelInternal_Implementation(const FString* URL, ETravelType TravelType, bool bSeamless) { NativeCall<void, const FString*, ETravelType, bool>(this, "APlayerController.ClientTravelInternal_Implementation(FString&,ETravelType,bool,FGuid)", URL, TravelType, bSeamless); }

    FString* GetPlayerNetworkAddress(FString* result) { return NativeCall<FString*, FString*>(this, "APlayerController.GetPlayerNetworkAddress()", result); }

    bool DefaultCanUnpause() { return NativeCall<bool>(this, "APlayerController.DefaultCanUnpause()"); }

    void StartSpectatingOnly() { NativeCall<void>(this, "APlayerController.StartSpectatingOnly()"); }

    void EndPlayingState() { NativeCall<void>(this, "APlayerController.EndPlayingState()"); }

    void BeginSpectatingState() { NativeCall<void>(this, "APlayerController.BeginSpectatingState()"); }

    void SetSpectatorPawn(ASpectatorPawn* NewSpectatorPawn) { NativeCall<void, ASpectatorPawn*>(this, "APlayerController.SetSpectatorPawn(ASpectatorPawn*)", NewSpectatorPawn); }

    ASpectatorPawn* SpawnSpectatorPawn() { return NativeCall<ASpectatorPawn*>(this, "APlayerController.SpawnSpectatorPawn()"); }

    void DestroySpectatorPawn() { NativeCall<void>(this, "APlayerController.DestroySpectatorPawn()"); }

    APawn* GetPawnOrSpectator() { return NativeCall<APawn*>(this, "APlayerController.GetPawnOrSpectator()"); }

    void UpdateStateInputComponents() { NativeCall<void>(this, "APlayerController.UpdateStateInputComponents()"); }

    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "APlayerController.ChangeState(FName)", NewState); }

    void EndSpectatingState() { NativeCall<void>(this, "APlayerController.EndSpectatingState()"); }

    void BeginInactiveState() { NativeCall<void>(this, "APlayerController.BeginInactiveState()"); }

    float GetMinRespawnDelay() { return NativeCall<float>(this, "APlayerController.GetMinRespawnDelay()"); }

    void SetupInactiveStateInputComponent(UInputComponent* InComponent) { NativeCall<void, UInputComponent*>(this, "APlayerController.SetupInactiveStateInputComponent(UInputComponent*)", InComponent); }

    void PushInputComponent(UInputComponent* InInputComponent) { NativeCall<void, UInputComponent*>(this, "APlayerController.PushInputComponent(UInputComponent*)", InInputComponent); }

    bool PopInputComponent(UInputComponent* InInputComponent) { return NativeCall<bool, UInputComponent*>(this, "APlayerController.PopInputComponent(UInputComponent*)", InInputComponent); }

    bool IsInputComponentInStack(const UInputComponent* InInputComponent) { return NativeCall<bool, const UInputComponent*>(this, "APlayerController.IsInputComponentInStack(UInputComponent*)", InInputComponent); }

    void AddPitchInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddPitchInput(float)", Val); }

    void AddYawInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddYawInput(float)", Val); }

    void AddRollInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddRollInput(float)", Val); }

    bool IsInputKeyDown(FKey* Key) { return NativeCall<bool, FKey*>(this, "APlayerController.IsInputKeyDown(FKey)", Key); }

    void GetInputMotionState(UE::Math::TVector<double>* Tilt, UE::Math::TVector<double>* RotationRate, UE::Math::TVector<double>* Gravity, UE::Math::TVector<double>* Acceleration) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "APlayerController.GetInputMotionState(UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&)", Tilt, RotationRate, Gravity, Acceleration); }

    float GetInputKeyTimeDown(FKey* Key) { return NativeCall<float, FKey*>(this, "APlayerController.GetInputKeyTimeDown(FKey)", Key); }

    bool GetMousePosition(float* LocationX, float* LocationY, bool bEvenWhenMouseNotAttached) { return NativeCall<bool, float*, float*, bool>(this, "APlayerController.GetMousePosition(float&,float&,bool)", LocationX, LocationY, bEvenWhenMouseNotAttached); }

    void GetInputMouseDelta(float* DeltaX, float* DeltaY) { NativeCall<void, float*, float*>(this, "APlayerController.GetInputMouseDelta(float&,float&)", DeltaX, DeltaY); }

    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APlayerController.EnableInput(APlayerController*)", PlayerController); }

    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APlayerController.DisableInput(APlayerController*)", PlayerController); }

    //void ActivateTouchInterface(UTouchInterface* NewTouchInterface) { NativeCall<void, UTouchInterface*>(this, "APlayerController.ActivateTouchInterface(UTouchInterface*)", NewTouchInterface); }

    //void SetVirtualJoystickVisibility(bool bVisible) { NativeCall<void, bool>(this, "APlayerController.SetVirtualJoystickVisibility(bool)", bVisible); }

    //void SetInputMode(const FInputModeDataBase* InData) { NativeCall<void, const FInputModeDataBase*>(this, "APlayerController.SetInputMode(FInputModeDataBase&)", InData); }

    //void UpdateCameraManager(float DeltaSeconds) { NativeCall<void, float>(this, "APlayerController.UpdateCameraManager(float)", DeltaSeconds); }

    //void BuildHiddenComponentList(const UE::Math::TVector<double>* ViewLocation, TSet<FPrimitiveComponentId, DefaultKeyFuncs<FPrimitiveComponentId, 0>, FDefaultSetAllocator>* HiddenComponentsOut) { NativeCall<void, const UE::Math::TVector<double>*, TSet<FPrimitiveComponentId, DefaultKeyFuncs<FPrimitiveComponentId, 0>, FDefaultSetAllocator>*>(this, "APlayerController.BuildHiddenComponentList(UE::Math::TVector<double>&,TSet<FPrimitiveComponentId,DefaultKeyFuncs<FPrimitiveComponentId,0>,FDefaultSetAllocator>&)", ViewLocation, HiddenComponentsOut); }

    //bool ShouldPerformFullTickWhenPaused() { return NativeCall<bool>(this, "APlayerController.ShouldPerformFullTickWhenPaused()"); }

    //FAsyncPhysicsTimestamp* GetAsyncPhysicsTimestamp(FAsyncPhysicsTimestamp* result, float DeltaSeconds) { return NativeCall<FAsyncPhysicsTimestamp*, FAsyncPhysicsTimestamp*, float>(this, "APlayerController.GetAsyncPhysicsTimestamp(float)", result, DeltaSeconds); }

    //void ServerSendLatestAsyncPhysicsTimestamp_Implementation(FAsyncPhysicsTimestamp Timestamp) { NativeCall<void, FAsyncPhysicsTimestamp>(this, "APlayerController.ServerSendLatestAsyncPhysicsTimestamp_Implementation(FAsyncPhysicsTimestamp)", Timestamp); }

    //void ClientCorrectionAsyncPhysicsTimestamp_Implementation(FAsyncPhysicsTimestamp Timestamp) { NativeCall<void, FAsyncPhysicsTimestamp>(this, "APlayerController.ClientCorrectionAsyncPhysicsTimestamp_Implementation(FAsyncPhysicsTimestamp)", Timestamp); }

    //void ClientAckTimeDilation_Implementation(float TimeDilation, int ServerStep) { NativeCall<void, float, int>(this, "APlayerController.ClientAckTimeDilation_Implementation(float,int)", TimeDilation, ServerStep); }

    //void AsyncPhysicsTickActor(float DeltaTime, float SimTime) { NativeCall<void, float, float>(this, "APlayerController.AsyncPhysicsTickActor(float,float)", DeltaTime, SimTime); }

};


struct APrimalPlayerController : APlayerController

{

    // Fields


    float& LastTeleportDistanceField() { return *GetNativePointerField<float*>(this, "APrimalPlayerController.LastTeleportDistance"); }

    UE::Math::TRotator<double>& PreviousRotationInputField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalPlayerController.PreviousRotationInput"); }

    UE::Math::TVector<double>& LastCharacterMovementTeleportUnstasisLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalPlayerController.LastCharacterMovementTeleportUnstasisLocation"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bLockedInputUI() { return { this, "APrimalPlayerController.bLockedInputUI" }; }

    BitFieldValue<bool, unsigned __int32> bPossessedAnyPawn() { return { this, "APrimalPlayerController.bPossessedAnyPawn" }; }

    BitFieldValue<bool, unsigned __int32> bCheatPlayer() { return { this, "APrimalPlayerController.bCheatPlayer" }; }

    BitFieldValue<bool, unsigned __int32> bForceSpawnedNotification() { return { this, "APrimalPlayerController.bForceSpawnedNotification" }; }

    BitFieldValue<bool, unsigned __int32> bShowExtendedInfoKey() { return { this, "APrimalPlayerController.bShowExtendedInfoKey" }; }

    BitFieldValue<bool, unsigned __int32> bIsAdmin() { return { this, "APrimalPlayerController.bIsAdmin" }; }

    BitFieldValue<bool, unsigned __int32> bForceShowMouseCursor() { return { this, "APrimalPlayerController.bForceShowMouseCursor" }; }


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "APrimalPlayerController.GetPrivateStaticClass()"); }

    void ClientProcessNetExecCommandBP(AActor* ForActor, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, AActor*, FName, FBPNetExecParams*>(this, "APrimalPlayerController.ClientProcessNetExecCommandBP(AActor*,FName,FBPNetExecParams)", ForActor, CommandName, ExecParams); }

    void ClientProcessNetExecCommandUnreliableBP(AActor* ForActor, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, AActor*, FName, FBPNetExecParams*>(this, "APrimalPlayerController.ClientProcessNetExecCommandUnreliableBP(AActor*,FName,FBPNetExecParams)", ForActor, CommandName, ExecParams); }

    void PropertyServerToClients(AActor* ActorToRep, const FName PropertyName, const TArray<unsigned char, TSizedDefaultAllocator<32> >* ReplicationData) { NativeCall<void, AActor*, const FName, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "APrimalPlayerController.PropertyServerToClients(AActor*,FName,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", ActorToRep, PropertyName, ReplicationData); }

    void PropertyServerToClientsUnreliable(AActor* ActorToRep, const FName PropertyName, const TArray<unsigned char, TSizedDefaultAllocator<32> >* ReplicationData) { NativeCall<void, AActor*, const FName, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "APrimalPlayerController.PropertyServerToClientsUnreliable(AActor*,FName,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", ActorToRep, PropertyName, ReplicationData); }

    static void StaticRegisterNativesAPrimalPlayerController() { NativeCall<void>(nullptr, "APrimalPlayerController.StaticRegisterNativesAPrimalPlayerController()"); }

    void ClientSetHUD_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "APrimalPlayerController.ClientSetHUD_Implementation(TSubclassOf<AHUD>)", NewHUDClass); }

    void ClientProcessNetExecCommand_Implementation(AActor* ForActor, FName CommandName, FNetExecParams* ExecParams) { NativeCall<void, AActor*, FName, FNetExecParams*>(this, "APrimalPlayerController.ClientProcessNetExecCommand_Implementation(AActor*,FName,FNetExecParams)", ForActor, CommandName, ExecParams); }

    void ServerProcessNetExecCommand_Implementation(AActor* ForActor, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, AActor*, FName, FBPNetExecParams*>(this, "APrimalPlayerController.ServerProcessNetExecCommand_Implementation(AActor*,FName,FBPNetExecParams)", ForActor, CommandName, ExecParams); }

    void ServerProcessNetExecCommandUnreliable_Implementation(AActor* ForActor, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, AActor*, FName, FBPNetExecParams*>(this, "APrimalPlayerController.ServerProcessNetExecCommandUnreliable_Implementation(AActor*,FName,FBPNetExecParams)", ForActor, CommandName, ExecParams); }

    void ClientProcessNetExecCommandBP_Implementation(AActor* ForActor, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, AActor*, FName, FBPNetExecParams*>(this, "APrimalPlayerController.ClientProcessNetExecCommandBP_Implementation(AActor*,FName,FBPNetExecParams)", ForActor, CommandName, ExecParams); }

    void ClientProcessSimpleNetExecCommandBP_Implementation(AActor* ForActor, FName CommandName) { NativeCall<void, AActor*, FName>(this, "APrimalPlayerController.ClientProcessSimpleNetExecCommandBP_Implementation(AActor*,FName)", ForActor, CommandName); }

    void ClientProcessSimpleNetExecCommandUnreliableBP_Implementation(AActor* ForActor, FName CommandName) { NativeCall<void, AActor*, FName>(this, "APrimalPlayerController.ClientProcessSimpleNetExecCommandUnreliableBP_Implementation(AActor*,FName)", ForActor, CommandName); }

    void PropertyServerToClients_Implementation(AActor* ActorToRep, const FName PropertyName, const TArray<unsigned char, TSizedDefaultAllocator<32> >* ReplicationData) { NativeCall<void, AActor*, const FName, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "APrimalPlayerController.PropertyServerToClients_Implementation(AActor*,FName,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", ActorToRep, PropertyName, ReplicationData); }

    void PropertyServerToClientsUnreliable_Implementation(AActor* ActorToRep, const FName PropertyName, const TArray<unsigned char, TSizedDefaultAllocator<32> >* ReplicationData) { NativeCall<void, AActor*, const FName, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "APrimalPlayerController.PropertyServerToClientsUnreliable_Implementation(AActor*,FName,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", ActorToRep, PropertyName, ReplicationData); }

};


struct ABasePlayerController : APrimalPlayerController

{

    // Fields


    //TSharedPtr<FOnlineAchievementsWrite, 1>& WriteObjectField() { return *GetNativePointerField<TSharedPtr<FOnlineAchievementsWrite, 1>*>(this, "ABasePlayerController.WriteObject"); }

    FName& ServerSayStringField() { return *GetNativePointerField<FName*>(this, "ABasePlayerController.ServerSayString"); }

    //UUI_CustomOverlay*& customCursorField() { return *GetNativePointerField<UUI_CustomOverlay**>(this, "ABasePlayerController.customCursor"); }

    TWeakObjectPtr<UUI_CustomOverlay>& consoleMouseCursorField() { return *GetNativePointerField<TWeakObjectPtr<UUI_CustomOverlay>*>(this, "ABasePlayerController.consoleMouseCursor"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bCheatEnabled() { return { this, "ABasePlayerController.bCheatEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bGameEndedFrame() { return { this, "ABasePlayerController.bGameEndedFrame" }; }

    BitFieldValue<bool, unsigned __int32> bAllowGameActions() { return { this, "ABasePlayerController.bAllowGameActions" }; }


    // Functions


    void ServerCheat(const FString* Msg) { NativeCall<void, const FString*>(this, "ABasePlayerController.ServerCheat(FString&)", Msg); }

    static void StaticRegisterNativesABasePlayerController() { NativeCall<void>(nullptr, "ABasePlayerController.StaticRegisterNativesABasePlayerController()"); }

    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "ABasePlayerController.GetPrivateStaticClass()"); }

    void ManageVirtualCursor() { NativeCall<void>(this, "ABasePlayerController.ManageVirtualCursor()"); }

    void SetVirtualCursorPosition(UE::Math::TVector2<double>* NewCursorPos) { NativeCall<void, UE::Math::TVector2<double>*>(this, "ABasePlayerController.SetVirtualCursorPosition(UE::Math::TVector2<double>)", NewCursorPos); }

    void TickActor(float DeltaTime, ELevelTick TickType, FActorTickFunction* ThisTickFunction) { NativeCall<void, float, ELevelTick, FActorTickFunction*>(this, "ABasePlayerController.TickActor(float,ELevelTick,FActorTickFunction&)", DeltaTime, TickType, ThisTickFunction); }

    void QueryAchievements() { NativeCall<void>(this, "ABasePlayerController.QueryAchievements()"); }

    void ClientGameStarted_Implementation() { NativeCall<void>(this, "ABasePlayerController.ClientGameStarted_Implementation()"); }

    void ClientStartOnlineGame_Implementation() { NativeCall<void>(this, "ABasePlayerController.ClientStartOnlineGame_Implementation()"); }

    void ClientEndOnlineGame_Implementation() { NativeCall<void>(this, "ABasePlayerController.ClientEndOnlineGame_Implementation()"); }

    void HandleReturnToMainMenu() { NativeCall<void>(this, "ABasePlayerController.HandleReturnToMainMenu()"); }

    void ClientReturnToMainMenu_Implementation(const FString* ReturnReason) { NativeCall<void, const FString*>(this, "ABasePlayerController.ClientReturnToMainMenu_Implementation(FString&)", ReturnReason); }

    void ClientGameEnded_Implementation(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "ABasePlayerController.ClientGameEnded_Implementation(AActor*,bool)", EndGameFocus, bIsWinner); }

    void ResetIntroCinematicsAndItems() { NativeCall<void>(this, "ABasePlayerController.ResetIntroCinematicsAndItems()"); }

    void ClientSendRoundEndEvent_Implementation(bool bIsWinner, int ExpendedTimeInSeconds) { NativeCall<void, bool, int>(this, "ABasePlayerController.ClientSendRoundEndEvent_Implementation(bool,int)", bIsWinner, ExpendedTimeInSeconds); }

    //void PreClientTravel(const FString* PendingURL, ETravelType TravelType, bool bIsSeamlessTravel) { NativeCall<void, const FString*, ETravelType, bool>(this, "ABasePlayerController.PreClientTravel(FString&,ETravelType,bool)", PendingURL, TravelType, bIsSeamlessTravel); }

    void ClientSetSpectatorCamera_Implementation(UE::Math::TVector<double>* CameraLocation, UE::Math::TRotator<double>* CameraRotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "ABasePlayerController.ClientSetSpectatorCamera_Implementation(UE::Math::TVector<double>,UE::Math::TRotator<double>)", CameraLocation, CameraRotation); }

    __int64 SetPause(bool bPause, TDelegate<bool __cdecl(void), FDefaultDelegateUserPolicy>* CanUnpauseDelegate) { return NativeCall<__int64, bool, TDelegate<bool __cdecl(void), FDefaultDelegateUserPolicy>*>(this, "ABasePlayerController.SetPause(bool,TDelegate<bool__cdecl(void)", bPause, CanUnpauseDelegate); }

    bool HasValidAdminIP() { return NativeCall<bool>(this, "ABasePlayerController.HasValidAdminIP()"); }

    void ServerCheat_Implementation(const FString* Msg) { NativeCall<void, const FString*>(this, "ABasePlayerController.ServerCheat_Implementation(FString&)", Msg); }

    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "ABasePlayerController.IsMoveInputIgnored()"); }

    bool IsLookInputIgnored() { return NativeCall<bool>(this, "ABasePlayerController.IsLookInputIgnored()"); }

    bool IsGameInputAllowed() { return NativeCall<bool>(this, "ABasePlayerController.IsGameInputAllowed()"); }

};


struct AShooterPlayerController : ABasePlayerController

{

    // Fields


    UPaintingStreamingComponent*& PaintingStreamingComponentField() { return *GetNativePointerField<UPaintingStreamingComponent**>(this, "AShooterPlayerController.PaintingStreamingComponent"); }

    FieldArray<unsigned __int8, 10> HeldItemSlotField() { return { this, "AShooterPlayerController.HeldItemSlot" }; }

    FieldArray<unsigned __int8, 10> UsedItemSlotField() { return { this, "AShooterPlayerController.UsedItemSlot" }; }

    FieldArray<long double, 10> LastRepeatUseConsumableTimeField() { return { this, "AShooterPlayerController.LastRepeatUseConsumableTime" }; }

    int& LastFrameScrollUpField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastFrameScrollUp"); }

    int& LastFrameScrollDownField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastFrameScrollDown"); }

    FieldArray<long double, 10> HeldItemSlotTimeField() { return { this, "AShooterPlayerController.HeldItemSlotTime" }; }

    FieldArray<long double, 10> LastUsedItemSlotTimesField() { return { this, "AShooterPlayerController.LastUsedItemSlotTimes" }; }

    float& RespawnSoundDelayField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.RespawnSoundDelay"); }

    //TSubclassOf<UUI_PauseMenu>& PauseMenuUITemplateField() { return *GetNativePointerField<TSubclassOf<UUI_PauseMenu>*>(this, "AShooterPlayerController.PauseMenuUITemplate"); }

    UE::Math::TRotator<double>& LastCachedPlayerControlRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "AShooterPlayerController.LastCachedPlayerControlRotation"); }

    TDelegate<void __cdecl(FString), FDefaultDelegateUserPolicy>& OnClientMessageOfTheDayRecivedField() { return *GetNativePointerField<TDelegate<void __cdecl(FString), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerController.OnClientMessageOfTheDayRecived"); }

    UE::Math::TVector<double>& CurrentPlayerCharacterLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.CurrentPlayerCharacterLocation"); }

    AActor*& TargetAimMagnetismField() { return *GetNativePointerField<AActor**>(this, "AShooterPlayerController.TargetAimMagnetism"); }

    float& MaxDragWeightToAimBoneField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.MaxDragWeightToAimBone"); }

    int& ModifedButtonCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ModifedButtonCount"); }

    int& nArkTributeLoadIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.nArkTributeLoadIndex"); }

    APrimalStructurePlacer*& StructurePlacerField() { return *GetNativePointerField<APrimalStructurePlacer**>(this, "AShooterPlayerController.StructurePlacer"); }

    FTimerHandle& MeleeAimAssistTimerField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.MeleeAimAssistTimer"); }

    UE::Math::TVector<double>& LastDeathLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.LastDeathLocation"); }

    long double& LastDeathTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastDeathTime"); }

    long double& LastDeathMarkField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastDeathMark"); }

    long double& LastDismissedPOIField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastDismissedPOI"); }

    FPointOfInterestData& DismissCenterScreenPOIField() { return *GetNativePointerField<FPointOfInterestData*>(this, "AShooterPlayerController.DismissCenterScreenPOI"); }

    FTimerHandle& DismissPOITimerField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.DismissPOITimer"); }

    TWeakObjectPtr<APrimalCharacter>& LastDeathPrimalCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "AShooterPlayerController.LastDeathPrimalCharacter"); }

    long double& LastDeadCharacterDestructionTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastDeadCharacterDestructionTime"); }

    long double& LastLargeQuantityTranserAllTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastLargeQuantityTranserAllTime"); }

    bool& bShowGameModeHUDField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bShowGameModeHUD"); }

    UE::Math::TVector2<double>& CurrentRadialDirection1Field() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "AShooterPlayerController.CurrentRadialDirection1"); }

    UE::Math::TVector2<double>& CurrentRadialDirection2Field() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "AShooterPlayerController.CurrentRadialDirection2"); }

    USoundCue*& SelectSlotSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterPlayerController.SelectSlotSound"); }

    //TSubclassOf<UFogOfWar>& FogOfWarClassField() { return *GetNativePointerField<TSubclassOf<UFogOfWar>*>(this, "AShooterPlayerController.FogOfWarClass"); }

    //UFogOfWar*& FogOfWarField() { return *GetNativePointerField<UFogOfWar**>(this, "AShooterPlayerController.FogOfWar"); }

    UPrimalLocalProfile*& PrimalLocalProfileField() { return *GetNativePointerField<UPrimalLocalProfile**>(this, "AShooterPlayerController.PrimalLocalProfile"); }

    FTimerHandle& SaveProfileHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.SaveProfileHandle"); }

    FString& ServerVersionField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.ServerVersion"); }

    int& CurrentGameModeMaxNumOfRespawnsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CurrentGameModeMaxNumOfRespawns"); }

    AShooterCharacter*& LastDiedListenServerHostField() { return *GetNativePointerField<AShooterCharacter**>(this, "AShooterPlayerController.LastDiedListenServerHost"); }

    UE::Math::TVector<double>& LastRawInputDirField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.LastRawInputDir"); }

    unsigned __int64& TargetOrbitedPlayerIdField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterPlayerController.TargetOrbitedPlayerId"); }

    TWeakObjectPtr<AShooterCharacter>& LastControlledPlayerCharacterField() { return *GetNativePointerField<TWeakObjectPtr<AShooterCharacter>*>(this, "AShooterPlayerController.LastControlledPlayerCharacter"); }

    TSubclassOf<APrimalStructurePlacer>& StructurePlacerClassField() { return *GetNativePointerField<TSubclassOf<APrimalStructurePlacer>*>(this, "AShooterPlayerController.StructurePlacerClass"); }

    FTimerHandle& UnFreezeHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.UnFreezeHandle"); }

    float& MaxUseDistanceField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.MaxUseDistance"); }

    float& MaxUseCheckRadiusField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.MaxUseCheckRadius"); }

    TArray<bool, TSizedDefaultAllocator<32> >& SavedSurvivorProfileSettingsField() { return *GetNativePointerField<TArray<bool, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.SavedSurvivorProfileSettings"); }

    int& SavedMissionBiomeFilterMaskField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.SavedMissionBiomeFilterMask"); }

    bool& bMissionSortByDistanceField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bMissionSortByDistance"); }

    FTimerHandle& StartInventoryRadialSelectorHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.StartInventoryRadialSelectorHandle"); }

    FTimerHandle& StartChatHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.StartChatHandle"); }

    FTimerHandle& StartPlayerActionRadialSelectorHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.StartPlayerActionRadialSelectorHandle"); }

    FTimerHandle& GamepadBackHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.GamepadBackHandle"); }

    FTimerHandle& StartWhistleSelectionHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.StartWhistleSelectionHandle"); }

    FTimerHandle& StartEmoteSelectionHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.StartEmoteSelectionHandle"); }

    FTimerHandle& TimerToggleChangeCameraModeField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.TimerToggleChangeCameraMode"); }

    FTimerHandle& ToggleDubleTapTimerMapField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.ToggleDubleTapTimerMap"); }

    //FMinimapMark& CurrentTrackingMarkField() { return *GetNativePointerField<FMinimapMark*>(this, "AShooterPlayerController.CurrentTrackingMark"); }

    long double& LastServerRequestFuelQuantityField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastServerRequestFuelQuantity"); }

    TArray<FDinoMapMarkerInfo, TSizedDefaultAllocator<32> >& MapDinosField() { return *GetNativePointerField<TArray<FDinoMapMarkerInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.MapDinos"); }

    TArray<TWeakObjectPtr<UPrimalInventoryComponent>, TSizedDefaultAllocator<32> >& RemoteViewingInventoriesField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UPrimalInventoryComponent>, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.RemoteViewingInventories"); }

    FTimerHandle& OnUseHeldTimerHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.OnUseHeldTimerHandle"); }

    TArray<int, TSizedDefaultAllocator<32> >& LastWheelCategoriesField() { return *GetNativePointerField<TArray<int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.LastWheelCategories"); }

    TArray<UTexture2D*, TSizedDefaultAllocator<32> >& LastWheelIconsField() { return *GetNativePointerField<TArray<UTexture2D*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.LastWheelIcons"); }

    TArray<FString, TSizedDefaultAllocator<32> >& LastWheelStringsField() { return *GetNativePointerField<TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.LastWheelStrings"); }

    TWeakObjectPtr<AActor>& LastHeldUseActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AShooterPlayerController.LastHeldUseActor"); }

    TWeakObjectPtr<UActorComponent>& LastHeldUseHitComponentField() { return *GetNativePointerField<TWeakObjectPtr<UActorComponent>*>(this, "AShooterPlayerController.LastHeldUseHitComponent"); }

    int& LastHeldUseHitBodyIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastHeldUseHitBodyIndex"); }

    TWeakObjectPtr<AActor>& SpawnAtBedField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AShooterPlayerController.SpawnAtBed"); }

    TWeakObjectPtr<AActor>& FastTravelDroppedInventoryField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AShooterPlayerController.FastTravelDroppedInventory"); }

    APawn*& TempLastLostPawnField() { return *GetNativePointerField<APawn**>(this, "AShooterPlayerController.TempLastLostPawn"); }

    int& VoiceChatFilerTypeField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.VoiceChatFilerType"); }

    FTimerHandle& OnRepeatUseHeldTimerHandlerField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.OnRepeatUseHeldTimerHandler"); }

    bool& bPreventCanOpenMapField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bPreventCanOpenMap"); }

    AActor*& PhotoModeMarkerActorField() { return *GetNativePointerField<AActor**>(this, "AShooterPlayerController.PhotoModeMarkerActor"); }

    long double& LastRespawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastRespawnTime"); }

    TSubclassOf<AHUD>& AwaitingHUDClassField() { return *GetNativePointerField<TSubclassOf<AHUD>*>(this, "AShooterPlayerController.AwaitingHUDClass"); }

    FItemNetID& LastEquipedItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterPlayerController.LastEquipedItemNetID"); }

    FItemNetID& LastUnequippedItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterPlayerController.LastUnequippedItemNetID"); }

    FTimerHandle& CloseSteamStatusSceneHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.CloseSteamStatusSceneHandle"); }

    __int64& LinkedPlayerIDField() { return *GetNativePointerField<__int64*>(this, "AShooterPlayerController.LinkedPlayerID"); }

    //TSubclassOf<UUI_SteamInventoryStatusPopup>& SteamInventoryStatusUITemplateField() { return *GetNativePointerField<TSubclassOf<UUI_SteamInventoryStatusPopup>*>(this, "AShooterPlayerController.SteamInventoryStatusUITemplate"); }

    int& PlayerControllerNumField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.PlayerControllerNum"); }

    UE::Math::TVector<double>& LastTurnSpeedField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.LastTurnSpeed"); }

    long double& LastMultiUseInteractionTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastMultiUseInteractionTime"); }

    long double& LastTimeSentCarriedRotationField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTimeSentCarriedRotation"); }

    //TMap<FGuid, FARKTributeData, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FGuid, FARKTributeData, 0> >& LastArkTributeDataField() { return *GetNativePointerField<TMap<FGuid, FARKTributeData, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FGuid, FARKTributeData, 0> >*>(this, "AShooterPlayerController.LastArkTributeData"); }

    //TMap<unsigned __int64, FNonClusterCharacterUploadData, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<unsigned __int64, FNonClusterCharacterUploadData, 0> >& InProgressNonClusterCharacterUploadsField() { return *GetNativePointerField<TMap<unsigned __int64, FNonClusterCharacterUploadData, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<unsigned __int64, FNonClusterCharacterUploadData, 0> >*>(this, "AShooterPlayerController.InProgressNonClusterCharacterUploads"); }

    FItemNetID& LastSteamItemIDToRemoveField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterPlayerController.LastSteamItemIDToRemove"); }

    FItemNetID& LastSteamItemIDToAddField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterPlayerController.LastSteamItemIDToAdd"); }

    bool& bRefreshedInvetoryForRemoveField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bRefreshedInvetoryForRemove"); }

    bool& bServerRefreshStatusField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerRefreshStatus"); }

    IOnlineSubsystem*& OnlineSubField() { return *GetNativePointerField<IOnlineSubsystem**>(this, "AShooterPlayerController.OnlineSub"); }

    long double& LastSteamInventoryRefreshTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastSteamInventoryRefreshTime"); }

    long double& LastRequesteDinoAncestorsTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastRequesteDinoAncestorsTime"); }

    long double& LastDiedMessageTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastDiedMessageTime"); }

    long double& LastNotifiedTorpidityIncreaseTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastNotifiedTorpidityIncreaseTime"); }

    long double& LastInvDropRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastInvDropRequestTime"); }

    long double& LastHadPawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastHadPawnTime"); }

    long double& LastChatMessageTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastChatMessageTime"); }

    FItemNetInfo& ARKTributeItemNetInfoField() { return *GetNativePointerField<FItemNetInfo*>(this, "AShooterPlayerController.ARKTributeItemNetInfo"); }

    bool& bServerPaintingSuccessField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerPaintingSuccess"); }

    long double& LastListenServerNotifyOutOfRangeTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastListenServerNotifyOutOfRangeTime"); }

    int& SpectatorCycleIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.SpectatorCycleIndex"); }

    bool& bIsFastTravellingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsFastTravelling"); }

    bool& bEnableTargetingInputField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bEnableTargetingInput"); }

    bool& bEnableAltFireField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bEnableAltFire"); }

    long double& WaitingForSpawnUITimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.WaitingForSpawnUITime"); }

    float& ChatSpamWeightField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ChatSpamWeight"); }

    long double& EnteredSpectatingStateTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.EnteredSpectatingStateTime"); }

    bool& bPreventPaintingStreamingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bPreventPaintingStreaming"); }

    long double& LastUsePressTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastUsePressTime"); }

    int& LastHarvestedElementIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastHarvestedElementIndex"); }

    TArray<int, TSizedDefaultAllocator<32> >& NotifiedTribeWarIDsField() { return *GetNativePointerField<TArray<int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.NotifiedTribeWarIDs"); }

    TArray<FString, TSizedDefaultAllocator<32> >& NotifiedTribeWarNamesField() { return *GetNativePointerField<TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.NotifiedTribeWarNames"); }

    int& ServerTribeLogLastLogIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ServerTribeLogLastLogIndex"); }

    int& ServerTribeLogLastTribeIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ServerTribeLogLastTribeID"); }

    UE::Math::TVector<double>& LastViewLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.LastViewLocation"); }

    bool& bClientReceivedTribeLogField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bClientReceivedTribeLog"); }

    TArray<FString, TSizedDefaultAllocator<32> >& CurrentTribeLogField() { return *GetNativePointerField<TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.CurrentTribeLog"); }

    long double& LastTribeLogRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTribeLogRequestTime"); }

    FWindowsCriticalSection& ChatPrivilegCSField() { return *GetNativePointerField<FWindowsCriticalSection*>(this, "AShooterPlayerController.ChatPrivilegCS"); }

    TDelegate<void __cdecl(FUniqueNetId const&, enum EUserPrivileges::Type, unsigned int), FDefaultDelegateUserPolicy>& GetUserCommunicationPrivilegeWithTargetUserCompleteDelegateField() { return *GetNativePointerField<TDelegate<void __cdecl(FUniqueNetId const&, enum EUserPrivileges::Type, unsigned int), FDefaultDelegateUserPolicy>*>(this, "AShooterPlayerController.GetUserCommunicationPrivilegeWithTargetUserCompleteDelegate"); }

    FThreadSafeCounter& MessageQueueTasksCounterField() { return *GetNativePointerField<FThreadSafeCounter*>(this, "AShooterPlayerController.MessageQueueTasksCounter"); }

    TArray<FPrimalChatMessage*, TSizedDefaultAllocator<32> >& MessageQueueField() { return *GetNativePointerField<TArray<FPrimalChatMessage*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.MessageQueue"); }

    bool& bServerAllowCommunicationField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerAllowCommunication"); }

    FThreadSafeCounter& ServerMessageQueueTasksCounterField() { return *GetNativePointerField<FThreadSafeCounter*>(this, "AShooterPlayerController.ServerMessageQueueTasksCounter"); }

    //TArray<FServerChatMessage, TSizedDefaultAllocator<32> >& ServerMessageQueueField() { return *GetNativePointerField<TArray<FServerChatMessage, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ServerMessageQueue"); }

    bool& bHasSurvivedOneDayField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasSurvivedOneDay"); }

    bool& bHasReachedLowestDepthField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasReachedLowestDepth"); }

    TSet<FString, DefaultKeyFuncs<FString, 0>, FDefaultSetAllocator>& ServerCachedAchievementIDsField() { return *GetNativePointerField<TSet<FString, DefaultKeyFuncs<FString, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerController.ServerCachedAchievementIDs"); }

    bool& bZoomingInField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bZoomingIn"); }

    long double& LastRPCStayAliveTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastRPCStayAliveTime"); }

    int& PlayerBadgeGroupField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.PlayerBadgeGroup"); }

    long double& LastMultiUseTraceTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastMultiUseTraceTime"); }

    UE::Math::TVector<double>& LastLargeMoveLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.LastLargeMoveLocation"); }

    long double& LastLargeMoveTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastLargeMoveTime"); }

    long double& LastNotOnUnriddenDinoTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastNotOnUnriddenDinoTime"); }

    TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >& WaypointsSOTFField() { return *GetNativePointerField<TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.WaypointsSOTF"); }

    long double& LastHitMarkerCharacterTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastHitMarkerCharacterTime"); }

    long double& LastHitMarkerStructureTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastHitMarkerStructureTime"); }

    //FHitMarkerSettings& LastHitMarkerCharacterSettingsField() { return *GetNativePointerField<FHitMarkerSettings*>(this, "AShooterPlayerController.LastHitMarkerCharacterSettings"); }

    float& DoFSettingCurrentTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DoFSettingCurrentTimer"); }

    float& DoFSettingTargetTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DoFSettingTargetTimer"); }

    TArray<FSteamInventoryItemInfo, TSizedDefaultAllocator<32> >& PlayerInventoryItemsField() { return *GetNativePointerField<TArray<FSteamInventoryItemInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.PlayerInventoryItems"); }

    int& LastSpawnPointIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastSpawnPointID"); }

    int& LastSpawnRegionIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastSpawnRegionIndex"); }

    int& LastDownloadCachedTribeIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastDownloadCachedTribeID"); }

    TArray<unsigned char, TSizedDefaultAllocator<32> >& LastDownloadPlayerDataBytesField() { return *GetNativePointerField<TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.LastDownloadPlayerDataBytes"); }

    unsigned __int64& LastTransferredPlayerIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterPlayerController.LastTransferredPlayerID"); }

    //AShooterPlayerController::CharacterTransferState& CurrentCharacterTransferStateField() { return *GetNativePointerField<AShooterPlayerController::CharacterTransferState*>(this, "AShooterPlayerController.CurrentCharacterTransferState"); }

    bool& bIsTransferringCharacterField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsTransferringCharacter"); }

    long double& PossessedFirstPawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.PossessedFirstPawnTime"); }

    int& SnapPointCycleField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.SnapPointCycle"); }

    int& TotalNumSnapPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.TotalNumSnapPoints"); }

    UE::Math::TVector<double>& LastSnapPointCyclePositionField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.LastSnapPointCyclePosition"); }

    int& ViewingWheelCategoryField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ViewingWheelCategory"); }

    long double& ForceDrawCurrentGroupsUntilTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ForceDrawCurrentGroupsUntilTime"); }

    long double& LastRequestedPlaceStructureTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastRequestedPlaceStructureTime"); }

    long double& LastVerifyStructureItemTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastVerifyStructureItemTime"); }

    long double& LastServerRemovePawnItemTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastServerRemovePawnItemTime"); }

    int& PersonalDinoTameCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.PersonalDinoTameCount"); }

    bool& bForceHideGameplayUIField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bForceHideGameplayUI"); }

    long double& LastGamepadOpenRemoteInventoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastGamepadOpenRemoteInventoryTime"); }

    long double& LastClientRequestTribeOnlineListTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastClientRequestTribeOnlineListTime"); }

    long double& LastClientModifiedARKInventoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastClientModifiedARKInventoryTime"); }

    TArray<unsigned __int64, TSizedDefaultAllocator<32> >& ClientCachedTribeOnlineListField() { return *GetNativePointerField<TArray<unsigned __int64, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientCachedTribeOnlineList"); }

    float& SFXVolumeMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.SFXVolumeMultiplier"); }

    long double& LastTeleportedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTeleportedTime"); }

    unsigned __int64& LastConvertedPlayerIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterPlayerController.LastConvertedPlayerID"); }

    FString& LastConvertedPlayerIDStringField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.LastConvertedPlayerIDString"); }

    long double& LastShowExtendedInfoTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastShowExtendedInfoTime"); }

    UPrimalItem*& LastTransferredToRemoteInventoryItemField() { return *GetNativePointerField<UPrimalItem**>(this, "AShooterPlayerController.LastTransferredToRemoteInventoryItem"); }

    TSet<TWeakObjectPtr<UPrimalInventoryComponent>, DefaultKeyFuncs<TWeakObjectPtr<UPrimalInventoryComponent>, 0>, FDefaultSetAllocator>& PendingResponseEquippedItemsQueueField() { return *GetNativePointerField<TSet<TWeakObjectPtr<UPrimalInventoryComponent>, DefaultKeyFuncs<TWeakObjectPtr<UPrimalInventoryComponent>, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerController.PendingResponseEquippedItemsQueue"); }

    TSet<TWeakObjectPtr<UPrimalInventoryComponent>, DefaultKeyFuncs<TWeakObjectPtr<UPrimalInventoryComponent>, 0>, FDefaultSetAllocator>& PendingRequestEquippedItemsQueueField() { return *GetNativePointerField<TSet<TWeakObjectPtr<UPrimalInventoryComponent>, DefaultKeyFuncs<TWeakObjectPtr<UPrimalInventoryComponent>, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerController.PendingRequestEquippedItemsQueue"); }

    bool& bIsOnlyViewingRemoteInventoryField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsOnlyViewingRemoteInventory"); }

    bool& bDrawBlackBackgroundField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bDrawBlackBackground"); }

    TSubclassOf<APrimalBuff>& CreativeModeBuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "AShooterPlayerController.CreativeModeBuff"); }

    float& PrimalStatsCacheFlushIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PrimalStatsCacheFlushInterval"); }

    //FPrimalStats& PrimalStatsCacheField() { return *GetNativePointerField<FPrimalStats*>(this, "AShooterPlayerController.PrimalStatsCache"); }

    bool& bAutoPlayerField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bAutoPlayer"); }

    float& PingCoolDownTimeField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingCoolDownTime"); }

    long double& LastPingTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastPingTime"); }

    float& PingTraceDistanceField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingTraceDistance"); }

    int& MaxTeamPingDataOnClientField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.MaxTeamPingDataOnClient"); }

    //TArray<FTeamPingDataForClient, TSizedDefaultAllocator<32> >& CurrentClientTeamPingsField() { return *GetNativePointerField<TArray<FTeamPingDataForClient, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.CurrentClientTeamPings"); }

    //FTeamPingDataForClient& TeamPingSettings_GoHereField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_GoHere"); }

    //FTeamPingDataForClient& TeamPingSettings_FollowField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_Follow"); }

    //FTeamPingDataForClient& TeamPingSettings_FollowMeField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_FollowMe"); }

    //FTeamPingDataForClient& TeamPingSettings_AttackField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_Attack"); }

    //FTeamPingDataForClient& TeamPingSettings_TameField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_Tame"); }

    //FTeamPingDataForClient& TeamPingSettings_LootItField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_LootIt"); }

    //FTeamPingDataForClient& TeamPingSettings_DangerField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_Danger"); }

    //FTeamPingDataForClient& TeamPingSettings_TrackField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_Track"); }

    //FTeamPingDataForClient& TeamPingSettings_RallyPointField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_RallyPoint"); }

    //FTeamPingDataForClient& TeamPingSettings_ClearRallyPointField() { return *GetNativePointerField<FTeamPingDataForClient*>(this, "AShooterPlayerController.TeamPingSettings_ClearRallyPoint"); }

    float& PingNotifyRadiusField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingNotifyRadius"); }

    float& PingLifetimeField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingLifetime"); }

    float& PingLifetime_DyingField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingLifetime_Dying"); }

    UTexture2D*& PingIcon_DefaultField() { return *GetNativePointerField<UTexture2D**>(this, "AShooterPlayerController.PingIcon_Default"); }

    UTexture2D*& PingIcon_PlayersField() { return *GetNativePointerField<UTexture2D**>(this, "AShooterPlayerController.PingIcon_Players"); }

    UTexture2D*& PingIcon_DinosField() { return *GetNativePointerField<UTexture2D**>(this, "AShooterPlayerController.PingIcon_Dinos"); }

    UTexture2D*& PingIcon_StructuresField() { return *GetNativePointerField<UTexture2D**>(this, "AShooterPlayerController.PingIcon_Structures"); }

    TArray<FPingData, TSizedDefaultAllocator<32> >& CurrentPingsField() { return *GetNativePointerField<TArray<FPingData, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.CurrentPings"); }

    FTimerHandle& TeamPingWheelHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.TeamPingWheelHandle"); }

    FTimerHandle& TribeRallyPointUpdateHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.TribeRallyPointUpdateHandle"); }

    FTeamPingData& TribeCacheRallyPointDataField() { return *GetNativePointerField<FTeamPingData*>(this, "AShooterPlayerController.TribeCacheRallyPointData"); }

    FDelegateHandle& RecvHandleField() { return *GetNativePointerField<FDelegateHandle*>(this, "AShooterPlayerController.RecvHandle"); }

    FDelegateHandle& BeforeSendHandleField() { return *GetNativePointerField<FDelegateHandle*>(this, "AShooterPlayerController.BeforeSendHandle"); }

    FWindowsCriticalSection& PlayerDataForVoiceCSField() { return *GetNativePointerField<FWindowsCriticalSection*>(this, "AShooterPlayerController.PlayerDataForVoiceCS"); }

    //TMap<FString, AShooterPlayerController::FPlayerDataForVoice, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, AShooterPlayerController::FPlayerDataForVoice, 0> >& PlayerDataForVoiceField() { return *GetNativePointerField<TMap<FString, AShooterPlayerController::FPlayerDataForVoice, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, AShooterPlayerController::FPlayerDataForVoice, 0> >*>(this, "AShooterPlayerController.PlayerDataForVoice"); }

    TAtomic<int>& VoiceChatFilerTypeTSField() { return *GetNativePointerField<TAtomic<int>*>(this, "AShooterPlayerController.VoiceChatFilerTypeTS"); }

    long double& LastVoiceOutTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastVoiceOutTime"); }

    //AShooterPlayerController::EQueryBlockedVoiceState& QueryBlockedVoiceStateField() { return *GetNativePointerField<AShooterPlayerController::EQueryBlockedVoiceState*>(this, "AShooterPlayerController.QueryBlockedVoiceState"); }

    //TMap<TSharedRef<FUniqueNetId const, 1>, bool, FDefaultSetAllocator, TUniqueNetIdMapKeyFuncs<bool> >& BlockedVoiceQueryResultsField() { return *GetNativePointerField<TMap<TSharedRef<FUniqueNetId const, 1>, bool, FDefaultSetAllocator, TUniqueNetIdMapKeyFuncs<bool> >*>(this, "AShooterPlayerController.BlockedVoiceQueryResults"); }

    TMap<FString, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, bool, 0> >& BlockedVoiceUsersField() { return *GetNativePointerField<TMap<FString, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, bool, 0> >*>(this, "AShooterPlayerController.BlockedVoiceUsers"); }

    TMap<FString, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, bool, 0> >& BlockedTextUsersField() { return *GetNativePointerField<TMap<FString, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, bool, 0> >*>(this, "AShooterPlayerController.BlockedTextUsers"); }

    TArray<FString, TSizedDefaultAllocator<32> >& QueuedBlockedVoiceChatUsersToProcessAfterLoggingInField() { return *GetNativePointerField<TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.QueuedBlockedVoiceChatUsersToProcessAfterLoggingIn"); }

    long double& LastBlockedVoiceQueryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastBlockedVoiceQueryTime"); }

    FDelegateHandle& OnSystemUIOverlayStateChangedDelegateHandleField() { return *GetNativePointerField<FDelegateHandle*>(this, "AShooterPlayerController.OnSystemUIOverlayStateChangedDelegateHandle"); }

    FDelegateHandle& ApplicationReactivatedDelegateHandleField() { return *GetNativePointerField<FDelegateHandle*>(this, "AShooterPlayerController.ApplicationReactivatedDelegateHandle"); }

    FDelegateHandle& ApplicationEnteredForegroundDelegateHandleField() { return *GetNativePointerField<FDelegateHandle*>(this, "AShooterPlayerController.ApplicationEnteredForegroundDelegateHandle"); }

    FDelegateHandle& ApplicationSystemBlockListChangedDelegateHandleField() { return *GetNativePointerField<FDelegateHandle*>(this, "AShooterPlayerController.ApplicationSystemBlockListChangedDelegateHandle"); }

    bool& bWaitingForServerMessageOfTheDayField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bWaitingForServerMessageOfTheDay"); }

    float& POI_SearchTickInterval_CurrentField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.POI_SearchTickInterval_Current"); }

    UE::Math::TVector2<double>& POI_SearchTickInterval_RandRangesField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "AShooterPlayerController.POI_SearchTickInterval_RandRanges"); }

    float& POI_SearchRadiusField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.POI_SearchRadius"); }

    long double& POI_LastSearchTickTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.POI_LastSearchTickTime"); }

    TArray<UUserWidget*, TSizedDefaultAllocator<32> >& SpawnedPointWidgetsField() { return *GetNativePointerField<TArray<UUserWidget*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.SpawnedPointWidgets"); }

    TArray<APointOfInterestCosmeticActor*, TSizedDefaultAllocator<32> >& SpawnedPointCosmeticActorsField() { return *GetNativePointerField<TArray<APointOfInterestCosmeticActor*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.SpawnedPointCosmeticActors"); }

    TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >& NearbyPointsOfInterestField() { return *GetNativePointerField<TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.NearbyPointsOfInterest"); }

    FMissionWaypointInfo& MissionWaypointField() { return *GetNativePointerField<FMissionWaypointInfo*>(this, "AShooterPlayerController.MissionWaypoint"); }

    long double& LastGen1FixENTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastGen1FixENTime"); }

    float& Gen1FixENTimeThresholdField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.Gen1FixENTimeThreshold"); }

    int& Gen1FixENCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.Gen1FixENCount"); }

    int& Gen1FixENCountThresholdField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.Gen1FixENCountThreshold"); }

    //FOnClientReceiveStructuresPlacedOnFloor& OnClientReceiveStructuresPlacedOnFloorField() { return *GetNativePointerField<FOnClientReceiveStructuresPlacedOnFloor*>(this, "AShooterPlayerController.OnClientReceiveStructuresPlacedOnFloor"); }

    FLinearColor& ForceColorOverlayColorField() { return *GetNativePointerField<FLinearColor*>(this, "AShooterPlayerController.ForceColorOverlayColor"); }

    long double& ForceColorOverlayUntilTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ForceColorOverlayUntilTime"); }

    long double& ForceColorOverlayFadeOutTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ForceColorOverlayFadeOutTime"); }

    int& Gen1ENFixDesyncValueField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.Gen1ENFixDesyncValue"); }

    //TArray<FStructHighlightInfo, TSizedDefaultAllocator<32> >& HighlightedStructuresField() { return *GetNativePointerField<TArray<FStructHighlightInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.HighlightedStructures"); }

    TArray<TSoftClassPtr<APrimalStructure>, TSizedDefaultAllocator<32> >& EnforcementRelevantStructuresField() { return *GetNativePointerField<TArray<TSoftClassPtr<APrimalStructure>, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.EnforcementRelevantStructures"); }

    TArray<FLinearColor, TSizedDefaultAllocator<32> >& EnforcementColorsField() { return *GetNativePointerField<TArray<FLinearColor, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.EnforcementColors"); }

    bool& bIsDelayedNetCleanupField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsDelayedNetCleanup"); }

    FTimerHandle& DelayedNetCleanupHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.DelayedNetCleanupHandle"); }

    bool& meleeAttackOrGatheringIsGatheringField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.meleeAttackOrGatheringIsGathering"); }

    float& meleeAttackOrGatheringTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.meleeAttackOrGatheringTimer"); }

    int& LastFrameAimedUseActorCachedField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastFrameAimedUseActorCached"); }

    AActor*& CachedAimedUseActorField() { return *GetNativePointerField<AActor**>(this, "AShooterPlayerController.CachedAimedUseActor"); }

    UActorComponent*& CachedAimedUseActorComponentField() { return *GetNativePointerField<UActorComponent**>(this, "AShooterPlayerController.CachedAimedUseActorComponent"); }

    int& CachedHitBodyIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CachedHitBodyIndex"); }

    TArray<FOctreeElementSimple*, TSizedDefaultAllocator<32> >& Cached_AimedSimplePrimitivesField() { return *GetNativePointerField<TArray<FOctreeElementSimple*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.Cached_AimedSimplePrimitives"); }

    unsigned __int64& LoadingFramesField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterPlayerController.LoadingFrames"); }

    float& disableWalkFromRadialWheelField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.disableWalkFromRadialWheel"); }

    bool& bEnableSpectatorCyclingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bEnableSpectatorCycling"); }

    //FUserCosmeticInfo& UserCosmeticInfoField() { return *GetNativePointerField<FUserCosmeticInfo*>(this, "AShooterPlayerController.UserCosmeticInfo"); }

    TMap<int, AActor*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, AActor*, 0> >& ActiveWaypoints_CreaturesField() { return *GetNativePointerField<TMap<int, AActor*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, AActor*, 0> >*>(this, "AShooterPlayerController.ActiveWaypoints_Creatures"); }

    TMap<int, AActor*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, AActor*, 0> >& ActiveWaypoints_PlayersField() { return *GetNativePointerField<TMap<int, AActor*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, AActor*, 0> >*>(this, "AShooterPlayerController.ActiveWaypoints_Players"); }

    long double& LastNetworkTimeRequestedFilterCachedTeamTameListField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastNetworkTimeRequestedFilterCachedTeamTameList"); }

    FTimerHandle& ServerRequestTamingInfoListHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.ServerRequestTamingInfoListHandle"); }

    //TArray<FTamingWaypointInfo, TSizedDefaultAllocator<32> >& TamingWaypointsField() { return *GetNativePointerField<TArray<FTamingWaypointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.TamingWaypoints"); }

    FTimerHandle& ServerRequestTrackedDinoInfoListHandle_WithUIField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.ServerRequestTrackedDinoInfoListHandle_WithUI"); }

    FTimerHandle& ServerRequestTrackedDinoInfoListHandle_WithoutUIField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.ServerRequestTrackedDinoInfoListHandle_WithoutUI"); }

    //TArray<FTrackedActorWaypointInfo, TSizedDefaultAllocator<32> >& TrackedActorWaypointsField() { return *GetNativePointerField<TArray<FTrackedActorWaypointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.TrackedActorWaypoints"); }

    //TArray<FTrackedActorWaypointInfo, TSizedDefaultAllocator<32> >& TrackedActorWaypoints_TeammatesOnMapField() { return *GetNativePointerField<TArray<FTrackedActorWaypointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.TrackedActorWaypoints_TeammatesOnMap"); }

    int& CustomActorTracking_DisplayedResultsCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CustomActorTracking_DisplayedResultsCount"); }

    int& CustomActorTracking_LastSavedCustomTameSelectionTypeField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CustomActorTracking_LastSavedCustomTameSelectionType"); }

    int& CustomActorTracking_LastSavedDinoGroupField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CustomActorTracking_LastSavedDinoGroup"); }

    FString& CustomActorTracking_LastSavedCustomTameSearchTextField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.CustomActorTracking_LastSavedCustomTameSearchText"); }

    int& CustomActorTracking_LastSavedScrollbarIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CustomActorTracking_LastSavedScrollbarIndex"); }

    bool& CustomActorTracking_HasJustChangedDinoGroupField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.CustomActorTracking_HasJustChangedDinoGroup"); }

    UE::Math::TVector<double>& AimMangetismClosestLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterPlayerController.AimMangetismClosestLocation"); }

    FName& AimMangetismCosestBoneField() { return *GetNativePointerField<FName*>(this, "AShooterPlayerController.AimMangetismCosestBone"); }

    long double& LastTimeFoundBetterClosestLocationField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTimeFoundBetterClosestLocation"); }

    TMap<int, FTrackedActorPlusInfoStruct, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FTrackedActorPlusInfoStruct, 0> >& AllCreaturesWhosInfoIsBeingSentToClientFromServerField() { return *GetNativePointerField<TMap<int, FTrackedActorPlusInfoStruct, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FTrackedActorPlusInfoStruct, 0> >*>(this, "AShooterPlayerController.AllCreaturesWhosInfoIsBeingSentToClientFromServer"); }

    TMap<int, FTrackedActorPlusInfoStruct, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FTrackedActorPlusInfoStruct, 0> >& AllPlayersWhosInfoIsBeingSentToClientFromServer_NotTeammatesField() { return *GetNativePointerField<TMap<int, FTrackedActorPlusInfoStruct, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FTrackedActorPlusInfoStruct, 0> >*>(this, "AShooterPlayerController.AllPlayersWhosInfoIsBeingSentToClientFromServer_NotTeammates"); }

    TMap<int, FTrackedActorPlusInfoStruct, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FTrackedActorPlusInfoStruct, 0> >& AllPlayersWhosInfoIsBeingSentToClientFromServer_TeammatesField() { return *GetNativePointerField<TMap<int, FTrackedActorPlusInfoStruct, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, FTrackedActorPlusInfoStruct, 0> >*>(this, "AShooterPlayerController.AllPlayersWhosInfoIsBeingSentToClientFromServer_Teammates"); }

    TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >& TrackedActorIDs_TotalForFilter_OrderedField() { return *GetNativePointerField<TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.TrackedActorIDs_TotalForFilter_Ordered"); }

    TMap<int, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, int, 0> >& TrackedActorIDs_OrderMap_PlayersField() { return *GetNativePointerField<TMap<int, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, int, 0> >*>(this, "AShooterPlayerController.TrackedActorIDs_OrderMap_Players"); }

    TMap<int, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, int, 0> >& TrackedActorIDs_OrderMap_CreaturesField() { return *GetNativePointerField<TMap<int, int, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, int, 0> >*>(this, "AShooterPlayerController.TrackedActorIDs_OrderMap_Creatures"); }

    TMap<int, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, bool, 0> >& CreaturesAlreadyHandledByTamingAutoAddField() { return *GetNativePointerField<TMap<int, bool, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, bool, 0> >*>(this, "AShooterPlayerController.CreaturesAlreadyHandledByTamingAutoAdd"); }

    long double& CachedTeamTameListUpdateIntervalField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.CachedTeamTameListUpdateInterval"); }

    int& CustomActorTracking_MaxAllowedFavoritedActorsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CustomActorTracking_MaxAllowedFavoritedActors"); }

    int& CustomActorTracking_MaxAllowedWaypointTrackedActorsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CustomActorTracking_MaxAllowedWaypointTrackedActors"); }

    float& ServerRequestCustomTrackedActorListInterval_WithoutUIField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorListInterval_WithoutUI"); }

    float& ServerRequestCustomTrackedActorListInterval_WithUIField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorListInterval_WithUI"); }

    int& ClientTimerCachedTameSelectionTypeField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ClientTimerCachedTameSelectionType"); }

    int& ClientTimerCachedDinoGroupField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ClientTimerCachedDinoGroup"); }

    FString& ClientTimerCachedCustomTameSearchTextField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.ClientTimerCachedCustomTameSearchText"); }

    int& ClientTimerCachedNewScrollbarIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ClientTimerCachedNewScrollbarIndex"); }

    float& TrackActorPOILocationLerpRateWhenNotInClientRangeField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.TrackActorPOILocationLerpRateWhenNotInClientRange"); }

    float& ActorTrackingPOIAlphaOnScreenField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ActorTrackingPOIAlphaOnScreen"); }

    float& ActorTrackingPOIScaleOnScreenField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ActorTrackingPOIScaleOnScreen"); }

    float& ActorTrackingPOIAlphaOffScreenField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ActorTrackingPOIAlphaOffScreen"); }

    float& ActorTrackingPOIScaleOffScreenField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ActorTrackingPOIScaleOffScreen"); }

    float& DesiredDistanceForActorTrackingPOILoweredTransparencyField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DesiredDistanceForActorTrackingPOILoweredTransparency"); }

    UE::Math::TVector2<double>& ActorTrackingPOIDistanceToScreenCenterForTransparencyField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "AShooterPlayerController.ActorTrackingPOIDistanceToScreenCenterForTransparency"); }

    UE::Math::TVector2<double>& POIDistanceToScreenCenterDismissField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "AShooterPlayerController.POIDistanceToScreenCenterDismiss"); }

    long double& ServerRequestTamingInfoList_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerRequestTamingInfoList_LastRequestedTime"); }

    float& ServerRequestTamingInfoList_ServerRequestTamingInfoListField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestTamingInfoList_ServerRequestTamingInfoList"); }

    long double& ServerRequestRemoveDinoFromTamingListByID_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerRequestRemoveDinoFromTamingListByID_LastRequestedTime"); }

    float& ServerRequestRemoveDinoFromTamingListByID_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestRemoveDinoFromTamingListByID_ServerCallRestrictionInterval"); }

    long double& ServerRequestCustomTrackedActorList_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorList_LastRequestedTime"); }

    float& ServerRequestCustomTrackedActorList_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorList_ServerCallRestrictionInterval"); }

    long double& ServerRequestUpdateTrackedWaypointsOnly_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsOnly_LastRequestedTime"); }

    float& ServerRequestUpdateTrackedWaypointsOnly_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsOnly_ServerCallRestrictionInterval"); }

    long double& ServerRequestUpdateTrackedWaypointsAndMapPlayers_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsAndMapPlayers_LastRequestedTime"); }

    float& ServerRequestUpdateTrackedWaypointsAndMapPlayers_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsAndMapPlayers_ServerCallRestrictionInterval"); }

    long double& ServerUntrackAllActors_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerUntrackAllActors_LastRequestedTime"); }

    float& ServerUntrackAllActors_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerUntrackAllActors_ServerCallRestrictionInterval"); }

    long double& ServerSetActiveWaypointTrackedPlayerViaCharacterIndex_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedPlayerViaCharacterIndex_LastRequestedTime"); }

    float& ServerSetActiveWaypointTrackedPlayerViaCharacterIndex_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedPlayerViaCharacterIndex_ServerCallRestrictionInterval"); }

    long double& ServerSetActiveWaypointTrackedCreatureViaCharacterIndex_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedCreatureViaCharacterIndex_LastRequestedTime"); }

    float& ServerSetActiveWaypointTrackedCreatureViaCharacterIndex_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedCreatureViaCharacterIndex_ServerCallRestrictionInterval"); }

    long double& ServerTogglePOIVisibilityForTrackedPlayerWaypoint_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedPlayerWaypoint_LastRequestedTime"); }

    float& ServerTogglePOIVisibilityForTrackedPlayerWaypoint_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedPlayerWaypoint_ServerCallRestrictionInterval"); }

    long double& ServerTogglePOIVisibilityForTrackedCreatureWaypoint_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedCreatureWaypoint_LastRequestedTime"); }

    float& ServerTogglePOIVisibilityForTrackedCreatureWaypoint_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedCreatureWaypoint_ServerCallRestrictionInterval"); }

    long double& ServerClearPOIVisibilityForAllActors_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerClearPOIVisibilityForAllActors_LastRequestedTime"); }

    float& ServerClearPOIVisibilityForAllActors_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerClearPOIVisibilityForAllActors_ServerCallRestrictionInterval"); }

    long double& ServerSetFavoriteTrackedPlayerViaCharacterIndex_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerSetFavoriteTrackedPlayerViaCharacterIndex_LastRequestedTime"); }

    float& ServerSetFavoriteTrackedPlayerViaCharacterIndex_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerSetFavoriteTrackedPlayerViaCharacterIndex_ServerCallRestrictionInterval"); }

    long double& ServerSetFavoriteTrackedCreatureViaCharacterIndex_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerSetFavoriteTrackedCreatureViaCharacterIndex_LastRequestedTime"); }

    float& ServerSetFavoriteTrackedCreatureViaCharacterIndex_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerSetFavoriteTrackedCreatureViaCharacterIndex_ServerCallRestrictionInterval"); }

    long double& TellServerAboutNewAutoTrackSetting_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.TellServerAboutNewAutoTrackSetting_LastRequestedTime"); }

    float& TellServerAboutNewAutoTrackSetting_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.TellServerAboutNewAutoTrackSetting_ServerCallRestrictionInterval"); }

    FTimerHandle& RestrictClientAutoMarkDeathWaypointAsReachedField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.RestrictClientAutoMarkDeathWaypointAsReached"); }

    float& DistanceNearDeathWaypointToClearPOIField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DistanceNearDeathWaypointToClearPOI"); }

    long double& ServerSetDeathWaypointVisible_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerSetDeathWaypointVisible_LastRequestedTime"); }

    float& ServerSetDeathWaypointVisible_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerSetDeathWaypointVisible_ServerCallRestrictionInterval"); }

    long double& ServerSetDeathWaypointInvisible_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerSetDeathWaypointInvisible_LastRequestedTime"); }

    float& ServerSetDeathWaypointInvisible_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerSetDeathWaypointInvisible_ServerCallRestrictionInterval"); }

    long double& Server_RequestLastDeathTrackingActorLoc_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.Server_RequestLastDeathTrackingActorLoc_LastRequestedTime"); }

    float& Server_RequestLastDeathTrackingActorLoc_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.Server_RequestLastDeathTrackingActorLoc_ServerCallRestrictionInterval"); }

    long double& ServerClearDeathWaypoint_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerClearDeathWaypoint_LastRequestedTime"); }

    float& ServerClearDeathWaypoint_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerClearDeathWaypoint_ServerCallRestrictionInterval"); }

    APostProcessVolume*& LastHighestPriorityPostProcessVolumeField() { return *GetNativePointerField<APostProcessVolume**>(this, "AShooterPlayerController.LastHighestPriorityPostProcessVolume"); }

    FPrimalPlayerDataStruct& MyPlayerDataStructField() { return *GetNativePointerField<FPrimalPlayerDataStruct*>(this, "AShooterPlayerController.MyPlayerDataStruct"); }

    //AVolumetricDispatcher*& MyVolumetricDispatcherField() { return *GetNativePointerField<AVolumetricDispatcher**>(this, "AShooterPlayerController.MyVolumetricDispatcher"); }

    FTimerHandle& ServerCheckIfWildDinoChildCanBeImprintedServersideHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.ServerCheckIfWildDinoChildCanBeImprintedServersideHandle"); }

    long double& ServerCheckIfWildDinoChildCanBeImprinted_LastRequestedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ServerCheckIfWildDinoChildCanBeImprinted_LastRequestedTime"); }

    float& ServerCheckIfWildDinoChildCanBeImprinted_ServerCallRestrictionIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ServerCheckIfWildDinoChildCanBeImprinted_ServerCallRestrictionInterval"); }

    //IVoiceChatUser*& VoiceChatUserField() { return *GetNativePointerField<IVoiceChatUser**>(this, "AShooterPlayerController.VoiceChatUser"); }

    FColor& ControllerLightColorNowField() { return *GetNativePointerField<FColor*>(this, "AShooterPlayerController.ControllerLightColorNow"); }

    UE::Math::TVector2<double>& GamepadAimMagnetismOffsetField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "AShooterPlayerController.GamepadAimMagnetismOffset"); }

    FTimerHandle& DisableStreamingSourceHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterPlayerController.DisableStreamingSourceHandle"); }

    FString& LastMessageOfTheDayStringField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.LastMessageOfTheDayString"); }

    TArray<TWeakObjectPtr<AActor>, TSizedDefaultAllocator<32> >& LastDeathTrackingActorsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<AActor>, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.LastDeathTrackingActors"); }

    long double& LastRequestDeathTrackingActorTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastRequestDeathTrackingActorTime"); }

    TMap<FString, FString, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, FString, 0> >& QueuedVoiceChannelsToJoinField() { return *GetNativePointerField<TMap<FString, FString, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FString, FString, 0> >*>(this, "AShooterPlayerController.QueuedVoiceChannelsToJoin"); }

    TMap<unsigned int, FString, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<unsigned int, FString, 0> >& playerIDToPlatformNameMapField() { return *GetNativePointerField<TMap<unsigned int, FString, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<unsigned int, FString, 0> >*>(this, "AShooterPlayerController.playerIDToPlatformNameMap"); }

    TSet<int, DefaultKeyFuncs<int, 0>, FDefaultSetAllocator>& Server_BlockedUserIdsField() { return *GetNativePointerField<TSet<int, DefaultKeyFuncs<int, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerController.Server_BlockedUserIds"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bDidAutoRunCheats() { return { this, "AShooterPlayerController.bDidAutoRunCheats" }; }

    BitFieldValue<bool, unsigned __int32> bInfiniteAmmo() { return { this, "AShooterPlayerController.bInfiniteAmmo" }; }

    BitFieldValue<bool, unsigned __int32> bGodMode() { return { this, "AShooterPlayerController.bGodMode" }; }

    BitFieldValue<bool, unsigned __int32> bHideGun() { return { this, "AShooterPlayerController.bHideGun" }; }

    BitFieldValue<bool, unsigned __int32> bEnemyInvisible() { return { this, "AShooterPlayerController.bEnemyInvisible" }; }

    BitFieldValue<bool, unsigned __int32> bIsAdminPauseUIEnabled() { return { this, "AShooterPlayerController.bIsAdminPauseUIEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bCanEnableCheats() { return { this, "AShooterPlayerController.bCanEnableCheats" }; }

    BitFieldValue<bool, unsigned __int32> bUsePressed() { return { this, "AShooterPlayerController.bUsePressed" }; }

    BitFieldValue<bool, unsigned __int32> bSkipForcedUnpossess() { return { this, "AShooterPlayerController.bSkipForcedUnpossess" }; }

    BitFieldValue<bool, unsigned __int32> bForceCraftButtonHeld() { return { this, "AShooterPlayerController.bForceCraftButtonHeld" }; }

    BitFieldValue<bool, unsigned __int32> bShowExtendedInfoKey() { return { this, "AShooterPlayerController.bShowExtendedInfoKey" }; }

    BitFieldValue<bool, unsigned __int32> bExtendedInfoKeyHeldFromInputAction() { return { this, "AShooterPlayerController.bExtendedInfoKeyHeldFromInputAction" }; }

    BitFieldValue<bool, unsigned __int32> bPreventControllerAutoUnfreeze() { return { this, "AShooterPlayerController.bPreventControllerAutoUnfreeze" }; }

    BitFieldValue<bool, unsigned __int32> bShouldAutoUploadTribeFlag() { return { this, "AShooterPlayerController.bShouldAutoUploadTribeFlag" }; }

    BitFieldValue<bool, unsigned __int32> bGamepadHotbarModifierPressed() { return { this, "AShooterPlayerController.bGamepadHotbarModifierPressed" }; }

    BitFieldValue<bool, unsigned __int32> bUpdatedAimMagnetismOffset() { return { this, "AShooterPlayerController.bUpdatedAimMagnetismOffset" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPServerCycleSpectator() { return { this, "AShooterPlayerController.bUseBPServerCycleSpectator" }; }

    BitFieldValue<bool, unsigned __int32> bIsFirstSpawn() { return { this, "AShooterPlayerController.bIsFirstSpawn" }; }

    BitFieldValue<bool, unsigned __int32> bIsRespawning() { return { this, "AShooterPlayerController.bIsRespawning" }; }

    BitFieldValue<bool, unsigned __int32> bIsVRPlayer() { return { this, "AShooterPlayerController.bIsVRPlayer" }; }

    BitFieldValue<bool, unsigned __int32> bBattlEyePlayerHasGottenInGameFully() { return { this, "AShooterPlayerController.bBattlEyePlayerHasGottenInGameFully" }; }

    BitFieldValue<bool, unsigned __int32> bAdminShowAllPlayers() { return { this, "AShooterPlayerController.bAdminShowAllPlayers" }; }

    BitFieldValue<bool, unsigned __int32> bNotifyPawnBuffsOfDamageEvents() { return { this, "AShooterPlayerController.bNotifyPawnBuffsOfDamageEvents" }; }

    BitFieldValue<bool, unsigned __int32> bInstantHarvest() { return { this, "AShooterPlayerController.bInstantHarvest" }; }

    BitFieldValue<bool, unsigned __int32> bForceAdminMeshChecking() { return { this, "AShooterPlayerController.bForceAdminMeshChecking" }; }

    BitFieldValue<bool, unsigned __int32> bForceAdminMeshCheckingOnShooterCharacters() { return { this, "AShooterPlayerController.bForceAdminMeshCheckingOnShooterCharacters" }; }

    BitFieldValue<bool, unsigned __int32> bWantsToPing() { return { this, "AShooterPlayerController.bWantsToPing" }; }

    BitFieldValue<bool, unsigned __int32> bEnablePingSystem() { return { this, "AShooterPlayerController.bEnablePingSystem" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreNextToggleInGameMenu() { return { this, "AShooterPlayerController.bIgnoreNextToggleInGameMenu" }; }

    BitFieldValue<bool, unsigned __int32> Gen1FixENCountRecord() { return { this, "AShooterPlayerController.Gen1FixENCountRecord" }; }

    BitFieldValue<bool, unsigned __int32> bWasGamepadHotbarModifierPressed_RightShoulder() { return { this, "AShooterPlayerController.bWasGamepadHotbarModifierPressed_RightShoulder" }; }

    BitFieldValue<bool, unsigned __int32> bUseIntercepted() { return { this, "AShooterPlayerController.bUseIntercepted" }; }

    BitFieldValue<bool, unsigned __int32> DebugPingLifetime() { return { this, "AShooterPlayerController.DebugPingLifetime" }; }

    BitFieldValue<bool, unsigned __int32> bEnablingSpectator() { return { this, "AShooterPlayerController.bEnablingSpectator" }; }


    // Functions


    //void ClientPlayForceFeedback(UForceFeedbackEffect* ForceFeedbackEffect, FForceFeedbackParameters* Params, float intensityMult) { NativeCall<void, UForceFeedbackEffect*, FForceFeedbackParameters*, float>(this, "AShooterPlayerController.ClientPlayForceFeedback(UForceFeedbackEffect*,FForceFeedbackParameters,float)", ForceFeedbackEffect, Params, intensityMult); }

    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AShooterPlayerController.GetPrivateStaticClass()"); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AShooterPlayerController.StaticClass()"); }

    bool AllowedToSpectateAllTeams() { return NativeCall<bool>(this, "AShooterPlayerController.AllowedToSpectateAllTeams()"); }

    void BPGetExtraWaypointsSOTF(APlayerController* Controller, AShooterCharacter* PlayerPawn, const TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >* IndicatorsIn, TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >* IndicatorsOut) { NativeCall<void, APlayerController*, AShooterCharacter*, const TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >*, TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.BPGetExtraWaypointsSOTF(APlayerController*,AShooterCharacter*,TArray<FPointOfInterestData_ForCompanion,TSizedDefaultAllocator<32>>&,TArray<FPointOfInterestData_ForCompanion,TSizedDefaultAllocator<32>>&)", Controller, PlayerPawn, IndicatorsIn, IndicatorsOut); }

    bool BPPreventChangeCamera() { return NativeCall<bool>(this, "AShooterPlayerController.BPPreventChangeCamera()"); }

    bool BPPreventTurnInput(bool bIsSpectatorTurn) { return NativeCall<bool, bool>(this, "AShooterPlayerController.BPPreventTurnInput(bool)", bIsSpectatorTurn); }

    AActor* BPServerCycleSpectator(bool bNext) { return NativeCall<AActor*, bool>(this, "AShooterPlayerController.BPServerCycleSpectator(bool)", bNext); }

    void Client_AddTeamPing(const FTeamPingData* WithPingData) { NativeCall<void, const FTeamPingData*>(this, "AShooterPlayerController.Client_AddTeamPing(FTeamPingData)", WithPingData); }

    void Client_GetPlatformNameFromId(unsigned int Id, const FString* PlatformName) { NativeCall<void, unsigned int, const FString*>(this, "AShooterPlayerController.Client_GetPlatformNameFromId(unsignedint,FString&)", Id, PlatformName); }

    void Client_UpdateRallyPointData(bool DestroyRallyPoint, FTeamPingData* RallyPointData) { NativeCall<void, bool, FTeamPingData*>(this, "AShooterPlayerController.Client_UpdateRallyPointData(bool,FTeamPingData)", DestroyRallyPoint, RallyPointData); }

    void ClientAddActorItem(UPrimalInventoryComponent* forInventory, FItemNetInfo* itemInfo, bool bEquipItem, bool ShowHUDNotification) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo*, bool, bool>(this, "AShooterPlayerController.ClientAddActorItem(UPrimalInventoryComponent*,FItemNetInfo,bool,bool)", forInventory, itemInfo, bEquipItem, ShowHUDNotification); }

    //void ClientAddFloatingText(FVector_NetQuantize* AtLocation, const FString* FloatingTextString, FColor FloatingTextColor, float ScaleX, float ScaleY, float TextLifeSpan, UE::Math::TVector<double>* TextVelocity, float MinScale, float FadeInTime, float FadeOutTime) { NativeCall<void, FVector_NetQuantize*, const FString*, FColor, float, float, float, UE::Math::TVector<double>*, float, float, float>(this, "AShooterPlayerController.ClientAddFloatingText(FVector_NetQuantize,FString&,FColor,float,float,float,UE::Math::TVector<double>,float,float,float)", AtLocation, FloatingTextString, FloatingTextColor, ScaleX, ScaleY, TextLifeSpan, TextVelocity, MinScale, FadeInTime, FadeOutTime); }

    void ClientChatMessage(FPrimalChatMessage Chat) { NativeCall<void, FPrimalChatMessage>(this, "AShooterPlayerController.ClientChatMessage(FPrimalChatMessage)", Chat); }

    void ClientCollectedAchievementItem(TSubclassOf<UPrimalItem> ItemClass) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.ClientCollectedAchievementItem(TSubclassOf<UPrimalItem>)", ItemClass); }

    void ClientDisplayNotificationDialog(const FString* Message, const FString* Title, bool bIsError, bool OnOkGoToMainMenu, bool bAutoClose, bool bCanBeTop, bool bHideXBoxFooter) { NativeCall<void, const FString*, const FString*, bool, bool, bool, bool, bool>(this, "AShooterPlayerController.ClientDisplayNotificationDialog(FString&,FString&,bool,bool,bool,bool,bool)", Message, Title, bIsError, OnOkGoToMainMenu, bAutoClose, bCanBeTop, bHideXBoxFooter); }

    void ClientDoMultiUse(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ClientDoMultiUse(UObject*,int)", ForObject, useIndex); }

    void ClientDownloadDinoRequestFinished(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadDinoRequestFinished(bool)", Success); }

    void ClientDownloadPlayerCharacterRequestFinished(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadPlayerCharacterRequestFinished(bool)", Success); }

    //void ClientDrawBrushComponentInGame(UBrushComponent* BrushComponent, float Duration, bool bDrawSolidBox) { NativeCall<void, UBrushComponent*, float, bool>(this, "AShooterPlayerController.ClientDrawBrushComponentInGame(UBrushComponent*,float,bool)", BrushComponent, Duration, bDrawSolidBox); }

    void ClientFailedRemoveSaddle() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedRemoveSaddle()"); }

    void ClientFailedToAddItemFromArkInventory() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedToAddItemFromArkInventory()"); }

    void ClientFinishedReceivingActorItems(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientFinishedReceivingActorItems(UPrimalInventoryComponent*,bool)", forInventory, bEquippedItems); }

    void ClientHUDNotificationTypeParams(int MessageType, int MessageType1, int MessageParam2, UObject* ObjectParam1) { NativeCall<void, int, int, int, UObject*>(this, "AShooterPlayerController.ClientHUDNotificationTypeParams(int,int,int,UObject*)", MessageType, MessageType1, MessageParam2, ObjectParam1); }

    void ClientLoadArkItems(UPrimalInventoryComponent* forInventory, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >* itemInfos, bool bClear, bool bFinalBatch) { NativeCall<void, UPrimalInventoryComponent*, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >*, bool, bool>(this, "AShooterPlayerController.ClientLoadArkItems(UPrimalInventoryComponent*,TArray<FItemNetInfo,TSizedDefaultAllocator<32>>&,bool,bool)", forInventory, itemInfos, bClear, bFinalBatch); }

    void ClientNotifyAdmin() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyAdmin()"); }

    void ClientNotifyDinoKill(APrimalDinoCharacter* InstigatingPawn, APawn* VictimPawn) { NativeCall<void, APrimalDinoCharacter*, APawn*>(this, "AShooterPlayerController.ClientNotifyDinoKill(APrimalDinoCharacter*,APawn*)", InstigatingPawn, VictimPawn); }

    void ClientNotifyEditText(TSubclassOf<UObject> ForObjectClass, int ExtraID1, int ExtraID2, UObject* ForObject) { NativeCall<void, TSubclassOf<UObject>, int, int, UObject*>(this, "AShooterPlayerController.ClientNotifyEditText(TSubclassOf<UObject>,int,int,UObject*)", ForObjectClass, ExtraID1, ExtraID2, ForObject); }

    void ClientNotifyPaintFinished(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientNotifyPaintFinished(bool)", bSuccess); }

    void ClientNotifyPlayerDeathReason(const FString* ReasonString) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ClientNotifyPlayerDeathReason(FString&)", ReasonString); }

    void ClientNotifyPlayerKill(AActor* PlayerPawn, APawn* VictimPawn) { NativeCall<void, AActor*, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerKill(AActor*,APawn*)", PlayerPawn, VictimPawn); }

    void ClientNotifyShowProfileRequest(FUniqueNetIdRepl* ProfileId) { NativeCall<void, FUniqueNetIdRepl*>(this, "AShooterPlayerController.ClientNotifyShowProfileRequest(FUniqueNetIdRepl)", ProfileId); }

    void ClientNotifyTamedDino(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyTamedDino(TSubclassOf<APrimalDinoCharacter>)", DinoClass); }

    void ClientNotifyUnlockedEngram(TSubclassOf<UPrimalItem> ItemClass, bool bTekGram) { NativeCall<void, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerController.ClientNotifyUnlockedEngram(TSubclassOf<UPrimalItem>,bool)", ItemClass, bTekGram); }

    void ClientOnCurrentCharacterAndItemsUploaded(unsigned __int64 TransferringPlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ClientOnCurrentCharacterAndItemsUploaded(unsigned__int64)", TransferringPlayerDataId); }

    void ClientOnEndDownloadTransferredPlayerCharacter(bool Success, int FailureResponseCode, const FString* FailureResponseMessage) { NativeCall<void, bool, int, const FString*>(this, "AShooterPlayerController.ClientOnEndDownloadTransferredPlayerCharacter(bool,int,FString&)", Success, FailureResponseCode, FailureResponseMessage); }

    void ClientPlayerIsValidToDownload(bool bIsValid, const FArkTributePlayerData* PlayerData) { NativeCall<void, bool, const FArkTributePlayerData*>(this, "AShooterPlayerController.ClientPlayerIsValidToDownload(bool,FArkTributePlayerData)", bIsValid, PlayerData); }

    void ClientPlayLocalSound(USoundBase* aSound, bool bAttach) { NativeCall<void, USoundBase*, bool>(this, "AShooterPlayerController.ClientPlayLocalSound(USoundBase*,bool)", aSound, bAttach); }

    void ClientProcessItemNetExecCommandBP(UPrimalInventoryComponent* forInventory, FItemNetID ForItemID, bool bIsEquippedItem, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, FName, FBPNetExecParams*>(this, "AShooterPlayerController.ClientProcessItemNetExecCommandBP(UPrimalInventoryComponent*,FItemNetID,bool,FName,FBPNetExecParams)", forInventory, ForItemID, bIsEquippedItem, CommandName, ExecParams); }

    void ClientProcessItemNetExecCommandUnreliableBP(UPrimalInventoryComponent* forInventory, FItemNetID ForItemID, bool bIsEquippedItem, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, FName, FBPNetExecParams*>(this, "AShooterPlayerController.ClientProcessItemNetExecCommandUnreliableBP(UPrimalInventoryComponent*,FItemNetID,bool,FName,FBPNetExecParams)", forInventory, ForItemID, bIsEquippedItem, CommandName, ExecParams); }

    void ClientProgressAchievement(const FString* AchievementID, float Progress, bool savePlayerData) { NativeCall<void, const FString*, float, bool>(this, "AShooterPlayerController.ClientProgressAchievement(FString&,float,bool)", AchievementID, Progress, savePlayerData); }

    void ClientSendArkDataPayloadBegin(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType, const FString* DataClass, const FString* TagName, const FString* Name, const TArray<FString, TSizedDefaultAllocator<32> >* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type, const FString*, const FString*, const FString*, const TArray<FString, TSizedDefaultAllocator<32> >*, unsigned int, unsigned int>(this, "AShooterPlayerController.ClientSendArkDataPayloadBegin(FGuid,EPrimalARKTributeDataType::Type,FString&,FString&,FString&,TArray<FString,TSizedDefaultAllocator<32>>&,unsignedint,unsignedint)", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }

    void ClientServerChatDirectMessage(const FString* MessageText, FLinearColor MessageColor, bool bIsBold, const FString* SenderId) { NativeCall<void, const FString*, FLinearColor, bool, const FString*>(this, "AShooterPlayerController.ClientServerChatDirectMessage(FString&,FLinearColor,bool,FString&)", MessageText, MessageColor, bIsBold, SenderId); }

    void ClientServerNotification(const FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, int Priority) { NativeCall<void, const FString*, FLinearColor, float, float, UTexture2D*, USoundBase*, int>(this, "AShooterPlayerController.ClientServerNotification(FString&,FLinearColor,float,float,UTexture2D*,USoundBase*,int)", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, Priority); }

    void ClientServerNotificationSingle(const FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, int MessageTypeID) { NativeCall<void, const FString*, FLinearColor, float, float, UTexture2D*, USoundBase*, int>(this, "AShooterPlayerController.ClientServerNotificationSingle(FString&,FLinearColor,float,float,UTexture2D*,USoundBase*,int,int)", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, MessageTypeID); }

    void ClientSetArkTributeLimits(bool LimitItems, bool LimitDinos, bool LimitCharacters, int MaxItems, int MaxDinos, int MaxCharacters) { NativeCall<void, bool, bool, bool, int, int, int>(this, "AShooterPlayerController.ClientSetArkTributeLimits(bool,bool,bool,int,int,int)", LimitItems, LimitDinos, LimitCharacters, MaxItems, MaxDinos, MaxCharacters); }

    void ClientSetHUDAndInitUIScenes(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "AShooterPlayerController.ClientSetHUDAndInitUIScenes(TSubclassOf<AHUD>)", NewHUDClass); }

    void ClientShowCharacterCreationUI(bool bShowDownloadCharacter) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientShowCharacterCreationUI(bool)", bShowDownloadCharacter); }

    void ClientShowLeaderboard(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag, const TArray<FLeaderboardRow, TSizedDefaultAllocator<32> >* LeaderboardRows, bool bPlayerHasValidLatestScore, FLeaderboardRow* LatestPlayerScore) { NativeCall<void, TSubclassOf<ULeaderboard>, FName, const TArray<FLeaderboardRow, TSizedDefaultAllocator<32> >*, bool, FLeaderboardRow*>(this, "AShooterPlayerController.ClientShowLeaderboard(TSubclassOf<ULeaderboard>,FName,TArray<FLeaderboardRow,TSizedDefaultAllocator<32>>&,bool,FLeaderboardRow)", LeaderboardType, MissionTag, LeaderboardRows, bPlayerHasValidLatestScore, LatestPlayerScore); }

    void ClientShowPaintingUI(UObject* ObjectToPaint) { NativeCall<void, UObject*>(this, "AShooterPlayerController.ClientShowPaintingUI(UObject*)", ObjectToPaint); }

    void ClientUnlockAchievement(const FString* AchievementID, bool savePlayerData) { NativeCall<void, const FString*, bool>(this, "AShooterPlayerController.ClientUnlockAchievement(FString&,bool)", AchievementID, savePlayerData); }

    void ClientUnlockExplorerNote(int ExplorerNoteIndex, const bool forceShowExplorerNoteUI, bool savePlayerData) { NativeCall<void, int, const bool, bool>(this, "AShooterPlayerController.ClientUnlockExplorerNote(int,bool,bool)", ExplorerNoteIndex, forceShowExplorerNoteUI, savePlayerData); }

    void ClientUpdateInventoryCraftQueue(UPrimalInventoryComponent* forInventory, const TArray<FItemCraftQueueEntry, TSizedDefaultAllocator<32> >* CraftQueueEntries) { NativeCall<void, UPrimalInventoryComponent*, const TArray<FItemCraftQueueEntry, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientUpdateInventoryCraftQueue(UPrimalInventoryComponent*,TArray<FItemCraftQueueEntry,TSizedDefaultAllocator<32>>&)", forInventory, CraftQueueEntries); }

    void IncrementStat(EPrimalGDKStat::Type StatToIncrement) { NativeCall<void, EPrimalGDKStat::Type>(this, "AShooterPlayerController.IncrementStat(EPrimalGDKStat::Type)", StatToIncrement); }

    void MarkDinoListEntryWidgetFavoritePlayer(int ID) { NativeCall<void, int>(this, "AShooterPlayerController.MarkDinoListEntryWidgetFavoritePlayer(int)", ID); }

    void NotifyTribeWarStatus(const FString* EnemyTribeString, int StatusType) { NativeCall<void, const FString*, int>(this, "AShooterPlayerController.NotifyTribeWarStatus(FString&,int)", EnemyTribeString, StatusType); }

    FString* PlayerCommand(FString* result, const FString* TheCommand) { return NativeCall<FString*, FString*, const FString*>(this, "AShooterPlayerController.PlayerCommand(FString&)", result, TheCommand); }

    void Server_SendBlockListFromClient(const TArray<FString, TSizedDefaultAllocator<32> >* BlockedEOSUserIds) { NativeCall<void, const TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.Server_SendBlockListFromClient(TArray<FString,TSizedDefaultAllocator<32>>&)", BlockedEOSUserIds); }

    void ServerActorCloseRemoteInventory(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorCloseRemoteInventory(UPrimalInventoryComponent*)", inventoryComp); }

    void ServerActorViewRemoteInventory(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorViewRemoteInventory(UPrimalInventoryComponent*)", inventoryComp); }

    void ServerAddAchievementID(const FString* AchievementID, bool bIsOnSpawn) { NativeCall<void, const FString*, bool>(this, "AShooterPlayerController.ServerAddAchievementID(FString&,bool)", AchievementID, bIsOnSpawn); }

    void ServerAddItemToCustomFolder(UPrimalInventoryComponent* forInventory, const FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, const FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerAddItemToCustomFolder(UPrimalInventoryComponent*,FString&,int,FItemNetID)", forInventory, CFolderName, InventoryCompType, ItemId); }

    void ServerCheckIfWildDinoChildCanBeImprinted() { NativeCall<void>(this, "AShooterPlayerController.ServerCheckIfWildDinoChildCanBeImprinted()"); }

    void ServerCraftItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerCraftItem(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerCycleSpectator(bool bNext) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerCycleSpectator(bool)", bNext); }

    void ServerDPC() { NativeCall<void>(this, "AShooterPlayerController.ServerDPC()"); }

    void ServerDropFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerDropFromRemoteInventory(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerEquipPawnItem(FItemNetID itemID) { NativeCall<void, FItemNetID>(this, "AShooterPlayerController.ServerEquipPawnItem(FItemNetID)", itemID); }

    void ServerEquipToRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerEquipToRemoteInventory(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerMultiUse(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerMultiUse(UObject*,int)", ForObject, useIndex); }

    void ServerPaint(UStructurePaintingComponent* Structure, const TArray<FPaintItem, TSizedDefaultAllocator<32> >* Paints, bool bLastBatch, bool bFromLoadFile, bool ReplicateToClients) { NativeCall<void, UStructurePaintingComponent*, const TArray<FPaintItem, TSizedDefaultAllocator<32> >*, bool, bool, bool>(this, "AShooterPlayerController.ServerPaint(UStructurePaintingComponent*,TArray<FPaintItem,TSizedDefaultAllocator<32>>&,bool,bool,bool)", Structure, Paints, bLastBatch, bFromLoadFile, ReplicateToClients); }

    void ServerRemovePassenger() { NativeCall<void>(this, "AShooterPlayerController.ServerRemovePassenger()"); }

    void ServerRemovePawnItem(FItemNetID itemID, bool bSecondryAction) { NativeCall<void, FItemNetID, bool>(this, "AShooterPlayerController.ServerRemovePawnItem(FItemNetID,bool)", itemID, bSecondryAction); }

    void ServerRepairItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRepairItem(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestActorItems(UPrimalInventoryComponent* forInventory, bool bInventoryItems, bool bWithFirstSpawn) { NativeCall<void, UPrimalInventoryComponent*, bool, bool>(this, "AShooterPlayerController.ServerRequestActorItems(UPrimalInventoryComponent*,bool,bool)", forInventory, bInventoryItems, bWithFirstSpawn); }

    void ServerRequestContainerFuel(APrimalStructureItemContainer* Container) { NativeCall<void, APrimalStructureItemContainer*>(this, "AShooterPlayerController.ServerRequestContainerFuel(APrimalStructureItemContainer*)", Container); }

    void ServerRequestCustomTrackedActorList(int CustomTameSelectionType, int DinoGroup, const FString* CustomTameSearchText, int NewScrollbarIndex, bool ClientAutoTrackTamesSetting) { NativeCall<void, int, int, const FString*, int, bool>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorList(int,int,FString&,int,bool)", CustomTameSelectionType, DinoGroup, CustomTameSearchText, NewScrollbarIndex, ClientAutoTrackTamesSetting); }

    void ServerRequestDownloadDino(FARKTributeDino* DownloadedDino) { NativeCall<void, FARKTributeDino*>(this, "AShooterPlayerController.ServerRequestDownloadDino(FARKTributeDino)", DownloadedDino); }

    void ServerRequestDropAllItems(const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter, const bool OnlySkins, const bool AlsoSkins) { NativeCall<void, const FString*, const FString*, const bool, const bool>(this, "AShooterPlayerController.ServerRequestDropAllItems(FString&,FString&,bool,bool)", CurrentCustomFolderFilter, CurrentNameFilter, OnlySkins, AlsoSkins); }

    void ServerRequestInventorySwapItems(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventorySwapItems(UPrimalInventoryComponent*,FItemNetID,FItemNetID)", inventoryComp, itemID1, itemID2); }

    void ServerRequestInventoryUseItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventoryUseItem(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestInventoryUseItemWithActor(AActor* anActor, UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, int AdditionalData) { NativeCall<void, AActor*, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithActor(AActor*,UPrimalInventoryComponent*,FItemNetID,int)", anActor, inventoryComp, itemID1, AdditionalData); }

    void ServerRequestInventoryUseItemWithItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2, int AdditionalData) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithItem(UPrimalInventoryComponent*,FItemNetID,FItemNetID,int)", inventoryComp, itemID1, itemID2, AdditionalData); }

    void ServerRequestRemoveWeaponAccessoryOnly(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponAccessoryOnly(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestRemoveWeaponClipAmmo(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponClipAmmo(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestSetPin(UObject* forTarget, int PinValue, bool bIsSetting, int TheCustomIndex) { NativeCall<void, UObject*, int, bool, int>(this, "AShooterPlayerController.ServerRequestSetPin(UObject*,int,bool,int)", forTarget, PinValue, bIsSetting, TheCustomIndex); }

    void ServerRequestShowLeaderboards(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag) { NativeCall<void, TSubclassOf<ULeaderboard>, FName>(this, "AShooterPlayerController.ServerRequestShowLeaderboards(TSubclassOf<ULeaderboard>,FName)", LeaderboardType, MissionTag); }

    void ServerRequestTamingInfoList() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTamingInfoList()"); }

    void ServerRequestUpdateActiveMissionTags() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestUpdateActiveMissionTags()"); }

    void ServerRequestUpdateTrackedWaypointsAndMapPlayers(bool ClientAutoTrackTamesSetting) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsAndMapPlayers(bool)", ClientAutoTrackTamesSetting); }

    void ServerSendArkDataPayloadBegin(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType, const FString* DataClass, const FString* TagName, const FString* Name, const TArray<FString, TSizedDefaultAllocator<32> >* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type, const FString*, const FString*, const FString*, const TArray<FString, TSizedDefaultAllocator<32> >*, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerSendArkDataPayloadBegin(FGuid,EPrimalARKTributeDataType::Type,FString&,FString&,FString&,TArray<FString,TSizedDefaultAllocator<32>>&,unsignedint,unsignedint)", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }

    void ServerSendDirectMessage(const FString* PlayerSteamID, const FString* Message) { NativeCall<void, const FString*, const FString*>(this, "AShooterPlayerController.ServerSendDirectMessage(FString&,FString&)", PlayerSteamID, Message); }

    void ServerSetActiveWaypointTrackedCreatureViaCharacterIndex(int TrackedCreatureIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedCreatureViaCharacterIndex(int,bool)", TrackedCreatureIndex, ShouldMarkActive); }

    void ServerSetActiveWaypointTrackedPlayerViaCharacterIndex(int TrackedPlayerIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedPlayerViaCharacterIndex(int,bool)", TrackedPlayerIndex, ShouldMarkActive); }

    void ServerSetDeathWaypointInvisible(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerSetDeathWaypointInvisible(int)", DeathLocationIndex); }

    void ServerSetFavoriteTrackedCreatureViaCharacterIndex(int TrackedPlayerIndex, bool ShouldFavorite) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetFavoriteTrackedCreatureViaCharacterIndex(int,bool)", TrackedPlayerIndex, ShouldFavorite); }

    void ServerSetFavoriteTrackedPlayerViaCharacterIndex(int TrackedPlayerIndex, bool ShouldFavorite) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetFavoriteTrackedPlayerViaCharacterIndex(int,bool)", TrackedPlayerIndex, ShouldFavorite); }

    void ServerTogglePOIVisibilityForTrackedCreatureWaypoint(int TrackedCreatureIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedCreatureWaypoint(int,bool)", TrackedCreatureIndex, ShouldMarkActive); }

    void ServerTogglePOIVisibilityForTrackedPlayerWaypoint(int TrackedPlayerIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedPlayerWaypoint(int,bool)", TrackedPlayerIndex, ShouldMarkActive); }

    void ServerTransferAllFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter, const FString* CurrentDestinationFolder, bool bNoFolderView) { NativeCall<void, UPrimalInventoryComponent*, const FString*, const FString*, const FString*, bool>(this, "AShooterPlayerController.ServerTransferAllFromRemoteInventory(UPrimalInventoryComponent*,FString&,FString&,FString&,bool)", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView); }

    void ServerTransferAllToRemoteInventory(UPrimalInventoryComponent* inventoryComp, const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter, const FString* CurrentDestinationFolder, bool bNoFolderView, bool OnlySkins, bool AlsoSkins) { NativeCall<void, UPrimalInventoryComponent*, const FString*, const FString*, const FString*, bool, bool, bool>(this, "AShooterPlayerController.ServerTransferAllToRemoteInventory(UPrimalInventoryComponent*,FString&,FString&,FString&,bool,bool,bool)", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView, OnlySkins, AlsoSkins); }

    void ServerTransferFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity, int ToSlotIndex, bool bEquipItem) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int, int, bool>(this, "AShooterPlayerController.ServerTransferFromRemoteInventory(UPrimalInventoryComponent*,FItemNetID,int,int,bool)", inventoryComp, itemID, requestedQuantity, ToSlotIndex, bEquipItem); }

    void ServerTransferToRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bAlsoTryToEqup, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, int>(this, "AShooterPlayerController.ServerTransferToRemoteInventory(UPrimalInventoryComponent*,FItemNetID,bool,int)", inventoryComp, itemID, bAlsoTryToEqup, requestedQuantity); }

    void ServerUnlockPerMapExplorerNote(int ExplorerNoteIndex, bool bAvoidBuff, bool savePlayerData) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerController.ServerUnlockPerMapExplorerNote(int,bool,bool)", ExplorerNoteIndex, bAvoidBuff, savePlayerData); }

    void ServerUploadCurrentCharacterAndItems(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCurrentCharacterAndItems(UPrimalInventoryComponent*)", inventoryComp); }

    void SetupNewTrackBP() { NativeCall<void>(this, "AShooterPlayerController.SetupNewTrackBP()"); }

    static void StaticRegisterNativesAShooterPlayerController() { NativeCall<void>(nullptr, "AShooterPlayerController.StaticRegisterNativesAShooterPlayerController()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void ClientRemoveCustomActorTrackListEntries_FromTotalList_Creatures_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientRemoveCustomActorTrackListEntries_FromTotalList_Creatures_Implementation(TArray<int,TSizedDefaultAllocator<32>>&,bool)"); }

    void EnableCheats(const FString* Pass) { NativeCall<void, const FString*>(this, "AShooterPlayerController.EnableCheats(FString)", Pass); }

    void CheckCanEnableCheats_Implementation() { NativeCall<void>(this, "AShooterPlayerController.CheckCanEnableCheats_Implementation()"); }

    void ClientSetCanEnableCheats_Implementation(bool bIsPossible) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientSetCanEnableCheats_Implementation(bool)", bIsPossible); }

    void CheckCheatsPassword_Implementation(const FString* Pass) { NativeCall<void, const FString*>(this, "AShooterPlayerController.CheckCheatsPassword_Implementation(FString&)", Pass); }

    void CheckRequestSpectator_Implementation(const FString* InSpectatorPass) { NativeCall<void, const FString*>(this, "AShooterPlayerController.CheckRequestSpectator_Implementation(FString&)", InSpectatorPass); }

    void ServerStopSpectating_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerStopSpectating_Implementation()"); }

    TArray<FString, TSizedDefaultAllocator<32> >* GetCheatsCommands(TArray<FString, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<FString, TSizedDefaultAllocator<32> >*, TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.GetCheatsCommands()", result); }

    void SetupInputComponent() { NativeCall<void>(this, "AShooterPlayerController.SetupInputComponent()"); }

    void LevelView() { NativeCall<void>(this, "AShooterPlayerController.LevelView()"); }

    void SpectatorDetachOrbitCamera() { NativeCall<void>(this, "AShooterPlayerController.SpectatorDetachOrbitCamera()"); }

    void DelayedTeamSpectatorSetup() { NativeCall<void>(this, "AShooterPlayerController.DelayedTeamSpectatorSetup()"); }

    void ServerCycleSpectator_Implementation(bool bNext) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerCycleSpectator_Implementation(bool)", bNext); }

    void ServerSpectateToPlayerByID_Implementation(unsigned __int64 PlayerID) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerSpectateToPlayerByID_Implementation(unsigned__int64)", PlayerID); }

    void ClientTeleportSpectator_Implementation(UE::Math::TVector<double>* Location, unsigned __int64 PlayerID) { NativeCall<void, UE::Math::TVector<double>*, unsigned __int64>(this, "AShooterPlayerController.ClientTeleportSpectator_Implementation(UE::Math::TVector<double>,unsigned__int64)", Location, PlayerID); }

    void ForceCraftPressed() { NativeCall<void>(this, "AShooterPlayerController.ForceCraftPressed()"); }

    void ForceCraftReleased() { NativeCall<void>(this, "AShooterPlayerController.ForceCraftReleased()"); }

    void StartTalkingWrapper(bool a2) { NativeCall<void, bool>(this, "AShooterPlayerController.StartTalkingWrapper()", a2); }

    void StopTalkingWrapper() { NativeCall<void>(this, "AShooterPlayerController.StopTalkingWrapper()"); }

    void StartTalkingWrapperKeybind() { NativeCall<void>(this, "AShooterPlayerController.StartTalkingWrapperKeybind()"); }

    void StopTalkingWrapperKeybind() { NativeCall<void>(this, "AShooterPlayerController.StopTalkingWrapperKeybind()"); }

    void StartTrackingItem(UPrimalItem* ItemReference) { NativeCall<void, UPrimalItem*>(this, "AShooterPlayerController.StartTrackingItem(UPrimalItem*)", ItemReference); }

    void ToggleHUDHidden() { NativeCall<void>(this, "AShooterPlayerController.ToggleHUDHidden()"); }

    void OnUseItemSlotForStructure(int ItemSlotNumber) { NativeCall<void, int>(this, "AShooterPlayerController.OnUseItemSlotForStructure(int)", ItemSlotNumber); }

    void OnUsePress(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterPlayerController.OnUsePress(bool)", bFromGamepad); }

    bool UICanDragDropCharacter(AActor* hitAct) { return NativeCall<bool, AActor*>(this, "AShooterPlayerController.UICanDragDropCharacter(AActor*)", hitAct); }

    bool GetAllAimedHarvestActors(float MaxDistance, TArray<AActor*, TSizedDefaultAllocator<32> >* OutHarvestActors, TArray<UActorComponent*, TSizedDefaultAllocator<32> >* OutHarvestComponents, TArray<int, TSizedDefaultAllocator<32> >* OutHitBodyIndices) { return NativeCall<bool, float, TArray<AActor*, TSizedDefaultAllocator<32> >*, TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, TArray<int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.GetAllAimedHarvestActors(float,TArray<AActor*,TSizedDefaultAllocator<32>>&,TArray<UActorComponent*,TSizedDefaultAllocator<32>>&,TArray<int,TSizedDefaultAllocator<32>>&)", MaxDistance, OutHarvestActors, OutHarvestComponents, OutHitBodyIndices); }

    AActor* GetAimedUseActor_Internal(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation, bool bForceUpdateAimedActors) { return NativeCall<AActor*, UActorComponent**, int*, bool, bool>(this, "AShooterPlayerController.GetAimedUseActor_Internal(UActorComponent**,int*,bool,bool)", UseComponent, hitBodyIndex, bForceUseActorLocation, bForceUpdateAimedActors); }

    AActor* GetAimedUseActor(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation, bool bForceUpdateAimedActors) { return NativeCall<AActor*, UActorComponent**, int*, bool, bool>(this, "AShooterPlayerController.GetAimedUseActor(UActorComponent**,int*,bool,bool)", UseComponent, hitBodyIndex, bForceUseActorLocation, bForceUpdateAimedActors); }

    void OnUseRelease(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterPlayerController.OnUseRelease(bool)", bFromGamepad); }

    void ActivateMultiUseSelection(bool bIsFromUseRelease) { NativeCall<void, bool>(this, "AShooterPlayerController.ActivateMultiUseSelection(bool)", bIsFromUseRelease); }

    void CancelMultiUseSelection() { NativeCall<void>(this, "AShooterPlayerController.CancelMultiUseSelection()"); }

    void OnKeyboardUsePress() { NativeCall<void>(this, "AShooterPlayerController.OnKeyboardUsePress()"); }

    void OnKeyboardUseRelease() { NativeCall<void>(this, "AShooterPlayerController.OnKeyboardUseRelease()"); }

    void OnGamepadUsePress() { NativeCall<void>(this, "AShooterPlayerController.OnGamepadUsePress()"); }

    void OnGamepadUseRelease() { NativeCall<void>(this, "AShooterPlayerController.OnGamepadUseRelease()"); }

    void OnRepeatUseHeldTimer() { NativeCall<void>(this, "AShooterPlayerController.OnRepeatUseHeldTimer()"); }

    void OnUseHeldTimer() { NativeCall<void>(this, "AShooterPlayerController.OnUseHeldTimer()"); }

    void SetMultiUseWheelCategory(int Category, APrimalBuff* OptionalBuff, AActor* OverrideTargetActor) { NativeCall<void, int, APrimalBuff*, AActor*>(this, "AShooterPlayerController.SetMultiUseWheelCategory(int,APrimalBuff*,AActor*)", Category, OptionalBuff, OverrideTargetActor); }

    void RefreshLastWheelCategories(bool bClearLastWheels) { NativeCall<void, bool>(this, "AShooterPlayerController.RefreshLastWheelCategories(bool)", bClearLastWheels); }

    void TryBackWheelCategory() { NativeCall<void>(this, "AShooterPlayerController.TryBackWheelCategory()"); }

    void StartInventoryRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.StartInventoryRadialSelector()"); }

    void SwitchMinimalTooltip() { NativeCall<void>(this, "AShooterPlayerController.SwitchMinimalTooltip()"); }

    void ForceEndInventoryRadialSelector(bool a2) { NativeCall<void, bool>(this, "AShooterPlayerController.ForceEndInventoryRadialSelector()", a2); }

    void EndInventoryRadialSelector(bool bForceClose) { NativeCall<void, bool>(this, "AShooterPlayerController.EndInventoryRadialSelector(bool)", bForceClose); }

    void ToggleThirdPersonCamera() { NativeCall<void>(this, "AShooterPlayerController.ToggleThirdPersonCamera()"); }

    void StartPlayerActionRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.StartPlayerActionRadialSelector()"); }

    void EndPlayerActionRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.EndPlayerActionRadialSelector()"); }

    void OnEmoteKey2Press() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey2Press()"); }

    void OnEmoteKey1Release() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey1Release()"); }

    void SaveSpectatorPos(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.SaveSpectatorPos(int)", Index); }

    void LoadSpectatorPos(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.LoadSpectatorPos(int)", Index); }

    void OnEmoteKey2Release() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey2Release()"); }

    void StartEmoteSelection() { NativeCall<void>(this, "AShooterPlayerController.StartEmoteSelection()"); }

    void OnWhistlePress() { NativeCall<void>(this, "AShooterPlayerController.OnWhistlePress()"); }

    void StartWhistleSelection() { NativeCall<void>(this, "AShooterPlayerController.StartWhistleSelection()"); }

    void EndWhistleSelection(bool a2) { NativeCall<void, bool>(this, "AShooterPlayerController.EndWhistleSelection()", a2); }

    void EndWhistleSelectionInput(bool bFromRelease) { NativeCall<void, bool>(this, "AShooterPlayerController.EndWhistleSelectionInput(bool)", bFromRelease); }

    void EndEmoteSelection(bool bFromRelease) { NativeCall<void, bool>(this, "AShooterPlayerController.EndEmoteSelection(bool)", bFromRelease); }

    void TriggerPlayerAction(int ActionIndex) { NativeCall<void, int>(this, "AShooterPlayerController.TriggerPlayerAction(int)", ActionIndex); }

    void SetEmoteLastFilterName() { NativeCall<void>(this, "AShooterPlayerController.SetEmoteLastFilterName()"); }

    void UseFastInventory() { NativeCall<void>(this, "AShooterPlayerController.UseFastInventory()"); }

    void SwitchFastInventory(bool bNext) { NativeCall<void, bool>(this, "AShooterPlayerController.SwitchFastInventory(bool)", bNext); }

    void ShowMyInventory() { NativeCall<void>(this, "AShooterPlayerController.ShowMyInventory()"); }

    void ShowMyCraftables() { NativeCall<void>(this, "AShooterPlayerController.ShowMyCraftables()"); }

    void ShowTribeManager() { NativeCall<void>(this, "AShooterPlayerController.ShowTribeManager()"); }

    void ShowGlobalChat() { NativeCall<void>(this, "AShooterPlayerController.ShowGlobalChat()"); }

    void ShowChat() { NativeCall<void>(this, "AShooterPlayerController.ShowChat()"); }

    void HideChat() { NativeCall<void>(this, "AShooterPlayerController.HideChat()"); }

    void ShowTribeChat() { NativeCall<void>(this, "AShooterPlayerController.ShowTribeChat()"); }

    void ShowAllianceChat() { NativeCall<void>(this, "AShooterPlayerController.ShowAllianceChat()"); }

    void ShowLocalChat() { NativeCall<void>(this, "AShooterPlayerController.ShowLocalChat()"); }

    void SetChangingCameraMode(bool bSet) { NativeCall<void, bool>(this, "AShooterPlayerController.SetChangingCameraMode(bool)", bSet); }

    void SwitchChangeCameraMode() { NativeCall<void>(this, "AShooterPlayerController.SwitchChangeCameraMode()"); }

    void PressedChangeCameraMode() { NativeCall<void>(this, "AShooterPlayerController.PressedChangeCameraMode()"); }

    void ReleasedChangeCameraMode() { NativeCall<void>(this, "AShooterPlayerController.ReleasedChangeCameraMode()"); }

    void ShowTutorial(int TutorialIndex, bool bForceDisplay) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ShowTutorial(int,bool)", TutorialIndex, bForceDisplay); }

    void HideTutorial(int TutorialIndex) { NativeCall<void, int>(this, "AShooterPlayerController.HideTutorial(int)", TutorialIndex); }

    void ClearTutorials() { NativeCall<void>(this, "AShooterPlayerController.ClearTutorials()"); }

    void ToggleAutoChat() { NativeCall<void>(this, "AShooterPlayerController.ToggleAutoChat()"); }

    void ScrollChatDown() { NativeCall<void>(this, "AShooterPlayerController.ScrollChatDown()"); }

    void ScrollChatUp() { NativeCall<void>(this, "AShooterPlayerController.ScrollChatUp()"); }

    void ToggleMap() { NativeCall<void>(this, "AShooterPlayerController.ToggleMap()"); }

    void ToggleCornerMap() { NativeCall<void>(this, "AShooterPlayerController.ToggleCornerMap()"); }

    void OpenMapMarkers() { NativeCall<void>(this, "AShooterPlayerController.OpenMapMarkers()"); }

    void ShowAllPlayersListToFollow() { NativeCall<void>(this, "AShooterPlayerController.ShowAllPlayersListToFollow()"); }

    void ToggleShowAllPlayersWhenSpectatingLocal() { NativeCall<void>(this, "AShooterPlayerController.ToggleShowAllPlayersWhenSpectatingLocal()"); }

    void ToggleDinoNameTags() { NativeCall<void>(this, "AShooterPlayerController.ToggleDinoNameTags()"); }

    void ToggleShowAllPlayersWhenSpectating() { NativeCall<void>(this, "AShooterPlayerController.ToggleShowAllPlayersWhenSpectating()"); }

    void ToggleWeaponAccessory() { NativeCall<void>(this, "AShooterPlayerController.ToggleWeaponAccessory()"); }

    void BeginPlay() { NativeCall<void>(this, "AShooterPlayerController.BeginPlay()"); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "AShooterPlayerController.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    void ServerGetVersion_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerGetVersion_Implementation()"); }

    void ClientSendVersion_Implementation(const FString* Version) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ClientSendVersion_Implementation(FString&)", Version); }

    void ConditionalSaveProfile() { NativeCall<void>(this, "AShooterPlayerController.ConditionalSaveProfile()"); }

    bool ShouldShowExtendedHUDInfo() { return NativeCall<bool>(this, "AShooterPlayerController.ShouldShowExtendedHUDInfo()"); }

    void TickActor(float DeltaTime, ELevelTick TickType, FActorTickFunction* ThisTickFunction) { NativeCall<void, float, ELevelTick, FActorTickFunction*>(this, "AShooterPlayerController.TickActor(float,ELevelTick,FActorTickFunction&)", DeltaTime, TickType, ThisTickFunction); }

    void ProcessServerMessages() { NativeCall<void>(this, "AShooterPlayerController.ProcessServerMessages()"); }

    void ClientNotifyPaintFinished_Implementation(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientNotifyPaintFinished_Implementation(bool)", bSuccess); }

    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "AShooterPlayerController.IsValidUnStasisCaster()"); }

    void ServerSetSpectatorLocation_Implementation(UE::Math::TVector<double>* NewLoc, UE::Math::TRotator<double>* NewRot) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AShooterPlayerController.ServerSetSpectatorLocation_Implementation(UE::Math::TVector<double>,UE::Math::TRotator<double>)", NewLoc, NewRot); }

    static void TickStasisForCharacter(UWorld* theWorld, APrimalCharacter* ShooterCharacter, UE::Math::TVector<double>* ActorLocation) { NativeCall<void, UWorld*, APrimalCharacter*, UE::Math::TVector<double>*>(nullptr, "AShooterPlayerController.TickStasisForCharacter(UWorld*,APrimalCharacter*,UE::Math::TVector<double>)", theWorld, ShooterCharacter, ActorLocation); }

    void SetPlayer(UPlayer* InPlayer) { NativeCall<void, UPlayer*>(this, "AShooterPlayerController.SetPlayer(UPlayer*)", InPlayer); }

    void UnFreeze() { NativeCall<void>(this, "AShooterPlayerController.UnFreeze()"); }

    void ServerCheckUnfreeze_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerCheckUnfreeze_Implementation()"); }

    void DoServerCheckUnfreeze_Implementation() { NativeCall<void>(this, "AShooterPlayerController.DoServerCheckUnfreeze_Implementation()"); }

    void FailedToSpawnPawn() { NativeCall<void>(this, "AShooterPlayerController.FailedToSpawnPawn()"); }

    void EnableSpectator(const bool destroyPlayerCharacter) { NativeCall<void, const bool>(this, "AShooterPlayerController.EnableSpectator(bool)", destroyPlayerCharacter); }

    bool AddFloatingDamageText_Implementation(const UE::Math::TVector<double>* atLocation, const float DamageAmount, AActor* damagedActor, AActor* damageCauser, AShooterPlayerController* EventInstigator) { return NativeCall<bool, const UE::Math::TVector<double>*, const float, AActor*, AActor*, AShooterPlayerController*>(this, "AShooterPlayerController.AddFloatingDamageText_Implementation(UE::Math::TVector<double>&,float,AActor*,AActor*,AShooterPlayerController*)", atLocation, DamageAmount, damagedActor, damageCauser, EventInstigator); }

    void DisableSpectator() { NativeCall<void>(this, "AShooterPlayerController.DisableSpectator()"); }

    void OnDisableSpectator_Implementation() { NativeCall<void>(this, "AShooterPlayerController.OnDisableSpectator_Implementation()"); }

    void CheckforOrbiting() { NativeCall<void>(this, "AShooterPlayerController.CheckforOrbiting()"); }

    void MoveForward(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.MoveForward(float)", Val); }

    void MoveRight(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.MoveRight(float)", Val); }

    void TurnAtRate(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.TurnAtRate(float)", Val); }

    void LookUpAtRate(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.LookUpAtRate(float)", Val); }

    void SpectatorTurn(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.SpectatorTurn(float)", Val); }

    void TurnInput(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.TurnInput(float)", Val); }

    void LookInput(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.LookInput(float)", Val); }

    void OnStartFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartFire()"); }

    void OnStopFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopFire()"); }

    bool CanGather() { return NativeCall<bool>(this, "AShooterPlayerController.CanGather()"); }

    void ShowBattleGameModeHUD() { NativeCall<void>(this, "AShooterPlayerController.ShowBattleGameModeHUD()"); }

    void OnStartTargeting() { NativeCall<void>(this, "AShooterPlayerController.OnStartTargeting()"); }

    void OnStopTargeting() { NativeCall<void>(this, "AShooterPlayerController.OnStopTargeting()"); }

    void ServerRequestPlaceStructure_Implementation(int StructureIndex, UE::Math::TVector<double>* BuildLocation, UE::Math::TRotator<double>* BuildRotation, UE::Math::TRotator<double>* PlayerViewRotation, FItemNetID PlaceUsingItemID, FPlacementData* PlacementData, bool bIsCheat, bool bIsFlipped, int WithSnapPointCycle) { NativeCall<void, int, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, UE::Math::TRotator<double>*, FItemNetID, FPlacementData*, bool, bool, int>(this, "AShooterPlayerController.ServerRequestPlaceStructure_Implementation(int,UE::Math::TVector<double>,UE::Math::TRotator<double>,UE::Math::TRotator<double>,FItemNetID,FPlacementData,bool,bool,int)", StructureIndex, BuildLocation, BuildRotation, PlayerViewRotation, PlaceUsingItemID, PlacementData, bIsCheat, bIsFlipped, WithSnapPointCycle); }

    void ServerVerifyStructurePlacementItemData_Implementation(FItemNetID PlaceUsingItemID) { NativeCall<void, FItemNetID>(this, "AShooterPlayerController.ServerVerifyStructurePlacementItemData_Implementation(FItemNetID)", PlaceUsingItemID); }

    void SetGodMode(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetGodMode(bool)", bEnable); }

    void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning) { NativeCall<void, bool, bool, bool, bool, bool>(this, "AShooterPlayerController.SetCinematicMode(bool,bool,bool,bool,bool)", bInCinematicMode, bHidePlayer, bAffectsHUD, bAffectsMovement, bAffectsTurning); }

    void PawnLeavingGame() { NativeCall<void>(this, "AShooterPlayerController.PawnLeavingGame()"); }

    void InitInputSystem() { NativeCall<void>(this, "AShooterPlayerController.InitInputSystem()"); }

    void AddCheats(bool bForce) { NativeCall<void, bool>(this, "AShooterPlayerController.AddCheats(bool)", bForce); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void EnemyInVisible(bool Invisible) { NativeCall<void, bool>(this, "AShooterPlayerController.EnemyInVisible(bool)", Invisible); }

    void ServerRemovePassenger_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRemovePassenger_Implementation()"); }

    void ClientTeamMessage_Implementation(APlayerState* SenderPlayerState, const FString* S, FName Type, float MsgLifeTime) { NativeCall<void, APlayerState*, const FString*, FName, float>(this, "AShooterPlayerController.ClientTeamMessage_Implementation(APlayerState*,FString&,FName,float)", SenderPlayerState, S, Type, MsgLifeTime); }

    AShooterHUD* GetShooterHUD() { return NativeCall<AShooterHUD*>(this, "AShooterPlayerController.GetShooterHUD()"); }

    void DrawHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterPlayerController.DrawHUD(AShooterHUD*)", HUD); }

    FString* FormatTextWithKeyBindings(FString* result, FString* InText, bool bIgnoreMarkup, int iconOffset) { return NativeCall<FString*, FString*, FString*, bool, int>(this, "AShooterPlayerController.FormatTextWithKeyBindings(FString,bool,int)", result, InText, bIgnoreMarkup, iconOffset); }

    UShooterPersistentUser* GetPersistentUser() { return NativeCall<UShooterPersistentUser*>(this, "AShooterPlayerController.GetPersistentUser()"); }

    void SetControlRotation(const UE::Math::TRotator<double>* NewRotation) { NativeCall<void, const UE::Math::TRotator<double>*>(this, "AShooterPlayerController.SetControlRotation(UE::Math::TRotator<double>&)", NewRotation); }

    void AcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "AShooterPlayerController.AcknowledgePossession(APawn*)", P); }

    void LeaveMeAlone() { NativeCall<void>(this, "AShooterPlayerController.LeaveMeAlone()"); }

    void InfiniteStats() { NativeCall<void>(this, "AShooterPlayerController.InfiniteStats()"); }

    void SetInfiniteStats(const bool bInfinite) { NativeCall<void, const bool>(this, "AShooterPlayerController.SetInfiniteStats(bool)", bInfinite); }

    void Destroyed() { NativeCall<void>(this, "AShooterPlayerController.Destroyed()"); }

    void PostInitializeComponents() { NativeCall<void>(this, "AShooterPlayerController.PostInitializeComponents()"); }

    void ServerGetMessageOfTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerGetMessageOfTheDay_Implementation()"); }

    void ClientGetMessageOfTheDay_Implementation(const FString* Message) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ClientGetMessageOfTheDay_Implementation(FString&)", Message); }

    void ServerReadMessageOFTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerReadMessageOFTheDay_Implementation()"); }

    void ClientNotifyShowProfileRequest_Implementation(FUniqueNetIdRepl* ProfileId) { NativeCall<void, FUniqueNetIdRepl*>(this, "AShooterPlayerController.ClientNotifyShowProfileRequest_Implementation(FUniqueNetIdRepl)", ProfileId); }

    void ClientShooterWasKicked_Implementation(const FText* KickReason) { NativeCall<void, const FText*>(this, "AShooterPlayerController.ClientShooterWasKicked_Implementation(FText&)", KickReason); }

    void ClientStartReceivingActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientStartReceivingActorItems_Implementation(UPrimalInventoryComponent*,bool)", forInventory, bEquippedItems); }

    void ClientFinishedReceivingActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientFinishedReceivingActorItems_Implementation(UPrimalInventoryComponent*,bool)", forInventory, bEquippedItems); }

    void ClientAddActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo* itemInfo, bool bEquipItem, bool ShowHUDNotification) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo*, bool, bool>(this, "AShooterPlayerController.ClientAddActorItem_Implementation(UPrimalInventoryComponent*,FItemNetInfo,bool,bool)", forInventory, itemInfo, bEquipItem, ShowHUDNotification); }

    void ClientAddActorItemToFolder_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo* itemInfo, bool bEquipItem, bool ShowHUDNotification, const FString* ToFolder) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo*, bool, bool, const FString*>(this, "AShooterPlayerController.ClientAddActorItemToFolder_Implementation(UPrimalInventoryComponent*,FItemNetInfo,bool,bool,FString&)", forInventory, itemInfo, bEquipItem, ShowHUDNotification, ToFolder); }

    void ClientSendFolderData_Implementation(UPrimalInventoryComponent* forInventory, const TArray<FServerCustomFolder, TSizedDefaultAllocator<32> >* ServerCustomFolder) { NativeCall<void, UPrimalInventoryComponent*, const TArray<FServerCustomFolder, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientSendFolderData_Implementation(UPrimalInventoryComponent*,TArray<FServerCustomFolder,TSizedDefaultAllocator<32>>&)", forInventory, ServerCustomFolder); }

    void ClientAddItemToArk_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo* itemInfo, bool bFromLoad) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo*, bool>(this, "AShooterPlayerController.ClientAddItemToArk_Implementation(UPrimalInventoryComponent*,FItemNetInfo,bool)", forInventory, itemInfo, bFromLoad); }

    void ClientAddFolderToInventoryComponent_Implementation(UPrimalInventoryComponent* forInventory, const FString* NewCustomFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, const FString*, int>(this, "AShooterPlayerController.ClientAddFolderToInventoryComponent_Implementation(UPrimalInventoryComponent*,FString&,int)", forInventory, NewCustomFolderName, InventoryCompType); }

    void ClientLoadArkItems_Implementation(UPrimalInventoryComponent* forInventory, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >* itemInfos, bool bClear, bool bFinalBatch) { NativeCall<void, UPrimalInventoryComponent*, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >*, bool, bool>(this, "AShooterPlayerController.ClientLoadArkItems_Implementation(UPrimalInventoryComponent*,TArray<FItemNetInfo,TSizedDefaultAllocator<32>>&,bool,bool)", forInventory, itemInfos, bClear, bFinalBatch); }

    void ClientFinishedLoadArkItems_Implementation(UPrimalInventoryComponent* forInventory) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ClientFinishedLoadArkItems_Implementation(UPrimalInventoryComponent*)", forInventory); }

    void ClientInsertActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo* itemInfo, FItemNetID InsertAfterItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo*, FItemNetID>(this, "AShooterPlayerController.ClientInsertActorItem_Implementation(UPrimalInventoryComponent*,FItemNetInfo,FItemNetID)", forInventory, itemInfo, InsertAfterItemID); }

    void ClientRemoveActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, bool showHUDMessage) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ClientRemoveActorItem_Implementation(UPrimalInventoryComponent*,FItemNetID,bool)", forInventory, itemID, showHUDMessage); }

    void ClientSwapActorItems_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ClientSwapActorItems_Implementation(UPrimalInventoryComponent*,FItemNetID,FItemNetID)", forInventory, itemID1, itemID2); }

    void ClientUpdateInventoryCraftQueue_Implementation(UPrimalInventoryComponent* forInventory, const TArray<FItemCraftQueueEntry, TSizedDefaultAllocator<32> >* CraftQueueEntries) { NativeCall<void, UPrimalInventoryComponent*, const TArray<FItemCraftQueueEntry, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientUpdateInventoryCraftQueue_Implementation(UPrimalInventoryComponent*,TArray<FItemCraftQueueEntry,TSizedDefaultAllocator<32>>&)", forInventory, CraftQueueEntries); }

    void ServerRequestActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bInventoryItems, bool bWithFirstSpawn) { NativeCall<void, UPrimalInventoryComponent*, bool, bool>(this, "AShooterPlayerController.ServerRequestActorItems_Implementation(UPrimalInventoryComponent*,bool,bool)", forInventory, bInventoryItems, bWithFirstSpawn); }

    UPrimalInventoryComponent* GetPlayerInventory() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPlayerInventory()"); }

    void ServerRemovePawnItem_Implementation(FItemNetID itemID, bool bSecondryAction) { NativeCall<void, FItemNetID, bool>(this, "AShooterPlayerController.ServerRemovePawnItem_Implementation(FItemNetID,bool)", itemID, bSecondryAction); }

    void ServerEquipPawnItem_Implementation(FItemNetID itemID) { NativeCall<void, FItemNetID>(this, "AShooterPlayerController.ServerEquipPawnItem_Implementation(FItemNetID)", itemID); }

    void ServerDeleteCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, const FString* CFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, const FString*, int>(this, "AShooterPlayerController.ServerDeleteCustomFolder_Implementation(UPrimalInventoryComponent*,FString&,int)", forInventory, CFolderName, InventoryCompType); }

    void ServerAddItemToCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, const FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, const FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerAddItemToCustomFolder_Implementation(UPrimalInventoryComponent*,FString&,int,FItemNetID)", forInventory, CFolderName, InventoryCompType, ItemId); }

    void ServerDeleteItemFromCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, const FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, const FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerDeleteItemFromCustomFolder_Implementation(UPrimalInventoryComponent*,FString&,int,FItemNetID)", forInventory, CFolderName, InventoryCompType, ItemId); }

    void ServerCraftItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerCraftItem_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRepairItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRepairItem_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestInventorySwapItems_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventorySwapItems_Implementation(UPrimalInventoryComponent*,FItemNetID,FItemNetID)", inventoryComp, itemID1, itemID2); }

    void ServerRequestInventoryUseItemWithItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2, int AdditionalData) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithItem_Implementation(UPrimalInventoryComponent*,FItemNetID,FItemNetID,int)", inventoryComp, itemID1, itemID2, AdditionalData); }

    void ServerRequestInventoryUseItemRemoteWithItemLocal_Implementation(UPrimalInventoryComponent* localinv, UPrimalInventoryComponent* remoteinv, FItemNetID itemID1, FItemNetID itemID2, int AdditionalData) { NativeCall<void, UPrimalInventoryComponent*, UPrimalInventoryComponent*, FItemNetID, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemRemoteWithItemLocal_Implementation(UPrimalInventoryComponent*,UPrimalInventoryComponent*,FItemNetID,FItemNetID,int)", localinv, remoteinv, itemID1, itemID2, AdditionalData); }

    void ServerRequestInventoryUseItemWithActor_Implementation(AActor* anActor, UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, int AdditionalData) { NativeCall<void, AActor*, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithActor_Implementation(AActor*,UPrimalInventoryComponent*,FItemNetID,int)", anActor, inventoryComp, itemID1, AdditionalData); }

    void ServerRequestContainerFuel_Implementation(APrimalStructureItemContainer* Container) { NativeCall<void, APrimalStructureItemContainer*>(this, "AShooterPlayerController.ServerRequestContainerFuel_Implementation(APrimalStructureItemContainer*)", Container); }

    void ClientSetContainerFuel_Implementation(APrimalStructureItemContainer* Container, float FuelQuantity) { NativeCall<void, APrimalStructureItemContainer*, float>(this, "AShooterPlayerController.ClientSetContainerFuel_Implementation(APrimalStructureItemContainer*,float)", Container, FuelQuantity); }

    void ServerRequestInventoryUseItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventoryUseItem_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerActorViewRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorViewRemoteInventory_Implementation(UPrimalInventoryComponent*)", inventoryComp); }

    void ServerActorCloseRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorCloseRemoteInventory_Implementation(UPrimalInventoryComponent*)", inventoryComp); }

    void ServerDropFromRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerDropFromRemoteInventory_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerInventoryClearCraftQueue_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerInventoryClearCraftQueue_Implementation(UPrimalInventoryComponent*)", inventoryComp); }

    void ServerRequestRemoveItemSkin_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkin_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestRemoveItemSkinOnly_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkinOnly_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestRemoveWeaponAccessoryOnly_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponAccessoryOnly_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerRequestRemoveWeaponClipAmmo_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponClipAmmo_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerEquipToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerEquipToRemoteInventory_Implementation(UPrimalInventoryComponent*,FItemNetID)", inventoryComp, itemID); }

    void ServerTransferFromRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity, int ToSlotIndex, bool bEquipItem) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int, int, bool>(this, "AShooterPlayerController.ServerTransferFromRemoteInventory_Implementation(UPrimalInventoryComponent*,FItemNetID,int,int,bool)", inventoryComp, itemID, requestedQuantity, ToSlotIndex, bEquipItem); }

    void ServerTransferAllFromRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter, const FString* CurrentDestinationFolder, bool bNoFolderView) { NativeCall<void, UPrimalInventoryComponent*, const FString*, const FString*, const FString*, bool>(this, "AShooterPlayerController.ServerTransferAllFromRemoteInventory_Implementation(UPrimalInventoryComponent*,FString&,FString&,FString&,bool)", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView); }

    bool CheckIsOnTransferAllCooldown(UPrimalInventoryComponent* inventoryComp) { return NativeCall<bool, UPrimalInventoryComponent*>(this, "AShooterPlayerController.CheckIsOnTransferAllCooldown(UPrimalInventoryComponent*)", inventoryComp); }

    void ServerTransferAllToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter, const FString* CurrentDestinationFolder, bool bNoFolderView, bool OnlySkins, bool AlsoSkins) { NativeCall<void, UPrimalInventoryComponent*, const FString*, const FString*, const FString*, bool, bool, bool>(this, "AShooterPlayerController.ServerTransferAllToRemoteInventory_Implementation(UPrimalInventoryComponent*,FString&,FString&,FString&,bool,bool,bool)", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView, OnlySkins, AlsoSkins); }

    void ServerTransferToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bAlsoTryToEqup, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, int>(this, "AShooterPlayerController.ServerTransferToRemoteInventory_Implementation(UPrimalInventoryComponent*,FItemNetID,bool,int)", inventoryComp, itemID, bAlsoTryToEqup, requestedQuantity); }

    void ServerGrindItemInRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool grindStack) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ServerGrindItemInRemoteInventory_Implementation(UPrimalInventoryComponent*,FItemNetID,bool)", inventoryComp, itemID, grindStack); }

    void ClientFailedToAddItemFromArkInventory_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedToAddItemFromArkInventory_Implementation()"); }

    void ServerAddItemFromArkInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerAddItemFromArkInventory_Implementation(UPrimalInventoryComponent*,FItemNetID,int)", inventoryComp, itemID, requestedQuantity); }

    void ServerTakeItemFromArkInventoryAfterRefresh() { NativeCall<void>(this, "AShooterPlayerController.ServerTakeItemFromArkInventoryAfterRefresh()"); }

    void ClientRemoveItemFromArk_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID RemovedItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientRemoveItemFromArk_Implementation(UPrimalInventoryComponent*,FItemNetID)", forInventory, RemovedItemID); }

    void UploadCharaterDataToArk(UPrimalInventoryComponent* InvComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.UploadCharaterDataToArk(UPrimalInventoryComponent*)", InvComp); }

    void ServerRequestCreateNewPlayerWithArkData(const TArray<unsigned char, TSizedDefaultAllocator<32> >* PlayerArkDataBytes, unsigned __int64 TribeID) { NativeCall<void, const TArray<unsigned char, TSizedDefaultAllocator<32> >*, unsigned __int64>(this, "AShooterPlayerController.ServerRequestCreateNewPlayerWithArkData(TArray<unsignedchar,TSizedDefaultAllocator<32>>&,unsigned__int64)", PlayerArkDataBytes, TribeID); }

    void ServerSetItemBalloonLocation_Implementation(APrimalStructureMovingContainer* ItemBalloon, FPrimalMapMarkerEntryData* MapMarker) { NativeCall<void, APrimalStructureMovingContainer*, FPrimalMapMarkerEntryData*>(this, "AShooterPlayerController.ServerSetItemBalloonLocation_Implementation(APrimalStructureMovingContainer*,FPrimalMapMarkerEntryData)", ItemBalloon, MapMarker); }

    void AddPlayerToClientTrackedActorPointersIfApplicable(AShooterCharacter* PlayerToAdd) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerController.AddPlayerToClientTrackedActorPointersIfApplicable(AShooterCharacter*)", PlayerToAdd); }

    void RemovePlayerFromClientTrackedActorPointers(AShooterCharacter* PlayerToRemove) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerController.RemovePlayerFromClientTrackedActorPointers(AShooterCharacter*)", PlayerToRemove); }

    void ServerUploadCurrentCharacterAndItems_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCurrentCharacterAndItems_Implementation(UPrimalInventoryComponent*)", inventoryComp); }

    void ClientOnCurrentCharacterAndItemsUploaded_Implementation(unsigned __int64 TransferringPlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ClientOnCurrentCharacterAndItemsUploaded_Implementation(unsigned__int64)", TransferringPlayerDataId); }

    void OnCurrentCharacterAndItemsUploaded(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.OnCurrentCharacterAndItemsUploaded(bool)", Success); }

    void ServerUploadCharaterDataToArk_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCharaterDataToArk_Implementation(UPrimalInventoryComponent*)", inventoryComp); }

    void ClientDataSetRPC_Implementation(const TArray<FDataSet, TSizedDefaultAllocator<32> >* dataSets) { NativeCall<void, const TArray<FDataSet, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientDataSetRPC_Implementation(TArray<FDataSet,TSizedDefaultAllocator<32>>&)", dataSets); }

    void ServerDataSetRPC_Implementation(const TArray<FDataSet, TSizedDefaultAllocator<32> >* dataSets) { NativeCall<void, const TArray<FDataSet, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ServerDataSetRPC_Implementation(TArray<FDataSet,TSizedDefaultAllocator<32>>&)", dataSets); }

    void UploadCharacterPlayerDataToArk(const TArray<unsigned char, TSizedDefaultAllocator<32> >* PlayerDataBytes, FString* PlayerName, TArray<FString, TSizedDefaultAllocator<32> >* PlayerStats, unsigned __int64 PlayerDataId, bool WithItems, unsigned int ItemCount) { NativeCall<void, const TArray<unsigned char, TSizedDefaultAllocator<32> >*, FString*, TArray<FString, TSizedDefaultAllocator<32> >*, unsigned __int64, bool, unsigned int>(this, "AShooterPlayerController.UploadCharacterPlayerDataToArk(TArray<unsignedchar,TSizedDefaultAllocator<32>>&,FString,TArray<FString,TSizedDefaultAllocator<32>>,unsigned__int64,bool,unsignedint)", PlayerDataBytes, PlayerName, PlayerStats, PlayerDataId, WithItems, ItemCount); }

    void ToggleHud() { NativeCall<void>(this, "AShooterPlayerController.ToggleHud()"); }

    bool IsHudVisible() { return NativeCall<bool>(this, "AShooterPlayerController.IsHudVisible()"); }

    void ToggleGun() { NativeCall<void>(this, "AShooterPlayerController.ToggleGun()"); }

    AShooterCharacter* GetPlayerCharacter() { return NativeCall<AShooterCharacter*>(this, "AShooterPlayerController.GetPlayerCharacter()"); }

    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.SetPawn(APawn*)", InPawn); }

    void SetDoingMeleeAimAssist() { NativeCall<void>(this, "AShooterPlayerController.SetDoingMeleeAimAssist()"); }

    void ToggleTrackingDinoOnMultiUse(APrimalDinoCharacter* Dino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ToggleTrackingDinoOnMultiUse(APrimalDinoCharacter*)", Dino); }

    void ToggleTrackingPlayerOnMultiUse(AShooterCharacter* PlayerRef) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerController.ToggleTrackingPlayerOnMultiUse(AShooterCharacter*)", PlayerRef); }

    void InputDismissPOI(APlayerController* ForPC, int Index) { NativeCall<void, APlayerController*, int>(this, "AShooterPlayerController.InputDismissPOI(APlayerController*,int)", ForPC, Index); }

    void TryInputCurrentDismiss() { NativeCall<void>(this, "AShooterPlayerController.TryInputCurrentDismiss()"); }

    __int64 CanDismissPOI(FPointOfInterestData* DataPOI) { return NativeCall<__int64, FPointOfInterestData*>(this, "AShooterPlayerController.CanDismissPOI(FPointOfInterestData)", DataPOI); }

    void ServerRepeatMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerRepeatMultiUse_Implementation(UObject*,int)", ForObject, useIndex); }

    void ServerMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerMultiUse_Implementation(UObject*,int)", ForObject, useIndex); }

    void ClientDoMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ClientDoMultiUse_Implementation(UObject*,int)", ForObject, useIndex); }

    void ClientUpdateItemQuantity_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int ItemQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemQuantity_Implementation(UPrimalInventoryComponent*,FItemNetID,int)", forInventory, itemID, ItemQuantity); }

    void ClientUpdateItemDurability_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, float ItemDurability) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, float>(this, "AShooterPlayerController.ClientUpdateItemDurability_Implementation(UPrimalInventoryComponent*,FItemNetID,float)", forInventory, itemID, ItemDurability); }

    void ClientUpdateItemCustomData_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, FCustomItemData* InData) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FCustomItemData*>(this, "AShooterPlayerController.ClientUpdateItemCustomData_Implementation(UPrimalInventoryComponent*,FItemNetID,FCustomItemData)", forInventory, itemID, InData); }

    void ClientUpdateItemWeaponClipAmmo_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int Ammo) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemWeaponClipAmmo_Implementation(UPrimalInventoryComponent*,FItemNetID,int)", forInventory, itemID, Ammo); }

    void ClientUsedActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientUsedActorItem_Implementation(UPrimalInventoryComponent*,FItemNetID)", forInventory, itemID); }

    void OnUnPossess() { NativeCall<void>(this, "AShooterPlayerController.OnUnPossess()"); }

    void DisableStreamingSource() { NativeCall<void>(this, "AShooterPlayerController.DisableStreamingSource()"); }

    void EnableStreamingSource() { NativeCall<void>(this, "AShooterPlayerController.EnableStreamingSource()"); }

    //bool GetStreamingSourcesInternal(TArray<FWorldPartitionStreamingSource, TSizedDefaultAllocator<32> >* OutStreamingSources) { return NativeCall<bool, TArray<FWorldPartitionStreamingSource, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.GetStreamingSourcesInternal(TArray<FWorldPartitionStreamingSource,TSizedDefaultAllocator<32>>&)", OutStreamingSources); }

    bool CanRestartPlayer() { return NativeCall<bool>(this, "AShooterPlayerController.CanRestartPlayer()"); }

    void OnPossess(APawn* inPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.OnPossess(APawn*)", inPawn); }

    void ScheduleTryLoadProfile() { NativeCall<void>(this, "AShooterPlayerController.ScheduleTryLoadProfile()"); }

    void TryLoadProfile() { NativeCall<void>(this, "AShooterPlayerController.TryLoadProfile()"); }

    void UpdateRotation(float DeltaTime) { NativeCall<void, float>(this, "AShooterPlayerController.UpdateRotation(float)", DeltaTime); }

    bool IsInputPressed(const FName InputName, const FName GamepadInputName) { return NativeCall<bool, const FName, const FName>(this, "AShooterPlayerController.IsInputPressed(FName,FName)", InputName, GamepadInputName); }

    bool IsAnyGampadFaceButtonPressed() { return NativeCall<bool>(this, "AShooterPlayerController.IsAnyGampadFaceButtonPressed()"); }

    bool CanDoPlayerCharacterInput(bool bIgnoreCurrentWeapon, bool bWeaponForcesMountedWeaponry) { return NativeCall<bool, bool, bool>(this, "AShooterPlayerController.CanDoPlayerCharacterInput(bool,bool)", bIgnoreCurrentWeapon, bWeaponForcesMountedWeaponry); }

    AActor* GetPlayerControllerViewerOverride() { return NativeCall<AActor*>(this, "AShooterPlayerController.GetPlayerControllerViewerOverride()"); }

    void ForceTame(bool bCheatTame, APrimalDinoCharacter* Dino) { NativeCall<void, bool, APrimalDinoCharacter*>(this, "AShooterPlayerController.ForceTame(bool,APrimalDinoCharacter*)", bCheatTame, Dino); }

    void SetImprintQuality(float ImprintingQuality) { NativeCall<void, float>(this, "AShooterPlayerController.SetImprintQuality(float)", ImprintingQuality); }

    APrimalDinoCharacter* SetTamingEffectivenessModifier(float TamingEffectiveness) { return NativeCall<APrimalDinoCharacter*, float>(this, "AShooterPlayerController.SetTamingEffectivenessModifier(float)", TamingEffectiveness); }

    void GiveToMe() { NativeCall<void>(this, "AShooterPlayerController.GiveToMe()"); }

    void GiveActorToMe(AActor* anAct, bool bNotifyNetwork) { NativeCall<void, AActor*, bool>(this, "AShooterPlayerController.GiveActorToMe(AActor*,bool)", anAct, bNotifyNetwork); }

    void ServerRequestLevelUp_Implementation(UPrimalCharacterStatusComponent* forStatusComp, EPrimalCharacterStatusValue::Type ValueType) { NativeCall<void, UPrimalCharacterStatusComponent*, EPrimalCharacterStatusValue::Type>(this, "AShooterPlayerController.ServerRequestLevelUp_Implementation(UPrimalCharacterStatusComponent*,EPrimalCharacterStatusValue::Type)", forStatusComp, ValueType); }

    void AddExperience(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "AShooterPlayerController.AddExperience(float,bool,bool)", HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void ServerRequestSetPin_Implementation(UObject* forTarget, int PinValue, bool bIsSetting, int TheCustomIndex) { NativeCall<void, UObject*, int, bool, int>(this, "AShooterPlayerController.ServerRequestSetPin_Implementation(UObject*,int,bool,int)", forTarget, PinValue, bIsSetting, TheCustomIndex); }

    void ClientNotifyTribeXP_Implementation(float HowMuch) { NativeCall<void, float>(this, "AShooterPlayerController.ClientNotifyTribeXP_Implementation(float)", HowMuch); }

    void ClientHUDNotificationTypeParams_Implementation(int MessageType, int MessageParam1, int MessageParam2, UObject* ObjectParam1) { NativeCall<void, int, int, int, UObject*>(this, "AShooterPlayerController.ClientHUDNotificationTypeParams_Implementation(int,int,int,UObject*)", MessageType, MessageParam1, MessageParam2, ObjectParam1); }

    void ServerRequestRespawnAtPoint_Implementation(int spawnPointID, int spawnRegionIndex) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestRespawnAtPoint_Implementation(int,int)", spawnPointID, spawnRegionIndex); }

    void ServerRequestFastTravelToPoint_Implementation(int fromSpawnPointID, int spawnPointID) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestFastTravelToPoint_Implementation(int,int)", fromSpawnPointID, spawnPointID); }

    char ServerDownloadDino(FARKTributeDino* DownloadedDino) { return NativeCall<char, FARKTributeDino*>(this, "AShooterPlayerController.ServerDownloadDino(FARKTributeDino)", DownloadedDino); }

    void SendDinoToServer(FARKTributeDino* DownloadedDino) { NativeCall<void, FARKTributeDino*>(this, "AShooterPlayerController.SendDinoToServer(FARKTributeDino)", DownloadedDino); }

    void ServerUploadDino_Implementation(APrimalDinoCharacter* DownloadedDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerUploadDino_Implementation(APrimalDinoCharacter*)", DownloadedDino); }

    void ServerRequestRemoteDropAllItems_Implementation(UPrimalInventoryComponent* inventoryComp, const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter) { NativeCall<void, UPrimalInventoryComponent*, const FString*, const FString*>(this, "AShooterPlayerController.ServerRequestRemoteDropAllItems_Implementation(UPrimalInventoryComponent*,FString&,FString&)", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter); }

    void ServerRequestDropAllItems_Implementation(const FString* CurrentCustomFolderFilter, const FString* CurrentNameFilter, bool OnlySkins, bool AlsoSkins) { NativeCall<void, const FString*, const FString*, bool, bool>(this, "AShooterPlayerController.ServerRequestDropAllItems_Implementation(FString&,FString&,bool,bool)", CurrentCustomFolderFilter, CurrentNameFilter, OnlySkins, AlsoSkins); }

    void ClientShowSpawnUI_Implementation(float Delay) { NativeCall<void, float>(this, "AShooterPlayerController.ClientShowSpawnUI_Implementation(float)", Delay); }

    void PlayRespawnSound() { NativeCall<void>(this, "AShooterPlayerController.PlayRespawnSound()"); }

    void ClientShowCharacterCreationUI_Implementation(bool bShowDownloadCharacter) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientShowCharacterCreationUI_Implementation(bool)", bShowDownloadCharacter); }

    AActor* SpawnActor(const FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, bool bDoDeferBeginPlay) { return NativeCall<AActor*, const FString*, float, float, float, bool>(this, "AShooterPlayerController.SpawnActor(FString&,float,float,float,bool)", blueprintPath, spawnDistance, spawnYOffset, ZOffset, bDoDeferBeginPlay); }

    bool GiveItem(TArray<UPrimalItem*, TSizedDefaultAllocator<32> >* outItems, const FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint, bool bAutoEquip, float MinRandomQuality) { return NativeCall<bool, TArray<UPrimalItem*, TSizedDefaultAllocator<32> >*, const FString*, int, float, bool, bool, float>(this, "AShooterPlayerController.GiveItem(TArray<UPrimalItem*,TSizedDefaultAllocator<32>>&,FString&,int,float,bool,bool,float)", outItems, blueprintPath, quantityOverride, qualityOverride, bForceBlueprint, bAutoEquip, MinRandomQuality); }

    bool GiveItem(const FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint, bool bAutoEquip, float MinRandomQuality) { return NativeCall<bool, const FString*, int, float, bool, bool, float>(this, "AShooterPlayerController.GiveItem(FString&,int,float,bool,bool,float)", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint, bAutoEquip, MinRandomQuality); }

    bool GiveFast(const FName* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint, float MinRandomQuality) { return NativeCall<bool, const FName*, int, float, bool, float>(this, "AShooterPlayerController.GiveFast(FName&,int,float,bool,float)", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint, MinRandomQuality); }

    bool GiveSlotItem(const FString* blueprintPath, int slotNum, int quantityOverride) { return NativeCall<bool, const FString*, int, int>(this, "AShooterPlayerController.GiveSlotItem(FString&,int,int)", blueprintPath, slotNum, quantityOverride); }

    bool GiveItemNum(int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { return NativeCall<bool, int, int, float, bool>(this, "AShooterPlayerController.GiveItemNum(int,int,float,bool)", masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }

    FString* GetUniqueNetIdAsString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerController.GetUniqueNetIdAsString()", result); }

    unsigned __int64 GetUniqueNetIdAsUINT64() { return NativeCall<unsigned __int64>(this, "AShooterPlayerController.GetUniqueNetIdAsUINT64()"); }

    void ClientOnAddedItemsToAllClustersInventory_Implementation(bool Success, const FString* UserId, const TArray<int, TSizedDefaultAllocator<32> >* MasterIndexNum) { NativeCall<void, bool, const FString*, const TArray<int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientOnAddedItemsToAllClustersInventory_Implementation(bool,FString&,TArray<int,TSizedDefaultAllocator<32>>&)", Success, UserId, MasterIndexNum); }

    void OnAddedItemsToAllClustersInventory(bool Success, const FString* UserId, const TArray<int, TSizedDefaultAllocator<32> >* MasterIndexNum) { NativeCall<void, bool, const FString*, const TArray<int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.OnAddedItemsToAllClustersInventory(bool,FString&,TArray<int,TSizedDefaultAllocator<32>>&)", Success, UserId, MasterIndexNum); }

    char AddItemToAllClustersInventory(FString* UserId, int MasterIndexNum) { return NativeCall<char, FString*, int>(this, "AShooterPlayerController.AddItemToAllClustersInventory(FString,int)", UserId, MasterIndexNum); }

    UPrimalInventoryComponent* GetPawnInventoryComponent() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPawnInventoryComponent()"); }

    UPrimalInventoryComponent* GetPlayerInventoryComponent() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPlayerInventoryComponent()"); }

    void BeginInactiveState() { NativeCall<void>(this, "AShooterPlayerController.BeginInactiveState()"); }

    void PawnPendingDestroy(APawn* inPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.PawnPendingDestroy(APawn*)", inPawn); }

    void BeginSpectatingState() { NativeCall<void>(this, "AShooterPlayerController.BeginSpectatingState()"); }

    void SetGraphicsQuality(int val) { NativeCall<void, int>(this, "AShooterPlayerController.SetGraphicsQuality(int)", val); }

    void GetPlayerViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AShooterPlayerController.GetPlayerViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    void GetPlayerViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation, bool ForAiming) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool>(this, "AShooterPlayerController.GetPlayerViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool)", out_Location, out_Rotation, ForAiming); }

    void GetPlayerViewPointNoModifiers(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation, bool ForAiming, bool bNoTPVAim) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, bool>(this, "AShooterPlayerController.GetPlayerViewPointNoModifiers(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool,bool)", out_Location, out_Rotation, ForAiming, bNoTPVAim); }

    void ClientNotifyEditText_Implementation(TSubclassOf<UObject> ForObjectClass, int ExtraID1, int ExtraID2, UObject* ForObject) { NativeCall<void, TSubclassOf<UObject>, int, int, UObject*>(this, "AShooterPlayerController.ClientNotifyEditText_Implementation(TSubclassOf<UObject>,int,int,UObject*)", ForObjectClass, ExtraID1, ExtraID2, ForObject); }

    void ServerNotifyEditText_Implementation(const FString* TextToUse, bool checkedBox, TSubclassOf<UObject> ForObjectClass, unsigned int ExtraID1, unsigned int ExtraID2, UObject* ForObject) { NativeCall<void, const FString*, bool, TSubclassOf<UObject>, unsigned int, unsigned int, UObject*>(this, "AShooterPlayerController.ServerNotifyEditText_Implementation(FString&,bool,TSubclassOf<UObject>,unsignedint,unsignedint,UObject*)", TextToUse, checkedBox, ForObjectClass, ExtraID1, ExtraID2, ForObject); }

    void ServerSendChatMessage_Implementation(const FString* ChatMessage, EChatSendMode::Type SendMode, int senderPlatform) { NativeCall<void, const FString*, EChatSendMode::Type, int>(this, "AShooterPlayerController.ServerSendChatMessage_Implementation(FString&,EChatSendMode::Type,int)", ChatMessage, SendMode, senderPlatform); }

    void LogChatMessage(const FPrimalChatMessage* Msg) { NativeCall<void, const FPrimalChatMessage*>(this, "AShooterPlayerController.LogChatMessage(FPrimalChatMessage&)", Msg); }

    void ClientChatMessage_Implementation(FPrimalChatMessage* Chat) { NativeCall<void, FPrimalChatMessage*>(this, "AShooterPlayerController.ClientChatMessage_Implementation(FPrimalChatMessage)", Chat); }

    void ClientServerChatMessage_Implementation(const FString* MessageText, FLinearColor* MessageColor, bool bIsBold) { NativeCall<void, const FString*, FLinearColor*, bool>(this, "AShooterPlayerController.ClientServerChatMessage_Implementation(FString&,FLinearColor,bool)", MessageText, MessageColor, bIsBold); }

    void ClientServerChatDirectMessage_Implementation(const FString* MessageText, FLinearColor* MessageColor, bool bIsBold, const FString* SenderId) { NativeCall<void, const FString*, FLinearColor*, bool, const FString*>(this, "AShooterPlayerController.ClientServerChatDirectMessage_Implementation(FString&,FLinearColor,bool,FString&)", MessageText, MessageColor, bIsBold, SenderId); }

    void ClientServerNotification_Implementation(const FString* MessageText, FLinearColor* MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, int Priority) { NativeCall<void, const FString*, FLinearColor*, float, float, UTexture2D*, USoundBase*, int>(this, "AShooterPlayerController.ClientServerNotification_Implementation(FString&,FLinearColor,float,float,UTexture2D*,USoundBase*,int)", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, Priority); }

    void ClientServerNotificationSingle_Implementation(const FString* MessageText, FLinearColor* MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, int MessageTypeID, int Priority) { NativeCall<void, const FString*, FLinearColor*, float, float, UTexture2D*, USoundBase*, int, int>(this, "AShooterPlayerController.ClientServerNotificationSingle_Implementation(FString&,FLinearColor,float,float,UTexture2D*,USoundBase*,int,int)", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, MessageTypeID, Priority); }

    void ClientServerSOTFNotification_Implementation(ESTOFNotificationType::Type NotificationType, const FString* MessageText, FLinearColor* MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, bool bLastPlayer, const FString* TribeName, const TArray<FString, TSizedDefaultAllocator<32> >* PlayerNames, const FString* DeathReason, const TArray<FPrimalPlayerCharacterConfigStructReplicated, TSizedDefaultAllocator<32> >* DeadPlayersData) { NativeCall<void, ESTOFNotificationType::Type, const FString*, FLinearColor*, float, float, UTexture2D*, USoundBase*, bool, const FString*, const TArray<FString, TSizedDefaultAllocator<32> >*, const FString*, const TArray<FPrimalPlayerCharacterConfigStructReplicated, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientServerSOTFNotification_Implementation(ESTOFNotificationType::Type,FString&,FLinearColor,float,float,UTexture2D*,USoundBase*,bool,FString&,TArray<FString,TSizedDefaultAllocator<32>>&,FString&,TArray<FPrimalPlayerCharacterConfigStructReplicated,TSizedDefaultAllocator<32>>&,int)", NotificationType, MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, bLastPlayer, TribeName, PlayerNames, DeathReason, DeadPlayersData); }

    void ClientServerSOTFNotificationCustom_Implementation(const FString* MessageText, FLinearColor* MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay) { NativeCall<void, const FString*, FLinearColor*, float, float, UTexture2D*, USoundBase*>(this, "AShooterPlayerController.ClientServerSOTFNotificationCustom_Implementation(FString&,FLinearColor,float,float,UTexture2D*,USoundBase*,int)", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay); }

    void ServerGetOriginalHairColor_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerGetOriginalHairColor_Implementation()"); }

    void ClientReceiveOriginalHairColor_Implementation(FLinearColor* HairColor) { NativeCall<void, FLinearColor*>(this, "AShooterPlayerController.ClientReceiveOriginalHairColor_Implementation(FLinearColor)", HairColor); }

    void OrganizeSOTFQueue(TEnumAsByte<ESTOFNotificationType::Type> NotificationType, TArray<FString, TSizedDefaultAllocator<32> >* PlayerNames, FString* DeathReason, FString* TribeName, TArray<FPrimalPlayerCharacterConfigStructReplicated, TSizedDefaultAllocator<32> >* DeadPlayersData, bool bLastPlayer, bool bForcePlay, float DisplayInterval, FString* CustomString) { NativeCall<void, TEnumAsByte<ESTOFNotificationType::Type>, TArray<FString, TSizedDefaultAllocator<32> >*, FString*, FString*, TArray<FPrimalPlayerCharacterConfigStructReplicated, TSizedDefaultAllocator<32> >*, bool, bool, float, FString*>(this, "AShooterPlayerController.OrganizeSOTFQueue(TEnumAsByte<ESTOFNotificationType::Type>,TArray<FString,TSizedDefaultAllocator<32>>,FString,FString,TArray<FPrimalPlayerCharacterConfigStructReplicated,TSizedDefaultAllocator<32>>,bool,bool,float,FString,int)", NotificationType, PlayerNames, DeathReason, TribeName, DeadPlayersData, bLastPlayer, bForcePlay, DisplayInterval, CustomString); }

    void TestNotification() { NativeCall<void>(this, "AShooterPlayerController.TestNotification()"); }

    void ClientReset_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientReset_Implementation()"); }

    void Reset() { NativeCall<void>(this, "AShooterPlayerController.Reset()"); }

    void DebugCheckSeven(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.DebugCheckSeven(bool)", bEnable); }

    void CopyCoordsToClipboard() { NativeCall<void>(this, "AShooterPlayerController.CopyCoordsToClipboard()"); }

    void GetAllMatinees() { NativeCall<void>(this, "AShooterPlayerController.GetAllMatinees()"); }

    void TestAlarmNotification(FString* Title, FString* Message) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.TestAlarmNotification(FString,FString)", Title, Message); }

    void SendAlarmNotification(FString* SteamID, FString* Title, FString* Message) { NativeCall<void, FString*, FString*, FString*>(this, "AShooterPlayerController.SendAlarmNotification(FString,FString,FString)", SteamID, Title, Message); }

    bool IsRidingDino() { return NativeCall<bool>(this, "AShooterPlayerController.IsRidingDino()"); }

    bool IsOnSeatingStructure() { return NativeCall<bool>(this, "AShooterPlayerController.IsOnSeatingStructure()"); }

    bool SendUseItemSlotToStructure() { return NativeCall<bool>(this, "AShooterPlayerController.SendUseItemSlotToStructure()"); }

    void SpectatorUseItem(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.SpectatorUseItem(int)", Index); }

    void ExportDinoData(APrimalDinoCharacter* DinoToExport) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ExportDinoData(APrimalDinoCharacter*)", DinoToExport); }

    void ServerReleaseSeatingStructure_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerReleaseSeatingStructure_Implementation()"); }

    void AdminCheat(const FString* Msg) { NativeCall<void, const FString*>(this, "AShooterPlayerController.AdminCheat(FString&)", Msg); }

    void RemoteServerCheat_Implementation(const FString* Msg) { NativeCall<void, const FString*>(this, "AShooterPlayerController.RemoteServerCheat_Implementation(FString&)", Msg); }

    void ServerGlobalCommand_Implementation(const FString* Msg) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerGlobalCommand_Implementation(FString&)", Msg); }

    void DoCrash() { NativeCall<void>(this, "AShooterPlayerController.DoCrash()"); }

    void OnExtendedInfoPress() { NativeCall<void>(this, "AShooterPlayerController.OnExtendedInfoPress()"); }

    void OnExtendedInfoRelease() { NativeCall<void>(this, "AShooterPlayerController.OnExtendedInfoRelease()"); }

    void ClientNotifyPlayerDeath_Implementation(APawn* InstigatingPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerDeath_Implementation(APawn*)", InstigatingPawn); }

    void ClientNotifyPlayerDeathReason_Implementation(const FString* ReasonString) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ClientNotifyPlayerDeathReason_Implementation(FString&)", ReasonString); }

    void ServerShowMessageOfTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerShowMessageOfTheDay_Implementation()"); }

    void ServerSetMessageOfTheDay_Implementation(const FString* Message) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerSetMessageOfTheDay_Implementation(FString&)", Message); }

    void ClientNotifyMessageOfTheDay_Implementation(const FString* Message, float TimeToDisplay) { NativeCall<void, const FString*, float>(this, "AShooterPlayerController.ClientNotifyMessageOfTheDay_Implementation(FString&,float)", Message, TimeToDisplay); }

    void ClientNotifyRemotePlayerDeath_Implementation(const FString* PlayerName, const FString* AttackerName) { NativeCall<void, const FString*, const FString*>(this, "AShooterPlayerController.ClientNotifyRemotePlayerDeath_Implementation(FString&,FString&)", PlayerName, AttackerName); }

    void ClientNotifyPlayerKill_Implementation(AActor* PlayerPawn, APawn* VictimPawn) { NativeCall<void, AActor*, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerKill_Implementation(AActor*,APawn*)", PlayerPawn, VictimPawn); }

    void ClientNotifyDinoKill_Implementation(APrimalDinoCharacter* InstigatingPawn, APawn* VictimPawn) { NativeCall<void, APrimalDinoCharacter*, APawn*>(this, "AShooterPlayerController.ClientNotifyDinoKill_Implementation(APrimalDinoCharacter*,APawn*)", InstigatingPawn, VictimPawn); }

    void ClientNotifyDinoDeath_Implementation(const FString* DinoName, const FString* AttackerName, bool bIsVehicle) { NativeCall<void, const FString*, const FString*, bool>(this, "AShooterPlayerController.ClientNotifyDinoDeath_Implementation(FString&,FString&,bool)", DinoName, AttackerName, bIsVehicle); }

    void ServerRequestDinoCharStats_Implementation(APrimalDinoCharacter* theDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoCharStats_Implementation(APrimalDinoCharacter*)", theDinoChar); }

    void ClientReceiveDinoCharStats_Implementation(APrimalDinoCharacter* theDinoChar, const TArray<float, TSizedDefaultAllocator<32> >* CurValues, const TArray<float, TSizedDefaultAllocator<32> >* MaxValues) { NativeCall<void, APrimalDinoCharacter*, const TArray<float, TSizedDefaultAllocator<32> >*, const TArray<float, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientReceiveDinoCharStats_Implementation(APrimalDinoCharacter*,TArray<float,TSizedDefaultAllocator<32>>&,TArray<float,TSizedDefaultAllocator<32>>&)", theDinoChar, CurValues, MaxValues); }

    void HandleRespawned_Implementation(APawn* NewPawn, bool IsFirstSpawn) { NativeCall<void, APawn*, bool>(this, "AShooterPlayerController.HandleRespawned_Implementation(APawn*,bool)", NewPawn, IsFirstSpawn); }

    void DisableEnemyInvisible() { NativeCall<void>(this, "AShooterPlayerController.DisableEnemyInvisible()"); }

    void ClientNotifyRespawned_Implementation(APawn* NewPawn, bool IsFirstSpawn) { NativeCall<void, APawn*, bool>(this, "AShooterPlayerController.ClientNotifyRespawned_Implementation(APawn*,bool)", NewPawn, IsFirstSpawn); }

    void ClientNotifyReconnected_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.ClientNotifyReconnected_Implementation(APawn*)", NewPawn); }

    void ClientResetRespawningFlag_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientResetRespawningFlag_Implementation()"); }

    void CheckForPlayerInventory() { NativeCall<void>(this, "AShooterPlayerController.CheckForPlayerInventory()"); }

    void ReportSpawnManagers() { NativeCall<void>(this, "AShooterPlayerController.ReportSpawnManagers()"); }

    void HibernationReport(const FString* ClassName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.HibernationReport(FString&)", ClassName); }

    void HiWarp(const FString* ClassName, int Index) { NativeCall<void, const FString*, int>(this, "AShooterPlayerController.HiWarp(FString&,int)", ClassName, Index); }

    void ReportLeastSpawnManagers() { NativeCall<void>(this, "AShooterPlayerController.ReportLeastSpawnManagers()"); }

    void FlushLevelStreaming() { NativeCall<void>(this, "AShooterPlayerController.FlushLevelStreaming()"); }

    void DoFlushLevelStreaming() { NativeCall<void>(this, "AShooterPlayerController.DoFlushLevelStreaming()"); }

    void FinalFlushLevelStreaming() { NativeCall<void>(this, "AShooterPlayerController.FinalFlushLevelStreaming()"); }

    void SetCameraCut() { NativeCall<void>(this, "AShooterPlayerController.SetCameraCut()"); }

    void InitHUD(bool bForceReinitUI) { NativeCall<void, bool>(this, "AShooterPlayerController.InitHUD(bool)", bForceReinitUI); }

    void ClientNotifyCantHarvest_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyCantHarvest_Implementation()"); }

    void ClientNotifyHitHarvest_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyHitHarvest_Implementation()"); }

    void ClientNotifyCantHitHarvest_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyCantHitHarvest_Implementation()"); }

    void ServerSetVRPlayer_Implementation(bool bSetVRPlayer) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetVRPlayer_Implementation(bool)", bSetVRPlayer); }

    void ClientNotifyTamedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyTamedDino_Implementation(TSubclassOf<APrimalDinoCharacter>)", DinoClass); }

    void ClientNotifySummonedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifySummonedDino_Implementation(TSubclassOf<APrimalDinoCharacter>)", DinoClass); }

    void ClientNotifyDefeatedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyDefeatedDino_Implementation(TSubclassOf<APrimalDinoCharacter>)", DinoClass); }

    void SetPlayerPos(float X, float Y, float Z) { NativeCall<void, float, float, float>(this, "AShooterPlayerController.SetPlayerPos(float,float,float)", X, Y, Z); }

    void SPI(float X, float Y, float Z, float Yaw, float Pitch) { NativeCall<void, float, float, float, float, float>(this, "AShooterPlayerController.SPI(float,float,float,float,float)", X, Y, Z, Yaw, Pitch); }

    void ClientSetSpectatorLocation_Implementation(UE::Math::TVector<double>* NewLocation) { NativeCall<void, UE::Math::TVector<double>*>(this, "AShooterPlayerController.ClientSetSpectatorLocation_Implementation(UE::Math::TVector<double>)", NewLocation); }

    void ClientSetControlRotation_Implementation(UE::Math::TRotator<double>* NewRotation) { NativeCall<void, UE::Math::TRotator<double>*>(this, "AShooterPlayerController.ClientSetControlRotation_Implementation(UE::Math::TRotator<double>)", NewRotation); }

    bool CanUseAimMagnetism() { return NativeCall<bool>(this, "AShooterPlayerController.CanUseAimMagnetism()"); }

    void SetupAimMagnetism() { NativeCall<void>(this, "AShooterPlayerController.SetupAimMagnetism()"); }

    bool HasRadio(bool allowVoice) { return NativeCall<bool, bool>(this, "AShooterPlayerController.HasRadio(bool)", allowVoice); }

    TArray<unsigned int, TSizedDefaultAllocator<32> >* GetRadioFrequencies(TArray<unsigned int, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<unsigned int, TSizedDefaultAllocator<32> >*, TArray<unsigned int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.GetRadioFrequencies()", result); }

    bool HasSameRadioFrequency(AShooterPlayerController* OtherPC, unsigned int* SharedFrequency) { return NativeCall<bool, AShooterPlayerController*, unsigned int*>(this, "AShooterPlayerController.HasSameRadioFrequency(AShooterPlayerController*,unsignedint&)", OtherPC, SharedFrequency); }

    void SetVoiceChatFilterType(int filterType) { NativeCall<void, int>(this, "AShooterPlayerController.SetVoiceChatFilterType(int)", filterType); }

    void ToggleSpeaking(bool bSpeaking) { NativeCall<void, bool>(this, "AShooterPlayerController.ToggleSpeaking(bool)", bSpeaking); }

    void ForceUnstasisAtLocation(UE::Math::TVector<double>* AtLocation) { NativeCall<void, UE::Math::TVector<double>*>(this, "AShooterPlayerController.ForceUnstasisAtLocation(UE::Math::TVector<double>)", AtLocation); }

    void SpawnActorSpread(const FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, const FString*, float, float, float, int, float>(this, "AShooterPlayerController.SpawnActorSpread(FString&,float,float,float,int,float)", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }

    void GetActorEyesViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AShooterPlayerController.GetActorEyesViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    void SpawnActorSpreadTamed(const FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, const FString*, float, float, float, int, float>(this, "AShooterPlayerController.SpawnActorSpreadTamed(FString&,float,float,float,int,float)", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }

    void GiveResources() { NativeCall<void>(this, "AShooterPlayerController.GiveResources()"); }

    void GiveEngrams(bool bForceAllEngrams, bool bTekEngramsOnly) { NativeCall<void, bool, bool>(this, "AShooterPlayerController.GiveEngrams(bool,bool)", bForceAllEngrams, bTekEngramsOnly); }

    void ForceTribes(const FString* PlayerName1, const FString* PlayerName2, const FString* NewTribeName) { NativeCall<void, const FString*, const FString*, const FString*>(this, "AShooterPlayerController.ForceTribes(FString&,FString&,FString&)", PlayerName1, PlayerName2, NewTribeName); }

    void ClientPlayLocalSound_Implementation(USoundBase* aSound, bool bAttach) { NativeCall<void, USoundBase*, bool>(this, "AShooterPlayerController.ClientPlayLocalSound_Implementation(USoundBase*,bool)", aSound, bAttach); }

    void ClientStopLocalSound_Implementation(USoundBase* aSound) { NativeCall<void, USoundBase*>(this, "AShooterPlayerController.ClientStopLocalSound_Implementation(USoundBase*)", aSound); }

    void ServerAddItemToArkInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerAddItemToArkInventory_Implementation(UPrimalInventoryComponent*,FItemNetID,int)", inventoryComp, itemID, requestedQuantity); }

    void OnArkTributeAllClustersInventoryItemsLoaded(const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >* Items, bool bAllowForcedItemDownload) { NativeCall<void, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.OnArkTributeAllClustersInventoryItemsLoaded(TArray<FItemNetInfo,TSizedDefaultAllocator<32>>&,bool)", Items, bAllowForcedItemDownload); }

    void OnArkTributeSaved(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.OnArkTributeSaved(bool)", Success); }

    void ClientSetArkTributeLimits_Implementation(bool LimitItems, bool LimitDinos, bool LimitCharacters, int MaxItems, int MaxDinos, int MaxCharacters) { NativeCall<void, bool, bool, bool, int, int, int>(this, "AShooterPlayerController.ClientSetArkTributeLimits_Implementation(bool,bool,bool,int,int,int)", LimitItems, LimitDinos, LimitCharacters, MaxItems, MaxDinos, MaxCharacters); }

    void ServerLoadArkInventoryItems_Implementation(const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >* ArkInventoryItemsInfo, bool bFinalBatch) { NativeCall<void, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerLoadArkInventoryItems_Implementation(TArray<FItemNetInfo,TSizedDefaultAllocator<32>>&,bool)", ArkInventoryItemsInfo, bFinalBatch); }

    void ServerAsyncLoadArkInventoryItems_Implementation(const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >* ArkInventoryItemsInfo, bool bFinalBatch) { NativeCall<void, const TArray<FItemNetInfo, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerAsyncLoadArkInventoryItems_Implementation(TArray<FItemNetInfo,TSizedDefaultAllocator<32>>&,bool)", ArkInventoryItemsInfo, bFinalBatch); }

    // TODO: Might need manual analysis

    void GetTamedDinosNearBy(TArray<TWeakObjectPtr<APrimalDinoCharacter>, TSizedDefaultAllocator<32> >* Dinos, float a3) { NativeCall<void, TArray<TWeakObjectPtr<APrimalDinoCharacter>, TSizedDefaultAllocator<32> >*, float>(this, "AShooterPlayerController.GetTamedDinosNearBy(TArray<TWeakObjectPtr<APrimalDinoCharacter>,TSizedDefaultAllocator<32>>&,float)", Dinos, a3); }

    void GetTamedDinosNearBy(TArray<APrimalDinoCharacter*, TSizedDefaultAllocator<32> >* Dinos, float RangeRadius, UE::Math::TVector<double>* NearLocation) { NativeCall<void, TArray<APrimalDinoCharacter*, TSizedDefaultAllocator<32> >*, float, UE::Math::TVector<double>*>(this, "AShooterPlayerController.GetTamedDinosNearBy(TArray<APrimalDinoCharacter*,TSizedDefaultAllocator<32>>&,float,UE::Math::TVector<double>)", Dinos, RangeRadius, NearLocation); }

    bool IsTamedDinoNearBy(APrimalDinoCharacter* Dino, float RangeRadius) { return NativeCall<bool, APrimalDinoCharacter*, float>(this, "AShooterPlayerController.IsTamedDinoNearBy(APrimalDinoCharacter*,float)", Dino, RangeRadius); }

    //void NewMinimapMark(FMinimapMark* NewMark) { NativeCall<void, FMinimapMark*>(this, "AShooterPlayerController.NewMinimapMark(FMinimapMark)", NewMark); }

    void RemoveMinimapMark(FName WithCustomTag, FName OnMap) { NativeCall<void, FName, FName>(this, "AShooterPlayerController.RemoveMinimapMark(FName,FName)", WithCustomTag, OnMap); }

    void UpdateTrackingWaypointMark(FName WithCustomTag) { NativeCall<void, FName>(this, "AShooterPlayerController.UpdateTrackingWaypointMark(FName)", WithCustomTag); }

    void ServerClearDeathWaypoint_Implementation(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerClearDeathWaypoint_Implementation(int)", DeathLocationIndex); }

    void ServerClearDeathWaypoint_ServerLogic(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerClearDeathWaypoint_ServerLogic(int)", DeathLocationIndex); }

    void ServerSetDeathWaypointVisible_Implementation(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerSetDeathWaypointVisible_Implementation(int)", DeathLocationIndex); }

    void ServerSetDeathWaypointVisible_ServerLogic(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerSetDeathWaypointVisible_ServerLogic(int)", DeathLocationIndex); }

    void ServerSetDeathWaypointInvisible_Implementation(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerSetDeathWaypointInvisible_Implementation(int)", DeathLocationIndex); }

    void ServerSetDeathWaypointInvisible_ServerLogic(int DeathLocationIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerSetDeathWaypointInvisible_ServerLogic(int)", DeathLocationIndex); }

    void TestSteamRefreshItems() { NativeCall<void>(this, "AShooterPlayerController.TestSteamRefreshItems()"); }

    void ServerSendArkDataPayloadBegin_Implementation(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType, const FString* DataClass, const FString* TagName, const FString* Name, const TArray<FString, TSizedDefaultAllocator<32> >* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type, const FString*, const FString*, const FString*, const TArray<FString, TSizedDefaultAllocator<32> >*, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerSendArkDataPayloadBegin_Implementation(FGuid,EPrimalARKTributeDataType::Type,FString&,FString&,FString&,TArray<FString,TSizedDefaultAllocator<32>>&,unsignedint,unsignedint)", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }

    void ServerSendArkDataPayload_Implementation(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType, const TArray<unsigned char, TSizedDefaultAllocator<32> >* DataBytes) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ServerSendArkDataPayload_Implementation(FGuid,EPrimalARKTributeDataType::Type,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", ID, ArkDataType, DataBytes); }

    void ServerSendArkDataPayloadEnd_Implementation(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type>(this, "AShooterPlayerController.ServerSendArkDataPayloadEnd_Implementation(FGuid,EPrimalARKTributeDataType::Type)", ID, ArkDataType); }

    void ClientSendArkDataPayloadBegin_Implementation(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType, const FString* DataClass, const FString* TagName, const FString* Name, const TArray<FString, TSizedDefaultAllocator<32> >* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type, const FString*, const FString*, const FString*, const TArray<FString, TSizedDefaultAllocator<32> >*, unsigned int, unsigned int>(this, "AShooterPlayerController.ClientSendArkDataPayloadBegin_Implementation(FGuid,EPrimalARKTributeDataType::Type,FString&,FString&,FString&,TArray<FString,TSizedDefaultAllocator<32>>&,unsignedint,unsignedint)", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }

    void ClientSendArkDataPayloadEnd_Implementation(FGuid* ID, EPrimalARKTributeDataType::Type ArkDataType, unsigned __int64 PlayerDataID) { NativeCall<void, FGuid*, EPrimalARKTributeDataType::Type, unsigned __int64>(this, "AShooterPlayerController.ClientSendArkDataPayloadEnd_Implementation(FGuid,EPrimalARKTributeDataType::Type,unsigned__int64)", ID, ArkDataType, PlayerDataID); }

    void RequestCreateNewPlayerWithArkDataPossibleItems(const FArkTributePlayerData* PlayerData, unsigned __int64 TribeID) { NativeCall<void, const FArkTributePlayerData*, unsigned __int64>(this, "AShooterPlayerController.RequestCreateNewPlayerWithArkDataPossibleItems(FArkTributePlayerData&,unsigned__int64)", PlayerData, TribeID); }

    void ServerCharacterUploadWithItems_Start_Implementation(unsigned __int64 PlayerDataId, FArkTributePlayerData* PlayerData) { NativeCall<void, unsigned __int64, FArkTributePlayerData*>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_Start_Implementation(unsigned__int64,FArkTributePlayerData)", PlayerDataId, PlayerData); }

    void ServerCharacterUploadWithItems_CharaterPayload_Implementation(unsigned __int64 PlayerDataId, const TArray<unsigned char, TSizedDefaultAllocator<32> >* PlayerDataChunk) { NativeCall<void, unsigned __int64, const TArray<unsigned char, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_CharaterPayload_Implementation(unsigned__int64,TArray<unsignedchar,TSizedDefaultAllocator<32>>&)", PlayerDataId, PlayerDataChunk); }

    void ServerCharacterUploadWithItems_UploadItem_Implementation(unsigned __int64 PlayerDataId, FItemNetInfo* InvItem) { NativeCall<void, unsigned __int64, FItemNetInfo*>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_UploadItem_Implementation(unsigned__int64,FItemNetInfo)", PlayerDataId, InvItem); }

    void ServerCharacterUploadWithItems_FinishAndCreateCharacter_Implementation(unsigned __int64 PlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_FinishAndCreateCharacter_Implementation(unsigned__int64)", PlayerDataId); }

    void ServerRequestCreateMissionDataBuff_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestCreateMissionDataBuff_Implementation()"); }

    AMissionType* GetActiveMission() { return NativeCall<AMissionType*>(this, "AShooterPlayerController.GetActiveMission()"); }

    TKeyValuePair<bool, FLeaderboardRow>* GetLatestScoreForMission(TKeyValuePair<bool, FLeaderboardRow>* result, FName MissionTag) { return NativeCall<TKeyValuePair<bool, FLeaderboardRow>*, TKeyValuePair<bool, FLeaderboardRow>*, FName>(this, "AShooterPlayerController.GetLatestScoreForMission(FName)", result, MissionTag); }

    void ServerRequestShowLeaderboards_Implementation(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag) { NativeCall<void, TSubclassOf<ULeaderboard>, FName>(this, "AShooterPlayerController.ServerRequestShowLeaderboards_Implementation(TSubclassOf<ULeaderboard>,FName)", LeaderboardType, MissionTag); }

    void ClientShowLeaderboard_Implementation(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag, const TArray<FLeaderboardRow, TSizedDefaultAllocator<32> >* LeaderboardRows, bool bPlayerHasValidLatestScore, FLeaderboardRow* LatestPlayerScore) { NativeCall<void, TSubclassOf<ULeaderboard>, FName, const TArray<FLeaderboardRow, TSizedDefaultAllocator<32> >*, bool, FLeaderboardRow*>(this, "AShooterPlayerController.ClientShowLeaderboard_Implementation(TSubclassOf<ULeaderboard>,FName,TArray<FLeaderboardRow,TSizedDefaultAllocator<32>>&,bool,FLeaderboardRow)", LeaderboardType, MissionTag, LeaderboardRows, bPlayerHasValidLatestScore, LatestPlayerScore); }

    void RequestCreateNewPlayerWithArkData(TArray<unsigned char, TSizedDefaultAllocator<32> >* PlayerArkDataBytes, unsigned __int64 TribeID) { NativeCall<void, TArray<unsigned char, TSizedDefaultAllocator<32> >*, unsigned __int64>(this, "AShooterPlayerController.RequestCreateNewPlayerWithArkData(TArray<unsignedchar,TSizedDefaultAllocator<32>>,unsigned__int64)", PlayerArkDataBytes, TribeID); }

    void SendArKPayload(bool bClient, FARKTributeData* ArKDataPayload) { NativeCall<void, bool, FARKTributeData*>(this, "AShooterPlayerController.SendArKPayload(bool,FARKTributeData)", bClient, ArKDataPayload); }

    void LoadLocalPlayerArkData() { NativeCall<void>(this, "AShooterPlayerController.LoadLocalPlayerArkData()"); }

    void AsyncLoadInventory() { NativeCall<void>(this, "AShooterPlayerController.AsyncLoadInventory()"); }

    int GetSubscribedAppIds() { return NativeCall<int>(this, "AShooterPlayerController.GetSubscribedAppIds()"); }

    void ServerLoadUploadedDinos_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerLoadUploadedDinos_Implementation()"); }

    //void ClientUploadedDinosLoaded_Implementation(const TArray<FARKTributeDinoListing, TSizedDefaultAllocator<32> >* UploadedDinosListings) { NativeCall<void, const TArray<FARKTributeDinoListing, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientUploadedDinosLoaded_Implementation(TArray<FARKTributeDinoListing,TSizedDefaultAllocator<32>>&)", UploadedDinosListings); }

    void ServerRequestDownloadDino_Implementation(FARKTributeDino* DownloadedDino) { NativeCall<void, FARKTributeDino*>(this, "AShooterPlayerController.ServerRequestDownloadDino_Implementation(FARKTributeDino)", DownloadedDino); }

    void ClientDownloadDinoRequestFinished_Implementation(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadDinoRequestFinished_Implementation(bool)", Success); }

    void OnLoadArkTributePlayersDataFinished(bool Success, const TArray<FArkTributePlayerData, TSizedDefaultAllocator<32> >* ArkUploadedCharsData, int FailureResponseCode) { NativeCall<void, bool, const TArray<FArkTributePlayerData, TSizedDefaultAllocator<32> >*, int>(this, "AShooterPlayerController.OnLoadArkTributePlayersDataFinished(bool,TArray<FArkTributePlayerData,TSizedDefaultAllocator<32>>&,int)", Success, ArkUploadedCharsData, FailureResponseCode); }

    void AttemptTransferRedownload() { NativeCall<void>(this, "AShooterPlayerController.AttemptTransferRedownload()"); }

    void ServerLoadUploadedCharacters_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerLoadUploadedCharacters_Implementation()"); }

    void ClientOnStartDownloadTransferredPlayerCharacter_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientOnStartDownloadTransferredPlayerCharacter_Implementation()"); }

    void ClientOnEndDownloadTransferredPlayerCharacter_Implementation(bool Success, int FailureResponseCode, const FString* FailureResponseMessage) { NativeCall<void, bool, int, const FString*>(this, "AShooterPlayerController.ClientOnEndDownloadTransferredPlayerCharacter_Implementation(bool,int,FString&)", Success, FailureResponseCode, FailureResponseMessage); }

    void DownloadTransferredPlayerCharacter() { NativeCall<void>(this, "AShooterPlayerController.DownloadTransferredPlayerCharacter()"); }

    //void ClientUploadedCharactersLoaded_Implementation(bool Success, const TArray<FArkTributePlayerDataListing, TSizedDefaultAllocator<32> >* UploadedDinosListings) { NativeCall<void, bool, const TArray<FArkTributePlayerDataListing, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientUploadedCharactersLoaded_Implementation(bool,TArray<FArkTributePlayerDataListing,TSizedDefaultAllocator<32>>&)", Success, UploadedDinosListings); }

    void ServerCheckIsValidPlayerToDownload_Implementation(const FArkTributePlayerData* PlayerData) { NativeCall<void, const FArkTributePlayerData*>(this, "AShooterPlayerController.ServerCheckIsValidPlayerToDownload_Implementation(FArkTributePlayerData)", PlayerData); }

    void ClientPlayerIsValidToDownload_Implementation(bool bIsValid, const FArkTributePlayerData* PlayerData) { NativeCall<void, bool, const FArkTributePlayerData*>(this, "AShooterPlayerController.ClientPlayerIsValidToDownload_Implementation(bool,FArkTributePlayerData)", bIsValid, PlayerData); }

    bool IsValidArkTributePlayerDownloadForThisServer(const FArkTributePlayerData* PlayerData) { return NativeCall<bool, const FArkTributePlayerData*>(this, "AShooterPlayerController.IsValidArkTributePlayerDownloadForThisServer(FArkTributePlayerData&)", PlayerData); }

    void ServerRequestDownloadPlayerCharacter_Implementation(FArkTributePlayerData* DownloadedCharacter, int spawnPointID, int spawnRegionIndex) { NativeCall<void, FArkTributePlayerData*, int, int>(this, "AShooterPlayerController.ServerRequestDownloadPlayerCharacter_Implementation(FArkTributePlayerData,int,int)", DownloadedCharacter, spawnPointID, spawnRegionIndex); }

    void OnFirstSaveAfterCharacterDownloadFinished(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.OnFirstSaveAfterCharacterDownloadFinished(bool)", Success); }

    void ClientDownloadPlayerCharacterRequestFinished_Implementation(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadPlayerCharacterRequestFinished_Implementation(bool)", Success); }

    FString* LinkedPlayerIDString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerController.LinkedPlayerIDString()", result); }

    void ServerSetSubscribedApp_Implementation(int AppID, bool bPreventDefaultItems) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetSubscribedApp_Implementation(int,bool)", AppID, bPreventDefaultItems); }

    void ServerRemoveSteamItemSucceeded_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRemoveSteamItemSucceeded_Implementation()"); }

    void RemoveItemSucceeded() { NativeCall<void>(this, "AShooterPlayerController.RemoveItemSucceeded()"); }

    void RefreshSteamInventory() { NativeCall<void>(this, "AShooterPlayerController.RefreshSteamInventory()"); }

    void ServerRemoveSteamItem_Implementation(unsigned int ItemdDefId) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerRemoveSteamItem_Implementation(unsignedint)", ItemdDefId); }

    void CloseSteamStatusScene() { NativeCall<void>(this, "AShooterPlayerController.CloseSteamStatusScene()"); }

    void AllowPlayerToJoinNoCheck(const FString* PlayerId) { NativeCall<void, const FString*>(this, "AShooterPlayerController.AllowPlayerToJoinNoCheck(FString&)", PlayerId); }

    void DisallowPlayerToJoinNoCheck(const FString* PlayerId) { NativeCall<void, const FString*>(this, "AShooterPlayerController.DisallowPlayerToJoinNoCheck(FString&)", PlayerId); }

    void ServerSendDirectMessage_Implementation(const FString* PlayerSteamID, const FString* MessageText) { NativeCall<void, const FString*, const FString*>(this, "AShooterPlayerController.ServerSendDirectMessage_Implementation(FString&,FString&)", PlayerSteamID, MessageText); }

    void ServerListPlayers_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerListPlayers_Implementation()"); }

    void KickPlayer(FString* PlayerSteamName) { NativeCall<void, FString*>(this, "AShooterPlayerController.KickPlayer(FString)", PlayerSteamName); }

    void ServerKickPlayer_Implementation(const FString* PlayerSteamName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerKickPlayer_Implementation(FString&)", PlayerSteamName); }

    void BanPlayer(FString* PlayerSteamName) { NativeCall<void, FString*>(this, "AShooterPlayerController.BanPlayer(FString)", PlayerSteamName); }

    void ServerBanPlayer_Implementation(const FString* PlayerSteamName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerBanPlayer_Implementation(FString&)", PlayerSteamName); }

    void UnbanPlayer(FString* PlayerSteamName) { NativeCall<void, FString*>(this, "AShooterPlayerController.UnbanPlayer(FString)", PlayerSteamName); }

    void ServerUnbanPlayer_Implementation(const FString* PlayerSteamName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerUnbanPlayer_Implementation(FString&)", PlayerSteamName); }

    void ServerAddAdminPlayer_Implementation(const FString* PlayerSteamName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerAddAdminPlayer_Implementation(FString&)", PlayerSteamName); }

    void ServerRemoveAdminPlayer_Implementation(const FString* PlayerSteamName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ServerRemoveAdminPlayer_Implementation(FString&)", PlayerSteamName); }

    void SetKickedNotification(FString* KickReason) { NativeCall<void, FString*>(this, "AShooterPlayerController.SetKickedNotification(FString)", KickReason); }

    void ClientProgressAchievement_Implementation(const FString* AchievementID, float Progress, bool savePlayerData) { NativeCall<void, const FString*, float, bool>(this, "AShooterPlayerController.ClientProgressAchievement_Implementation(FString&,float,bool)", AchievementID, Progress, savePlayerData); }

    void ClientProgressAchievementInteger_Implementation(const FString* AchievementID, int ProgressInteger, bool savePlayerData) { NativeCall<void, const FString*, int, bool>(this, "AShooterPlayerController.ClientProgressAchievementInteger_Implementation(FString&,int,bool)", AchievementID, ProgressInteger, savePlayerData); }

    void ClientUnlockAchievement_Implementation(const FString* AchievementID, bool savePlayerData) { NativeCall<void, const FString*, bool>(this, "AShooterPlayerController.ClientUnlockAchievement_Implementation(FString&,bool)", AchievementID, savePlayerData); }

    void ClientStartActivity_Implementation(const FString* ActivityName) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ClientStartActivity_Implementation(FString&)", ActivityName); }

    void ClientNotifyLevelUp_Implementation(APrimalCharacter* ForChar, int NewLevel) { NativeCall<void, APrimalCharacter*, int>(this, "AShooterPlayerController.ClientNotifyLevelUp_Implementation(APrimalCharacter*,int)", ForChar, NewLevel); }

    void ClientNotifyTorpidityIncrease_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTorpidityIncrease_Implementation()"); }

    void ServerPaint_Implementation(UStructurePaintingComponent* Structure, const TArray<FPaintItem, TSizedDefaultAllocator<32> >* Paints, bool bLastBatch, bool bFromLoadFile) { NativeCall<void, UStructurePaintingComponent*, const TArray<FPaintItem, TSizedDefaultAllocator<32> >*, bool, bool>(this, "AShooterPlayerController.ServerPaint_Implementation(UStructurePaintingComponent*,TArray<FPaintItem,TSizedDefaultAllocator<32>>&,bool,bool,bool)", Structure, Paints, bLastBatch, bFromLoadFile); }

    void InitCharacterPainting_Implementation(APrimalCharacter* Char) { NativeCall<void, APrimalCharacter*>(this, "AShooterPlayerController.InitCharacterPainting_Implementation(APrimalCharacter*)", Char); }

    void ClientNotifyListenServerOutOfRange_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyListenServerOutOfRange_Implementation()"); }

    void StopLoadingMusic() { NativeCall<void>(this, "AShooterPlayerController.StopLoadingMusic()"); }

    void FadeOutLoadingMusic() { NativeCall<void>(this, "AShooterPlayerController.FadeOutLoadingMusic()"); }

    ASpectatorPawn* SpawnSpectatorPawn() { return NativeCall<ASpectatorPawn*>(this, "AShooterPlayerController.SpawnSpectatorPawn()"); }

    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "AShooterPlayerController.ChangeState(FName)", NewState); }

    bool IsSpectator(const bool bIncludeSOTFIntro) { return NativeCall<bool, const bool>(this, "AShooterPlayerController.IsSpectator(bool)", bIncludeSOTFIntro); }

    void ClientFailedRemoveSaddle_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedRemoveSaddle_Implementation()"); }

    void ZoneVolumeReport() { NativeCall<void>(this, "AShooterPlayerController.ZoneVolumeReport()"); }

    void PrintColors() { NativeCall<void>(this, "AShooterPlayerController.PrintColors()"); }

    bool AllowConsoleUI() { return NativeCall<bool>(this, "AShooterPlayerController.AllowConsoleUI()"); }

    void ServerSetFreeCraftingQuantity_Implementation(UPrimalInventoryComponent* InventoryComp, const int Quantity) { NativeCall<void, UPrimalInventoryComponent*, const int>(this, "AShooterPlayerController.ServerSetFreeCraftingQuantity_Implementation(UPrimalInventoryComponent*,int)", InventoryComp, Quantity); }

    FString* ConsoleCommand(FString* result, const FString* Command, bool bWriteToLog) { return NativeCall<FString*, FString*, const FString*, bool>(this, "AShooterPlayerController.ConsoleCommand(FString&,bool)", result, Command, bWriteToLog); }

    void ClientRunLocalConsoleCommand_Implementation(const FString* Command, bool bWriteToLog) { NativeCall<void, const FString*, bool>(this, "AShooterPlayerController.ClientRunLocalConsoleCommand_Implementation(FString&,bool)", Command, bWriteToLog); }

    void EnvQA() { NativeCall<void>(this, "AShooterPlayerController.EnvQA()"); }

    void ClientShowPaintingUI_Implementation(UObject* ObjectToPaint) { NativeCall<void, UObject*>(this, "AShooterPlayerController.ClientShowPaintingUI_Implementation(UObject*)", ObjectToPaint); }

    void HideRiders(bool bDoHide) { NativeCall<void, bool>(this, "AShooterPlayerController.HideRiders(bool)", bDoHide); }

    AActor* GetViewTarget() { return NativeCall<AActor*>(this, "AShooterPlayerController.GetViewTarget()"); }

    void SpawnPlayerCameraManager() { NativeCall<void>(this, "AShooterPlayerController.SpawnPlayerCameraManager()"); }

    void ServerSetSupressAdminIcon_Implementation(bool bSuppress) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetSupressAdminIcon_Implementation(bool)", bSuppress); }

    void NotifyTribeWarStatus_Implementation(const FString* EnemyTribeString, int StatusType) { NativeCall<void, const FString*, int>(this, "AShooterPlayerController.NotifyTribeWarStatus_Implementation(FString&,int)", EnemyTribeString, StatusType); }

    void StartArkGamepadLeftShoulder() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadLeftShoulder()"); }

    void EndArkGamepadLeftShoulder() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadLeftShoulder()"); }

    void StartArkGamepadRightShoulder() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadRightShoulder()"); }

    void EndArkGamepadRightShoulder() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadRightShoulder()"); }

    void ServerRequestTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTribeLog_Implementation()"); }

    void ClientStartReceivingTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientStartReceivingTribeLog_Implementation()"); }

    void ClientReceiveTribeLog_Implementation(const FString* LogString) { NativeCall<void, const FString*>(this, "AShooterPlayerController.ClientReceiveTribeLog_Implementation(FString&)", LogString); }

    void ClientEndReceivingTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientEndReceivingTribeLog_Implementation()"); }

    void RPCStayAlive_Implementation() { NativeCall<void>(this, "AShooterPlayerController.RPCStayAlive_Implementation()"); }

    void ConditonalEndGamepadModiferState() { NativeCall<void>(this, "AShooterPlayerController.ConditonalEndGamepadModiferState()"); }

    void StartArkGamepadBackButton() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadBackButton()"); }

    void EndArkGamepadBackButton() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadBackButton()"); }

    void StartArkGamepadFaceButtonLeft() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonLeft()"); }

    void EndArkGamepadFaceButtonLeft() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonLeft()"); }

    void StartArkGamepadFaceButtonRight() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonRight()"); }

    void EndArkGamepadFaceButtonRight() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonRight()"); }

    void StartArkGamepadFaceButtonTop() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonTop()"); }

    void EndArkGamepadFaceButtonTop() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonTop()"); }

    void StartArkGamepadFaceButtonBottom() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonBottom()"); }

    void EndArkGamepadFaceButtonBottom() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonBottom()"); }

    void OnStartInGameMenu() { NativeCall<void>(this, "AShooterPlayerController.OnStartInGameMenu()"); }

    void OnToggleInGameMenu() { NativeCall<void>(this, "AShooterPlayerController.OnToggleInGameMenu()"); }

    void HideFPVMesh() { NativeCall<void>(this, "AShooterPlayerController.HideFPVMesh()"); }

    void ControlsStartMap() { NativeCall<void>(this, "AShooterPlayerController.ControlsStartMap()"); }

    void ControlsStopMap() { NativeCall<void>(this, "AShooterPlayerController.ControlsStopMap()"); }

    void SlowMovementOn() { NativeCall<void>(this, "AShooterPlayerController.SlowMovementOn()"); }

    void SlowMovementOff() { NativeCall<void>(this, "AShooterPlayerController.SlowMovementOff()"); }

    void ControlsStartInventory() { NativeCall<void>(this, "AShooterPlayerController.ControlsStartInventory()"); }

    void ControlsEndInventory() { NativeCall<void>(this, "AShooterPlayerController.ControlsEndInventory()"); }

    void ControlsStartReload() { NativeCall<void>(this, "AShooterPlayerController.ControlsStartReload()"); }

    void ControlsEndReload() { NativeCall<void>(this, "AShooterPlayerController.ControlsEndReload()"); }

    void ControlsStartUse() { NativeCall<void>(this, "AShooterPlayerController.ControlsStartUse()"); }

    void ControlsEndUse() { NativeCall<void>(this, "AShooterPlayerController.ControlsEndUse()"); }

    void ControlsStartJump() { NativeCall<void>(this, "AShooterPlayerController.ControlsStartJump()"); }

    void ControlsEndJump() { NativeCall<void>(this, "AShooterPlayerController.ControlsEndJump()"); }

    void StartArkGamepadDpadLeft() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadLeft()"); }

    void EndArkGamepadDpadLeft() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadDpadLeft()"); }

    void StartArkGamepadDpadUp() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadUp()"); }

    void EndAArkGamepadDpadUp() { NativeCall<void>(this, "AShooterPlayerController.EndAArkGamepadDpadUp()"); }

    void StartArkGamepadDpadRight() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadRight()"); }

    void EndArkGamepadDpadRight() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadDpadRight()"); }

    void StartArkGamepadDpadDown() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadDown()"); }

    void EndArkGamepadDpadDown() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadDpadDown()"); }

    void ServerAddAchievementID_Implementation(const FString* AchievementID, bool bIsOnSpawn) { NativeCall<void, const FString*, bool>(this, "AShooterPlayerController.ServerAddAchievementID_Implementation(FString&,bool)", AchievementID, bIsOnSpawn); }

    int GetLinkedPlayerID() { return NativeCall<int>(this, "AShooterPlayerController.GetLinkedPlayerID()"); }

    FString* GetPlayerCharacterName(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerController.GetPlayerCharacterName()", result); }

    //void ClientCollectedAchievementItem_Implementation(TSubclassOf<UPrimalItem> ItemClass) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.ClientCollectedAchievementItem_Implementation(TSubclassOf<UPrimalItem>)", ItemClass); }

    //bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject* OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerController.AllowTribeGroupPermission(ETribeGroupPermission::Type,UObject*)", TribeGroupPermission, OnObject); }

    bool UseTribeGroupRanks() { return NativeCall<bool>(this, "AShooterPlayerController.UseTribeGroupRanks()"); }

    bool IsTribeAdmin() { return NativeCall<bool>(this, "AShooterPlayerController.IsTribeAdmin()"); }

    bool IsInTribe() { return NativeCall<bool>(this, "AShooterPlayerController.IsInTribe()"); }

    void ClientAddFloatingDamageText_Implementation(FVector_NetQuantize* AtLocation, int DamageAmount, int FromTeamID) { NativeCall<void, FVector_NetQuantize*, int, int>(this, "AShooterPlayerController.ClientAddFloatingDamageText_Implementation(FVector_NetQuantize,int,int)", AtLocation, DamageAmount, FromTeamID); }

    void ClientAddFloatingText_Implementation(FVector_NetQuantize* AtLocation, const FString* FloatingTextString, FColor FloatingTextColor, float ScaleX, float ScaleY, float TextLifeSpan, UE::Math::TVector<double>* TextVelocity, float MinScale, float FadeInTime, float FadeOutTime) { NativeCall<void, FVector_NetQuantize*, const FString*, FColor, float, float, float, UE::Math::TVector<double>*, float, float, float>(this, "AShooterPlayerController.ClientAddFloatingText_Implementation(FVector_NetQuantize,FString&,FColor,float,float,float,UE::Math::TVector<double>,float,float,float)", AtLocation, FloatingTextString, FloatingTextColor, ScaleX, ScaleY, TextLifeSpan, TextVelocity, MinScale, FadeInTime, FadeOutTime); }

    UPrimalItem* GetInventoryUISelectedSkinLocal() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedSkinLocal()"); }

    UPrimalItem* GetInventoryUISelectedSkinRemote() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedSkinRemote()"); }

    UPrimalItem* GetInventoryUISelectedItemRemote() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedItemRemote()"); }

    void NotifyDealDamageSuccess(APrimalCharacter* HitCharacter, bool bHitFriendlyTarget, float PreDamageHealth, float DamageAmount, const FDamageEvent* DamageEvent) { NativeCall<void, APrimalCharacter*, bool, float, float, const FDamageEvent*>(this, "AShooterPlayerController.NotifyDealDamageSuccess(APrimalCharacter*,bool,float,float,FDamageEvent&)", HitCharacter, bHitFriendlyTarget, PreDamageHealth, DamageAmount, DamageEvent); }

    //void PlayHitMarkerCharacter_Implementation(bool bHitFriendlyTarget, const FHitMarkerSettings* HitMarkerSettings) { NativeCall<void, bool, const FHitMarkerSettings*>(this, "AShooterPlayerController.PlayHitMarkerCharacter_Implementation(bool,FHitMarkerSettings)", bHitFriendlyTarget, HitMarkerSettings); }

    void PlayHitMarkerStructure_Implementation() { NativeCall<void>(this, "AShooterPlayerController.PlayHitMarkerStructure_Implementation()"); }

    void PlayHitMarkerStructureAlly_Implementation() { NativeCall<void>(this, "AShooterPlayerController.PlayHitMarkerStructureAlly_Implementation()"); }

    void ClientShowTransferredPlayerConfirmationDialog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientShowTransferredPlayerConfirmationDialog_Implementation()"); }

    void ShowTransferCharacterConfirmationDialog() { NativeCall<void>(this, "AShooterPlayerController.ShowTransferCharacterConfirmationDialog()"); }

    void OnTransferCharacterConfirmationDialogClosed(bool bAccept) { NativeCall<void, bool>(this, "AShooterPlayerController.OnTransferCharacterConfirmationDialogClosed(bool)", bAccept); }

    void ServerTransferredPlayerConfirmationResult_Implementation(bool bAccpet) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerTransferredPlayerConfirmationResult_Implementation(bool)", bAccpet); }

    void ClientSetHUDAndInitUIScenes_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "AShooterPlayerController.ClientSetHUDAndInitUIScenes_Implementation(TSubclassOf<AHUD>)", NewHUDClass); }

    void ClientShowSpawnUIForTransferringPlayer_Implementation(TSubclassOf<AHUD> NewHUDClass, unsigned __int64 TransferingPlayerID, bool bUseTimer) { NativeCall<void, TSubclassOf<AHUD>, unsigned __int64, bool>(this, "AShooterPlayerController.ClientShowSpawnUIForTransferringPlayer_Implementation(TSubclassOf<AHUD>,unsigned__int64,bool)", NewHUDClass, TransferingPlayerID, bUseTimer); }

    void ServerDownloadTransferredPlayer_Implementation(int spawnPointID, int spawnPointRegionIndex) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerDownloadTransferredPlayer_Implementation(int,int)", spawnPointID, spawnPointRegionIndex); }

    void GetAudioListenerPosition(UE::Math::TVector<double>* OutLocation, UE::Math::TVector<double>* OutFrontDir, UE::Math::TVector<double>* OutRightDir) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "AShooterPlayerController.GetAudioListenerPosition(UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&)", OutLocation, OutFrontDir, OutRightDir); }

    void ServerStartWeaponFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponFire_Implementation(AShooterWeapon*)", weapon); }

    void ServerStopWeaponFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponFire_Implementation(AShooterWeapon*)", weapon); }

    void ServerStartWeaponAltFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponAltFire_Implementation(AShooterWeapon*)", weapon); }

    void ServerStopWeaponAltFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponAltFire_Implementation(AShooterWeapon*)", weapon); }

    void ClientStartSurfaceCameraForPassenger_Implementation(float yaw, float pitch, float roll, bool bInvertTurnInput) { NativeCall<void, float, float, float, bool>(this, "AShooterPlayerController.ClientStartSurfaceCameraForPassenger_Implementation(float,float,float,bool)", yaw, pitch, roll, bInvertTurnInput); }

    void ClientNotifyUnlockedAllExplorerNotes_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyUnlockedAllExplorerNotes_Implementation()"); }

    void ServerUnlockPerMapExplorerNote_Implementation(int ExplorerNoteIndex, bool bAvoidBuff, bool savePlayerData) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerController.ServerUnlockPerMapExplorerNote_Implementation(int,bool,bool)", ExplorerNoteIndex, bAvoidBuff, savePlayerData); }

    void UnlockExplorerNote(int ExplorerNoteIndex, const bool forceShowExplorerNoteUI, bool savePlayerData) { NativeCall<void, int, const bool, bool>(this, "AShooterPlayerController.UnlockExplorerNote(int,bool,bool)", ExplorerNoteIndex, forceShowExplorerNoteUI, savePlayerData); }

    void ClientUnlockExplorerNote_Implementation(int ExplorerNoteIndex, bool forceShowExplorerNoteUI, bool savePlayerData) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerController.ClientUnlockExplorerNote_Implementation(int,bool,bool)", ExplorerNoteIndex, forceShowExplorerNoteUI, savePlayerData); }

    APawn* GetResponsibleDamager(AActor* DamageCauser) { return NativeCall<APawn*, AActor*>(this, "AShooterPlayerController.GetResponsibleDamager(AActor*)", DamageCauser); }

    void UnlockEmote(FName EmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.UnlockEmote(FName)", EmoteName); }

    void LockEmote(FName EmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.LockEmote(FName)", EmoteName); }

    bool IsEmoteUnlocked(FName EmoteName) { return NativeCall<bool, FName>(this, "AShooterPlayerController.IsEmoteUnlocked(FName)", EmoteName); }

    int GetCurrentMultiUseWheelCategory() { return NativeCall<int>(this, "AShooterPlayerController.GetCurrentMultiUseWheelCategory()"); }

    void SetCurrentMultiUseWheelCategory(int Category) { NativeCall<void, int>(this, "AShooterPlayerController.SetCurrentMultiUseWheelCategory(int)", Category); }

    void ClientReceiveDinoAncestors_Implementation(APrimalDinoCharacter* ForDino, const TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >* DinoAncestors, const TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >* DinoAncestorsMale, int RandomMutationsFemale, int RandomMutationsMale) { NativeCall<void, APrimalDinoCharacter*, const TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >*, const TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >*, int, int>(this, "AShooterPlayerController.ClientReceiveDinoAncestors_Implementation(APrimalDinoCharacter*,TArray<FDinoAncestorsEntry,TSizedDefaultAllocator<32>>&,TArray<FDinoAncestorsEntry,TSizedDefaultAllocator<32>>&,int,int)", ForDino, DinoAncestors, DinoAncestorsMale, RandomMutationsFemale, RandomMutationsMale); }

    void ServerRequestDinoAncestors_Implementation(APrimalDinoCharacter* ForDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoAncestors_Implementation(APrimalDinoCharacter*)", ForDino); }

    void OnPressGroupAddOrRemoveTame() { NativeCall<void>(this, "AShooterPlayerController.OnPressGroupAddOrRemoveTame()"); }

    AActor* BaseGetPlayerCharacter() { return NativeCall<AActor*>(this, "AShooterPlayerController.BaseGetPlayerCharacter()"); }

    void ClientNotifyUnlockedEngram_Implementation(TSubclassOf<UPrimalItem> ItemClass, bool bTekGram) { NativeCall<void, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerController.ClientNotifyUnlockedEngram_Implementation(TSubclassOf<UPrimalItem>,bool)", ItemClass, bTekGram); }

    void ClientTeleportSucceeded_Implementation(UE::Math::TVector<double>* TeleportLoc, UE::Math::TRotator<double>* TeleportRot, bool bSimpleTeleport) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool>(this, "AShooterPlayerController.ClientTeleportSucceeded_Implementation(UE::Math::TVector<double>,UE::Math::TRotator<double>,bool)", TeleportLoc, TeleportRot, bSimpleTeleport); }

    bool IsAtPersonalTameLimit(bool bIsForStructure) { return NativeCall<bool, bool>(this, "AShooterPlayerController.IsAtPersonalTameLimit(bool)", bIsForStructure); }

    FString* GetPersonalTameLimitString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerController.GetPersonalTameLimitString()", result); }

    void ClientSetPersonalDinoTameCount_Implementation(int NewPersonalDinoTameCount) { NativeCall<void, int>(this, "AShooterPlayerController.ClientSetPersonalDinoTameCount_Implementation(int)", NewPersonalDinoTameCount); }

    void UpdatePostProcessVolumes() { NativeCall<void>(this, "AShooterPlayerController.UpdatePostProcessVolumes()"); }

    bool IsSavingData() { return NativeCall<bool>(this, "AShooterPlayerController.IsSavingData()"); }

    FString* PlayerCommand_Implementation(FString* result, const FString* TheCommand) { return NativeCall<FString*, FString*, const FString*>(this, "AShooterPlayerController.PlayerCommand_Implementation(FString&)", result, TheCommand); }

    void TryToForceUploadCharacter_Implementation() { NativeCall<void>(this, "AShooterPlayerController.TryToForceUploadCharacter_Implementation()"); }

    void ServerDPC_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerDPC_Implementation()"); }

    void QuitToMainMenu() { NativeCall<void>(this, "AShooterPlayerController.QuitToMainMenu()"); }

    bool IsViewingInventoryUI() { return NativeCall<bool>(this, "AShooterPlayerController.IsViewingInventoryUI()"); }

    bool ViewingAnUploadTerminal() { return NativeCall<bool>(this, "AShooterPlayerController.ViewingAnUploadTerminal()"); }

    bool IsFirstLocalPlayer() { return NativeCall<bool>(this, "AShooterPlayerController.IsFirstLocalPlayer()"); }

    bool IsFirstLocalPlayerOrLivingLocalPlayer() { return NativeCall<bool>(this, "AShooterPlayerController.IsFirstLocalPlayerOrLivingLocalPlayer()"); }

    void ServerRequestMyTribeOnlineList_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyTribeOnlineList_Implementation()"); }

    void ClientReceiveMyTribeOnlineList_Implementation(const TArray<unsigned int, TSizedDefaultAllocator<32> >* OnlinePlayerIDs) { NativeCall<void, const TArray<unsigned int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientReceiveMyTribeOnlineList_Implementation(TArray<unsignedint,TSizedDefaultAllocator<32>>&)", OnlinePlayerIDs); }

    void ClientNotifyUnlockHairStyleOrEmote_Implementation(FName HairstyleOrEmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.ClientNotifyUnlockHairStyleOrEmote_Implementation(FName)", HairstyleOrEmoteName); }

    void UpdateRequestEquippedItemsQueue() { NativeCall<void>(this, "AShooterPlayerController.UpdateRequestEquippedItemsQueue()"); }

    void ClientProcessItemNetExecCommandBP_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID ForItemID, bool bIsEquippedItem, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, FName, FBPNetExecParams*>(this, "AShooterPlayerController.ClientProcessItemNetExecCommandBP_Implementation(UPrimalInventoryComponent*,FItemNetID,bool,FName,FBPNetExecParams)", forInventory, ForItemID, bIsEquippedItem, CommandName, ExecParams); }

    void ServerProcessItemNetExecCommandBP_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID ForItemID, bool bIsEquippedItem, FName CommandName, FBPNetExecParams* ExecParams) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, FName, FBPNetExecParams*>(this, "AShooterPlayerController.ServerProcessItemNetExecCommandBP_Implementation(UPrimalInventoryComponent*,FItemNetID,bool,FName,FBPNetExecParams)", forInventory, ForItemID, bIsEquippedItem, CommandName, ExecParams); }

    void ServerDropAllNotReadyForUploadItems_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerDropAllNotReadyForUploadItems_Implementation()"); }

    void ClientOnDropAllNotReadyForUploadItemsFinished_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientOnDropAllNotReadyForUploadItemsFinished_Implementation()"); }

    void NetSpawnActorAtLocation_Implementation(TSubclassOf<AActor> AnActorClass, FVector_NetQuantize* AtLocation, FRotator_NetQuantize* AtRotation, USceneComponent* attachToComponent, int dataIndex, FName attachSocketName) { NativeCall<void, TSubclassOf<AActor>, FVector_NetQuantize*, FRotator_NetQuantize*, USceneComponent*, int, FName>(this, "AShooterPlayerController.NetSpawnActorAtLocation_Implementation(TSubclassOf<AActor>,FVector_NetQuantize,FRotator_NetQuantize,USceneComponent*,int,FName)", AnActorClass, AtLocation, AtRotation, attachToComponent, dataIndex, attachSocketName); }

    void NetSpawnFoliageVFXActorAtLocationAndDoFoliageInteraction_Implementation(TSubclassOf<AActor> AnActorClass, FVector_NetQuantize* AtLocation, FRotator_NetQuantize* AtRotation, int dataIndex, FVector_NetQuantize* FoliageOrigin_ImpactPoint, FVector_NetQuantize* TraceEndpoint, USceneComponent* attachToComponent) { NativeCall<void, TSubclassOf<AActor>, FVector_NetQuantize*, FRotator_NetQuantize*, int, FVector_NetQuantize*, FVector_NetQuantize*, USceneComponent*>(this, "AShooterPlayerController.NetSpawnFoliageVFXActorAtLocationAndDoFoliageInteraction_Implementation(TSubclassOf<AActor>,FVector_NetQuantize,FRotator_NetQuantize,int,FVector_NetQuantize,FVector_NetQuantize,USceneComponent*)", AnActorClass, AtLocation, AtRotation, dataIndex, FoliageOrigin_ImpactPoint, TraceEndpoint, attachToComponent); }

    void NetSpawnFoliageVFXActorAtLocationAndDoFoliageInteraction_Simple_Implementation(TSubclassOf<AActor> AnActorClass, FVector_NetQuantize* AtLocation, FRotator_NetQuantize* AtRotation, int dataIndex, FVector_NetQuantize* FoliageOrigin_ImpactPoint, float TraceEndpointZ, USceneComponent* attachToComponent) { NativeCall<void, TSubclassOf<AActor>, FVector_NetQuantize*, FRotator_NetQuantize*, int, FVector_NetQuantize*, float, USceneComponent*>(this, "AShooterPlayerController.NetSpawnFoliageVFXActorAtLocationAndDoFoliageInteraction_Simple_Implementation(TSubclassOf<AActor>,FVector_NetQuantize,FRotator_NetQuantize,int,FVector_NetQuantize,float,USceneComponent*)", AnActorClass, AtLocation, AtRotation, dataIndex, FoliageOrigin_ImpactPoint, TraceEndpointZ, attachToComponent); }

    void IncrementPrimalStats(EPrimalStatsValueTypes::Type statsValueType) { NativeCall<void, EPrimalStatsValueTypes::Type>(this, "AShooterPlayerController.IncrementPrimalStats(EPrimalStatsValueTypes::Type)", statsValueType); }

    void FlushPrimalStats() { NativeCall<void>(this, "AShooterPlayerController.FlushPrimalStats()"); }

    void SetInstantHarvest(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetInstantHarvest(bool)", bEnable); }

    bool HasInstantHarvest() { return NativeCall<bool>(this, "AShooterPlayerController.HasInstantHarvest()"); }

    AShooterCharacter* GetControllerPlayer(__int16 a2) { return NativeCall<AShooterCharacter*, __int16>(this, "AShooterPlayerController.GetControllerPlayer()", a2); }

    void Client_ReceiveBuffFromDayCycle_Implementation(TSubclassOf<APrimalBuff> GiveBuffClass, ADayCycleManager* FromDayCycle) { NativeCall<void, TSubclassOf<APrimalBuff>, ADayCycleManager*>(this, "AShooterPlayerController.Client_ReceiveBuffFromDayCycle_Implementation(TSubclassOf<APrimalBuff>,ADayCycleManager*)", GiveBuffClass, FromDayCycle); }

    void Tick_UpdatePings(const float DeltaTime) { NativeCall<void, const float>(this, "AShooterPlayerController.Tick_UpdatePings(float)", DeltaTime); }

    void OnPingDown() { NativeCall<void>(this, "AShooterPlayerController.OnPingDown()"); }

    void OnPingUp() { NativeCall<void>(this, "AShooterPlayerController.OnPingUp()"); }

    //FTeamPingDataForClient* GetTeamPingSettingsByType(FTeamPingDataForClient* result, TEnumAsByte<ETeamPingType::Type> TeamPingType) { return NativeCall<FTeamPingDataForClient*, FTeamPingDataForClient*, TEnumAsByte<ETeamPingType::Type>>(this, "AShooterPlayerController.GetTeamPingSettingsByType(TEnumAsByte<ETeamPingType::Type>)", result, TeamPingType); }

    void StartTeamPingWheel() { NativeCall<void>(this, "AShooterPlayerController.StartTeamPingWheel()"); }

    void Client_UpdateRallyPointData_Implementation(bool DestroyRallyPoint, FTeamPingData* RallyPointData) { NativeCall<void, bool, FTeamPingData*>(this, "AShooterPlayerController.Client_UpdateRallyPointData_Implementation(bool,FTeamPingData)", DestroyRallyPoint, RallyPointData); }

    void Server_UpdateRallyPointData_Implementation() { NativeCall<void>(this, "AShooterPlayerController.Server_UpdateRallyPointData_Implementation()"); }

    void Server_DoTeamPing_Implementation(const FTeamPingData* WithPingData) { NativeCall<void, const FTeamPingData*>(this, "AShooterPlayerController.Server_DoTeamPing_Implementation(FTeamPingData)", WithPingData); }

    void Client_AddTeamPing_Implementation(const FTeamPingData* WithPingData) { NativeCall<void, const FTeamPingData*>(this, "AShooterPlayerController.Client_AddTeamPing_Implementation(FTeamPingData)", WithPingData); }

    void DrawMultiUsePingEntry(const int index, const FName text, UCanvas* Canvas, const UE::Math::TVector2<double>* canvasPosition) { NativeCall<void, const int, const FName, UCanvas*, const UE::Math::TVector2<double>*>(this, "AShooterPlayerController.DrawMultiUsePingEntry(int,FName,UCanvas*,UE::Math::TVector2<double>&)", index, text, Canvas, canvasPosition); }

    bool TraceTeamPingType(TEnumAsByte<ETeamPingType::Type> PingType, FHitResult* Hit, TEnumAsByte<ETeamPingType::Type>* ReturnPingType) { return NativeCall<bool, TEnumAsByte<ETeamPingType::Type>, FHitResult*, TEnumAsByte<ETeamPingType::Type>*>(this, "AShooterPlayerController.TraceTeamPingType(TEnumAsByte<ETeamPingType::Type>,FHitResult&,TEnumAsByte<ETeamPingType::Type>&)", PingType, Hit, ReturnPingType); }

    bool TryCreateTeamPingType(TEnumAsByte<ETeamPingType::Type> PingType) { return NativeCall<bool, TEnumAsByte<ETeamPingType::Type>>(this, "AShooterPlayerController.TryCreateTeamPingType(TEnumAsByte<ETeamPingType::Type>)", PingType); }

    bool CanTeamPing() { return NativeCall<bool>(this, "AShooterPlayerController.CanTeamPing()"); }

    bool CanPingRallyPoint() { return NativeCall<bool>(this, "AShooterPlayerController.CanPingRallyPoint()"); }

    bool DoPingTrace(FReplicatePingData* NewPing, bool* bIsResponding) { return NativeCall<bool, FReplicatePingData*, bool*>(this, "AShooterPlayerController.DoPingTrace(FReplicatePingData&,bool&)", NewPing, bIsResponding); }

    void Server_Ping_Implementation(const FReplicatePingData* WithPingData) { NativeCall<void, const FReplicatePingData*>(this, "AShooterPlayerController.Server_Ping_Implementation(FReplicatePingData)", WithPingData); }

    void PingNearbyPlayers(const FReplicatePingData* WithPingData) { NativeCall<void, const FReplicatePingData*>(this, "AShooterPlayerController.PingNearbyPlayers(FReplicatePingData&)", WithPingData); }

    void Client_ReceivePing_Implementation(const FReplicatePingData* ReceivedPingData) { NativeCall<void, const FReplicatePingData*>(this, "AShooterPlayerController.Client_ReceivePing_Implementation(FReplicatePingData)", ReceivedPingData); }

    void Server_RespondToPing_Implementation(const FReplicatePingData* RespondToPingData) { NativeCall<void, const FReplicatePingData*>(this, "AShooterPlayerController.Server_RespondToPing_Implementation(FReplicatePingData)", RespondToPingData); }

    void RespondToPing(const FReplicatePingData* RespondToPingData) { NativeCall<void, const FReplicatePingData*>(this, "AShooterPlayerController.RespondToPing(FReplicatePingData&)", RespondToPingData); }

    void Client_ReceivePingResponse_Implementation(const FReplicatePingData* ResponseData, AShooterCharacter* RespondingPlayer) { NativeCall<void, const FReplicatePingData*, AShooterCharacter*>(this, "AShooterPlayerController.Client_ReceivePingResponse_Implementation(FReplicatePingData,AShooterCharacter*)", ResponseData, RespondingPlayer); }

    bool InitPing(FPingData* ForPingData, const FReplicatePingData* InitFromData) { return NativeCall<bool, FPingData*, const FReplicatePingData*>(this, "AShooterPlayerController.InitPing(FPingData&,FReplicatePingData&)", ForPingData, InitFromData); }

    static bool IsPlayerViewingPing(const AShooterPlayerController* ForPC, const FPingData* CheckPingData) { return NativeCall<bool, const AShooterPlayerController*, const FPingData*>(nullptr, "AShooterPlayerController.IsPlayerViewingPing(AShooterPlayerController*,FPingData&)", ForPC, CheckPingData); }

    static bool IsPingedItem(const UPrimitiveComponent* PingComponent) { return NativeCall<bool, const UPrimitiveComponent*>(nullptr, "AShooterPlayerController.IsPingedItem(UPrimitiveComponent*)", PingComponent); }

    TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >* GetNearbyPOIs(TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >*, TArray<FPointOfInterestData_ForCompanion, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.GetNearbyPOIs()", result); }

    void Tick_SearchForPOIs(float DeltaTime) { NativeCall<void, float>(this, "AShooterPlayerController.Tick_SearchForPOIs(float)", DeltaTime); }

    void GetMapMarkerPOIs(__int64 a2) { NativeCall<void, __int64>(this, "AShooterPlayerController.GetMapMarkerPOIs()", a2); }

    void VerifyNearbyPOIActors(TArray<AActor*, TSizedDefaultAllocator<32> >* foundActors) { NativeCall<void, TArray<AActor*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.VerifyNearbyPOIActors(TArray<AActor*,TSizedDefaultAllocator<32>>&)", foundActors); }

    void Server_RequestLastDeathTrackingActorLoc_Implementation() { NativeCall<void>(this, "AShooterPlayerController.Server_RequestLastDeathTrackingActorLoc_Implementation()"); }

    void Server_RequestLastDeathTrackingActorLoc_ServerLogic() { NativeCall<void>(this, "AShooterPlayerController.Server_RequestLastDeathTrackingActorLoc_ServerLogic()"); }

    void Client_ReceiveLastDeathTrackingActorLoc_Implementation(int Index, UE::Math::TVector<double>* Loc) { NativeCall<void, int, UE::Math::TVector<double>*>(this, "AShooterPlayerController.Client_ReceiveLastDeathTrackingActorLoc_Implementation(int,UE::Math::TVector<double>)", Index, Loc); }

    void NotifyPawnBuffsOfDamageEvent(AActor* DamagedActor, float DamageAmount, const FDamageEvent* DamageEvent) { NativeCall<void, AActor*, float, const FDamageEvent*>(this, "AShooterPlayerController.NotifyPawnBuffsOfDamageEvent(AActor*,float,FDamageEvent&)", DamagedActor, DamageAmount, DamageEvent); }

    void PurchaseEngramPoint(int NumPointsToPurchase) { NativeCall<void, int>(this, "AShooterPlayerController.PurchaseEngramPoint(int)", NumPointsToPurchase); }

    bool IsPOINearCenterOfScreen(UE::Math::TVector2<double>* POIPosition, UE::Math::TVector2<double>* DeadZone) { return NativeCall<bool, UE::Math::TVector2<double>*, UE::Math::TVector2<double>*>(this, "AShooterPlayerController.IsPOINearCenterOfScreen(UE::Math::TVector2<double>,UE::Math::TVector2<double>)", POIPosition, DeadZone); }

    void ServerRequestStructuresPlacedOnFloor_Implementation(const TArray<APrimalStructure*, TSizedDefaultAllocator<32> >* OnStructures) { NativeCall<void, const TArray<APrimalStructure*, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ServerRequestStructuresPlacedOnFloor_Implementation(TArray<APrimalStructure*,TSizedDefaultAllocator<32>>&)", OnStructures); }

    //void ClientReceiveStructuresPlacedOnFloor_Implementation(const TArray<FStructuresOnFloor, TSizedDefaultAllocator<32> >* Structures) { NativeCall<void, const TArray<FStructuresOnFloor, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientReceiveStructuresPlacedOnFloor_Implementation(TArray<FStructuresOnFloor,TSizedDefaultAllocator<32>>&)", Structures); }

    bool IsRemoteControlling() { return NativeCall<bool>(this, "AShooterPlayerController.IsRemoteControlling()"); }

    void CopyWorldBuffStatus() { NativeCall<void>(this, "AShooterPlayerController.CopyWorldBuffStatus()"); }

    void SetCinematicModeAdvanced(bool bInCinematicMode, bool bPreventCameraAnimFPV, bool bSetHUDHidden, bool bDisableKeymappings, const TArray<FName, TSizedDefaultAllocator<32> >* KeyActionNames, bool bDisableChat) { NativeCall<void, bool, bool, bool, bool, const TArray<FName, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.SetCinematicModeAdvanced(bool,bool,bool,bool,TArray<FName,TSizedDefaultAllocator<32>>,bool)", bInCinematicMode, bPreventCameraAnimFPV, bSetHUDHidden, bDisableKeymappings, KeyActionNames, bDisableChat); }

    void ServerSelectedCustomItemAction_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, FName SelectedOption) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FName>(this, "AShooterPlayerController.ServerSelectedCustomItemAction_Implementation(UPrimalInventoryComponent*,FItemNetID,FName)", inventoryComp, itemID, SelectedOption); }

    void ServerRequestUpdateActiveMissionTags_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestUpdateActiveMissionTags_Implementation()"); }

    void ClientReceiveActiveMissionTags_Implementation(const TArray<FName, TSizedDefaultAllocator<32> >* MissionTags) { NativeCall<void, const TArray<FName, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientReceiveActiveMissionTags_Implementation(TArray<FName,TSizedDefaultAllocator<32>>&)", MissionTags); }

    void DoDestroyTribeIdStructures() { NativeCall<void>(this, "AShooterPlayerController.DoDestroyTribeIdStructures()"); }

    void GiveCryoItemAndCaptureDino(APrimalDinoCharacter* targetDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.GiveCryoItemAndCaptureDino(APrimalDinoCharacter*)", targetDino); }

    void OnNetCleanup(UNetConnection* Connection) { NativeCall<void, UNetConnection*>(this, "AShooterPlayerController.OnNetCleanup(UNetConnection*)", Connection); }

    void DelayedNetCleanup() { NativeCall<void>(this, "AShooterPlayerController.DelayedNetCleanup()"); }

    void ClientDrawUndermeshSphere_Implementation(const int radius) { NativeCall<void, const int>(this, "AShooterPlayerController.ClientDrawUndermeshSphere_Implementation(int)", radius); }

    //void ServerUpdateLevelVisibility_Implementation(const FUpdateLevelVisibilityLevelInfo* LevelVisibility) { NativeCall<void, const FUpdateLevelVisibilityLevelInfo*>(this, "AShooterPlayerController.ServerUpdateLevelVisibility_Implementation(FUpdateLevelVisibilityLevelInfo&)", LevelVisibility); }

    void OnRep_Pawn(__int16 a2) { NativeCall<void, __int16>(this, "AShooterPlayerController.OnRep_Pawn()", a2); }

    //APrimalCinematicActor* GetControllingCinematic() { return NativeCall<APrimalCinematicActor*>(this, "AShooterPlayerController.GetControllingCinematic()"); }

    void OnSubobjectDestroyFromReplication(UObject* Subobject) { NativeCall<void, UObject*>(this, "AShooterPlayerController.OnSubobjectDestroyFromReplication(UObject*)", Subobject); }

    void PlayWheelClickSound() { NativeCall<void>(this, "AShooterPlayerController.PlayWheelClickSound()"); }

    void PlayWheelProgressSound() { NativeCall<void>(this, "AShooterPlayerController.PlayWheelProgressSound()"); }

    void PlayWheelProgressCompleteSound() { NativeCall<void>(this, "AShooterPlayerController.PlayWheelProgressCompleteSound()"); }

    void StopWheelProgressSound() { NativeCall<void>(this, "AShooterPlayerController.StopWheelProgressSound()"); }

    void ServerAutoStackItemIDs_Implementation(UPrimalInventoryComponent* InventoryComp, const TArray<FItemNetID, TSizedDefaultAllocator<32> >* ItemIDs) { NativeCall<void, UPrimalInventoryComponent*, const TArray<FItemNetID, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ServerAutoStackItemIDs_Implementation(UPrimalInventoryComponent*,TArray<FItemNetID,TSizedDefaultAllocator<32>>&)", InventoryComp, ItemIDs); }

    bool BPSearchForPOIs_Implementation(__int16 a2) { return NativeCall<bool, __int16>(this, "AShooterPlayerController.BPSearchForPOIs_Implementation()", a2); }

    void ClientDisplayNotificationDialog_Implementation(const FString* Message, const FString* Title, bool bIsError, bool OnOkGoToMainMenu, bool bAutoClose, bool bCanBeTop, bool bHideXBoxFooter) { NativeCall<void, const FString*, const FString*, bool, bool, bool, bool, bool>(this, "AShooterPlayerController.ClientDisplayNotificationDialog_Implementation(FString&,FString&,bool,bool,bool,bool,bool)", Message, Title, bIsError, OnOkGoToMainMenu, bAutoClose, bCanBeTop, bHideXBoxFooter); }

    void ServerRequestSetDefaultDestination_Implementation(int forSpawnPointID, int spawnPointID) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestSetDefaultDestination_Implementation(int,int)", forSpawnPointID, spawnPointID); }

    void ServerRequestTamingInfoList_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTamingInfoList_Implementation()"); }

    void ServerRequestTamingInfoList_ServerLogic() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTamingInfoList_ServerLogic()"); }

    //void ClientReceiveTamingInfoList_Implementation(const TArray<FTamingDinoInfo, TSizedDefaultAllocator<32> >* InfoList) { NativeCall<void, const TArray<FTamingDinoInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.ClientReceiveTamingInfoList_Implementation(TArray<FTamingDinoInfo,TSizedDefaultAllocator<32>>&)", InfoList); }

    void ServerRequestRemoveDinoFromTamingListByID_Implementation(int InID1, int InID2) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestRemoveDinoFromTamingListByID_Implementation(int,int)", InID1, InID2); }

    void ServerRequestRemoveDinoFromTamingListByID_ServerLogic(int InID1, int InID2) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestRemoveDinoFromTamingListByID_ServerLogic(int,int)", InID1, InID2); }

    void SetSyncTamingDinosWithoutUI(bool bShouldSync) { NativeCall<void, bool>(this, "AShooterPlayerController.SetSyncTamingDinosWithoutUI(bool)", bShouldSync); }

    //void RawSyncTamingDinoWaypoints(const TArray<FTamingDinoInfo, TSizedDefaultAllocator<32> >* TamingList, __int64 a3, bool* a4) { NativeCall<void, const TArray<FTamingDinoInfo, TSizedDefaultAllocator<32> >*, __int64, bool*>(this, "AShooterPlayerController.RawSyncTamingDinoWaypoints(TArray<FTamingDinoInfo,TSizedDefaultAllocator<32>>&)", TamingList, a3, a4); }

    //void ProcessedSyncTamingDinoWaypoints(const TMap<unsigned int, FTamingDinoInfo, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<unsigned int, FTamingDinoInfo, 0> >* TamingList) { NativeCall<void, const TMap<unsigned int, FTamingDinoInfo, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<unsigned int, FTamingDinoInfo, 0> >*>(this, "AShooterPlayerController.ProcessedSyncTamingDinoWaypoints(TMap<unsignedint,FTamingDinoInfo,FDefaultSetAllocator,TDefaultMapHashableKeyFuncs<unsignedint,FTamingDinoInfo,0>>&)", TamingList); }

    //void SetTamingWaypoints(TArray<FTamingWaypointInfo, TSizedDefaultAllocator<32> >* InWaypoints) { NativeCall<void, TArray<FTamingWaypointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.SetTamingWaypoints(TArray<FTamingWaypointInfo,TSizedDefaultAllocator<32>>)", InWaypoints); }

    void ServerRequestCustomTrackedActorList_Implementation(int CustomTameSelectionType, int DinoGroup, const FString* CustomTameSearchText, int NewScrollbarIndex, bool ClientAutoTrackTamesSetting) { NativeCall<void, int, int, const FString*, int, bool>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorList_Implementation(int,int,FString&,int,bool)", CustomTameSelectionType, DinoGroup, CustomTameSearchText, NewScrollbarIndex, ClientAutoTrackTamesSetting); }

    void ServerRequestCustomTrackedActorList_ServerLogic(int CustomTameSelectionType, int DinoGroup, const FString* CustomTameSearchText, int NewScrollbarIndex, bool ClientAutoTrackTamesSetting) { NativeCall<void, int, int, const FString*, int, bool>(this, "AShooterPlayerController.ServerRequestCustomTrackedActorList_ServerLogic(int,int,FString&,int,bool)", CustomTameSelectionType, DinoGroup, CustomTameSearchText, NewScrollbarIndex, ClientAutoTrackTamesSetting); }

    void ServerRequestUpdateTrackedWaypointsOnly_Implementation(bool ClientAutoTrackTamesSetting) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsOnly_Implementation(bool)", ClientAutoTrackTamesSetting); }

    void ServerRequestUpdateTrackedWaypointsOnly_ServerLogic(bool ClientAutoTrackTamesSetting) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsOnly_ServerLogic(bool)", ClientAutoTrackTamesSetting); }

    void ServerRequestUpdateTrackedWaypointsAndMapPlayers_Implementation(bool ClientAutoTrackTamesSetting) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsAndMapPlayers_Implementation(bool)", ClientAutoTrackTamesSetting); }

    void ServerRequestUpdateTrackedWaypointsAndMapPlayers_ServerLogic(bool ClientAutoTrackTamesSetting) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerRequestUpdateTrackedWaypointsAndMapPlayers_ServerLogic(bool)", ClientAutoTrackTamesSetting); }

    void SetCustomActorTracking_LastSavedCustomTameSearchText(const FString* CustomTameSearchText) { NativeCall<void, const FString*>(this, "AShooterPlayerController.SetCustomActorTracking_LastSavedCustomTameSearchText(FString&)", CustomTameSearchText); }

    void RefreshLocalTrackedActors(bool IsInfoFresh) { NativeCall<void, bool>(this, "AShooterPlayerController.RefreshLocalTrackedActors(bool)", IsInfoFresh); }

    void ServerAddCustomActorTrackListEntries_Players(const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerAddCustomActorTrackListEntries_Players(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    void ServerAddCustomActorTrackListEntries_Creatures(const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerAddCustomActorTrackListEntries_Creatures(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    void ServerAddCustomActorTrackListEntries_Creatures_ForcePOIVisible(const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerAddCustomActorTrackListEntries_Creatures_ForcePOIVisible(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* AddCustomActorTrackListEntries_Combined(TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* result, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh, bool IsPlayer, bool ForcePOIVisible) { return NativeCall<TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool, bool, bool>(this, "AShooterPlayerController.AddCustomActorTrackListEntries_Combined(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool,bool,bool)", result, InfoList, IsInfoFresh, IsPlayer, ForcePOIVisible); }

    void AddCustomActorTrackList_Individual(const FTrackedActorPlusInfoStruct* InfoListEntry, ETrackedActorCategory::Type Category, bool ForcePOIVisible) { NativeCall<void, const FTrackedActorPlusInfoStruct*, ETrackedActorCategory::Type, bool>(this, "AShooterPlayerController.AddCustomActorTrackList_Individual(FTrackedActorPlusInfoStruct&,ETrackedActorCategory::Type,bool)", InfoListEntry, Category, ForcePOIVisible); }

    TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* ReceiveCustomActorTrackList_Combined(TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* result, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh, bool IsPlayer) { return NativeCall<TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool, bool>(this, "AShooterPlayerController.ReceiveCustomActorTrackList_Combined(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool,bool)", result, InfoList, IsInfoFresh, IsPlayer); }

    void ClientSimpleMarkTrackedActorInfoUpdated_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientSimpleMarkTrackedActorInfoUpdated_Implementation()"); }

    void ServerRemoveCustomActorTrackListEntries_FromTotalList_TeammatePlayers(const TArray<int, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<int, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerRemoveCustomActorTrackListEntries_FromTotalList_TeammatePlayers(TArray<int,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    void ServerRemoveCustomActorTrackListEntries_FromTotalList_Creatures(const TArray<int, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<int, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerRemoveCustomActorTrackListEntries_FromTotalList_Creatures(TArray<int,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    void RemoveCustomActorTrackListEntries_FromTotalList_Combined(const TArray<int, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh, bool IsPlayer, bool teammateplayers) { NativeCall<void, const TArray<int, TSizedDefaultAllocator<32> >*, bool, bool, bool>(this, "AShooterPlayerController.RemoveCustomActorTrackListEntries_FromTotalList_Combined(TArray<int,TSizedDefaultAllocator<32>>&,bool,bool,bool)", InfoList, IsInfoFresh, IsPlayer, teammateplayers); }

    void RemoveCustomActorTrackList_Individual(int InfoListIndex, ETrackedActorCategory::Type Category) { NativeCall<void, int, ETrackedActorCategory::Type>(this, "AShooterPlayerController.RemoveCustomActorTrackList_Individual(int,ETrackedActorCategory::Type)", InfoListIndex, Category); }

    void ServerUpdateCustomActorTrackListEntries_Creatures(const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ServerUpdateCustomActorTrackListEntries_Creatures(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    void ClientUpdateCustomActorTrackListEntries_Players_Implementation(const TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ClientUpdateCustomActorTrackListEntries_Players_Implementation(TArray<FCustomTrackedActorInfo,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    void ClientUpdateCustomActorTrackListEntries_Creatures_Implementation(const TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh) { NativeCall<void, const TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, bool>(this, "AShooterPlayerController.ClientUpdateCustomActorTrackListEntries_Creatures_Implementation(TArray<FCustomTrackedActorInfo,TSizedDefaultAllocator<32>>&,bool)", InfoList, IsInfoFresh); }

    TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* UpdateCustomActorTrackListEntries_Combined(TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >* result, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >* InfoList, bool IsInfoFresh, bool IsPlayer) { return NativeCall<TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, TArray<FCustomTrackedActorInfo, TSizedDefaultAllocator<32> >*, const TArray<FTrackedActorPlusInfoStruct, TSizedDefaultAllocator<32> >*, bool, bool>(this, "AShooterPlayerController.UpdateCustomActorTrackListEntries_Combined(TArray<FTrackedActorPlusInfoStruct,TSizedDefaultAllocator<32>>&,bool,bool)", result, InfoList, IsInfoFresh, IsPlayer); }

    bool UpdateCustomActorTrackList_Individual(const FTrackedActorPlusInfoStruct* InfoListEntry, ETrackedActorCategory::Type Category) { return NativeCall<bool, const FTrackedActorPlusInfoStruct*, ETrackedActorCategory::Type>(this, "AShooterPlayerController.UpdateCustomActorTrackList_Individual(FTrackedActorPlusInfoStruct&,ETrackedActorCategory::Type)", InfoListEntry, Category); }

    FCustomTrackedActorInfo* SetFCustomTrackedPlayerInfoMembersByPlayerRef(FCustomTrackedActorInfo* result, AShooterCharacter* HandledPlayer, bool IsFavorited, bool IsATeammateOnMap, bool bIsTrackedWaypoint, bool bIsValidForCurrentFilter) { return NativeCall<FCustomTrackedActorInfo*, FCustomTrackedActorInfo*, AShooterCharacter*, bool, bool, bool, bool>(this, "AShooterPlayerController.SetFCustomTrackedPlayerInfoMembersByPlayerRef(AShooterCharacter*,bool,bool,bool,bool)", result, HandledPlayer, IsFavorited, IsATeammateOnMap, bIsTrackedWaypoint, bIsValidForCurrentFilter); }

    void SetSyncTrackedActorsWithoutUI(bool bShouldSync, int CustomTameSelectionType, int DinoGroup, const FString* CustomTameSearchText, int NewScrollbarIndex) { NativeCall<void, bool, int, int, const FString*, int>(this, "AShooterPlayerController.SetSyncTrackedActorsWithoutUI(bool,int,int,FString&,int)", bShouldSync, CustomTameSelectionType, DinoGroup, CustomTameSearchText, NewScrollbarIndex); }

    void ClientRequestNewTrackInfoFromServer(bool FromUI, int CustomTameSelectionType, int DinoGroup, const FString* CustomTameSearchText, int NewScrollbarIndex) { NativeCall<void, bool, int, int, const FString*, int>(this, "AShooterPlayerController.ClientRequestNewTrackInfoFromServer(bool,int,int,FString&,int)", FromUI, CustomTameSelectionType, DinoGroup, CustomTameSearchText, NewScrollbarIndex); }

    void ClientRequestNewTrackInfoFromServer_TimerRestriction(int CustomTameSelectionType, int DinoGroup, const FString* CustomTameSearchText, int NewScrollbarIndex) { NativeCall<void, int, int, const FString*, int>(this, "AShooterPlayerController.ClientRequestNewTrackInfoFromServer_TimerRestriction(int,int,FString&,int)", CustomTameSelectionType, DinoGroup, CustomTameSearchText, NewScrollbarIndex); }

    void ProcessedSyncTrackedActorWaypoints() { NativeCall<void>(this, "AShooterPlayerController.ProcessedSyncTrackedActorWaypoints()"); }

    void SetTrackedActorWaypoints(TArray<FTrackedActorWaypointInfo, TSizedDefaultAllocator<32> >* InWaypoints) { NativeCall<void, TArray<FTrackedActorWaypointInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.SetTrackedActorWaypoints(TArray<FTrackedActorWaypointInfo,TSizedDefaultAllocator<32>>)", InWaypoints); }

    void OnRecievedUpdatedCachedTeamTameList(bool IsInfoFresh, int DesiredIndexOfWidgetThatShouldHaveItsCreatureReturned) { NativeCall<void, bool, int>(this, "AShooterPlayerController.OnRecievedUpdatedCachedTeamTameList(bool,int)", IsInfoFresh, DesiredIndexOfWidgetThatShouldHaveItsCreatureReturned); }

    void ServerUntrackAllActors_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerUntrackAllActors_Implementation()"); }

    void ServerSetActiveWaypointTrackedPlayerViaCharacterIndex_Implementation(int TrackedPlayerIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedPlayerViaCharacterIndex_Implementation(int,bool)", TrackedPlayerIndex, ShouldMarkActive); }

    void ServerSetActiveWaypointTrackedCreatureViaCharacterIndex_Implementation(int TrackedCreatureIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedCreatureViaCharacterIndex_Implementation(int,bool)", TrackedCreatureIndex, ShouldMarkActive); }

    void ServerSetActiveWaypointTrackedActorViaCharacterIndex_Combined(int Index, bool ShouldMarkActive, bool IsPlayer) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerController.ServerSetActiveWaypointTrackedActorViaCharacterIndex_Combined(int,bool,bool)", Index, ShouldMarkActive, IsPlayer); }

    void ServerTogglePOIVisibilityForTrackedPlayerWaypoint_Implementation(int TrackedPlayerIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedPlayerWaypoint_Implementation(int,bool)", TrackedPlayerIndex, ShouldMarkActive); }

    void ServerTogglePOIVisibilityForTrackedCreatureWaypoint_Implementation(int TrackedCreatureIndex, bool ShouldMarkActive) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedCreatureWaypoint_Implementation(int,bool)", TrackedCreatureIndex, ShouldMarkActive); }

    void ServerTogglePOIVisibilityForTrackedActorWaypoint_Combined(int Index, bool ShouldMarkActive, bool IsPlayer, bool bDoToggle) { NativeCall<void, int, bool, bool, bool>(this, "AShooterPlayerController.ServerTogglePOIVisibilityForTrackedActorWaypoint_Combined(int,bool,bool,bool)", Index, ShouldMarkActive, IsPlayer, bDoToggle); }

    void ServerClearPOIVisibilityForAllActors_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerClearPOIVisibilityForAllActors_Implementation()"); }

    void ServerClearPOIVisibilityForAllActors_ServerLogic() { NativeCall<void>(this, "AShooterPlayerController.ServerClearPOIVisibilityForAllActors_ServerLogic()"); }

    void MarkDinoListEntryWidgetFavoritePlayer_Implementation(int ID) { NativeCall<void, int>(this, "AShooterPlayerController.MarkDinoListEntryWidgetFavoritePlayer_Implementation(int)", ID); }

    void MarkDinoListEntryWidgetFavoriteCreature_Implementation(int ID) { NativeCall<void, int>(this, "AShooterPlayerController.MarkDinoListEntryWidgetFavoriteCreature_Implementation(int)", ID); }

    void MarkDinoListEntryWidgetFavoriteCombined(int ID, bool IsPlayer) { NativeCall<void, int, bool>(this, "AShooterPlayerController.MarkDinoListEntryWidgetFavoriteCombined(int,bool)", ID, IsPlayer); }

    void ServerSetFavoriteTrackedPlayerViaCharacterIndex_Implementation(int TrackedPlayerIndex, bool ShouldFavorite) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetFavoriteTrackedPlayerViaCharacterIndex_Implementation(int,bool)", TrackedPlayerIndex, ShouldFavorite); }

    void ServerSetFavoriteTrackedCreatureViaCharacterIndex_Implementation(int TrackedCreatureIsendex, bool ShouldFavorite) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetFavoriteTrackedCreatureViaCharacterIndex_Implementation(int,bool)", TrackedCreatureIsendex, ShouldFavorite); }

    void ServerSetFavoriteTrackedActorViaCharacterIndex_Combined(int Index, bool ShouldFavorite, bool IsPlayer) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerController.ServerSetFavoriteTrackedActorViaCharacterIndex_Combined(int,bool,bool)", Index, ShouldFavorite, IsPlayer); }

    void RefreshDinoTrackInfo() { NativeCall<void>(this, "AShooterPlayerController.RefreshDinoTrackInfo()"); }

    int FindGetTrackedActorFavoritedIndex(int PlayerID, TEnumAsByte<ETrackedActorCategory::Type> PlayerCategory) { return NativeCall<int, int, TEnumAsByte<ETrackedActorCategory::Type>>(this, "AShooterPlayerController.FindGetTrackedActorFavoritedIndex(int,TEnumAsByte<ETrackedActorCategory::Type>)", PlayerID, PlayerCategory); }

    int FindGetTrackedActorWaypointIndex(int PlayerID, TEnumAsByte<ETrackedActorCategory::Type> PlayerCategory) { return NativeCall<int, int, TEnumAsByte<ETrackedActorCategory::Type>>(this, "AShooterPlayerController.FindGetTrackedActorWaypointIndex(int,TEnumAsByte<ETrackedActorCategory::Type>)", PlayerID, PlayerCategory); }

    void TellServerAboutNewAutoTrackSetting_Implementation(bool SelectedAutotrack) { NativeCall<void, bool>(this, "AShooterPlayerController.TellServerAboutNewAutoTrackSetting_Implementation(bool)", SelectedAutotrack); }

    void TellServerAboutNewAutoTrackSetting_ServerLogic(bool SelectedAutotrack) { NativeCall<void, bool>(this, "AShooterPlayerController.TellServerAboutNewAutoTrackSetting_ServerLogic(bool)", SelectedAutotrack); }

    void SpawnTestDinos(int NumDinos, float Spacing, int DinoArrayIndex, int NumDinoTypes) { NativeCall<void, int, float, int, int>(this, "AShooterPlayerController.SpawnTestDinos(int,float,int,int)", NumDinos, Spacing, DinoArrayIndex, NumDinoTypes); }

    void SpawnTestStructures(int NumStructures, float Spacing, int StructureArrayIndex, int NumStructureTypes) { NativeCall<void, int, float, int, int>(this, "AShooterPlayerController.SpawnTestStructures(int,float,int,int)", NumStructures, Spacing, StructureArrayIndex, NumStructureTypes); }

    void JoinVoiceChannel_Implementation(const FString* InChannelName, const FString* InChannelCredentials) { NativeCall<void, const FString*, const FString*>(this, "AShooterPlayerController.JoinVoiceChannel_Implementation(FString&,FString&)", InChannelName, InChannelCredentials); }

    void TickVoiceChatClientInfo() { NativeCall<void>(this, "AShooterPlayerController.TickVoiceChatClientInfo()"); }

    void DisconnectVoiceUser(bool bRelease) { NativeCall<void, bool>(this, "AShooterPlayerController.DisconnectVoiceUser(bool)", bRelease); }

    void Server_JoinVoiceChannel_Internal(const FString* VoiceSessionName, const FString* ServerName) { NativeCall<void, const FString*, const FString*>(this, "AShooterPlayerController.Server_JoinVoiceChannel_Internal(FString&,FString&)", VoiceSessionName, ServerName); }

    void Server_JoinTribeAndAllianceVoiceChannel() { NativeCall<void>(this, "AShooterPlayerController.Server_JoinTribeAndAllianceVoiceChannel()"); }

    void Server_SelectAndJoinVoiceChannel_Implementation(int VoiceFilterType) { NativeCall<void, int>(this, "AShooterPlayerController.Server_SelectAndJoinVoiceChannel_Implementation(int)", VoiceFilterType); }

    void Server_SendBlockListFromClient_Implementation(const TArray<FString, TSizedDefaultAllocator<32> >* BlockedEOSUserIds) { NativeCall<void, const TArray<FString, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.Server_SendBlockListFromClient_Implementation(TArray<FString,TSizedDefaultAllocator<32>>&)", BlockedEOSUserIds); }

    void Client_RecieveBlockedUserIdsFromServer_Implementation(const TArray<unsigned int, TSizedDefaultAllocator<32> >* BlockedUserIds) { NativeCall<void, const TArray<unsigned int, TSizedDefaultAllocator<32> >*>(this, "AShooterPlayerController.Client_RecieveBlockedUserIdsFromServer_Implementation(TArray<unsignedint,TSizedDefaultAllocator<32>>&)", BlockedUserIds); }

    void ServerCheckIfWildDinoChildCanBeImprinted_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerCheckIfWildDinoChildCanBeImprinted_Implementation()"); }

    void ServerCheckIfWildDinoChildCanBeImprinted_ServerLogic() { NativeCall<void>(this, "AShooterPlayerController.ServerCheckIfWildDinoChildCanBeImprinted_ServerLogic()"); }

    //void SetInputMode(const FInputModeDataBase* InData) { NativeCall<void, const FInputModeDataBase*>(this, "AShooterPlayerController.SetInputMode(FInputModeDataBase&)", InData); }

    void FinishInputBlockingTimeout() { NativeCall<void>(this, "AShooterPlayerController.FinishInputBlockingTimeout()"); }

    bool ShouldBlockGameInputsForUI() { return NativeCall<bool>(this, "AShooterPlayerController.ShouldBlockGameInputsForUI()"); }

    void ServerSetSlomoRateFromSpectator_Implementation(float Rate) { NativeCall<void, float>(this, "AShooterPlayerController.ServerSetSlomoRateFromSpectator_Implementation(float)", Rate); }

    void ClientUpdateMyPlayerDataStruct_Implementation(FPrimalPlayerDataStruct* NetMyPlayerDataStruct) { NativeCall<void, FPrimalPlayerDataStruct*>(this, "AShooterPlayerController.ClientUpdateMyPlayerDataStruct_Implementation(FPrimalPlayerDataStruct)", NetMyPlayerDataStruct); }

    void HarvestedElement(FAttachedInstancedHarvestingElement* Element, bool bGaveResources, bool bDamagedInstigator) { NativeCall<void, FAttachedInstancedHarvestingElement*, bool, bool>(this, "AShooterPlayerController.HarvestedElement(FAttachedInstancedHarvestingElement*,bool,bool)", Element, bGaveResources, bDamagedInstigator); }

    void ResetCameraMode() { NativeCall<void>(this, "AShooterPlayerController.ResetCameraMode()"); }

    void IsTargetSleeping() { NativeCall<void>(this, "AShooterPlayerController.IsTargetSleeping()"); }

    //bool InputKey(const FInputKeyParams* Params) { return NativeCall<bool, const FInputKeyParams*>(this, "AShooterPlayerController.InputKey(FInputKeyParams&)", Params); }

    FString* GetDisplayedNameForPlayer(FString* result, unsigned int playerID, FString* playerName, bool* blocked) { return NativeCall<FString*, FString*, unsigned int, FString*, bool*>(this, "AShooterPlayerController.GetDisplayedNameForPlayer(unsignedint,FString,bool&)", result, playerID, playerName, blocked); }

    FString* GetPlatformNameFromId(FString* result, unsigned int Id) { return NativeCall<FString*, FString*, unsigned int>(this, "AShooterPlayerController.GetPlatformNameFromId(unsignedint)", result, Id); }

    void Server_GetPlatformNameFromId_Implementation(unsigned int Id) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.Server_GetPlatformNameFromId_Implementation(unsignedint)", Id); }

    void Client_GetPlatformNameFromId_Implementation(unsigned int Id, const FString* PlatformName) { NativeCall<void, unsigned int, const FString*>(this, "AShooterPlayerController.Client_GetPlatformNameFromId_Implementation(unsignedint,FString&)", Id, PlatformName); }

    void PlayReconnectSound() { NativeCall<void>(this, "AShooterPlayerController.PlayReconnectSound()"); }

    FVector* GetViewLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterPlayerController.GetViewLocation()", result); }

    //void OnSelectOrderGroup<0>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<0>()"); }

    //void OnSelectOrderGroup<1>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<1>()"); }

    //void OnSelectOrderGroup<2>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<2>()"); }

    //void OnSelectOrderGroup<3>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<3>()"); }

    //void OnSelectOrderGroup<4>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<4>()"); }

    //void OnSelectOrderGroup<5>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<5>()"); }

    //void OnSelectOrderGroup<6>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<6>()"); }

    //void OnSelectOrderGroup<7>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<7>()"); }

    //void OnSelectOrderGroup<8>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<8>()"); }

    //void OnSelectOrderGroup<9>() { NativeCall<void>(this, "AShooterPlayerController.OnSelectOrderGroup<9>()"); }

    //void OnUseItemSlot<0>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<0>()"); }

    //void OnUseItemSlot<1>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<1>()"); }

    //void OnUseItemSlot<2>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<2>()"); }

    //void OnUseItemSlot<3>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<3>()"); }

    //void OnUseItemSlot<4>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<4>()"); }

    //void OnUseItemSlot<5>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<5>()"); }

    //void OnUseItemSlot<6>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<6>()"); }

    //void OnUseItemSlot<7>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<7>()"); }

    //void OnUseItemSlot<8>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<8>()"); }

    //void OnUseItemSlot<9>() { NativeCall<void>(this, "AShooterPlayerController.OnUseItemSlot<9>()"); }

    //void OnReleaseItemSlot<0>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<0>()"); }

    //void OnReleaseItemSlot<1>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<1>()"); }

    //void OnReleaseItemSlot<2>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<2>()"); }

    //void OnReleaseItemSlot<3>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<3>()"); }

    //void OnReleaseItemSlot<4>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<4>()"); }

    //void OnReleaseItemSlot<5>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<5>()"); }

    //void OnReleaseItemSlot<6>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<6>()"); }

    //void OnReleaseItemSlot<7>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<7>()"); }

    //void OnReleaseItemSlot<8>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<8>()"); }

    //void OnReleaseItemSlot<9>() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseItemSlot<9>()"); }

};


struct APawn : AActor

{

    // Fields


    float& BaseEyeHeightField() { return *GetNativePointerField<float*>(this, "APawn.BaseEyeHeight"); }

    FieldArray<char, 1> AutoPossessAIField() { return { this, "APawn.AutoPossessAI" }; }

    TSubclassOf<AController>& AIControllerClassField() { return *GetNativePointerField<TSubclassOf<AController>*>(this, "APawn.AIControllerClass"); }

    TObjectPtr<APlayerState>& PlayerStateField() { return *GetNativePointerField<TObjectPtr<APlayerState>*>(this, "APawn.PlayerState"); }

    float& BlendedReplayViewPitchField() { return *GetNativePointerField<float*>(this, "APawn.BlendedReplayViewPitch"); }

    TObjectPtr<AController>& LastHitByField() { return *GetNativePointerField<TObjectPtr<AController>*>(this, "APawn.LastHitBy"); }

    TObjectPtr<AController>& ControllerField() { return *GetNativePointerField<TObjectPtr<AController>*>(this, "APawn.Controller"); }

    TObjectPtr<AController>& PreviousControllerField() { return *GetNativePointerField<TObjectPtr<AController>*>(this, "APawn.PreviousController"); }

    float& AllowedYawErrorField() { return *GetNativePointerField<float*>(this, "APawn.AllowedYawError"); }

    //FPawnRestartedSignature& ReceiveRestartedDelegateField() { return *GetNativePointerField<FPawnRestartedSignature*>(this, "APawn.ReceiveRestartedDelegate"); }

    UE::Math::TVector<double>& ControlInputVectorField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APawn.ControlInputVector"); }

    UE::Math::TVector<double>& LastControlInputVectorField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APawn.LastControlInputVector"); }

    TSubclassOf<UInputComponent>& OverrideInputComponentClassField() { return *GetNativePointerField<TSubclassOf<UInputComponent>*>(this, "APawn.OverrideInputComponentClass"); }

    //FMovementTetherEvent& OnMovementTetherSetField() { return *GetNativePointerField<FMovementTetherEvent*>(this, "APawn.OnMovementTetherSet"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bUseControllerRotationPitch() { return { this, "APawn.bUseControllerRotationPitch" }; }

    BitFieldValue<bool, unsigned __int32> bUseControllerRotationYaw() { return { this, "APawn.bUseControllerRotationYaw" }; }

    BitFieldValue<bool, unsigned __int32> bUseControllerRotationRoll() { return { this, "APawn.bUseControllerRotationRoll" }; }

    BitFieldValue<bool, unsigned __int32> bCanAffectNavigationGeneration() { return { this, "APawn.bCanAffectNavigationGeneration" }; }

    BitFieldValue<bool, unsigned __int32> bForceUseCustomCameraComponent() { return { this, "APawn.bForceUseCustomCameraComponent" }; }

    BitFieldValue<bool, unsigned __int32> bDisableControllerDesiredRotation() { return { this, "APawn.bDisableControllerDesiredRotation" }; }

    BitFieldValue<bool, unsigned __int32> bInputEnabled() { return { this, "APawn.bInputEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bProcessingOutsideWorldBounds() { return { this, "APawn.bProcessingOutsideWorldBounds" }; }

    BitFieldValue<bool, unsigned __int32> bIsLocalViewTarget() { return { this, "APawn.bIsLocalViewTarget" }; }


    // Functions


    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "APawn.GetPrivateStaticClass()"); }

    bool IsPawnControlled() { return NativeCall<bool>(this, "APawn.IsPawnControlled()"); }

    AShooterPlayerState* GetPlayerState() { return NativeCall<AShooterPlayerState*>(this, "APawn.GetPlayerState<class AShooterPlayerState>()"); }

    void PostLoad() { NativeCall<void>(this, "APawn.PostLoad()"); }

    void BeginPlay() { NativeCall<void>(this, "APawn.BeginPlay()"); }

    void GetMoveGoalReachTest(const AActor* MovingActor, const UE::Math::TVector<double>* MoveOffset, UE::Math::TVector<double>* GoalOffset, float* GoalRadius, float* GoalHalfHeight) { NativeCall<void, const AActor*, const UE::Math::TVector<double>*, UE::Math::TVector<double>*, float*, float*>(this, "APawn.GetMoveGoalReachTest(AActor*,UE::Math::TVector<double>&,UE::Math::TVector<double>&,float&,float&)", MovingActor, MoveOffset, GoalOffset, GoalRadius, GoalHalfHeight); }

    static void StaticRegisterNativesAPawn() { NativeCall<void>(nullptr, "APawn.StaticRegisterNativesAPawn()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "APawn.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void PreInitializeComponents() { NativeCall<void>(this, "APawn.PreInitializeComponents()"); }

    void PostInitializeComponents() { NativeCall<void>(this, "APawn.PostInitializeComponents()"); }

    void PostRegisterAllComponents() { NativeCall<void>(this, "APawn.PostRegisterAllComponents()"); }

    UPawnMovementComponent* GetMovementComponent() { return NativeCall<UPawnMovementComponent*>(this, "APawn.GetMovementComponent()"); }

    void UpdateNavAgent() { NativeCall<void>(this, "APawn.UpdateNavAgent()"); }

    void SetCanAffectNavigationGeneration(bool bNewValue, bool bForceUpdate) { NativeCall<void, bool, bool>(this, "APawn.SetCanAffectNavigationGeneration(bool,bool)", bNewValue, bForceUpdate); }

    bool CanBeBaseForCharacter(APawn* Pawn) { return NativeCall<bool, APawn*>(this, "APawn.CanBeBaseForCharacter(APawn*)", Pawn); }

    bool IsLocallyControlled() { return NativeCall<bool>(this, "APawn.IsLocallyControlled()"); }

    bool IsPlayerControlled() { return NativeCall<bool>(this, "APawn.IsPlayerControlled()"); }

    bool IsBotControlled() { return NativeCall<bool>(this, "APawn.IsBotControlled()"); }

    bool ReachedDesiredRotation() { return NativeCall<bool>(this, "APawn.ReachedDesiredRotation()"); }

    float GetDefaultHalfHeight() { return NativeCall<float>(this, "APawn.GetDefaultHalfHeight()"); }

    //UPawnNoiseEmitterComponent* GetPawnNoiseEmitterComponent() { return NativeCall<UPawnNoiseEmitterComponent*>(this, "APawn.GetPawnNoiseEmitterComponent()"); }

    bool ShouldTickIfViewportsOnly() { return NativeCall<bool>(this, "APawn.ShouldTickIfViewportsOnly()"); }

    void SpawnDefaultController() { NativeCall<void>(this, "APawn.SpawnDefaultController()"); }

    void TurnOff() { NativeCall<void>(this, "APawn.TurnOff()"); }

    void BecomeViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "APawn.BecomeViewTarget(APlayerController*)", PC); }

    void EndViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "APawn.EndViewTarget(APlayerController*)", PC); }

    APlayerController* GetLocalViewingPlayerController() { return NativeCall<APlayerController*>(this, "APawn.GetLocalViewingPlayerController()"); }

    void PawnClientRestart() { NativeCall<void>(this, "APawn.PawnClientRestart()"); }

    void NotifyRestarted() { NativeCall<void>(this, "APawn.NotifyRestarted()"); }

    void Destroyed() { NativeCall<void>(this, "APawn.Destroyed()"); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "APawn.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    bool ShouldTakeDamage(float Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<bool, float, const FDamageEvent*, AController*, AActor*>(this, "APawn.ShouldTakeDamage(float,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    float TakeDamage(float Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, const FDamageEvent*, AController*, AActor*>(this, "APawn.TakeDamage(float,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    void OnRep_Controller() { NativeCall<void>(this, "APawn.OnRep_Controller()"); }

    void PossessedBy(AController* NewController) { NativeCall<void, AController*>(this, "APawn.PossessedBy(AController*)", NewController); }

    void UnPossessed() { NativeCall<void>(this, "APawn.UnPossessed()"); }

    void NotifyControllerChanged() { NativeCall<void>(this, "APawn.NotifyControllerChanged()"); }

    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "APawn.GetNetConnection()"); }

    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "APawn.GetNetOwningPlayer()"); }

    UInputComponent* CreatePlayerInputComponent() { return NativeCall<UInputComponent*>(this, "APawn.CreatePlayerInputComponent()"); }

    void DestroyPlayerInputComponent() { NativeCall<void>(this, "APawn.DestroyPlayerInputComponent()"); }

    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "APawn.IsMoveInputIgnored()"); }

    void AddMovementInput(UE::Math::TVector<double>* WorldDirection, float ScaleValue, bool bForce) { NativeCall<void, UE::Math::TVector<double>*, float, bool>(this, "APawn.AddMovementInput(UE::Math::TVector<double>,float,bool)", WorldDirection, ScaleValue, bForce); }

    void AddControllerPitchInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerPitchInput(float)", Val); }

    void AddControllerYawInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerYawInput(float)", Val); }

    void AddControllerRollInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerRollInput(float)", Val); }

    void Restart() { NativeCall<void>(this, "APawn.Restart()"); }

    APhysicsVolume* GetPawnPhysicsVolume() { return NativeCall<APhysicsVolume*>(this, "APawn.GetPawnPhysicsVolume()"); }

    APhysicsVolume* GetPhysicsVolume() { return NativeCall<APhysicsVolume*>(this, "APawn.GetPhysicsVolume()"); }

    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "APawn.RecalculateBaseEyeHeight()"); }

    void Reset() { NativeCall<void>(this, "APawn.Reset()"); }

    FString* GetHumanReadableName(FString* result) { return NativeCall<FString*, FString*>(this, "APawn.GetHumanReadableName()", result); }

    void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo* DebugDisplay, float* YL, float* YPos) { NativeCall<void, UCanvas*, const FDebugDisplayInfo*, float*, float*>(this, "APawn.DisplayDebug(UCanvas*,FDebugDisplayInfo&,float&,float&)", Canvas, DebugDisplay, YL, YPos); }

    void GetActorEyesViewPoint(UE::Math::TVector<double>* out_Location, UE::Math::TRotator<double>* out_Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "APawn.GetActorEyesViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", out_Location, out_Rotation); }

    bool InFreeCam() { return NativeCall<bool>(this, "APawn.InFreeCam()"); }

    void OutsideWorldBounds() { NativeCall<void>(this, "APawn.OutsideWorldBounds()"); }

    void FaceRotation(UE::Math::TRotator<double>* NewControlRotation, float DeltaTime) { NativeCall<void, UE::Math::TRotator<double>*, float>(this, "APawn.FaceRotation(UE::Math::TRotator<double>,float)", NewControlRotation, DeltaTime); }

    void DetachFromControllerPendingDestroy() { NativeCall<void>(this, "APawn.DetachFromControllerPendingDestroy()"); }

    AController* GetDamageInstigator(AController* InstigatedBy, const UDamageType* DamageType) { return NativeCall<AController*, AController*, const UDamageType*>(this, "APawn.GetDamageInstigator(AController*,UDamageType&)", InstigatedBy, DamageType); }

    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APawn.EnableInput(APlayerController*)", PlayerController); }

    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APawn.DisableInput(APlayerController*)", PlayerController); }

    void TeleportSucceeded(bool bIsATest, bool bSimpleTeleport) { NativeCall<void, bool, bool>(this, "APawn.TeleportSucceeded(bool,bool)", bIsATest, bSimpleTeleport); }

    void PostNetReceiveVelocity(const UE::Math::TVector<double>* NewVelocity) { NativeCall<void, const UE::Math::TVector<double>*>(this, "APawn.PostNetReceiveVelocity(UE::Math::TVector<double>&)", NewVelocity); }

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "APawn.PostNetReceiveLocationAndRotation()"); }

    bool IsBasedOnActor(const AActor* Other) { return NativeCall<bool, const AActor*>(this, "APawn.IsBasedOnActor(AActor*)", Other); }

    bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const UE::Math::TVector<double>* SrcLocation) { return NativeCall<bool, const AActor*, const AActor*, const UE::Math::TVector<double>*>(this, "APawn.IsNetRelevantFor(AActor*,AActor*,UE::Math::TVector<double>&)", RealViewer, ViewTarget, SrcLocation); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "APawn.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    void PreReplication(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "APawn.PreReplication(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    const FNavAgentProperties* GetNavAgentPropertiesRef() { return NativeCall<const FNavAgentProperties*>(this, "APawn.GetNavAgentPropertiesRef()"); }

    FVector* GetPawnViewLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APawn.GetPawnViewLocation()", result); }

};


struct APrimalPawn : APawn

{

    // Fields


    FRotator_NetQuantizeSmartPitch& LastMovementDesiredRotationField() { return *GetNativePointerField<FRotator_NetQuantizeSmartPitch*>(this, "APrimalPawn.LastMovementDesiredRotation"); }

    float& HarvestingDestructionMeshRangeMultiplerField() { return *GetNativePointerField<float*>(this, "APrimalPawn.HarvestingDestructionMeshRangeMultipler"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bUseBPPreventMovementMode() { return { this, "APrimalPawn.bUseBPPreventMovementMode" }; }

    BitFieldValue<bool, unsigned __int32> bReplicateDesiredRotation() { return { this, "APrimalPawn.bReplicateDesiredRotation" }; }

    BitFieldValue<bool, unsigned __int32> bIsPlayingTurningAnim() { return { this, "APrimalPawn.bIsPlayingTurningAnim" }; }

    BitFieldValue<bool, unsigned __int32> bClearOnConsume() { return { this, "APrimalPawn.bClearOnConsume" }; }

    BitFieldValue<bool, unsigned __int32> bUse_ModifySavedMoveAcceleration_PreRep() { return { this, "APrimalPawn.bUse_ModifySavedMoveAcceleration_PreRep" }; }

    BitFieldValue<bool, unsigned __int32> bUse_ModifySavedMoveAcceleration_PostRep() { return { this, "APrimalPawn.bUse_ModifySavedMoveAcceleration_PostRep" }; }

    BitFieldValue<bool, unsigned __int32> bSetDefaultMovementMode() { return { this, "APrimalPawn.bSetDefaultMovementMode" }; }


    // Functions


    AController* GetCharacterController() { return NativeCall<AController*>(this, "APrimalPawn.GetCharacterController()"); }

    void SetLastMovementDesiredRotation(const UE::Math::TRotator<double>* InRotation) { NativeCall<void, const UE::Math::TRotator<double>*>(this, "APrimalPawn.SetLastMovementDesiredRotation(UE::Math::TRotator<double>&)", InRotation); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalPawn.StaticClass()"); }

    void InterceptInputEvent(const FString* InputName) { NativeCall<void, const FString*>(this, "APrimalPawn.InterceptInputEvent(FString&)", InputName); }

    static void StaticRegisterNativesAPrimalPawn() { NativeCall<void>(nullptr, "APrimalPawn.StaticRegisterNativesAPrimalPawn()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "APrimalPawn.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "APrimalPawn.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    bool AllowMovementMode(EMovementMode NewMovementMode, unsigned __int8 NewCustomMode) { return NativeCall<bool, EMovementMode, unsigned __int8>(this, "APrimalPawn.AllowMovementMode(EMovementMode,unsignedchar)", NewMovementMode, NewCustomMode); }

    bool PreventMovementMode(EMovementMode NewMovementMode, unsigned __int8 NewCustomMode) { return NativeCall<bool, EMovementMode, unsigned __int8>(this, "APrimalPawn.PreventMovementMode(EMovementMode,unsignedchar)", NewMovementMode, NewCustomMode); }

    APlayerController* GetOwnerController() { return NativeCall<APlayerController*>(this, "APrimalPawn.GetOwnerController()"); }

    bool IsLocallyControlledByPlayer() { return NativeCall<bool>(this, "APrimalPawn.IsLocallyControlledByPlayer()"); }

    void InitInputComponent() { NativeCall<void>(this, "APrimalPawn.InitInputComponent()"); }

};


struct ACharacter : APrimalPawn

{

    // Fields


    TObjectPtr<USkeletalMeshComponent>& MeshField() { return *GetNativePointerField<TObjectPtr<USkeletalMeshComponent>*>(this, "ACharacter.Mesh"); }

    TObjectPtr<UCharacterMovementComponent>& CharacterMovementField() { return *GetNativePointerField<TObjectPtr<UCharacterMovementComponent>*>(this, "ACharacter.CharacterMovement"); }

    TObjectPtr<UCapsuleComponent>& CapsuleComponentField() { return *GetNativePointerField<TObjectPtr<UCapsuleComponent>*>(this, "ACharacter.CapsuleComponent"); }

    FBasedMovementInfo& BasedMovementField() { return *GetNativePointerField<FBasedMovementInfo*>(this, "ACharacter.BasedMovement"); }

    FReplicatedBasedMovementInfo& ReplicatedBasedMovementField() { return *GetNativePointerField<FReplicatedBasedMovementInfo*>(this, "ACharacter.ReplicatedBasedMovement"); }

    float& AnimRootMotionTranslationScaleField() { return *GetNativePointerField<float*>(this, "ACharacter.AnimRootMotionTranslationScale"); }

    UE::Math::TVector<double>& BaseTranslationOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "ACharacter.BaseTranslationOffset"); }

    UE::Math::TQuat<double>& BaseRotationOffsetField() { return *GetNativePointerField<UE::Math::TQuat<double>*>(this, "ACharacter.BaseRotationOffset"); }

    long double& ReplicatedServerLastTransformUpdateTimeStampField() { return *GetNativePointerField<long double*>(this, "ACharacter.ReplicatedServerLastTransformUpdateTimeStamp"); }

    float& ReplayLastTransformUpdateTimeStampField() { return *GetNativePointerField<float*>(this, "ACharacter.ReplayLastTransformUpdateTimeStamp"); }

    bool& bInBaseReplicationField() { return *GetNativePointerField<bool*>(this, "ACharacter.bInBaseReplication"); }

    float& CrouchedEyeHeightField() { return *GetNativePointerField<float*>(this, "ACharacter.CrouchedEyeHeight"); }

    float& JumpKeyHoldTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.JumpKeyHoldTime"); }

    float& JumpOfWaterKeyHoldTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.JumpOfWaterKeyHoldTime"); }

    float& JumpForceTimeRemainingField() { return *GetNativePointerField<float*>(this, "ACharacter.JumpForceTimeRemaining"); }

    float& ProxyJumpForceStartedTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.ProxyJumpForceStartedTime"); }

    float& JumpMaxHoldTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.JumpMaxHoldTime"); }

    int& JumpMaxCountField() { return *GetNativePointerField<int*>(this, "ACharacter.JumpMaxCount"); }

    int& JumpCurrentCountField() { return *GetNativePointerField<int*>(this, "ACharacter.JumpCurrentCount"); }

    int& JumpCurrentCountPreJumpField() { return *GetNativePointerField<int*>(this, "ACharacter.JumpCurrentCountPreJump"); }

    unsigned int& NumActorOverlapEventsCounterField() { return *GetNativePointerField<unsigned int*>(this, "ACharacter.NumActorOverlapEventsCounter"); }

    FCharacterReachedApexSignature& OnReachedJumpApexField() { return *GetNativePointerField<FCharacterReachedApexSignature*>(this, "ACharacter.OnReachedJumpApex"); }

    FLandedSignature& LandedDelegateField() { return *GetNativePointerField<FLandedSignature*>(this, "ACharacter.LandedDelegate"); }

    FMovementModeChangedSignature& MovementModeChangedDelegateField() { return *GetNativePointerField<FMovementModeChangedSignature*>(this, "ACharacter.MovementModeChangedDelegate"); }

    FCharacterMovementUpdatedSignature& OnCharacterMovementUpdatedField() { return *GetNativePointerField<FCharacterMovementUpdatedSignature*>(this, "ACharacter.OnCharacterMovementUpdated"); }

    FRootMotionSourceGroup& SavedRootMotionField() { return *GetNativePointerField<FRootMotionSourceGroup*>(this, "ACharacter.SavedRootMotion"); }

    FRootMotionMovementParams& ClientRootMotionParamsField() { return *GetNativePointerField<FRootMotionMovementParams*>(this, "ACharacter.ClientRootMotionParams"); }

    TArray<FSimulatedRootMotionReplicatedMove, TSizedDefaultAllocator<32> >& RootMotionRepMovesField() { return *GetNativePointerField<TArray<FSimulatedRootMotionReplicatedMove, TSizedDefaultAllocator<32> >*>(this, "ACharacter.RootMotionRepMoves"); }

    FRepRootMotionMontage& RepRootMotionField() { return *GetNativePointerField<FRepRootMotionMontage*>(this, "ACharacter.RepRootMotion"); }

    long double& LeftDynamicActorBaseTimeField() { return *GetNativePointerField<long double*>(this, "ACharacter.LeftDynamicActorBaseTime"); }

    long double& LastClientForceUpdateMovementTimeField() { return *GetNativePointerField<long double*>(this, "ACharacter.LastClientForceUpdateMovementTime"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bIsCrouched() { return { this, "ACharacter.bIsCrouched" }; }

    BitFieldValue<bool, unsigned __int32> bProxyIsJumpForceApplied() { return { this, "ACharacter.bProxyIsJumpForceApplied" }; }

    BitFieldValue<bool, unsigned __int32> bCurrentlyUpdatingRootMotion() { return { this, "ACharacter.bCurrentlyUpdatingRootMotion" }; }

    BitFieldValue<bool, unsigned __int32> bPressedJump() { return { this, "ACharacter.bPressedJump" }; }

    BitFieldValue<bool, unsigned __int32> bClientUpdating() { return { this, "ACharacter.bClientUpdating" }; }

    BitFieldValue<bool, unsigned __int32> bClientWasFalling() { return { this, "ACharacter.bClientWasFalling" }; }

    BitFieldValue<bool, unsigned __int32> bClientResimulateRootMotion() { return { this, "ACharacter.bClientResimulateRootMotion" }; }

    BitFieldValue<bool, unsigned __int32> bClientResimulateRootMotionSources() { return { this, "ACharacter.bClientResimulateRootMotionSources" }; }

    BitFieldValue<bool, unsigned __int32> bSimGravityDisabled() { return { this, "ACharacter.bSimGravityDisabled" }; }

    BitFieldValue<bool, unsigned __int32> bClientCheckEncroachmentOnNetUpdate() { return { this, "ACharacter.bClientCheckEncroachmentOnNetUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bServerMoveIgnoreRootMotion() { return { this, "ACharacter.bServerMoveIgnoreRootMotion" }; }

    BitFieldValue<bool, unsigned __int32> bWasJumping() { return { this, "ACharacter.bWasJumping" }; }


    // Functions


    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "ACharacter.StaticClass()"); }

    UPrimitiveComponent* GetMovementBase() { return NativeCall<UPrimitiveComponent*>(this, "ACharacter.GetMovementBase()"); }

    UPawnMovementComponent* GetMovementComponent() { return NativeCall<UPawnMovementComponent*>(this, "ACharacter.GetMovementComponent()"); }

    void ClientAdjustRootMotionSourcePosition(float TimeStamp, FRootMotionSourceGroup* ServerRootMotion, bool bHasAnimRootMotion, float ServerMontageTrackPosition, UE::Math::TVector<double>* ServerLoc, FVector_NetQuantizeNormal* ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned __int8 ServerMovementMode) { NativeCall<void, float, FRootMotionSourceGroup*, bool, float, UE::Math::TVector<double>*, FVector_NetQuantizeNormal*, float, UPrimitiveComponent*, FName, bool, bool, unsigned __int8>(this, "ACharacter.ClientAdjustRootMotionSourcePosition(float,FRootMotionSourceGroup,bool,float,UE::Math::TVector<double>,FVector_NetQuantizeNormal,float,UPrimitiveComponent*,FName,bool,bool,unsignedchar)", TimeStamp, ServerRootMotion, bHasAnimRootMotion, ServerMontageTrackPosition, ServerLoc, ServerRotation, ServerVelZ, ServerBase, ServerBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode); }

    void OnJumped() { NativeCall<void>(this, "ACharacter.OnJumped()"); }

    void OnLanded(const FHitResult* Hit) { NativeCall<void, const FHitResult*>(this, "ACharacter.OnLanded(FHitResult&)", Hit); }

    static void StaticRegisterNativesACharacter() { NativeCall<void>(nullptr, "ACharacter.StaticRegisterNativesACharacter()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "ACharacter.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void PostInitializeComponents() { NativeCall<void>(this, "ACharacter.PostInitializeComponents()"); }

    void CacheInitialMeshOffset(UE::Math::TVector<double>* MeshRelativeLocation, UE::Math::TRotator<double>* MeshRelativeRotation, __int64 a4) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, __int64>(this, "ACharacter.CacheInitialMeshOffset(UE::Math::TVector<double>,UE::Math::TRotator<double>)", MeshRelativeLocation, MeshRelativeRotation, a4); }

    void GetSimpleCollisionCylinder(float* CollisionRadius, float* CollisionHalfHeight) { NativeCall<void, float*, float*>(this, "ACharacter.GetSimpleCollisionCylinder(float&,float&)", CollisionRadius, CollisionHalfHeight); }

    float GetDefaultHalfHeight() { return NativeCall<float>(this, "ACharacter.GetDefaultHalfHeight()"); }

    UActorComponent* FindComponentByClass(const TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, const TSubclassOf<UActorComponent>>(this, "ACharacter.FindComponentByClass(TSubclassOf<UActorComponent>)", ComponentClass); }

    void NotifyJumpApex() { NativeCall<void>(this, "ACharacter.NotifyJumpApex()"); }

    void Landed(const FHitResult* Hit) { NativeCall<void, const FHitResult*>(this, "ACharacter.Landed(FHitResult&)", Hit); }

    bool CanJump() { return NativeCall<bool>(this, "ACharacter.CanJump()"); }

    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "ACharacter.CanJumpInternal_Implementation()"); }

    void ResetJumpState() { NativeCall<void>(this, "ACharacter.ResetJumpState()"); }

    bool IsJumpProvidingForce() { return NativeCall<bool>(this, "ACharacter.IsJumpProvidingForce()"); }

    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "ACharacter.RecalculateBaseEyeHeight()"); }

    void OnRep_IsCrouched(__int64 a2) { NativeCall<void, __int64>(this, "ACharacter.OnRep_IsCrouched()", a2); }

    void SetReplicateMovement(bool bInReplicateMovement) { NativeCall<void, bool>(this, "ACharacter.SetReplicateMovement(bool)", bInReplicateMovement); }

    bool CanCrouch() { return NativeCall<bool>(this, "ACharacter.CanCrouch()"); }

    void Crouch(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.Crouch(bool)", bClientSimulation); }

    void UnCrouch(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.UnCrouch(bool)", bClientSimulation); }

    void OnEndCrouch(float HeightAdjust, float ScaledHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.OnEndCrouch(float,float)", HeightAdjust, ScaledHeightAdjust); }

    void OnStartCrouch(float HeightAdjust, float ScaledHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.OnStartCrouch(float,float)", HeightAdjust, ScaledHeightAdjust); }

    void ApplyDamageMomentum(float DamageTaken, const FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "ACharacter.ApplyDamageMomentum(float,FDamageEvent&,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void ClearCrossLevelReferences(__int64 a2, __int64 a3, __int64 a4) { NativeCall<void, __int64, __int64, __int64>(this, "ACharacter.ClearCrossLevelReferences()", a2, a3, a4); }

    void SetBase(UPrimitiveComponent* NewBaseComponent, const FName InBoneName, bool bNotifyPawn) { NativeCall<void, UPrimitiveComponent*, const FName, bool>(this, "ACharacter.SetBase(UPrimitiveComponent*,FName,bool)", NewBaseComponent, InBoneName, bNotifyPawn); }

    void TurnOff() { NativeCall<void>(this, "ACharacter.TurnOff()"); }

    void Restart() { NativeCall<void>(this, "ACharacter.Restart()"); }

    void PawnClientRestart() { NativeCall<void>(this, "ACharacter.PawnClientRestart()"); }

    void PossessedBy(AController* NewController) { NativeCall<void, AController*>(this, "ACharacter.PossessedBy(AController*)", NewController); }

    void UnPossessed() { NativeCall<void>(this, "ACharacter.UnPossessed()"); }

    void TornOff() { NativeCall<void>(this, "ACharacter.TornOff()"); }

    void NotifyActorBeginOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "ACharacter.NotifyActorBeginOverlap(AActor*)", OtherActor); }

    void NotifyActorEndOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "ACharacter.NotifyActorEndOverlap(AActor*)", OtherActor); }

    void BaseChange() { NativeCall<void>(this, "ACharacter.BaseChange()"); }

    void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo* DebugDisplay, float* YL, float* YPos) { NativeCall<void, UCanvas*, const FDebugDisplayInfo*, float*, float*>(this, "ACharacter.DisplayDebug(UCanvas*,FDebugDisplayInfo&,float&,float&)", Canvas, DebugDisplay, YL, YPos); }

    void LaunchCharacter(UE::Math::TVector<double>* LaunchVelocity, bool bXYOverride, bool bZOverride) { NativeCall<void, UE::Math::TVector<double>*, bool, bool>(this, "ACharacter.LaunchCharacter(UE::Math::TVector<double>,bool,bool)", LaunchVelocity, bXYOverride, bZOverride); }

    void OnMovementModeChanged(EMovementMode PrevMovementMode, unsigned __int8 PrevCustomMode) { NativeCall<void, EMovementMode, unsigned __int8>(this, "ACharacter.OnMovementModeChanged(EMovementMode,unsignedchar)", PrevMovementMode, PrevCustomMode); }

    bool ShouldNotifyLanded(const FHitResult* Hit) { return NativeCall<bool, const FHitResult*>(this, "ACharacter.ShouldNotifyLanded(FHitResult&)", Hit); }

    void Jump() { NativeCall<void>(this, "ACharacter.Jump()"); }

    void StopJumping() { NativeCall<void>(this, "ACharacter.StopJumping()"); }

    void CheckJumpInput(float DeltaTime) { NativeCall<void, float>(this, "ACharacter.CheckJumpInput(float)", DeltaTime); }

    void ClearJumpInput(float DeltaTime) { NativeCall<void, float>(this, "ACharacter.ClearJumpInput(float)", DeltaTime); }

    float GetJumpMaxHoldTime() { return NativeCall<float>(this, "ACharacter.GetJumpMaxHoldTime()"); }

    void PreNetReceive() { NativeCall<void>(this, "ACharacter.PreNetReceive()"); }

    void PostNetReceive() { NativeCall<void>(this, "ACharacter.PostNetReceive()"); }

    void OnRep_ReplicatedBasedMovement() { NativeCall<void>(this, "ACharacter.OnRep_ReplicatedBasedMovement()"); }

    void OnRep_ReplicatedMovement() { NativeCall<void>(this, "ACharacter.OnRep_ReplicatedMovement()"); }

    void SimulatedRootMotionPositionFixup(float DeltaSeconds) { NativeCall<void, float>(this, "ACharacter.SimulatedRootMotionPositionFixup(float)", DeltaSeconds); }

    bool RestoreReplicatedMove(const FSimulatedRootMotionReplicatedMove* RootMotionRepMove) { return NativeCall<bool, const FSimulatedRootMotionReplicatedMove*>(this, "ACharacter.RestoreReplicatedMove(FSimulatedRootMotionReplicatedMove&)", RootMotionRepMove); }

    void OnUpdateSimulatedPosition(const UE::Math::TVector<double>* OldLocation, const UE::Math::TQuat<double>* OldRotation) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*>(this, "ACharacter.OnUpdateSimulatedPosition(UE::Math::TVector<double>&,UE::Math::TQuat<double>&)", OldLocation, OldRotation); }

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "ACharacter.PostNetReceiveLocationAndRotation()"); }

    void PreReplication(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "ACharacter.PreReplication(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void GetReplicatedCustomConditionState(FCustomPropertyConditionState* OutActiveState) { NativeCall<void, FCustomPropertyConditionState*>(this, "ACharacter.GetReplicatedCustomConditionState(FCustomPropertyConditionState&)", OutActiveState); }

    void PreReplicationForReplay(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "ACharacter.PreReplicationForReplay(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "ACharacter.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    float PlayAnimMontage(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer, float BlendInTime, float BlendOutTime) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool, float, float>(this, "ACharacter.PlayAnimMontage(UAnimMontage*,float,FName,bool,bool,float,float)", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, BlendInTime, BlendOutTime); }

    void StopAnimMontage(UAnimMontage* AnimMontage) { NativeCall<void, UAnimMontage*>(this, "ACharacter.StopAnimMontage(UAnimMontage*)", AnimMontage); }

    UAnimMontage* GetCurrentMontage() { return NativeCall<UAnimMontage*>(this, "ACharacter.GetCurrentMontage()"); }

    void ClientCheatWalk_Implementation() { NativeCall<void>(this, "ACharacter.ClientCheatWalk_Implementation()"); }

    void ClientCheatFly_Implementation() { NativeCall<void>(this, "ACharacter.ClientCheatFly_Implementation()"); }

    void ClientCheatGhost_Implementation() { NativeCall<void>(this, "ACharacter.ClientCheatGhost_Implementation()"); }

    bool IsBasedOnDynamicActor() { return NativeCall<bool>(this, "ACharacter.IsBasedOnDynamicActor()"); }

    void ClientForceUpdateMovement_Implementation(UE::Math::TVector<double>* NewLocation, UE::Math::TVector<double>* NewVelocity) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "ACharacter.ClientForceUpdateMovement_Implementation(UE::Math::TVector<double>,UE::Math::TVector<double>)", NewLocation, NewVelocity); }

};


struct APrimalCharacter : ACharacter

{

    // Fields


    long double& LastMeshGameplayRelevantTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastMeshGameplayRelevantTime"); }

    float& ProneEyeHeightField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ProneEyeHeight"); }

    float& ExtraMaxAccelerationModifierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraMaxAccelerationModifier"); }

    float& ExtraFrictionModifierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraFrictionModifier"); }

    long double& LastTimePlayAnimationEndedField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimePlayAnimationEnded"); }

    long double& LastTimeForceTickPoseOnServerPlayAnimationEndedField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeForceTickPoseOnServerPlayAnimationEnded"); }

    UE::Math::TVector<double>& OldLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.OldLocation"); }

    UE::Math::TRotator<double>& OldRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.OldRotation"); }

    float& EffectorInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.EffectorInterpSpeed"); }

    float& HalfLegLengthField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.HalfLegLength"); }

    float& TwoLeggedVirtualPointDistFactorField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TwoLeggedVirtualPointDistFactor"); }

    float& FullIKDistanceField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.FullIKDistance"); }

    float& IKAfterFallingTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.IKAfterFallingTime"); }

    float& SimpleIkRateField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.SimpleIkRate"); }

    UE::Math::TVector<double>& GroundCheckExtentField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.GroundCheckExtent"); }

    long double& LastForceAimedCharactersTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastForceAimedCharactersTime"); }

    float& FluidInteractionScalarField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.FluidInteractionScalar"); }

    UAnimMontage*& JumpAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.JumpAnim"); }

    UAnimMontage*& LandedAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.LandedAnim"); }

    UAnimMontage*& HurtAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.HurtAnim"); }

    UAnimMontage*& HurtAnim_FlyingField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.HurtAnim_Flying"); }

    UAnimMontage*& HurtAnim_SleepingField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.HurtAnim_Sleeping"); }

    UAnimMontage*& PinnedAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.PinnedAnim"); }

    UParticleSystem*& HurtFXField() { return *GetNativePointerField<UParticleSystem**>(this, "APrimalCharacter.HurtFX"); }

    USoundBase*& HurtSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.HurtSound"); }

    FName& RootBodyBoneNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.RootBodyBoneName"); }

    FDecalData& HurtDecalDataField() { return *GetNativePointerField<FDecalData*>(this, "APrimalCharacter.HurtDecalData"); }

    UE::Math::TVector<double>& SavedBaseWorldLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.SavedBaseWorldLocation"); }

    TArray<APrimalBuff*, TSizedDefaultAllocator<32> >& BuffsField() { return *GetNativePointerField<TArray<APrimalBuff*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.Buffs"); }

    long double& LastStartedTalkingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartedTalkingTime"); }

    bool& bIsMutedField() { return *GetNativePointerField<bool*>(this, "APrimalCharacter.bIsMuted"); }

    FString& TribeNameField() { return *GetNativePointerField<FString*>(this, "APrimalCharacter.TribeName"); }

    float& WaterSubmergedDepthThresholdField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.WaterSubmergedDepthThreshold"); }

    float& ProneWaterSubmergedDepthThresholdField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ProneWaterSubmergedDepthThreshold"); }

    TEnumAsByte<enum EMovementMode>& UnSubmergedWaterMovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "APrimalCharacter.UnSubmergedWaterMovementMode"); }

    UToolTipWidget*& CustomTooltipWidgetField() { return *GetNativePointerField<UToolTipWidget**>(this, "APrimalCharacter.CustomTooltipWidget"); }

    TArray<FDamageTypeAdjuster, TSizedDefaultAllocator<32> >& DamageTypeAdjustersField() { return *GetNativePointerField<TArray<FDamageTypeAdjuster, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.DamageTypeAdjusters"); }

    float& SnapshotScaleField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.SnapshotScale"); }

    TArray<FPrimalSnapshotPose, TSizedDefaultAllocator<32> >& SnapshotPosesField() { return *GetNativePointerField<TArray<FPrimalSnapshotPose, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.SnapshotPoses"); }

    TSubclassOf<UPrimalItem>& PoopItemClassField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalCharacter.PoopItemClass"); }

    TSubclassOf<UPrimalItem>& TaxidermySkinClassField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalCharacter.TaxidermySkinClass"); }

    FName& DragBoneNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.DragBoneName"); }

    FName& DragSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.DragSocketName"); }

    float& MaxDragDistanceField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxDragDistance"); }

    float& MaxDragDistanceTimeoutField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxDragDistanceTimeout"); }

    TArray<FName, TSizedDefaultAllocator<32> >& BonesToIngoreWhileDraggedField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.BonesToIngoreWhileDragged"); }

    float& DefaultTPVZoomField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DefaultTPVZoom"); }

    float& MaxTPVZoomField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxTPVZoom"); }

    float& MinTPVZoomField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MinTPVZoom"); }

    float& PreviewCameraMaxZoomMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.PreviewCameraMaxZoomMultiplier"); }

    float& PreviewCameraDefaultZoomMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.PreviewCameraDefaultZoomMultiplier"); }

    float& PreviewCameraDistanceScaleFactorField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.PreviewCameraDistanceScaleFactor"); }

    USoundBase*& StartDraggedSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.StartDraggedSound"); }

    USoundBase*& EndDraggedSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.EndDraggedSound"); }

    APrimalCharacter*& DraggedCharacterField() { return *GetNativePointerField<APrimalCharacter**>(this, "APrimalCharacter.DraggedCharacter"); }

    APrimalCharacter*& DraggingCharacterField() { return *GetNativePointerField<APrimalCharacter**>(this, "APrimalCharacter.DraggingCharacter"); }

    UE::Math::TTransform<double>& LocalDraggedCharacterTransformField() { return *GetNativePointerField<UE::Math::TTransform<double>*>(this, "APrimalCharacter.LocalDraggedCharacterTransform"); }

    long double& StartDraggingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.StartDraggingTime"); }

    long double& LastDragUpdateTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastDragUpdateTime"); }

    long double& ForceUnfreezeSkeletalDynamicsUntilTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.ForceUnfreezeSkeletalDynamicsUntilTime"); }

    float& StasisConsumerRangeMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.StasisConsumerRangeMultiplier"); }

    AActor*& ImmobilizationActorField() { return *GetNativePointerField<AActor**>(this, "APrimalCharacter.ImmobilizationActor"); }

    int& CurrentFrameAnimPreventInputField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.CurrentFrameAnimPreventInput"); }

    float& BPTimerServerMinField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BPTimerServerMin"); }

    float& BPTimerServerMaxField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BPTimerServerMax"); }

    float& BPTimerNonDedicatedMinField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BPTimerNonDedicatedMin"); }

    float& BPTimerNonDedicatedMaxField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BPTimerNonDedicatedMax"); }

    long double& NextBPTimerServerField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.NextBPTimerServer"); }

    long double& NextBPTimerNonDedicatedField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.NextBPTimerNonDedicated"); }

    long double& LastCausedDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastCausedDamageTime"); }

    AActor*& LastDamageCauserField() { return *GetNativePointerField<AActor**>(this, "APrimalCharacter.LastDamageCauser"); }

    TArray<TSubclassOf<APrimalStructure>, TSizedDefaultAllocator<32> >& ImmobilizationTrapsToIgnoreField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalStructure>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ImmobilizationTrapsToIgnore"); }

    TWeakObjectPtr<APrimalStructureElevatorPlatform>& BasedElevatorField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructureElevatorPlatform>*>(this, "APrimalCharacter.BasedElevator"); }

    TWeakObjectPtr<APrimalDinoCharacter>& CarryingDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "APrimalCharacter.CarryingDino"); }

    FName& DediOverrideCapsuleCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.DediOverrideCapsuleCollisionProfileName"); }

    FName& DediOverrideMeshCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.DediOverrideMeshCollisionProfileName"); }

    FName& SnaredFromSocketField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.SnaredFromSocket"); }

    TSubclassOf<APrimalStructureItemContainer>& DeathDestructionDepositInventoryClassField() { return *GetNativePointerField<TSubclassOf<APrimalStructureItemContainer>*>(this, "APrimalCharacter.DeathDestructionDepositInventoryClass"); }

    float& DamageNotifyTeamAggroMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DamageNotifyTeamAggroMultiplier"); }

    float& DamageNotifyTeamAggroRangeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DamageNotifyTeamAggroRange"); }

    float& DamageNotifyTeamAggroRangeFalloffField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DamageNotifyTeamAggroRangeFalloff"); }

    float& ReplicatedCurrentHealthField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ReplicatedCurrentHealth"); }

    float& ReplicatedMaxHealthField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ReplicatedMaxHealth"); }

    float& ReplicatedCurrentTorporField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ReplicatedCurrentTorpor"); }

    float& ReplicatedMaxTorporField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ReplicatedMaxTorpor"); }

    APrimalProjectileGrapplingHook*& LastGrapHookPullingMeField() { return *GetNativePointerField<APrimalProjectileGrapplingHook**>(this, "APrimalCharacter.LastGrapHookPullingMe"); }

    AShooterCharacter*& LastGrapHookPullingOwnerField() { return *GetNativePointerField<AShooterCharacter**>(this, "APrimalCharacter.LastGrapHookPullingOwner"); }

    UE::Math::TVector<double>& DragOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.DragOffset"); }

    TArray<USoundBase*, TSizedDefaultAllocator<32> >& CharacterOverrideSoundFromField() { return *GetNativePointerField<TArray<USoundBase*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.CharacterOverrideSoundFrom"); }

    TArray<USoundBase*, TSizedDefaultAllocator<32> >& CharacterOverrideSoundToField() { return *GetNativePointerField<TArray<USoundBase*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.CharacterOverrideSoundTo"); }

    TArray<UParticleSystem*, TSizedDefaultAllocator<32> >& CharacterOverrideParticleFromField() { return *GetNativePointerField<TArray<UParticleSystem*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.CharacterOverrideParticleFrom"); }

    TArray<UParticleSystem*, TSizedDefaultAllocator<32> >& CharacterOverrideParticleToField() { return *GetNativePointerField<TArray<UParticleSystem*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.CharacterOverrideParticleTo"); }

    TWeakObjectPtr<AStaticMeshActor>& KinematicActorField() { return *GetNativePointerField<TWeakObjectPtr<AStaticMeshActor>*>(this, "APrimalCharacter.KinematicActor"); }

    long double& LastUpdatedAimOffsetsTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastUpdatedAimOffsetsTime"); }

    UE::Math::TVector<double>& MeshPreRagdollRelativeLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.MeshPreRagdollRelativeLocation"); }

    UE::Math::TRotator<double>& MeshPreRagdollRelativeRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.MeshPreRagdollRelativeRotation"); }

    int& DraggingBodyIndexField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.DraggingBodyIndex"); }

    int& DraggedBoneIndexField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.DraggedBoneIndex"); }

    int& customBitFlagsField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.customBitFlags"); }

    float& RunningSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RunningSpeedModifier"); }

    float& LowHealthPercentageField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LowHealthPercentage"); }

    float& BaseTurnRateField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BaseTurnRate"); }

    float& BaseLookUpRateField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BaseLookUpRate"); }

    UAnimMontage*& DeathAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.DeathAnim"); }

    UAnimationAsset*& ReplicatedDeathAnimField() { return *GetNativePointerField<UAnimationAsset**>(this, "APrimalCharacter.ReplicatedDeathAnim"); }

    TSoftObjectPtr<UAnimationAsset>& SavedDeathAnimField() { return *GetNativePointerField<TSoftObjectPtr<UAnimationAsset>*>(this, "APrimalCharacter.SavedDeathAnim"); }

    USoundBase*& DeathSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.DeathSound"); }

    USoundBase*& RunLoopSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.RunLoopSound"); }

    USoundBase*& RunStopSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.RunStopSound"); }

    TArray<USoundBase*, TSizedDefaultAllocator<32> >& FootStepSoundsPhysMatField() { return *GetNativePointerField<TArray<USoundBase*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.FootStepSoundsPhysMat"); }

    TArray<USoundBase*, TSizedDefaultAllocator<32> >& LandedSoundsPhysMatField() { return *GetNativePointerField<TArray<USoundBase*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.LandedSoundsPhysMat"); }

    //FVelocityBasedCharacterSoundInfo& VelocityBasedLandedSoundsField() { return *GetNativePointerField<FVelocityBasedCharacterSoundInfo*>(this, "APrimalCharacter.VelocityBasedLandedSounds"); }

    float& LastSimulatedFallingVelocityZField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastSimulatedFallingVelocityZ"); }

    FName& MeshRootSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.MeshRootSocketName"); }

    TWeakObjectPtr<UAudioComponent>& LastVoiceAudioComponentField() { return *GetNativePointerField<TWeakObjectPtr<UAudioComponent>*>(this, "APrimalCharacter.LastVoiceAudioComponent"); }

    float& MaxFallSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxFallSpeed"); }

    float& FallDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.FallDamageMultiplier"); }

    UAudioComponent*& RunLoopACField() { return *GetNativePointerField<UAudioComponent**>(this, "APrimalCharacter.RunLoopAC"); }

    //FConstraintInstance& DraggingConstraintField() { return *GetNativePointerField<FConstraintInstance*>(this, "APrimalCharacter.DraggingConstraint"); }

    float& CurrentCarriedYawField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CurrentCarriedYaw"); }

    float& TargetCarriedYawField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TargetCarriedYaw"); }

    float& ServerTargetCarriedYawField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ServerTargetCarriedYaw"); }

    USoundBase*& NetDynamicMusicSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.NetDynamicMusicSound"); }

    TWeakObjectPtr<APrimalDinoCharacter>& MountedDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "APrimalCharacter.MountedDino"); }

    long double& MountedDinoTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.MountedDinoTime"); }

    TWeakObjectPtr<APrimalDinoCharacter>& PreviousMountedDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "APrimalCharacter.PreviousMountedDino"); }

    UE::Math::TVector<double>& LastForceFallCheckBaseLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.LastForceFallCheckBaseLocation"); }

    UE::Math::TVector<double>& LastHitWallSweepCheckLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.LastHitWallSweepCheckLocation"); }

    long double& LastTimeBasedMovementHadCurrentActorField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeBasedMovementHadCurrentActor"); }

    TWeakObjectPtr<AActor>& LastBasedMovementActorRefField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalCharacter.LastBasedMovementActorRef"); }

    float& GrabWeightThresholdField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.GrabWeightThreshold"); }

    float& DragWeightField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DragWeight"); }

    FTimerHandle& UpdateDraggingHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.UpdateDraggingHandle"); }

    FString& DescriptiveNameField() { return *GetNativePointerField<FString*>(this, "APrimalCharacter.DescriptiveName"); }

    //TArray<FVector_NetQuantize, TSizedDefaultAllocator<32> >& ReplicatedRagdollPositionsField() { return *GetNativePointerField<TArray<FVector_NetQuantize, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ReplicatedRagdollPositions"); }

    //TArray<FRotator_NetQuantize, TSizedDefaultAllocator<32> >& ReplicatedRagdollRotationsField() { return *GetNativePointerField<TArray<FRotator_NetQuantize, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ReplicatedRagdollRotations"); }

    //TArray<FVector_NetQuantize, TSizedDefaultAllocator<32> >& LastReplicatedRagdollPositionsField() { return *GetNativePointerField<TArray<FVector_NetQuantize, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.LastReplicatedRagdollPositions"); }

    //TArray<FRotator_NetQuantize, TSizedDefaultAllocator<32> >& LastReplicatedRagdollRotationsField() { return *GetNativePointerField<TArray<FRotator_NetQuantize, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.LastReplicatedRagdollRotations"); }

    UE::Math::TRotator<double>& ReplicatedRootRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.ReplicatedRootRotation"); }

    //TArray<FConstraintInstance, TSizedDefaultAllocator<32> >& ReplicatedBonesConstraintsField() { return *GetNativePointerField<TArray<FConstraintInstance, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ReplicatedBonesConstraints"); }

    TArray<int, TSizedDefaultAllocator<32> >& ReplicatedBonesIndiciesField() { return *GetNativePointerField<TArray<int, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ReplicatedBonesIndicies"); }

    FTimerHandle& UpdateRagdollReplicationOnClientHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.UpdateRagdollReplicationOnClientHandle"); }

    float& WalkRunTransitionCooldownField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.WalkRunTransitionCooldown"); }

    float& KillXPBaseField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.KillXPBase"); }

    TArray<FName, TSizedDefaultAllocator<32> >& ReplicatedBonesField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ReplicatedBones"); }

    float& RagdollReplicationIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RagdollReplicationInterval"); }

    FTimerHandle& ReplicateRagdollHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.ReplicateRagdollHandle"); }

    TArray<FBoneDamageAdjuster, TSizedDefaultAllocator<32> >& BoneDamageAdjustersField() { return *GetNativePointerField<TArray<FBoneDamageAdjuster, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.BoneDamageAdjusters"); }

    float& ClientRotationInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ClientRotationInterpSpeed"); }

    float& ClientLocationInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ClientLocationInterpSpeed"); }

    float& MaxDragMovementSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxDragMovementSpeed"); }

    UE::Math::TRotator<double>& CurrentAimRotField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.CurrentAimRot"); }

    UE::Math::TVector<double>& CurrentRootLocField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.CurrentRootLoc"); }

    int& LastYawSpeedWorldFrameCounterField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.LastYawSpeedWorldFrameCounter"); }

    FName& MeshPreRagdollCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.MeshPreRagdollCollisionProfileName"); }

    FName& CapsulePreRagdollCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.CapsulePreRagdollCollisionProfileName"); }

    UPrimalCharacterStatusComponent*& MyCharacterStatusComponentField() { return *GetNativePointerField<UPrimalCharacterStatusComponent**>(this, "APrimalCharacter.MyCharacterStatusComponent"); }

    float& LastTickStaminaValueField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastTickStaminaValue"); }

    UPrimalInventoryComponent*& MyInventoryComponentField() { return *GetNativePointerField<UPrimalInventoryComponent**>(this, "APrimalCharacter.MyInventoryComponent"); }

    UAnimMontage*& SyncedMontageField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.SyncedMontage"); }

    long double& LastMontageSyncTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastMontageSyncTime"); }

    float& SyncedMontageDurationField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.SyncedMontageDuration"); }

    float& MontageSyncIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MontageSyncInterval"); }

    long double& LastRunningTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastRunningTime"); }

    UE::Math::TVector<double>& TPVCameraOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.TPVCameraOffset"); }

    UE::Math::TVector<double>& TPVCameraOffsetMultiplierField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.TPVCameraOffsetMultiplier"); }

    float& TPVCameraHorizontalOffsetFactorMaxField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TPVCameraHorizontalOffsetFactorMax"); }

    float& TPVCameraHorizontalOffsetFactorMaxClampField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TPVCameraHorizontalOffsetFactorMaxClamp"); }

    UE::Math::TVector<double>& TPVCameraOrgOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.TPVCameraOrgOffset"); }

    float& LandedSoundMaxRangeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LandedSoundMaxRange"); }

    float& FallingDamageHealthScaleBaseField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.FallingDamageHealthScaleBase"); }

    float& FootstepsMaxRangeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.FootstepsMaxRange"); }

    float& MinTimeBetweenFootstepsField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MinTimeBetweenFootsteps"); }

    long double& LastPlayedFootstepTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastPlayedFootstepTime"); }

    float& MinTimeBetweenFootstepsRunningField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MinTimeBetweenFootstepsRunning"); }

    TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >& AnimationsPreventInputField() { return *GetNativePointerField<TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.AnimationsPreventInput"); }

    TSubclassOf<UPrimalHarvestingComponent>& DeathHarvestingComponentField() { return *GetNativePointerField<TSubclassOf<UPrimalHarvestingComponent>*>(this, "APrimalCharacter.DeathHarvestingComponent"); }

    UPrimalHarvestingComponent*& MyDeathHarvestingComponentField() { return *GetNativePointerField<UPrimalHarvestingComponent**>(this, "APrimalCharacter.MyDeathHarvestingComponent"); }

    TSharedPtr<FAttachedInstancedHarvestingElement>& MyDeathHarvestingElementField() { return *GetNativePointerField<TSharedPtr<FAttachedInstancedHarvestingElement>*>(this, "APrimalCharacter.MyDeathHarvestingElement"); }

    long double& LastNetDidLandField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastNetDidLand"); }

    FTimerHandle& ForceSleepRagdollHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.ForceSleepRagdollHandle"); }

    FTimerHandle& ForceSleepRagdollExHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.ForceSleepRagdollExHandle"); }

    FTimerHandle& LifespanExpiredHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.LifespanExpiredHandle"); }

    TWeakObjectPtr<AController>& LastDamageEventInstigatorField() { return *GetNativePointerField<TWeakObjectPtr<AController>*>(this, "APrimalCharacter.LastDamageEventInstigator"); }

    int& CachedNumberOfClientRagdollCorrectionAttemptsField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.CachedNumberOfClientRagdollCorrectionAttempts"); }

    int& NumberOfClientRagdollCorrectionAttemptsField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.NumberOfClientRagdollCorrectionAttempts"); }

    float& ServerForceSleepRagdollIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ServerForceSleepRagdollInterval"); }

    float& ClientForceSleepRagdollIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ClientForceSleepRagdollInterval"); }

    float& NonRelevantServerForceSleepRagdollIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.NonRelevantServerForceSleepRagdollInterval"); }

    ABiomeZoneVolume*& MyBiomeZoneVolumeField() { return *GetNativePointerField<ABiomeZoneVolume**>(this, "APrimalCharacter.MyBiomeZoneVolume"); }

    TEnumAsByte<enum EShooterPhysMaterialType::Type>& TargetableDamageFXDefaultPhysMaterialField() { return *GetNativePointerField<TEnumAsByte<enum EShooterPhysMaterialType::Type>*>(this, "APrimalCharacter.TargetableDamageFXDefaultPhysMaterial"); }

    UAnimMontage*& PoopAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.PoopAnimation"); }

    bool& AccessSpawn2PressedField() { return *GetNativePointerField<bool*>(this, "APrimalCharacter.AccessSpawn2Pressed"); }

    FieldArray<bool, 2> ToggleCameraProbeModeChordField() { return { this, "APrimalCharacter.ToggleCameraProbeModeChord" }; }

    long double& CorpseDestructionTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.CorpseDestructionTime"); }

    float& CorpseLifespanField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CorpseLifespan"); }

    float& TPVStructurePlacingHeightMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TPVStructurePlacingHeightMultiplier"); }

    float& CorpseFadeAwayTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CorpseFadeAwayTime"); }

    float& RagdollDeathImpulseScalerField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RagdollDeathImpulseScaler"); }

    USoundBase*& PoopSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.PoopSound"); }

    float& BaseTargetingDesirabilityField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BaseTargetingDesirability"); }

    float& DeadBaseTargetingDesirabilityField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DeadBaseTargetingDesirability"); }

    UE::Math::TRotator<double>& OrbitCamRotField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.OrbitCamRot"); }

    float& OrbitCamZoomField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.OrbitCamZoom"); }

    float& OrbitCamZoomStepSizeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.OrbitCamZoomStepSize"); }

    float& OrbitCamMinZoomLevelField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.OrbitCamMinZoomLevel"); }

    float& OrbitCamMaxZoomLevelField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.OrbitCamMaxZoomLevel"); }

    TArray<ABiomeZoneVolume*, TSizedDefaultAllocator<32> >& BiomeZoneVolumesField() { return *GetNativePointerField<TArray<ABiomeZoneVolume*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.BiomeZoneVolumes"); }

    UE::Math::TVector<double>& LastSubmergedCheckLocField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.LastSubmergedCheckLoc"); }

    long double& LastTimeNotInFallingField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeNotInFalling"); }

    float& MaxCursorHUDDistanceField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxCursorHUDDistance"); }

    float& AddForwardVelocityOnJumpField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.AddForwardVelocityOnJump"); }

    UE::Math::TVector<double>& DeathActorTargetingOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.DeathActorTargetingOffset"); }

    FName& SocketOverrideTargetingLocationField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.SocketOverrideTargetingLocation"); }

    FDamageEvent*& CurrentDamageEventField() { return *GetNativePointerField<FDamageEvent**>(this, "APrimalCharacter.CurrentDamageEvent"); }

    TWeakObjectPtr<APhysicsVolume>& LastApproximatePhysicsVolumeField() { return *GetNativePointerField<TWeakObjectPtr<APhysicsVolume>*>(this, "APrimalCharacter.LastApproximatePhysicsVolume"); }

    UE::Math::TVector<double>& LastApproximatePhysVolumeLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.LastApproximatePhysVolumeLocation"); }

    FTimerHandle& UseFastInventoryHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalCharacter.UseFastInventoryHandle"); }

    long double& LastTimeSubmergedField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeSubmerged"); }

    EPhysicalSurface& LastFootPhysicalSurfaceTypeField() { return *GetNativePointerField<EPhysicalSurface*>(this, "APrimalCharacter.LastFootPhysicalSurfaceType"); }

    long double& LastFootPhysicalSurfaceCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastFootPhysicalSurfaceCheckTime"); }

    float& FootPhysicalSurfaceCheckIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.FootPhysicalSurfaceCheckInterval"); }

    TWeakObjectPtr<APrimalCharacter>& LastHurtByNearbyPlayerField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalCharacter.LastHurtByNearbyPlayer"); }

    long double& LastHurtByNearbyPlayerTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastHurtByNearbyPlayerTime"); }

    TWeakObjectPtr<APrimalCharacter>& LastAttackedNearbyPlayerField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalCharacter.LastAttackedNearbyPlayer"); }

    long double& LastAttackedNearbyPlayerTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastAttackedNearbyPlayerTime"); }

    long double& LastStartFallingRagdollTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartFallingRagdollTime"); }

    UE::Math::TVector<double>& RagdollLastFrameLinearVelocityField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.RagdollLastFrameLinearVelocity"); }

    float& RagdollImpactDamageVelocityScaleField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RagdollImpactDamageVelocityScale"); }

    float& RagdollImpactDamageMinDecelerationSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RagdollImpactDamageMinDecelerationSpeed"); }

    float& StartFallingImpactRagdollTimeIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.StartFallingImpactRagdollTimeInterval"); }

    long double& LastUnstasisTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastUnstasisTime"); }

    UE::Math::TVector<double>& PreviousRagdollLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.PreviousRagdollLocation"); }

    int& RagdollPenetrationFailuresField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.RagdollPenetrationFailures"); }

    long double& LastTimeUpdatedCharacterStatusComponentField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeUpdatedCharacterStatusComponent"); }

    long double& LastTimeUpdatedCorpseDestructionTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeUpdatedCorpseDestructionTime"); }

    long double& NextBlinkTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.NextBlinkTime"); }

    long double& BlinkTimerField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.BlinkTimer"); }

    long double& LastInSwimmingSoundTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastInSwimmingSoundTime"); }

    USoundBase*& EnteredSwimmingSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.EnteredSwimmingSound"); }

    //FVelocityBasedCharacterSoundInfo& VelocityBasedEnteredSwimmingSoundsField() { return *GetNativePointerField<FVelocityBasedCharacterSoundInfo*>(this, "APrimalCharacter.VelocityBasedEnteredSwimmingSounds"); }

    USoundBase*& EnteredSleepingSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.EnteredSleepingSound"); }

    USoundBase*& LeftSleepingSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalCharacter.LeftSleepingSound"); }

    long double& LastRelevantToPlayerTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastRelevantToPlayerTime"); }

    long double& MeshStopForceUpdatingAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.MeshStopForceUpdatingAtTime"); }

    long double& LastWalkingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastWalkingTime"); }

    UE::Math::TVector<double>& LastWalkingLocField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.LastWalkingLoc"); }

    long double& LastSpecialDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastSpecialDamageTime"); }

    float& CorpseDraggedDecayRateField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CorpseDraggedDecayRate"); }

    float& PoopAltItemChanceField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.PoopAltItemChance"); }

    TSubclassOf<UPrimalItem>& PoopAltItemClassField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalCharacter.PoopAltItemClass"); }

    TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >& DefaultBuffsField() { return *GetNativePointerField<TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.DefaultBuffs"); }

    UTexture2D*& PoopIconField() { return *GetNativePointerField<UTexture2D**>(this, "APrimalCharacter.PoopIcon"); }

    float& RunningMaxDesiredRotDeltaField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RunningMaxDesiredRotDelta"); }

    float& CorpseDestructionTimerField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CorpseDestructionTimer"); }

    long double& LastSkinnedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastSkinnedTime"); }

    float& OriginalCorpseLifespanField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.OriginalCorpseLifespan"); }

    float& CorpseHarvestFadeTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CorpseHarvestFadeTime"); }

    //FPrimalCharacterDied& OnDiedField() { return *GetNativePointerField<FPrimalCharacterDied*>(this, "APrimalCharacter.OnDied"); }

    //FPrimalCharacterNotifyDamage& OnNotifyDamageField() { return *GetNativePointerField<FPrimalCharacterNotifyDamage*>(this, "APrimalCharacter.OnNotifyDamage"); }

    //FPrimalCharacterSleepStateChanged& OnSleepStateChangedField() { return *GetNativePointerField<FPrimalCharacterSleepStateChanged*>(this, "APrimalCharacter.OnSleepStateChanged"); }

    //FPrimalCharacterNotifyLevelUp& NotifyLevelUpField() { return *GetNativePointerField<FPrimalCharacterNotifyLevelUp*>(this, "APrimalCharacter.NotifyLevelUp"); }

    //FPrimalCharacterNotifyUnstasis& NotifyUnstasisField() { return *GetNativePointerField<FPrimalCharacterNotifyUnstasis*>(this, "APrimalCharacter.NotifyUnstasis"); }

    //FPrimalCharacterNotifyStasis& NotifyStasisField() { return *GetNativePointerField<FPrimalCharacterNotifyStasis*>(this, "APrimalCharacter.NotifyStasis"); }

    UE::Math::TVector<double>& CurrentLocalRootLocField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.CurrentLocalRootLoc"); }

    float& RootYawField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RootYaw"); }

    long double& LastTimeInSwimmingField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeInSwimming"); }

    long double& LastListenRangePushTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastListenRangePushTime"); }

    //TArray<FDefaultTextureParamOverride, TSizedDefaultAllocator<32> >& DefaultNoItemTextureParamOverridesField() { return *GetNativePointerField<TArray<FDefaultTextureParamOverride, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.DefaultNoItemTextureParamOverrides"); }

    float& LastDamageAmountMaterialValueField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastDamageAmountMaterialValue"); }

    long double& LastDamageAmountChangeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastDamageAmountChange"); }

    float& BuffedDamageMultField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BuffedDamageMult"); }

    float& BuffedResistanceMultField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BuffedResistanceMult"); }

    UStructurePaintingComponent*& PaintingComponentField() { return *GetNativePointerField<UStructurePaintingComponent**>(this, "APrimalCharacter.PaintingComponent"); }

    float& ExtraMaxSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraMaxSpeedModifier"); }

    float& ExtraRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraRotationRateModifier"); }

    float& TamedDinoCallOutRangeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TamedDinoCallOutRange"); }

    long double& LastBumpedDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastBumpedDamageTime"); }

    UE::Math::TVector<double>& TargetPathfindingLocationOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.TargetPathfindingLocationOffset"); }

    long double& LastTookDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTookDamageTime"); }

    float& ExtraReceiveDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraReceiveDamageMultiplier"); }

    float& ExtraMeleeDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraMeleeDamageMultiplier"); }

    float& LastFallingZField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastFallingZ"); }

    int& NumFallZFailsField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.NumFallZFails"); }

    TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >& CharactersGrappledToMeField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.CharactersGrappledToMe"); }

    float& DamageTheMeleeDamageCauserPercentField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DamageTheMeleeDamageCauserPercent"); }

    float& DurabilityDegrateTheMeleeDamageCauserPercentField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DurabilityDegrateTheMeleeDamageCauserPercent"); }

    TSubclassOf<UDamageType>& DamageTheMeleeDamageCauserDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalCharacter.DamageTheMeleeDamageCauserDamageType"); }

    float& CharacterDamageImpulseMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CharacterDamageImpulseMultiplier"); }

    long double& ForceCheckPushThroughWallsTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.ForceCheckPushThroughWallsTime"); }

    long double& LastStoppedEatAnimationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStoppedEatAnimationTime"); }

    long double& LastTimeFailedToDrawHUDField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimeFailedToDrawHUD"); }

    long double& NextTimeFlushFloorField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.NextTimeFlushFloor"); }

    float& MaxRagdollDeathVelocityImpulseField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MaxRagdollDeathVelocityImpulse"); }

    float& ClientRotationInterpSpeedMultiplierGroundField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ClientRotationInterpSpeedMultiplierGround"); }

    long double& LastIkUpdateTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastIkUpdateTime"); }

    float& GlideGravityScaleMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.GlideGravityScaleMultiplier"); }

    float& GlideMaxCarriedWeightField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.GlideMaxCarriedWeight"); }

    UAnimMontage*& lastPlayedMountAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.lastPlayedMountAnim"); }

    FName& DefaultCameraStyleField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.DefaultCameraStyle"); }

    float& ScaleDeathHarvestHealthyByMaxHealthBaseField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ScaleDeathHarvestHealthyByMaxHealthBase"); }

    //FPrimalCharacterInputNotify& NotifyInputEventField() { return *GetNativePointerField<FPrimalCharacterInputNotify*>(this, "APrimalCharacter.NotifyInputEvent"); }

    long double& LastForceMeshRefreshBonesTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastForceMeshRefreshBonesTime"); }

    long double& LastStartedBeingCarriedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartedBeingCarriedTime"); }

    float& RunMinVelocityRotDotField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RunMinVelocityRotDot"); }

    long double& LastHitDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastHitDamageTime"); }

    int& MeshedCounterField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.MeshedCounter"); }

    TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >& SavedBasedCharactersField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.SavedBasedCharacters"); }

    TSet<TWeakObjectPtr<APrimalCharacter>, DefaultKeyFuncs<TWeakObjectPtr<APrimalCharacter>, 0>, FDefaultSetAllocator>& BasedCharacterSetField() { return *GetNativePointerField<TSet<TWeakObjectPtr<APrimalCharacter>, DefaultKeyFuncs<TWeakObjectPtr<APrimalCharacter>, 0>, FDefaultSetAllocator>*>(this, "APrimalCharacter.BasedCharacterSet"); }

    int& MeshingTickCounterMultiplierField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.MeshingTickCounterMultiplier"); }

    TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >& PreventBuffClassesField() { return *GetNativePointerField<TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.PreventBuffClasses"); }

    TArray<FName, TSizedDefaultAllocator<32> >& PreventBuffClassesWithTagField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.PreventBuffClassesWithTag"); }

    UE::Math::TVector<double>& AutonomousCorrectionOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.AutonomousCorrectionOffset"); }

    float& ControlledInventoryAccessDistanceOffsetField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ControlledInventoryAccessDistanceOffset"); }

    //FOnOrbitCameraViewChange& OnOrbitCameraViewChangeField() { return *GetNativePointerField<FOnOrbitCameraViewChange*>(this, "APrimalCharacter.OnOrbitCameraViewChange"); }

    float& AdditionalMaxUseDistanceField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.AdditionalMaxUseDistance"); }

    TWeakObjectPtr<AActor>& TetherActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalCharacter.TetherActor"); }

    float& TetherRadiusField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TetherRadius"); }

    float& TetherHeightField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TetherHeight"); }

    long double& lastStartRunningTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.lastStartRunningTime"); }

    long double& PressCrouchProneToggleTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.PressCrouchProneToggleTime"); }

    long double& lastGatherHapticsTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.lastGatherHapticsTime"); }

    UE::Math::TVector<double>& LastTrueGetAimOffsetsLocationCSField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.LastTrueGetAimOffsetsLocationCS"); }

    UE::Math::TRotator<double>& LastTrueGetAimOffsetsRotationCSField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.LastTrueGetAimOffsetsRotationCS"); }

    //TSubclassOf<UPrimalCameraConfig>& ASACameraConfigClassField() { return *GetNativePointerField<TSubclassOf<UPrimalCameraConfig>*>(this, "APrimalCharacter.ASACameraConfigClass"); }

    //UPrimalCameraConfig*& CurrentPrimalCameraConfigField() { return *GetNativePointerField<UPrimalCameraConfig**>(this, "APrimalCharacter.CurrentPrimalCameraConfig"); }

    FName& CameraProfileIdOverrideField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.CameraProfileIdOverride"); }

    long double& LastStartedSleepingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartedSleepingTime"); }

    long double& ForcePreventCharZInterpUntilTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.ForcePreventCharZInterpUntilTime"); }

    TMap<FName, UAnimationAsset*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, UAnimationAsset*, 0> >& DeathAnimationsField() { return *GetNativePointerField<TMap<FName, UAnimationAsset*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<FName, UAnimationAsset*, 0> >*>(this, "APrimalCharacter.DeathAnimations"); }

    TSet<UParticleSystemComponent*, DefaultKeyFuncs<UParticleSystemComponent*, 0>, FDefaultSetAllocator>& ParticleSystemsToActivateAfterDraggedField() { return *GetNativePointerField<TSet<UParticleSystemComponent*, DefaultKeyFuncs<UParticleSystemComponent*, 0>, FDefaultSetAllocator>*>(this, "APrimalCharacter.ParticleSystemsToActivateAfterDragged"); }

    TSet<UNiagaraComponent*, DefaultKeyFuncs<UNiagaraComponent*, 0>, FDefaultSetAllocator>& NiagaraSystemsToActivateAfterDraggedField() { return *GetNativePointerField<TSet<UNiagaraComponent*, DefaultKeyFuncs<UNiagaraComponent*, 0>, FDefaultSetAllocator>*>(this, "APrimalCharacter.NiagaraSystemsToActivateAfterDragged"); }

    float& DraggingInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DraggingInterpSpeed"); }

    float& DraggingInterpDurationField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DraggingInterpDuration"); }

    AActor*& CharacterSavedDynamicBaseField() { return *GetNativePointerField<AActor**>(this, "APrimalCharacter.CharacterSavedDynamicBase"); }

    FName& CharacterSavedDynamicBaseBoneNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.CharacterSavedDynamicBaseBoneName"); }

    UE::Math::TVector<double>& CharacterSavedDynamicBaseRelativeLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.CharacterSavedDynamicBaseRelativeLocation"); }

    UE::Math::TQuat<double>& CharacterSavedDynamicBaseRelativeRotationField() { return *GetNativePointerField<UE::Math::TQuat<double>*>(this, "APrimalCharacter.CharacterSavedDynamicBaseRelativeRotation"); }

    UE::Math::TRotator<double>& LastCachedPlayerControlRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalCharacter.LastCachedPlayerControlRotation"); }

    float& DragSocketVerticalOffsetAsCapsulePercentField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DragSocketVerticalOffsetAsCapsulePercent"); }

    TEnumAsByte<enum ETickingGroup>& DraggingMovementComponentTickGroupField() { return *GetNativePointerField<TEnumAsByte<enum ETickingGroup>*>(this, "APrimalCharacter.DraggingMovementComponentTickGroup"); }

    FCollisionResponseSet& PreDragCollisionSetField() { return *GetNativePointerField<FCollisionResponseSet*>(this, "APrimalCharacter.PreDragCollisionSet"); }

    TEnumAsByte<enum ETickingGroup>& PreDraggingMovementTickGroupField() { return *GetNativePointerField<TEnumAsByte<enum ETickingGroup>*>(this, "APrimalCharacter.PreDraggingMovementTickGroup"); }

    float& CharacterLocalControlZInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CharacterLocalControlZInterpSpeed"); }

    float& DeathCapsuleRadiusMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DeathCapsuleRadiusMultiplier"); }

    float& DeathCapsuleHalfHeightMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DeathCapsuleHalfHeightMultiplier"); }

    float& DeathMeshRelativeZOffsetAsCapsulePercentField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DeathMeshRelativeZOffsetAsCapsulePercent"); }

    float& EnvironmentInteractionPlasticityMultField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.EnvironmentInteractionPlasticityMult"); }

    float& EnvironmentInteractionPlasticityExponentField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.EnvironmentInteractionPlasticityExponent"); }

    long double& LastSpawnedAttackerDamageImpactFXTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastSpawnedAttackerDamageImpactFXTime"); }

    UNiagaraSystem*& DamageImpactFXForAttackerField() { return *GetNativePointerField<UNiagaraSystem**>(this, "APrimalCharacter.DamageImpactFXForAttacker"); }

    float& DamageImpactFXSizeOverrideField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DamageImpactFXSizeOverride"); }

    FName& NonLocationalDamageHurtFXSocketField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.NonLocationalDamageHurtFXSocket"); }

    UE::Math::TVector<double>& NonLocationalDamageHurtFXScaleOverrideField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalCharacter.NonLocationalDamageHurtFXScaleOverride"); }

    long double& PossessedAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.PossessedAtTime"); }

    TObjectPtr<UTexture2D>& DragBodyIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.DragBodyIcon"); }

    TObjectPtr<UTexture2D>& ReleaseBodyIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.ReleaseBodyIcon"); }

    TObjectPtr<UTexture2D>& MoveCloserIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.MoveCloserIcon"); }

    TObjectPtr<UTexture2D>& ColorizeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.ColorizeIcon"); }

    TObjectPtr<UTexture2D>& TrackingInfoIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.TrackingInfoIcon"); }

    TObjectPtr<UTexture2D>& ToggleTrackingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.ToggleTrackingIcon"); }

    TObjectPtr<UTexture2D>& TogglePOIIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalCharacter.TogglePOIIcon"); }

    float& EquippedArmorDurabilityPercent1Field() { return *GetNativePointerField<float*>(this, "APrimalCharacter.EquippedArmorDurabilityPercent1"); }

    float& EquippedArmorDurabilityPercent2Field() { return *GetNativePointerField<float*>(this, "APrimalCharacter.EquippedArmorDurabilityPercent2"); }

    float& ArmorDurabilityPercentUpdateIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ArmorDurabilityPercentUpdateInterval"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bIsProne() { return { this, "APrimalCharacter.bIsProne" }; }

    BitFieldValue<bool, unsigned __int32> bCanEverProne() { return { this, "APrimalCharacter.bCanEverProne" }; }

    BitFieldValue<bool, unsigned __int32> bUseBlueprintJumpInputEvents() { return { this, "APrimalCharacter.bUseBlueprintJumpInputEvents" }; }

    BitFieldValue<bool, unsigned __int32> bUseDeferredMovement() { return { this, "APrimalCharacter.bUseDeferredMovement" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideAccessInventoryInput() { return { this, "APrimalCharacter.bUseBPOverrideAccessInventoryInput" }; }

    BitFieldValue<bool, unsigned __int32> bDisableCameraShakeOnNotifyHit() { return { this, "APrimalCharacter.bDisableCameraShakeOnNotifyHit" }; }

    BitFieldValue<bool, unsigned __int32> bHasBuffPreSerializeForInstigator() { return { this, "APrimalCharacter.bHasBuffPreSerializeForInstigator" }; }

    BitFieldValue<bool, unsigned __int32> bIsSleeping() { return { this, "APrimalCharacter.bIsSleeping" }; }

    BitFieldValue<bool, unsigned __int32> bWantsToRun() { return { this, "APrimalCharacter.bWantsToRun" }; }

    BitFieldValue<bool, unsigned __int32> bActiveRunToggle() { return { this, "APrimalCharacter.bActiveRunToggle" }; }

    BitFieldValue<bool, unsigned __int32> bLocalIsDragging() { return { this, "APrimalCharacter.bLocalIsDragging" }; }

    BitFieldValue<bool, unsigned __int32> bIsBeingDragged() { return { this, "APrimalCharacter.bIsBeingDragged" }; }

    BitFieldValue<bool, unsigned __int32> bDisableSpawnDefaultController() { return { this, "APrimalCharacter.bDisableSpawnDefaultController" }; }

    BitFieldValue<bool, unsigned __int32> bIsDragging() { return { this, "APrimalCharacter.bIsDragging" }; }

    BitFieldValue<bool, unsigned __int32> bIsDraggingWithGrapHook() { return { this, "APrimalCharacter.bIsDraggingWithGrapHook" }; }

    BitFieldValue<bool, unsigned __int32> bAllowCapsuleDamageAfterDeath() { return { this, "APrimalCharacter.bAllowCapsuleDamageAfterDeath" }; }

    BitFieldValue<bool, unsigned __int32> bRemoteRunning() { return { this, "APrimalCharacter.bRemoteRunning" }; }

    BitFieldValue<bool, unsigned __int32> bCanRun() { return { this, "APrimalCharacter.bCanRun" }; }

    BitFieldValue<bool, unsigned __int32> bUseHealthDamageMaterialOverlay() { return { this, "APrimalCharacter.bUseHealthDamageMaterialOverlay" }; }

    BitFieldValue<bool, unsigned __int32> bIsBlinking() { return { this, "APrimalCharacter.bIsBlinking" }; }

    BitFieldValue<bool, unsigned __int32> bSleepedWaterRagdoll() { return { this, "APrimalCharacter.bSleepedWaterRagdoll" }; }

    BitFieldValue<bool, unsigned __int32> bCanBeTorpid() { return { this, "APrimalCharacter.bCanBeTorpid" }; }

    BitFieldValue<bool, unsigned __int32> bDebugIK() { return { this, "APrimalCharacter.bDebugIK" }; }

    BitFieldValue<bool, unsigned __int32> bDebugIK_ShowTraceNames() { return { this, "APrimalCharacter.bDebugIK_ShowTraceNames" }; }

    BitFieldValue<bool, unsigned __int32> bForceAlwaysUpdateMesh() { return { this, "APrimalCharacter.bForceAlwaysUpdateMesh" }; }

    BitFieldValue<bool, unsigned __int32> bRagdollIgnoresPawnCapsules() { return { this, "APrimalCharacter.bRagdollIgnoresPawnCapsules" }; }

    BitFieldValue<bool, unsigned __int32> bUsePoopAnimationNotify() { return { this, "APrimalCharacter.bUsePoopAnimationNotify" }; }

    BitFieldValue<bool, unsigned __int32> bIsBigDino() { return { this, "APrimalCharacter.bIsBigDino" }; }

    BitFieldValue<bool, unsigned __int32> bDeathUseRagdoll() { return { this, "APrimalCharacter.bDeathUseRagdoll" }; }

    BitFieldValue<bool, unsigned __int32> bCanBeCarried() { return { this, "APrimalCharacter.bCanBeCarried" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCanNotifyTeamAggroAI() { return { this, "APrimalCharacter.bUseBPCanNotifyTeamAggroAI" }; }

    BitFieldValue<bool, unsigned __int32> bDamageNotifyTeamAggroAI() { return { this, "APrimalCharacter.bDamageNotifyTeamAggroAI" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_OverrideCameraTargetOriginLocation() { return { this, "APrimalCharacter.bUseBP_OverrideCameraTargetOriginLocation" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetOverrideCameraInterpSpeed() { return { this, "APrimalCharacter.bUseBPGetOverrideCameraInterpSpeed" }; }

    BitFieldValue<bool, unsigned __int32> bRecentlyUpdateIk() { return { this, "APrimalCharacter.bRecentlyUpdateIk" }; }

    BitFieldValue<bool, unsigned __int32> bIKEnabled() { return { this, "APrimalCharacter.bIKEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bIsCarried() { return { this, "APrimalCharacter.bIsCarried" }; }

    BitFieldValue<bool, unsigned __int32> bIsCarriedAsPassenger() { return { this, "APrimalCharacter.bIsCarriedAsPassenger" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPPreventFallDamage() { return { this, "APrimalCharacter.bUseBPPreventFallDamage" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPNotifyIsDamageCauserOfAddedBuff() { return { this, "APrimalCharacter.bUseBPNotifyIsDamageCauserOfAddedBuff" }; }

    BitFieldValue<bool, unsigned __int32> bPreventProjectileAttachment() { return { this, "APrimalCharacter.bPreventProjectileAttachment" }; }

    BitFieldValue<bool, unsigned __int32> bForceIKOnDedicatedServer() { return { this, "APrimalCharacter.bForceIKOnDedicatedServer" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreAllImmobilizationTraps() { return { this, "APrimalCharacter.bIgnoreAllImmobilizationTraps" }; }

    BitFieldValue<bool, unsigned __int32> bForceTriggerIgnoredTraps() { return { this, "APrimalCharacter.bForceTriggerIgnoredTraps" }; }

    BitFieldValue<bool, unsigned __int32> bIsImmobilized() { return { this, "APrimalCharacter.bIsImmobilized" }; }

    BitFieldValue<bool, unsigned __int32> bCanIgnoreWater() { return { this, "APrimalCharacter.bCanIgnoreWater" }; }

    BitFieldValue<bool, unsigned __int32> bIsDead() { return { this, "APrimalCharacter.bIsDead" }; }

    BitFieldValue<bool, unsigned __int32> ReplicateAllBones() { return { this, "APrimalCharacter.ReplicateAllBones" }; }

    BitFieldValue<bool, unsigned __int32> AutoStopReplicationWhenSleeping() { return { this, "APrimalCharacter.AutoStopReplicationWhenSleeping" }; }

    BitFieldValue<bool, unsigned __int32> bCanDrag() { return { this, "APrimalCharacter.bCanDrag" }; }

    BitFieldValue<bool, unsigned __int32> bCanBeDragged() { return { this, "APrimalCharacter.bCanBeDragged" }; }

    BitFieldValue<bool, unsigned __int32> bUsesRunningAnimation() { return { this, "APrimalCharacter.bUsesRunningAnimation" }; }

    BitFieldValue<bool, unsigned __int32> bForceNetDidLand() { return { this, "APrimalCharacter.bForceNetDidLand" }; }

    BitFieldValue<bool, unsigned __int32> bPreventSimpleIK() { return { this, "APrimalCharacter.bPreventSimpleIK" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyAllowRunningWhileFlying() { return { this, "APrimalCharacter.bOnlyAllowRunningWhileFlying" }; }

    BitFieldValue<bool, unsigned __int32> bOrbitCamera() { return { this, "APrimalCharacter.bOrbitCamera" }; }

    BitFieldValue<bool, unsigned __int32> bClientSetCurrentAimRot() { return { this, "APrimalCharacter.bClientSetCurrentAimRot" }; }

    BitFieldValue<bool, unsigned __int32> bDisablePawnTick() { return { this, "APrimalCharacter.bDisablePawnTick" }; }

    BitFieldValue<bool, unsigned __int32> bSetDeath() { return { this, "APrimalCharacter.bSetDeath" }; }

    BitFieldValue<bool, unsigned __int32> bTicksOnClient() { return { this, "APrimalCharacter.bTicksOnClient" }; }

    BitFieldValue<bool, unsigned __int32> bPlayingRunSound() { return { this, "APrimalCharacter.bPlayingRunSound" }; }

    BitFieldValue<bool, unsigned __int32> bIsRespawn() { return { this, "APrimalCharacter.bIsRespawn" }; }

    BitFieldValue<bool, unsigned __int32> bCreatedDynamicMaterials() { return { this, "APrimalCharacter.bCreatedDynamicMaterials" }; }

    BitFieldValue<bool, unsigned __int32> bCurrentFrameAnimPreventInput() { return { this, "APrimalCharacter.bCurrentFrameAnimPreventInput" }; }

    BitFieldValue<bool, unsigned __int32> bDraggedFromExtremitiesOnly() { return { this, "APrimalCharacter.bDraggedFromExtremitiesOnly" }; }

    BitFieldValue<bool, unsigned __int32> bEnableIK() { return { this, "APrimalCharacter.bEnableIK" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyPlayPoopAnimWhileWalking() { return { this, "APrimalCharacter.bOnlyPlayPoopAnimWhileWalking" }; }

    BitFieldValue<bool, unsigned __int32> bUseBlueprintAnimNotifyCustomEvent() { return { this, "APrimalCharacter.bUseBlueprintAnimNotifyCustomEvent" }; }

    BitFieldValue<bool, unsigned __int32> bNoDamageImpulse() { return { this, "APrimalCharacter.bNoDamageImpulse" }; }

    BitFieldValue<bool, unsigned __int32> bPreventImmobilization() { return { this, "APrimalCharacter.bPreventImmobilization" }; }

    BitFieldValue<bool, unsigned __int32> bAllowAirJump() { return { this, "APrimalCharacter.bAllowAirJump" }; }

    BitFieldValue<bool, unsigned __int32> bSleepingUseRagdoll() { return { this, "APrimalCharacter.bSleepingUseRagdoll" }; }

    BitFieldValue<bool, unsigned __int32> bDediForceUnregisterSKMesh() { return { this, "APrimalCharacter.bDediForceUnregisterSKMesh" }; }

    BitFieldValue<bool, unsigned __int32> bReadyToPoop() { return { this, "APrimalCharacter.bReadyToPoop" }; }

    BitFieldValue<bool, unsigned __int32> bHasDynamicBase() { return { this, "APrimalCharacter.bHasDynamicBase" }; }

    BitFieldValue<bool, unsigned __int32> bIsBeingDraggedByDino() { return { this, "APrimalCharacter.bIsBeingDraggedByDino" }; }

    BitFieldValue<bool, unsigned __int32> bIsDraggingDinoStopped() { return { this, "APrimalCharacter.bIsDraggingDinoStopped" }; }

    BitFieldValue<bool, unsigned __int32> bMissingDynamicBase() { return { this, "APrimalCharacter.bMissingDynamicBase" }; }

    BitFieldValue<bool, unsigned __int32> bClientRagdollUpdateTimerEnabled() { return { this, "APrimalCharacter.bClientRagdollUpdateTimerEnabled" }; }

    BitFieldValue<bool, unsigned __int32> bDieIfLeftWater() { return { this, "APrimalCharacter.bDieIfLeftWater" }; }

    BitFieldValue<bool, unsigned __int32> bIsAmphibious() { return { this, "APrimalCharacter.bIsAmphibious" }; }

    BitFieldValue<bool, unsigned __int32> bUseAmphibiousTargeting() { return { this, "APrimalCharacter.bUseAmphibiousTargeting" }; }

    BitFieldValue<bool, unsigned __int32> bIsWaterDino() { return { this, "APrimalCharacter.bIsWaterDino" }; }

    BitFieldValue<bool, unsigned __int32> bIsFlyerDino() { return { this, "APrimalCharacter.bIsFlyerDino" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreTargetingCarnivores() { return { this, "APrimalCharacter.bIgnoreTargetingCarnivores" }; }

    BitFieldValue<bool, unsigned __int32> bAimGettingCharacterMeshRotation() { return { this, "APrimalCharacter.bAimGettingCharacterMeshRotation" }; }

    BitFieldValue<bool, unsigned __int32> bIsRunningCheckIgnoreVelocity() { return { this, "APrimalCharacter.bIsRunningCheckIgnoreVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bIsPlayingLowHealthAnim() { return { this, "APrimalCharacter.bIsPlayingLowHealthAnim" }; }

    BitFieldValue<bool, unsigned __int32> bAllowCharacterPainting() { return { this, "APrimalCharacter.bAllowCharacterPainting" }; }

    BitFieldValue<bool, unsigned __int32> bTickStatusComponent() { return { this, "APrimalCharacter.bTickStatusComponent" }; }

    BitFieldValue<bool, unsigned __int32> bReplicateDamageMomentum() { return { this, "APrimalCharacter.bReplicateDamageMomentum" }; }

    BitFieldValue<bool, unsigned __int32> bDontActuallyEmitPoop() { return { this, "APrimalCharacter.bDontActuallyEmitPoop" }; }

    BitFieldValue<bool, unsigned __int32> bBPHUDOverideBuffProgressBar() { return { this, "APrimalCharacter.bBPHUDOverideBuffProgressBar" }; }

    BitFieldValue<bool, unsigned __int32> bAllowRunningWhileSwimming() { return { this, "APrimalCharacter.bAllowRunningWhileSwimming" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPNotifyBumpedByPawn() { return { this, "APrimalCharacter.bUseBPNotifyBumpedByPawn" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPNotifyBumpedPawn() { return { this, "APrimalCharacter.bUseBPNotifyBumpedPawn" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustDamage() { return { this, "APrimalCharacter.bUseBPAdjustDamage" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPTimerServer() { return { this, "APrimalCharacter.bUseBPTimerServer" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPTimerNonDedicated() { return { this, "APrimalCharacter.bUseBPTimerNonDedicated" }; }

    BitFieldValue<bool, unsigned __int32> bTriggerBPStasis() { return { this, "APrimalCharacter.bTriggerBPStasis" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPSetCharacterMeshseMaterialScalarParamValue() { return { this, "APrimalCharacter.bUseBPSetCharacterMeshseMaterialScalarParamValue" }; }

    BitFieldValue<bool, unsigned __int32> bIsMounted() { return { this, "APrimalCharacter.bIsMounted" }; }

    BitFieldValue<bool, unsigned __int32> bPreventTargetingByTurrets() { return { this, "APrimalCharacter.bPreventTargetingByTurrets" }; }

    BitFieldValue<bool, unsigned __int32> bDelayFootstepsUnderMinInterval() { return { this, "APrimalCharacter.bDelayFootstepsUnderMinInterval" }; }

    BitFieldValue<bool, unsigned __int32> bSleepingDisableIK() { return { this, "APrimalCharacter.bSleepingDisableIK" }; }

    BitFieldValue<bool, unsigned __int32> bRagdollRetainAnimations() { return { this, "APrimalCharacter.bRagdollRetainAnimations" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAddedAttachments() { return { this, "APrimalCharacter.bUseBPAddedAttachments" }; }

    BitFieldValue<bool, unsigned __int32> bCanPlayLandingAnim() { return { this, "APrimalCharacter.bCanPlayLandingAnim" }; }

    BitFieldValue<bool, unsigned __int32> bOnlyHasRunningAnimationWhenWalking() { return { this, "APrimalCharacter.bOnlyHasRunningAnimationWhenWalking" }; }

    BitFieldValue<bool, unsigned __int32> bIsReflectingDamage() { return { this, "APrimalCharacter.bIsReflectingDamage" }; }

    BitFieldValue<bool, unsigned __int32> bPreventTargetingAndMovement() { return { this, "APrimalCharacter.bPreventTargetingAndMovement" }; }

    BitFieldValue<bool, unsigned __int32> bPreventMovement() { return { this, "APrimalCharacter.bPreventMovement" }; }

    BitFieldValue<bool, unsigned __int32> bPreventWaterHopCorrectionVelChange() { return { this, "APrimalCharacter.bPreventWaterHopCorrectionVelChange" }; }

    BitFieldValue<bool, unsigned __int32> bIsWhistleTargetingDown() { return { this, "APrimalCharacter.bIsWhistleTargetingDown" }; }

    BitFieldValue<bool, unsigned __int32> bBPPreventInputType() { return { this, "APrimalCharacter.bBPPreventInputType" }; }

    BitFieldValue<bool, unsigned __int32> bForcePreventAllInput() { return { this, "APrimalCharacter.bForcePreventAllInput" }; }

    BitFieldValue<bool, unsigned __int32> bPreventAllBuffs() { return { this, "APrimalCharacter.bPreventAllBuffs" }; }

    BitFieldValue<bool, unsigned __int32> LastIsInsideVaccumSealedCube() { return { this, "APrimalCharacter.LastIsInsideVaccumSealedCube" }; }

    BitFieldValue<bool, unsigned __int32> bPreventJump() { return { this, "APrimalCharacter.bPreventJump" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPPreventStasis() { return { this, "APrimalCharacter.bUseBPPreventStasis" }; }

    BitFieldValue<bool, unsigned __int32> bDestroyOnStasis() { return { this, "APrimalCharacter.bDestroyOnStasis" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPPreSerializeSaveGame() { return { this, "APrimalCharacter.bUseBPPreSerializeSaveGame" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPPostLoadedFromSaveGame() { return { this, "APrimalCharacter.bUseBPPostLoadedFromSaveGame" }; }

    BitFieldValue<bool, unsigned __int32> bUseHeavyCombatMusic() { return { this, "APrimalCharacter.bUseHeavyCombatMusic" }; }

    BitFieldValue<bool, unsigned __int32> bMarkForDestruction() { return { this, "APrimalCharacter.bMarkForDestruction" }; }

    BitFieldValue<bool, unsigned __int32> bBPModifyAllowedViewHitDir() { return { this, "APrimalCharacter.bBPModifyAllowedViewHitDir" }; }

    BitFieldValue<bool, unsigned __int32> bBPLimitPlayerRotation() { return { this, "APrimalCharacter.bBPLimitPlayerRotation" }; }

    BitFieldValue<bool, unsigned __int32> bBPManagedFPVViewLocation() { return { this, "APrimalCharacter.bBPManagedFPVViewLocation" }; }

    BitFieldValue<bool, unsigned __int32> bBPCameraRotationFinal() { return { this, "APrimalCharacter.bBPCameraRotationFinal" }; }

    BitFieldValue<bool, unsigned __int32> bServerBPNotifyInventoryItemChangesUseQuantity() { return { this, "APrimalCharacter.bServerBPNotifyInventoryItemChangesUseQuantity" }; }

    BitFieldValue<bool, unsigned __int32> bServerBPNotifyInventoryItemChanges() { return { this, "APrimalCharacter.bServerBPNotifyInventoryItemChanges" }; }

    BitFieldValue<bool, unsigned __int32> bAllowRun() { return { this, "APrimalCharacter.bAllowRun" }; }

    BitFieldValue<bool, unsigned __int32> bIsAtMaxInventoryItems() { return { this, "APrimalCharacter.bIsAtMaxInventoryItems" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnStaminaDrained() { return { this, "APrimalCharacter.bUseBPOnStaminaDrained" }; }

    BitFieldValue<bool, unsigned __int32> bStaminaIsGreaterThanZero() { return { this, "APrimalCharacter.bStaminaIsGreaterThanZero" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGrabDebugSnapshot() { return { this, "APrimalCharacter.bUseBPGrabDebugSnapshot" }; }

    BitFieldValue<bool, unsigned __int32> bIsAttachedOtherCharacter() { return { this, "APrimalCharacter.bIsAttachedOtherCharacter" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnLethalDamage() { return { this, "APrimalCharacter.bUseBPOnLethalDamage" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustTorpidityDamage() { return { this, "APrimalCharacter.bUseBPAdjustTorpidityDamage" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPForceCameraStyle() { return { this, "APrimalCharacter.bUseBPForceCameraStyle" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPRemovedAsPassenger() { return { this, "APrimalCharacter.bUseBPRemovedAsPassenger" }; }

    BitFieldValue<bool, unsigned __int32> bDisableFPV() { return { this, "APrimalCharacter.bDisableFPV" }; }

    BitFieldValue<bool, unsigned __int32> bConsumeZoomInput() { return { this, "APrimalCharacter.bConsumeZoomInput" }; }

    BitFieldValue<bool, unsigned __int32> bDisableIkOnDeath() { return { this, "APrimalCharacter.bDisableIkOnDeath" }; }

    BitFieldValue<bool, unsigned __int32> bDisabledIKFromDeath() { return { this, "APrimalCharacter.bDisabledIKFromDeath" }; }

    BitFieldValue<bool, unsigned __int32> bIsReplicatedRagdoll() { return { this, "APrimalCharacter.bIsReplicatedRagdoll" }; }

    BitFieldValue<bool, unsigned __int32> bWasAllBodiesSleeping() { return { this, "APrimalCharacter.bWasAllBodiesSleeping" }; }

    BitFieldValue<bool, unsigned __int32> bInRagdoll() { return { this, "APrimalCharacter.bInRagdoll" }; }

    BitFieldValue<bool, unsigned __int32> bIsNPC() { return { this, "APrimalCharacter.bIsNPC" }; }

    BitFieldValue<bool, unsigned __int32> LastCheckedSubmergedFull() { return { this, "APrimalCharacter.LastCheckedSubmergedFull" }; }

    BitFieldValue<bool, unsigned __int32> bAllowFullSubmergedCheck() { return { this, "APrimalCharacter.bAllowFullSubmergedCheck" }; }

    BitFieldValue<bool, unsigned __int32> bRagdollWasInWaterVolume() { return { this, "APrimalCharacter.bRagdollWasInWaterVolume" }; }

    BitFieldValue<bool, unsigned __int32> bIsBuffed() { return { this, "APrimalCharacter.bIsBuffed" }; }

    BitFieldValue<bool, unsigned __int32> bIsDraggingWithOffset() { return { this, "APrimalCharacter.bIsDraggingWithOffset" }; }

    BitFieldValue<bool, unsigned __int32> bIsDraggedWithOffset() { return { this, "APrimalCharacter.bIsDraggedWithOffset" }; }

    BitFieldValue<bool, unsigned __int32> bPreventRunningWhileWalking() { return { this, "APrimalCharacter.bPreventRunningWhileWalking" }; }

    BitFieldValue<bool, unsigned __int32> bCanLandOnWater() { return { this, "APrimalCharacter.bCanLandOnWater" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustMoveForward() { return { this, "APrimalCharacter.bUseBPAdjustMoveForward" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustMoveRight() { return { this, "APrimalCharacter.bUseBPAdjustMoveRight" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetGravity() { return { this, "APrimalCharacter.bUseBPGetGravity" }; }

    BitFieldValue<bool, unsigned __int32> bAllowDamageWhenMounted() { return { this, "APrimalCharacter.bAllowDamageWhenMounted" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnAttachmentReplication() { return { this, "APrimalCharacter.bUseBPOnAttachmentReplication" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnMovementModeChangedNotify() { return { this, "APrimalCharacter.bUseBPOnMovementModeChangedNotify" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnAnimPlayedNotify() { return { this, "APrimalCharacter.bUseBPOnAnimPlayedNotify" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCharacterNewFallVelocity() { return { this, "APrimalCharacter.bUseBPOverrideCharacterNewFallVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCharacterSound() { return { this, "APrimalCharacter.bUseBPOverrideCharacterSound" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCharacterParticle() { return { this, "APrimalCharacter.bUseBPOverrideCharacterParticle" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_OnSetRunningEvent() { return { this, "APrimalCharacter.bUseBP_OnSetRunningEvent" }; }

    BitFieldValue<bool, unsigned __int32> bForceTurretFastTargeting() { return { this, "APrimalCharacter.bForceTurretFastTargeting" }; }

    BitFieldValue<bool, unsigned __int32> bFlyingOrWaterDinoPreventBackwardsRun() { return { this, "APrimalCharacter.bFlyingOrWaterDinoPreventBackwardsRun" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideFlyingVelocity() { return { this, "APrimalCharacter.bUseBPOverrideFlyingVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bSleepingDisableRagdoll() { return { this, "APrimalCharacter.bSleepingDisableRagdoll" }; }

    BitFieldValue<bool, unsigned __int32> bDestroyOnStasisWhenDead() { return { this, "APrimalCharacter.bDestroyOnStasisWhenDead" }; }

    BitFieldValue<bool, unsigned __int32> bPreventLiveBlinking() { return { this, "APrimalCharacter.bPreventLiveBlinking" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreSeatingDetachment() { return { this, "APrimalCharacter.bIgnoreSeatingDetachment" }; }

    BitFieldValue<bool, unsigned __int32> bForceAlwaysUpdateMeshAndCollision() { return { this, "APrimalCharacter.bForceAlwaysUpdateMeshAndCollision" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetHUDElements() { return { this, "APrimalCharacter.bUseBPGetHUDElements" }; }

    BitFieldValue<bool, unsigned __int32> bPreventHurtAnim() { return { this, "APrimalCharacter.bPreventHurtAnim" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCanBeBaseForCharacter() { return { this, "APrimalCharacter.bUseBPCanBeBaseForCharacter" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCanBaseOnCharacter() { return { this, "APrimalCharacter.bUseBPCanBaseOnCharacter" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnLanded() { return { this, "APrimalCharacter.bUseBPOnLanded" }; }

    BitFieldValue<bool, unsigned __int32> bEnableMoveCollapsing() { return { this, "APrimalCharacter.bEnableMoveCollapsing" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_ForceAllowBuffClasses() { return { this, "APrimalCharacter.bUseBP_ForceAllowBuffClasses" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCheckJumpInput() { return { this, "APrimalCharacter.bUseBPCheckJumpInput" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideHurtAnim() { return { this, "APrimalCharacter.bUseBPOverrideHurtAnim" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideDamageCauserHitMarker() { return { this, "APrimalCharacter.bUseBPOverrideDamageCauserHitMarker" }; }

    BitFieldValue<bool, unsigned __int32> bIsSkinned() { return { this, "APrimalCharacter.bIsSkinned" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustImpulseFromDamage() { return { this, "APrimalCharacter.bUseBPAdjustImpulseFromDamage" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAdjustCharacterMovementImpulse() { return { this, "APrimalCharacter.bUseBPAdjustCharacterMovementImpulse" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPModifyFOVInterpSpeed() { return { this, "APrimalCharacter.bUseBPModifyFOVInterpSpeed" }; }

    BitFieldValue<bool, unsigned __int32> bVerifyBasingForSaddleStructures() { return { this, "APrimalCharacter.bVerifyBasingForSaddleStructures" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_OverrideTerminalVelocity() { return { this, "APrimalCharacter.bUseBP_OverrideTerminalVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_ShouldForceDisableTPVCameraInterpolation() { return { this, "APrimalCharacter.bUseBP_ShouldForceDisableTPVCameraInterpolation" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPAllowPlayMontage() { return { this, "APrimalCharacter.bUseBPAllowPlayMontage" }; }

    BitFieldValue<bool, unsigned __int32> bPreventPerPixelPainting() { return { this, "APrimalCharacter.bPreventPerPixelPainting" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPItemSlotOverrides() { return { this, "APrimalCharacter.bUseBPItemSlotOverrides" }; }

    BitFieldValue<bool, unsigned __int32> bPreventMoveUp() { return { this, "APrimalCharacter.bPreventMoveUp" }; }

    BitFieldValue<bool, unsigned __int32> bForceAllowDediServerGroundConformInterpolate() { return { this, "APrimalCharacter.bForceAllowDediServerGroundConformInterpolate" }; }

    BitFieldValue<bool, unsigned __int32> bCanBePushed() { return { this, "APrimalCharacter.bCanBePushed" }; }

    BitFieldValue<bool, unsigned __int32> bCanPushOthers() { return { this, "APrimalCharacter.bCanPushOthers" }; }

    BitFieldValue<bool, unsigned __int32> bIsBigPusher() { return { this, "APrimalCharacter.bIsBigPusher" }; }

    BitFieldValue<bool, unsigned __int32> bCanEverCrouch() { return { this, "APrimalCharacter.bCanEverCrouch" }; }

    BitFieldValue<bool, unsigned __int32> bUseOptimizedPhysWalkingChecks() { return { this, "APrimalCharacter.bUseOptimizedPhysWalkingChecks" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreLowGravityDisorientation() { return { this, "APrimalCharacter.bIgnoreLowGravityDisorientation" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOnMassTeleportEvent() { return { this, "APrimalCharacter.bUseBPOnMassTeleportEvent" }; }

    BitFieldValue<bool, unsigned __int32> bUseBlueprintAnimNotifyCustomState() { return { this, "APrimalCharacter.bUseBlueprintAnimNotifyCustomState" }; }

    BitFieldValue<bool, unsigned __int32> bPreventIKWhenNotWalking() { return { this, "APrimalCharacter.bPreventIKWhenNotWalking" }; }

    BitFieldValue<bool, unsigned __int32> bIgnoreCorpseDecompositionMultipliers() { return { this, "APrimalCharacter.bIgnoreCorpseDecompositionMultipliers" }; }

    BitFieldValue<bool, unsigned __int32> bInterpHealthDamageMaterialOverlayAlpha() { return { this, "APrimalCharacter.bInterpHealthDamageMaterialOverlayAlpha" }; }

    BitFieldValue<bool, unsigned __int32> bSuppressPlayerKillNotification() { return { this, "APrimalCharacter.bSuppressPlayerKillNotification" }; }

    BitFieldValue<bool, unsigned __int32> bAllowCorpseDestructionWithPreventSaving() { return { this, "APrimalCharacter.bAllowCorpseDestructionWithPreventSaving" }; }

    BitFieldValue<bool, unsigned __int32> bPreventInventoryAccess() { return { this, "APrimalCharacter.bPreventInventoryAccess" }; }

    BitFieldValue<bool, unsigned __int32> bUseGetOverrideSocket() { return { this, "APrimalCharacter.bUseGetOverrideSocket" }; }

    BitFieldValue<bool, unsigned __int32> bAllowBPNewDoorInteractionDrawHUD() { return { this, "APrimalCharacter.bAllowBPNewDoorInteractionDrawHUD" }; }

    BitFieldValue<bool, unsigned __int32> bJumpOnRelease() { return { this, "APrimalCharacter.bJumpOnRelease" }; }

    BitFieldValue<bool, unsigned __int32> bAllowMultiUseByRemoteDino() { return { this, "APrimalCharacter.bAllowMultiUseByRemoteDino" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverrideJumpZModifier() { return { this, "APrimalCharacter.bUseBPOverrideJumpZModifier" }; }

    BitFieldValue<bool, unsigned __int32> bUseZeroGravityWander() { return { this, "APrimalCharacter.bUseZeroGravityWander" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPPreventNotifySound() { return { this, "APrimalCharacter.bUseBPPreventNotifySound" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_ModifyInputAcceleration() { return { this, "APrimalCharacter.bUseBP_ModifyInputAcceleration" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_ModifySavedMoveAcceleration_PreRep() { return { this, "APrimalCharacter.bUseBP_ModifySavedMoveAcceleration_PreRep" }; }

    BitFieldValue<bool, unsigned __int32> bUseBP_ModifySavedMoveAcceleration_PostRep() { return { this, "APrimalCharacter.bUseBP_ModifySavedMoveAcceleration_PostRep" }; }

    BitFieldValue<bool, unsigned __int32> bForceSimpleTeleportFade() { return { this, "APrimalCharacter.bForceSimpleTeleportFade" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPGetArmorDurabilityDecreaseMultiplier() { return { this, "APrimalCharacter.bUseBPGetArmorDurabilityDecreaseMultiplier" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPShieldBlock() { return { this, "APrimalCharacter.bUseBPShieldBlock" }; }

    BitFieldValue<bool, unsigned __int32> bHideFromScans() { return { this, "APrimalCharacter.bHideFromScans" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideWalkingVelocity() { return { this, "APrimalCharacter.bOverrideWalkingVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideSwimmingVelocity() { return { this, "APrimalCharacter.bOverrideSwimmingVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideSwimmingAcceleration() { return { this, "APrimalCharacter.bOverrideSwimmingAcceleration" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideNewFallVelocity() { return { this, "APrimalCharacter.bOverrideNewFallVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideFlyingVelocity() { return { this, "APrimalCharacter.bOverrideFlyingVelocity" }; }

    BitFieldValue<bool, unsigned __int32> bUsesRootMotion() { return { this, "APrimalCharacter.bUsesRootMotion" }; }

    BitFieldValue<bool, unsigned __int32> bEnableAnimationGroundConforming() { return { this, "APrimalCharacter.bEnableAnimationGroundConforming" }; }

    BitFieldValue<bool, unsigned __int32> bWasBeingDragged() { return { this, "APrimalCharacter.bWasBeingDragged" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPOverridePhysicsImpulses() { return { this, "APrimalCharacter.bUseBPOverridePhysicsImpulses" }; }

    BitFieldValue<bool, unsigned __int32> bAllowASACamera() { return { this, "APrimalCharacter.bAllowASACamera" }; }

    BitFieldValue<bool, unsigned __int32> bWasUsingOldCameraOnDinoBase() { return { this, "APrimalCharacter.bWasUsingOldCameraOnDinoBase" }; }

    BitFieldValue<bool, unsigned __int32> bDediServerAutoUnregisterSkeletalMeshWhenNotRelevant() { return { this, "APrimalCharacter.bDediServerAutoUnregisterSkeletalMeshWhenNotRelevant" }; }

    BitFieldValue<bool, unsigned __int32> bPreventUnconsciousMeshBasing() { return { this, "APrimalCharacter.bPreventUnconsciousMeshBasing" }; }

    BitFieldValue<bool, unsigned __int32> bUseOnCharacterSteppedNotify() { return { this, "APrimalCharacter.bUseOnCharacterSteppedNotify" }; }

    BitFieldValue<bool, unsigned __int32> bHasAppliedDraggedSettings() { return { this, "APrimalCharacter.bHasAppliedDraggedSettings" }; }

    BitFieldValue<bool, unsigned __int32> bWantsToRestoreSavedBase() { return { this, "APrimalCharacter.bWantsToRestoreSavedBase" }; }

    BitFieldValue<bool, unsigned __int32> bUnregisteredMeshDueToVisibilityTickOption() { return { this, "APrimalCharacter.bUnregisteredMeshDueToVisibilityTickOption" }; }

    BitFieldValue<bool, unsigned __int32> bHasAutoUnregisteredExtraSkeletalComponents() { return { this, "APrimalCharacter.bHasAutoUnregisteredExtraSkeletalComponents" }; }

    BitFieldValue<bool, unsigned __int32> bDraggedFlip180() { return { this, "APrimalCharacter.bDraggedFlip180" }; }

    BitFieldValue<bool, unsigned __int32> bIsDoingDraggedInterp() { return { this, "APrimalCharacter.bIsDoingDraggedInterp" }; }

    BitFieldValue<bool, unsigned __int32> bCorrectMeshRelativeZOffsetWhileDragged() { return { this, "APrimalCharacter.bCorrectMeshRelativeZOffsetWhileDragged" }; }

    BitFieldValue<bool, unsigned __int32> bReturnToCapsuleCenterWhenDroppedInWater() { return { this, "APrimalCharacter.bReturnToCapsuleCenterWhenDroppedInWater" }; }

    BitFieldValue<bool, unsigned __int32> bOverrideBlendSpaceSmoothType() { return { this, "APrimalCharacter.bOverrideBlendSpaceSmoothType" }; }

    BitFieldValue<bool, unsigned __int32> bSetAnimationTickPrerequisite() { return { this, "APrimalCharacter.bSetAnimationTickPrerequisite" }; }

    BitFieldValue<bool, unsigned __int32> bNetworkClientsUpdateBasedMovementOnTick() { return { this, "APrimalCharacter.bNetworkClientsUpdateBasedMovementOnTick" }; }

    BitFieldValue<bool, unsigned __int32> bUseArmorDurabilityVFX() { return { this, "APrimalCharacter.bUseArmorDurabilityVFX" }; }

    BitFieldValue<bool, unsigned __int32> bPreventStaggeredMovement() { return { this, "APrimalCharacter.bPreventStaggeredMovement" }; }

    BitFieldValue<bool, unsigned __int32> bBPForceUseOldASECamera() { return { this, "APrimalCharacter.bBPForceUseOldASECamera" }; }

    BitFieldValue<bool, unsigned __int32> bUsesWaterFinLocking() { return { this, "APrimalCharacter.bUsesWaterFinLocking" }; }


    // Functions


    bool IsBeingDestroyed() { return NativeCall<bool>(this, "APrimalCharacter.IsBeingDestroyed()"); }

    UMeshComponent* GetSkeletalMeshComponent() { return NativeCall<UMeshComponent*>(this, "APrimalCharacter.GetSkeletalMeshComponent()"); }

    ENetRole GetRole() { return NativeCall<ENetRole>(this, "APrimalCharacter.GetRole()"); }

    bool IsReadyForDynamicBasing() { return NativeCall<bool>(this, "APrimalCharacter.IsReadyForDynamicBasing()"); }

    bool AllowOverrideSwimmingAcceleration() { return NativeCall<bool>(this, "APrimalCharacter.AllowOverrideSwimmingAcceleration()"); }

    bool IsInMission() { return NativeCall<bool>(this, "APrimalCharacter.IsInMission()"); }

    bool IsGamePlayRelevant() { return NativeCall<bool>(this, "APrimalCharacter.IsGamePlayRelevant()"); }

    long double GetLastGameplayRelevantTime() { return NativeCall<long double>(this, "APrimalCharacter.GetLastGameplayRelevantTime()"); }

    float GetStasisConsumerRangeMultiplier() { return NativeCall<float>(this, "APrimalCharacter.GetStasisConsumerRangeMultiplier()"); }

    void BP_OnZoomIn() { NativeCall<void>(this, "APrimalCharacter.BP_OnZoomIn()"); }

    float BPAdjustDamage(float IncomingDamage, FDamageEvent* TheDamageEvent, AController* EventInstigator, AActor* DamageCauser, bool bIsPointDamage, FHitResult* PointHitInfo) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*, bool, FHitResult*>(this, "APrimalCharacter.BPAdjustDamage(float,FDamageEvent,AController*,AActor*,bool,FHitResult)", IncomingDamage, TheDamageEvent, EventInstigator, DamageCauser, bIsPointDamage, PointHitInfo); }

    float BPModifyViewHitDir(APrimalCharacter* viewingCharacter, float InViewHitDir) { return NativeCall<float, APrimalCharacter*, float>(this, "APrimalCharacter.BPModifyViewHitDir(APrimalCharacter*,float)", viewingCharacter, InViewHitDir); }

    void BPOnStaminaDrained() { NativeCall<void>(this, "APrimalCharacter.BPOnStaminaDrained()"); }

    bool BPOverrideCameraArmLengthInterpParams(const FPrimalCameraParams* CameraParams, FPrimalCameraInterpParams* OutInterpParams) { return NativeCall<bool, const FPrimalCameraParams*, FPrimalCameraInterpParams*>(this, "APrimalCharacter.BPOverrideCameraArmLengthInterpParams(FPrimalCameraParams&,FPrimalCameraInterpParams&)", CameraParams, OutInterpParams); }

    void BPOverrideReleaseItemSlot(int ItemSlot) { NativeCall<void, int>(this, "APrimalCharacter.BPOverrideReleaseItemSlot(int)", ItemSlot); }

    void BPOverrideUseItemSlot(int ItemSlot) { NativeCall<void, int>(this, "APrimalCharacter.BPOverrideUseItemSlot(int)", ItemSlot); }

    void ClientOrderedAttackTarget(AActor* attackTarget) { NativeCall<void, AActor*>(this, "APrimalCharacter.ClientOrderedAttackTarget(AActor*)", attackTarget); }

    void ClientSyncAnimation(UAnimMontage* AnimMontage, float PlayRate, float ServerCurrentMontageTime, bool bForceTickPoseAndServerUpdateMesh, float BlendInTime, float BlendOutTime) { NativeCall<void, UAnimMontage*, float, float, bool, float, float>(this, "APrimalCharacter.ClientSyncAnimation(UAnimMontage*,float,float,bool,float,float)", AnimMontage, PlayRate, ServerCurrentMontageTime, bForceTickPoseAndServerUpdateMesh, BlendInTime, BlendOutTime); }

    TSubclassOf<UToolTipWidget>* GetCustomTooltip(TSubclassOf<UToolTipWidget>* result, UE::Math::TVector2<double>* tooltipPadding, UE::Math::TVector2<double>* tooltipScale, UE::Math::TVector<double>* tooltipLocationOffset) { return NativeCall<TSubclassOf<UToolTipWidget> *, TSubclassOf<UToolTipWidget>*, UE::Math::TVector2<double>*, UE::Math::TVector2<double>*, UE::Math::TVector<double>*>(this, "APrimalCharacter.GetCustomTooltip(UE::Math::TVector2<double>&,UE::Math::TVector2<double>&,UE::Math::TVector<double>&)", result, tooltipPadding, tooltipScale, tooltipLocationOffset); }

    FName* GetOverrideSocket(FName* result, FName from) { return NativeCall<FName*, FName*, FName>(this, "APrimalCharacter.GetOverrideSocket(FName)", result, from); }

    UMeshComponent* GetPaintingMesh() { return NativeCall<UMeshComponent*>(this, "APrimalCharacter.GetPaintingMesh()"); }

    void LocalUnpossessed() { NativeCall<void>(this, "APrimalCharacter.LocalUnpossessed()"); }

    void NetPlaySoundOnCharacter(USoundBase* SoundToPlay, bool bPlayOnOwner) { NativeCall<void, USoundBase*, bool>(this, "APrimalCharacter.NetPlaySoundOnCharacter(USoundBase*,bool)", SoundToPlay, bPlayOnOwner); }

    void OnBeginDrag(APrimalCharacter* Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "APrimalCharacter.OnBeginDrag(APrimalCharacter*,int,bool)", Dragged, BoneIndex, bWithGrapHook); }

    void OnEndDrag() { NativeCall<void>(this, "APrimalCharacter.OnEndDrag()"); }

    void PlayHitEffectGeneric(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectGeneric(float,FDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void PlayHitEffectPoint(float DamageTaken, FPointDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FPointDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectPoint(float,FPointDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void PlayHitEffectRadial(float DamageTaken, FRadialDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FRadialDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectRadial(float,FRadialDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    bool PreventsTargeting(AActor* ByActor) { return NativeCall<bool, AActor*>(this, "APrimalCharacter.PreventsTargeting(AActor*)", ByActor); }

    void ServerCallAggressive() { NativeCall<void>(this, "APrimalCharacter.ServerCallAggressive()"); }

    void ServerCallAttackTarget(AActor* TheTarget) { NativeCall<void, AActor*>(this, "APrimalCharacter.ServerCallAttackTarget(AActor*)", TheTarget); }

    void ServerCallFollow() { NativeCall<void>(this, "APrimalCharacter.ServerCallFollow()"); }

    void ServerCallMoveTo(UE::Math::TVector<double>* MoveToLoc) { NativeCall<void, UE::Math::TVector<double>*>(this, "APrimalCharacter.ServerCallMoveTo(UE::Math::TVector<double>)", MoveToLoc); }

    void ServerCallNeutral() { NativeCall<void>(this, "APrimalCharacter.ServerCallNeutral()"); }

    void ServerCallPassive() { NativeCall<void>(this, "APrimalCharacter.ServerCallPassive()"); }

    void ServerCallSetAggressive() { NativeCall<void>(this, "APrimalCharacter.ServerCallSetAggressive()"); }

    void ServerCallStay() { NativeCall<void>(this, "APrimalCharacter.ServerCallStay()"); }

    void ServerCaptureDermis(APrimalCharacter* Target) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.ServerCaptureDermis(APrimalCharacter*)", Target); }

    void ServerDinoOrder(APrimalDinoCharacter* aDino, EDinoTamedOrder::Type OrderType, AActor* target) { NativeCall<void, APrimalDinoCharacter*, EDinoTamedOrder::Type, AActor*>(this, "APrimalCharacter.ServerDinoOrder(APrimalDinoCharacter*,EDinoTamedOrder::Type,AActor*)", aDino, OrderType, target); }

    void ToggleWeapon() { NativeCall<void>(this, "APrimalCharacter.ToggleWeapon()"); }

    void ServerRequestDrag() { NativeCall<void>(this, "APrimalCharacter.ServerRequestDrag()"); }

    void ServerTryPoop() { NativeCall<void>(this, "APrimalCharacter.ServerTryPoop()"); }

    void SetCameraProfile(FName NewProfileId) { NativeCall<void, FName>(this, "APrimalCharacter.SetCameraProfile(FName)", NewProfileId); }

    static void StaticRegisterNativesAPrimalCharacter() { NativeCall<void>(nullptr, "APrimalCharacter.StaticRegisterNativesAPrimalCharacter()"); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalCharacter.StaticClass()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void Serialize(FStructuredArchiveRecord Record) { NativeCall<void, FStructuredArchiveRecord>(this, "APrimalCharacter.Serialize(FStructuredArchiveRecord)", Record); }

    UAnimMontage* GetPoopAnimation(bool bForcePoop) { return NativeCall<UAnimMontage*, bool>(this, "APrimalCharacter.GetPoopAnimation(bool)", bForcePoop); }

    long double GetLastStartedTalkingTime() { return NativeCall<long double>(this, "APrimalCharacter.GetLastStartedTalkingTime()"); }

    bool IsVoiceTalking() { return NativeCall<bool>(this, "APrimalCharacter.IsVoiceTalking()"); }

    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "APrimalCharacter.CanJumpInternal_Implementation()"); }

    void RegisterAllComponents() { NativeCall<void>(this, "APrimalCharacter.RegisterAllComponents()"); }

    void PreInitializeComponents() { NativeCall<void>(this, "APrimalCharacter.PreInitializeComponents()"); }

    void ValidatePaintingComponentOctree() { NativeCall<void>(this, "APrimalCharacter.ValidatePaintingComponentOctree()"); }

    void PostInitializeComponents() { NativeCall<void>(this, "APrimalCharacter.PostInitializeComponents()"); }

    void Destroyed() { NativeCall<void>(this, "APrimalCharacter.Destroyed()"); }

    void BeginPlay() { NativeCall<void>(this, "APrimalCharacter.BeginPlay()"); }

    void FellOutOfWorld(const UDamageType* dmgType) { NativeCall<void, const UDamageType*>(this, "APrimalCharacter.FellOutOfWorld(UDamageType&)", dmgType); }

    void Suicide() { NativeCall<void>(this, "APrimalCharacter.Suicide()"); }

    bool IsDead() { return NativeCall<bool>(this, "APrimalCharacter.IsDead()"); }

    void InventoryItemUsed(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "APrimalCharacter.InventoryItemUsed(UObject*)", InventoryItemObject); }

    void AdjustDamage(float* Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, const FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.AdjustDamage(float&,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    bool CanBeTargetedBy(const ITargetableInterface* Attacker) { return NativeCall<bool, const ITargetableInterface*>(this, "APrimalCharacter.CanBeTargetedBy(ITargetableInterface*)", Attacker); }

    bool IsValidForCombatMusic() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForCombatMusic()"); }

    float TakeDamage(float Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, const FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.TakeDamage(float,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    void HurtMe(int HowMuch) { NativeCall<void, int>(this, "APrimalCharacter.HurtMe(int)", HowMuch); }

    bool CanDie(float KillingDamage, const FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, const FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.CanDie(float,FDamageEvent&,AController*,AActor*)", KillingDamage, DamageEvent, Killer, DamageCauser); }

    bool CanMoveThroughActor_Implementation(AActor* actor) { return NativeCall<bool, AActor*>(this, "APrimalCharacter.CanMoveThroughActor_Implementation(AActor*)", actor); }

    bool Die(float KillingDamage, const FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, const FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.Die(float,FDamageEvent&,AController*,AActor*)", KillingDamage, DamageEvent, Killer, DamageCauser); }

    void DeathHarvestingDepleted() { NativeCall<void>(this, "APrimalCharacter.DeathHarvestingDepleted(UPrimalHarvestingComponent*)"); }

    void PlayDyingPoint_Implementation(float KillingDamage, FPointDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FPointDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayDyingPoint_Implementation(float,FPointDamageEvent,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void PlayDyingRadial_Implementation(float KillingDamage, FRadialDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FRadialDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayDyingRadial_Implementation(float,FRadialDamageEvent,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void SetDeath(bool bJoinInProgress, bool AllowMovementModeChange) { NativeCall<void, bool, bool>(this, "APrimalCharacter.SetDeath(bool,bool)", bJoinInProgress, AllowMovementModeChange); }

    bool CanIgnoreImmobilizationTrap(TSubclassOf<APrimalStructure> TrapClass, bool* bForceTrigger) { return NativeCall<bool, TSubclassOf<APrimalStructure>, bool*>(this, "APrimalCharacter.CanIgnoreImmobilizationTrap(TSubclassOf<APrimalStructure>,bool&)", TrapClass, bForceTrigger); }

    void Immobilize(bool bImmobilize, AActor* UsingActor, bool bImmobilizeFalling, bool bPreventDismount) { NativeCall<void, bool, AActor*, bool, bool>(this, "APrimalCharacter.Immobilize(bool,AActor*,bool,bool)", bImmobilize, UsingActor, bImmobilizeFalling, bPreventDismount); }

    float GetCorpseLifespan() { return NativeCall<float>(this, "APrimalCharacter.GetCorpseLifespan()"); }

    void PlayDying(float KillingDamage, const FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayDying(float,FDamageEvent&,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void PlayHitEffectGeneric_Implementation(float DamageTaken, FPointDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FPointDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectGeneric_Implementation(float,FDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void PlayHitEffectRadial_Implementation(float DamageTaken, FRadialDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FRadialDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectRadial_Implementation(float,FRadialDamageEvent,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    bool AllowHurtAnimation() { return NativeCall<bool>(this, "APrimalCharacter.AllowHurtAnimation()"); }

    UPrimitiveComponent* GetPrimaryHitComponent() { return NativeCall<UPrimitiveComponent*>(this, "APrimalCharacter.GetPrimaryHitComponent()"); }

    void PlayHitEffect(float DamageTaken, const FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser, bool bIsLocalPath, bool bSuppressImpactSound) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*, bool, bool>(this, "APrimalCharacter.PlayHitEffect(float,FDamageEvent&,APawn*,AActor*,bool,bool)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser, bIsLocalPath, bSuppressImpactSound); }

    void PlayHurtAnim(float DamageTaken, const FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser, bool bIsLocalPath) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*, bool>(this, "APrimalCharacter.PlayHurtAnim(float,FDamageEvent&,APawn*,AActor*,bool)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser, bIsLocalPath); }

    void DoSetRagdollPhysics() { NativeCall<void>(this, "APrimalCharacter.DoSetRagdollPhysics()"); }

    void SetRagdollPhysics(bool bUseRagdollLocationOffset, bool bForceRecreateBones, bool bForLoading) { NativeCall<void, bool, bool, bool>(this, "APrimalCharacter.SetRagdollPhysics(bool,bool,bool)", bUseRagdollLocationOffset, bForceRecreateBones, bForLoading); }

    void CheckOnDinoPlatformSaddle() { NativeCall<void>(this, "APrimalCharacter.CheckOnDinoPlatformSaddle()"); }

    void ForceSleepRagdollEx() { NativeCall<void>(this, "APrimalCharacter.ForceSleepRagdollEx()"); }

    void ForceSleepRagdoll() { NativeCall<void>(this, "APrimalCharacter.ForceSleepRagdoll()"); }

    void RemoveBasedPawns(USceneComponent* BasedOnComponent) { NativeCall<void, USceneComponent*>(this, "APrimalCharacter.RemoveBasedPawns(USceneComponent*)", BasedOnComponent); }

    void ClearRagdollPhysics() { NativeCall<void>(this, "APrimalCharacter.ClearRagdollPhysics()"); }

    void DoFindGoodSpot(UE::Math::TVector<double>* RagdollLoc, bool bClearCollisionSweep) { NativeCall<void, UE::Math::TVector<double>*, bool>(this, "APrimalCharacter.DoFindGoodSpot(UE::Math::TVector<double>,bool)", RagdollLoc, bClearCollisionSweep); }

    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset, bool bPreserveSavedAnim) { NativeCall<void, bool, bool, bool>(this, "APrimalCharacter.SetSleeping(bool,bool,bool)", bSleeping, bUseRagdollLocationOffset, bPreserveSavedAnim); }

    void NetPlayDeathAnimIfNeeded_Implementation(bool bOnlyPlayOnClient) { NativeCall<void, bool>(this, "APrimalCharacter.NetPlayDeathAnimIfNeeded_Implementation(bool)", bOnlyPlayOnClient); }

    void PlayDeathAnimIfNeeded(bool bWasPlayingDeathAnim) { NativeCall<void, bool>(this, "APrimalCharacter.PlayDeathAnimIfNeeded(bool)", bWasPlayingDeathAnim); }

    void TryPlaySleepingAnim(bool bWasPlayingDeathAnim) { NativeCall<void, bool>(this, "APrimalCharacter.TryPlaySleepingAnim(bool)", bWasPlayingDeathAnim); }

    void TryPlayDeathAnim() { NativeCall<void>(this, "APrimalCharacter.TryPlayDeathAnim()"); }

    void ExecSetSleeping(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.ExecSetSleeping(bool)", bEnable); }

    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "APrimalCharacter.ChangeActorTeam(int)", NewTeam); }

    void UpdateTribeName(FString* NewTribeName) { NativeCall<void, FString*>(this, "APrimalCharacter.UpdateTribeName(FString)", NewTribeName); }

    void NetUpdateTribeName_Implementation(const FString* NewTribeName) { NativeCall<void, const FString*>(this, "APrimalCharacter.NetUpdateTribeName_Implementation(FString&)", NewTribeName); }

    float GetMaxCursorHUDDistance(AShooterPlayerController* PC) { return NativeCall<float, AShooterPlayerController*>(this, "APrimalCharacter.GetMaxCursorHUDDistance(AShooterPlayerController*)", PC); }

    bool IsSubmerged(bool bDontCheckSwimming, bool bUseFullThreshold, bool bForceCheck, bool bFromVolumeChange) { return NativeCall<bool, bool, bool, bool, bool>(this, "APrimalCharacter.IsSubmerged(bool,bool,bool,bool)", bDontCheckSwimming, bUseFullThreshold, bForceCheck, bFromVolumeChange); }

    float GetWaterSubmergedDepthThreshold() { return NativeCall<float>(this, "APrimalCharacter.GetWaterSubmergedDepthThreshold()"); }

    float PlayAnimMontage(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer, float BlendInTime, float BlendOutTime) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool, float, float>(this, "APrimalCharacter.PlayAnimMontage(UAnimMontage*,float,FName,bool,bool,float,float)", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, BlendInTime, BlendOutTime); }

    void StopAnimMontage(UAnimMontage* AnimMontage) { NativeCall<void, UAnimMontage*>(this, "APrimalCharacter.StopAnimMontage(UAnimMontage*)", AnimMontage); }

    bool IsMontagePlaying(UAnimMontage* AnimMontage, float TimeFromEndToConsiderFinished) { return NativeCall<bool, UAnimMontage*, float>(this, "APrimalCharacter.IsMontagePlaying(UAnimMontage*,float)", AnimMontage, TimeFromEndToConsiderFinished); }

    void SetupPlayerInputComponent(UInputComponent* WithInputComponent) { NativeCall<void, UInputComponent*>(this, "APrimalCharacter.SetupPlayerInputComponent(UInputComponent*)", WithInputComponent); }

    void TryGiveDefaultWeapon() { NativeCall<void>(this, "APrimalCharacter.TryGiveDefaultWeapon()"); }

    void TryGiveDefaultWeaponReleased() { NativeCall<void>(this, "APrimalCharacter.TryGiveDefaultWeaponReleased()"); }

    void TryPoop() { NativeCall<void>(this, "APrimalCharacter.TryPoop()"); }

    void OrbitCamToggle() { NativeCall<void>(this, "APrimalCharacter.OrbitCamToggle()"); }

    void OrbitCamOn() { NativeCall<void>(this, "APrimalCharacter.OrbitCamOn()"); }

    void OrbitCamOff() { NativeCall<void>(this, "APrimalCharacter.OrbitCamOff()"); }

    void ServerRequestDrag_Implementation() { NativeCall<void>(this, "APrimalCharacter.ServerRequestDrag_Implementation()"); }

    void ServerDinoOrder_Implementation(APrimalDinoCharacter* aDino, EDinoTamedOrder::Type OrderType, AActor* enemyTarget) { NativeCall<void, APrimalDinoCharacter*, EDinoTamedOrder::Type, AActor*>(this, "APrimalCharacter.ServerDinoOrder_Implementation(APrimalDinoCharacter*,EDinoTamedOrder::Type,AActor*)", aDino, OrderType, enemyTarget); }

    void GetInputSpeedModifier(float* Val) { NativeCall<void, float*>(this, "APrimalCharacter.GetInputSpeedModifier(float&)", Val); }

    void MoveForward(float Val) { NativeCall<void, float>(this, "APrimalCharacter.MoveForward(float)", Val); }

    void MoveRight(float Val) { NativeCall<void, float>(this, "APrimalCharacter.MoveRight(float)", Val); }

    void MoveUp(float Val) { NativeCall<void, float>(this, "APrimalCharacter.MoveUp(float)", Val); }

    void TurnInput(float Val) { NativeCall<void, float>(this, "APrimalCharacter.TurnInput(float)", Val); }

    void LookInput(float Val) { NativeCall<void, float>(this, "APrimalCharacter.LookInput(float)", Val); }

    void TurnAtRate(float Val) { NativeCall<void, float>(this, "APrimalCharacter.TurnAtRate(float)", Val); }

    void LookUpAtRate(float Val) { NativeCall<void, float>(this, "APrimalCharacter.LookUpAtRate(float)", Val); }

    bool IsGamepadActive() { return NativeCall<bool>(this, "APrimalCharacter.IsGamepadActive()"); }

    bool IsInputAllowed() { return NativeCall<bool>(this, "APrimalCharacter.IsInputAllowed()"); }

    void OnStartFire() { NativeCall<void>(this, "APrimalCharacter.OnStartFire()"); }

    void OnStopFire() { NativeCall<void>(this, "APrimalCharacter.OnStopFire()"); }

    void OnStartTargeting() { NativeCall<void>(this, "APrimalCharacter.OnStartTargeting()"); }

    void OnStopTargeting() { NativeCall<void>(this, "APrimalCharacter.OnStopTargeting()"); }

    void OnAltFirePressed() { NativeCall<void>(this, "APrimalCharacter.OnAltFirePressed()"); }

    void OnAltFireReleased() { NativeCall<void>(this, "APrimalCharacter.OnAltFireReleased()"); }

    void OnStartAltFire() { NativeCall<void>(this, "APrimalCharacter.OnStartAltFire()"); }

    void OnStopAltFire() { NativeCall<void>(this, "APrimalCharacter.OnStopAltFire()"); }

    void OnStartRunning() { NativeCall<void>(this, "APrimalCharacter.OnStartRunning()"); }

    void OnStopRunning() { NativeCall<void>(this, "APrimalCharacter.OnStopRunning()"); }

    void OnRunTogglePressed() { NativeCall<void>(this, "APrimalCharacter.OnRunTogglePressed()"); }

    void OnRunToggleReleased() { NativeCall<void>(this, "APrimalCharacter.OnRunToggleReleased()"); }

    //TArray<FTooltipTextInfo, TSizedDefaultAllocator<32> >* GetTooltipCharacterInfo(TArray<FTooltipTextInfo, TSizedDefaultAllocator<32> >* result, AShooterPlayerController* PlayerOwner) { return NativeCall<TArray<FTooltipTextInfo, TSizedDefaultAllocator<32> >*, TArray<FTooltipTextInfo, TSizedDefaultAllocator<32> >*, AShooterPlayerController*>(this, "APrimalCharacter.GetTooltipCharacterInfo(AShooterPlayerController*)", result, PlayerOwner); }

    bool IsTurningTooFastToRun(const UE::Math::TVector<double>* Velocity, const UE::Math::TRotator<double>* Rotation) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*>(this, "APrimalCharacter.IsTurningTooFastToRun(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", Velocity, Rotation); }

    bool IsRunning() { return NativeCall<bool>(this, "APrimalCharacter.IsRunning()"); }

    bool IsMoving() { return NativeCall<bool>(this, "APrimalCharacter.IsMoving()"); }

    void UpdateStatusComponent(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.UpdateStatusComponent(float)", DeltaSeconds); }

    void ServerCaptureDermis_Implementation(APrimalCharacter* Target) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.ServerCaptureDermis_Implementation(APrimalCharacter*)", Target); }

    void CaptureCharacterSnapshot(UPrimalItem* Item) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.CaptureCharacterSnapshot(UPrimalItem*)", Item); }

    static void StaticApplyCharacterSnapshot(UPrimalItem* Item, AActor* To, UE::Math::TVector<double>* Offset, float MaxExtent, int Pose, bool bCollisionOn) { NativeCall<void, UPrimalItem*, AActor*, UE::Math::TVector<double>*, float, int, bool>(nullptr, "APrimalCharacter.StaticApplyCharacterSnapshot(UPrimalItem*,AActor*,UE::Math::TVector<double>,float,int,bool)", Item, To, Offset, MaxExtent, Pose, bCollisionOn); }

    static void StaticApplyCharacterSnapshotEquipment(UPrimalInventoryComponent* Inventory, AActor* To) { NativeCall<void, UPrimalInventoryComponent*, AActor*>(nullptr, "APrimalCharacter.StaticApplyCharacterSnapshotEquipment(UPrimalInventoryComponent*,AActor*)", Inventory, To); }

    static void StaticRemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(nullptr, "APrimalCharacter.StaticRemoveCharacterSnapshot(UPrimalItem*,AActor*)", Item, From); }

    static int StaticGetSnapshotPoseCount(UPrimalItem* Item) { return NativeCall<int, UPrimalItem*>(nullptr, "APrimalCharacter.StaticGetSnapshotPoseCount(UPrimalItem*)", Item); }

    static FPrimalSnapshotPose* StaticGetSnapshotPose(FPrimalSnapshotPose* result, UPrimalItem* Item, int PoseIndex) { return NativeCall<FPrimalSnapshotPose*, FPrimalSnapshotPose*, UPrimalItem*, int>(nullptr, "APrimalCharacter.StaticGetSnapshotPose(UPrimalItem*,int)", result, Item, PoseIndex); }

    void ApplyCharacterSnapshot(UPrimalItem* Item, AActor* To, UE::Math::TVector<double>* Offset, float MaxExtent, int Pose, bool bCollisionOn) { NativeCall<void, UPrimalItem*, AActor*, UE::Math::TVector<double>*, float, int, bool>(this, "APrimalCharacter.ApplyCharacterSnapshot(UPrimalItem*,AActor*,UE::Math::TVector<double>,float,int,bool)", Item, To, Offset, MaxExtent, Pose, bCollisionOn); }

    void RemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(this, "APrimalCharacter.RemoveCharacterSnapshot(UPrimalItem*,AActor*)", Item, From); }

    static UActorComponent* GetSnapshotComponent(AActor* From, FName Tag) { return NativeCall<UActorComponent*, AActor*, FName>(nullptr, "APrimalCharacter.GetSnapshotComponent(AActor*,FName)", From, Tag); }

    static UActorComponent* CreateSnapshotComponent(AActor* For, UObject* Template, FName Tag, FName Name) { return NativeCall<UActorComponent*, AActor*, UObject*, FName, FName>(nullptr, "APrimalCharacter.CreateSnapshotComponent(AActor*,UObject*,FName,FName)", For, Template, Tag, Name); }

    void UpdateStencilValues() { NativeCall<void>(this, "APrimalCharacter.UpdateStencilValues()"); }

    void CheckRegisterCharacterMesh() { NativeCall<void>(this, "APrimalCharacter.CheckRegisterCharacterMesh()"); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.Tick(float)", DeltaSeconds); }

    void EndPlay(const EEndPlayReason::Type EndPlayReason) { NativeCall<void, const EEndPlayReason::Type>(this, "APrimalCharacter.EndPlay(EEndPlayReason::Type)", EndPlayReason); }

    void SetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "APrimalCharacter.SetCharacterMeshesMaterialScalarParamValue(FName,float)", ParamName, Value); }

    APhysicsVolume* GetApproximateLocationPhysicsVolume(bool bForceUpdate, const UE::Math::TVector<double>* LocOffset, bool bFavorWaterVolume) { return NativeCall<APhysicsVolume*, bool, const UE::Math::TVector<double>*, bool>(this, "APrimalCharacter.GetApproximateLocationPhysicsVolume(bool,UE::Math::TVector<double>&,bool)", bForceUpdate, LocOffset, bFavorWaterVolume); }

    void UpdateSwimmingState() { NativeCall<void>(this, "APrimalCharacter.UpdateSwimmingState()"); }

    bool IsOwningClient() { return NativeCall<bool>(this, "APrimalCharacter.IsOwningClient()"); }

    void GetCharacterViewLocationAndDirection(UE::Math::TVector<double>* OutViewLocation, UE::Math::TVector<double>* OutViewDirection, bool* OutFromCrosshairOrCamera, float FallbackAngleOffsetDegrees) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, bool*, float>(this, "APrimalCharacter.GetCharacterViewLocationAndDirection(UE::Math::TVector<double>&,UE::Math::TVector<double>&,bool&,float)", OutViewLocation, OutViewDirection, OutFromCrosshairOrCamera, FallbackAngleOffsetDegrees); }

    void ZoomIn() { NativeCall<void>(this, "APrimalCharacter.ZoomIn()"); }

    void ZoomOut() { NativeCall<void>(this, "APrimalCharacter.ZoomOut()"); }

    void OnStartJump() { NativeCall<void>(this, "APrimalCharacter.OnStartJump()"); }

    void PlayJumpAnim() { NativeCall<void>(this, "APrimalCharacter.PlayJumpAnim()"); }

    void PlayLandedAnim() { NativeCall<void>(this, "APrimalCharacter.PlayLandedAnim()"); }

    void OnJumped_Implementation() { NativeCall<void>(this, "APrimalCharacter.OnJumped_Implementation()"); }

    void NetOnJumped_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetOnJumped_Implementation()"); }

    void OnStopJump() { NativeCall<void>(this, "APrimalCharacter.OnStopJump()"); }

    void PreReplication(IRepChangedPropertyTracker* ChangedPropertyTracker) { NativeCall<void, IRepChangedPropertyTracker*>(this, "APrimalCharacter.PreReplication(IRepChangedPropertyTracker&)", ChangedPropertyTracker); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    float GetRunningSpeedModifier(bool bIsForDefaultSpeed) { return NativeCall<float, bool>(this, "APrimalCharacter.GetRunningSpeedModifier(bool)", bIsForDefaultSpeed); }

    float GetMaxHealth() { return NativeCall<float>(this, "APrimalCharacter.GetMaxHealth()"); }

    bool AllowFirstPerson() { return NativeCall<bool>(this, "APrimalCharacter.AllowFirstPerson()"); }

    AActor* GetAimedActor(ECollisionChannel CollisionChannel, UActorComponent** HitComponent, float MaxDistanceOverride, float CheckRadius, int* hitBodyIndex, FHitResult* outHitResult, bool bForceUseCameraLocation, bool bForceUpdateAimedActors, bool bForceUseActorLocation, bool* bIsDirectHit) { return NativeCall<AActor*, ECollisionChannel, UActorComponent**, float, float, int*, FHitResult*, bool, bool, bool, bool*>(this, "APrimalCharacter.GetAimedActor(ECollisionChannel,UActorComponent**,float,float,int*,FHitResult*,bool,bool,bool,bool*)", CollisionChannel, HitComponent, MaxDistanceOverride, CheckRadius, hitBodyIndex, outHitResult, bForceUseCameraLocation, bForceUpdateAimedActors, bForceUseActorLocation, bIsDirectHit); }

    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "APrimalCharacter.OnPrimalCharacterSleeped()"); }

    TSubclassOf<UToolTipWidget>* GetCustomTooltip_Implementation(TSubclassOf<UToolTipWidget>* result, UE::Math::TVector2<double>* tooltipPadding, UE::Math::TVector2<double>* tooltipScale, UE::Math::TVector<double>* tooltipLocationOffset) { return NativeCall<TSubclassOf<UToolTipWidget> *, TSubclassOf<UToolTipWidget>*, UE::Math::TVector2<double>*, UE::Math::TVector2<double>*, UE::Math::TVector<double>*>(this, "APrimalCharacter.GetCustomTooltip_Implementation(UE::Math::TVector2<double>&,UE::Math::TVector2<double>&,UE::Math::TVector<double>&)", result, tooltipPadding, tooltipScale, tooltipLocationOffset); }

    void OnPrimalCharacterUnsleeped() { NativeCall<void>(this, "APrimalCharacter.OnPrimalCharacterUnsleeped()"); }

    void ControlRigNotify(FName NotifyName, FName NotifyCustomTag, const FHitResult* WorldSpaceHitResult, const UE::Math::TVector<double>* Velocity) { NativeCall<void, FName, FName, const FHitResult*, const UE::Math::TVector<double>*>(this, "APrimalCharacter.ControlRigNotify(FName,FName,FHitResult&,UE::Math::TVector<double>&)", NotifyName, NotifyCustomTag, WorldSpaceHitResult, Velocity); }

    float PlayAnimEx(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bReplicate, bool bReplicateToOwner, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer, bool bForceKeepSynced, float BlendInTime, float BlendOutTime) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool, bool, bool, bool, float, float>(this, "APrimalCharacter.PlayAnimEx(UAnimMontage*,float,FName,bool,bool,bool,bool,bool,float,float)", AnimMontage, InPlayRate, StartSectionName, bReplicate, bReplicateToOwner, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, bForceKeepSynced, BlendInTime, BlendOutTime); }

    void StopAnimEx(UAnimMontage* AnimMontage, bool bReplicate, bool bReplicateToOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, bool, float>(this, "APrimalCharacter.StopAnimEx(UAnimMontage*,bool,bool,float)", AnimMontage, bReplicate, bReplicateToOwner, BlendOutTime); }

    void ClientPlayAnimation_Implementation(UAnimMontage* AnimMontage, float PlayRate, FName StartSectionName, bool bPlayOnOwner, bool bForceTickPoseAndServerUpdateMesh) { NativeCall<void, UAnimMontage*, float, FName, bool, bool>(this, "APrimalCharacter.ClientPlayAnimation_Implementation(UAnimMontage*,float,FName,bool,bool)", AnimMontage, PlayRate, StartSectionName, bPlayOnOwner, bForceTickPoseAndServerUpdateMesh); }

    void ClientSyncAnimation_Implementation(UAnimMontage* AnimMontage, float PlayRate, float ServerCurrentMontageTime, bool bForceTickPoseAndServerUpdateMesh, float BlendInTime, float BlendOutTime) { NativeCall<void, UAnimMontage*, float, float, bool, float, float>(this, "APrimalCharacter.ClientSyncAnimation_Implementation(UAnimMontage*,float,float,bool,float,float)", AnimMontage, PlayRate, ServerCurrentMontageTime, bForceTickPoseAndServerUpdateMesh, BlendInTime, BlendOutTime); }

    void ClientStopAnimation_Implementation(UAnimMontage* AnimMontage, bool bStopOnOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, float>(this, "APrimalCharacter.ClientStopAnimation_Implementation(UAnimMontage*,bool,float)", AnimMontage, bStopOnOwner, BlendOutTime); }

    void SetRunning(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.SetRunning(bool)", bNewRunning); }

    void ServerSetRunning_Implementation(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.ServerSetRunning_Implementation(bool)", bNewRunning); }

    void ControllerLeavingGame(AShooterPlayerController* theController) { NativeCall<void, AShooterPlayerController*>(this, "APrimalCharacter.ControllerLeavingGame(AShooterPlayerController*)", theController); }

    float GetLowHealthPercentage() { return NativeCall<float>(this, "APrimalCharacter.GetLowHealthPercentage()"); }

    bool IsAlive() { return NativeCall<bool>(this, "APrimalCharacter.IsAlive()"); }

    FString* GetDescriptiveName(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalCharacter.GetDescriptiveName()", result); }

    void PrepareForSaving() { NativeCall<void>(this, "APrimalCharacter.PrepareForSaving()"); }

    void CacheDynamicBaseValues() { NativeCall<void>(this, "APrimalCharacter.CacheDynamicBaseValues()"); }

    FString* GetShortName(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalCharacter.GetShortName()", result); }

    TArray<FString, TSizedDefaultAllocator<32> >* GetDetailedDescription(TArray<FString, TSizedDefaultAllocator<32> >* result, const FString* IndentPrefix) { return NativeCall<TArray<FString, TSizedDefaultAllocator<32> >*, TArray<FString, TSizedDefaultAllocator<32> >*, const FString*>(this, "APrimalCharacter.GetDetailedDescription(FString&)", result, IndentPrefix); }

    float GetHealthPercentage() { return NativeCall<float>(this, "APrimalCharacter.GetHealthPercentage()"); }

    float GetHealth() { return NativeCall<float>(this, "APrimalCharacter.GetHealth()"); }

    void AnimNotifyCustomEvent(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const UAnimNotify* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, const UAnimNotify*>(this, "APrimalCharacter.AnimNotifyCustomEvent(FName,USkeletalMeshComponent*,UAnimSequenceBase*,UAnimNotify*)", CustomEventName, MeshComp, Animation, AnimNotifyObject); }

    void AnimNotifyCustomState_Begin(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float TotalDuration, const UAnimNotifyState* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, float, const UAnimNotifyState*>(this, "APrimalCharacter.AnimNotifyCustomState_Begin(FName,USkeletalMeshComponent*,UAnimSequenceBase*,float,UAnimNotifyState*)", CustomEventName, MeshComp, Animation, TotalDuration, AnimNotifyObject); }

    void AnimNotifyCustomState_End(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const UAnimNotifyState* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, const UAnimNotifyState*>(this, "APrimalCharacter.AnimNotifyCustomState_End(FName,USkeletalMeshComponent*,UAnimSequenceBase*,UAnimNotifyState*)", CustomEventName, MeshComp, Animation, AnimNotifyObject); }

    void DrawFloatingChatMessage(AShooterHUD* HUD, FString* Message, long double receivedChatTime) { NativeCall<void, AShooterHUD*, FString*, long double>(this, "APrimalCharacter.DrawFloatingChatMessage(AShooterHUD*,FString,double,APrimalCharacter*)", HUD, Message, receivedChatTime); }

    float GetClientRotationInterpSpeed(const UE::Math::TVector<double>* RootLoc) { return NativeCall<float, const UE::Math::TVector<double>*>(this, "APrimalCharacter.GetClientRotationInterpSpeed(UE::Math::TVector<double>&)", RootLoc); }

    void ForceRefreshBones(UObject* a2) { NativeCall<void, UObject*>(this, "APrimalCharacter.ForceRefreshBones()", a2); }

    void StartForceSkelUpdate(float ForTime, bool bForceUpdateMesh, bool bServerOnly) { NativeCall<void, float, bool, bool>(this, "APrimalCharacter.StartForceSkelUpdate(float,bool,bool)", ForTime, bForceUpdateMesh, bServerOnly); }

    void EndForceSkelUpdate() { NativeCall<void>(this, "APrimalCharacter.EndForceSkelUpdate()"); }

    void ForceMeshRelevant(float Duration) { NativeCall<void, float>(this, "APrimalCharacter.ForceMeshRelevant(float)", Duration); }

    bool IsConscious() { return NativeCall<bool>(this, "APrimalCharacter.IsConscious()"); }

    bool IsEncumbered() { return NativeCall<bool>(this, "APrimalCharacter.IsEncumbered()"); }

    void Stasis() { NativeCall<void>(this, "APrimalCharacter.Stasis()"); }

    void CheckBasedOnDino() { NativeCall<void>(this, "APrimalCharacter.CheckBasedOnDino()"); }

    void Unstasis() { NativeCall<void>(this, "APrimalCharacter.Unstasis()"); }

    void OnVoiceTalkingStateChanged(bool isTalking, bool InbIsMuted) { NativeCall<void, bool, bool>(this, "APrimalCharacter.OnVoiceTalkingStateChanged(bool,bool)", isTalking, InbIsMuted); }

    bool AllowFallDamage(const FHitResult* HitResult, float FallDamageAmount, bool CustomFallDamage) { return NativeCall<bool, const FHitResult*, float, bool>(this, "APrimalCharacter.AllowFallDamage(FHitResult&,float,bool)", HitResult, FallDamageAmount, CustomFallDamage); }

    UPrimalCharacterStatusComponent* GetCharacterStatusComponent() { return NativeCall<UPrimalCharacterStatusComponent*>(this, "APrimalCharacter.GetCharacterStatusComponent()"); }

    void DrawLocalPlayerHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalCharacter.DrawLocalPlayerHUD(AShooterHUD*)", HUD); }

    bool IsInStatusState(EPrimalCharacterStatusState::Type StatusStateType) { return NativeCall<bool, EPrimalCharacterStatusState::Type>(this, "APrimalCharacter.IsInStatusState(EPrimalCharacterStatusState::Type)", StatusStateType); }

    float GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalCharacter.GetMaxSpeedModifier()"); }

    float GetRotationRateModifier() { return NativeCall<float>(this, "APrimalCharacter.GetRotationRateModifier()"); }

    float GetJumpZModifier() { return NativeCall<float>(this, "APrimalCharacter.GetJumpZModifier()"); }

    bool CanBeBaseForCharacter(APawn* Pawn) { return NativeCall<bool, APawn*>(this, "APrimalCharacter.CanBeBaseForCharacter(APawn*)", Pawn); }

    float GetDefaultMovementSpeed() { return NativeCall<float>(this, "APrimalCharacter.GetDefaultMovementSpeed()"); }

    void TakeFallingDamage(const FHitResult* Hit) { NativeCall<void, const FHitResult*>(this, "APrimalCharacter.TakeFallingDamage(FHitResult&)", Hit); }

    void ApplyCustomFallDamage(const UE::Math::TVector<double>* Location, const UE::Math::TVector<double>* Velocity, float FallDamageThreshold) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, float>(this, "APrimalCharacter.ApplyCustomFallDamage(UE::Math::TVector<double>&,UE::Math::TVector<double>&,float)", Location, Velocity, FallDamageThreshold); }

    void NativeOnLanded(const FHitResult* Hit) { NativeCall<void, const FHitResult*>(this, "APrimalCharacter.NativeOnLanded(FHitResult&)", Hit); }

    void NetDidLand_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetDidLand_Implementation()"); }

    void DidLand() { NativeCall<void>(this, "APrimalCharacter.DidLand()"); }

    void FadeOutLoadingMusic() { NativeCall<void>(this, "APrimalCharacter.FadeOutLoadingMusic()"); }

    void LocalPossessedBy(APlayerController* ByController) { NativeCall<void, APlayerController*>(this, "APrimalCharacter.LocalPossessedBy(APlayerController*)", ByController); }

    void LocalUnpossessed_Implementation() { NativeCall<void>(this, "APrimalCharacter.LocalUnpossessed_Implementation()"); }

    UAudioComponent* PlayFootstep() { return NativeCall<UAudioComponent*>(this, "APrimalCharacter.PlayFootstep()"); }

    EPhysicalSurface GetFootPhysicalSurfaceType(bool bForce, bool bIsForFootstepParticles) { return NativeCall<EPhysicalSurface, bool, bool>(this, "APrimalCharacter.GetFootPhysicalSurfaceType(bool,bool)", bForce, bIsForFootstepParticles); }

    EPhysicalSurface GetPhysMatTypeFromHits(const TArray<FHitResult, TSizedDefaultAllocator<32> >* FromHits) { return NativeCall<EPhysicalSurface, const TArray<FHitResult, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.GetPhysMatTypeFromHits(TArray<FHitResult,TSizedDefaultAllocator<32>>&)", FromHits); }

    bool ModifyInputAcceleration(UE::Math::TVector<double>* InputAcceleration) { return NativeCall<bool, UE::Math::TVector<double>*>(this, "APrimalCharacter.ModifyInputAcceleration(UE::Math::TVector<double>&)", InputAcceleration); }

    bool AnimationPreventsInput() { return NativeCall<bool>(this, "APrimalCharacter.AnimationPreventsInput()"); }

    float SetHealth(float newHealth) { return NativeCall<float, float>(this, "APrimalCharacter.SetHealth(float)", newHealth); }

    bool IsOfTribe(int ID) { return NativeCall<bool, int>(this, "APrimalCharacter.IsOfTribe(int)", ID); }

    void SetRagdollReplication(bool Enabled) { NativeCall<void, bool>(this, "APrimalCharacter.SetRagdollReplication(bool)", Enabled); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "APrimalCharacter.Serialize(FArchive&)", Ar); }

    void ReplicateRagdoll() { NativeCall<void>(this, "APrimalCharacter.ReplicateRagdoll()"); }

    void InitRagdollRepConstraints() { NativeCall<void>(this, "APrimalCharacter.InitRagdollRepConstraints()"); }

    void TermRagdollRepConstraints() { NativeCall<void>(this, "APrimalCharacter.TermRagdollRepConstraints()"); }

    //void ClientRagdollUpdate_Implementation(const TArray<FVector_NetQuantize, TSizedDefaultAllocator<32> >* BoneLocations, FRotator_NetQuantize* TargetRootRotation) { NativeCall<void, const TArray<FVector_NetQuantize, TSizedDefaultAllocator<32> >*, FRotator_NetQuantize*>(this, "APrimalCharacter.ClientRagdollUpdate_Implementation(TArray<FVector_NetQuantize,TSizedDefaultAllocator<32>>&,FRotator_NetQuantize)", BoneLocations, TargetRootRotation); }

    void SleepBodies() { NativeCall<void>(this, "APrimalCharacter.SleepBodies()"); }

    void UpdateRagdollReplicationOnClient() { NativeCall<void>(this, "APrimalCharacter.UpdateRagdollReplicationOnClient()"); }

    void ClientEndRagdollUpdate_Implementation(int a2) { NativeCall<void, int>(this, "APrimalCharacter.ClientEndRagdollUpdate_Implementation()", a2); }

    void OnRep_RagdollPositions() { NativeCall<void>(this, "APrimalCharacter.OnRep_RagdollPositions()"); }

    void InitRagdollReplication(__int16 a2) { NativeCall<void, __int16>(this, "APrimalCharacter.InitRagdollReplication()", a2); }

    bool CanDragCharacter(APrimalCharacter* Character, bool bIgnoreWeight) { return NativeCall<bool, APrimalCharacter*, bool>(this, "APrimalCharacter.CanDragCharacter(APrimalCharacter*,bool)", Character, bIgnoreWeight); }

    bool HasEnoughWeightToDragCharacter(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.HasEnoughWeightToDragCharacter(APrimalCharacter*)", Character); }

    void NotifyEquippedItems() { NativeCall<void>(this, "APrimalCharacter.NotifyEquippedItems()"); }

    void NotifyUnequippedItems() { NativeCall<void>(this, "APrimalCharacter.NotifyUnequippedItems()"); }

    bool CanBeDragged() { return NativeCall<bool>(this, "APrimalCharacter.CanBeDragged()"); }

    bool IsInvincible() { return NativeCall<bool>(this, "APrimalCharacter.IsInvincible()"); }

    __int64 GetNearestBoneIndexForDrag(APrimalCharacter* Character, UE::Math::TVector<double>* HitLocation) { return NativeCall<__int64, APrimalCharacter*, UE::Math::TVector<double>*>(this, "APrimalCharacter.GetNearestBoneIndexForDrag(APrimalCharacter*,UE::Math::TVector<double>)", Character, HitLocation); }

    bool TryDragCharacterTarget(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.TryDragCharacterTarget(APrimalCharacter*)", Character); }

    void TryDragCharacter() { NativeCall<void>(this, "APrimalCharacter.TryDragCharacter()"); }

    void UpdateDragging() { NativeCall<void>(this, "APrimalCharacter.UpdateDragging()"); }

    void OnBeginDrag_Implementation(APrimalCharacter* Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "APrimalCharacter.OnBeginDrag_Implementation(APrimalCharacter*,int,bool)", Dragged, BoneIndex, bWithGrapHook); }

    void OnEndDrag_Implementation() { NativeCall<void>(this, "APrimalCharacter.OnEndDrag_Implementation()"); }

    void OnBeginDragged(APrimalCharacter* Dragger) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.OnBeginDragged(APrimalCharacter*)", Dragger); }

    void OnDraggedStarted() { NativeCall<void>(this, "APrimalCharacter.OnDraggedStarted()"); }

    void TickBeingDragged(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.TickBeingDragged(float)", DeltaSeconds); }

    void OnDraggedInterpEnded() { NativeCall<void>(this, "APrimalCharacter.OnDraggedInterpEnded()"); }

    void OnEndDragged(APrimalCharacter* Dragger) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.OnEndDragged(APrimalCharacter*)", Dragger); }

    bool CanBeCarried(APrimalCharacter* ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.CanBeCarried(APrimalCharacter*)", ByCarrier); }

    float GetKillXP() { return NativeCall<float>(this, "APrimalCharacter.GetKillXP()"); }

    void UpdateIK() { NativeCall<void>(this, "APrimalCharacter.UpdateIK()"); }

    //bool IKFootTrace(int LegIndex, FIKLegInfo* LegInfo, UE::Math::TVector<double>* ActorLocation, UE::Math::TVector<double>* ActorForward, UE::Math::TVector<double>* TraceDirection, float TraceDistance) { return NativeCall<bool, int, FIKLegInfo*, UE::Math::TVector<double>*, UE::Math::TVector<double>*, UE::Math::TVector<double>*, float>(this, "APrimalCharacter.IKFootTrace(int,FIKLegInfo&,UE::Math::TVector<double>,UE::Math::TVector<double>,UE::Math::TVector<double>,float)", LegIndex, LegInfo, ActorLocation, ActorForward, TraceDirection, TraceDistance); }

    void EnableIK(bool bEnable, bool bForceOnDedicated) { NativeCall<void, bool, bool>(this, "APrimalCharacter.EnableIK(bool,bool)", bEnable, bForceOnDedicated); }

    void GetMultiUseEntries(APlayerController* ForPC, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* MultiUseEntries, int hitBodyIndex) { NativeCall<void, APlayerController*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*, int>(this, "APrimalCharacter.GetMultiUseEntries(APlayerController*,TArray<FMultiUseEntry,TSizedDefaultAllocator<32>>&,int)", ForPC, MultiUseEntries, hitBodyIndex); }

    void FilterMultiUseEntries(APlayerController* ForPC, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* MultiUseEntries) { NativeCall<void, APlayerController*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.FilterMultiUseEntries(APlayerController*,TArray<FMultiUseEntry,TSizedDefaultAllocator<32>>&)", ForPC, MultiUseEntries); }

    bool TryMultiUse(APlayerController* ForPC, int UseIndex, int hitBodyIndex) { return NativeCall<bool, APlayerController*, int, int>(this, "APrimalCharacter.TryMultiUse(APlayerController*,int,int)", ForPC, UseIndex, hitBodyIndex); }

    void ClientMultiUse(APlayerController* ForPC, int UseIndex, int hitBodyIndex) { NativeCall<void, APlayerController*, int, int>(this, "APrimalCharacter.ClientMultiUse(APlayerController*,int,int)", ForPC, UseIndex, hitBodyIndex); }

    void GetHUDElements(APlayerController* ForPC, TArray<FHUDElement, TSizedDefaultAllocator<32> >* OutElements) { NativeCall<void, APlayerController*, TArray<FHUDElement, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.GetHUDElements(APlayerController*,TArray<FHUDElement,TSizedDefaultAllocator<32>>&)", ForPC, OutElements); }

    void SetBiomeZoneVolume(ABiomeZoneVolume* theVolume) { NativeCall<void, ABiomeZoneVolume*>(this, "APrimalCharacter.SetBiomeZoneVolume(ABiomeZoneVolume*)", theVolume); }

    void ClearBiomeZoneVolume(ABiomeZoneVolume* theVolume) { NativeCall<void, ABiomeZoneVolume*>(this, "APrimalCharacter.ClearBiomeZoneVolume(ABiomeZoneVolume*)", theVolume); }

    void RefreshBiomeZoneVolumes() { NativeCall<void>(this, "APrimalCharacter.RefreshBiomeZoneVolumes()"); }

    void ForceTickPoseDelta(UObject* a2) { NativeCall<void, UObject*>(this, "APrimalCharacter.ForceTickPoseDelta()", a2); }

    bool CheckJumpOutOfWater() { return NativeCall<bool>(this, "APrimalCharacter.CheckJumpOutOfWater()"); }

    bool IsTargetableDead() { return NativeCall<bool>(this, "APrimalCharacter.IsTargetableDead()"); }

    void RequestPoop() { NativeCall<void>(this, "APrimalCharacter.RequestPoop()"); }

    bool Poop(bool bForcePoop) { return NativeCall<bool, bool>(this, "APrimalCharacter.Poop(bool)", bForcePoop); }

    void EmitPoop() { NativeCall<void>(this, "APrimalCharacter.EmitPoop()"); }

    bool IsValidForStatusRecovery() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForStatusRecovery()"); }

    bool GetGroundLocation(UE::Math::TVector<double>* theGroundLoc, const UE::Math::TVector<double>* OffsetUp, const UE::Math::TVector<double>* OffsetDown) { return NativeCall<bool, UE::Math::TVector<double>*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*>(this, "APrimalCharacter.GetGroundLocation(UE::Math::TVector<double>&,UE::Math::TVector<double>&,UE::Math::TVector<double>&)", theGroundLoc, OffsetUp, OffsetDown); }

    void DeathHarvestingFadeOut_Implementation() { NativeCall<void>(this, "APrimalCharacter.DeathHarvestingFadeOut_Implementation()"); }

    void ServerUploadCharacter(AShooterPlayerController* UploadedBy) { NativeCall<void, AShooterPlayerController*>(this, "APrimalCharacter.ServerUploadCharacter(AShooterPlayerController*)", UploadedBy); }

    void ApplyDamageMomentum(float DamageTaken, const FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.ApplyDamageMomentum(float,FDamageEvent&,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void NetAddCharacterMovementImpulse_Implementation(UE::Math::TVector<double>* Impulse, __int64 bVelChange, float ImpulseExponent, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, UE::Math::TVector<double>*, __int64, float, bool, EMovementMode>(this, "APrimalCharacter.NetAddCharacterMovementImpulse_Implementation(UE::Math::TVector<double>,bool,float,bool,EMovementMode,bool)", Impulse, bVelChange, ImpulseExponent, bSetNewMovementMode, NewMovementMode); }

    void NetSetCharacterMovementVelocity_Implementation(bool bSetNewVelocity, UE::Math::TVector<double>* NewVelocity, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, bool, UE::Math::TVector<double>*, bool, EMovementMode>(this, "APrimalCharacter.NetSetCharacterMovementVelocity_Implementation(bool,UE::Math::TVector<double>,bool,EMovementMode)", bSetNewVelocity, NewVelocity, bSetNewMovementMode, NewMovementMode); }

    bool AllowSaving() { return NativeCall<bool>(this, "APrimalCharacter.AllowSaving()"); }

    bool IsWatered() { return NativeCall<bool>(this, "APrimalCharacter.IsWatered()"); }

    void OnDeserializedByGame(EOnDeserializationType::Type DeserializationType) { NativeCall<void, EOnDeserializationType::Type>(this, "APrimalCharacter.OnDeserializedByGame(EOnDeserializationType::Type)", DeserializationType); }

    int LevelUpPlayerAddedStat(TEnumAsByte<EPrimalCharacterStatusValue::Type> StatToLevel, int NumLevels, AShooterPlayerController* ForPlayer) { return NativeCall<int, TEnumAsByte<EPrimalCharacterStatusValue::Type>, int, AShooterPlayerController*>(this, "APrimalCharacter.LevelUpPlayerAddedStat(TEnumAsByte<EPrimalCharacterStatusValue::Type>,int,AShooterPlayerController*)", StatToLevel, NumLevels, ForPlayer); }

    void CheckJumpInput(float DeltaTime) { NativeCall<void, float>(this, "APrimalCharacter.CheckJumpInput(float)", DeltaTime); }

    void ServerTryPoop_Implementation() { NativeCall<void>(this, "APrimalCharacter.ServerTryPoop_Implementation()"); }

    void ClientFailedPoop_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientFailedPoop_Implementation()"); }

    void ClientDidPoop_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientDidPoop_Implementation()"); }

    void TryAccessInventoryWrapper() { NativeCall<void>(this, "APrimalCharacter.TryAccessInventoryWrapper()"); }

    void TryAccessInventoryReleased() { NativeCall<void>(this, "APrimalCharacter.TryAccessInventoryReleased()"); }

    bool TryAccessInventory() { return NativeCall<bool>(this, "APrimalCharacter.TryAccessInventory()"); }

    void ToggleCameraProbeModePressed1(FKey* Key) { NativeCall<void, FKey*>(this, "APrimalCharacter.ToggleCameraProbeModePressed1(FKey)", Key); }

    void ToggleCameraProbeModePressed2(FKey* Key) { NativeCall<void, FKey*>(this, "APrimalCharacter.ToggleCameraProbeModePressed2(FKey)", Key); }

    void ToggleCameraProbeModeReleased1(FKey* Key) { NativeCall<void, FKey*>(this, "APrimalCharacter.ToggleCameraProbeModeReleased1(FKey)", Key); }

    void ToggleCameraProbeModeReleased2(FKey* Key) { NativeCall<void, FKey*>(this, "APrimalCharacter.ToggleCameraProbeModeReleased2(FKey)", Key); }

    void CameraProbeModeNext() { NativeCall<void>(this, "APrimalCharacter.CameraProbeModeNext()"); }

    void CameraProbeModePrevious() { NativeCall<void>(this, "APrimalCharacter.CameraProbeModePrevious()"); }

    bool IsRagdolled() { return NativeCall<bool>(this, "APrimalCharacter.IsRagdolled()"); }

    static void ForceUpdateAimedCharacters(UWorld* World, const UE::Math::TVector<double>* StartLoc, const UE::Math::TVector<double>* EndLoc, AActor* IgnoreActor, bool bForceUpdateIgnoreActor, float TraceRadius, bool bOnlyRefreshRelevancyValues) { NativeCall<void, UWorld*, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, AActor*, bool, float, bool>(nullptr, "APrimalCharacter.ForceUpdateAimedCharacters(UWorld*,UE::Math::TVector<double>&,UE::Math::TVector<double>&,AActor*,bool,float,bool)", World, StartLoc, EndLoc, IgnoreActor, bForceUpdateIgnoreActor, TraceRadius, bOnlyRefreshRelevancyValues); }

    void NetForceUpdateAimedCharacters_Implementation(UE::Math::TVector<double>* StartLoc, UE::Math::TVector<double>* EndLoc, AActor* IgnoreActor, bool bForceUpdateIgnoreActor, float TraceRadius) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*, AActor*, bool, float>(this, "APrimalCharacter.NetForceUpdateAimedCharacters_Implementation(UE::Math::TVector<double>,UE::Math::TVector<double>,AActor*,bool,float)", StartLoc, EndLoc, IgnoreActor, bForceUpdateIgnoreActor, TraceRadius); }

    bool HasBuff(TSubclassOf<APrimalBuff> BuffClass, bool useExactMatch) { return NativeCall<bool, TSubclassOf<APrimalBuff>, bool>(this, "APrimalCharacter.HasBuff(TSubclassOf<APrimalBuff>,bool)", BuffClass, useExactMatch); }

    bool HasBuffWithCustomTag(FName buffCustomTag) { return NativeCall<bool, FName>(this, "APrimalCharacter.HasBuffWithCustomTag(FName)", buffCustomTag); }

    bool HasBuffWithCustomTags(TArray<FName, TSizedDefaultAllocator<32> >* customTags) { return NativeCall<bool, TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.HasBuffWithCustomTags(TArray<FName,TSizedDefaultAllocator<32>>)", customTags); }

    int GetBuffStackCount(TSubclassOf<APrimalBuff> BuffClass, bool useExactMatch) { return NativeCall<int, TSubclassOf<APrimalBuff>, bool>(this, "APrimalCharacter.GetBuffStackCount(TSubclassOf<APrimalBuff>,bool)", BuffClass, useExactMatch); }

    APrimalBuff* GetBuff(TSubclassOf<APrimalBuff> BuffClass) { return NativeCall<APrimalBuff*, TSubclassOf<APrimalBuff>>(this, "APrimalCharacter.GetBuff(TSubclassOf<APrimalBuff>)", BuffClass); }

    void GetBuffs(TArray<APrimalBuff*, TSizedDefaultAllocator<32> >* TheBuffs) { NativeCall<void, TArray<APrimalBuff*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.GetBuffs(TArray<APrimalBuff*,TSizedDefaultAllocator<32>>&)", TheBuffs); }

    APrimalBuff* GetBuffForPostEffect(UMaterialInterface* anEffect) { return NativeCall<APrimalBuff*, UMaterialInterface*>(this, "APrimalCharacter.GetBuffForPostEffect(UMaterialInterface*)", anEffect); }

    void AddAdditionalDefaultBuffs(UWorld* world, TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >* ToBuffs) { NativeCall<void, UWorld*, TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.AddAdditionalDefaultBuffs(UWorld*,TArray<TSoftClassPtr<APrimalBuff>,TSizedDefaultAllocator<32>>&)", world, ToBuffs); }

    void RemoveAllJumpDeactivatedBuffs(APrimalBuff* IgnoredBuff) { NativeCall<void, APrimalBuff*>(this, "APrimalCharacter.RemoveAllJumpDeactivatedBuffs(APrimalBuff*)", IgnoredBuff); }

    //float GetCameraShakeScalar(TSubclassOf<UCameraShakeBase> currentShake, const float currentScale) { return NativeCall<float, TSubclassOf<UCameraShakeBase>, const float>(this, "APrimalCharacter.GetCameraShakeScalar(TSubclassOf<UCameraShakeBase>,float)", currentShake, currentScale); }

    bool IsInSingletonMission() { return NativeCall<bool>(this, "APrimalCharacter.IsInSingletonMission()"); }

    void UpdateNetDynamicMusic() { NativeCall<void>(this, "APrimalCharacter.UpdateNetDynamicMusic()"); }

    void NetPlaySoundOnCharacter_Implementation(USoundBase* SoundToPlay, bool bPlayOnOwner) { NativeCall<void, USoundBase*, bool>(this, "APrimalCharacter.NetPlaySoundOnCharacter_Implementation(USoundBase*,bool)", SoundToPlay, bPlayOnOwner); }

    bool IsMeshGameplayRelevant() { return NativeCall<bool>(this, "APrimalCharacter.IsMeshGameplayRelevant()"); }

    float GetCorpseDecayRate() { return NativeCall<float>(this, "APrimalCharacter.GetCorpseDecayRate()"); }

    void TagFriendlyStructures() { NativeCall<void>(this, "APrimalCharacter.TagFriendlyStructures()"); }

    void DestroyByMeshing() { NativeCall<void>(this, "APrimalCharacter.DestroyByMeshing()"); }

    void SetCarryingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.SetCarryingDino(APrimalDinoCharacter*)", aDino); }

    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalCharacter.ClearCarryingDino(bool,bool)", bFromDino, bCancelAnyCarryBuffs); }

    void OnAttachedToCharacter() { NativeCall<void>(this, "APrimalCharacter.OnAttachedToCharacter()"); }

    void OnDetachedFromCharacter(APrimalCharacter* aCharacter, int OverrideDirection) { NativeCall<void, APrimalCharacter*, int>(this, "APrimalCharacter.OnDetachedFromCharacter(APrimalCharacter*,int)", aCharacter, OverrideDirection); }

    void ClearMountedDino(bool fromMountedDino) { NativeCall<void, bool>(this, "APrimalCharacter.ClearMountedDino(bool)", fromMountedDino); }

    bool DinoMountOnMe(APrimalDinoCharacter* dinoCharacter) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.DinoMountOnMe(APrimalDinoCharacter*)", dinoCharacter); }

    bool CanMountOnMe(APrimalDinoCharacter* dinoCharacter) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.CanMountOnMe(APrimalDinoCharacter*)", dinoCharacter); }

    bool HasCryoSickness() { return NativeCall<bool>(this, "APrimalCharacter.HasCryoSickness()"); }

    float GetDragWeight(APrimalCharacter* ForDragger) { return NativeCall<float, APrimalCharacter*>(this, "APrimalCharacter.GetDragWeight(APrimalCharacter*)", ForDragger); }

    void SetBase(UPrimitiveComponent* NewBaseComponent, const FName BoneName, bool bNotifyPawn) { NativeCall<void, UPrimitiveComponent*, const FName, bool>(this, "APrimalCharacter.SetBase(UPrimitiveComponent*,FName,bool)", NewBaseComponent, BoneName, bNotifyPawn); }

    void UnPossessed() { NativeCall<void>(this, "APrimalCharacter.UnPossessed()"); }

    void TryCallAttackTarget() { NativeCall<void>(this, "APrimalCharacter.TryCallAttackTarget()"); }

    void TryCallMoveTo() { NativeCall<void>(this, "APrimalCharacter.TryCallMoveTo()"); }

    void TryCallMoveToEx(bool bOnlyAttackTarget) { NativeCall<void, bool>(this, "APrimalCharacter.TryCallMoveToEx(bool)", bOnlyAttackTarget); }

    UTexture2D* GetOverrideDefaultCharacterParamTexture(FName theParamName, UTexture2D* CurrentTexture) { return NativeCall<UTexture2D*, FName, UTexture2D*>(this, "APrimalCharacter.GetOverrideDefaultCharacterParamTexture(FName,UTexture2D*)", theParamName, CurrentTexture); }

    bool CanBePainted() { return NativeCall<bool>(this, "APrimalCharacter.CanBePainted()"); }

    UPaintingTexture* GetPaintingTexture() { return NativeCall<UPaintingTexture*>(this, "APrimalCharacter.GetPaintingTexture()"); }

    bool AllowColoringBy(APlayerController* ForPC, UObject* anItem) { return NativeCall<bool, APlayerController*, UObject*>(this, "APrimalCharacter.AllowColoringBy(APlayerController*,UObject*)", ForPC, anItem); }

    void NetStopAllAnimMontage_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetStopAllAnimMontage_Implementation()"); }

    void DeactivateBuffs(TSubclassOf<APrimalBuff> ForBuffClass, UPrimalItem* ForInstigatorItem, bool perfectClassMatch) { NativeCall<void, TSubclassOf<APrimalBuff>, UPrimalItem*, bool>(this, "APrimalCharacter.DeactivateBuffs(TSubclassOf<APrimalBuff>,UPrimalItem*,bool)", ForBuffClass, ForInstigatorItem, perfectClassMatch); }

    bool ExcludePostProcessBlendableMaterial(const UMaterialInterface* BlendableMaterialInterface) { return NativeCall<bool, const UMaterialInterface*>(this, "APrimalCharacter.ExcludePostProcessBlendableMaterial(UMaterialInterface*)", BlendableMaterialInterface); }

    void PostProcessModifyBlendableMaterial(const UMaterialInterface* BlendableMaterialInterface, UMaterialInstanceDynamic* MID) { NativeCall<void, const UMaterialInterface*, UMaterialInstanceDynamic*>(this, "APrimalCharacter.PostProcessModifyBlendableMaterial(UMaterialInterface*,UMaterialInstanceDynamic*)", BlendableMaterialInterface, MID); }

    void TryCallStayOne() { NativeCall<void>(this, "APrimalCharacter.TryCallStayOne()"); }

    void TryCallFollowOne() { NativeCall<void>(this, "APrimalCharacter.TryCallFollowOne()"); }

    void TryCallFollowDistanceCycleOne() { NativeCall<void>(this, "APrimalCharacter.TryCallFollowDistanceCycleOne()"); }

    void TryCallFlyerLandOne() { NativeCall<void>(this, "APrimalCharacter.TryCallFlyerLandOne()"); }

    void OnRep_AttachmentReplication() { NativeCall<void>(this, "APrimalCharacter.OnRep_AttachmentReplication()"); }

    FString* GetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalCharacter.GetDebugInfoString()", result); }

    bool AllowMovementMode(EMovementMode NewMovementMode, unsigned __int8 NewCustomMode) { return NativeCall<bool, EMovementMode, unsigned __int8>(this, "APrimalCharacter.AllowMovementMode(EMovementMode,unsignedchar)", NewMovementMode, NewCustomMode); }

    APrimalDinoCharacter* GetBasedOrSeatingOnDino(__int16 a2) { return NativeCall<APrimalDinoCharacter*, __int16>(this, "APrimalCharacter.GetBasedOrSeatingOnDino()", a2); }

    APrimalDinoCharacter* GetBasedOnDino(bool bUseReplicatedData, bool bOnlyConsciousDino) { return NativeCall<APrimalDinoCharacter*, bool, bool>(this, "APrimalCharacter.GetBasedOnDino(bool,bool)", bUseReplicatedData, bOnlyConsciousDino); }

    float GetBaseDragWeight() { return NativeCall<float>(this, "APrimalCharacter.GetBaseDragWeight()"); }

    void ClientHandleNetDestroy() { NativeCall<void>(this, "APrimalCharacter.ClientHandleNetDestroy()"); }

    bool AllowParallelAnimations(USkeletalMeshComponent* forComp) { return NativeCall<bool, USkeletalMeshComponent*>(this, "APrimalCharacter.AllowParallelAnimations(USkeletalMeshComponent*)", forComp); }

    bool UseClearOnConsumeInput() { return NativeCall<bool>(this, "APrimalCharacter.UseClearOnConsumeInput()"); }

    float GetDamageTorpidityIncreaseMultiplierScale() { return NativeCall<float>(this, "APrimalCharacter.GetDamageTorpidityIncreaseMultiplierScale()"); }

    float GetIndirectTorpidityIncreaseMultiplierScale() { return NativeCall<float>(this, "APrimalCharacter.GetIndirectTorpidityIncreaseMultiplierScale()"); }

    void NotifyBumpedByPawn(APrimalCharacter* ByPawn) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.NotifyBumpedByPawn(APrimalCharacter*)", ByPawn); }

    void NotifyBumpedPawn(APawn* BumpedPawn) { NativeCall<void, APawn*>(this, "APrimalCharacter.NotifyBumpedPawn(APawn*)", BumpedPawn); }

    float GetTPVHorizontalCameraOffset() { return NativeCall<float>(this, "APrimalCharacter.GetTPVHorizontalCameraOffset()"); }

    float GetTPVHorizontalCameraOffsetFromSlider() { return NativeCall<float>(this, "APrimalCharacter.GetTPVHorizontalCameraOffsetFromSlider()"); }

    float GetTransitionToCameraStateInterpTime(TEnumAsByte<EPrimalCameraState> ToFinalCameraState) { return NativeCall<float, TEnumAsByte<EPrimalCameraState>>(this, "APrimalCharacter.GetTransitionToCameraStateInterpTime(TEnumAsByte<EPrimalCameraState>)", ToFinalCameraState); }

    float GetPrimalCameraDesiredArmLength(const FPrimalCameraParams* ForCameraParams, float CurrentCameraArmLength, float DefaultCameraArmLength) { return NativeCall<float, const FPrimalCameraParams*, float, float>(this, "APrimalCharacter.GetPrimalCameraDesiredArmLength(FPrimalCameraParams*,float,float)", ForCameraParams, CurrentCameraArmLength, DefaultCameraArmLength); }

    float GetPrimalCameraDesiredArmLength(float CurrentCameraArmLength, float DefaultCameraArmLength) { return NativeCall<float, float, float>(this, "APrimalCharacter.GetPrimalCameraDesiredArmLength(float,float)", CurrentCameraArmLength, DefaultCameraArmLength); }

    bool UseCenteredTPVCamera() { return NativeCall<bool>(this, "APrimalCharacter.UseCenteredTPVCamera()"); }

    void PossessedBy(AController* NewController) { NativeCall<void, AController*>(this, "APrimalCharacter.PossessedBy(AController*)", NewController); }

    bool IsBlockedByShield(const FHitResult* HitInfo, const UE::Math::TVector<double>* ShotDirection, bool bBlockAllPointDamage) { return NativeCall<bool, const FHitResult*, const UE::Math::TVector<double>*, bool>(this, "APrimalCharacter.IsBlockedByShield(FHitResult&,UE::Math::TVector<double>&,bool)", HitInfo, ShotDirection, bBlockAllPointDamage); }

    void BPNetAddCharacterMovementImpulse(UE::Math::TVector<double>* Impulse, bool bVelChange, float ImpulseExponent, bool bSetNewMovementMode, EMovementMode NewMovementMode, bool bOverrideMaxImpulseZ, bool bApplyToBigPawns) { NativeCall<void, UE::Math::TVector<double>*, bool, float, bool, EMovementMode, bool, bool>(this, "APrimalCharacter.BPNetAddCharacterMovementImpulse(UE::Math::TVector<double>,bool,float,bool,EMovementMode,bool,bool)", Impulse, bVelChange, ImpulseExponent, bSetNewMovementMode, NewMovementMode, bOverrideMaxImpulseZ, bApplyToBigPawns); }

    void BPNetSetCharacterMovementVelocity(bool bSetNewVelocity, UE::Math::TVector<double>* NewVelocity, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, bool, UE::Math::TVector<double>*, bool, EMovementMode>(this, "APrimalCharacter.BPNetSetCharacterMovementVelocity(bool,UE::Math::TVector<double>,bool,EMovementMode)", bSetNewVelocity, NewVelocity, bSetNewMovementMode, NewMovementMode); }

    void NetSetMovementModeSimulatedInternal_Implementation(EMovementMode NewMovementMode) { NativeCall<void, EMovementMode>(this, "APrimalCharacter.NetSetMovementModeSimulatedInternal_Implementation(EMovementMode)", NewMovementMode); }

    float GetGravityZScale() { return NativeCall<float>(this, "APrimalCharacter.GetGravityZScale()"); }

    void OnMovementModeChanged(EMovementMode PrevMovementMode, unsigned __int8 PreviousCustomMode) { NativeCall<void, EMovementMode, unsigned __int8>(this, "APrimalCharacter.OnMovementModeChanged(EMovementMode,unsignedchar)", PrevMovementMode, PreviousCustomMode); }

    void SetCharacterAndRagdollLocation(UE::Math::TVector<double>* NewLocation) { NativeCall<void, UE::Math::TVector<double>*>(this, "APrimalCharacter.SetCharacterAndRagdollLocation(UE::Math::TVector<double>)", NewLocation); }

    void CheckRagdollPenetration() { NativeCall<void>(this, "APrimalCharacter.CheckRagdollPenetration()"); }

    APrimalStructureExplosive* GetAttachedExplosive() { return NativeCall<APrimalStructureExplosive*>(this, "APrimalCharacter.GetAttachedExplosive()"); }

    bool IsInVacuumSealedSpace() { return NativeCall<bool>(this, "APrimalCharacter.IsInVacuumSealedSpace()"); }

    void ClientOrderedMoveTo_Implementation(UE::Math::TVector<double>* MoveToLoc) { NativeCall<void, UE::Math::TVector<double>*>(this, "APrimalCharacter.ClientOrderedMoveTo_Implementation(UE::Math::TVector<double>)", MoveToLoc); }

    void ClientOrderedAttackTarget_Implementation(AActor* attackTarget) { NativeCall<void, AActor*>(this, "APrimalCharacter.ClientOrderedAttackTarget_Implementation(AActor*)", attackTarget); }

    void DownCallOne() { NativeCall<void>(this, "APrimalCharacter.DownCallOne()"); }

    float BPModifyFOV_Implementation(float FOVIn) { return NativeCall<float, float>(this, "APrimalCharacter.BPModifyFOV_Implementation(float)", FOVIn); }

    bool AllowOverrideWalkingVelocity() { return NativeCall<bool>(this, "APrimalCharacter.AllowOverrideWalkingVelocity()"); }

    bool AllowOverrideSwimmingVelocity() { return NativeCall<bool>(this, "APrimalCharacter.AllowOverrideSwimmingVelocity()"); }

    bool AllowOverrideNewFallVelocity() { return NativeCall<bool>(this, "APrimalCharacter.AllowOverrideNewFallVelocity()"); }

    void OverrideWalkingVelocity(UE::Math::TVector<double>* InitialVelocity, const float* Friction, float DeltaTime) { NativeCall<void, UE::Math::TVector<double>*, const float*, float>(this, "APrimalCharacter.OverrideWalkingVelocity(UE::Math::TVector<double>&,float&,float)", InitialVelocity, Friction, DeltaTime); }

    void OverrideSwimmingVelocity(UE::Math::TVector<double>* InitialVelocity, const UE::Math::TVector<double>* Gravity, const float* FluidFriction, const float* NetBuoyancy, float DeltaTime) { NativeCall<void, UE::Math::TVector<double>*, const UE::Math::TVector<double>*, const float*, const float*, float>(this, "APrimalCharacter.OverrideSwimmingVelocity(UE::Math::TVector<double>&,UE::Math::TVector<double>&,float&,float&,float)", InitialVelocity, Gravity, FluidFriction, NetBuoyancy, DeltaTime); }

    void OverrideNewFallVelocity(UE::Math::TVector<double>* InitialVelocity, const UE::Math::TVector<double>* Gravity, float DeltaTime) { NativeCall<void, UE::Math::TVector<double>*, const UE::Math::TVector<double>*, float>(this, "APrimalCharacter.OverrideNewFallVelocity(UE::Math::TVector<double>&,UE::Math::TVector<double>&,float)", InitialVelocity, Gravity, DeltaTime); }

    char PreventLanding(const UE::Math::TVector<double>* ImpactPoint, const UE::Math::TVector<double>* ImpactAccel, UE::Math::TVector<double>* Velocity) { return NativeCall<char, const UE::Math::TVector<double>*, const UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "APrimalCharacter.PreventLanding(UE::Math::TVector<double>,UE::Math::TVector<double>,UE::Math::TVector<double>&)", ImpactPoint, ImpactAccel, Velocity); }

    bool AllowOverrideFlyingVelocity() { return NativeCall<bool>(this, "APrimalCharacter.AllowOverrideFlyingVelocity()"); }

    void OverrideFlyingVelocity(UE::Math::TVector<double>* InitialVelocity, const UE::Math::TVector<double>* Gravity, float DeltaTime) { NativeCall<void, UE::Math::TVector<double>*, const UE::Math::TVector<double>*, float>(this, "APrimalCharacter.OverrideFlyingVelocity(UE::Math::TVector<double>&,UE::Math::TVector<double>&,float)", InitialVelocity, Gravity, DeltaTime); }

    void SetDynamicMusic(USoundBase* newMusic) { NativeCall<void, USoundBase*>(this, "APrimalCharacter.SetDynamicMusic(USoundBase*)", newMusic); }

    bool PreventsTargeting_Implementation(AActor* ByActor) { return NativeCall<bool, AActor*>(this, "APrimalCharacter.PreventsTargeting_Implementation(AActor*)", ByActor); }

    bool PreventInputType(EPrimalCharacterInputType::Type inputType) { return NativeCall<bool, EPrimalCharacterInputType::Type>(this, "APrimalCharacter.PreventInputType(EPrimalCharacterInputType::Type)", inputType); }

    bool PreventInputDoesOffset() { return NativeCall<bool>(this, "APrimalCharacter.PreventInputDoesOffset()"); }

    bool IsAlliedWithOtherTeam(int OtherTeamID) { return NativeCall<bool, int>(this, "APrimalCharacter.IsAlliedWithOtherTeam(int)", OtherTeamID); }

    void ResetCollisionSweepLocation(const UE::Math::TVector<double>* newLocation, bool bForceReset) { NativeCall<void, const UE::Math::TVector<double>*, bool>(this, "APrimalCharacter.ResetCollisionSweepLocation(UE::Math::TVector<double>&,bool)", newLocation, bForceReset); }

    void DidTeleport_Implementation(UE::Math::TVector<double>* newLoc, UE::Math::TRotator<double>* newRot, bool bDoCameraFade, FLinearColor* CameraFadeColor) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, bool, FLinearColor*>(this, "APrimalCharacter.DidTeleport_Implementation(UE::Math::TVector<double>,UE::Math::TRotator<double>,bool,FLinearColor)", newLoc, newRot, bDoCameraFade, CameraFadeColor); }

    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "APrimalCharacter.FinalLoadedFromSaveGame()"); }

    void OnConstruction(const UE::Math::TTransform<double>* Transform) { NativeCall<void, const UE::Math::TTransform<double>*>(this, "APrimalCharacter.OnConstruction(UE::Math::TTransform<double>&)", Transform); }

    void OnUpdateSimulatedPosition(const UE::Math::TVector<double>* NewLocation, const UE::Math::TQuat<double>* NewRotation) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TQuat<double>*>(this, "APrimalCharacter.OnUpdateSimulatedPosition(UE::Math::TVector<double>&,UE::Math::TQuat<double>&)", NewLocation, NewRotation); }

    void NotifyItemQuantityUpdated(UPrimalItem* anItem, int amount) { NativeCall<void, UPrimalItem*, int>(this, "APrimalCharacter.NotifyItemQuantityUpdated(UPrimalItem*,int)", anItem, amount); }

    void PerBuffLambda(std::function<void __cdecl(APrimalBuff*)>* lambda) { NativeCall<void, std::function<void __cdecl(APrimalBuff*)>*>(this, "APrimalCharacter.PerBuffLambda(std::function<void__cdecl(APrimalBuff*)", lambda); }

    void NotifyItemAdded(UPrimalItem* anItem, bool bEquipItem) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalCharacter.NotifyItemAdded(UPrimalItem*,bool)", anItem, bEquipItem); }

    void NotifyItemRemoved(UPrimalItem* anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.NotifyItemRemoved(UPrimalItem*)", anItem); }

    void TeleportSucceeded(bool bIsATest, bool bSimpleTeleport) { NativeCall<void, bool, bool>(this, "APrimalCharacter.TeleportSucceeded(bool,bool)", bIsATest, bSimpleTeleport); }

    bool IsAttachedToSomething() { return NativeCall<bool>(this, "APrimalCharacter.IsAttachedToSomething()"); }

    void AttachToOtherCharacter(APrimalCharacter* characterToAttachTo, const FName InSocketName, const bool enableMovementAndCollision, EAttachLocation::Type AttachLocation) { NativeCall<void, APrimalCharacter*, const FName, const bool, EAttachLocation::Type>(this, "APrimalCharacter.AttachToOtherCharacter(APrimalCharacter*,FName,bool,EAttachLocation::Type)", characterToAttachTo, InSocketName, enableMovementAndCollision, AttachLocation); }

    void AttachedToOtherCharacterUpdateWorldLocation(const UE::Math::TVector<double>* worldLocation) { NativeCall<void, const UE::Math::TVector<double>*>(this, "APrimalCharacter.AttachedToOtherCharacterUpdateWorldLocation(UE::Math::TVector<double>&)", worldLocation); }

    void DetachFromOtherCharacter(const bool enableMovementAndCollision) { NativeCall<void, const bool>(this, "APrimalCharacter.DetachFromOtherCharacter(bool)", enableMovementAndCollision); }

    bool ConsumeProjectileImpact(AShooterProjectile* theProjectile, const FHitResult* HitResult) { return NativeCall<bool, AShooterProjectile*, const FHitResult*>(this, "APrimalCharacter.ConsumeProjectileImpact(AShooterProjectile*,FHitResult&)", theProjectile, HitResult); }

    bool CanProne() { return NativeCall<bool>(this, "APrimalCharacter.CanProne()"); }

    void Prone(bool bClientSimulation) { NativeCall<void, bool>(this, "APrimalCharacter.Prone(bool)", bClientSimulation); }

    void UnProne(bool bClientSimulation) { NativeCall<void, bool>(this, "APrimalCharacter.UnProne(bool)", bClientSimulation); }

    void OnRep_IsProne(__int64 a2) { NativeCall<void, __int64>(this, "APrimalCharacter.OnRep_IsProne()", a2); }

    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "APrimalCharacter.RecalculateBaseEyeHeight()"); }

    void Crouch(bool bClientSimulation) { NativeCall<void, bool>(this, "APrimalCharacter.Crouch(bool)", bClientSimulation); }

    void Landed(const FHitResult* Hit) { NativeCall<void, const FHitResult*>(this, "APrimalCharacter.Landed(FHitResult&)", Hit); }

    bool IsProneOrSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "APrimalCharacter.IsProneOrSitting(bool)", bIgnoreLockedToSeat); }

    void DoCharacterDetachment(bool bIncludeRiding, bool bIncludeCarrying, APrimalBuff* BuffToIgnore) { NativeCall<void, bool, bool, APrimalBuff*>(this, "APrimalCharacter.DoCharacterDetachment(bool,bool,APrimalBuff*)", bIncludeRiding, bIncludeCarrying, BuffToIgnore); }

    bool IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "APrimalCharacter.IsCharacterHardAttached(bool,bool)", bIgnoreRiding, bIgnoreCarried); }

    void InitializedAnimScriptInstance() { NativeCall<void>(this, "APrimalCharacter.InitializedAnimScriptInstance()"); }

    bool ForceAddUnderwaterCharacterStatusValues() { return NativeCall<bool>(this, "APrimalCharacter.ForceAddUnderwaterCharacterStatusValues()"); }

    bool IsPrimalCharFriendly(APrimalCharacter* primalChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.IsPrimalCharFriendly(APrimalCharacter*)", primalChar); }

    bool TeleportTo(const UE::Math::TVector<double>* DestLocation, const UE::Math::TRotator<double>* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*, bool, bool>(this, "APrimalCharacter.TeleportTo(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool,bool)", DestLocation, DestRotation, bIsATest, bNoCheck); }

    void OnMassTeleportEvent(const EMassTeleportState::Type EventState, const APrimalCharacter* TeleportInitiatedByChar) { NativeCall<void, const EMassTeleportState::Type, const APrimalCharacter*>(this, "APrimalCharacter.OnMassTeleportEvent(EMassTeleportState::Type,APrimalCharacter*)", EventState, TeleportInitiatedByChar); }

    bool GetAllAttachedChars(TArray<APrimalCharacter*, TSizedDefaultAllocator<32> >* AttachedCharsArray, const bool bIncludeSelf, const bool bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TArray<APrimalCharacter*, TSizedDefaultAllocator<32> >*, const bool, const bool, const bool, const bool>(this, "APrimalCharacter.GetAllAttachedChars(TArray<APrimalCharacter*,TSizedDefaultAllocator<32>>&,bool,bool,bool,bool)", AttachedCharsArray, bIncludeSelf, bIncludeBased, bIncludePassengers, bIncludeCarried); }

    bool GetAllAttachedCharsInternal(TSet<APrimalCharacter*, DefaultKeyFuncs<APrimalCharacter*, 0>, FDefaultSetAllocator>* AttachedChars, const APrimalCharacter* OriginalChar, bool* bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TSet<APrimalCharacter*, DefaultKeyFuncs<APrimalCharacter*, 0>, FDefaultSetAllocator>*, const APrimalCharacter*, bool*, const bool, const bool>(this, "APrimalCharacter.GetAllAttachedCharsInternal(TSet<APrimalCharacter*,DefaultKeyFuncs<APrimalCharacter*,0>,FDefaultSetAllocator>&,APrimalCharacter*,bool,bool,bool)", AttachedChars, OriginalChar, bIncludeBased, bIncludePassengers, bIncludeCarried); }

    void ClearCachedIkTraceResults() { NativeCall<void>(this, "APrimalCharacter.ClearCachedIkTraceResults()"); }

    float OverrideTerminalVelocity() { return NativeCall<float>(this, "APrimalCharacter.OverrideTerminalVelocity()"); }

    void ClientCheatFly_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientCheatFly_Implementation()"); }

    void ClientCheatWalk_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientCheatWalk_Implementation()"); }

    bool UseOverrideWaterJumpVelocity() { return NativeCall<bool>(this, "APrimalCharacter.UseOverrideWaterJumpVelocity()"); }

    float GetOverrideWaterJumpVelocity(float OutOfWaterZ) { return NativeCall<float, float>(this, "APrimalCharacter.GetOverrideWaterJumpVelocity(float)", OutOfWaterZ); }

    void OverrideCameraTargetOriginLocation(UE::Math::TVector<double>* OutOverrideOrigin, const FName WithCameraStyle) { NativeCall<void, UE::Math::TVector<double>*, const FName>(this, "APrimalCharacter.OverrideCameraTargetOriginLocation(UE::Math::TVector<double>&,FName)", OutOverrideOrigin, WithCameraStyle); }

    void OverrideCameraInterpSpeed(const float DefaultTPVCameraSpeedInterpMultiplier, const float DefaultTPVOffsetInterpSpeed, float* TPVCameraSpeedInterpMultiplier, float* TPVOffsetInterpSpeed) { NativeCall<void, const float, const float, float*, float*>(this, "APrimalCharacter.OverrideCameraInterpSpeed(float,float,float&,float&)", DefaultTPVCameraSpeedInterpMultiplier, DefaultTPVOffsetInterpSpeed, TPVCameraSpeedInterpMultiplier, TPVOffsetInterpSpeed); }

    void NativeSimulateHair(TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >* CurrentPos, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >* LastPos, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >* RestPos, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >* PivotPos, TArray<float, TSizedDefaultAllocator<32> >* RestDistance, UE::Math::TVector<double>* HairSocketLoc, UE::Math::TRotator<double>* HairSocketRot, UE::Math::TVector<double>* ChestSocketLoc, UE::Math::TRotator<double>* ChestSocketRot, float DeltaTime, float Damping, float DampingFrontModifier, float DampingBack, float InWater, float HairWetness, float DragForce, float HairScale, float SpringForce, float SpringForceFrontModifier, float SpringForceBack, float GravityForce, UE::Math::TVector<double>* ShoulderLCollisionOffset, float ShoulderLCollisionRadius, UE::Math::TVector<double>* ShoulderRCollisionOffset, float ShoulderRCollisionRadius, UE::Math::TVector<double>* HeadHairCollisionOffset, float HeadHairCollisionRadius, UE::Math::TVector<double>* NeckHairCollisionOffset, float NeckHairCollisionRadius, float MaxDistanceToRestPos, UE::Math::TTransform<double>* LastHeadTransform, bool bPosAsPivot, bool bCollideMiddle, bool bCollideWithNeck) { NativeCall<void, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >*, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >*, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >*, TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >*, TArray<float, TSizedDefaultAllocator<32> >*, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, UE::Math::TVector<double>*, UE::Math::TRotator<double>*, float, float, float, float, float, float, float, float, float, float, float, float, UE::Math::TVector<double>*, float, UE::Math::TVector<double>*, float, UE::Math::TVector<double>*, float, UE::Math::TVector<double>*, float, float, UE::Math::TTransform<double>*, bool, bool, bool>(this, "APrimalCharacter.NativeSimulateHair(TArray<UE::Math::TVector<double>,TSizedDefaultAllocator<32>>&,TArray<UE::Math::TVector<double>,TSizedDefaultAllocator<32>>&,TArray<UE::Math::TVector<double>,TSizedDefaultAllocator<32>>&,TArray<UE::Math::TVector<double>,TSizedDefaultAllocator<32>>&,TArray<float,TSizedDefaultAllocator<32>>&,UE::Math::TVector<double>,UE::Math::TRotator<double>,UE::Math::TVector<double>,UE::Math::TRotator<double>,float,float,float,float,float,float,float,float,float,float,float,float,UE::Math::TVector<double>,float,UE::Math::TVector<double>,float,UE::Math::TVector<double>,float,UE::Math::TVector<double>,float,float,UE::Math::TTransform<double>,bool,bool,bool)", CurrentPos, LastPos, RestPos, PivotPos, RestDistance, HairSocketLoc, HairSocketRot, ChestSocketLoc, ChestSocketRot, DeltaTime, Damping, DampingFrontModifier, DampingBack, InWater, HairWetness, DragForce, HairScale, SpringForce, SpringForceFrontModifier, SpringForceBack, GravityForce, ShoulderLCollisionOffset, ShoulderLCollisionRadius, ShoulderRCollisionOffset, ShoulderRCollisionRadius, HeadHairCollisionOffset, HeadHairCollisionRadius, NeckHairCollisionOffset, NeckHairCollisionRadius, MaxDistanceToRestPos, LastHeadTransform, bPosAsPivot, bCollideMiddle, bCollideWithNeck); }

    bool ShouldDisableCameraInterpolation() { return NativeCall<bool>(this, "APrimalCharacter.ShouldDisableCameraInterpolation()"); }

    EMovementMode GetPrimalCharMovementMode() { return NativeCall<EMovementMode>(this, "APrimalCharacter.GetPrimalCharMovementMode()"); }

    bool BuffsPreventInventoryAccess() { return NativeCall<bool>(this, "APrimalCharacter.BuffsPreventInventoryAccess()"); }

    bool PreventNotifySound(USoundBase* SoundIn) { return NativeCall<bool, USoundBase*>(this, "APrimalCharacter.PreventNotifySound(USoundBase*)", SoundIn); }

    void OnCameraStyleChangedNotify(const FName* NewCameraStyle, const FName* OldCameraStyle) { NativeCall<void, const FName*, const FName*>(this, "APrimalCharacter.OnCameraStyleChangedNotify(FName&,FName&)", NewCameraStyle, OldCameraStyle); }

    void OnPaintingComponentInitialized(const UStructurePaintingComponent* PaintingComp) { NativeCall<void, const UStructurePaintingComponent*>(this, "APrimalCharacter.OnPaintingComponentInitialized(UStructurePaintingComponent*)", PaintingComp); }

    void ClearMovementTether() { NativeCall<void>(this, "APrimalCharacter.ClearMovementTether()"); }

    bool IsMovementTethered() { return NativeCall<bool>(this, "APrimalCharacter.IsMovementTethered()"); }

    bool IsWithinTether() { return NativeCall<bool>(this, "APrimalCharacter.IsWithinTether()"); }

    bool IsTargetWithinTether(const UE::Math::TVector<double>* Destination, float AdditionalRadius) { return NativeCall<bool, const UE::Math::TVector<double>*, float>(this, "APrimalCharacter.IsTargetWithinTether(UE::Math::TVector<double>&,float)", Destination, AdditionalRadius); }

    TArray<APawn*, TSizedDefaultAllocator<32> >* GetTrueBasedPawns(TArray<APawn*, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<APawn*, TSizedDefaultAllocator<32> >*, TArray<APawn*, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.GetTrueBasedPawns()", result); }

    USoundBase* OverrideCharacterSound(USoundBase* SoundIn) { return NativeCall<USoundBase*, USoundBase*>(this, "APrimalCharacter.OverrideCharacterSound(USoundBase*)", SoundIn); }

    USoundBase* BPOverrideCharacterSound_Implementation(USoundBase* SoundIn) { return NativeCall<USoundBase*, USoundBase*>(this, "APrimalCharacter.BPOverrideCharacterSound_Implementation(USoundBase*)", SoundIn); }

    UParticleSystem* BPOverrideCharacterParticle_Implementation(UParticleSystem* ParticleIn) { return NativeCall<UParticleSystem*, UParticleSystem*>(this, "APrimalCharacter.BPOverrideCharacterParticle_Implementation(UParticleSystem*)", ParticleIn); }

    void LaunchCharacter(UE::Math::TVector<double>* LaunchVelocity, bool bXYOverride, bool bZOverride) { NativeCall<void, UE::Math::TVector<double>*, bool, bool>(this, "APrimalCharacter.LaunchCharacter(UE::Math::TVector<double>,bool,bool)", LaunchVelocity, bXYOverride, bZOverride); }

    bool IsDeadOrDying() { return NativeCall<bool>(this, "APrimalCharacter.IsDeadOrDying()"); }

    void BPSuicide_Implementation() { NativeCall<void>(this, "APrimalCharacter.BPSuicide_Implementation()"); }

    void OnUROPostInterpolation(float Delta, USkeletalMeshComponent* InMesh, TArray<UE::Math::TTransform<double>, TSizedDefaultAllocator<32> >* InterpTransforms) { NativeCall<void, float, USkeletalMeshComponent*, TArray<UE::Math::TTransform<double>, TSizedDefaultAllocator<32> >*>(this, "APrimalCharacter.OnUROPostInterpolation(float,USkeletalMeshComponent*,TArray<UE::Math::TTransform<double>,TSizedDefaultAllocator<32>>&)", Delta, InMesh, InterpTransforms); }

    //void LoadPrimalCameraConfig(TSubclassOf<UPrimalCameraConfig> PrimalCameraConfigClass) { NativeCall<void, TSubclassOf<UPrimalCameraConfig>>(this, "APrimalCharacter.LoadPrimalCameraConfig(TSubclassOf<UPrimalCameraConfig>)", PrimalCameraConfigClass); }

    //bool GetPrimalCameraSettings(const FPrimalCameraProfile* ForCameraProfile, FPrimalCameraSettings* OutCameraSettings, const APrimalCharacter* CharForConditionChecks) { return NativeCall<bool, const FPrimalCameraProfile*, FPrimalCameraSettings*, const APrimalCharacter*>(this, "APrimalCharacter.GetPrimalCameraSettings(FPrimalCameraProfile&,FPrimalCameraSettings&,APrimalCharacter*)", ForCameraProfile, OutCameraSettings, CharForConditionChecks); }

    //bool GetCurrentPrimalCameraSettings(FPrimalCameraSettings* OutCameraSettings, const APrimalCharacter* CharForConditionChecks) { return NativeCall<bool, FPrimalCameraSettings*, const APrimalCharacter*>(this, "APrimalCharacter.GetCurrentPrimalCameraSettings(FPrimalCameraSettings&,APrimalCharacter*)", OutCameraSettings, CharForConditionChecks); }

    void GetPrimalCameraParams(FPrimalCameraParams* OutCameraParams, const APrimalCharacter* CharForConditionChecks, bool bIncludeWeaponOverride, FName ForProfileId) { NativeCall<void, FPrimalCameraParams*, const APrimalCharacter*, bool, FName>(this, "APrimalCharacter.GetPrimalCameraParams(FPrimalCameraParams&,APrimalCharacter*,bool,FName)", OutCameraParams, CharForConditionChecks, bIncludeWeaponOverride, ForProfileId); }

    //void GetPrimalCameraParams(FPrimalCameraParams* OutCameraParams, const FPrimalCameraProfile* ForCameraProfile, const APrimalCharacter* CharForConditionChecks, bool bIncludeWeaponOverride, FName ForProfileId) { NativeCall<void, FPrimalCameraParams*, const FPrimalCameraProfile*, const APrimalCharacter*, bool, FName>(this, "APrimalCharacter.GetPrimalCameraParams(FPrimalCameraParams&,FPrimalCameraProfile&,APrimalCharacter*,bool,FName)", OutCameraParams, ForCameraProfile, CharForConditionChecks, bIncludeWeaponOverride, ForProfileId); }

    //bool CanUseCameraSettings(const FPrimalCameraSettingsConditions* TheCameraSettingsConditions, const APrimalCharacter* CharForConditionChecks) { return NativeCall<bool, const FPrimalCameraSettingsConditions*, const APrimalCharacter*>(this, "APrimalCharacter.CanUseCameraSettings(FPrimalCameraSettingsConditions&,APrimalCharacter*)", TheCameraSettingsConditions, CharForConditionChecks); }

    void FindAndApplyWeaponCameraParamsOverride(FPrimalCameraParams* OutCameraParams, const APrimalCharacter* CharForConditionChecks, FName ForProfileId) { NativeCall<void, FPrimalCameraParams*, const APrimalCharacter*, FName>(this, "APrimalCharacter.FindAndApplyWeaponCameraParamsOverride(FPrimalCameraParams&,APrimalCharacter*,FName)", OutCameraParams, CharForConditionChecks, ForProfileId); }

    //bool GetCurrentCameraProfile(FPrimalCameraProfile* OutCameraProfile) { return NativeCall<bool, FPrimalCameraProfile*>(this, "APrimalCharacter.GetCurrentCameraProfile(FPrimalCameraProfile&)", OutCameraProfile); }

    FName* GetCurrentCameraProfileId(FName* result) { return NativeCall<FName*, FName*>(this, "APrimalCharacter.GetCurrentCameraProfileId()", result); }

    //bool GetCameraProfileForId(FName CameraProfileId, FPrimalCameraProfile* OutCameraProfile) { return NativeCall<bool, FName, FPrimalCameraProfile*>(this, "APrimalCharacter.GetCameraProfileForId(FName,FPrimalCameraProfile&)", CameraProfileId, OutCameraProfile); }

    void SetCameraProfile_Implementation(FName NewProfileId) { NativeCall<void, FName>(this, "APrimalCharacter.SetCameraProfile_Implementation(FName)", NewProfileId); }

    bool ShouldUseASACamera(bool bCheckShouldSwitchToOld) { return NativeCall<bool, bool>(this, "APrimalCharacter.ShouldUseASACamera(bool)", bCheckShouldSwitchToOld); }

    bool ShouldASACameraSwitchToOld(bool bDontCheckForTargeting) { return NativeCall<bool, bool>(this, "APrimalCharacter.ShouldASACameraSwitchToOld(bool)", bDontCheckForTargeting); }

    bool IsASACameraEnabled() { return NativeCall<bool>(this, "APrimalCharacter.IsASACameraEnabled()"); }

    bool HasValidASACameraConfig() { return NativeCall<bool>(this, "APrimalCharacter.HasValidASACameraConfig()"); }

    bool ShouldUseLongFallCameraPivotZValues() { return NativeCall<bool>(this, "APrimalCharacter.ShouldUseLongFallCameraPivotZValues()"); }

    //float GetPrimalCameraInterpMultiplier(const FCameraInterpMovementBasedMultipliers* CameraInterpMultipliers, TEnumAsByte<EAxis::Type> ForAxis) { return NativeCall<float, const FCameraInterpMovementBasedMultipliers*, TEnumAsByte<EAxis::Type>>(this, "APrimalCharacter.GetPrimalCameraInterpMultiplier(FCameraInterpMovementBasedMultipliers&,TEnumAsByte<EAxis::Type>)", CameraInterpMultipliers, ForAxis); }

    //bool GetPrimalCameraPivotInterpParams(const FPrimalCameraProfile* ForCameraProfile, const FPrimalCameraParams* ForCameraParams, const FPrimalCameraInterpParams* LastInterpParamsX, const FPrimalCameraInterpParams* LastInterpParamsY, const FPrimalCameraInterpParams* LastInterpParamsZ, FPrimalCameraInterpParams* OutParamsX, FPrimalCameraInterpParams* OutParamsY, FPrimalCameraInterpParams* OutParamsZ) { return NativeCall<bool, const FPrimalCameraProfile*, const FPrimalCameraParams*, const FPrimalCameraInterpParams*, const FPrimalCameraInterpParams*, const FPrimalCameraInterpParams*, FPrimalCameraInterpParams*, FPrimalCameraInterpParams*, FPrimalCameraInterpParams*>(this, "APrimalCharacter.GetPrimalCameraPivotInterpParams(FPrimalCameraProfile*,FPrimalCameraParams*,FPrimalCameraInterpParams&,FPrimalCameraInterpParams&,FPrimalCameraInterpParams&,FPrimalCameraInterpParams&,FPrimalCameraInterpParams&,FPrimalCameraInterpParams&)", ForCameraProfile, ForCameraParams, LastInterpParamsX, LastInterpParamsY, LastInterpParamsZ, OutParamsX, OutParamsY, OutParamsZ); }

    bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const UE::Math::TVector<double>* SrcLocation) { return NativeCall<bool, const AActor*, const AActor*, const UE::Math::TVector<double>*>(this, "APrimalCharacter.IsNetRelevantFor(AActor*,AActor*,UE::Math::TVector<double>&)", RealViewer, ViewTarget, SrcLocation); }

    bool WantsToUseRagdollForSleeping() { return NativeCall<bool>(this, "APrimalCharacter.WantsToUseRagdollForSleeping()"); }

    bool WantsToUseRagdollForDeath() { return NativeCall<bool>(this, "APrimalCharacter.WantsToUseRagdollForDeath()"); }

    UAnimationAsset* GetDeathAnim_Implementation(float KillingDamage, const UE::Math::TVector<double>* ImpactVelocity, APawn* InstigatingPawn, AActor* DamageCauser) { return NativeCall<UAnimationAsset*, float, const UE::Math::TVector<double>*, APawn*, AActor*>(this, "APrimalCharacter.GetDeathAnim_Implementation(float,UE::Math::TVector<double>&,APawn*,AActor*)", KillingDamage, ImpactVelocity, InstigatingPawn, DamageCauser); }

    void GenerateDeathAnim(float KillingDamage, const UE::Math::TVector<double>* ImpactVelocity, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, const UE::Math::TVector<double>*, APawn*, AActor*>(this, "APrimalCharacter.GenerateDeathAnim(float,UE::Math::TVector<double>&,APawn*,AActor*)", KillingDamage, ImpactVelocity, InstigatingPawn, DamageCauser); }

    bool IsFollowingFinalPathSegment() { return NativeCall<bool>(this, "APrimalCharacter.IsFollowingFinalPathSegment()"); }

    void GetWindSourceComponents(TArray<UActorComponent*, TSizedDefaultAllocator<32> >* Components, int includePriorityGreaterThan, bool bIsFirstPerson) { NativeCall<void, TArray<UActorComponent*, TSizedDefaultAllocator<32> >*, int, bool>(this, "APrimalCharacter.GetWindSourceComponents(TArray<UActorComponent*,TSizedDefaultAllocator<32>>&,int,bool)", Components, includePriorityGreaterThan, bIsFirstPerson); }

    void OnCharacterStepped_Implementation(UE::Math::TVector<double>* PrevLocation, UE::Math::TVector<double>* NewLocation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "APrimalCharacter.OnCharacterStepped_Implementation(UE::Math::TVector<double>,UE::Math::TVector<double>)", PrevLocation, NewLocation); }

    void NetSetReplicatedDeathAnim_Implementation(UAnimationAsset* Anim) { NativeCall<void, UAnimationAsset*>(this, "APrimalCharacter.NetSetReplicatedDeathAnim_Implementation(UAnimationAsset*)", Anim); }

    FLinearColor* GetFXBloodColor_Implementation(FLinearColor* result) { return NativeCall<FLinearColor*, FLinearColor*>(this, "APrimalCharacter.GetFXBloodColor_Implementation()", result); }

    void OnRep_ReplicatedBasedMovement() { NativeCall<void>(this, "APrimalCharacter.OnRep_ReplicatedBasedMovement()"); }

    void UpdateReplicatedBasedMovement() { NativeCall<void>(this, "APrimalCharacter.UpdateReplicatedBasedMovement()"); }

    //__int64 GetVelocityBasedSoundIndex(FVelocityBasedCharacterSoundInfo* InStruct, UE::Math::TVector<double>* InVelocity) { return NativeCall<__int64, FVelocityBasedCharacterSoundInfo*, UE::Math::TVector<double>*>(this, "APrimalCharacter.GetVelocityBasedSoundIndex(FVelocityBasedCharacterSoundInfo,UE::Math::TVector<double>)", InStruct, InVelocity); }

    AActor* GetBasedOnDinoAsActor(bool bUseReplicatedData, bool bOnlyConsciousDino) { return NativeCall<AActor*, bool, bool>(this, "APrimalCharacter.GetBasedOnDinoAsActor(bool,bool)", bUseReplicatedData, bOnlyConsciousDino); }

    void SetReplicateMovement(bool bInReplicateMovement) { NativeCall<void, bool>(this, "APrimalCharacter.SetReplicateMovement(bool)", bInReplicateMovement); }

    void UpdateEquippedItemDurabilityVariable(FItemNetID itemID, float ItemDurabilityPercentage) { NativeCall<void, FItemNetID, float>(this, "APrimalCharacter.UpdateEquippedItemDurabilityVariable(FItemNetID,float)", itemID, ItemDurabilityPercentage); }

    void UpdateEquippedItemDurabilityMaterials(FItemNetID itemID, float ItemDurabilityPercentage) { NativeCall<void, FItemNetID, float>(this, "APrimalCharacter.UpdateEquippedItemDurabilityMaterials(FItemNetID,float)", itemID, ItemDurabilityPercentage); }

    void UpdateAllEquippedItemsDurabilityMaterials() { NativeCall<void>(this, "APrimalCharacter.UpdateAllEquippedItemsDurabilityMaterials()"); }

    void UpdateAllEquippedItemsDurabilityVariables() { NativeCall<void>(this, "APrimalCharacter.UpdateAllEquippedItemsDurabilityVariables()"); }

    void OnRep_ReplicateMovement() { NativeCall<void>(this, "APrimalCharacter.OnRep_ReplicateMovement()"); }

    bool ShouldUseArmorDurabilityVFX() { return NativeCall<bool>(this, "APrimalCharacter.ShouldUseArmorDurabilityVFX()"); }

    //void GetExtraSaveMovedData(FSavedMove_Character* ForMove) { NativeCall<void, FSavedMove_Character*>(this, "APrimalCharacter.GetExtraSaveMovedData(FSavedMove_Character*)", ForMove); }

};


struct AShooterCharacter : APrimalCharacter

{

    // Fields


    FTimerHandle& OnReloadHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.OnReloadHandle"); }

    UParticleSystemComponent*& ListenServerBoundsPSCField() { return *GetNativePointerField<UParticleSystemComponent**>(this, "AShooterCharacter.ListenServerBoundsPSC"); }

    FTimerHandle& FinishSpawnIntroHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.FinishSpawnIntroHandle"); }

    UAnimMontage*& SpawnIntroAnim1PField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.SpawnIntroAnim1P"); }

    UAnimMontage*& RespawnIntroAnim1PField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.RespawnIntroAnim1P"); }

    UAnimMontage*& ProneInAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ProneInAnim"); }

    UAnimMontage*& ProneOutAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ProneOutAnim"); }

    UAnimMontage*& StartRidingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.StartRidingAnim"); }

    UAnimMontage*& StopRidingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.StopRidingAnim"); }

    UAnimMontage*& TalkingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.TalkingAnim"); }

    UAnimMontage*& VoiceTalkingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.VoiceTalkingAnim"); }

    TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >& EmoteAnimsField() { return *GetNativePointerField<TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.EmoteAnims"); }

    UAnimMontage*& FireBallistaAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.FireBallistaAnimation"); }

    UAnimMontage*& ReloadBallistaAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ReloadBallistaAnimation"); }

    UAnimMontage*& DraggingCharacterAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.DraggingCharacterAnim"); }

    TSoftClassPtr<APrimalBuff>& CheckCancelEmoteBuffClassField() { return *GetNativePointerField<TSoftClassPtr<APrimalBuff>*>(this, "AShooterCharacter.CheckCancelEmoteBuffClass"); }

    int& CurrentVoiceModeField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.CurrentVoiceMode"); }

    //TDelegate<void __cdecl(TSharedRef<FUniqueNetId const, 1>, bool), FDefaultDelegateUserPolicy>& OnPlayerTalkingStateChangedDelegateField() { return *GetNativePointerField<TDelegate<void __cdecl(TSharedRef<FUniqueNetId const, 1>, bool), FDefaultDelegateUserPolicy>*>(this, "AShooterCharacter.OnPlayerTalkingStateChangedDelegate"); }

    bool& bIsPreviewCharacterField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsPreviewCharacter"); }

    long double& DontTargetUntilTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.DontTargetUntilTime"); }

    float& OriginalCollisionHeightField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.OriginalCollisionHeight"); }

    float& WalkBobMagnitudeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WalkBobMagnitude"); }

    float& WalkBobInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WalkBobInterpSpeed"); }

    float& MinimumDistanceThresholdToCrouchField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MinimumDistanceThresholdToCrouch"); }

    float& MinimumDistanceThresholdToProneFromStandingField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MinimumDistanceThresholdToProneFromStanding"); }

    float& MinimumDistanceThresholdToProneFromCrouchField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MinimumDistanceThresholdToProneFromCrouch"); }

    float& TargetingTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TargetingTime"); }

    float& BobMaxMovementSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BobMaxMovementSpeed"); }

    float& WeaponBobMaxMovementSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobMaxMovementSpeed"); }

    float& MinRunSpeedThresholdField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MinRunSpeedThreshold"); }

    long double& LastCheckSevenField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastCheckSeven"); }

    long double& LastCheckSevenHitField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastCheckSevenHit"); }

    long double& LastCheckSevenTransmissionField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastCheckSevenTransmission"); }

    long double& LastValidCheckSevenField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastValidCheckSeven"); }

    long double& LastCheckSevenTeleportField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastCheckSevenTeleport"); }

    UE::Math::TVector<double>& LastCheckSevenLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.LastCheckSevenLocation"); }

    LocationQueue& PreviousValidLocationsField() { return *GetNativePointerField<LocationQueue*>(this, "AShooterCharacter.PreviousValidLocations"); }

    TSubclassOf<AShooterWeapon>& DefaultWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.DefaultWeapon"); }

    TSubclassOf<AShooterWeapon>& OverrideDefaultWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.OverrideDefaultWeapon"); }

    TSubclassOf<AShooterWeapon>& MapWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.MapWeapon"); }

    TSubclassOf<AShooterWeapon>& GPSWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.GPSWeapon"); }

    TSubclassOf<AShooterWeapon>& CompassWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.CompassWeapon"); }

    TWeakObjectPtr<APrimalStructureLadder>& ClimbingLadderField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructureLadder>*>(this, "AShooterCharacter.ClimbingLadder"); }

    FString& PlayerNameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.PlayerName"); }

    TWeakObjectPtr<APrimalDinoCharacter>& RidingDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "AShooterCharacter.RidingDino"); }

    USkeletalMeshComponent*& Mesh1PField() { return *GetNativePointerField<USkeletalMeshComponent**>(this, "AShooterCharacter.Mesh1P"); }

    TArray<FName, TSizedDefaultAllocator<32> >& LowerBodyPartRootBonesField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.LowerBodyPartRootBones"); }

    //UPhysicsAsset*& FPVCameraAnimationPhysicsAssetField() { return *GetNativePointerField<UPhysicsAsset**>(this, "AShooterCharacter.FPVCameraAnimationPhysicsAsset"); }

    UAnimMontage*& DropItemAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.DropItemAnimation"); }

    UAnimMontage*& ThrowItemAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ThrowItemAnimation"); }

    UAnimMontage*& PickupItemAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.PickupItemAnimation"); }

    UAnimMontage*& ActivateInventoryAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ActivateInventoryAnimation"); }

    USkeletalMeshComponent*& SurvivorProfilePreviewMeshField() { return *GetNativePointerField<USkeletalMeshComponent**>(this, "AShooterCharacter.SurvivorProfilePreviewMesh"); }

    UE::Math::TRotator<double>& LastDinoAimRotationOffsetField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "AShooterCharacter.LastDinoAimRotationOffset"); }

    UE::Math::TRotator<double>& LastAimRotOffsetField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "AShooterCharacter.LastAimRotOffset"); }

    APrimalProjectileBoomerang*& LastFiredBoomerangField() { return *GetNativePointerField<APrimalProjectileBoomerang**>(this, "AShooterCharacter.LastFiredBoomerang"); }

    APrimalProjectileGrapplingHook*& LastFiredGrapHookField() { return *GetNativePointerField<APrimalProjectileGrapplingHook**>(this, "AShooterCharacter.LastFiredGrapHook"); }

    UPrimalCableComponent*& GrapplingHookCableField() { return *GetNativePointerField<UPrimalCableComponent**>(this, "AShooterCharacter.GrapplingHookCable"); }

    UAudioComponent*& LastGrapHookACField() { return *GetNativePointerField<UAudioComponent**>(this, "AShooterCharacter.LastGrapHookAC"); }

    int& _GrapHookCableObjectCountField() { return *GetNativePointerField<int*>(this, "AShooterCharacter._GrapHookCableObjectCount"); }

    UE::Math::TVector<double>& GrapHookDefaultOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.GrapHookDefaultOffset"); }

    float& GrapHookCableWidthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GrapHookCableWidth"); }

    UMaterialInterface*& GrapHookMaterialField() { return *GetNativePointerField<UMaterialInterface**>(this, "AShooterCharacter.GrapHookMaterial"); }

    float& LadderJumpVelocityField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LadderJumpVelocity"); }

    float& GrapHookPulledRopeDistanceField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GrapHookPulledRopeDistance"); }

    float& GrapHookSyncTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GrapHookSyncTime"); }

    long double& LastTimeDestroyedWeaponField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeDestroyedWeapon"); }

    FName& SplitScreenCameraStyleOverrideField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.SplitScreenCameraStyleOverride"); }

    FString& PlatformProfileNameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.PlatformProfileName"); }

    FUniqueNetIdRepl& PlatformProfileIDField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "AShooterCharacter.PlatformProfileID"); }

    //TArray<FPlayerStatusStateCharacterSound, TSizedDefaultAllocator<32> >& CharacterStatusStateSoundsField() { return *GetNativePointerField<TArray<FPlayerStatusStateCharacterSound, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.CharacterStatusStateSounds"); }

    UAudioComponent*& CharacterStatusStateSoundComponentField() { return *GetNativePointerField<UAudioComponent**>(this, "AShooterCharacter.CharacterStatusStateSoundComponent"); }

    long double& LastUncrouchTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUncrouchTime"); }

    long double& LastUnproneTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUnproneTime"); }

    long double& LastTimeStartedCrouchOrProneTransitionField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeStartedCrouchOrProneTransition"); }

    float& CurrentWeaponBobSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CurrentWeaponBobSpeed"); }

    float& WalkBobOldSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WalkBobOldSpeed"); }

    float& AppliedBobField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.AppliedBob"); }

    float& BobTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BobTime"); }

    long double& LastPressReloadTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastPressReloadTime"); }

    long double& LastReleaseReloadTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastReleaseReloadTime"); }

    long double& LastReloadToggledAccessoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastReloadToggledAccessoryTime"); }

    long double& lastSubmergedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.lastSubmergedTime"); }

    //TSubclassOf<UAnimInstance>& DefaultTPVAnimBlueprintField() { return *GetNativePointerField<TSubclassOf<UAnimInstance>*>(this, "AShooterCharacter.DefaultTPVAnimBlueprint"); }

    FName& WeaponAttachPointField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.WeaponAttachPoint"); }

    float& TargetingSpeedModifierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TargetingSpeedModifier"); }

    USoundBase*& LowHealthSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.LowHealthSound"); }

    USoundBase*& FastTravelSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.FastTravelSound"); }

    UAnimMontage*& CallFollowAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CallFollowAnim"); }

    UAnimMontage*& CallStayAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CallStayAnim"); }

    UAnimMontage*& CallFollowAnimSingleField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CallFollowAnimSingle"); }

    UAnimMontage*& CallStayAnimSingleField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CallStayAnimSingle"); }

    UAnimMontage*& CallMoveToAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CallMoveToAnim"); }

    UAnimMontage*& CallAttackAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CallAttackAnim"); }

    UAudioComponent*& LowHealthWarningPlayerField() { return *GetNativePointerField<UAudioComponent**>(this, "AShooterCharacter.LowHealthWarningPlayer"); }

    FItemNetID& NextWeaponItemIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.NextWeaponItemID"); }

    float& WeaponBobTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobTime"); }

    float& CurrentAimBlendingField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CurrentAimBlending"); }

    long double& InterpLastCrouchProneStateChangeTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.InterpLastCrouchProneStateChangeTime"); }

    float& CraftingMovementSpeedModifierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CraftingMovementSpeedModifier"); }

    UE::Math::TVector<double>& WeaponBobMagnitudesField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.WeaponBobMagnitudes"); }

    UE::Math::TVector<double>& WeaponBobPeriodsField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.WeaponBobPeriods"); }

    UE::Math::TVector<double>& WeaponBobOffsetsField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.WeaponBobOffsets"); }

    UE::Math::TVector<double>& WeaponBobMagnitudes_TargetingField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.WeaponBobMagnitudes_Targeting"); }

    UE::Math::TVector<double>& WeaponBobPeriods_TargetingField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.WeaponBobPeriods_Targeting"); }

    UE::Math::TVector<double>& WeaponBobOffsets_TargetingField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.WeaponBobOffsets_Targeting"); }

    float& WeaponBobMinimumSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobMinimumSpeed"); }

    float& WeaponBobSpeedBaseField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobSpeedBase"); }

    float& WeaponBobSpeedBaseFallingField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobSpeedBaseFalling"); }

    float& WeaponBobTargetingBlendField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobTargetingBlend"); }

    TArray<FItemAttachmentInfo, TSizedDefaultAllocator<32> >& DefaultAttachmentInfosField() { return *GetNativePointerField<TArray<FItemAttachmentInfo, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.DefaultAttachmentInfos"); }

    USoundBase*& StartCrouchSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.StartCrouchSound"); }

    USoundBase*& EndCrouchSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.EndCrouchSound"); }

    USoundBase*& StartProneSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.StartProneSound"); }

    USoundBase*& EndProneSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.EndProneSound"); }

    TSubclassOf<AShooterWeapon>& NextInventoryWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.NextInventoryWeapon"); }

    FItemNetID& PreMapWeaponItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreMapWeaponItemNetID"); }

    FItemNetID& CurrentWeaponItemIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.CurrentWeaponItemID"); }

    float& ServerSeatedViewRotationYawField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ServerSeatedViewRotationYaw"); }

    float& ServerSeatedViewRotationPitchField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ServerSeatedViewRotationPitch"); }

    AShooterWeapon*& CurrentWeaponField() { return *GetNativePointerField<AShooterWeapon**>(this, "AShooterCharacter.CurrentWeapon"); }

    FTimerHandle& GiveDefaultWeaponTimerHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.GiveDefaultWeaponTimerHandle"); }

    float& HealthBarOffsetYField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.HealthBarOffsetY"); }

    unsigned __int64& LinkedPlayerDataIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterCharacter.LinkedPlayerDataID"); }

    FTimerHandle& FinishWeaponSwitchHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.FinishWeaponSwitchHandle"); }

    long double& LastTimeInFallingField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeInFalling"); }

    long double& StartedRidingTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.StartedRidingTime"); }

    long double& TimeSinceLastControllerField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.TimeSinceLastController"); }

    TWeakObjectPtr<AController>& LastControllerField() { return *GetNativePointerField<TWeakObjectPtr<AController>*>(this, "AShooterCharacter.LastController"); }

    TWeakObjectPtr<AShooterPlayerController>& LastValidPlayerControllerField() { return *GetNativePointerField<TWeakObjectPtr<AShooterPlayerController>*>(this, "AShooterCharacter.LastValidPlayerController"); }

    UAnimMontage*& DrinkingAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.DrinkingAnimation"); }

    long double& LastRequestedTribeTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastRequestedTribeTime"); }

    int& LastRequestedTribeIDField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.LastRequestedTribeID"); }

    FString& LastRequestedTribeNameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.LastRequestedTribeName"); }

    TWeakObjectPtr<AShooterCharacter>& LastRequestedTribePlayerCharacterField() { return *GetNativePointerField<TWeakObjectPtr<AShooterCharacter>*>(this, "AShooterCharacter.LastRequestedTribePlayerCharacter"); }

    float& IndoorsHyperthermiaInsulationField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.IndoorsHyperthermiaInsulation"); }

    float& IndoorsHypothermiaInsulationField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.IndoorsHypothermiaInsulation"); }

    float& IndoorCheckIntervalField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.IndoorCheckInterval"); }

    long double& LastIndoorCheckTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastIndoorCheckTime"); }

    FItemNetID& PreRidingWeaponItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreRidingWeaponItemNetID"); }

    FItemNetID& PreInventoryWeaponItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreInventoryWeaponItemNetID"); }

    TArray<FOverrideAnimBlueprintEntry, TSizedDefaultAllocator<32> >& OverrideAnimBlueprintsField() { return *GetNativePointerField<TArray<FOverrideAnimBlueprintEntry, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.OverrideAnimBlueprints"); }

    UAnimSequence*& ViewingInventoryAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.ViewingInventoryAnimation"); }

    UAnimSequence*& DefaultDinoRidingAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.DefaultDinoRidingAnimation"); }

    UAnimSequence*& DefaultDinoRidingMoveAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.DefaultDinoRidingMoveAnimation"); }

    UAnimSequence*& DefaultSeatingAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.DefaultSeatingAnimation"); }

    UAnimSequence*& DefaultShieldAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.DefaultShieldAnimation"); }

    UAnimMontage*& ShieldCoverAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ShieldCoverAnimation"); }

    UAnimMontage*& ShieldCoverAnimationForCrouchField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.ShieldCoverAnimationForCrouch"); }

    float& EnemyPlayerMaxCursorHUDDistanceProneField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EnemyPlayerMaxCursorHUDDistanceProne"); }

    float& EnemyPlayerMaxCursorHUDDistanceCrouchedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EnemyPlayerMaxCursorHUDDistanceCrouched"); }

    float& EnemyPlayerMaxCursorHUDDistanceStandingField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EnemyPlayerMaxCursorHUDDistanceStanding"); }

    long double& ForceSleepRagdollUntilTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.ForceSleepRagdollUntilTime"); }

    FSaddlePassengerSeatDefinition& CurrentPassengerSeatDefinitionField() { return *GetNativePointerField<FSaddlePassengerSeatDefinition*>(this, "AShooterCharacter.CurrentPassengerSeatDefinition"); }

    TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >& AnimsOverrideFromField() { return *GetNativePointerField<TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.AnimsOverrideFrom"); }

    TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >& AnimOverrideToField() { return *GetNativePointerField<TArray<TSoftObjectPtr<UAnimMontage>, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.AnimOverrideTo"); }

    TArray<TSoftObjectPtr<UAnimSequence>, TSizedDefaultAllocator<32> >& AnimSequencesOverrideFromField() { return *GetNativePointerField<TArray<TSoftObjectPtr<UAnimSequence>, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.AnimSequencesOverrideFrom"); }

    TArray<TSoftObjectPtr<UAnimSequence>, TSizedDefaultAllocator<32> >& AnimSequenceOverrideToField() { return *GetNativePointerField<TArray<TSoftObjectPtr<UAnimSequence>, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.AnimSequenceOverrideTo"); }

    float& PreviousRootYawSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.PreviousRootYawSpeed"); }

    FieldArray<FLinearColor, 4> BodyColorsField() { return { this, "AShooterCharacter.BodyColors" }; }

    unsigned __int8& HeadHairIndexField() { return *GetNativePointerField<unsigned __int8*>(this, "AShooterCharacter.HeadHairIndex"); }

    FieldArray<float, 26> RawBoneModifiersField() { return { this, "AShooterCharacter.RawBoneModifiers" }; }

    TArray<FBoneModifier, TSizedDefaultAllocator<32> >& BoneModifiersField() { return *GetNativePointerField<TArray<FBoneModifier, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.BoneModifiers"); }

    TArray<FBoneModifier, TSizedDefaultAllocator<32> >& BoneModifiers_FemaleField() { return *GetNativePointerField<TArray<FBoneModifier, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.BoneModifiers_Female"); }

    FieldArray<unsigned __int8, 50> DynamicMaterialBytesField() { return { this, "AShooterCharacter.DynamicMaterialBytes" }; }

    FieldArray<unsigned __int8, 4> DynamicOverrideHairDyeBytesField() { return { this, "AShooterCharacter.DynamicOverrideHairDyeBytes" }; }

    UPrimaryDataAsset*& Player_Voice_CollectionField() { return *GetNativePointerField<UPrimaryDataAsset**>(this, "AShooterCharacter.Player_Voice_Collection"); }

    float& LoggedOutTargetingDesirabilityField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LoggedOutTargetingDesirability"); }

    long double& LastAttackTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastAttackTime"); }

    bool& bWasLocallyControlledField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasLocallyControlled"); }

    bool& bWasLocalPossessedByControlledField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasLocalPossessedByControlled"); }

    unsigned int& UniqueNetIdTypeHashField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.UniqueNetIdTypeHash"); }

    unsigned int& SplitscreenMainPlayerUniqueNetIdTypeHashField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.SplitscreenMainPlayerUniqueNetIdTypeHash"); }

    long double& LastUseHarvestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUseHarvestTime"); }

    long double& StopRidingTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.StopRidingTime"); }

    UAnimMontage*& SpawnAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.SpawnAnim"); }

    UAnimMontage*& FirstSpawnAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.FirstSpawnAnim"); }

    UAnimMontage*& SleepOutAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.SleepOutAnim"); }

    long double& LocalLastViewingInventoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LocalLastViewingInventoryTime"); }

    UE::Math::TVector<double>& LastStasisCastPositionField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.LastStasisCastPosition"); }

    TArray<UPrimalItem*, TSizedDefaultAllocator<32> >& OldItemSlotsField() { return *GetNativePointerField<TArray<UPrimalItem*, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.OldItemSlots"); }

    FTimerHandle& RequestFastInventoryHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.RequestFastInventoryHandle"); }

    int& FastInventoryLastIndexField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.FastInventoryLastIndex"); }

    int& FastInventoryLastMaxRowField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.FastInventoryLastMaxRow"); }

    int& FastInventoryQuantitySlotsField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.FastInventoryQuantitySlots"); }

    FString& CustomFolderFastInventoryField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.CustomFolderFastInventory"); }

    long double& SavedLastTimeHadControllerField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.SavedLastTimeHadController"); }

    long double& LastTimeHadControllerField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeHadController"); }

    float& LastTaggedTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastTaggedTime"); }

    float& LastTaggedTimeExtraField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastTaggedTimeExtra"); }

    float& LastTaggedTimeThirdField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastTaggedTimeThird"); }

    float& ExtraFloatVarField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ExtraFloatVar"); }

    UE::Math::TVector<double>& ExtraVectorVarField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.ExtraVectorVar"); }

    UE::Math::TVector<double>& ExtraExtraVectorVarField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.ExtraExtraVectorVar"); }

    FName& ExtraNameVarField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.ExtraNameVar"); }

    bool& bIsControllingBallistaField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsControllingBallista"); }

    float& CurrentControlledBallistaYawField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CurrentControlledBallistaYaw"); }

    TWeakObjectPtr<APrimalStructureSeating>& SeatingStructureField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructureSeating>*>(this, "AShooterCharacter.SeatingStructure"); }

    int& SeatingStructureSeatNumberField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.SeatingStructureSeatNumber"); }

    long double& NextPlayerUndergroundCheckField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.NextPlayerUndergroundCheck"); }

    int& PlayerNumUnderGroundFailField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.PlayerNumUnderGroundFail"); }

    float& LastSweepCapsuleHeightField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastSweepCapsuleHeight"); }

    float& LastSweepCapsuleRadiusField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastSweepCapsuleRadius"); }

    USoundBase*& ThrowCharacterSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.ThrowCharacterSound"); }

    float& ClientSeatedViewRotationPitchField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ClientSeatedViewRotationPitch"); }

    float& ClientSeatedViewRotationYawField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ClientSeatedViewRotationYaw"); }

    long double& LastReleaseSeatingStructureTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastReleaseSeatingStructureTime"); }

    bool& bShouldInvertTurnInputField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bShouldInvertTurnInput"); }

    TWeakObjectPtr<APrimalCharacter>& LastGrappledToCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "AShooterCharacter.LastGrappledToCharacter"); }

    TWeakObjectPtr<APrimalCharacter>& CurrentGrappledToCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "AShooterCharacter.CurrentGrappledToCharacter"); }

    int& AllianceInviteRequestingTeamField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.AllianceInviteRequestingTeam"); }

    unsigned int& AllianceInviteIDField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.AllianceInviteID"); }

    FString& AllianceInviteNameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.AllianceInviteName"); }

    long double& AllianceInviteTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.AllianceInviteTime"); }

    float& InventoryDragWeightScaleField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.InventoryDragWeightScale"); }

    UAnimMontage*& MountedCarryingDinoAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.MountedCarryingDinoAnimation"); }

    UAnimMontage*& CuddleAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.CuddleAnimation"); }

    long double& LastUpdatedAimActorsTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUpdatedAimActorsTime"); }

    UE::Math::TVector<double>& UpdateHyperThermalInsulationPositionField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.UpdateHyperThermalInsulationPosition"); }

    UE::Math::TVector<double>& UpdateHypoThermalInsulationPositionField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.UpdateHypoThermalInsulationPosition"); }

    long double& NextUpdateHyperThermalInsulationTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.NextUpdateHyperThermalInsulationTime"); }

    long double& NextUpdateHypoThermalInsulationTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.NextUpdateHypoThermalInsulationTime"); }

    float& LastAdditionalHypoThermalInsulationField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastAdditionalHypoThermalInsulation"); }

    float& LastAdditionalHyperThermalInsulationField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastAdditionalHyperThermalInsulation"); }

    float& WaterLossRateMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WaterLossRateMultiplier"); }

    UAnimSequence*& CharacterAdditiveStandingAnimField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.CharacterAdditiveStandingAnim"); }

    long double& LastTryAccessInventoryFailTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTryAccessInventoryFailTime"); }

    long double& LastEmotePlayTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastEmotePlayTime"); }

    USkeletalMeshComponent*& HeadHairComponentField() { return *GetNativePointerField<USkeletalMeshComponent**>(this, "AShooterCharacter.HeadHairComponent"); }

    USkeletalMeshComponent*& FacialHairComponentField() { return *GetNativePointerField<USkeletalMeshComponent**>(this, "AShooterCharacter.FacialHairComponent"); }

    USkeletalMeshComponent*& EyebrowsComponentField() { return *GetNativePointerField<USkeletalMeshComponent**>(this, "AShooterCharacter.EyebrowsComponent"); }

    USkeletalMeshComponent*& EyelashesComponentField() { return *GetNativePointerField<USkeletalMeshComponent**>(this, "AShooterCharacter.EyelashesComponent"); }

    float& IntervalForFullHeadHairGrowthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.IntervalForFullHeadHairGrowth"); }

    float& IntervalForFullFacialHairGrowthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.IntervalForFullFacialHairGrowth"); }

    float& PercentOfFullFacialHairGrowthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.PercentOfFullFacialHairGrowth"); }

    float& PercentOfFullHeadHairGrowthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.PercentOfFullHeadHairGrowth"); }

    FLinearColor& OriginalHairColorField() { return *GetNativePointerField<FLinearColor*>(this, "AShooterCharacter.OriginalHairColor"); }

    //FShooterCharacterPostUpdateTickFunction& PostUpdateTickField() { return *GetNativePointerField<FShooterCharacterPostUpdateTickFunction*>(this, "AShooterCharacter.PostUpdateTick"); }

    long double& LastEmoteTryPlayTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastEmoteTryPlayTime"); }

    int& IgnoreCollisionSweepUntilFrameNumberField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.IgnoreCollisionSweepUntilFrameNumber"); }

    float& ReplicatedWeightField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ReplicatedWeight"); }

    long double& LastPoopTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastPoopTime"); }

    UParticleSystemComponent*& LocalCorpseEmitterField() { return *GetNativePointerField<UParticleSystemComponent**>(this, "AShooterCharacter.LocalCorpseEmitter"); }

    long double& LocalDiedAtTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LocalDiedAtTime"); }

    long double& LastNotStuckTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastNotStuckTime"); }

    USoundBase*& ProneMoveSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.ProneMoveSound"); }

    long double& UploadEarliestValidTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.UploadEarliestValidTime"); }

    long double& LastCollisionStuckTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastCollisionStuckTime"); }

    int& SimulatedLastFrameProcessedForceUpdateAimedActorsField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.SimulatedLastFrameProcessedForceUpdateAimedActors"); }

    TWeakObjectPtr<AController>& SpawnedForControllerField() { return *GetNativePointerField<TWeakObjectPtr<AController>*>(this, "AShooterCharacter.SpawnedForController"); }

    UParticleSystemComponent*& JunctionLinkCableParticleField() { return *GetNativePointerField<UParticleSystemComponent**>(this, "AShooterCharacter.JunctionLinkCableParticle"); }

    UE::Math::TVector<double>& OriginalLastHitWallSweepCheckLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.OriginalLastHitWallSweepCheckLocation"); }

    int& LastCapsuleAttachmentChangedIncrementField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.LastCapsuleAttachmentChangedIncrement"); }

    int& LastMeshAttachmentChangedIncrementField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.LastMeshAttachmentChangedIncrement"); }

    int& LastCameraAttachmentChangedIncrementField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.LastCameraAttachmentChangedIncrement"); }

    TEnumAsByte<enum EPrimalStatsValueTypes::Type>& BestInstantShotResultField() { return *GetNativePointerField<TEnumAsByte<enum EPrimalStatsValueTypes::Type>*>(this, "AShooterCharacter.BestInstantShotResult"); }

    TWeakObjectPtr<APrimalStructure>& CurrentItemBalloonField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructure>*>(this, "AShooterCharacter.CurrentItemBalloon"); }

    FWeaponEvent& NotifyWeaponUnequippedField() { return *GetNativePointerField<FWeaponEvent*>(this, "AShooterCharacter.NotifyWeaponUnequipped"); }

    FWeaponEvent& NotifyWeaponEquippedField() { return *GetNativePointerField<FWeaponEvent*>(this, "AShooterCharacter.NotifyWeaponEquipped"); }

    FWeaponEvent& NotifyWeaponFiredField() { return *GetNativePointerField<FWeaponEvent*>(this, "AShooterCharacter.NotifyWeaponFired"); }

    FWeaponEvent& NotifyOnWeaponEquipField() { return *GetNativePointerField<FWeaponEvent*>(this, "AShooterCharacter.NotifyOnWeaponEquip"); }

    int& PlayerHexagonCountField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.PlayerHexagonCount"); }

    int& DefaultHexagonAmountEarnedOnMissionCompletionField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.DefaultHexagonAmountEarnedOnMissionCompletion"); }

    float& fAutoMoveField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.fAutoMove"); }

    float& fAutoStrafeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.fAutoStrafe"); }

    float& fAutoTurnField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.fAutoTurn"); }

    bool& bAutoFireField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoFire"); }

    bool& bAutoProneField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoProne"); }

    FTimerHandle& AutoPlayerHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.AutoPlayerHandle"); }

    FTimerHandle& AutoMoveHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.AutoMoveHandle"); }

    FTimerHandle& AutoTurnHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.AutoTurnHandle"); }

    FTimerHandle& AutoJumpHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.AutoJumpHandle"); }

    FTimerHandle& AutoFireHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.AutoFireHandle"); }

    float& MeshHeightAdjustmentField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MeshHeightAdjustment"); }

    float& BuffExtraDamageMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BuffExtraDamageMultiplier"); }

    FTimerHandle& UnlockHeadPositionHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.UnlockHeadPositionHandle"); }

    FTimerHandle& ForceStreamComponentsHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "AShooterCharacter.ForceStreamComponentsHandle"); }

    unsigned int& ExpectedBaseIDField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.ExpectedBaseID"); }

    long double& LastExpectedBaseTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastExpectedBaseTime"); }

    bool& bBlockSpawnIntroField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bBlockSpawnIntro"); }

    TWeakObjectPtr<APrimalDinoCharacter>& SavedRidingDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "AShooterCharacter.SavedRidingDino"); }

    UAudioComponent*& DialogueSoundComponentField() { return *GetNativePointerField<UAudioComponent**>(this, "AShooterCharacter.DialogueSoundComponent"); }

    TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >& CachedPlayerMaterialsField() { return *GetNativePointerField<TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.CachedPlayerMaterials"); }

    TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >& CachedAttachmentMaterialsField() { return *GetNativePointerField<TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.CachedAttachmentMaterials"); }

    long double& CurrentShadowOpactiyField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.CurrentShadowOpactiy"); }

    long double& FPVShadowThresholdField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.FPVShadowThreshold"); }

    long double& FPVShadowFadeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.FPVShadowFade"); }

    UAnimationAsset*& ReplicatedSleepAnimField() { return *GetNativePointerField<UAnimationAsset**>(this, "AShooterCharacter.ReplicatedSleepAnim"); }

    TSoftObjectPtr<UAnimationAsset>& SavedSleepAnimField() { return *GetNativePointerField<TSoftObjectPtr<UAnimationAsset>*>(this, "AShooterCharacter.SavedSleepAnim"); }

    float& AimMagnetismStrengthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.AimMagnetismStrength"); }

    float& AimMagnetismOffsetDecaySpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.AimMagnetismOffsetDecaySpeed"); }

    float& AimMagnetismOffsetMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.AimMagnetismOffsetMultiplier"); }

    TMap<int, AShooterProjectile*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, AShooterProjectile*, 0> >& FiredProjectilesCacheField() { return *GetNativePointerField<TMap<int, AShooterProjectile*, FDefaultSetAllocator, TDefaultMapHashableKeyFuncs<int, AShooterProjectile*, 0> >*>(this, "AShooterCharacter.FiredProjectilesCache"); }

    long double& LastUpdatedLocallyInterpolatedViewLocationXField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUpdatedLocallyInterpolatedViewLocationX"); }

    long double& LocallyInterpolatedViewLocationXField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LocallyInterpolatedViewLocationX"); }

    long double& LastUpdatedLocallyInterpolatedViewLocationYField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUpdatedLocallyInterpolatedViewLocationY"); }

    long double& LocallyInterpolatedViewLocationYField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LocallyInterpolatedViewLocationY"); }

    long double& LastUpdatedLocallyInterpolatedViewLocationZField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUpdatedLocallyInterpolatedViewLocationZ"); }

    long double& LocallyInterpolatedViewLocationZField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LocallyInterpolatedViewLocationZ"); }

    float& LocallyInterpolatedViewLocationZSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LocallyInterpolatedViewLocationZSpeed"); }

    long double& LastTimeInThirdPersonField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeInThirdPerson"); }

    float& DefaultPercentOfFullHeadHairGrowthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.DefaultPercentOfFullHeadHairGrowth"); }

    int& DefaultHeadHairIndexField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.DefaultHeadHairIndex"); }

    float& DefaultPercentOfFullFacialHairGrowthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.DefaultPercentOfFullFacialHairGrowth"); }

    int& DefaultFacialHairIndexField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.DefaultFacialHairIndex"); }

    unsigned __int8& bIsPlayingSleepAnimField() { return *GetNativePointerField<unsigned __int8*>(this, "AShooterCharacter.bIsPlayingSleepAnim"); }

    long double& LastTimeDetectedSleepingAnimWhileAwakeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeDetectedSleepingAnimWhileAwake"); }

    float& ClearRiderCameraTransitionInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ClearRiderCameraTransitionInterpSpeed"); }

    float& ClearRiderCameraTransitionInterpTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ClearRiderCameraTransitionInterpTime"); }

    float& TPVCameraExtraCollisionZOffsetField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TPVCameraExtraCollisionZOffset"); }

    TObjectPtr<UTexture2D>& TribeManagementOptionsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.TribeManagementOptionsIcon"); }

    TObjectPtr<UTexture2D>& RecruitToTribeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.RecruitToTribeIcon"); }

    TObjectPtr<UTexture2D>& BanishFromTribeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.BanishFromTribeIcon"); }

    TObjectPtr<UTexture2D>& PromoteToAdminIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.PromoteToAdminIcon"); }

    TObjectPtr<UTexture2D>& AcceptTribeInvitationIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.AcceptTribeInvitationIcon"); }

    TObjectPtr<UTexture2D>& MergeTribeAcceptInvitationIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.MergeTribeAcceptInvitationIcon"); }

    TObjectPtr<UTexture2D>& ViewTribeInfoIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.ViewTribeInfoIcon"); }

    TObjectPtr<UTexture2D>& TribeInvitationOptionsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.TribeInvitationOptionsIcon"); }

    TObjectPtr<UTexture2D>& InviteToAllianceIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.InviteToAllianceIcon"); }

    TObjectPtr<UTexture2D>& CantInviteToAllianceIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.CantInviteToAllianceIcon"); }

    TObjectPtr<UTexture2D>& AcceptInviteToAllianceIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.AcceptInviteToAllianceIcon"); }

    TObjectPtr<UTexture2D>& CantAcceptInviteToAllianceIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.CantAcceptInviteToAllianceIcon"); }

    TObjectPtr<UTexture2D>& DeclareTribeWarIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.DeclareTribeWarIcon"); }

    TObjectPtr<UTexture2D>& AcceptTribeWarIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.AcceptTribeWarIcon"); }

    TObjectPtr<UTexture2D>& ShowUserPageIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "AShooterCharacter.ShowUserPageIcon"); }

    float& EquippedArmorDurabilityPercent3Field() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EquippedArmorDurabilityPercent3"); }

    float& EquippedArmorDurabilityPercent4Field() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EquippedArmorDurabilityPercent4"); }

    float& EquippedArmorDurabilityPercent5Field() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EquippedArmorDurabilityPercent5"); }

    float& EquippedArmorDurabilityPercent6Field() { return *GetNativePointerField<float*>(this, "AShooterCharacter.EquippedArmorDurabilityPercent6"); }

    unsigned int& bSetInitialControlPitchField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.bSetInitialControlPitch"); }

    long double& LastTimePushedField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimePushed"); }

    long double& LastTimeHadPreviousInterpolatedRootLocField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeHadPreviousInterpolatedRootLoc"); }

    UE::Math::TVector<double>& PreviousInterpolatedRootLocField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "AShooterCharacter.PreviousInterpolatedRootLoc"); }

    int& LastPushedDirectionField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.LastPushedDirection"); }

    float& VisualVelocitySizeWhenPushedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.VisualVelocitySizeWhenPushed"); }

    long double& LastPushedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastPushedTime"); }

    long double& LastTimeMulticastedAttachmentReplicationField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeMulticastedAttachmentReplication"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bIsTargeting() { return { this, "AShooterCharacter.bIsTargeting" }; }

    BitFieldValue<bool, unsigned __int32> bIsCrafting() { return { this, "AShooterCharacter.bIsCrafting" }; }

    BitFieldValue<bool, unsigned __int32> bIsRiding() { return { this, "AShooterCharacter.bIsRiding" }; }

    BitFieldValue<bool, unsigned __int32> bIsIndoors() { return { this, "AShooterCharacter.bIsIndoors" }; }

    BitFieldValue<bool, unsigned __int32> bIsClimbing() { return { this, "AShooterCharacter.bIsClimbing" }; }

    BitFieldValue<bool, unsigned __int32> bIsViewingInventory() { return { this, "AShooterCharacter.bIsViewingInventory" }; }

    BitFieldValue<bool, unsigned __int32> bUseAlternateFallBlendspace() { return { this, "AShooterCharacter.bUseAlternateFallBlendspace" }; }

    BitFieldValue<bool, unsigned __int32> bIsFemale() { return { this, "AShooterCharacter.bIsFemale" }; }

    BitFieldValue<bool, unsigned __int32> bPlaySpawnAnim() { return { this, "AShooterCharacter.bPlaySpawnAnim" }; }

    BitFieldValue<bool, unsigned __int32> bPlayFirstSpawnAnim() { return { this, "AShooterCharacter.bPlayFirstSpawnAnim" }; }

    BitFieldValue<bool, unsigned __int32> bNoPhysics() { return { this, "AShooterCharacter.bNoPhysics" }; }

    BitFieldValue<bool, unsigned __int32> bPossessionDontUnsleep() { return { this, "AShooterCharacter.bPossessionDontUnsleep" }; }

    BitFieldValue<bool, unsigned __int32> bLastViewingInventory() { return { this, "AShooterCharacter.bLastViewingInventory" }; }

    BitFieldValue<bool, unsigned __int32> bPlayedSpawnIntro() { return { this, "AShooterCharacter.bPlayedSpawnIntro" }; }

    BitFieldValue<bool, unsigned __int32> bWasSubmerged() { return { this, "AShooterCharacter.bWasSubmerged" }; }

    BitFieldValue<bool, unsigned __int32> bCheckPushedThroughWallsWasSeatingStructure() { return { this, "AShooterCharacter.bCheckPushedThroughWallsWasSeatingStructure" }; }

    BitFieldValue<bool, unsigned __int32> bGaveInitialItems() { return { this, "AShooterCharacter.bGaveInitialItems" }; }

    BitFieldValue<bool, unsigned __int32> bReceivedGenesisSeasonPassItems() { return { this, "AShooterCharacter.bReceivedGenesisSeasonPassItems" }; }

    BitFieldValue<bool, unsigned __int32> bHadGrapHookAttachActor() { return { this, "AShooterCharacter.bHadGrapHookAttachActor" }; }

    BitFieldValue<bool, unsigned __int32> bAddedToActivePlayerList() { return { this, "AShooterCharacter.bAddedToActivePlayerList" }; }

    BitFieldValue<bool, unsigned __int32> bDrawHealthBar() { return { this, "AShooterCharacter.bDrawHealthBar" }; }

    BitFieldValue<bool, unsigned __int32> bBPOverrideHealthBarOffset() { return { this, "AShooterCharacter.bBPOverrideHealthBarOffset" }; }

    BitFieldValue<bool, unsigned __int32> bUseCustomHealthBarColor() { return { this, "AShooterCharacter.bUseCustomHealthBarColor" }; }

    BitFieldValue<bool, unsigned __int32> bDisableLookYaw() { return { this, "AShooterCharacter.bDisableLookYaw" }; }

    BitFieldValue<bool, unsigned __int32> bPlayingShieldCoverAnimation() { return { this, "AShooterCharacter.bPlayingShieldCoverAnimation" }; }

    BitFieldValue<bool, unsigned __int32> bPlayingShieldCoverAnimationForCrouch() { return { this, "AShooterCharacter.bPlayingShieldCoverAnimationForCrouch" }; }

    BitFieldValue<bool, unsigned __int32> bTriggerBPUnstasis() { return { this, "AShooterCharacter.bTriggerBPUnstasis" }; }

    BitFieldValue<bool, unsigned __int32> bWasFirstPerson() { return { this, "AShooterCharacter.bWasFirstPerson" }; }

    BitFieldValue<bool, unsigned __int32> bLastLocInterpProne() { return { this, "AShooterCharacter.bLastLocInterpProne" }; }

    BitFieldValue<bool, unsigned __int32> bLastLocInterpCrouched() { return { this, "AShooterCharacter.bLastLocInterpCrouched" }; }

    BitFieldValue<bool, unsigned __int32> bHatHidden() { return { this, "AShooterCharacter.bHatHidden" }; }

    BitFieldValue<bool, unsigned __int32> bBeganPlay() { return { this, "AShooterCharacter.bBeganPlay" }; }

    BitFieldValue<bool, unsigned __int32> bAllowDPC() { return { this, "AShooterCharacter.bAllowDPC" }; }

    BitFieldValue<bool, unsigned __int32> bHadWeaponWhenStartedClimbingLadder() { return { this, "AShooterCharacter.bHadWeaponWhenStartedClimbingLadder" }; }

    BitFieldValue<bool, unsigned __int32> bIsConnected() { return { this, "AShooterCharacter.bIsConnected" }; }

    BitFieldValue<bool, unsigned __int32> bRefreshDefaultAttachmentsHadEquippedItems() { return { this, "AShooterCharacter.bRefreshDefaultAttachmentsHadEquippedItems" }; }

    BitFieldValue<bool, unsigned __int32> bHasShooterCharacterTicked() { return { this, "AShooterCharacter.bHasShooterCharacterTicked" }; }

    BitFieldValue<bool, unsigned __int32> bLockedToSeatingStructure() { return { this, "AShooterCharacter.bLockedToSeatingStructure" }; }

    BitFieldValue<bool, unsigned __int32> bPreventAllWeapons() { return { this, "AShooterCharacter.bPreventAllWeapons" }; }

    BitFieldValue<bool, unsigned __int32> bForceBuffAimOverride() { return { this, "AShooterCharacter.bForceBuffAimOverride" }; }

    BitFieldValue<bool, unsigned __int32> bIsHidingFPVMesh() { return { this, "AShooterCharacter.bIsHidingFPVMesh" }; }

    BitFieldValue<bool, unsigned __int32> bHideFloatingHUD() { return { this, "AShooterCharacter.bHideFloatingHUD" }; }

    BitFieldValue<bool, unsigned __int32> bForceDrawHUD() { return { this, "AShooterCharacter.bForceDrawHUD" }; }

    BitFieldValue<bool, unsigned __int32> bForceSeatingAnim() { return { this, "AShooterCharacter.bForceSeatingAnim" }; }

    BitFieldValue<bool, unsigned __int32> bIsPressingRunning() { return { this, "AShooterCharacter.bIsPressingRunning" }; }

    BitFieldValue<bool, unsigned __int32> bAutoDestroyPlayerWeapons() { return { this, "AShooterCharacter.bAutoDestroyPlayerWeapons" }; }

    BitFieldValue<bool, unsigned __int32> bDebugCheckDinoPawnsOctree() { return { this, "AShooterCharacter.bDebugCheckDinoPawnsOctree" }; }

    BitFieldValue<bool, unsigned __int32> bUseDefaultWeaponWhenOpeningInventory() { return { this, "AShooterCharacter.bUseDefaultWeaponWhenOpeningInventory" }; }

    BitFieldValue<bool, unsigned __int32> bNeedsHairOrBodyUpdate() { return { this, "AShooterCharacter.bNeedsHairOrBodyUpdate" }; }

    BitFieldValue<bool, unsigned __int32> bSKDynamicMatsHaveBeenRecentlyChangedAndNeedUpdatingOnTheAnimbp() { return { this, "AShooterCharacter.bSKDynamicMatsHaveBeenRecentlyChangedAndNeedUpdatingOnTheAnimbp" }; }


    // Functions


    void ClientNetEndClimbingLadder() { NativeCall<void>(this, "AShooterCharacter.ClientNetEndClimbingLadder()"); }

    void DetachFromLadder() { NativeCall<void>(this, "AShooterCharacter.DetachFromLadder()"); }

    void DetachGrapHookCable() { NativeCall<void>(this, "AShooterCharacter.DetachGrapHookCable()"); }

    void GameStateHandleEvent(FName NameParam, UE::Math::TVector<double>* VecParam) { NativeCall<void, FName, UE::Math::TVector<double>*>(this, "AShooterCharacter.GameStateHandleEvent(FName,UE::Math::TVector<double>)", NameParam, VecParam); }

    bool IsPlayingUpperBodyCallAnimation() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingUpperBodyCallAnimation()"); }

    void NetSetFacialHairPercent(float thePercent, int newFacialHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetFacialHairPercent(float,int)", thePercent, newFacialHairIndex); }

    void NetSetHeadHairPercent(float thePercent, int newHeadHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetHeadHairPercent(float,int)", thePercent, newHeadHairIndex); }

    void RenamePlayer(const FString* NewName) { NativeCall<void, const FString*>(this, "AShooterCharacter.RenamePlayer(FString&)", NewName); }

    void ServerDetachGrapHookCable(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.ServerDetachGrapHookCable(bool,float)", bDoUpwardsJump, UpwardsJumpYaw); }

    void ServerPlayFireBallistaAnimation() { NativeCall<void>(this, "AShooterCharacter.ServerPlayFireBallistaAnimation()"); }

    void ServerSeatingStructureAction(unsigned __int8 ActionNumber) { NativeCall<void, unsigned __int8>(this, "AShooterCharacter.ServerSeatingStructureAction(unsignedchar)", ActionNumber); }

    void ServerSetBallistaNewRotation(float Pitch, float Yaw) { NativeCall<void, float, float>(this, "AShooterCharacter.ServerSetBallistaNewRotation(float,float)", Pitch, Yaw); }

    void ServerSetViewingInventory(bool bIsViewing, bool bMulticast) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ServerSetViewingInventory(bool,bool)", bIsViewing, bMulticast); }

    void ServerStartSurfaceCameraForPassenger(float yaw, float pitch, float roll, bool bShouldInvertInput) { NativeCall<void, float, float, float, bool>(this, "AShooterCharacter.ServerStartSurfaceCameraForPassenger(float,float,float,bool)", yaw, pitch, roll, bShouldInvertInput); }

    void ServerStopFireBallista() { NativeCall<void>(this, "AShooterCharacter.ServerStopFireBallista()"); }

    static void StaticRegisterNativesAShooterCharacter() { NativeCall<void>(nullptr, "AShooterCharacter.StaticRegisterNativesAShooterCharacter()"); }

    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AShooterCharacter.StaticClass()"); }

    void ValidateGeneratedRepEnums(const TArray<FRepRecord, TSizedDefaultAllocator<32> >* ClassReps) { NativeCall<void, const TArray<FRepRecord, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.ValidateGeneratedRepEnums(TArray<FRepRecord,TSizedDefaultAllocator<32>>&)", ClassReps); }

    void Serialize(FStructuredArchiveRecord Record) { NativeCall<void, FStructuredArchiveRecord>(this, "AShooterCharacter.Serialize(FStructuredArchiveRecord)", Record); }

    unsigned int GetUniqueNetIdTypeHash() { return NativeCall<unsigned int>(this, "AShooterCharacter.GetUniqueNetIdTypeHash()"); }

    bool IsVoiceWhispering() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceWhispering()"); }

    bool IsVoiceYelling() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceYelling()"); }

    bool IsVoiceSilent() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceSilent()"); }

    bool IsRider() { return NativeCall<bool>(this, "AShooterCharacter.IsRider()"); }

    bool IsSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsSitting(bool)", bIgnoreLockedToSeat); }

    bool IsProneOrSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsProneOrSitting(bool)", bIgnoreLockedToSeat); }

    void EmitPoop() { NativeCall<void>(this, "AShooterCharacter.EmitPoop()"); }

    unsigned __int64 GetLinkedPlayerDataID() { return NativeCall<unsigned __int64>(this, "AShooterCharacter.GetLinkedPlayerDataID()"); }

    bool IsVoiceTalking() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceTalking()"); }

    bool BuffsPreventFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.BuffsPreventFirstPerson()"); }

    void PostInitializeComponents() { NativeCall<void>(this, "AShooterCharacter.PostInitializeComponents()"); }

    void AuthPostSpawnInit() { NativeCall<void>(this, "AShooterCharacter.AuthPostSpawnInit()"); }

    void CheckFallFromLadder() { NativeCall<void>(this, "AShooterCharacter.CheckFallFromLadder()"); }

    void Destroyed() { NativeCall<void>(this, "AShooterCharacter.Destroyed()"); }

    void OnRep_RawBoneModifiers() { NativeCall<void>(this, "AShooterCharacter.OnRep_RawBoneModifiers()"); }

    void BeginPlay() { NativeCall<void>(this, "AShooterCharacter.BeginPlay()"); }

    void DoSetActorLocation(const UE::Math::TVector<double>* NewLocation) { NativeCall<void, const UE::Math::TVector<double>*>(this, "AShooterCharacter.DoSetActorLocation(UE::Math::TVector<double>&)", NewLocation); }

    void PlaySpawnAnim() { NativeCall<void>(this, "AShooterCharacter.PlaySpawnAnim()"); }

    void ClearSpawnAnim() { NativeCall<void>(this, "AShooterCharacter.ClearSpawnAnim()"); }

    void PlayJumpAnim() { NativeCall<void>(this, "AShooterCharacter.PlayJumpAnim()"); }

    void PlayLandedAnim() { NativeCall<void>(this, "AShooterCharacter.PlayLandedAnim()"); }

    void DedicatedServerBoneFixup() { NativeCall<void>(this, "AShooterCharacter.DedicatedServerBoneFixup()"); }

    void ControllerLeavingGame(AShooterPlayerController* theController) { NativeCall<void, AShooterPlayerController*>(this, "AShooterCharacter.ControllerLeavingGame(AShooterPlayerController*)", theController); }

    void ModifyFirstPersonCameraLocation(UE::Math::TVector<double>* Loc, float DeltaTime) { NativeCall<void, UE::Math::TVector<double>*, float>(this, "AShooterCharacter.ModifyFirstPersonCameraLocation(UE::Math::TVector<double>&,float)", Loc, DeltaTime); }

    void PossessedBy(AController* InController) { NativeCall<void, AController*>(this, "AShooterCharacter.PossessedBy(AController*)", InController); }

    void LocalPossessedBy(APlayerController* ByController) { NativeCall<void, APlayerController*>(this, "AShooterCharacter.LocalPossessedBy(APlayerController*)", ByController); }

    void ForceStreamComponents() { NativeCall<void>(this, "AShooterCharacter.ForceStreamComponents()"); }

    void DoForceStreamComponents(bool bFirstPerson, bool bForceMaxTexturesOnConsole) { NativeCall<void, bool, bool>(this, "AShooterCharacter.DoForceStreamComponents(bool,bool)", bFirstPerson, bForceMaxTexturesOnConsole); }

    void OnRep_PlayerState() { NativeCall<void>(this, "AShooterCharacter.OnRep_PlayerState()"); }

    void ServerDetachGrapHookCable_Implementation(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.ServerDetachGrapHookCable_Implementation(bool,float)", bDoUpwardsJump, UpwardsJumpYaw); }

    void ServerReleaseGrapHookCable_Implementation(bool bReleasing) { NativeCall<void, bool>(this, "AShooterCharacter.ServerReleaseGrapHookCable_Implementation(bool)", bReleasing); }

    void DetachGrapHookCable_Implementation() { NativeCall<void>(this, "AShooterCharacter.DetachGrapHookCable_Implementation()"); }

    void SyncGrapHookDistance_Implementation(float Distance) { NativeCall<void, float>(this, "AShooterCharacter.SyncGrapHookDistance_Implementation(float)", Distance); }

    void UpdateGrapHook(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.UpdateGrapHook(float)", DeltaSeconds); }

    void SetCarriedPitchYaw_Implementation(float NewCarriedPitch, float NewCarriedYaw) { NativeCall<void, float, float>(this, "AShooterCharacter.SetCarriedPitchYaw_Implementation(float,float)", NewCarriedPitch, NewCarriedYaw); }

    void UpdatePawnMeshes(bool bForceThirdPerson, bool bForceFlush) { NativeCall<void, bool, bool>(this, "AShooterCharacter.UpdatePawnMeshes(bool,bool)", bForceThirdPerson, bForceFlush); }

    void OnCameraUpdate(const UE::Math::TVector<double>* CameraLocation, const UE::Math::TRotator<double>* CameraRotation) { NativeCall<void, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*>(this, "AShooterCharacter.OnCameraUpdate(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", CameraLocation, CameraRotation); }

    void ToggleWeapon() { NativeCall<void>(this, "AShooterCharacter.ToggleWeapon()"); }

    void GiveDefaultWeapon(bool bForceGiveDefaultWeapon) { NativeCall<void, bool>(this, "AShooterCharacter.GiveDefaultWeapon(bool)", bForceGiveDefaultWeapon); }

    void GiveMapWeapon() { NativeCall<void>(this, "AShooterCharacter.GiveMapWeapon()"); }

    void SwitchMap() { NativeCall<void>(this, "AShooterCharacter.SwitchMap()"); }

    bool PreventArmorSuitHUD() { return NativeCall<bool>(this, "AShooterCharacter.PreventArmorSuitHUD()"); }

    void DelayGiveDefaultWeapon(float DelayTime) { NativeCall<void, float>(this, "AShooterCharacter.DelayGiveDefaultWeapon(float)", DelayTime); }

    void ServerSwitchMap_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerSwitchMap_Implementation()"); }

    void ServerGiveDefaultWeapon_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerGiveDefaultWeapon_Implementation()"); }

    void GivePrimalItemWeapon(UPrimalItem* aPrimalItem) { NativeCall<void, UPrimalItem*>(this, "AShooterCharacter.GivePrimalItemWeapon(UPrimalItem*)", aPrimalItem); }

    AShooterWeapon* GivePrimalItemWeaponForMission(UPrimalItem* aPrimalItem, AMissionType* AssociatedMission) { return NativeCall<AShooterWeapon*, UPrimalItem*, AMissionType*>(this, "AShooterCharacter.GivePrimalItemWeaponForMission(UPrimalItem*,AMissionType*)", aPrimalItem, AssociatedMission); }

    bool CanStartWeaponSwitch(UPrimalItem* aPrimalItem) { return NativeCall<bool, UPrimalItem*>(this, "AShooterCharacter.CanStartWeaponSwitch(UPrimalItem*)", aPrimalItem); }

    void StartWeaponSwitch(UPrimalItem* aPrimalItem, bool bDontClearLastWeapon) { NativeCall<void, UPrimalItem*, bool>(this, "AShooterCharacter.StartWeaponSwitch(UPrimalItem*,bool)", aPrimalItem, bDontClearLastWeapon); }

    void FinishWeaponSwitch() { NativeCall<void>(this, "AShooterCharacter.FinishWeaponSwitch()"); }

    float GetMaxCursorHUDDistance(AShooterPlayerController* PC) { return NativeCall<float, AShooterPlayerController*>(this, "AShooterCharacter.GetMaxCursorHUDDistance(AShooterPlayerController*)", PC); }

    bool IsSplitPlayer(int* SSIndex) { return NativeCall<bool, int*>(this, "AShooterCharacter.IsSplitPlayer(int*)", SSIndex); }

    void DrawFloatingHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterCharacter.DrawFloatingHUD(AShooterHUD*)", HUD); }

    void SetCurrentWeapon(AShooterWeapon* NewWeapon, AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*, AShooterWeapon*>(this, "AShooterCharacter.SetCurrentWeapon(AShooterWeapon*,AShooterWeapon*)", NewWeapon, LastWeapon); }

    //TSubclassOf<UAnimInstance>* GetOverridenAnimBlueprint(TSubclassOf<UAnimInstance>* result, TSubclassOf<UAnimInstance> fromBPClass) { return NativeCall<TSubclassOf<UAnimInstance> *, TSubclassOf<UAnimInstance>*, TSubclassOf<UAnimInstance>>(this, "AShooterCharacter.GetOverridenAnimBlueprint(TSubclassOf<UAnimInstance>)", result, fromBPClass); }

    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "AShooterCharacter.Serialize(FArchive&)", Ar); }

    void ForceSleep() { NativeCall<void>(this, "AShooterCharacter.ForceSleep()"); }

    bool CanFire() { return NativeCall<bool>(this, "AShooterCharacter.CanFire()"); }

    void SetTargeting(bool bNewTargeting) { NativeCall<void, bool>(this, "AShooterCharacter.SetTargeting(bool)", bNewTargeting); }

    void ServerSetTargeting_Implementation(bool bNewTargeting) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetTargeting_Implementation(bool)", bNewTargeting); }

    void ZoomIn() { NativeCall<void>(this, "AShooterCharacter.ZoomIn()"); }

    void ZoomOut() { NativeCall<void>(this, "AShooterCharacter.ZoomOut()"); }

    bool CanCrouch() { return NativeCall<bool>(this, "AShooterCharacter.CanCrouch()"); }

    bool ShouldBlockCrouch() { return NativeCall<bool>(this, "AShooterCharacter.ShouldBlockCrouch()"); }

    bool CanProne() { return NativeCall<bool>(this, "AShooterCharacter.CanProne()"); }

    void SetupPlayerInputComponent(UInputComponent* WithInputComponent) { NativeCall<void, UInputComponent*>(this, "AShooterCharacter.SetupPlayerInputComponent(UInputComponent*)", WithInputComponent); }

    void OnPressCrouch() { NativeCall<void>(this, "AShooterCharacter.OnPressCrouch()"); }

    void Crouch(bool bClientSimulation) { NativeCall<void, bool>(this, "AShooterCharacter.Crouch(bool)", bClientSimulation); }

    void Prone(bool bClientSimulation) { NativeCall<void, bool>(this, "AShooterCharacter.Prone(bool)", bClientSimulation); }

    void OnPressProne() { NativeCall<void>(this, "AShooterCharacter.OnPressProne()"); }

    void OnPressCrouchProneToggle() { NativeCall<void>(this, "AShooterCharacter.OnPressCrouchProneToggle()"); }

    void OnReleaseCrouchProneToggle() { NativeCall<void>(this, "AShooterCharacter.OnReleaseCrouchProneToggle()"); }

    void OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "AShooterCharacter.OnEndCrouch(float,float)", HalfHeightAdjust, ScaledHalfHeightAdjust); }

    void OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "AShooterCharacter.OnStartCrouch(float,float)", HalfHeightAdjust, ScaledHalfHeightAdjust); }

    void OnStartFire() { NativeCall<void>(this, "AShooterCharacter.OnStartFire()"); }

    void OnStopFire() { NativeCall<void>(this, "AShooterCharacter.OnStopFire()"); }

    void OnStartTargeting() { NativeCall<void>(this, "AShooterCharacter.OnStartTargeting()"); }

    void OnStopTargeting() { NativeCall<void>(this, "AShooterCharacter.OnStopTargeting()"); }

    void OnStartAltFire() { NativeCall<void>(this, "AShooterCharacter.OnStartAltFire()"); }

    void OnStopAltFire() { NativeCall<void>(this, "AShooterCharacter.OnStopAltFire()"); }

    void OnPressReload() { NativeCall<void>(this, "AShooterCharacter.OnPressReload()"); }

    void OnReleaseReload() { NativeCall<void>(this, "AShooterCharacter.OnReleaseReload()"); }

    void OnHoldingReload() { NativeCall<void>(this, "AShooterCharacter.OnHoldingReload()"); }

    void OnReload() { NativeCall<void>(this, "AShooterCharacter.OnReload()"); }

    void OnStartRunning() { NativeCall<void>(this, "AShooterCharacter.OnStartRunning()"); }

    void OnStopRunning() { NativeCall<void>(this, "AShooterCharacter.OnStopRunning()"); }

    bool IsTurningTooFastToRun(const UE::Math::TVector<double>* Velocity, const UE::Math::TRotator<double>* Rotation) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*>(this, "AShooterCharacter.IsTurningTooFastToRun(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", Velocity, Rotation); }

    bool IsRunning() { return NativeCall<bool>(this, "AShooterCharacter.IsRunning()"); }

    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset, bool bPreserveSavedAnim) { NativeCall<void, bool, bool, bool>(this, "AShooterCharacter.SetSleeping(bool,bool,bool)", bSleeping, bUseRagdollLocationOffset, bPreserveSavedAnim); }

    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "AShooterCharacter.IsValidUnStasisCaster()"); }

    void CheckAndHandleBasedPlayersBeingPushedThroughWalls() { NativeCall<void>(this, "AShooterCharacter.CheckAndHandleBasedPlayersBeingPushedThroughWalls()"); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.Tick(float)", DeltaSeconds); }

    void CalculateTetheringForSplitScreen() { NativeCall<void>(this, "AShooterCharacter.CalculateTetheringForSplitScreen()"); }

    void UpdateCarriedLocationAndRotation(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.UpdateCarriedLocationAndRotation(float)", DeltaSeconds); }

    float GetCarryingSocketYaw(bool RefreshBones) { return NativeCall<float, bool>(this, "AShooterCharacter.GetCarryingSocketYaw(bool)", RefreshBones); }

    bool CanBeCarried(APrimalCharacter* ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "AShooterCharacter.CanBeCarried(APrimalCharacter*)", ByCarrier); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.GetLifetimeReplicatedProps(TArray<FLifetimeProperty,TSizedDefaultAllocator<32>>&)", OutLifetimeProps); }

    bool IsTargeting() { return NativeCall<bool>(this, "AShooterCharacter.IsTargeting()"); }

    bool IsFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.IsFirstPerson()"); }

    bool IsFirstPersonCamera() { return NativeCall<bool>(this, "AShooterCharacter.IsFirstPersonCamera()"); }

    void SetActorHiddenInGame(bool bNewHidden) { NativeCall<void, bool>(this, "AShooterCharacter.SetActorHiddenInGame(bool)", bNewHidden); }

    bool AllowFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.AllowFirstPerson()"); }

    void SetCameraMode(bool bFirstperson, bool bIgnoreSettingFirstPersonRiding, bool bForce) { NativeCall<void, bool, bool, bool>(this, "AShooterCharacter.SetCameraMode(bool,bool,bool)", bFirstperson, bIgnoreSettingFirstPersonRiding, bForce); }

    void PlaySpawnIntro() { NativeCall<void>(this, "AShooterCharacter.PlaySpawnIntro()"); }

    void FinishSpawnIntro() { NativeCall<void>(this, "AShooterCharacter.FinishSpawnIntro()"); }

    void AnimNotifyCustomEvent(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const UAnimNotify* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, const UAnimNotify*>(this, "AShooterCharacter.AnimNotifyCustomEvent(FName,USkeletalMeshComponent*,UAnimSequenceBase*,UAnimNotify*)", CustomEventName, MeshComp, Animation, AnimNotifyObject); }

    void AnimNotifyCustomState_Begin(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float TotalDuration, const UAnimNotifyState* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, float, const UAnimNotifyState*>(this, "AShooterCharacter.AnimNotifyCustomState_Begin(FName,USkeletalMeshComponent*,UAnimSequenceBase*,float,UAnimNotifyState*)", CustomEventName, MeshComp, Animation, TotalDuration, AnimNotifyObject); }

    void AnimNotifyCustomState_Tick(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float FrameDeltaTime, const UAnimNotifyState* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, float, const UAnimNotifyState*>(this, "AShooterCharacter.AnimNotifyCustomState_Tick(FName,USkeletalMeshComponent*,UAnimSequenceBase*,float,UAnimNotifyState*)", CustomEventName, MeshComp, Animation, FrameDeltaTime, AnimNotifyObject); }

    void AnimNotifyCustomState_End(FName CustomEventName, USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const UAnimNotifyState* AnimNotifyObject) { NativeCall<void, FName, USkeletalMeshComponent*, UAnimSequenceBase*, const UAnimNotifyState*>(this, "AShooterCharacter.AnimNotifyCustomState_End(FName,USkeletalMeshComponent*,UAnimSequenceBase*,UAnimNotifyState*)", CustomEventName, MeshComp, Animation, AnimNotifyObject); }

    bool ValidToRestoreForPC(AShooterPlayerController* aPC) { return NativeCall<bool, AShooterPlayerController*>(this, "AShooterCharacter.ValidToRestoreForPC(AShooterPlayerController*)", aPC); }

    static AShooterCharacter* FindForPlayerController(AShooterPlayerController* aPC) { return NativeCall<AShooterCharacter*, AShooterPlayerController*>(nullptr, "AShooterCharacter.FindForPlayerController(AShooterPlayerController*)", aPC); }

    FString* GetDescriptiveName(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterCharacter.GetDescriptiveName()", result); }

    FString* GetShortName(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterCharacter.GetShortName()", result); }

    UPrimalPlayerData* GetPlayerData() { return NativeCall<UPrimalPlayerData*>(this, "AShooterCharacter.GetPlayerData()"); }

    void PlayDying(float KillingDamage, const FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "AShooterCharacter.PlayDying(float,FDamageEvent&,APawn*,AActor*)", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    bool IsUsingShield() { return NativeCall<bool>(this, "AShooterCharacter.IsUsingShield()"); }

    bool IsBlockingWithShield() { return NativeCall<bool>(this, "AShooterCharacter.IsBlockingWithShield()"); }

    void NetSimulatedForceUpdateAimedActors_Implementation(float OverrideMaxDistance) { NativeCall<void, float>(this, "AShooterCharacter.NetSimulatedForceUpdateAimedActors_Implementation(float)", OverrideMaxDistance); }

    void ServerForceUpdatedAimedActors(float OverrideMaxDistance, bool bReplicateToSimulatedClients) { NativeCall<void, float, bool>(this, "AShooterCharacter.ServerForceUpdatedAimedActors(float,bool)", OverrideMaxDistance, bReplicateToSimulatedClients); }

    void ServerSetBallistaNewRotation_Implementation(float Pitch, float Yaw) { NativeCall<void, float, float>(this, "AShooterCharacter.ServerSetBallistaNewRotation_Implementation(float,float)", Pitch, Yaw); }

    void ServerNotifyBallistaShot_Implementation(FHitResult* Impact, FVector_NetQuantizeNormal* ShootDir) { NativeCall<void, FHitResult*, FVector_NetQuantizeNormal*>(this, "AShooterCharacter.ServerNotifyBallistaShot_Implementation(FHitResult,FVector_NetQuantizeNormal)", Impact, ShootDir); }

    float GetMaxSpeedModifier() { return NativeCall<float>(this, "AShooterCharacter.GetMaxSpeedModifier()"); }

    USkeletalMeshComponent* GetFirstPersonHandsMesh() { return NativeCall<USkeletalMeshComponent*>(this, "AShooterCharacter.GetFirstPersonHandsMesh()"); }

    AShooterWeapon* GetCurrentWeapon() { return NativeCall<AShooterWeapon*>(this, "AShooterCharacter.GetCurrentWeapon()"); }

    void SetRidingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.SetRidingDino(APrimalDinoCharacter*)", aDino); }

    void ServerReceiveTribeInvite_Implementation(AShooterPlayerController* playerSendingInvite) { NativeCall<void, AShooterPlayerController*>(this, "AShooterCharacter.ServerReceiveTribeInvite_Implementation(AShooterPlayerController*)", playerSendingInvite); }

    void ClearRidingDino(bool bFromDino, int OverrideUnboardDirection, bool bForceEvenIfBuffPreventsClear) { NativeCall<void, bool, int, bool>(this, "AShooterCharacter.ClearRidingDino(bool,int,bool)", bFromDino, OverrideUnboardDirection, bForceEvenIfBuffPreventsClear); }

    void SetCarryingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.SetCarryingDino(APrimalDinoCharacter*)", aDino); }

    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ClearCarryingDino(bool,bool)", bFromDino, bCancelAnyCarryBuffs); }

    void SetRidingDinoAsPassenger(APrimalDinoCharacter* aDino, const FSaddlePassengerSeatDefinition* SeatDefinition) { NativeCall<void, APrimalDinoCharacter*, const FSaddlePassengerSeatDefinition*>(this, "AShooterCharacter.SetRidingDinoAsPassenger(APrimalDinoCharacter*,FSaddlePassengerSeatDefinition&)", aDino, SeatDefinition); }

    void ClearRidingDinoAsPassenger(bool bFromDino) { NativeCall<void, bool>(this, "AShooterCharacter.ClearRidingDinoAsPassenger(bool)", bFromDino); }

    void ServerLaunchMountedDino_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerLaunchMountedDino_Implementation()"); }

    void ServerPrepareMountedDinoForLaunch_Implementation(UE::Math::TVector<double>* viewLoc, UE::Math::TVector<double>* viewDir) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "AShooterCharacter.ServerPrepareMountedDinoForLaunch_Implementation(UE::Math::TVector<double>,UE::Math::TVector<double>)", viewLoc, viewDir); }

    void ClientPlayHarvestAnim_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientPlayHarvestAnim_Implementation()"); }

    void LaunchMountedDino() { NativeCall<void>(this, "AShooterCharacter.LaunchMountedDino()"); }

    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "AShooterCharacter.OnPrimalCharacterSleeped()"); }

    bool Die(float KillingDamage, const FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, const FDamageEvent*, AController*, AActor*>(this, "AShooterCharacter.Die(float,FDamageEvent&,AController*,AActor*)", KillingDamage, DamageEvent, Killer, DamageCauser); }

    void ApplyDamageMomentum(float DamageTaken, const FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, const FDamageEvent*, APawn*, AActor*>(this, "AShooterCharacter.ApplyDamageMomentum(float,FDamageEvent&,APawn*,AActor*)", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.CanJumpInternal_Implementation()"); }

    bool CanProneInternal(__int16 a2) { return NativeCall<bool, __int16>(this, "AShooterCharacter.CanProneInternal()", a2); }

    bool IsCrafting() { return NativeCall<bool>(this, "AShooterCharacter.IsCrafting()"); }

    void RemoveAttachments(AActor* From, bool bIsSnapshot) { NativeCall<void, AActor*, bool>(this, "AShooterCharacter.RemoveAttachments(AActor*,bool)", From, bIsSnapshot); }

    void NotifyEquippedItems() { NativeCall<void>(this, "AShooterCharacter.NotifyEquippedItems()"); }

    void NotifyUnequippedItems() { NativeCall<void>(this, "AShooterCharacter.NotifyUnequippedItems()"); }

    void RefreshAttachmentsAndBody() { NativeCall<void>(this, "AShooterCharacter.RefreshAttachmentsAndBody()"); }

    void RefreshDefaultAttachments(AActor* UseOtherActor, bool bIsSnapshot) { NativeCall<void, AActor*, bool>(this, "AShooterCharacter.RefreshDefaultAttachments(AActor*,bool)", UseOtherActor, bIsSnapshot); }

    void GetMultiUseEntries(APlayerController* ForPC, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* MultiUseEntries, int hitBodyIndex) { NativeCall<void, APlayerController*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*, int>(this, "AShooterCharacter.GetMultiUseEntries(APlayerController*,TArray<FMultiUseEntry,TSizedDefaultAllocator<32>>&,int)", ForPC, MultiUseEntries, hitBodyIndex); }

    void GetMultiUseEntriesFromBuffs(APlayerController* ForPC, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* MultiUseEntries) { NativeCall<void, APlayerController*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.GetMultiUseEntriesFromBuffs(APlayerController*,TArray<FMultiUseEntry,TSizedDefaultAllocator<32>>&)", ForPC, MultiUseEntries); }

    void ClientMultiUse(APlayerController* ForPC, int UseIndex, int hitBodyIndex) { NativeCall<void, APlayerController*, int, int>(this, "AShooterCharacter.ClientMultiUse(APlayerController*,int,int)", ForPC, UseIndex, hitBodyIndex); }

    bool TryMultiUse(APlayerController* ForPC, int UseIndex, int hitBodyIndex) { return NativeCall<bool, APlayerController*, int, int>(this, "AShooterCharacter.TryMultiUse(APlayerController*,int,int)", ForPC, UseIndex, hitBodyIndex); }

    void RefreshTribeName() { NativeCall<void>(this, "AShooterCharacter.RefreshTribeName()"); }

    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "AShooterCharacter.ChangeActorTeam(int)", NewTeam); }

    void ClientClearTribeRequest_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientClearTribeRequest_Implementation()"); }

    void ClientNotifyTribeRequest_Implementation(const FString* RequestTribeName, AShooterCharacter* PlayerCharacter) { NativeCall<void, const FString*, AShooterCharacter*>(this, "AShooterCharacter.ClientNotifyTribeRequest_Implementation(FString&,AShooterCharacter*)", RequestTribeName, PlayerCharacter); }

    //void PlayDrinkingAnimation() { NativeCall<void, __int64, __int64>(this, "AShooterCharacter.PlayDrinkingAnimation()"); }

    float GetCharacterAdditionalHypothermiaInsulationValue() { return NativeCall<float>(this, "AShooterCharacter.GetCharacterAdditionalHypothermiaInsulationValue()"); }

    bool CalcIsIndoors() { return NativeCall<bool>(this, "AShooterCharacter.CalcIsIndoors()"); }

    static bool IsIndoorsAtLoc(UWorld* theWorld, const UE::Math::TVector<double>* actorLoc) { return NativeCall<bool, UWorld*, const UE::Math::TVector<double>*>(nullptr, "AShooterCharacter.IsIndoorsAtLoc(UWorld*,UE::Math::TVector<double>&)", theWorld, actorLoc); }

    float GetInsulationFromItem(const FHitResult* HitOut, EPrimalItemStat::Type TypeInsulation) { return NativeCall<float, const FHitResult*, EPrimalItemStat::Type>(this, "AShooterCharacter.GetInsulationFromItem(FHitResult&,EPrimalItemStat::Type)", HitOut, TypeInsulation); }

    float GetCharacterAdditionalInsulationValueFromStructure(UWorld* theWorld, const UE::Math::TVector<double>* actorLoc, EPrimalItemStat::Type TypeInsulation) { return NativeCall<float, UWorld*, const UE::Math::TVector<double>*, EPrimalItemStat::Type>(this, "AShooterCharacter.GetCharacterAdditionalInsulationValueFromStructure(UWorld*,UE::Math::TVector<double>&,EPrimalItemStat::Type)", theWorld, actorLoc, TypeInsulation); }

    float GetCharacterAdditionalHyperthermiaInsulationValue() { return NativeCall<float>(this, "AShooterCharacter.GetCharacterAdditionalHyperthermiaInsulationValue()"); }

    void PreInitializeComponents() { NativeCall<void>(this, "AShooterCharacter.PreInitializeComponents()"); }

    void OnMovementModeChanged(EMovementMode PrevMovementMode, unsigned __int8 PreviousCustomMode) { NativeCall<void, EMovementMode, unsigned __int8>(this, "AShooterCharacter.OnMovementModeChanged(EMovementMode,unsignedchar)", PrevMovementMode, PreviousCustomMode); }

    void PreApplyAccumulatedForces(float DeltaSeconds, UE::Math::TVector<double>* PendingImpulseToApply, UE::Math::TVector<double>* PendingForceToApply) { NativeCall<void, float, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "AShooterCharacter.PreApplyAccumulatedForces(float,UE::Math::TVector<double>&,UE::Math::TVector<double>&)", DeltaSeconds, PendingImpulseToApply, PendingForceToApply); }

    void OnBeginDrag_Implementation(APrimalCharacter* Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "AShooterCharacter.OnBeginDrag_Implementation(APrimalCharacter*,int,bool)", Dragged, BoneIndex, bWithGrapHook); }

    void OnEndDrag_Implementation() { NativeCall<void>(this, "AShooterCharacter.OnEndDrag_Implementation()"); }

    bool IsSubmerged(bool bDontCheckSwimming, bool bUseHalfThreshold, bool bForceCheck, bool bFromVolumeChange) { return NativeCall<bool, bool, bool, bool, bool>(this, "AShooterCharacter.IsSubmerged(bool,bool,bool,bool)", bDontCheckSwimming, bUseHalfThreshold, bForceCheck, bFromVolumeChange); }

    void UpdateSwimmingState() { NativeCall<void>(this, "AShooterCharacter.UpdateSwimmingState()"); }

    void SetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "AShooterCharacter.SetCharacterMeshesMaterialScalarParamValue(FName,float)", ParamName, Value); }

    void RefreshRiderSocket() { NativeCall<void>(this, "AShooterCharacter.RefreshRiderSocket()"); }

    float GetRidingDinoAnimSpeedRatio() { return NativeCall<float>(this, "AShooterCharacter.GetRidingDinoAnimSpeedRatio()"); }

    UAnimSequence* GetDinoRidingAnimation() { return NativeCall<UAnimSequence*>(this, "AShooterCharacter.GetDinoRidingAnimation()"); }

    UAnimSequence* GetDinoRidingMoveAnimation() { return NativeCall<UAnimSequence*>(this, "AShooterCharacter.GetDinoRidingMoveAnimation()"); }

    UAnimSequence* GetSeatingAnimation() { return NativeCall<UAnimSequence*>(this, "AShooterCharacter.GetSeatingAnimation()"); }

    float GetBaseTargetingDesire(const ITargetableInterface* Attacker) { return NativeCall<float, const ITargetableInterface*>(this, "AShooterCharacter.GetBaseTargetingDesire(ITargetableInterface*)", Attacker); }

    void ApplyBodyColors() { NativeCall<void>(this, "AShooterCharacter.ApplyBodyColors()"); }

    void ApplyBodyColors(USkeletalMeshComponent* toMesh) { NativeCall<void, USkeletalMeshComponent*>(this, "AShooterCharacter.ApplyBodyColors(USkeletalMeshComponent*)", toMesh); }

    void ApplyBoneModifiers(int a2) { NativeCall<void, int>(this, "AShooterCharacter.ApplyBoneModifiers()", a2); }

    void CaptureCharacterSnapshot(UPrimalItem* Item) { NativeCall<void, UPrimalItem*>(this, "AShooterCharacter.CaptureCharacterSnapshot(UPrimalItem*)", Item); }

    void ApplyCharacterSnapshot(UPrimalItem* Item, AActor* To, UE::Math::TVector<double>* Offset, float MaxExtent, int Pose, bool bCollisionOn) { NativeCall<void, UPrimalItem*, AActor*, UE::Math::TVector<double>*, float, int, bool>(this, "AShooterCharacter.ApplyCharacterSnapshot(UPrimalItem*,AActor*,UE::Math::TVector<double>,float,int,bool)", Item, To, Offset, MaxExtent, Pose, bCollisionOn); }

    void RemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(this, "AShooterCharacter.RemoveCharacterSnapshot(UPrimalItem*,AActor*)", Item, From); }

    float GetTargetingDesirability(const ITargetableInterface* Attacker) { return NativeCall<float, const ITargetableInterface*>(this, "AShooterCharacter.GetTargetingDesirability(ITargetableInterface*)", Attacker); }

    UAnimMontage* GetOverridenMontage(UAnimMontage* AnimMontage) { return NativeCall<UAnimMontage*, UAnimMontage*>(this, "AShooterCharacter.GetOverridenMontage(UAnimMontage*)", AnimMontage); }

    UAnimSequence* GetOverridenAnimSequence(UAnimSequence* AnimSeq) { return NativeCall<UAnimSequence*, UAnimSequence*>(this, "AShooterCharacter.GetOverridenAnimSequence(UAnimSequence*)", AnimSeq); }

    bool IsWatered() { return NativeCall<bool>(this, "AShooterCharacter.IsWatered()"); }

    void AdjustDamage(float* Damage, const FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, const FDamageEvent*, AController*, AActor*>(this, "AShooterCharacter.AdjustDamage(float&,FDamageEvent&,AController*,AActor*)", Damage, DamageEvent, EventInstigator, DamageCauser); }

    bool IsBlockedByShield(const FHitResult* HitInfo, const UE::Math::TVector<double>* ShotDirection, bool bBlockAllPointDamage) { return NativeCall<bool, const FHitResult*, const UE::Math::TVector<double>*, bool>(this, "AShooterCharacter.IsBlockedByShield(FHitResult&,UE::Math::TVector<double>&,bool)", HitInfo, ShotDirection, bBlockAllPointDamage); }

    void ClientNotifyLevelUp_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientNotifyLevelUp_Implementation()"); }

    void StartedFiringWeapon(bool bPrimaryFire) { NativeCall<void, bool>(this, "AShooterCharacter.StartedFiringWeapon(bool)", bPrimaryFire); }

    void FiredWeapon() { NativeCall<void>(this, "AShooterCharacter.FiredWeapon()"); }

    void OrbitCamOn() { NativeCall<void>(this, "AShooterCharacter.OrbitCamOn()"); }

    void OrbitCamToggle() { NativeCall<void>(this, "AShooterCharacter.OrbitCamToggle()"); }

    void SetRagdollPhysics(bool bUseRagdollLocationOffset, bool bForceRecreateBones, bool bForLoading) { NativeCall<void, bool, bool, bool>(this, "AShooterCharacter.SetRagdollPhysics(bool,bool,bool)", bUseRagdollLocationOffset, bForceRecreateBones, bForLoading); }

    bool IsPlayingUpperBodyCallAnimation_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingUpperBodyCallAnimation_Implementation()"); }

    void ServerCallFollow_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallFollow_Implementation()"); }

    void ServerCallFollowOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallFollowOne_Implementation(APrimalDinoCharacter*)", ForDinoChar); }

    void ServerCallStay_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallStay_Implementation()"); }

    void ServerCallStayOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallStayOne_Implementation(APrimalDinoCharacter*)", ForDinoChar); }

    void ServerCallFollowDistanceCycleOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallFollowDistanceCycleOne_Implementation(APrimalDinoCharacter*)", ForDinoChar); }

    void ServerCallAggressive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallAggressive_Implementation()"); }

    void ServerCallAttackTargetNew_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallAttackTargetNew_Implementation()"); }

    void ServerCallNeutral_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallNeutral_Implementation()"); }

    void ServerCallPassive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallPassive_Implementation()"); }

    void ServerCallPassiveFlee_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallPassiveFlee_Implementation()"); }

    void ServerCallSetAggressive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallSetAggressive_Implementation()"); }

    void ServerCallAttackTarget_Implementation(AActor* TheTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ServerCallAttackTarget_Implementation(AActor*)", TheTarget); }

    void ServerCallMoveTo_Implementation(UE::Math::TVector<double>* MoveToLoc) { NativeCall<void, UE::Math::TVector<double>*>(this, "AShooterCharacter.ServerCallMoveTo_Implementation(UE::Math::TVector<double>)", MoveToLoc); }

    void ServerCallLandFlyerOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallLandFlyerOne_Implementation(APrimalDinoCharacter*)", ForDinoChar); }

    bool TryAccessInventory() { return NativeCall<bool>(this, "AShooterCharacter.TryAccessInventory()"); }

    void TryLaunchMountedDino() { NativeCall<void>(this, "AShooterCharacter.TryLaunchMountedDino()"); }

    bool TemplateAllowActorSpawn(UWorld* World, const UE::Math::TVector<double>* AtLocation, const UE::Math::TRotator<double>* AtRotation, const FActorSpawnParameters* SpawnParameters) { return NativeCall<bool, UWorld*, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*, const FActorSpawnParameters*>(this, "AShooterCharacter.TemplateAllowActorSpawn(UWorld*,UE::Math::TVector<double>&,UE::Math::TRotator<double>&,FActorSpawnParameters&)", World, AtLocation, AtRotation, SpawnParameters); }

    bool WillPlayEmote(unsigned __int8 EmoteIndex) { return NativeCall<bool, unsigned __int8>(this, "AShooterCharacter.WillPlayEmote(unsignedchar)", EmoteIndex); }

    void PlayEmoteAnimation_Implementation(unsigned __int8 EmoteIndex) { NativeCall<void, unsigned __int8>(this, "AShooterCharacter.PlayEmoteAnimation_Implementation(unsignedchar)", EmoteIndex); }

    void OnVoiceTalkingStateChanged(bool talking, bool InbIsMuted) { NativeCall<void, bool, bool>(this, "AShooterCharacter.OnVoiceTalkingStateChanged(bool,bool)", talking, InbIsMuted); }

    void OnPlayerTalkingStateChanged(TSharedRef<FUniqueNetId const>* TalkingPlayerId, bool bIsTalking) { NativeCall<void, TSharedRef<FUniqueNetId const>*, bool>(this, "AShooterCharacter.OnPlayerTalkingStateChanged(TSharedRef<FUniqueNetId,1>,bool)", TalkingPlayerId, bIsTalking); }

    APrimalCharacter* GetTalkerCharacter() { return NativeCall<APrimalCharacter*>(this, "AShooterCharacter.GetTalkerCharacter()"); }

    void OnFailedJumped() { NativeCall<void>(this, "AShooterCharacter.OnFailedJumped()"); }

    float GetRecoilMultiplier() { return NativeCall<float>(this, "AShooterCharacter.GetRecoilMultiplier()"); }

    void StasisingCharacter() { NativeCall<void>(this, "AShooterCharacter.StasisingCharacter()"); }

    bool UseAdditiveStandingAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAdditiveStandingAnim()"); }

    UAnimSequence* GetAdditiveStandingAnim(float* OutBlendInTime, float* OutBlendOutTime) { return NativeCall<UAnimSequence*, float*, float*>(this, "AShooterCharacter.GetAdditiveStandingAnim(float&,float&)", OutBlendInTime, OutBlendOutTime); }

    void ServerSetViewingInventory_Implementation(bool bIsViewing, bool bMulticast) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ServerSetViewingInventory_Implementation(bool,bool)", bIsViewing, bMulticast); }

    void ServerCheckDrinkingWater_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCheckDrinkingWater_Implementation()"); }

    void SetFastInventoryMode(bool Activate) { NativeCall<void, bool>(this, "AShooterCharacter.SetFastInventoryMode(bool)", Activate); }

    void CycleFastInventory(bool bRefresh, bool bNext) { NativeCall<void, bool, bool>(this, "AShooterCharacter.CycleFastInventory(bool,bool)", bRefresh, bNext); }

    void ClientUpdatedInventory_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientUpdatedInventory_Implementation()"); }

    void RequestFastInventory() { NativeCall<void>(this, "AShooterCharacter.RequestFastInventory()"); }

    TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* GetWeaponAmmoWheelEntries(TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.GetWeaponAmmoWheelEntries()", result); }

    void TrySwitchFastInventory() { NativeCall<void>(this, "AShooterCharacter.TrySwitchFastInventory()"); }

    void GameStateHandleEvent_Implementation(FName NameParam, UE::Math::TVector<double>* VecParam) { NativeCall<void, FName, UE::Math::TVector<double>*>(this, "AShooterCharacter.GameStateHandleEvent_Implementation(FName,UE::Math::TVector<double>)", NameParam, VecParam); }

    APrimalDinoCharacter* GetRidingDino() { return NativeCall<APrimalDinoCharacter*>(this, "AShooterCharacter.GetRidingDino()"); }

    void AttachToLadder_Implementation(USceneComponent* Parent) { NativeCall<void, USceneComponent*>(this, "AShooterCharacter.AttachToLadder_Implementation(USceneComponent*)", Parent); }

    void DetachFromLadder_Implementation() { NativeCall<void>(this, "AShooterCharacter.DetachFromLadder_Implementation()"); }

    bool IsValidForStatusRecovery() { return NativeCall<bool>(this, "AShooterCharacter.IsValidForStatusRecovery()"); }

    bool IsOnSeatingStructure() { return NativeCall<bool>(this, "AShooterCharacter.IsOnSeatingStructure()"); }

    bool IsControllingBallistaTurret() { return NativeCall<bool>(this, "AShooterCharacter.IsControllingBallistaTurret()"); }

    APrimalStructureTurretBallista* GetControlledTurretBallista() { return NativeCall<APrimalStructureTurretBallista*>(this, "AShooterCharacter.GetControlledTurretBallista()"); }

    AMissionType* GetActiveMission() { return NativeCall<AMissionType*>(this, "AShooterCharacter.GetActiveMission()"); }

    bool IsInMission() { return NativeCall<bool>(this, "AShooterCharacter.IsInMission()"); }

    bool IsInSingletonMission() { return NativeCall<bool>(this, "AShooterCharacter.IsInSingletonMission()"); }

    void OnDetachedFromSeatingStructure(APrimalStructureSeating* InSeatingStructure) { NativeCall<void, APrimalStructureSeating*>(this, "AShooterCharacter.OnDetachedFromSeatingStructure(APrimalStructureSeating*)", InSeatingStructure); }

    void TakeSeatingStructure(APrimalStructureSeating* InSeatingStructure, int SeatNumber, bool bLockedToSeat) { NativeCall<void, APrimalStructureSeating*, int, bool>(this, "AShooterCharacter.TakeSeatingStructure(APrimalStructureSeating*,int,bool)", InSeatingStructure, SeatNumber, bLockedToSeat); }

    void ReleaseSeatingStructure(APrimalStructureSeating* InSeatingStructure, UE::Math::TVector<double>* PrevRelativeLocation) { NativeCall<void, APrimalStructureSeating*, UE::Math::TVector<double>*>(this, "AShooterCharacter.ReleaseSeatingStructure(APrimalStructureSeating*,UE::Math::TVector<double>)", InSeatingStructure, PrevRelativeLocation); }

    bool IsUsingClimbingPick() { return NativeCall<bool>(this, "AShooterCharacter.IsUsingClimbingPick()"); }

    void ServerSetBallistaTargeting_Implementation(bool StartTargeting) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetBallistaTargeting_Implementation(bool)", StartTargeting); }

    void ServerPlayFireBallistaAnimation_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerPlayFireBallistaAnimation_Implementation()"); }

    void ServerStopFireBallista_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerStopFireBallista_Implementation()"); }

    void ServerSwitchBallistaAmmo_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerSwitchBallistaAmmo_Implementation()"); }

    void ServerToClientsPlayFireBallistaAnimation_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerToClientsPlayFireBallistaAnimation_Implementation()"); }

    void ServerFireBallistaProjectile_Implementation(UE::Math::TVector<double>* Origin, FVector_NetQuantizeNormal* ShootDir) { NativeCall<void, UE::Math::TVector<double>*, FVector_NetQuantizeNormal*>(this, "AShooterCharacter.ServerFireBallistaProjectile_Implementation(UE::Math::TVector<double>,FVector_NetQuantizeNormal)", Origin, ShootDir); }

    void ServerSeatingStructureAction_Implementation(unsigned __int8 ActionNumber) { NativeCall<void, unsigned __int8>(this, "AShooterCharacter.ServerSeatingStructureAction_Implementation(unsignedchar)", ActionNumber); }

    void WasPushed(ACharacter* ByOtherCharacter, UE::Math::TVector<double>* PushDirection) { NativeCall<void, ACharacter*, UE::Math::TVector<double>*>(this, "AShooterCharacter.WasPushed(ACharacter*,UE::Math::TVector<double>)", ByOtherCharacter, PushDirection); }

    void ClientWasPushed_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientWasPushed_Implementation()"); }

    void NotifyBumpedPawn(APawn* BumpedPawn) { NativeCall<void, APawn*>(this, "AShooterCharacter.NotifyBumpedPawn(APawn*)", BumpedPawn); }

    void ClientNetEndClimbingLadder_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientNetEndClimbingLadder_Implementation()"); }

    void ServerNetEndClimbingLadder_Implementation(bool bIsClimbOver, UE::Math::TVector<double>* ClimbOverLoc, UE::Math::TVector<double>* JumpDir) { NativeCall<void, bool, UE::Math::TVector<double>*, UE::Math::TVector<double>*>(this, "AShooterCharacter.ServerNetEndClimbingLadder_Implementation(bool,UE::Math::TVector<double>,UE::Math::TVector<double>)", bIsClimbOver, ClimbOverLoc, JumpDir); }

    void RenamePlayer_Implementation(const FString* NewName) { NativeCall<void, const FString*>(this, "AShooterCharacter.RenamePlayer_Implementation(FString&)", NewName); }

    bool AllowDinoTargetingRange(const UE::Math::TVector<double>* AtLoc, float TargetingRange) { return NativeCall<bool, const UE::Math::TVector<double>*, float>(this, "AShooterCharacter.AllowDinoTargetingRange(UE::Math::TVector<double>&,float)", AtLoc, TargetingRange); }

    bool IsCarriedAsPassenger() { return NativeCall<bool>(this, "AShooterCharacter.IsCarriedAsPassenger()"); }

    void ClientInviteToAlliance_Implementation(int RequestingTeam, unsigned int AllianceID, const FString* AllianceName, const FString* InviteeName) { NativeCall<void, int, unsigned int, const FString*, const FString*>(this, "AShooterCharacter.ClientInviteToAlliance_Implementation(int,unsignedint,FString&,FString&)", RequestingTeam, AllianceID, AllianceName, InviteeName); }

    void InviteToAlliance(int RequestingTeam, unsigned int AllianceID, FString* AllianceName, FString* InviterName) { NativeCall<void, int, unsigned int, FString*, FString*>(this, "AShooterCharacter.InviteToAlliance(int,unsignedint,FString,FString)", RequestingTeam, AllianceID, AllianceName, InviterName); }

    bool CanDragCharacter(APrimalCharacter* Character, bool bIgnoreWeight) { return NativeCall<bool, APrimalCharacter*, bool>(this, "AShooterCharacter.CanDragCharacter(APrimalCharacter*,bool)", Character, bIgnoreWeight); }

    bool HasEnoughWeightToDragCharacter(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "AShooterCharacter.HasEnoughWeightToDragCharacter(APrimalCharacter*)", Character); }

    void GiveDefaultWeaponTimer() { NativeCall<void>(this, "AShooterCharacter.GiveDefaultWeaponTimer()"); }

    bool IsCarryingSomething(bool bNotForRunning) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsCarryingSomething(bool)", bNotForRunning); }

    void ForceGiveDefaultWeapon() { NativeCall<void>(this, "AShooterCharacter.ForceGiveDefaultWeapon()"); }

    APrimalDinoCharacter* GetBasedOnDino(bool bUseReplicatedData, bool bOnlyConsciousDino) { return NativeCall<APrimalDinoCharacter*, bool, bool>(this, "AShooterCharacter.GetBasedOnDino(bool,bool)", bUseReplicatedData, bOnlyConsciousDino); }

    bool AllowParallelAnimations(USkeletalMeshComponent* forComp) { return NativeCall<bool, USkeletalMeshComponent*>(this, "AShooterCharacter.AllowParallelAnimations(USkeletalMeshComponent*)", forComp); }

    void ServerStartSurfaceCameraForPassenger_Implementation(float yaw, float roll, float pitch, bool bShouldInvertInput) { NativeCall<void, float, float, float, bool>(this, "AShooterCharacter.ServerStartSurfaceCameraForPassenger_Implementation(float,float,float,bool)", yaw, roll, pitch, bShouldInvertInput); }

    float ModifyAirControl(float AirControlIn) { return NativeCall<float, float>(this, "AShooterCharacter.ModifyAirControl(float)", AirControlIn); }

    float GetPercentageOfHeadHairGrowth() { return NativeCall<float>(this, "AShooterCharacter.GetPercentageOfHeadHairGrowth()"); }

    float GetPercentageOfFacialHairGrowth() { return NativeCall<float>(this, "AShooterCharacter.GetPercentageOfFacialHairGrowth()"); }

    void NetSetHeadHairPercent_Implementation(float thePercent, int newHeadHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetHeadHairPercent_Implementation(float,int)", thePercent, newHeadHairIndex); }

    void NetSetFacialHairPercent_Implementation(float thePercent, int newFacialHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetFacialHairPercent_Implementation(float,int)", thePercent, newFacialHairIndex); }

    void NetSetEyebrowStyle_Implementation(int newEyebrowIndex) { NativeCall<void, int>(this, "AShooterCharacter.NetSetEyebrowStyle_Implementation(int)", newEyebrowIndex); }

    void UpdateHair() { NativeCall<void>(this, "AShooterCharacter.UpdateHair()"); }

    //void SetHairOnComponent(USkeletalMeshComponent* HairComponent, USkeletalMeshComponent* LeaderPoseComponent, TSoftObjectPtr<USkeletalMesh>* HairMesh, TSubclassOf<UAnimInstance> AnimBlueprint, TSoftObjectPtr<UMaterialInterface>* FemaleHairOverride) { NativeCall<void, USkeletalMeshComponent*, USkeletalMeshComponent*, TSoftObjectPtr<USkeletalMesh>*, TSubclassOf<UAnimInstance>, TSoftObjectPtr<UMaterialInterface>*>(this, "AShooterCharacter.SetHairOnComponent(USkeletalMeshComponent*,USkeletalMeshComponent*,TSoftObjectPtr<USkeletalMesh>,TSubclassOf<UAnimInstance>,TSoftObjectPtr<UMaterialInterface>)", HairComponent, LeaderPoseComponent, HairMesh, AnimBlueprint, FemaleHairOverride); }

    void NetSetOverrideHeadHairColor_Implementation(unsigned __int8 HairColor, int ToIndex) { NativeCall<void, unsigned __int8, int>(this, "AShooterCharacter.NetSetOverrideHeadHairColor_Implementation(unsignedchar,int)", HairColor, ToIndex); }

    void NetSetOverrideFacialHairColor_Implementation(unsigned __int8 HairColor, int ToIndex) { NativeCall<void, unsigned __int8, int>(this, "AShooterCharacter.NetSetOverrideFacialHairColor_Implementation(unsignedchar,int)", HairColor, ToIndex); }

    void Unstasis() { NativeCall<void>(this, "AShooterCharacter.Unstasis()"); }

    void RegisterActorTickFunctions(bool bRegister, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool>(this, "AShooterCharacter.RegisterActorTickFunctions(bool,bool)", bRegister, bSaveAndRestoreTickState); }

    void OnRep_HatHidden() { NativeCall<void>(this, "AShooterCharacter.OnRep_HatHidden()"); }

    static float ComputeHeadHairMorphTargetValue(bool bFemale, unsigned __int8 HairIndex, float PercentOfGrowth) { return NativeCall<float, bool, unsigned __int8, float>(nullptr, "AShooterCharacter.ComputeHeadHairMorphTargetValue(bool,unsignedchar,float)", bFemale, HairIndex, PercentOfGrowth); }

    static float ComputeFacialHairMorphTargetValue(bool bFemale, unsigned __int8 HairIndex, float PercentOfGrowth) { return NativeCall<float, bool, unsigned __int8, float>(nullptr, "AShooterCharacter.ComputeFacialHairMorphTargetValue(bool,unsignedchar,float)", bFemale, HairIndex, PercentOfGrowth); }

    void TempDampenInputAcceleration() { NativeCall<void>(this, "AShooterCharacter.TempDampenInputAcceleration()"); }

    bool Poop(bool bForcePoop) { return NativeCall<bool, bool>(this, "AShooterCharacter.Poop(bool)", bForcePoop); }

    AActor* StructurePlacementUseAlternateOriginActor() { return NativeCall<AActor*>(this, "AShooterCharacter.StructurePlacementUseAlternateOriginActor()"); }

    USceneComponent* GetActorSoundAttachmentComponentOverride(USceneComponent* ForComponent) { return NativeCall<USceneComponent*, USceneComponent*>(this, "AShooterCharacter.GetActorSoundAttachmentComponentOverride(USceneComponent*)", ForComponent); }

    bool AllowGrappling_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.AllowGrappling_Implementation()"); }

    void TryCutEnemyGrapplingCable() { NativeCall<void>(this, "AShooterCharacter.TryCutEnemyGrapplingCable()"); }

    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "AShooterCharacter.FinalLoadedFromSaveGame()"); }

    AActor* GetSecondaryMountedActor() { return NativeCall<AActor*>(this, "AShooterCharacter.GetSecondaryMountedActor()"); }

    void FaceRotation(UE::Math::TRotator<double>* NewControlRotation, float DeltaTime) { NativeCall<void, UE::Math::TRotator<double>*, float>(this, "AShooterCharacter.FaceRotation(UE::Math::TRotator<double>,float)", NewControlRotation, DeltaTime); }

    bool IsGameInputAllowed() { return NativeCall<bool>(this, "AShooterCharacter.IsGameInputAllowed()"); }

    bool IsReadyToUpload(UWorld* theWorld) { return NativeCall<bool, UWorld*>(this, "AShooterCharacter.IsReadyToUpload(UWorld*)", theWorld); }

    void ServerClearSwitchingWeapon_Implementation(bool bOnlyIfDefaultWeapon, bool bClientRequestNextWeaponID) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ServerClearSwitchingWeapon_Implementation(bool,bool)", bOnlyIfDefaultWeapon, bClientRequestNextWeaponID); }

    void ClientReceiveNextWeaponID_Implementation(FItemNetID theItemID) { NativeCall<void, FItemNetID>(this, "AShooterCharacter.ClientReceiveNextWeaponID_Implementation(FItemNetID)", theItemID); }

    void DoCharacterDetachment(bool bIncludeRiding, bool bIncludeCarrying, APrimalBuff* BuffToIgnore) { NativeCall<void, bool, bool, APrimalBuff*>(this, "AShooterCharacter.DoCharacterDetachment(bool,bool,APrimalBuff*)", bIncludeRiding, bIncludeCarrying, BuffToIgnore); }

    bool IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "AShooterCharacter.IsCharacterHardAttached(bool,bool)", bIgnoreRiding, bIgnoreCarried); }

    bool IsGrapplingAttachedToMe() { return NativeCall<bool>(this, "AShooterCharacter.IsGrapplingAttachedToMe()"); }

    bool IsGrapplingHardAttached() { return NativeCall<bool>(this, "AShooterCharacter.IsGrapplingHardAttached()"); }

    bool TeleportTo(const UE::Math::TVector<double>* DestLocation, const UE::Math::TRotator<double>* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, const UE::Math::TVector<double>*, const UE::Math::TRotator<double>*, bool, bool>(this, "AShooterCharacter.TeleportTo(UE::Math::TVector<double>&,UE::Math::TRotator<double>&,bool,bool)", DestLocation, DestRotation, bIsATest, bNoCheck); }

    FString* GetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterCharacter.GetDebugInfoString()", result); }

    bool ForceCrosshair() { return NativeCall<bool>(this, "AShooterCharacter.ForceCrosshair()"); }

    AActor* GetUnstasisViewerSiblingActor() { return NativeCall<AActor*>(this, "AShooterCharacter.GetUnstasisViewerSiblingActor()"); }

    void UpdateAutoPlayer() { NativeCall<void>(this, "AShooterCharacter.UpdateAutoPlayer()"); }

    void UpdateAutoMove() { NativeCall<void>(this, "AShooterCharacter.UpdateAutoMove()"); }

    void UpdateAutoTurn() { NativeCall<void>(this, "AShooterCharacter.UpdateAutoTurn()"); }

    void UpdateAutoJump() { NativeCall<void>(this, "AShooterCharacter.UpdateAutoJump()"); }

    void UpdateAutoFire() { NativeCall<void>(this, "AShooterCharacter.UpdateAutoFire()"); }

    float PlayAnimMontage(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer, float BlendInTime, float BlendOutTime) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool, float, float>(this, "AShooterCharacter.PlayAnimMontage(UAnimMontage*,float,FName,bool,bool,float,float)", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, BlendInTime, BlendOutTime); }

    bool GetAllAttachedCharsInternal(TSet<APrimalCharacter*, DefaultKeyFuncs<APrimalCharacter*, 0>, FDefaultSetAllocator>* AttachedChars, const APrimalCharacter* OriginalChar, bool* bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TSet<APrimalCharacter*, DefaultKeyFuncs<APrimalCharacter*, 0>, FDefaultSetAllocator>*, const APrimalCharacter*, bool*, const bool, const bool>(this, "AShooterCharacter.GetAllAttachedCharsInternal(TSet<APrimalCharacter*,DefaultKeyFuncs<APrimalCharacter*,0>,FDefaultSetAllocator>&,APrimalCharacter*,bool,bool,bool)", AttachedChars, OriginalChar, bIncludeBased, bIncludePassengers, bIncludeCarried); }

    __int64 GiveHexagons(int NumHexagons, int TriggerIndex, float OverrideHexGainFalloffRate, int OverrideHexGainFalloffMin, float OverrideCollectSFXVolume, UE::Math::TVector<double>* OverrideVfxSpawnLoc, int OverrideHexagonVFXActorCount, bool VFXImmediatelyAttracts) { return NativeCall<__int64, int, int, float, int, float, UE::Math::TVector<double>*, int, bool>(this, "AShooterCharacter.GiveHexagons(int,int,float,int,float,UE::Math::TVector<double>,int,bool)", NumHexagons, TriggerIndex, OverrideHexGainFalloffRate, OverrideHexGainFalloffMin, OverrideCollectSFXVolume, OverrideVfxSpawnLoc, OverrideHexagonVFXActorCount, VFXImmediatelyAttracts); }

    bool SetPlayerHexagonCount(int NewHexagonCount) { return NativeCall<bool, int>(this, "AShooterCharacter.SetPlayerHexagonCount(int)", NewHexagonCount); }

    int GetPlayerHexagonCount() { return NativeCall<int>(this, "AShooterCharacter.GetPlayerHexagonCount()"); }

    void ServerRequestHexagonTrade_Implementation(int RequestedTradableItemIndex, int Quantity) { NativeCall<void, int, int>(this, "AShooterCharacter.ServerRequestHexagonTrade_Implementation(int,int)", RequestedTradableItemIndex, Quantity); }

    void PlayHatHiddenAnim() { NativeCall<void>(this, "AShooterCharacter.PlayHatHiddenAnim()"); }

    void UnlockHeadPosition() { NativeCall<void>(this, "AShooterCharacter.UnlockHeadPosition()"); }

    void ClientSetExpectedBase_Implementation(unsigned int BaseID) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ClientSetExpectedBase_Implementation(unsignedint)", BaseID); }

    void NotifyItemQuantityUpdated(UPrimalItem* anItem, int amount) { NativeCall<void, UPrimalItem*, int>(this, "AShooterCharacter.NotifyItemQuantityUpdated(UPrimalItem*,int)", anItem, amount); }

    void NotifyItemAdded(UPrimalItem* anItem, bool bEquipItem) { NativeCall<void, UPrimalItem*, bool>(this, "AShooterCharacter.NotifyItemAdded(UPrimalItem*,bool)", anItem, bEquipItem); }

    void NotifyItemRemoved(UPrimalItem* anItem) { NativeCall<void, UPrimalItem*>(this, "AShooterCharacter.NotifyItemRemoved(UPrimalItem*)", anItem); }

    UAudioComponent* PlayFootstep() { return NativeCall<UAudioComponent*>(this, "AShooterCharacter.PlayFootstep()"); }

    void DoInitialMeshingCheck() { NativeCall<void>(this, "AShooterCharacter.DoInitialMeshingCheck()"); }

    void RemoveProjectileFromCache(int ProjectileID) { NativeCall<void, int>(this, "AShooterCharacter.RemoveProjectileFromCache(int)", ProjectileID); }

    bool IsProjectileInCache(int ProjectileID) { return NativeCall<bool, int>(this, "AShooterCharacter.IsProjectileInCache(int)", ProjectileID); }

    void ServerNotifyProjectileImpact_Implementation(const FHitResult* HitResult, bool bFromReplication, int FromProjectileID) { NativeCall<void, const FHitResult*, bool, int>(this, "AShooterCharacter.ServerNotifyProjectileImpact_Implementation(FHitResult&,bool,int)", HitResult, bFromReplication, FromProjectileID); }

    void UpdateProjectileCache() { NativeCall<void>(this, "AShooterCharacter.UpdateProjectileCache()"); }

    float GetRiddenStasisRangeMultiplier() { return NativeCall<float>(this, "AShooterCharacter.GetRiddenStasisRangeMultiplier()"); }

    FString* GetUniqueNetIdAsString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterCharacter.GetUniqueNetIdAsString()", result); }

    bool BPCanImplantSuicide() { return NativeCall<bool>(this, "AShooterCharacter.BPCanImplantSuicide()"); }

    void SetImplantSuicideCooldownStartTime(long double StartTime) { NativeCall<void, long double>(this, "AShooterCharacter.SetImplantSuicideCooldownStartTime(double)", StartTime); }

    //void UpdateAllyRadarDatas_Implementation(const TArray<FAllyRadarDatas, TSizedDefaultAllocator<32> >* newDatas) { NativeCall<void, const TArray<FAllyRadarDatas, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.UpdateAllyRadarDatas_Implementation(TArray<FAllyRadarDatas,TSizedDefaultAllocator<32>>&)", newDatas); }

    bool ShouldASACameraSwitchToOld(bool bDontCheckForTargeting) { return NativeCall<bool, bool>(this, "AShooterCharacter.ShouldASACameraSwitchToOld(bool)", bDontCheckForTargeting); }

    bool ShouldUseSlowInterpToOldCamera() { return NativeCall<bool>(this, "AShooterCharacter.ShouldUseSlowInterpToOldCamera()"); }

    UAnimationAsset* GetDeathAnim_Implementation(float KillingDamage, const UE::Math::TVector<double>* ImpactVelocity, APawn* InstigatingPawn, AActor* DamageCauser) { return NativeCall<UAnimationAsset*, float, const UE::Math::TVector<double>*, APawn*, AActor*>(this, "AShooterCharacter.GetDeathAnim_Implementation(float,UE::Math::TVector<double>&,APawn*,AActor*)", KillingDamage, ImpactVelocity, InstigatingPawn, DamageCauser); }

    void OnDraggingStarted() { NativeCall<void>(this, "AShooterCharacter.OnDraggingStarted()"); }

    TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* GetShoulderDinoWheelEntries(TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >* result) { return NativeCall<TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*, TArray<FMultiUseEntry, TSizedDefaultAllocator<32> >*>(this, "AShooterCharacter.GetShoulderDinoWheelEntries()", result); }

    bool ShouldHideNonWeaponHUD() { return NativeCall<bool>(this, "AShooterCharacter.ShouldHideNonWeaponHUD()"); }

    void UpdateLocallyInterpolatedViewLocationX() { NativeCall<void>(this, "AShooterCharacter.UpdateLocallyInterpolatedViewLocationX()"); }

    void UpdateLocallyInterpolatedViewLocationY() { NativeCall<void>(this, "AShooterCharacter.UpdateLocallyInterpolatedViewLocationY()"); }

    void UpdateLocallyInterpolatedViewLocationZ() { NativeCall<void>(this, "AShooterCharacter.UpdateLocallyInterpolatedViewLocationZ()"); }

    void GetActorEyesViewPoint(UE::Math::TVector<double>* Location, UE::Math::TRotator<double>* Rotation) { NativeCall<void, UE::Math::TVector<double>*, UE::Math::TRotator<double>*>(this, "AShooterCharacter.GetActorEyesViewPoint(UE::Math::TVector<double>&,UE::Math::TRotator<double>&)", Location, Rotation); }

    bool ShouldSkipPhysicsUpdateOnAttachmentReplication() { return NativeCall<bool>(this, "AShooterCharacter.ShouldSkipPhysicsUpdateOnAttachmentReplication()"); }

    FName* GetAttackerDamageImpactFXAttachSocket(FName* result, UE::Math::TVector<double>* HitLoc) { return NativeCall<FName*, FName*, UE::Math::TVector<double>*>(this, "AShooterCharacter.GetAttackerDamageImpactFXAttachSocket(UE::Math::TVector<double>)", result, HitLoc); }

    int GetCurrentCameraModeIndex() { return NativeCall<int>(this, "AShooterCharacter.GetCurrentCameraModeIndex()"); }

    UTexture2D* GetPlatformIcon() { return NativeCall<UTexture2D*>(this, "AShooterCharacter.GetPlatformIcon()"); }

    float GetEquippedItemDurabilityPercent(FItemNetID itemID) { return NativeCall<float, FItemNetID>(this, "AShooterCharacter.GetEquippedItemDurabilityPercent(FItemNetID)", itemID); }

    void SetEquippedItemDurabilityPercent(FItemNetID itemID, float ItemDurabilityPercentage) { NativeCall<void, FItemNetID, float>(this, "AShooterCharacter.SetEquippedItemDurabilityPercent(FItemNetID,float)", itemID, ItemDurabilityPercentage); }

    void ReplicateDurabilityForEquippedItem(FItemNetID itemID) { NativeCall<void, FItemNetID>(this, "AShooterCharacter.ReplicateDurabilityForEquippedItem(FItemNetID)", itemID); }

    bool ShouldUseDurabilityVar(int VarIndex) { return NativeCall<bool, int>(this, "AShooterCharacter.ShouldUseDurabilityVar(int)", VarIndex); }

    bool ShouldUseDurabilityVarForItemType(TEnumAsByte<EPrimalEquipmentType::Type> TheItemType) { return NativeCall<bool, TEnumAsByte<EPrimalEquipmentType::Type>>(this, "AShooterCharacter.ShouldUseDurabilityVarForItemType(TEnumAsByte<EPrimalEquipmentType::Type>)", TheItemType); }

    void TickBeingDragged(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.TickBeingDragged(float)", DeltaSeconds); }

    void OnEndDragged(APrimalCharacter* Dragger) { NativeCall<void, APrimalCharacter*>(this, "AShooterCharacter.OnEndDragged(APrimalCharacter*)", Dragger); }

    void UnCrouch(bool bClientSimulation) { NativeCall<void, bool>(this, "AShooterCharacter.UnCrouch(bool)", bClientSimulation); }

    void UnProne(bool bClientSimulation) { NativeCall<void, bool>(this, "AShooterCharacter.UnProne(bool)", bClientSimulation); }

    UPrimalItem* GetShieldItem() { return NativeCall<UPrimalItem*>(this, "AShooterCharacter.GetShieldItem()"); }

};


struct UPrimalPlayerData : UObject

{

    FPrimalPlayerDataStruct* MyDataField() { return GetNativePointerField<FPrimalPlayerDataStruct*>(this, "UPrimalPlayerData.MyData"); }

};


struct APrimalDinoCharacter : APrimalCharacter

{

    // Fields


    UE::Math::TVector<double>& BaseDinoScaleField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.BaseDinoScale"); }

    TWeakObjectPtr<AActor>& ForcedMasterTargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoCharacter.ForcedMasterTarget"); }

    FName& MountCharacterSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.MountCharacterSocketName"); }

    TWeakObjectPtr<APrimalCharacter>& MountCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalDinoCharacter.MountCharacter"); }

    ECollisionChannel& MeshOriginalCollisionChannelField() { return *GetNativePointerField<ECollisionChannel*>(this, "APrimalDinoCharacter.MeshOriginalCollisionChannel"); }

    UE::Math::TVector<double>& RidingAttackExtraVelocityField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.RidingAttackExtraVelocity"); }

    UAnimMontage*& StartChargeAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.StartChargeAnimation"); }

    TArray<UAnimMontage*, TSizedDefaultAllocator<32> >& AttackAnimationsField() { return *GetNativePointerField<TArray<UAnimMontage*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.AttackAnimations"); }

    TArray<float, TSizedDefaultAllocator<32> >& AttackAnimationWeightsField() { return *GetNativePointerField<TArray<float, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.AttackAnimationWeights"); }

    TArray<float, TSizedDefaultAllocator<32> >& AttackAnimationsTimeFromEndToConsiderFinishedField() { return *GetNativePointerField<TArray<float, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.AttackAnimationsTimeFromEndToConsiderFinished"); }

    float& ColorizationIntensityField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ColorizationIntensity"); }

    TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >& FemaleMaterialOverridesField() { return *GetNativePointerField<TArray<UMaterialInterface*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.FemaleMaterialOverrides"); }

    float& PaintConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PaintConsumptionMultiplier"); }

    float& ChargingBlockedStopTimeThresholdField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingBlockedStopTimeThreshold"); }

    TArray<FName, TSizedDefaultAllocator<32> >& MeleeSwingSocketsField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.MeleeSwingSockets"); }

    int& MeleeDamageAmountField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MeleeDamageAmount"); }

    float& MeleeDamageImpulseField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MeleeDamageImpulse"); }

    float& MeleeSwingRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MeleeSwingRadius"); }

    TArray<FDinoAttackInfo, TSizedDefaultAllocator<32> >& AttackInfosField() { return *GetNativePointerField<TArray<FDinoAttackInfo, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.AttackInfos"); }

    unsigned __int8& LastAttackIndexField() { return *GetNativePointerField<unsigned __int8*>(this, "APrimalDinoCharacter.LastAttackIndex"); }

    TSubclassOf<UDamageType>& MeleeDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalDinoCharacter.MeleeDamageType"); }

    TSubclassOf<UDamageType>& StepActorDamageTypeOverrideField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalDinoCharacter.StepActorDamageTypeOverride"); }

    float& AttackOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackOffset"); }

    float& FleeHealthPercentageField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FleeHealthPercentage"); }

    float& BreakFleeHealthPercentageField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BreakFleeHealthPercentage"); }

    FString& TamerStringField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.TamerString"); }

    FString& TamedNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.TamedName"); }

    TArray<FHibernationZoneInfo, TSizedDefaultAllocator<32> >& HibernatedZoneVolumesField() { return *GetNativePointerField<TArray<FHibernationZoneInfo, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.HibernatedZoneVolumes"); }

    UE::Math::TVector2<double>& OverlayTooltipPaddingField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "APrimalDinoCharacter.OverlayTooltipPadding"); }

    UE::Math::TVector2<double>& OverlayTooltipScaleField() { return *GetNativePointerField<UE::Math::TVector2<double>*>(this, "APrimalDinoCharacter.OverlayTooltipScale"); }

    //TSubclassOf<UPrimalDinoToolTipWidget>& HUDOverlayToolTipWidgetField() { return *GetNativePointerField<TSubclassOf<UPrimalDinoToolTipWidget>*>(this, "APrimalDinoCharacter.HUDOverlayToolTipWidget"); }

    TSubclassOf<UPrimalDinoEntry>& MyDinoEntryField() { return *GetNativePointerField<TSubclassOf<UPrimalDinoEntry>*>(this, "APrimalDinoCharacter.MyDinoEntry"); }

    UE::Math::TVector<double>& RiderFPVCameraOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.RiderFPVCameraOffset"); }

    FTimerHandle& UpdateRidingFarShadowHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.UpdateRidingFarShadowHandle"); }

    UE::Math::TVector<double>& LandingLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.LandingLocation"); }

    long double& StartLandingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.StartLandingTime"); }

    long double& LastAxisStartPressTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastAxisStartPressTime"); }

    long double& LastMoveForwardTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastMoveForwardTime"); }

    float& FinalNPCLevelMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FinalNPCLevelMultiplier"); }

    float& LandingTraceMaxDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LandingTraceMaxDistance"); }

    float& FlyingWanderFixedDistanceAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyingWanderFixedDistanceAmount"); }

    float& FlyingWanderRandomDistanceAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyingWanderRandomDistanceAmount"); }

    float& AcceptableLandingRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AcceptableLandingRadius"); }

    float& MaxLandingTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MaxLandingTime"); }

    FieldArray<float, 2> GenderSpeedMultipliersField() { return { this, "APrimalDinoCharacter.GenderSpeedMultipliers" }; }

    float& ChargeSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargeSpeedMultiplier"); }

    UAnimMontage*& ChargingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.ChargingAnim"); }

    float& ChargingStaminaPerSecondDrainField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingStaminaPerSecondDrain"); }

    float& ChargingStopDotTresholdField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingStopDotTreshold"); }

    UE::Math::TVector<double>& LastChargeLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.LastChargeLocation"); }

    long double& LastStartChargingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastStartChargingTime"); }

    TWeakObjectPtr<AShooterCharacter>& RiderField() { return *GetNativePointerField<TWeakObjectPtr<AShooterCharacter>*>(this, "APrimalDinoCharacter.Rider"); }

    TWeakObjectPtr<AShooterCharacter>& PreviousRiderField() { return *GetNativePointerField<TWeakObjectPtr<AShooterCharacter>*>(this, "APrimalDinoCharacter.PreviousRider"); }

    TSubclassOf<UPrimalItem>& SaddleItemClassField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.SaddleItemClass"); }

    FString& SaddleSlotNameOverrideField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.SaddleSlotNameOverride"); }

    TArray<FSaddlePassengerSeatDefinition, TSizedDefaultAllocator<32> >& NoSaddlePassengerSeatsField() { return *GetNativePointerField<TArray<FSaddlePassengerSeatDefinition, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.NoSaddlePassengerSeats"); }

    TWeakObjectPtr<APrimalCharacter>& CarriedCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalDinoCharacter.CarriedCharacter"); }

    TWeakObjectPtr<APrimalCharacter>& PreviousCarriedCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalDinoCharacter.PreviousCarriedCharacter"); }

    UAnimMontage*& DinoWithPassengerAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.DinoWithPassengerAnim"); }

    UAnimMontage*& DinoWithDinoPassengerAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.DinoWithDinoPassengerAnim"); }

    TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >& PassengerPerSeatField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.PassengerPerSeat"); }

    TArray<APrimalCharacter*, TSizedDefaultAllocator<32> >& SavedPassengerPerSeatField() { return *GetNativePointerField<TArray<APrimalCharacter*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.SavedPassengerPerSeat"); }

    TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >& PrevPassengerPerSeatField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.PrevPassengerPerSeat"); }

    long double& LastClientCameraRotationServerUpdateField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastClientCameraRotationServerUpdate"); }

    TArray<USceneComponent*, TSizedDefaultAllocator<32> >& OverrideTargetComponentsField() { return *GetNativePointerField<TArray<USceneComponent*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.OverrideTargetComponents"); }

    float& WhistleTraceOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WhistleTraceOffset"); }

    TWeakObjectPtr<UPrimalAIState>& ActiveStateField() { return *GetNativePointerField<TWeakObjectPtr<UPrimalAIState>*>(this, "APrimalDinoCharacter.ActiveState"); }

    TWeakObjectPtr<UPrimalAIState>& ActiveWonderStateField() { return *GetNativePointerField<TWeakObjectPtr<UPrimalAIState>*>(this, "APrimalDinoCharacter.ActiveWonderState"); }

    int& LastPlayedAttackAnimationField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastPlayedAttackAnimation"); }

    TArray<FDinoBaseLevelWeightEntry, TSizedDefaultAllocator<32> >& DinoBaseLevelWeightEntriesField() { return *GetNativePointerField<TArray<FDinoBaseLevelWeightEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DinoBaseLevelWeightEntries"); }

    float& OriginalCapsuleHalfHeightField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OriginalCapsuleHalfHeight"); }

    TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >& LastSocketPositionsField() { return *GetNativePointerField<TArray<UE::Math::TVector<double>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.LastSocketPositions"); }

    TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>& MeleeSwingHurtListField() { return *GetNativePointerField<TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>*>(this, "APrimalDinoCharacter.MeleeSwingHurtList"); }

    long double& EndAttackTargetTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.EndAttackTargetTime"); }

    UE::Math::TVector<double>& RidingFirstPersonViewLocationOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.RidingFirstPersonViewLocationOffset"); }

    float& BabyChanceOfTwinsField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyChanceOfTwins"); }

    float& BabyGestationSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyGestationSpeed"); }

    float& ExtraBabyGestationSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraBabyGestationSpeedMultiplier"); }

    float& AutoFadeOutAfterTameTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AutoFadeOutAfterTameTime"); }

    float& BasedCameraSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BasedCameraSpeedMultiplier"); }

    long double& LastEggBoostedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastEggBoostedTime"); }

    float& WildPercentageChanceOfBabyField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildPercentageChanceOfBaby"); }

    float& WildBabyAgeWeightField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildBabyAgeWeight"); }

    float& BabyGestationProgressField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyGestationProgress"); }

    float& FlyerForceLimitPitchMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyerForceLimitPitchMin"); }

    float& FlyerForceLimitPitchMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyerForceLimitPitchMax"); }

    float& LastBabyAgeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LastBabyAge"); }

    float& LastBabyGestationProgressField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LastBabyGestationProgress"); }

    float& BabyChanceOfTripletsField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyChanceOfTriplets"); }

    float& BabyAgeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyAge"); }

    float& MaxPercentOfCapsulHeightAllowedForIKField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MaxPercentOfCapsulHeightAllowedForIK"); }

    float& SlopeBiasForMaxCapsulePercentField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SlopeBiasForMaxCapsulePercent"); }

    float& FlyingForceRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyingForceRotationRateModifier"); }

    TArray<FName, TSizedDefaultAllocator<32> >& HideBoneNamesField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.HideBoneNames"); }

    FString& HideBonesStringField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.HideBonesString"); }

    UE::Math::TVector<double>& WaterSurfaceExtraJumpVectorField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.WaterSurfaceExtraJumpVector"); }

    UE::Math::TVector<double>& FlyerTakeOffAdditionalVelocityField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.FlyerTakeOffAdditionalVelocity"); }

    float& OpenDoorDelayField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OpenDoorDelay"); }

    float& TamedWanderHarvestIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedWanderHarvestInterval"); }

    float& TamedWanderHarvestSearchRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedWanderHarvestSearchRange"); }

    float& TamedWanderHarvestCollectRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedWanderHarvestCollectRadius"); }

    UE::Math::TVector<double>& TamedWanderHarvestCollectOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.TamedWanderHarvestCollectOffset"); }

    float& RootLocSwimOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RootLocSwimOffset"); }

    float& PlayAnimBelowHealthPercentField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PlayAnimBelowHealthPercent"); }

    float& LeavePlayAnimBelowHealthPercentField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LeavePlayAnimBelowHealthPercent"); }

    float& PlatformSaddleMaxStructureBuildDistance2DField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PlatformSaddleMaxStructureBuildDistance2D"); }

    UAnimMontage*& PlayAnimBelowHealthField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.PlayAnimBelowHealth"); }

    USoundBase*& LowHealthExitSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalDinoCharacter.LowHealthExitSound"); }

    USoundBase*& LowHealthEnterSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalDinoCharacter.LowHealthEnterSound"); }

    TSubclassOf<UPrimalDinoSettings>& LowHealthDinoSettingsField() { return *GetNativePointerField<TSubclassOf<UPrimalDinoSettings>*>(this, "APrimalDinoCharacter.LowHealthDinoSettings"); }

    float& SwimOffsetInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SwimOffsetInterpSpeed"); }

    float& CurrentRootLocSwimOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CurrentRootLocSwimOffset"); }

    float& AIRangeMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AIRangeMultiplier"); }

    FieldArray<unsigned __int8, 6> PreventColorizationRegionsField() { return { this, "APrimalDinoCharacter.PreventColorizationRegions" }; }

    FieldArray<unsigned __int8, 6> AllowPaintingColorRegionsField() { return { this, "APrimalDinoCharacter.AllowPaintingColorRegions" }; }

    FieldArray<unsigned __int8, 6> ColorSetIndicesField() { return { this, "APrimalDinoCharacter.ColorSetIndices" }; }

    FieldArray<FName, 6> ColorSetNamesField() { return { this, "APrimalDinoCharacter.ColorSetNames" }; }

    FieldArray<float, 6> ColorSetIntensityMultipliersField() { return { this, "APrimalDinoCharacter.ColorSetIntensityMultipliers" }; }

    TWeakObjectPtr<APrimalBuff>& ColorOverrideBuffField() { return *GetNativePointerField<TWeakObjectPtr<APrimalBuff>*>(this, "APrimalDinoCharacter.ColorOverrideBuff"); }

    long double& ColorOverrideBuffDeactivateTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.ColorOverrideBuffDeactivateTime"); }

    float& ColorOverrideBuffInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ColorOverrideBuffInterpSpeed"); }

    float& MeleeAttackStaminaCostField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MeleeAttackStaminaCost"); }

    UAnimMontage*& WakingTameAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.WakingTameAnimation"); }

    TWeakObjectPtr<AActor>& TargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoCharacter.Target"); }

    TWeakObjectPtr<AActor>& TamedFollowTargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoCharacter.TamedFollowTarget"); }

    TWeakObjectPtr<AActor>& TamedLandTargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoCharacter.TamedLandTarget"); }

    float& PercentChanceFemaleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PercentChanceFemale"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& DeathGiveItemClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DeathGiveItemClasses"); }

    TArray<float, TSizedDefaultAllocator<32> >& DeathGiveItemChanceToBeBlueprintField() { return *GetNativePointerField<TArray<float, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DeathGiveItemChanceToBeBlueprint"); }

    float& DeathGiveItemQualityMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DeathGiveItemQualityMin"); }

    float& DeathGiveItemQualityMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DeathGiveItemQualityMax"); }

    float& DeathGiveItemRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DeathGiveItemRange"); }

    FString& DeathGiveAchievementField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.DeathGiveAchievement"); }

    USoundBase*& OverrideAreaMusicField() { return *GetNativePointerField<USoundBase**>(this, "APrimalDinoCharacter.OverrideAreaMusic"); }

    UE::Math::TVector<double>& UnboardLocationOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.UnboardLocationOffset"); }

    long double& LastTimeWhileHeadingToGoalField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTimeWhileHeadingToGoal"); }

    float& ForceUpdateIKTimerField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ForceUpdateIKTimer"); }

    long double& LastColorizationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastColorizationTime"); }

    FRootMotionMovementParams& PreMatineeUpdateRootMotionParamsField() { return *GetNativePointerField<FRootMotionMovementParams*>(this, "APrimalDinoCharacter.PreMatineeUpdateRootMotionParams"); }

    float& RidingNetUpdateFequencyField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RidingNetUpdateFequency"); }

    float& RiderMaxSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderMaxSpeedModifier"); }

    float& RiderExtraMaxSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderExtraMaxSpeedModifier"); }

    float& RiderMaxRunSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderMaxRunSpeedModifier"); }

    float& RiderRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderRotationRateModifier"); }

    float& SwimmingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SwimmingRotationRateModifier"); }

    float& chargingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.chargingRotationRateModifier"); }

    UAnimMontage*& EnterFlightAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.EnterFlightAnim"); }

    UAnimMontage*& ExitFlightAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.ExitFlightAnim"); }

    UAnimMontage*& SleepConsumeFoodAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.SleepConsumeFoodAnim"); }

    UAnimMontage*& WakingConsumeFoodAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.WakingConsumeFoodAnim"); }

    UAnimMontage*& FallAsleepAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.FallAsleepAnim"); }

    UAnimMontage*& TamedUnsleepAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.TamedUnsleepAnim"); }

    UAnimMontage*& WildUnsleepAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.WildUnsleepAnim"); }

    UAnimMontage*& OpenDoorAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.OpenDoorAnim"); }

    float& ControlFacePitchInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ControlFacePitchInterpSpeed"); }

    float& TamedWalkableFloorZField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedWalkableFloorZ"); }

    float& CurrentMovementAnimRateField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CurrentMovementAnimRate"); }

    int& MinPlayerLevelForWakingTameField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MinPlayerLevelForWakingTame"); }

    float& ForceNextAttackIndexField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ForceNextAttackIndex"); }

    TSubclassOf<UPrimalInventoryComponent>& TamedInventoryComponentTemplateField() { return *GetNativePointerField<TSubclassOf<UPrimalInventoryComponent>*>(this, "APrimalDinoCharacter.TamedInventoryComponentTemplate"); }

    FWeightedObjectList& DeathInventoryTemplatesField() { return *GetNativePointerField<FWeightedObjectList*>(this, "APrimalDinoCharacter.DeathInventoryTemplates"); }

    float& DeathInventoryChanceToUseField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DeathInventoryChanceToUse"); }

    float& WakingTameFeedIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameFeedInterval"); }

    long double& LastWakingTameFedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastWakingTameFedTime"); }

    float& DeathInventoryQualityPerLevelMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DeathInventoryQualityPerLevelMultiplier"); }

    float& RequiredTameAffinityField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RequiredTameAffinity"); }

    float& RequiredTameAffinityPerBaseLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RequiredTameAffinityPerBaseLevel"); }

    FName& PassengerBoneNameOverrideField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.PassengerBoneNameOverride"); }

    float& CurrentTameAffinityField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CurrentTameAffinity"); }

    float& TameIneffectivenessModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TameIneffectivenessModifier"); }

    float& TameIneffectivenessByAffinityField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TameIneffectivenessByAffinity"); }

    int& LastFrameUseLowQualityAnimationTickField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastFrameUseLowQualityAnimationTick"); }

    FTimerHandle& ServerSleepingTickHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.ServerSleepingTickHandle"); }

    FTimerHandle& ServerTamedTickHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.ServerTamedTickHandle"); }

    TArray<FPrimalSaddleStructure, TSizedDefaultAllocator<32> >& SaddleStructuresField() { return *GetNativePointerField<TArray<FPrimalSaddleStructure, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.SaddleStructures"); }

    int& MaxSaddleStructuresHeightField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxSaddleStructuresHeight"); }

    bool& CalculateStructureDistanceFromSaddleField() { return *GetNativePointerField<bool*>(this, "APrimalDinoCharacter.CalculateStructureDistanceFromSaddle"); }

    int& SaddlePivotOffsetField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.SaddlePivotOffset"); }

    int& MaxSaddleStructuresNumField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxSaddleStructuresNum"); }

    TSubclassOf<UPrimalDinoSettings>& DinoSettingsClassField() { return *GetNativePointerField<TSubclassOf<UPrimalDinoSettings>*>(this, "APrimalDinoCharacter.DinoSettingsClass"); }

    float& TamingFoodConsumeIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamingFoodConsumeInterval"); }

    float& DediForceAttackAnimTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DediForceAttackAnimTime"); }

    float& DediForceStartAttackAfterAnimTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DediForceStartAttackAfterAnimTime"); }

    float& WakingTameFoodIncreaseMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameFoodIncreaseMultiplier"); }

    int& TamingTeamIDField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.TamingTeamID"); }

    int& OwningPlayerIDField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.OwningPlayerID"); }

    FString& OwningPlayerNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.OwningPlayerName"); }

    long double& TamingLastFoodConsumptionTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.TamingLastFoodConsumptionTime"); }

    long double& LastTameConsumedFoodTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTameConsumedFoodTime"); }

    unsigned int& DinoID1Field() { return *GetNativePointerField<unsigned int*>(this, "APrimalDinoCharacter.DinoID1"); }

    unsigned int& DinoID2Field() { return *GetNativePointerField<unsigned int*>(this, "APrimalDinoCharacter.DinoID2"); }

    UE::Math::TRotator<double>& PreviousAimRotField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalDinoCharacter.PreviousAimRot"); }

    int& TamedAggressionLevelField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.TamedAggressionLevel"); }

    float& TamingIneffectivenessModifierIncreaseByDamagePercentField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamingIneffectivenessModifierIncreaseByDamagePercent"); }

    int& NPCSpawnerExtraLevelOffsetField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.NPCSpawnerExtraLevelOffset"); }

    float& NPCSpawnerLevelMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NPCSpawnerLevelMultiplier"); }

    TWeakObjectPtr<APrimalStructureItemContainer_SupplyCrate>& LinkedSupplyCrateField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructureItemContainer_SupplyCrate>*>(this, "APrimalDinoCharacter.LinkedSupplyCrate"); }

    float& UntamedPoopTimeMinIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.UntamedPoopTimeMinInterval"); }

    float& UntamedPoopTimeMaxIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.UntamedPoopTimeMaxInterval"); }

    float& MeleeHarvestDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MeleeHarvestDamageMultiplier"); }

    float& AllowRidingMaxDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AllowRidingMaxDistance"); }

    float& UntamedPoopTimeCacheField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.UntamedPoopTimeCache"); }

    TSubclassOf<UPrimalItem>& BaseEggClassField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.BaseEggClass"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& EggItemsToSpawnField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.EggItemsToSpawn"); }

    TArray<float, TSizedDefaultAllocator<32> >& EggWeightsToSpawnField() { return *GetNativePointerField<TArray<float, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.EggWeightsToSpawn"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& FertilizedEggItemsToSpawnField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.FertilizedEggItemsToSpawn"); }

    TArray<float, TSizedDefaultAllocator<32> >& FertilizedEggWeightsToSpawnField() { return *GetNativePointerField<TArray<float, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.FertilizedEggWeightsToSpawn"); }

    float& EggChanceToSpawnUnstasisField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.EggChanceToSpawnUnstasis"); }

    float& EggIntervalBetweenUnstasisChancesField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.EggIntervalBetweenUnstasisChances"); }

    float& EggRangeMaximumNumberFromSameDinoTypeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.EggRangeMaximumNumberFromSameDinoType"); }

    int& EggMaximumNumberFromSameDinoTypeField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.EggMaximumNumberFromSameDinoType"); }

    float& EggRangeMaximumNumberField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.EggRangeMaximumNumber"); }

    int& EggMaximumNumberField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.EggMaximumNumber"); }

    FName& EggSpawnSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.EggSpawnSocketName"); }

    UAnimMontage*& EggLayingAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.EggLayingAnimation"); }

    float& UntamedWalkingSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.UntamedWalkingSpeedModifier"); }

    float& TamedWalkingSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedWalkingSpeedModifier"); }

    float& UntamedRunningSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.UntamedRunningSpeedModifier"); }

    float& TamedRunningSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedRunningSpeedModifier"); }

    TSubclassOf<UPrimalColorSet>& RandomColorSetsMaleField() { return *GetNativePointerField<TSubclassOf<UPrimalColorSet>*>(this, "APrimalDinoCharacter.RandomColorSetsMale"); }

    TSubclassOf<UPrimalColorSet>& RandomColorSetsFemaleField() { return *GetNativePointerField<TSubclassOf<UPrimalColorSet>*>(this, "APrimalDinoCharacter.RandomColorSetsFemale"); }

    TSubclassOf<UPrimalColorSet>& SpawnerColorSetsField() { return *GetNativePointerField<TSubclassOf<UPrimalColorSet>*>(this, "APrimalDinoCharacter.SpawnerColorSets"); }

    UAnimSequence*& RiderAnimOverrideField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalDinoCharacter.RiderAnimOverride"); }

    UAnimSequence*& TurningRightRiderAnimOverrideField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalDinoCharacter.TurningRightRiderAnimOverride"); }

    UAnimSequence*& TurningLeftRiderAnimOverrideField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalDinoCharacter.TurningLeftRiderAnimOverride"); }

    UAnimSequence*& LatchedRiderAnimOverrideField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalDinoCharacter.LatchedRiderAnimOverride"); }

    UAnimSequence*& RiderMoveAnimOverrideField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalDinoCharacter.RiderMoveAnimOverride"); }

    float& RidingAnimSpeedFactorField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RidingAnimSpeedFactor"); }

    UAnimMontage*& StartRidingAnimOverrideField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.StartRidingAnimOverride"); }

    UAnimMontage*& StopRidingAnimOverrideField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.StopRidingAnimOverride"); }

    FName& TargetingTeamNameOverrideField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.TargetingTeamNameOverride"); }

    float& ExtraTamedSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraTamedSpeedMultiplier"); }

    float& ExtraUnTamedSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraUnTamedSpeedMultiplier"); }

    long double& LastEggSpawnChanceTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastEggSpawnChanceTime"); }

    FName& OriginalNPCVolumeNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.OriginalNPCVolumeName"); }

    float& OutsideOriginalNPCVolumeStasisDestroyIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OutsideOriginalNPCVolumeStasisDestroyInterval"); }

    float& StasisedDestroyIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StasisedDestroyInterval"); }

    float& TamedAllowNamingTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedAllowNamingTime"); }

    float& MovementSpeedScalingRotationRatePowerField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MovementSpeedScalingRotationRatePower"); }

    float& AttackNoStaminaTorpidityMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackNoStaminaTorpidityMultiplier"); }

    float& DecayDestructionPeriodField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DecayDestructionPeriod"); }

    long double& TamedAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.TamedAtTime"); }

    long double& LastInAllyRangeTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastInAllyRangeTime"); }

    TArray<ANPCZoneVolume*, TSizedDefaultAllocator<32> >& CurrentNPCVolumesField() { return *GetNativePointerField<TArray<ANPCZoneVolume*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.CurrentNPCVolumes"); }

    TArray<APrimalStructure*, TSizedDefaultAllocator<32> >& LatchedOnStructuresField() { return *GetNativePointerField<TArray<APrimalStructure*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.LatchedOnStructures"); }

    UPrimalDinoSettings*& MyDinoSettingsCDOField() { return *GetNativePointerField<UPrimalDinoSettings**>(this, "APrimalDinoCharacter.MyDinoSettingsCDO"); }

    int& OriginalTargetingTeamField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.OriginalTargetingTeam"); }

    float& LocInterpolationSnapDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LocInterpolationSnapDistance"); }

    float& PreviousRootYawSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PreviousRootYawSpeed"); }

    long double& LastTimeFallingField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTimeFalling"); }

    float& HUDScaleMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HUDScaleMultiplier"); }

    float& HUDTextScaleMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HUDTextScaleMultiplier"); }

    float& TamedCorpseLifespanField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedCorpseLifespan"); }

    float& MateBoostDamageReceiveMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MateBoostDamageReceiveMultiplier"); }

    float& MateBoostDamageGiveMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MateBoostDamageGiveMultiplier"); }

    float& MateBoostRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MateBoostRange"); }

    FName& DinoNameTagField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.DinoNameTag"); }

    AShooterPlayerController*& AttackMyTargetForPlayerControllerField() { return *GetNativePointerField<AShooterPlayerController**>(this, "APrimalDinoCharacter.AttackMyTargetForPlayerController"); }

    float& RidingAttackExtraVelocityDelayField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RidingAttackExtraVelocityDelay"); }

    float& StepDamageRadialDamageIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageRadialDamageInterval"); }

    float& StepDamageRadialDamageExtraRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageRadialDamageExtraRadius"); }

    float& StepDamageRadialDamageAmountGeneralField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageRadialDamageAmountGeneral"); }

    float& StepDamageRadialDamageAmountHarvestableField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageRadialDamageAmountHarvestable"); }

    long double& LastRadialStepDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastRadialStepDamageTime"); }

    TSubclassOf<UDamageType>& StepHarvestableDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalDinoCharacter.StepHarvestableDamageType"); }

    float& StepDamageFootDamageIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageFootDamageInterval"); }

    float& StepDamageFootDamageRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageFootDamageRadius"); }

    float& StepDamageFootDamageAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageFootDamageAmount"); }

    TArray<FName, TSizedDefaultAllocator<32> >& StepDamageFootDamageSocketsField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.StepDamageFootDamageSockets"); }

    float& DurationBeforeMovingStuckPawnField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DurationBeforeMovingStuckPawn"); }

    UE::Math::TVector<double>& LastCheckedLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.LastCheckedLocation"); }

    long double& LastValidNotStuckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastValidNotStuckTime"); }

    UAnimMontage*& StartledAnimationRightDefaultField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.StartledAnimationRightDefault"); }

    UAnimMontage*& StartledAnimationLeftField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.StartledAnimationLeft"); }

    TArray<UAnimMontage*, TSizedDefaultAllocator<32> >& StartledAnimationsField() { return *GetNativePointerField<TArray<UAnimMontage*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.StartledAnimations"); }

    UAnimMontage*& FlyingStartledAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.FlyingStartledAnimation"); }

    float& RandomPlayStartledAnimIntervalMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RandomPlayStartledAnimIntervalMin"); }

    float& RandomPlayStartledAnimIntervalMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RandomPlayStartledAnimIntervalMax"); }

    float& StartledAnimationCooldownField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StartledAnimationCooldown"); }

    float& DefaultActivateAttackRangeOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DefaultActivateAttackRangeOffset"); }

    float& CorpseTargetingMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CorpseTargetingMultiplier"); }

    long double& LastFootStepDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastFootStepDamageTime"); }

    long double& LastStartledTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastStartledTime"); }

    float& AccumulatedStatusUpdateTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AccumulatedStatusUpdateTime"); }

    float& CorpseLifespanNonRelevantField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CorpseLifespanNonRelevant"); }

    ANPCZoneManager*& DirectLinkNPCZoneManagerField() { return *GetNativePointerField<ANPCZoneManager**>(this, "APrimalDinoCharacter.DirectLinkNPCZoneManager"); }

    FTimerHandle& ForceClearRiderHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.ForceClearRiderHandle"); }

    float& MinStaminaForRiderField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MinStaminaForRider"); }

    float& LoseStaminaWithRiderRateField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LoseStaminaWithRiderRate"); }

    float& FollowingRunDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FollowingRunDistance"); }

    float& MaxDinoKillerTransferWeightPercentField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MaxDinoKillerTransferWeightPercent"); }

    float& NPCZoneVolumeCountWeightField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NPCZoneVolumeCountWeight"); }

    float& NPCLerpToMaxRandomBaseLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NPCLerpToMaxRandomBaseLevel"); }

    UE::Math::TVector<double>& FloatingHUDTextWorldOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.FloatingHUDTextWorldOffset"); }

    long double& LastAttackedTargetTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastAttackedTargetTime"); }

    long double& LastForcedLandingCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastForcedLandingCheckTime"); }

    long double& LastAllyTargetLookTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastAllyTargetLookTime"); }

    long double& LastAttackedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastAttackedTime"); }

    long double& LastPlayerDinoOverlapRelevantTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastPlayerDinoOverlapRelevantTime"); }

    UE::Math::TRotator<double>& DinoAimRotationOffsetField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalDinoCharacter.DinoAimRotationOffset"); }

    long double& LastDinoAllyLookInterpTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastDinoAllyLookInterpTime"); }

    UE::Math::TVector<double>& LastRiderOverlappedPositionField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.LastRiderOverlappedPosition"); }

    TWeakObjectPtr<APrimalCharacter>& AutoDragByPawnField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalDinoCharacter.AutoDragByPawn"); }

    long double& NextRidingFlyerUndergroundCheckField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.NextRidingFlyerUndergroundCheck"); }

    long double& LastSetRiderTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastSetRiderTime"); }

    TSubclassOf<UPrimalItem>& RepairRequirementsItemField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.RepairRequirementsItem"); }

    float& RepairAmountRemainingField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RepairAmountRemaining"); }

    float& RepairCheckIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RepairCheckInterval"); }

    float& RepairPercentPerIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RepairPercentPerInterval"); }

    FTimerHandle& RepairCheckTimerHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.RepairCheckTimerHandle"); }

    UE::Math::TVector<double>& RiderCheckTraceOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.RiderCheckTraceOffset"); }

    UE::Math::TVector<double>& RiderEjectionImpulseField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.RiderEjectionImpulse"); }

    float& WakingTameAffinityDecreaseFoodPercentageField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameAffinityDecreaseFoodPercentage"); }

    float& WakingTameAllowFeedingFoodPercentageField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameAllowFeedingFoodPercentage"); }

    float& WakingTameFoodAffinityMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameFoodAffinityMultiplier"); }

    float& CheckForWildAmbientHarvestingIntervalMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CheckForWildAmbientHarvestingIntervalMin"); }

    float& CheckForWildAmbientHarvestingIntervalMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CheckForWildAmbientHarvestingIntervalMax"); }

    float& WildAmbientHarvestingTimerField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildAmbientHarvestingTimer"); }

    UAnimMontage*& WildAmbientHarvestingAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.WildAmbientHarvestingAnimation"); }

    TArray<UAnimMontage*, TSizedDefaultAllocator<32> >& WildAmbientHarvestingAnimationsField() { return *GetNativePointerField<TArray<UAnimMontage*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.WildAmbientHarvestingAnimations"); }

    TArray<TSubclassOf<UPrimalHarvestingComponent>, TSizedDefaultAllocator<32> >& WildAmbientHarvestingComponentClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalHarvestingComponent>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.WildAmbientHarvestingComponentClasses"); }

    float& WildAmbientHarvestingRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildAmbientHarvestingRadius"); }

    int& FlyerNumUnderGroundFailField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.FlyerNumUnderGroundFail"); }

    int& AbsoluteBaseLevelField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.AbsoluteBaseLevel"); }

    TArray<FStatValuePair, TSizedDefaultAllocator<32> >& OverrideBaseStatLevelsOnSpawnField() { return *GetNativePointerField<TArray<FStatValuePair, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.OverrideBaseStatLevelsOnSpawn"); }

    TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>, TSizedDefaultAllocator<32> >& OverrideStatPriorityOnSpawnField() { return *GetNativePointerField<TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.OverrideStatPriorityOnSpawn"); }

    TSubclassOf<UDamageType>& TamedHarvestDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalDinoCharacter.TamedHarvestDamageType"); }

    FDinoSaddleStruct& SaddleStructField() { return *GetNativePointerField<FDinoSaddleStruct*>(this, "APrimalDinoCharacter.SaddleStruct"); }

    TArray<APrimalCharacter*, TSizedDefaultAllocator<32> >& DraggedRagdollsField() { return *GetNativePointerField<TArray<APrimalCharacter*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DraggedRagdolls"); }

    UE::Math::TVector<double>& LastOverrodeRandomWanderLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.LastOverrodeRandomWanderLocation"); }

    //TSubclassOf<UMatineeCameraShake>& StartChargingShakeField() { return *GetNativePointerField<TSubclassOf<UMatineeCameraShake>*>(this, "APrimalDinoCharacter.StartChargingShake"); }

    //TSubclassOf<UMatineeCameraShake>& LightEndChargingShakeField() { return *GetNativePointerField<TSubclassOf<UMatineeCameraShake>*>(this, "APrimalDinoCharacter.LightEndChargingShake"); }

    //TSubclassOf<UMatineeCameraShake>& HardEndChargingShakeField() { return *GetNativePointerField<TSubclassOf<UMatineeCameraShake>*>(this, "APrimalDinoCharacter.HardEndChargingShake"); }

    float& ChargeBumpDamageField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargeBumpDamage"); }

    TSubclassOf<UDamageType>& ChargeBumpDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalDinoCharacter.ChargeBumpDamageType"); }

    float& ChargeBumpImpulseField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargeBumpImpulse"); }

    float& MinChargeIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MinChargeInterval"); }

    float& PlayerMountedLaunchFowardSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PlayerMountedLaunchFowardSpeed"); }

    float& PlayerMountedLaunchUpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PlayerMountedLaunchUpSpeed"); }

    float& AttackOnLaunchMaximumTargetDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackOnLaunchMaximumTargetDistance"); }

    float& KeepFlightRemainingTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.KeepFlightRemainingTime"); }

    UAnimMontage*& MountCharacterAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.MountCharacterAnimation"); }

    UAnimMontage*& UnmountCharacterAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.UnmountCharacterAnimation"); }

    UAnimMontage*& EndChargingAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.EndChargingAnimation"); }

    float& FlyingRunSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyingRunSpeedModifier"); }

    float& ChargingAnimDelayField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingAnimDelay"); }

    FName& RiderSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.RiderSocketName"); }

    float& ChargingActivationRequiresStaminaField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingActivationRequiresStamina"); }

    float& ChargingActivationConsumesStaminaField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingActivationConsumesStamina"); }

    float& FlyerHardBreakingOverrideField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyerHardBreakingOverride"); }

    float& BabyScaleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyScale"); }

    float& BabySpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabySpeedMultiplier"); }

    float& BabyPitchMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyPitchMultiplier"); }

    float& BabyVolumeMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyVolumeMultiplier"); }

    TWeakObjectPtr<AActor>& WanderAroundActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoCharacter.WanderAroundActor"); }

    float& WanderAroundActorMaxDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WanderAroundActorMaxDistance"); }

    long double& ChargingStartBlockedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.ChargingStartBlockedTime"); }

    long double& LastChargeEndTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastChargeEndTime"); }

    TArray<APrimalStructure*, TSizedDefaultAllocator<32> >& SaddledStructuresField() { return *GetNativePointerField<TArray<APrimalStructure*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.SaddledStructures"); }

    TSoftClassPtr<APrimalBuff>& BuffGivenToBasedCharactersField() { return *GetNativePointerField<TSoftClassPtr<APrimalBuff>*>(this, "APrimalDinoCharacter.BuffGivenToBasedCharacters"); }

    long double& LastTamedFlyerNearbyAllyCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTamedFlyerNearbyAllyCheckTime"); }

    long double& LastUpdatedBabyAgeAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastUpdatedBabyAgeAtTime"); }

    long double& LastUpdatedGestationAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastUpdatedGestationAtTime"); }

    long double& LastUpdatedMatingAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastUpdatedMatingAtTime"); }

    float& BabyAgeSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyAgeSpeed"); }

    float& ExtraBabyAgeSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraBabyAgeSpeedMultiplier"); }

    float& FemaleMatingRangeAdditionField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FemaleMatingRangeAddition"); }

    float& FemaleMatingTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FemaleMatingTime"); }

    long double& NextAllowedMatingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.NextAllowedMatingTime"); }

    float& MatingProgressField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MatingProgress"); }

    long double& LastMatingNotificationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastMatingNotificationTime"); }

    APrimalDinoCharacter*& MatingWithDinoField() { return *GetNativePointerField<APrimalDinoCharacter**>(this, "APrimalDinoCharacter.MatingWithDino"); }

    UAnimMontage*& MatingAnimationMaleField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.MatingAnimationMale"); }

    FieldArray<unsigned __int8, 12> GestationEggNumberOfLevelUpPointsAppliedField() { return { this, "APrimalDinoCharacter.GestationEggNumberOfLevelUpPointsApplied" }; }

    FieldArray<unsigned __int8, 12> GestationEggNumberOfMutationsAppliedField() { return { this, "APrimalDinoCharacter.GestationEggNumberOfMutationsApplied" }; }

    float& GestationEggTamedIneffectivenessModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GestationEggTamedIneffectivenessModifier"); }

    FieldArray<unsigned __int8, 6> GestationEggColorSetIndicesField() { return { this, "APrimalDinoCharacter.GestationEggColorSetIndices" }; }

    float& NewFemaleMinTimeBetweenMatingField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NewFemaleMinTimeBetweenMating"); }

    float& NewFemaleMaxTimeBetweenMatingField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NewFemaleMaxTimeBetweenMating"); }

    TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >& DefaultTamedBuffsField() { return *GetNativePointerField<TArray<TSoftClassPtr<APrimalBuff>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DefaultTamedBuffs"); }

    UE::Math::TVector<double>& InterpolatedVelocityField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.InterpolatedVelocity"); }

    UE::Math::TVector<double>& OldInterpolatedLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.OldInterpolatedLocation"); }

    float& HyperThermiaInsulationField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HyperThermiaInsulation"); }

    float& HypoThermiaInsulationField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HypoThermiaInsulation"); }

    float& InsulationRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.InsulationRange"); }

    float& GangOverlapRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GangOverlapRange"); }

    float& GangDamageResistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GangDamageResistance"); }

    float& GangDamageField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GangDamage"); }

    int& MaxGangCountField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxGangCount"); }

    int& GangCountField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.GangCount"); }

    long double& LastGangCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastGangCheckTime"); }

    UE::Math::TVector<double>& LastGangCheckPositionField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.LastGangCheckPosition"); }

    int& PreviousTargetingTeamField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.PreviousTargetingTeam"); }

    int& LastRiderExitFrameCounterField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastRiderExitFrameCounter"); }

    float& WildRandomScaleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildRandomScale"); }

    float& HeldJumpSlowFallingGravityZScaleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HeldJumpSlowFallingGravityZScale"); }

    UAnimMontage*& SlowFallingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.SlowFallingAnim"); }

    float& SlowFallingStaminaCostPerSecondField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SlowFallingStaminaCostPerSecond"); }

    float& NoRiderRotationModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NoRiderRotationModifier"); }

    FName& RiderFPVCameraUseSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.RiderFPVCameraUseSocketName"); }

    FName& RiderLatchedFPVCameraUseSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.RiderLatchedFPVCameraUseSocketName"); }

    FName& PassengerFPVCameraRootSocketField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.PassengerFPVCameraRootSocket"); }

    TArray<FName, TSizedDefaultAllocator<32> >& FPVRiderBoneNamesToHideField() { return *GetNativePointerField<TArray<FName, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.FPVRiderBoneNamesToHide"); }

    float& ExtraRunningSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraRunningSpeedModifier"); }

    float& ScaleExtraRunningSpeedModifierMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ScaleExtraRunningSpeedModifierMin"); }

    float& ScaleExtraRunningSpeedModifierMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ScaleExtraRunningSpeedModifierMax"); }

    float& ScaleExtraRunningSpeedModifierSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ScaleExtraRunningSpeedModifierSpeed"); }

    float& LastHigherScaleExtraRunningSpeedValueField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LastHigherScaleExtraRunningSpeedValue"); }

    long double& LastHigherScaleExtraRunningSpeedTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastHigherScaleExtraRunningSpeedTime"); }

    float& RiderMovementSpeedScalingRotationRatePowerMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderMovementSpeedScalingRotationRatePowerMultiplier"); }

    float& HighQualityLedgeDetectionExtraTraceDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HighQualityLedgeDetectionExtraTraceDistance"); }

    float& ForwardPlatformSaddleStructureDamageToDinoMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ForwardPlatformSaddleStructureDamageToDinoMultiplier"); }

    FName& ForwardPlatformSaddleStructurePointDamageToBoneField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.ForwardPlatformSaddleStructurePointDamageToBone"); }

    int& LoadDestroyWildDinosUnderVersionField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LoadDestroyWildDinosUnderVersion"); }

    int& SaveDestroyWildDinosUnderVersionField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.SaveDestroyWildDinosUnderVersion"); }

    float& AllowWaterSurfaceExtraJumpStaminaCostField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AllowWaterSurfaceExtraJumpStaminaCost"); }

    USoundBase*& PlayKillLocalSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalDinoCharacter.PlayKillLocalSound"); }

    TWeakObjectPtr<AActor>& RiderAttackTargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoCharacter.RiderAttackTarget"); }

    UE::Math::TVector<double>& RiderAttackLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.RiderAttackLocation"); }

    unsigned __int8& TribeGroupPetRidingRankField() { return *GetNativePointerField<unsigned __int8*>(this, "APrimalDinoCharacter.TribeGroupPetRidingRank"); }

    FString& ImprinterNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.ImprinterName"); }

    FString& ImprinterPlayerUniqueNetIdField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.ImprinterPlayerUniqueNetId"); }

    float& BabyMinCuddleIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyMinCuddleInterval"); }

    float& BabyMaxCuddleIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyMaxCuddleInterval"); }

    float& BabyCuddleGracePeriodField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyCuddleGracePeriod"); }

    float& BabyCuddleLoseImpringQualityPerSecondField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyCuddleLoseImpringQualityPerSecond"); }

    float& BabyCuddleWalkDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyCuddleWalkDistance"); }

    UE::Math::TVector<double>& BabyCuddleWalkStartingLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.BabyCuddleWalkStartingLocation"); }

    long double& BabyNextCuddleTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.BabyNextCuddleTime"); }

    TSubclassOf<UPrimalItem>& BabyCuddleFoodField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.BabyCuddleFood"); }

    UAnimMontage*& BabyCuddledAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.BabyCuddledAnimation"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& MyBabyCuddleFoodTypesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.MyBabyCuddleFoodTypes"); }

    float& RiderMaxImprintingQualityDamageReductionField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderMaxImprintingQualityDamageReduction"); }

    float& RiderMaxImprintingQualityDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderMaxImprintingQualityDamageMultiplier"); }

    float& BabyImprintingQualityTotalMaturationTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyImprintingQualityTotalMaturationTime"); }

    float& WakingTameMaxDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameMaxDistance"); }

    float& TimeBetweenTamedWakingEatAnimationsField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TimeBetweenTamedWakingEatAnimations"); }

    long double& LastEatAnimationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastEatAnimationTime"); }

    float& StepDamageFootDamageRunningMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepDamageFootDamageRunningMultiplier"); }

    float& maxRangeForWeaponTriggeredTooltipField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.maxRangeForWeaponTriggeredTooltip"); }

    float& StepRadialDamageOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StepRadialDamageOffset"); }

    float& ForcePawnBigPushingForTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ForcePawnBigPushingForTime"); }

    float& WanderRadiusMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WanderRadiusMultiplier"); }

    float& HealthBarMaxDrawDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HealthBarMaxDrawDistance"); }

    float& AIDinoForceActiveUntasisingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AIDinoForceActiveUntasisingRange"); }

    float& WildRunningRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildRunningRotationRateModifier"); }

    float& TamedRunningRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedRunningRotationRateModifier"); }

    float& TamedSwimmingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedSwimmingRotationRateModifier"); }

    float& WildSwimmingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildSwimmingRotationRateModifier"); }

    TWeakObjectPtr<ANPCZoneVolume>& HardLimitWildDinoToVolumeField() { return *GetNativePointerField<TWeakObjectPtr<ANPCZoneVolume>*>(this, "APrimalDinoCharacter.HardLimitWildDinoToVolume"); }

    TWeakObjectPtr<AVolume>& WildLimitTargetVolumeField() { return *GetNativePointerField<TWeakObjectPtr<AVolume>*>(this, "APrimalDinoCharacter.WildLimitTargetVolume"); }

    float& RiderFlyingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiderFlyingRotationRateModifier"); }

    float& NoRiderFlyingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NoRiderFlyingRotationRateModifier"); }

    float& AICombatRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AICombatRotationRateModifier"); }

    float& WalkingRotationRateModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WalkingRotationRateModifier"); }

    TEnumAsByte<enum EFilterInterpolationType>& UnMountedBlendFilterSmoothTypeField() { return *GetNativePointerField<TEnumAsByte<enum EFilterInterpolationType>*>(this, "APrimalDinoCharacter.UnMountedBlendFilterSmoothType"); }

    float& SetAttackTargetTraceDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SetAttackTargetTraceDistance"); }

    float& SetAttackTargetTraceWidthField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SetAttackTargetTraceWidth"); }

    long double& RepeatPrimaryAttackLastSendTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.RepeatPrimaryAttackLastSendTime"); }

    long double& NextTamedDinoCharacterStatusTickTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.NextTamedDinoCharacterStatusTickTime"); }

    long double& LastTamedDinoCharacterStatusTickTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTamedDinoCharacterStatusTickTime"); }

    UAnimMontage*& PlayerMountedCarryAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.PlayerMountedCarryAnimation"); }

    float& HealthBarOffsetYField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HealthBarOffsetY"); }

    AMissionType*& OwnerMissionField() { return *GetNativePointerField<AMissionType**>(this, "APrimalDinoCharacter.OwnerMission"); }

    float& LimitRiderYawOnLatchedRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LimitRiderYawOnLatchedRange"); }

    float& LatchingDistanceLimitField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LatchingDistanceLimit"); }

    float& LatchingInitialYawField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LatchingInitialYaw"); }

    float& LatchingInitialPitchField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LatchingInitialPitch"); }

    float& LatchingInterpolatedPitchField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LatchingInterpolatedPitch"); }

    float& LatchedFirstPersonViewAngleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LatchedFirstPersonViewAngle"); }

    float& LatchingCameraInterpolationSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LatchingCameraInterpolationSpeed"); }

    float& TargetLatchingInitialYawField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TargetLatchingInitialYaw"); }

    float& CurrentStrafeMagnitudeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CurrentStrafeMagnitude"); }

    float& GainStaminaWhenLatchedRateField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GainStaminaWhenLatchedRate"); }

    float& AIAggroNotifyNeighborsClassesRangeScaleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AIAggroNotifyNeighborsClassesRangeScale"); }

    int& LastFrameMoveRightField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastFrameMoveRight"); }

    int& LastFrameMoveLeftField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastFrameMoveLeft"); }

    UE::Math::TRotator<double>& LastRiderMountedWeaponRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalDinoCharacter.LastRiderMountedWeaponRotation"); }

    long double& LastRiderMountedWeaponRotationSentTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastRiderMountedWeaponRotationSentTime"); }

    int& DeathGivesDossierIndexField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.DeathGivesDossierIndex"); }

    float& DeathGivesDossierDelayField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DeathGivesDossierDelay"); }

    FRotator_NetQuantizeSmartPitch& LastMovementDesiredRotation_MountedWeaponryField() { return *GetNativePointerField<FRotator_NetQuantizeSmartPitch*>(this, "APrimalDinoCharacter.LastMovementDesiredRotation_MountedWeaponry"); }

    FName& SaddleRiderMovementTraceThruSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.SaddleRiderMovementTraceThruSocketName"); }

    float& SwimmingRunSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SwimmingRunSpeedModifier"); }

    float& RidingSwimmingRunSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RidingSwimmingRunSpeedModifier"); }

    long double& DinoDownloadedAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.DinoDownloadedAtTime"); }

    FString& UploadedFromServerNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.UploadedFromServerName"); }

    FString& LatestUploadedFromServerNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.LatestUploadedFromServerName"); }

    FString& PreviousUploadedFromServerNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.PreviousUploadedFromServerName"); }

    FString& TamedOnServerNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.TamedOnServerName"); }

    TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >& DinoAncestorsField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DinoAncestors"); }

    TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >& DinoAncestorsMaleField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DinoAncestorsMale"); }

    TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >& NextBabyDinoAncestorsField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.NextBabyDinoAncestors"); }

    TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >& NextBabyDinoAncestorsMaleField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.NextBabyDinoAncestorsMale"); }

    int& MaxAllowedRandomMutationsField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxAllowedRandomMutations"); }

    int& RandomMutationRollsField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.RandomMutationRolls"); }

    float& RandomMutationChanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RandomMutationChance"); }

    float& RandomMutationGivePointsField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RandomMutationGivePoints"); }

    int& RandomMutationsMaleField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.RandomMutationsMale"); }

    int& RandomMutationsFemaleField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.RandomMutationsFemale"); }

    int& GestationEggRandomMutationsFemaleField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.GestationEggRandomMutationsFemale"); }

    int& GestationEggRandomMutationsMaleField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.GestationEggRandomMutationsMale"); }

    FName& WakingTameDistanceSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.WakingTameDistanceSocketName"); }

    int& WakingTameConsumeEntireStackMaxQuantityField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.WakingTameConsumeEntireStackMaxQuantity"); }

    float& AttackPlayerDesirabilityMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackPlayerDesirabilityMultiplier"); }

    long double& LastAutoHealingItemUseField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastAutoHealingItemUse"); }

    long double& LastStartedCarryingCharacterTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastStartedCarryingCharacterTime"); }

    float& FlyerAttachedExplosiveSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FlyerAttachedExplosiveSpeedMultiplier"); }

    TArray<FDinoExtraDefaultItemList, TSizedDefaultAllocator<32> >& DinoExtraDefaultInventoryItemsField() { return *GetNativePointerField<TArray<FDinoExtraDefaultItemList, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DinoExtraDefaultInventoryItems"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& DeathGiveEngramClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DeathGiveEngramClasses"); }

    float& SinglePlayerOutgoingDamageModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SinglePlayerOutgoingDamageModifier"); }

    float& SinglePlayerIncomingDamageModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SinglePlayerIncomingDamageModifier"); }

    int& LastTickDelayFrameCountField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastTickDelayFrameCount"); }

    long double& NextTickDelayAllowTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.NextTickDelayAllowTime"); }

    float& TickStatusTimeAccumulationField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TickStatusTimeAccumulation"); }

    long double& LastServerTamedTickField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastServerTamedTick"); }

    int& LastTempDampenMovementInputAccelerationFrameField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastTempDampenMovementInputAccelerationFrame"); }

    UAnimMontage*& DinoLevelUpAnimationOverrideField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.DinoLevelUpAnimationOverride"); }

    TArray<TSubclassOf<AActor>, TSizedDefaultAllocator<32> >& DamageVictimClassesIgnoreBlockingGeomtryTraceField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.DamageVictimClassesIgnoreBlockingGeomtryTrace"); }

    long double& LastVacuumSpaceCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastVacuumSpaceCheckTime"); }

    long double& LastGrappledTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastGrappledTime"); }

    float& CloneBaseElementCostField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CloneBaseElementCost"); }

    float& CloneElementCostPerLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CloneElementCostPerLevel"); }

    int& LastValidTameVersionField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastValidTameVersion"); }

    int& SavedLastValidTameVersionField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.SavedLastValidTameVersion"); }

    FName& NonDedicatedFreezeDinoPhysicsIfLayerUnloadedField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.NonDedicatedFreezeDinoPhysicsIfLayerUnloaded"); }

    UE::Math::TVector<double>& UnboardLocationTraceOffsetField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.UnboardLocationTraceOffset"); }

    FName& AttackLineOfSightMeshSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.AttackLineOfSightMeshSocketName"); }

    float& AttackForceWalkDistanceMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackForceWalkDistanceMultiplier"); }

    float& AttackForceWalkRotationRateMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackForceWalkRotationRateMultiplier"); }

    int& OverrideDinoTameSoundIndexField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.OverrideDinoTameSoundIndex"); }

    USoundBase*& SwimSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalDinoCharacter.SwimSound"); }

    float& SwimSoundIntervalPerHundredSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SwimSoundIntervalPerHundredSpeed"); }

    float& SwimSoundTimeCacheField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.SwimSoundTimeCache"); }

    TSubclassOf<AController>& TamedAIControllerOverrideField() { return *GetNativePointerField<TSubclassOf<AController>*>(this, "APrimalDinoCharacter.TamedAIControllerOverride"); }

    int& PersonalTamedDinoCostField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.PersonalTamedDinoCost"); }

    long double& UploadEarliestValidTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.UploadEarliestValidTime"); }

    float& StasisAutoDestroyIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.StasisAutoDestroyInterval"); }

    float& CarryCameraYawOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CarryCameraYawOffset"); }

    float& ExtraDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraDamageMultiplier"); }

    float& ExtraTamedBaseHealthMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraTamedBaseHealthMultiplier"); }

    float& AttackRangeOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AttackRangeOffset"); }

    float& DinoExtraIncreasePlayerCollisionActivationDistanceSquaredField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DinoExtraIncreasePlayerCollisionActivationDistanceSquared"); }

    float& OverrideApproachRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OverrideApproachRadius"); }

    float& TamedOverrideStasisComponentRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedOverrideStasisComponentRadius"); }

    UStaticMesh*& UniqueDino_MapMarkerMeshField() { return *GetNativePointerField<UStaticMesh**>(this, "APrimalDinoCharacter.UniqueDino_MapMarkerMesh"); }

    FColor& UniqueDino_MapMarkerColorField() { return *GetNativePointerField<FColor*>(this, "APrimalDinoCharacter.UniqueDino_MapMarkerColor"); }

    float& OverrideDinoMaxExperiencePointsField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OverrideDinoMaxExperiencePoints"); }

    int& MaxDinoTameLevelsField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxDinoTameLevels"); }

    int& DestroyTamesOverLevelClampOffsetField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.DestroyTamesOverLevelClampOffset"); }

    float& NursingTroughFoodEffectivenessMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NursingTroughFoodEffectivenessMultiplier"); }

    TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >& ForceAllowFoodAsConsumableListField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.ForceAllowFoodAsConsumableList"); }

    int& CustomReplicatedDataField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.CustomReplicatedData"); }

    FNotifySetRider& OnNotifySetRiderField() { return *GetNativePointerField<FNotifySetRider*>(this, "APrimalDinoCharacter.OnNotifySetRider"); }

    FNotifyClearRider& OnNotifyClearRiderField() { return *GetNativePointerField<FNotifyClearRider*>(this, "APrimalDinoCharacter.OnNotifyClearRider"); }

    FOnSetMountedDino& OnSetMountedDinoField() { return *GetNativePointerField<FOnSetMountedDino*>(this, "APrimalDinoCharacter.OnSetMountedDino"); }

    FOnClearMountedDino& OnClearMountedDinoField() { return *GetNativePointerField<FOnClearMountedDino*>(this, "APrimalDinoCharacter.OnClearMountedDino"); }

    FNotifyAddPassenger& OnNotifyAddPassengerField() { return *GetNativePointerField<FNotifyAddPassenger*>(this, "APrimalDinoCharacter.OnNotifyAddPassenger"); }

    FNotifyClearPassenger& OnNotifyClearPassengerField() { return *GetNativePointerField<FNotifyClearPassenger*>(this, "APrimalDinoCharacter.OnNotifyClearPassenger"); }

    long double& NextAllowedBedUseTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.NextAllowedBedUseTime"); }

    float& UseBedCooldownTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.UseBedCooldownTime"); }

    float& CarriedAsBabyPassengerSizeLimitOverrideField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CarriedAsBabyPassengerSizeLimitOverride"); }

    float& MutagenBaseCostField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MutagenBaseCost"); }

    int& PaintTextureResolutionField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.PaintTextureResolution"); }

    FLinearColor& PaintingAllowedUVRangesField() { return *GetNativePointerField<FLinearColor*>(this, "APrimalDinoCharacter.PaintingAllowedUVRanges"); }

    FTimerHandle& InternalRemoveDinoFromTamingArrayHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.InternalRemoveDinoFromTamingArrayHandle"); }

    FNotifyFlyerLanded& OnFlyerStartLandingField() { return *GetNativePointerField<FNotifyFlyerLanded*>(this, "APrimalDinoCharacter.OnFlyerStartLanding"); }

    FNotifyFlyerLanded& OnFlyerLandedField() { return *GetNativePointerField<FNotifyFlyerLanded*>(this, "APrimalDinoCharacter.OnFlyerLanded"); }

    FNotifyFlyerLanded& OnFlyerLandingInterruptedField() { return *GetNativePointerField<FNotifyFlyerLanded*>(this, "APrimalDinoCharacter.OnFlyerLandingInterrupted"); }

    bool& bHasPlayerControllerField() { return *GetNativePointerField<bool*>(this, "APrimalDinoCharacter.bHasPlayerController"); }

    UStaticMeshComponent*& CopyDinoSettingsRangeMeshField() { return *GetNativePointerField<UStaticMeshComponent**>(this, "APrimalDinoCharacter.CopyDinoSettingsRangeMesh"); }

    float& MPLandingAfterLeavingTimerField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MPLandingAfterLeavingTimer"); }

    FTimerHandle& DeferredDestroyHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.DeferredDestroyHandle"); }

    long double& TimeOfNextMateBoostUpdateField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.TimeOfNextMateBoostUpdate"); }

    UPrimalInventoryComponent*& SecondaryInventoryComponentField() { return *GetNativePointerField<UPrimalInventoryComponent**>(this, "APrimalDinoCharacter.SecondaryInventoryComponent"); }

    bool& bDisabledFromAscensionField() { return *GetNativePointerField<bool*>(this, "APrimalDinoCharacter.bDisabledFromAscension"); }

    float& RiddenStasisRangeMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RiddenStasisRangeMultiplier"); }

    AActor*& WildFollowingParentRefField() { return *GetNativePointerField<AActor**>(this, "APrimalDinoCharacter.WildFollowingParentRef"); }

    TArray<AActor*, TSizedDefaultAllocator<32> >& WildFollowerRefsField() { return *GetNativePointerField<TArray<AActor*, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.WildFollowerRefs"); }

    TArray<FWildFollowerSpawnEntry, TSizedDefaultAllocator<32> >& OverwrittenWildFollowingDinoInfosField() { return *GetNativePointerField<TArray<FWildFollowerSpawnEntry, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.OverwrittenWildFollowingDinoInfos"); }

    float& ForcedWildBabyAgeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ForcedWildBabyAge"); }

    FTimerHandle& ServerCheckIfWildDinoChildCanBeImprintedHandleField() { return *GetNativePointerField<FTimerHandle*>(this, "APrimalDinoCharacter.ServerCheckIfWildDinoChildCanBeImprintedHandle"); }

    UE::Math::TVector<double>& DinoLimbWallAvoidanceLastLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.DinoLimbWallAvoidanceLastLocation"); }

    UE::Math::TRotator<double>& DinoLimbWallAvoidanceLastRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalDinoCharacter.DinoLimbWallAvoidanceLastRotation"); }

    UE::Math::TRotator<double>& DinoLimbWallAvoidanceLastAimRotationField() { return *GetNativePointerField<UE::Math::TRotator<double>*>(this, "APrimalDinoCharacter.DinoLimbWallAvoidanceLastAimRotation"); }

    UPrimalNavigationInvokerComponent*& NavigationInvokerComponentField() { return *GetNativePointerField<UPrimalNavigationInvokerComponent**>(this, "APrimalDinoCharacter.NavigationInvokerComponent"); }

    float& DieIfLeftWaterSpawnCapsuleDepthMultiField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DieIfLeftWaterSpawnCapsuleDepthMulti"); }

    FName& RestrictNonAlliedCarriedPlayerYawSocketField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.RestrictNonAlliedCarriedPlayerYawSocket"); }

    TObjectPtr<UTexture2D>& RideIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.RideIcon"); }

    TObjectPtr<UTexture2D>& DriveIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DriveIcon"); }

    TObjectPtr<UTexture2D>& EquipSaddleToRideIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EquipSaddleToRideIcon"); }

    TObjectPtr<UTexture2D>& PassangerSeatsGenericIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.PassangerSeatsGenericIcon"); }

    TObjectPtr<UTexture2D>& EnablePublicSeatingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnablePublicSeatingIcon"); }

    TObjectPtr<UTexture2D>& DisablePublicSeatingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisablePublicSeatingIcon"); }

    TObjectPtr<UTexture2D>& FlyingMountsDisabledIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FlyingMountsDisabledIcon"); }

    TObjectPtr<UTexture2D>& RequiresEngramToMountIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.RequiresEngramToMountIcon"); }

    TObjectPtr<UTexture2D>& OptionsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.OptionsIcon"); }

    TObjectPtr<UTexture2D>& BehaviourIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.BehaviourIcon"); }

    TObjectPtr<UTexture2D>& PickUpIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.PickUpIcon"); }

    TObjectPtr<UTexture2D>& NeuterIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.NeuterIcon"); }

    TObjectPtr<UTexture2D>& ExportIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.ExportIcon"); }

    TObjectPtr<UTexture2D>& AllowSpecialAttacksIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.AllowSpecialAttacksIcon"); }

    TObjectPtr<UTexture2D>& DisableSpecialAttacksIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableSpecialAttacksIcon"); }

    TObjectPtr<UTexture2D>& EnableTurretModeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableTurretModeIcon"); }

    TObjectPtr<UTexture2D>& DisableTurretModeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableTurretModeIcon"); }

    TObjectPtr<UTexture2D>& HideBoneIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.HideBoneIcon"); }

    TObjectPtr<UTexture2D>& UnhideBoneIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.UnhideBoneIcon"); }

    TObjectPtr<UTexture2D>& RepairIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.RepairIcon"); }

    TObjectPtr<UTexture2D>& CantRepairIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.CantRepairIcon"); }

    TObjectPtr<UTexture2D>& RenameIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.RenameIcon"); }

    TObjectPtr<UTexture2D>& DemolishIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DemolishIcon"); }

    TObjectPtr<UTexture2D>& ImprintOnIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.ImprintOnIcon"); }

    TObjectPtr<UTexture2D>& WantsToCuddleIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.WantsToCuddleIcon"); }

    TObjectPtr<UTexture2D>& WantsToGoOnAWalkIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.WantsToGoOnAWalkIcon"); }

    TObjectPtr<UTexture2D>& WantsCareIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.WantsCareIcon"); }

    TObjectPtr<UTexture2D>& FeedToComfortIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FeedToComfortIcon"); }

    TObjectPtr<UTexture2D>& FeedToTameIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FeedToTameIcon"); }

    TObjectPtr<UTexture2D>& PutItemInLastSlotToTameIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.PutItemInLastSlotToTameIcon"); }

    TObjectPtr<UTexture2D>& PutTamingFoodInLastSlotToTameIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.PutTamingFoodInLastSlotToTameIcon"); }

    TObjectPtr<UTexture2D>& DoesNotWantToBeTamedIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DoesNotWantToBeTamedIcon"); }

    TObjectPtr<UTexture2D>& NeedLevelToFeedIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.NeedLevelToFeedIcon"); }

    TObjectPtr<UTexture2D>& WaitUntilHungryIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.WaitUntilHungryIcon"); }

    TObjectPtr<UTexture2D>& ClaimIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.ClaimIcon"); }

    TObjectPtr<UTexture2D>& UnclaimIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.UnclaimIcon"); }

    TObjectPtr<UTexture2D>& HarvestSettingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.HarvestSettingIcon"); }

    TObjectPtr<UTexture2D>& DisableResourceHarvestingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableResourceHarvestingIcon"); }

    TObjectPtr<UTexture2D>& EnableResourceHarvestingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableResourceHarvestingIcon"); }

    TObjectPtr<UTexture2D>& DisableVictimItemCollectionIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableVictimItemCollectionIcon"); }

    TObjectPtr<UTexture2D>& EnableVictimItemCollectionIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableVictimItemCollectionIcon"); }

    TObjectPtr<UTexture2D>& OrderGroupSettingsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.OrderGroupSettingsIcon"); }

    TObjectPtr<UTexture2D>& AddTameToGroupIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.AddTameToGroupIcon"); }

    TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >& AddTameToGroupSelectionIconsField() { return *GetNativePointerField<TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.AddTameToGroupSelectionIcons"); }

    TObjectPtr<UTexture2D>& RemoveTameFromGroupsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.RemoveTameFromGroupsIcon"); }

    TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >& RemoveTameFromGroupSelectionIconsField() { return *GetNativePointerField<TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.RemoveTameFromGroupSelectionIcons"); }

    TObjectPtr<UTexture2D>& AddClassToGroupIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.AddClassToGroupIcon"); }

    TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >& AddClassToGroupSelectionIconsField() { return *GetNativePointerField<TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.AddClassToGroupSelectionIcons"); }

    TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >& RemoveClassFromGroupSelectionIconsField() { return *GetNativePointerField<TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.RemoveClassFromGroupSelectionIcons"); }

    TObjectPtr<UTexture2D>& StanceIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.StanceIcon"); }

    TObjectPtr<UTexture2D>& StancePassiveFleeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.StancePassiveFleeIcon"); }

    TObjectPtr<UTexture2D>& StancePassiveIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.StancePassiveIcon"); }

    TObjectPtr<UTexture2D>& StanceNeutralIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.StanceNeutralIcon"); }

    TObjectPtr<UTexture2D>& StanceAggressiveIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.StanceAggressiveIcon"); }

    TObjectPtr<UTexture2D>& StanceAttackTargetIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.StanceAttackTargetIcon"); }

    TObjectPtr<UTexture2D>& DisableAllyLookingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableAllyLookingIcon"); }

    TObjectPtr<UTexture2D>& EnableAllyLookingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableAllyLookingIcon"); }

    TObjectPtr<UTexture2D>& EnableIgnoreGroupWhistlesIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableIgnoreGroupWhistlesIcon"); }

    TObjectPtr<UTexture2D>& DisableIgnoreGroupWhistlesIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableIgnoreGroupWhistlesIcon"); }

    TObjectPtr<UTexture2D>& EnableMatingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableMatingIcon"); }

    TObjectPtr<UTexture2D>& DisableMatingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableMatingIcon"); }

    TObjectPtr<UTexture2D>& EnableWanderingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableWanderingIcon"); }

    TObjectPtr<UTexture2D>& DisableWanderingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableWanderingIcon"); }

    TObjectPtr<UTexture2D>& EnableFollowingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableFollowingIcon"); }

    TObjectPtr<UTexture2D>& DisableFollowingIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableFollowingIcon"); }

    TObjectPtr<UTexture2D>& ChangeFollowDistanceIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.ChangeFollowDistanceIcon"); }

    TObjectPtr<UTexture2D>& FollowDistanceLowestIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FollowDistanceLowestIcon"); }

    TObjectPtr<UTexture2D>& FollowDistanceLowIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FollowDistanceLowIcon"); }

    TObjectPtr<UTexture2D>& FollowDistanceMediumIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FollowDistanceMediumIcon"); }

    TObjectPtr<UTexture2D>& FollowDistanceHighIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FollowDistanceHighIcon"); }

    TObjectPtr<UTexture2D>& FollowDistanceHighestIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.FollowDistanceHighestIcon"); }

    TObjectPtr<UTexture2D>& ShowCopySettingsVisualIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.ShowCopySettingsVisualIcon"); }

    TObjectPtr<UTexture2D>& HideCopySettingsVisualIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.HideCopySettingsVisualIcon"); }

    TObjectPtr<UTexture2D>& CopySettingsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.CopySettingsIcon"); }

    TObjectPtr<UTexture2D>& CopySettingsInRangeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.CopySettingsInRangeIcon"); }

    TObjectPtr<UTexture2D>& CopySettingsInRangeWithPinCodeIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.CopySettingsInRangeWithPinCodeIcon"); }

    TObjectPtr<UTexture2D>& TargetingOptionsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TargetingOptionsIcon"); }

    TObjectPtr<UTexture2D>& TargetingRangeLowestIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TargetingRangeLowestIcon"); }

    TObjectPtr<UTexture2D>& TargetingRangeLowIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TargetingRangeLowIcon"); }

    TObjectPtr<UTexture2D>& TargetingRangeMediumIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TargetingRangeMediumIcon"); }

    TObjectPtr<UTexture2D>& TargetingRangeHighIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TargetingRangeHighIcon"); }

    TObjectPtr<UTexture2D>& TargetingRangeHighestIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TargetingRangeHighestIcon"); }

    TObjectPtr<UTexture2D>& EnableOnlyTargetConsciousIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.EnableOnlyTargetConsciousIcon"); }

    TObjectPtr<UTexture2D>& DisableOnlyTargetConsciousIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.DisableOnlyTargetConsciousIcon"); }

    TObjectPtr<UTexture2D>& TribeRankSettingsIconField() { return *GetNativePointerField<TObjectPtr<UTexture2D>*>(this, "APrimalDinoCharacter.TribeRankSettingsIcon"); }

    TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >& TribeOrderRankSelectionIconsField() { return *GetNativePointerField<TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.TribeOrderRankSelectionIcons"); }

    TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >& TribeRidingRankSelectionIconsField() { return *GetNativePointerField<TArray<TObjectPtr<UTexture2D>, TSizedDefaultAllocator<32> >*>(this, "APrimalDinoCharacter.TribeRidingRankSelectionIcons"); }

    float& PathfollowingMaxSpeedModiferField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PathfollowingMaxSpeedModifer"); }

    UE::Math::TVector<double>& SpawnedLocationField() { return *GetNativePointerField<UE::Math::TVector<double>*>(this, "APrimalDinoCharacter.SpawnedLocation"); }

    long double& LastWantsToEnableNavRelevancyField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastWantsToEnableNavRelevancy"); }

    float& DinoArmorDurabilityScalingMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DinoArmorDurabilityScalingMultiplier"); }

    unsigned __int8& TamedAITargetingRangeField() { return *GetNativePointerField<unsigned __int8*>(this, "APrimalDinoCharacter.TamedAITargetingRange"); }


    // Bitfields


    BitFieldValue<bool, unsigned __int32> bAttackStopsMovement() { return { this, "APrimalDinoCharacter.bAttackStopsMovement" }; }

    BitFieldValue<bool, unsigned __int32> bLocationBasedAttack() { return { this, "APrimalDinoCharacter.bLocationBasedAttack" }; }

    BitFieldValue<bool, unsigned __int32> bTamedWanderHarvestAllowUsableHarvestingAsWell() { return { this, "APrimalDinoCharacter.bTamedWanderHarvestAllowUsableHarvestingAsWell" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPKilledSomethingEvent() { return { this, "APrimalDinoCharacter.bUseBPKilledSomethingEvent" }; }

    BitFieldValue<bool, unsigned __int32> bPreventDinoResetAffinityOnUnsleep() { return { this, "APrimalDinoCharacter.bPreventDinoResetAffinityOnUnsleep" }; }

    BitFieldValue<bool, unsigned __int32> bKeepInventoryForWakingTame() { return { this, "APrimalDinoCharacter.bKeepInventoryForWakingTame" }; }

    BitFieldValue<bool, unsigned __int32> bForceReachedDestination() { return { this, "APrimalDinoCharacter.bForceReachedDestination" }; }

    BitFieldValue<bool, unsigned __int32> bHadLinkedSupplyCrate() { return { this, "APrimalDinoCharacter.bHadLinkedSupplyCrate" }; }

    BitFieldValue<bool, unsigned __int32> bRemovingStructuresOnDeath() { return { this, "APrimalDinoCharacter.bRemovingStructuresOnDeath" }; }

    BitFieldValue<bool, unsigned __int32> bResetUseAccelerationForRequestedMove() { return { this, "APrimalDinoCharacter.bResetUseAccelerationForRequestedMove" }; }

    BitFieldValue<bool, unsigned __int32> bHiddenForLocalPassenger() { return { this, "APrimalDinoCharacter.bHiddenForLocalPassenger" }; }

    BitFieldValue<bool, unsigned __int32> bRunCheckCarriedTrace() { return { this, "APrimalDinoCharacter.bRunCheckCarriedTrace" }; }

    BitFieldValue<bool, unsigned __int32> CanElevate() { return { this, "APrimalDinoCharacter.CanElevate" }; }

    BitFieldValue<bool, unsigned __int32> bIsElevating() { return { this, "APrimalDinoCharacter.bIsElevating" }; }

    BitFieldValue<bool, unsigned __int32> bIsBraking() { return { this, "APrimalDinoCharacter.bIsBraking" }; }

    BitFieldValue<bool, unsigned __int32> MovingForward() { return { this, "APrimalDinoCharacter.MovingForward" }; }

    BitFieldValue<bool, unsigned __int32> bTamedWanderCorpseHarvesting() { return { this, "APrimalDinoCharacter.bTamedWanderCorpseHarvesting" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPNotifyStructurePlacedNearby() { return { this, "APrimalDinoCharacter.bUseBPNotifyStructurePlacedNearby" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPCanTargetCorpse() { return { this, "APrimalDinoCharacter.bUseBPCanTargetCorpse" }; }

    BitFieldValue<bool, unsigned __int32> bUseBPShouldForceFlee() { return { this, "APrimalDinoCharacter.bUseBPShouldForceFlee" }; }

    BitFieldValue<bool, unsigned __int32> bReceivedDinoAncestors() { return { this, "APrimalDinoCharacter.bReceivedDinoAncestors" }; }

    BitFieldValue<bool, unsigned __int32> bForceWanderOverrideNPCZoneManager() { return { this, "APrimalDinoCharacter.bForceWanderOverrideNPCZoneManager" }; }

    BitFieldValue<bool, unsigned __int32> bDeprecateDino() { return { this, "APrimalDinoCharacter.bDeprecateDino" }; }

    BitFieldValue<bool, unsigned __int32> bForceFoodItemAutoConsume() { return { this, "APrimalDinoCharacter.bForceFoodItemAutoConsume" }; }

    BitFieldValue<bool, unsigned __int32> bFlyerAllowFlyingWithExplosive() { return { this, "APrimalDinoCharacter.bFlyerAllowFlyingWithExplosive" }; }

    BitFieldValue<bool, unsigned __int32> bForceUseDediAttackTiming() { return { this, "APrimalDinoCharacter.bForceUseDediAttackTiming" }; }

    BitFieldValue<bool, unsigned __int32> bForcePreventExitingWater() { return { this, "APrimalDinoCharacter.bForcePreventExitingWater" }; }

    BitFieldValue<bool, unsigned __int32> bWakingTameConsumeEntireStack() { return { this, "APrimalDinoCharacter.bWakingTameConsumeEntireStack" }; }